dodo-mcp 1.0.1 → 1.0.3

package/README.md

@@ -1,11 +1,11 @@
 # DODO MCP
 
-**DODO MCP 1.0.1** คือ MCP server แบบ local-first สำหรับให้ AI ช่วยพัฒนา software โดยทำงานกับ workspace ที่เจ้าของเลือก ค่าเริ่มต้นเป็นโหมดส่วนตัวแบบเพิ่มโปรเจกต์แล้วใช้ได้ทันที และยังมีโหมด managed สำหรับแยก workspace ACL/trust แบบละเอียด
+**DODO MCP 1.0.3** คือ MCP server แบบ local-first สำหรับให้ AI ช่วยพัฒนา software โดยทำงานกับ workspace ที่เจ้าของเลือก ค่าเริ่มต้นเป็นโหมดส่วนตัวแบบเพิ่มโปรเจกต์แล้วใช้ได้ทันที และยังมีโหมด managed สำหรับแยก workspace ACL/trust แบบละเอียด
 
 ## จุดเด่น
 
 - MCP ผ่าน HTTP ที่ `127.0.0.1:21730/mcp` พร้อม OAuth และ PKCE
-- Local Config แบบ loopback ที่ `127.0.0.1:21731`
+- Local Config แบบ loopback ที่ `127.0.0.1:21731` และ Remote Config ชั่วคราวผ่าน tunnel เมื่อเจ้าของสั่ง `dodo --web`
 - HTTP ใช้ Compact Tool Surface 19 tools เพื่อลดภาระการโหลด schema
 - STDIO ใช้ Full Tool Surface; มี capability definitions ทั้งหมด 125 รายการ แต่ค่าเริ่มต้นซ่อน Sub-agent 4 operations จาก MCP จึงเห็น 121 tools
 - Hybrid Surface 49 tools สำหรับ client ที่รับ catalog ขนาดกลาง
@@ -36,7 +36,8 @@ dodo --cli
 ```
 
 `dodo --cli` เปิดเมนู local owner สำหรับเลือก/เพิ่มโปรเจกต์ เปิด MCP + Local Config +
-Tunnel และรัน setup รวม `cloudflared` โดยไม่ต้อง `cd` เข้าโปรเจกต์
+Tunnel, เปิด Remote Config ชั่วคราว 1 ชั่วโมง และรัน setup รวม `cloudflared` โดยไม่ต้อง
+`cd` เข้าโปรเจกต์
 ก่อน หากเรียก `dodo` หรือ `dodo start` จากโฟลเดอร์ใดก็ตาม ระบบจะเปิดโปรเจกต์ที่
 เจ้าของเลือกล่าสุด หากยังไม่มีโปรเจกต์ใน registry จะเปิด control plane, OAuth และ
 authenticated tool catalog ได้โดยไม่ใช้ CWD เป็น workspace เมื่อเจ้าของเพิ่มโปรเจกต์
@@ -249,27 +250,55 @@ command sandbox, idempotency และ audit เดิม `agent_exec` ใช้
 
 ### เชื่อม Remote MCP ผ่าน Cloudflare Tunnel
 
-DODO ไม่สร้าง Tunnel, DNS หรือ Cloudflare account ให้ ผู้ใช้สร้าง remotely-managed Tunnel และตั้ง public hostname ให้ route **ทุก path** มาที่ `http://127.0.0.1:21730` ก่อน จากนั้นตั้ง public origin ครั้งเดียว:
+DODO เลือกวิธีเชื่อมต่อระดับ installation ได้หนึ่งแบบ: `local` หรือ `tunnel` ค่าที่เลือก
+มีผลกับทุก `dodo start` และไม่มี fallback อัตโนมัติ หากเลือก Tunnel แล้ว credential หรือ
+readiness ไม่พร้อม DODO จะหยุด startup แทนการเปิด local โดยไม่แจ้ง
+
+Local mode:
+
+```bash
+dodo tunnel configure --local
+dodo start
+```
+
+DODO Tunnel mode:
 
 ```bash
 dodo setup --check --components cloudflared
-dodo init --public-url https://mcp.example.com
+dodo tunnel configure \
+  --tunnel \
+  --public-url https://mcp.example.com \
+  --os-credential
 dodo start
-# Cloudflare Tunnel token (temporary; Enter = local only):
 ```
 
