v0.6.1: connect serve — config-driven multi-service expose

New command: `connect serve` reads the `expose:` block from pconnect.yml
and exposes multiple local services with one command. One config file,
one command, multiple tunnels — for webhooks, demos, and APIs.

- Extended pconnect.yml config format with `expose:` section
- New `connect serve` command (expose-side counterpart to `connect dev`)
- Updated YAML/JSON parser to handle expose block
- Docs: config-driven-expose-webhooks-demos.md
- Updated README, DETAILED.md with serve references

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: dantelex

DETAILED.md

@@ -216,6 +216,7 @@ connect delete <service>      # Delete a service
 connect proxy                 # Subdomain proxy (my-api.localhost:3000)
 connect daemon <action>       # Background daemon (install|status|logs)
 connect dev                   # Project dev mode (pconnect.yml)
+connect serve                 # Expose all services from pconnect.yml
 connect dns <action>          # Local DNS (*.connect domains)
 connect mcp <action>          # AI assistant integration
 connect broker <action>       # Agent Permission Broker
@@ -396,6 +397,37 @@ connect dev --init  # Create config
 connect dev         # Connect all services
 ```
 
+### Config-driven Expose (`connect serve`)
+
+Add an `expose` block to your `pconnect.yml` to expose multiple local services with one command:
+
+```yaml
+# pconnect.yml
+services:
+  - name: staging-db
+    port: 5432
+
+expose:
+  web:
+    target: localhost:3000
+    public: true
+  api:
+    target: localhost:8000
+  webhooks:
+    target: localhost:3000
+    public: true
+```
+
+Then:
+
+```bash
+connect serve       # Expose all entries under expose:
+```
+
+Each entry becomes a named service in the hub. Set `public: true` to get a public URL (for webhooks and demos). Teammates can `connect reach web` or `connect reach api` to access your services.
+
+See [docs/config-driven-expose-webhooks-demos.md](docs/config-driven-expose-webhooks-demos.md) for the full guide.
+
 ### Subdomain Proxy
 
 ```bash

README.md

@@ -49,6 +49,7 @@ npx private-connect test db.internal:5432
 | Quick tunnel (no signup) | `npx private-connect tunnel 3000` |
 | Named tunnel (webhook/demo) | `npx private-connect stripe 3000` |
 | Expose a service | `connect 5432` |
+| Expose many from config | `connect serve` |
 | Access a service | `connect prod-db` |
 | Share with a teammate | `connect 5432 --share` |
 | Clone a teammate's setup | `connect clone alice` |
@@ -147,6 +148,7 @@ curl -s -X POST http://localhost:3001/v1/ask -H "Content-Type: application/json"
 - **DB + Cursor (2 min)**: [docs/database-and-cursor.md](docs/database-and-cursor.md) — expose local DB, reach from anywhere, use with Cursor
 - **Docs**: [DETAILED.md](DETAILED.md) — full CLI reference, all features
 - **API Reference**: [DETAILED.md#control-api](DETAILED.md#control-api) — REST API documentation
+- **Config-driven expose**: [docs/config-driven-expose-webhooks-demos.md](docs/config-driven-expose-webhooks-demos.md) — expose multiple services from config (`connect serve`)
 - **Debugging**: [docs/debugging.md](docs/debugging.md) — live traffic inspection, AI copilot
 - **AI & MCP**: [docs/AI.md](docs/AI.md) — AI integration, orchestration, SDK
 - **OpenClaw**: [docs/openclaw-remote-access.md](docs/openclaw-remote-access.md) — secure remote access to OpenClaw gateway

apps/agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "private": true,
   "bin": {
     "connect": "./dist/cli.js"

apps/agent/pconnect.yml

@@ -1,8 +1,19 @@
 # Private Connect project config
-# Run: connect dev
+# Reach services:  connect dev
+# Expose services: connect serve
 
 services:
   - name: staging-db
     port: 5432
   - name: redis
     port: 6379
+
+# Expose local services (webhooks, demos, APIs)
+# Uncomment and edit, then run: connect serve
+#
+# expose:
+#   web:
+#     target: localhost:3000
+#     public: true
+#   api:
+#     target: localhost:8000

apps/agent/src/cli.ts

@@ -14,6 +14,7 @@ import { joinCommand } from './commands/join';
 import { mapCommand, mapStatusCommand } from './commands/map';
 import { daemonCommand } from './commands/daemon';
 import { devCommand, devInitCommand } from './commands/dev';
+import { serveCommand } from './commands/serve';
 import { linkCommand } from './commands/link';
 import { deleteCommand } from './commands/delete';
 import { doctorCommand, cleanupCommand, statusCommand } from './commands/doctor';
@@ -434,6 +435,18 @@ program
     }
   });
 
+// Serve Mode Commands
+program
+  .command('serve')
+  .description('Expose all services defined in the expose block of pconnect.yml')
+  .option('-H, --hub <url>', 'Hub URL', DEFAULT_HUB_URL)
+  .option('-f, --file <path>', 'Path to pconnect.yml file')
+  .option('-c, --config <path>', 'Agent config file path')
+  .action((options) => {
+    if (options.config) setConfigPath(options.config);
+    serveCommand(options);
+  });
+
 // Health & Diagnostics Commands
 program
   .command('doctor')

