dodo-mcp 1.0.2 → 1.0.4

package/README.md

@@ -1,6 +1,6 @@
 # DODO MCP
 
-**DODO MCP 1.0.2** คือ MCP server แบบ local-first สำหรับให้ AI ช่วยพัฒนา software โดยทำงานกับ workspace ที่เจ้าของเลือก ค่าเริ่มต้นเป็นโหมดส่วนตัวแบบเพิ่มโปรเจกต์แล้วใช้ได้ทันที และยังมีโหมด managed สำหรับแยก workspace ACL/trust แบบละเอียด
+**DODO MCP 1.0.4** คือ MCP server แบบ local-first สำหรับให้ AI ช่วยพัฒนา software โดยทำงานกับ workspace ที่เจ้าของเลือก ค่าเริ่มต้นเป็นโหมดส่วนตัวแบบเพิ่มโปรเจกต์แล้วใช้ได้ทันที และยังมีโหมด managed สำหรับแยก workspace ACL/trust แบบละเอียด
 
 ## จุดเด่น
 
@@ -57,6 +57,12 @@ expected hash, workspace context และ OAuth scopes หากต้องแ
 
 `dodo setup --check` และ `dodo setup --plan` เป็น read-only หากแผนมี dependency ที่ต้องติดตั้ง ให้ตรวจรายการก่อนแล้วจึงรัน `dodo setup --yes --components <list>` ระบบจะไม่เริ่ม installer หากไม่มี `--yes` และ `--yes` ไม่ข้าม sudo, OS permission หรือ owner consent
 
+บน Windows ให้รัน DODO ด้วย account เดียวกับที่จะใช้งานประจำและเก็บ state บน local
+NTFS หากพบ `private Windows state ACL could not be established or verified` ห้ามลด
+ACL หรือลบ state เดิม ดูวิธีใช้ `DODO_CONFIG_DIR` เพื่อเริ่ม installation ใหม่อย่าง
+ปลอดภัยและรายการ component ที่ต้องติดตั้งเองใน [Windows Setup](docs/WINDOWS_SETUP.md)
+โดยเฉพาะ `cloudflared` ซึ่ง Windows ต้องติดตั้ง signed package จาก Cloudflare ก่อน
+
 เมื่อ DODO ตรวจพบ config เดิมในตำแหน่งมาตรฐาน สามารถใช้ `dodo setup --import-state` เพื่อนำเข้าเฉพาะ preference ที่ปลอดภัย เช่น port, search backend, retention และ tool surface ระบบจะสร้าง installation identity ใหม่เสมอและไม่คัดลอก OAuth keys/tokens, client grants, workspace ACL, trust, approvals, schedules, public origin, web/desktop permission, executable registration หรือฐานข้อมูลเดิม ต้นฉบับจะไม่ถูกแก้ไข
 
 เปิด Local Config จาก URL ที่ `dodo` แสดงใน terminal ใช้สำหรับเพิ่มโปรเจกต์, AI
@@ -250,20 +256,34 @@ 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 เดียวกัน:
 
@@ -277,15 +297,14 @@ dodo web --close    # ปิดหน้า Remote Config แต่ MCP/Tunnel
 terminal หลังจับคู่ browser จะใช้ cookie ที่เป็น `Secure`, `HttpOnly`,
 `SameSite=Strict` และจำกัด path ที่ `/config` หน้า Remote Config ปิดอัตโนมัติภายใน
 1 ชั่วโมง การเปิดใหม่ออก code/session ใหม่และไม่ต้อง restart MCP ไม่มี token หรือ