-เมื่อกรอก token DODO จะเริ่ม `cloudflared` เป็น child process ของรอบนั้นและหยุดพร้อม
-DODO Token อยู่ในหน่วยความจำระหว่างรอบและ environment ของ child เท่านั้น ไม่อยู่ใน
-argv, config, Keychain, Credential Manager, Secret Service, tunnel log, MCP response
-หรือ environment ของ MCP jobs กด Enter หรือใช้ `dodo start --no-tunnel` เพื่อเปิด
-เฉพาะ local MCP
+เจ้าของสร้าง remotely-managed Tunnel, public hostname และ DNS ใน Cloudflare และ route
+**ทุก path** มาที่ `http://127.0.0.1:21730` DODO ไม่จัดการ Cloudflare account/DNS
+Token ถูกบันทึกใน macOS Keychain, Windows Credential Manager หรือ Linux Secret Service;
+global config เก็บเพียง opaque reference ทุกครั้งที่เปิด DODO ระบบจะเริ่ม
+`cloudflared` เป็น child และหยุด child พร้อม DODO Token ไม่อยู่ใน argv, config, log,
+audit, browser storage, MCP response หรือ environment ของ MCP jobs
+
+หากต้องตั้งค่าจากอุปกรณ์อื่น ให้เปิดหน้าเจ้าของแบบชั่วคราวผ่าน public listener เดียวกัน:
+
+```bash
+dodo --web          # เริ่ม DODO/Tunnel หรือเปิด lease ใหม่ให้ process ที่รันอยู่
+dodo web --status   # ดูสถานะแบบไม่มี secret
+dodo web --close    # ปิดหน้า Remote Config แต่ MCP/Tunnel ยังทำงาน
+```
+
+คำสั่งจะแสดง `https://mcp.example.com/config` กับ pairing code แบบใช้ครั้งเดียวใน
+terminal หลังจับคู่ browser จะใช้ cookie ที่เป็น `Secure`, `HttpOnly`,
+`SameSite=Strict` และจำกัด path ที่ `/config` หน้า Remote Config ปิดอัตโนมัติภายใน
+1 ชั่วโมง การเปิดใหม่ออก code/session ใหม่และไม่ต้อง restart MCP ไม่มี token หรือ
+credential อยู่ใน URL คำสั่งนี้ใช้ได้เฉพาะเมื่อ persistent mode เป็น `tunnel` และ
+DODO-owned Tunnel กำลังทำงาน; มันไม่รับ token ใหม่ผ่าน IPC และไม่เปลี่ยนจาก Local เอง
 
-หน้า Local Config ที่ `127.0.0.1:21731` มีช่อง **Temporary Tunnel token** สำหรับเริ่ม
-และหยุด tunnel ของ DODO process ปัจจุบันได้จริง ช่องจะถูกล้างหลังส่งและ backend ไม่
-persist ค่า ดูสถานะด้วย `dodo tunnel status`, ตรวจ connectivity ด้วย
-`dodo tunnel doctor` และดู log ที่ redacted ด้วย `dodo tunnel logs` คำสั่ง
-`dodo tunnel configure` เดิมยังมีสำหรับ advanced/headless compatibility และต้องเรียก
-โดยเจ้าของอย่างชัดเจน; เส้นทาง `dodo start` และหน้าเว็บไม่ใช้ credential store
+หน้า Local Config ที่ `127.0.0.1:21731` เลือก Local/Tunnel, ตั้ง public origin และบันทึก
+token แบบ write-only เข้า OS credential store ได้ ค่าใหม่มีผลหลัง restart หน้าเว็บแสดง
+Active MCP URL จาก runtime จริงและไม่กล่าวว่า Tunnel หรือ AI client เชื่อมแล้วหากไม่มี
+หลักฐาน ดูสถานะด้วย `dodo tunnel status`, ตรวจ connectivity ด้วย `dodo tunnel doctor`
+และดู log ที่ redacted ด้วย `dodo tunnel logs`
 
 บน macOS `dodo setup --yes` เลือก component `cloudflared` อยู่ในชุด `all` แล้ว
 Tunnel route ต้องชี้เฉพาะ MCP/OAuth listener `21730` ห้ามชี้ Local Config `21731`