apps/agent/src/commands/dev.ts

@@ -13,15 +13,23 @@ interface DevOptions {
   config?: string;
 }
 
-interface ProjectService {
+export interface ProjectService {
   name: string;
   port?: number;
   localPort?: number; // alias for port
   protocol?: string;
 }
 
-interface ProjectConfig {
+export interface ExposeEntry {
+  name: string;
+  target: string;
+  public?: boolean;
+  expires?: string;
+}
+
+export interface ProjectConfig {
   services: ProjectService[];
+  expose?: ExposeEntry[];
   hub?: string;
 }
 
@@ -34,7 +42,7 @@ const CONFIG_FILENAMES = [
   '.pconnect.json',
 ];
 
-function findProjectConfig(startDir?: string): string | null {
+export function findProjectConfig(startDir?: string): string | null {
   const dir = startDir || process.cwd();
 
   for (const filename of CONFIG_FILENAMES) {
@@ -56,17 +64,28 @@ function findProjectConfig(startDir?: string): string | null {
 function parseYaml(content: string): ProjectConfig {
   // Simple YAML parser for our limited use case
   const lines = content.split('\n');
-  const config: ProjectConfig = { services: [] };
+  const config: ProjectConfig = { services: [], expose: [] };
   let currentService: ProjectService | null = null;
-  let inServices = false;
+  let currentExposeEntry: ExposeEntry | null = null;
+  let section: 'none' | 'services' | 'expose' = 'none';
 
   for (const line of lines) {
     const trimmed = line.trim();
 
     if (trimmed.startsWith('#') || trimmed === '') continue;
 
+    // Top-level section headers
     if (trimmed === 'services:') {
-      inServices = true;
+      if (currentService) { config.services.push(currentService); currentService = null; }
+      if (currentExposeEntry && currentExposeEntry.target) { config.expose!.push(currentExposeEntry); currentExposeEntry = null; }
+      section = 'services';
+      continue;
+    }
+    
+    if (trimmed === 'expose:') {
+      if (currentService) { config.services.push(currentService); currentService = null; }
+      if (currentExposeEntry && currentExposeEntry.target) { config.expose!.push(currentExposeEntry); currentExposeEntry = null; }
+      section = 'expose';
       continue;
     }
 
@@ -75,7 +94,7 @@ function parseYaml(content: string): ProjectConfig {
       continue;
     }
 
-    if (inServices) {
+    if (section === 'services') {
       // New service entry
       if (trimmed.startsWith('- name:')) {
         if (currentService) {
@@ -94,21 +113,59 @@ function parseYaml(content: string): ProjectConfig {
         }
       }
     }
+    
+    if (section === 'expose') {
+      // New expose entry: "name:" (word followed by colon, no value)
+      const entryMatch = trimmed.match(/^([a-zA-Z0-9_-]+):$/);
+      if (entryMatch) {
+        if (currentExposeEntry && currentExposeEntry.target) {
+          config.expose!.push(currentExposeEntry);
+        }
+        currentExposeEntry = { name: entryMatch[1], target: '' };
+      } else if (currentExposeEntry) {
+        // Expose entry properties
+        if (trimmed.startsWith('target:')) {
+          currentExposeEntry.target = trimmed.split(':').slice(1).join(':').trim().replace(/['"]/g, '');
+        } else if (trimmed.startsWith('public:')) {
+          const val = trimmed.split(':')[1].trim().toLowerCase();
+          currentExposeEntry.public = val === 'true';
+        } else if (trimmed.startsWith('expires:')) {
+          currentExposeEntry.expires = trimmed.split(':')[1].trim().replace(/['"]/g, '');
+        }
+      }
+    }
   }
 
+  // Flush remaining entries
   if (currentService) {
     config.services.push(currentService);
   }
+  if (currentExposeEntry && currentExposeEntry.target) {
+    config.expose!.push(currentExposeEntry);
+  }
 
   return config;
 }
 
-function loadProjectConfig(configPath: string): ProjectConfig | null {
+export function loadProjectConfig(configPath: string): ProjectConfig | null {
   try {
     const content = fs.readFileSync(configPath, 'utf-8');
 
     if (configPath.endsWith('.json')) {
-      return JSON.parse(content) as ProjectConfig;
+      const raw = JSON.parse(content);
+      const config: ProjectConfig = {
+        services: raw.services || [],
+        hub: raw.hub,
+        expose: [],
+      };
+      // Convert expose map { name: { target, public, expires } } to array
+      if (raw.expose && typeof raw.expose === 'object') {
+        for (const [name, entry] of Object.entries(raw.expose)) {
+          const e = entry as { target: string; public?: boolean; expires?: string };
+          config.expose!.push({ name, target: e.target, public: e.public, expires: e.expires });
+        }
+      }
+      return config;
     } else {
       return parseYaml(content);
     }

apps/agent/src/commands/serve.ts

@@ -0,0 +1,134 @@
+import chalk from 'chalk';
+import { loadConfig } from '../config';
+import { exposeCommand } from './expose';
+import { findProjectConfig, loadProjectConfig } from './dev';
+
+interface ServeOptions {
+  hub: string;
+  file?: string;
+  config?: string;
+}
+
+/**
+ * connect serve - Expose all services defined in the expose block of pconnect.yml
+ *
+ * Reads the `expose:` section from the project config and calls exposeCommand
+ * for each entry. One command, multiple tunnels.
+ */
+export async function serveCommand(options: ServeOptions) {
+  const agentConfig = loadConfig();
+  
+  if (!agentConfig) {
+    console.error(chalk.red('\n[x] Agent not configured'));
+    console.log(chalk.gray(`  Run ${chalk.cyan('connect up')} first to authenticate.\n`));
+    process.exit(1);
+  }
+
+  // Find project config
+  const configPath = options.file || findProjectConfig();
+  
+  if (!configPath) {
+    console.log(chalk.yellow('\n[!] No project config found.\n'));
+    console.log(chalk.gray('  Create a pconnect.yml with an expose section:\n'));
+    console.log(chalk.cyan('    expose:'));
+    console.log(chalk.cyan('      web:'));
+    console.log(chalk.cyan('        target: localhost:3000'));
+    console.log(chalk.cyan('        public: true'));
+    console.log(chalk.cyan('      api:'));
+    console.log(chalk.cyan('        target: localhost:8000'));
+    console.log();
+    process.exit(1);
+  }
+
+  const projectConfig = loadProjectConfig(configPath);
+  
+  if (!projectConfig || !projectConfig.expose || projectConfig.expose.length === 0) {
+    console.error(chalk.red('\n[x] No expose entries in config.\n'));
+    console.log(chalk.gray('  Add an expose section to your pconnect.yml:\n'));
+    console.log(chalk.cyan('    expose:'));
+    console.log(chalk.cyan('      web:'));
+    console.log(chalk.cyan('        target: localhost:3000'));
+    console.log(chalk.cyan('        public: true'));
+    console.log();
+    process.exit(1);
+  }
+
+  const hubUrl = projectConfig.hub || agentConfig.hubUrl || options.hub;
+  const entries = projectConfig.expose;
+
+  console.log(chalk.cyan('\n📡 Private Connect Serve\n'));
+  console.log(chalk.gray(`  Config:   ${configPath}`));
+  console.log(chalk.gray(`  Hub:      ${hubUrl}`));
+  console.log(chalk.gray(`  Services: ${entries.length}`));
+  console.log();
+
+  // Expose each entry
+  const results: Array<{ name: string; target: string; success: boolean; public?: boolean }> = [];
+
+  for (const entry of entries) {
+    if (!entry.target) {
+      console.log(chalk.yellow(`  [!] Skipping "${entry.name}": no target specified`));
+      results.push({ name: entry.name, target: '', success: false });
+      continue;
+    }
+
+    console.log(chalk.gray(`  ── ${entry.name} ──\n`));
+
+    try {
+      const result = await exposeCommand(entry.target, {
+        name: entry.name,
+        hub: hubUrl,
+        protocol: 'auto',
+        public: entry.public || false,
+      });
+
+      results.push({
+        name: entry.name,
+        target: entry.target,
+        success: !!result,
+        public: entry.public,
+      });
+    } catch (error) {
+      const err = error as Error;
+      console.log(chalk.red(`  [x] Failed to expose "${entry.name}": ${err.message}`));
+      results.push({ name: entry.name, target: entry.target, success: false });
+    }
+
+    console.log();
+  }
+
+  // Print summary
+  const successful = results.filter(r => r.success);
+  const failed = results.filter(r => !r.success);
+
+  console.log(chalk.cyan('─────────────────────────────────────'));
+  console.log(chalk.white('  Serve Summary\n'));
+
+  if (successful.length > 0) {
+    console.log(chalk.green(`  ✓ ${successful.length} service(s) exposed:\n`));
+    successful.forEach(r => {
+      const publicTag = r.public ? chalk.blue(' [public]') : chalk.gray(' [private]');
+      console.log(chalk.white(`    ${r.name}`) + chalk.gray(` → ${r.target}`) + publicTag);
+    });
+    console.log();
+  }
+
+  if (failed.length > 0) {
+    console.log(chalk.yellow(`  ! ${failed.length} service(s) failed:\n`));
+    failed.forEach(r => {
+      console.log(chalk.gray(`    ${r.name} → ${r.target || '(no target)'}`));
+    });
+    console.log();
+  }
+
+  if (successful.length === 0) {
+    console.error(chalk.red('  [x] No services exposed.\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.gray('  Press Ctrl+C to stop all services\n'));
+
+  // Keep process alive (WebSocket connections from exposeCommand keep the event loop active,
+  // but this ensures we don't exit even if all connections temporarily drop)
+  await new Promise(() => {});
+}