-credential อยู่ใน URL หาก process เดิมเริ่มแบบ local-only `dodo --web` จะถาม Tunnel
-token แบบซ่อนและเปิด `cloudflared` ของ process นั้นก่อน
+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`
@@ -394,6 +413,7 @@ dodo desktop allow --app com.google.Chrome --mode control --persist --yes
 - [Tunnel](docs/TUNNEL.md)
 - [Web clients](docs/WEB_CLIENTS.md)
 - [Windows compatibility](docs/WINDOWS.md)
+- [Windows setup และ ACL troubleshooting](docs/WINDOWS_SETUP.md)
 - [Task assistance](docs/ASSISTANCE.md)
 - [Multimodal](docs/MULTIMODAL.md)
 - [Project Registry](docs/PROJECTS.md)

package/dist/cli/main.js

@@ -142,21 +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;
-    if (opts.web && !publicUrl)
-        fail('dodo --web requires a public HTTPS origin; run dodo init --public-url https://your-host first');
-    let temporaryTunnelToken;
-    const interactiveTerminal = process.stdin.isTTY === true && process.stdout.isTTY === true;
-    if (opts.web && opts.tunnel !== false && !interactiveTerminal) {
-        fail('dodo --web needs an interactive terminal for temporary Tunnel token entry; use dodo start --web --no-tunnel only with an already-running external tunnel');
-    }
-    if (opts.tunnel !== false && (config.tunnel.startWithDodo || opts.web) && publicUrl && interactiveTerminal) {
-        const { readTemporaryTunnelToken } = await import('../tunnel/credentials.js');
-        temporaryTunnelToken = await readTemporaryTunnelToken();
-        if (opts.web && !temporaryTunnelToken) {
-            fail('Remote Config was not opened because no temporary Tunnel token was entered');
-        }
+    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' } : {}),
@@ -165,12 +167,11 @@ async function launchHttp(opts) {
         allowUnsafeRoot: opts.allowUnsafeRoot ?? false,
         quiet: opts.quiet ?? false,
         onLog: (line) => console.log(formatTerminalLine(line)),
-        ...(opts.web ? { remoteConfig: true } : {}),
+        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}`));
@@ -184,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)
@@ -278,9 +273,12 @@ program.command('setup')
     }
     catch (error) {
         if (opts.json)
-            console.log(JSON.stringify({ error: error instanceof DodoError ? error.code : 'SETUP_FAILED', message: error.message }));
-        else
+            console.log(JSON.stringify({ error: error instanceof DodoError ? error.code : 'SETUP_FAILED', message: error.message, ...(error instanceof DodoError && error.recovery ? { recovery: error.recovery } : {}) }));
+        else {
             console.error(`dodo setup: ${error.message}`);
+            if (error instanceof DodoError && error.recovery)
+                console.error(`Recovery: ${error.recovery}`);
+        }
         process.exitCode = 1;
     }
 });
@@ -367,9 +365,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')
@@ -381,8 +382,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');
@@ -393,6 +396,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;
@@ -401,7 +414,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 } : {}),
@@ -409,7 +422,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 } });
@@ -427,19 +440,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) {
@@ -570,7 +583,7 @@ 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),
@@ -590,20 +603,7 @@ function printRemoteConfig(result) {
 }
 async function openRemoteConfigFromCli() {
     try {
-        const status = await ipcForInstallation('remoteConfig.status');
-        let tunnelToken;
-        if (status.tunnel?.available === true && status.tunnel.running !== true) {
-            const { readTemporaryTunnelToken } = await import('../tunnel/credentials.js');
-            tunnelToken = await readTemporaryTunnelToken('Cloudflare Tunnel token (temporary; required for Remote Config): ');
-            if (!tunnelToken)
-                fail('Remote Config needs a temporary Tunnel token; use dodo start --no-tunnel for local-only MCP');
-        }
-        try {
-            printRemoteConfig(await ipcForInstallation('remoteConfig.open', tunnelToken ? { tunnelToken } : {}));
-        }
-        finally {
-            tunnelToken = undefined;
-        }
+        printRemoteConfig(await ipcForInstallation('remoteConfig.open'));
     }
     catch (error) {
         if (!(error instanceof IpcError) || !error.message.includes('no running DODO installation'))
@@ -641,13 +641,11 @@ program
     .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) => {
@@ -771,8 +769,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) {
@@ -1440,10 +1438,12 @@ 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 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
-  dodo start --no-tunnel               run local MCP only`);
+  dodo web --close                     close Remote Config; keep MCP/Tunnel running`);
 function effectiveArgv() {
     if (process.argv.length <= 2)
         return [...process.argv, 'start'];