@@ -326,7 +355,8 @@ dodo_read(operation="read_files", args={...})
 
 - **Local MCP:** `http://127.0.0.1:21730/mcp` สำหรับ process ในเครื่อง
 - **Public MCP:** origin HTTPS ของ tunnel ที่เจ้าของสร้างและกำหนด route เอง; DODO อาจ supervise เฉพาะ `cloudflared` process ที่เจ้าของสั่ง
-- **Local Config:** loopback เท่านั้น ใช้ owner capability token และ Host/Origin checks
+- **Local Config:** `127.0.0.1:21731` เท่านั้น ใช้ owner capability token และ Host/Origin checks
+- **Remote Config:** ปิดเป็น 404 โดยค่าเริ่มต้น; เจ้าของเปิด `/config` บน public origin ได้ครั้งละไม่เกิน 1 ชั่วโมงด้วย `dodo --web`
 
 DODO รายงาน `connected` เฉพาะเมื่อ managed `cloudflared` ตอบ readiness จริง และ `doctor` แยก local/public health ออกจากกัน สถานะนี้ไม่ใช่หลักฐานว่า ChatGPT หรือ AI client เชื่อมต่อแล้ว
 
@@ -354,7 +384,7 @@ dodo desktop allow --app com.google.Chrome --mode control --persist --yes
 ## ความปลอดภัย
 
 - public MCP ใช้ OAuth เสมอ ไม่มี NoAuth fallback
-- Local Config bind loopback และมี capability token, expiration, Host/Origin checks และ rate limit
+- Local Config bind loopback และมี capability token, expiration, Host/Origin checks และ rate limit; Remote Config ต้องจับคู่ด้วย code ใช้ครั้งเดียวและหมดอายุภายใน 1 ชั่วโมง
 - client secret/access token ไม่แสดงใน UI หรือ audit
 - path traversal, symlink/hardlink, secret paths และ stale hashes ถูกปฏิเสธ
 - command environment ใช้ allowlist และไม่ส่ง local auth state ให้ child process

package/dist/cli/main.js

@@ -142,13 +142,23 @@ async function launchHttp(opts) {
     const configDir = resolveConfigDir(process.env).dir;
     const configFile = statePaths(configDir).configFile;
     const config = loadGlobalConfig(configFile);
-    const publicUrl = opts.publicUrl ?? config.publicUrl;
-    let temporaryTunnelToken;
-    const interactiveTerminal = process.stdin.isTTY === true && process.stdout.isTTY === true;
-    if (opts.tunnel !== false && config.tunnel.startWithDodo && publicUrl && interactiveTerminal) {
-        const { readTemporaryTunnelToken } = await import('../tunnel/credentials.js');
-        temporaryTunnelToken = await readTemporaryTunnelToken();
+    const connectionMode = config.tunnel.connectionMode;
+    const publicUrl = config.publicUrl;
+    const selectedPort = opts.port ?? config.port;
+    if (connectionMode === 'tunnel') {
+        if (!publicUrl)
+            fail('Tunnel mode requires a public HTTPS origin; run dodo tunnel configure --tunnel --os-credential --public-url https://your-host');
+        validatePublicUrl(publicUrl, false);
+        if (!config.tunnel.credentialRef)
+            fail('Tunnel mode requires a saved credential; run dodo tunnel configure --tunnel --os-credential --public-url https://your-host');
+    }
+    else {
+        if (opts.web)
+            fail('Remote Config requires Tunnel mode; configure Tunnel, restart DODO, then run dodo --web');
+        if (selectedPort === 0)
+            fail('local connection mode requires a concrete MCP port');
     }
+    const endpointOrigin = connectionMode === 'tunnel' ? publicUrl : `http://127.0.0.1:${selectedPort}`;
     const startOpts = {
         configPort: config.configPort,
         ...(opts.bypass ? { runMode: 'bypass' } : opts.allow ? { runMode: 'allow-all' } : {}),
@@ -157,11 +167,11 @@ async function launchHttp(opts) {
         allowUnsafeRoot: opts.allowUnsafeRoot ?? false,
         quiet: opts.quiet ?? false,
         onLog: (line) => console.log(formatTerminalLine(line)),
+        connectionMode,
+        publicUrlOverride: endpointOrigin,
     };
     if (opts.port !== undefined && !Number.isNaN(opts.port))
         startOpts.portOverride = opts.port;
-    if (opts.publicUrl !== undefined)
-        startOpts.publicUrlOverride = opts.publicUrl;
     if (opts.tools !== undefined)
         startOpts.toolSurface = opts.tools;
     const tunnelRuntime = new TunnelRuntime(configDir, line => console.log(`[dodo:tunnel] ${line}`));
@@ -175,32 +185,26 @@ async function launchHttp(opts) {
                 void stop('server stop');
         },
     });
-    if (temporaryTunnelToken) {
+    if (connectionMode === 'tunnel') {
         try {
-            const transientConfig = GlobalConfigSchema.parse({
+            const selectedConfig = GlobalConfigSchema.parse({
                 ...config,
                 ...(publicUrl ? { publicUrl } : {}),
-                tunnel: { ...config.tunnel, mode: 'managed' },
+                tunnel: { ...config.tunnel, connectionMode: 'tunnel' },
             });
-            const status = await tunnelRuntime.start(transientConfig, temporaryTunnelToken);
-            console.log(`[dodo] Cloudflare Tunnel attached for this run: ${status.publicOrigin}/mcp`);
+            const status = await tunnelRuntime.start(selectedConfig);
+            console.log(`[dodo] DODO Tunnel started: ${status.publicOrigin}/mcp`);
+            if (opts.web)
+                printRemoteConfig(await ipcForInstallation('remoteConfig.open'));
         }
         catch (error) {
             suppressOnStopped = true;
             await server.close();
             throw error;
         }
-        finally {
-            temporaryTunnelToken = undefined;
-        }
     }
-    else if (!opts.quiet && opts.tunnel !== false && config.tunnel.startWithDodo) {
-        if (!publicUrl)
-            console.log('[dodo] Tunnel skipped: configure the public HTTPS origin, then restart DODO.');
-        else if (!interactiveTerminal)
-            console.log('[dodo] Tunnel skipped: temporary token entry requires an interactive terminal.');
-        else
-            console.log('[dodo] Tunnel skipped for this run; local MCP remains available.');
+    else if (!opts.quiet) {
+        console.log(`[dodo] Local connection selected: ${endpointOrigin}/mcp`);
     }
     async function stop(signal) {
         if (shutdownPromise)
@@ -358,9 +362,12 @@ project.command('remove <projectId>')
 // --------------------------------------------------------------- tunnel ----
 const tunnel = program.command('tunnel').description('manage or inspect a Cloudflare remotely-managed Tunnel without managing DNS or the Cloudflare account');
 tunnel.command('configure')
-    .description('save local tunnel mode and a credential reference; tokens are never written to config')
-    .option('--managed', 'DODO supervises cloudflared in the foreground', false)
-    .option('--external', 'an owner/system service manages the tunnel', false)
+    .description('select persistent local or DODO-owned Tunnel mode; tokens are never written to config')
+    .option('--tunnel', 'select the DODO-owned Tunnel for every dodo start', false)
+    .option('--local', 'select local-only MCP for every dodo start', false)
+    .option('--managed', 'deprecated alias for --tunnel', false)
+    .option('--external', 'deprecated alias for --local', false)
+    .option('--public-url <url>', 'public HTTPS origin used by the selected DODO Tunnel')
     .option('--os-credential', 'prompt through the reviewed OS credential provider', false)
     .option('--token-env <name>', 'reference an uppercase environment variable that already contains the token')
     .option('--token-file <absolute-path>', 'reference an owner-private absolute token file')
@@ -372,8 +379,10 @@ tunnel.command('configure')
     .option('--json', 'machine-readable non-secret result', false)
     .action(async (opts) => {
     try {
-        if (opts.managed && opts.external)
-            fail('choose --managed or --external');
+        const chooseTunnel = opts.tunnel || opts.managed;
+        const chooseLocal = opts.local || opts.external;
+        if (chooseTunnel && chooseLocal)
+            fail('choose --tunnel or --local');
         const methods = [opts.osCredential, opts.tokenEnv !== undefined, opts.tokenFile !== undefined].filter(Boolean).length;
         if (methods > 1)
             fail('choose only one of --os-credential, --token-env or --token-file');
@@ -384,6 +393,16 @@ tunnel.command('configure')
         const { dir } = resolveConfigDir(process.env);
         ensureConfigDir(dir);
         const paths = statePaths(dir), current = loadGlobalConfig(paths.configFile);
+        const connectionMode = chooseTunnel ? 'tunnel' : chooseLocal ? 'local' : methods > 0 ? 'tunnel' : current.tunnel.connectionMode;
+        const publicUrl = opts.publicUrl !== undefined
+            ? validatePublicUrl(opts.publicUrl, false).origin
+            : current.publicUrl;
+        if (connectionMode === 'tunnel' && !publicUrl)
+            fail('Tunnel mode requires --public-url https://your-host (or a previously saved public origin)');
+        if (connectionMode === 'tunnel' && publicUrl)
+            validatePublicUrl(publicUrl, false);
+        if (connectionMode === 'local' && opts.publicUrl !== undefined)
+            fail('--public-url is used only with --tunnel');
         const credentials = await import('../tunnel/credentials.js');
         const { resolveCloudflared } = await import('../tunnel/supervisor.js');
         const previousCredentialRef = current.tunnel.credentialRef;
@@ -392,7 +411,7 @@ tunnel.command('configure')
             credentialRef = undefined;
         const baseTunnelInput = {
             ...current.tunnel,
-            mode: opts.managed ? 'managed' : opts.external ? 'external' : current.tunnel.mode,
+            connectionMode,
             ...(credentialRef ? { credentialRef } : {}),
             ...(opts.metricsPort !== undefined ? { metricsPort: opts.metricsPort } : {}),
             ...(opts.maxRestarts !== undefined ? { maxRestarts: opts.maxRestarts } : {}),
@@ -400,7 +419,7 @@ tunnel.command('configure')
         };
         if (!credentialRef)
             delete baseTunnelInput['credentialRef'];
-        let next = GlobalConfigSchema.parse({ ...current, tunnel: baseTunnelInput });
+        let next = GlobalConfigSchema.parse({ ...current, ...(publicUrl ? { publicUrl } : {}), tunnel: baseTunnelInput });
         if (opts.cloudflared !== undefined) {
             const canonical = resolveCloudflared(next);
             next = GlobalConfigSchema.parse({ ...next, tunnel: { ...next.tunnel, executable: canonical } });
@@ -418,19 +437,19 @@ tunnel.command('configure')
         if (!credentialRef)
             delete withCredential['credentialRef'];
         next = GlobalConfigSchema.parse({ ...next, tunnel: withCredential });
-        if (next.tunnel.mode === 'managed' && !next.tunnel.credentialRef)
-            fail('managed mode requires --os-credential, --token-env or --token-file');
+        if (next.tunnel.connectionMode === 'tunnel' && !next.tunnel.credentialRef)
+            fail('Tunnel mode requires --os-credential, --token-env or --token-file');
         saveGlobalConfig(paths.configFile, next);
         if (opts.removeCredential && previousCredentialRef)
             credentials.deleteOsTunnelCredential(previousCredentialRef);
-        const result = { mode: next.tunnel.mode, credential: next.tunnel.credentialRef ? 'configured' : 'not-configured', metricsPort: next.tunnel.metricsPort, maxRestarts: next.tunnel.maxRestarts, cloudflared: next.tunnel.executable ? 'owner-selected' : 'trusted-PATH', started: false };
+        const result = { connectionMode: next.tunnel.connectionMode, publicOrigin: next.tunnel.connectionMode === 'tunnel' ? next.publicUrl : null, credential: next.tunnel.credentialRef ? 'configured' : 'not-configured', metricsPort: next.tunnel.metricsPort, maxRestarts: next.tunnel.maxRestarts, cloudflared: next.tunnel.executable ? 'owner-selected' : 'trusted-PATH', started: false };
         if (opts.json)
             console.log(JSON.stringify(result, null, 2));
         else {
-            console.log(`Tunnel mode: ${result.mode}`);
+            console.log(`Connection mode: ${result.connectionMode}`);
             console.log(`Credential: ${result.credential} (value is not stored in config or displayed)`);
             console.log(`Readiness: 127.0.0.1:${result.metricsPort}   Restarts: ${result.maxRestarts}`);
-            console.log(result.mode === 'managed' ? 'Configuration saved. Start explicitly with: dodo tunnel start --yes' : 'External mode saved. DODO will observe health but will not start cloudflared.');
+            console.log(result.connectionMode === 'tunnel' ? 'Saved. Every dodo start now owns this Tunnel and fails closed if it cannot start.' : 'Saved. Every dodo start now uses only the local MCP endpoint.');
         }
     }
     catch (error) {
@@ -561,7 +580,8 @@ program.command('cli')
             startupProject,
             selectProject: selectStartupProject,
             addProject: addAndSelectProject,
-            start: async (root, tunnel = true) => launchHttp({ ...(root === undefined ? {} : { root }), tunnel }),
+            start: async (root) => launchHttp({ ...(root === undefined ? {} : { root }) }),
+            openRemoteConfig: openRemoteConfigFromCli,
             setupAll: () => setupFromMenu(false),
             checkSetup: () => setupFromMenu(true),
         }, { input: process.stdin, output: process.stdout });
@@ -572,19 +592,58 @@ program.command('cli')
         throw error;
     }
 });
-// ---------------------------------------------------------------- start ----
+function printRemoteConfig(result) {
+    console.log(`Remote Config: ${result.url}`);
+    console.log(`Pairing code (shown once): ${result.pairingCode}`);
+    console.log(`Expires: ${new Date(result.expiresAt).toISOString()} (ไม่เกิน 1 ชั่วโมง)`);
+    console.log('เปิด URL แล้วกรอก code นี้ ระบบจะแลกเป็น Secure/HttpOnly cookie; ไม่มี secret อยู่ใน URL');
+}
+async function openRemoteConfigFromCli() {
+    try {
+        printRemoteConfig(await ipcForInstallation('remoteConfig.open'));
+    }
+    catch (error) {
+        if (!(error instanceof IpcError) || !error.message.includes('no running DODO installation'))
+            throw error;
+        await launchHttp({ web: true });
+    }
+}
+const web = program.command('web')
+    .description('open or renew the one-hour Remote Config page through the public MCP tunnel')
+    .option('--close', 'close the Remote Config lease without stopping MCP or Tunnel', false)
+    .option('--status', 'show the current non-secret Remote Config lease status', false)
+    .action(async (opts) => {
+    if (opts.close && opts.status)
+        fail('choose --close or --status');
+    try {
+        if (opts.close) {
+            console.log(JSON.stringify(await ipcForInstallation('remoteConfig.close'), null, 2));
+            return;
+        }
+        if (opts.status) {
+            console.log(JSON.stringify(await ipcForInstallation('remoteConfig.status'), null, 2));
+            return;
+        }
+        await openRemoteConfigFromCli();
+    }
+    catch (error) {
+        if (error instanceof DodoError || error instanceof IpcError)
+            fail(error.message);
+        throw error;
+    }
+});
+void web;
 program
     .command('start')
     .description('start the MCP server for the saved project, or wait for a project selection (foreground)')
     .option('--root <path>', 'select and remember an explicit workspace root (local CLI only)')
     .option('--port <n>', 'listen port (default from config, initially 21730)', (v) => Number.parseInt(v, 10))
-    .option('--public-url <url>', 'public origin override for this run (local CLI only)')
     .option('--allow-unsafe-root', 'permit filesystem root / home / other unusually broad workspace roots', false)
     .option('--allow', 'allow task execution for this run (requires --all)', false)
     .option('--all', 'all local action classes (requires --allow)', false)
     .option('--bypass', 'trusted actions and no default job sandbox for this run; OAuth and file guards remain', false)
     .option('--tools <surface>', 'tool exposure for this run: compact (HTTP default), full, or hybrid (49 tools: gateways + common direct tools); permissions are unchanged')
-    .option('--no-tunnel', 'start local MCP only; do not ask for a temporary Cloudflare Tunnel token')
+    .option('--web', 'open Remote Config through the public tunnel for at most one hour', false)
     .option('--quiet', 'suppress the startup banner', false)
     .action(async (opts) => {
     try {
@@ -707,8 +766,8 @@ program
         console.log('');
         console.log('Next steps:');
         console.log(`  1. Point your own tunnel at 127.0.0.1:${next.port} for host ${url.hostname} (see docs/TUNNEL.md — route ALL paths, not just /mcp)`);
-        console.log('  2. Register your client callback: dodo auth add-client --redirect-uri <exact callback URL from your client UI>');
-        console.log('  3. cd into a project, set trust: dodo trust --mode edit');
+        console.log(`  2. Select it persistently: dodo tunnel configure --tunnel --public-url ${url.origin} --os-credential`);
+        console.log('  3. Register your client callback: dodo auth add-client --redirect-uri <exact callback URL from your client UI>');
         console.log('  4. dodo start');
     }
     catch (err) {
@@ -1376,13 +1435,19 @@ Desktop (platform helper and explicit app permission required):
   dodo desktop disable               revoke desktop access
 Remote setup:
   dodo init --public-url https://...   configure public origin once
-  dodo start                           prompt for a temporary Tunnel token
-  dodo start --no-tunnel               run local MCP only`);
+  dodo tunnel configure --tunnel --os-credential --public-url https://...
+                                       select the persistent DODO Tunnel
+  dodo tunnel configure --local        select local-only MCP
+  dodo start                            use exactly the saved connection mode
+  dodo --web                           start/renew Remote Config through that tunnel for 1 hour
+  dodo web --close                     close Remote Config; keep MCP/Tunnel running`);
 function effectiveArgv() {
     if (process.argv.length <= 2)
         return [...process.argv, 'start'];
     if (process.argv.length === 3 && process.argv[2] === '--cli')
         return [...process.argv.slice(0, 2), 'cli'];
+    if (process.argv.length === 3 && process.argv[2] === '--web')
+        return [...process.argv.slice(0, 2), 'web'];
     if (process.argv[2] === '--bypass')
         return [...process.argv.slice(0, 2), 'start', ...process.argv.slice(2)];
     return process.argv;