fix(daemon): recover od mcp install from bare-od fallback via IPC discovery

`od mcp install <agent>` degrades to a broken `command: 'od'` launch spec
whenever resolveMcpLaunchSpec() can't reach the running daemon's
/api/mcp/install-info. In practice this triggers on every plain terminal
invocation against a packaged install, since OD_SIDECAR_IPC_PATH is only
ever stamped into the packaged app's own spawned children, and the
packaged daemon binds an ephemeral port rather than the legacy 7456
default. On macOS/Linux the resulting bare `od` then collides with the
system octal-dump utility (#5120/#5219, docs-only fix, root cause
untouched).

resolveDaemonUrl() gains an opt-in allowConventionalIpcDiscovery option:
when OD_SIDECAR_IPC_PATH is absent, it also probes the conventional
per-release-channel sidecar socket path(s) (stable first, deterministic
even when multiple channels are live). Default stays false so every other
`od` subcommand keeps its existing behavior unchanged; only
resolveMcpLaunchSpec() opts in. Probed responses are also required to be
loopback URLs before being trusted, since the JSON-IPC protocol has no
responder-identity check and this is the first caller to persist a probed
response's command/args into a coding agent's config.

The remaining fallback (daemon truly unreachable) now self-reinvokes via
process.execPath + process.argv[1], matching the existing pattern used
elsewhere in cli.ts, instead of the bare 'od' string.

Fixes #6424

Author: mixxer

apps/daemon/src/cli.ts

@@ -1402,12 +1402,12 @@ function positionalArgs(argv, stringFlags = new Set()) {
   return out;
 }
 
-async function cliDaemonUrl(flags) {
-  return resolveDaemonUrl({ flagUrl: flags?.['daemon-url'] });
+async function cliDaemonUrl(flags, resolveOptions = {}) {
+  return resolveDaemonUrl({ flagUrl: flags?.['daemon-url'], ...resolveOptions });
 }
 
-async function cliDaemonBaseUrl(flags) {
-  return (await cliDaemonUrl(flags)).replace(/\/$/, '');
+async function cliDaemonBaseUrl(flags, resolveOptions = {}) {
+  return (await cliDaemonUrl(flags, resolveOptions)).replace(/\/$/, '');
 }
 
 function printMediaHelp() {
@@ -1575,8 +1575,14 @@ To register this server into a coding agent's own config automatically:
 // Codex one-click install use), so every install path configures byte-for-
 // byte the same command. Falls back to a minimal `od mcp --daemon-url`
 // spec when the daemon is unreachable.
+//
+// Opts into conventional per-channel IPC discovery (daemon-url.ts) — unlike
+// every other `od` subcommand, a bare terminal invocation of `mcp install
+// <agent>` against a packaged install has no other way to find the running
+// daemon, since OD_SIDECAR_IPC_PATH is only ever stamped into the packaged
+// app's own spawned children. See issue #6424.
 async function resolveMcpLaunchSpec(flags) {
-  const base = await cliDaemonBaseUrl(flags);
+  const base = await cliDaemonBaseUrl(flags, { allowConventionalIpcDiscovery: true });
   try {
     const resp = await fetch(`${base}/api/mcp/install-info`);
     if (resp.ok) {
@@ -1592,9 +1598,14 @@ async function resolveMcpLaunchSpec(flags) {
   } catch {
     // daemon not running / unreachable — fall through to the minimal spec
   }
+  // Bare `od` collides with the system octal-dump utility on macOS/Linux
+  // (issue #5120). Self-reinvoke via the absolute interpreter + entry-point
+  // paths this very process was launched with instead — the same pattern
+  // already used for plugin-validate above — so the degraded spec still
+  // resolves to a real executable even when discovery keeps failing.
   return {
-    command: 'od',
-    args: ['mcp', '--daemon-url', base],
+    command: process.execPath,
+    args: [process.argv[1], 'mcp', '--daemon-url', base],
     env: {},
   };
 }

apps/daemon/src/daemon-url.ts

@@ -2,11 +2,18 @@ import { spawn } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import {
+  RELEASE_CHANNELS,
+  releaseNamespace,
+  type ReleasePlatform,
+} from "@open-design/release";
+import {
+  APP_KEYS,
+  OPEN_DESIGN_SIDECAR_CONTRACT,
   SIDECAR_ENV,
   SIDECAR_MESSAGES,
   type DaemonStatusSnapshot,
 } from "@open-design/sidecar-proto";
-import { requestJsonIpc } from "@open-design/sidecar";
+import { requestJsonIpc, resolveAppIpcPath } from "@open-design/sidecar";
 
 export const DEFAULT_DAEMON_URL = "http://127.0.0.1:7456";
 const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..");
@@ -18,16 +25,32 @@ export interface ResolveDaemonUrlOptions {
   env?: NodeJS.ProcessEnv;
   /** IPC discovery timeout. Short by default so an absent daemon does not stall CLI startup. */
   timeoutMs?: number;
+  /**
+   * Opt-in: when `OD_SIDECAR_IPC_PATH` is absent, also probe the
+   * conventional per-release-channel sidecar socket path(s) (see
+   * `conventionalIpcSocketPaths`) before falling through to `tools-dev`
+   * discovery and the legacy default. Defaults to `false` so every existing
+   * `resolveDaemonUrl` caller (media generate, project list, run start, …)
+   * keeps its current behavior unchanged — an unrelated already-running
+   * packaged daemon must not silently start answering for commands that
+   * never asked for daemon auto-discovery beyond an explicit IPC path.
+   * `resolveMcpLaunchSpec` (cli.ts, `od mcp install <agent>`) is the one
+   * caller that opts in: a plain terminal invocation of that command has no
+   * other way to find a packaged install's daemon. See issue #6424.
+   */
+  allowConventionalIpcDiscovery?: boolean;
 }
 
 /**
  * Resolve the daemon HTTP base URL for `od` client commands.
  *
  * Spawn order: explicit `--daemon-url` flag, `OD_DAEMON_URL` env, then
  * a STATUS roundtrip to the concrete sidecar IPC endpoint supplied by
- * the lifecycle owner in `OD_SIDECAR_IPC_PATH`, then the default
- * `tools-dev status --json` runtime. Falls back to the legacy default
- * for direct `od` launches that do not run as a sidecar.
+ * the lifecycle owner in `OD_SIDECAR_IPC_PATH` (optionally falling back to
+ * the conventional per-channel socket path(s) when that env var is absent —
+ * see `allowConventionalIpcDiscovery` / `conventionalIpcSocketPaths`), then
+ * the default `tools-dev status --json` runtime. Falls back to the legacy
+ * default for direct `od` launches that do not run as a sidecar.
  */
 export async function resolveDaemonUrl(
   options: ResolveDaemonUrlOptions = {},
@@ -37,7 +60,11 @@ export async function resolveDaemonUrl(
   if (flagUrl != null && flagUrl.length > 0) return flagUrl;
   const envUrl = env.OD_DAEMON_URL;
   if (envUrl != null && envUrl.length > 0) return envUrl;
-  const discovered = await discoverDaemonUrlFromIpc(env, options.timeoutMs ?? 800);
+  const discovered = await discoverDaemonUrlFromIpc(
+    env,
+    options.timeoutMs ?? 800,
+    options.allowConventionalIpcDiscovery ?? false,
+  );
   if (discovered != null) return discovered;
   const toolsDevUrl = await discoverDaemonUrlFromToolsDev(env, options.timeoutMs ?? 800);
   if (toolsDevUrl != null) return toolsDevUrl;
@@ -47,21 +74,124 @@ export async function resolveDaemonUrl(
 async function discoverDaemonUrlFromIpc(
   env: NodeJS.ProcessEnv,
   timeoutMs: number,
+  allowConventionalIpcDiscovery: boolean,
+): Promise<string | null> {
+  const explicitSocketPath = env[SIDECAR_ENV.IPC_PATH];
+  if (explicitSocketPath != null && explicitSocketPath.length > 0) {
+    return await probeIpcSocket(explicitSocketPath, timeoutMs);
+  }
+  if (!allowConventionalIpcDiscovery) return null;
+  // `OD_SIDECAR_IPC_PATH` is only ever stamped by the packaged app into its
+  // OWN spawned child processes (see apps/packaged/src/sidecars.ts) — an
+  // ordinary user terminal never has it set. Without this fallback, `od mcp
+  // install <agent>` run from a plain shell against a running packaged
+  // install can never find `/api/mcp/install-info` and always degrades to
+  // the broken bare-`od` launch spec in cli.ts's resolveMcpLaunchSpec, even
+  // though a live daemon is reachable at a well-known socket path. Gated
+  // behind `allowConventionalIpcDiscovery` so every other `od` subcommand
+  // keeps requiring an explicit IPC path / --daemon-url instead of silently
+  // latching onto an unrelated already-running packaged daemon. See #6424.
+  const candidates = conventionalIpcSocketPaths(env);
+  if (candidates.length === 0) return null;
+  const results = await Promise.allSettled(
+    candidates.map((socketPath) => probeIpcSocket(socketPath, timeoutMs)),
+  );
+  for (const result of results) {
+    if (result.status === "fulfilled" && result.value != null) return result.value;
+  }
+  return null;
+}
+
+async function probeIpcSocket(
+  socketPath: string,
+  timeoutMs: number,
 ): Promise<string | null> {
-  const socketPath = env[SIDECAR_ENV.IPC_PATH];
-  if (socketPath == null || socketPath.length === 0) return null;
   try {
     const status = await requestJsonIpc<DaemonStatusSnapshot>(
       socketPath,
       { type: SIDECAR_MESSAGES.STATUS },
       { timeoutMs },
     );
-    return status?.url ?? null;
+    const url = status?.url ?? null;
+    return url != null && isLoopbackHttpUrl(url) ? url : null;
   } catch {
     return null;
   }
 }
 
+/**
+ * Whether `url` is an http(s) URL whose host is loopback. The JSON-IPC
+ * protocol has no responder-identity check (no peer-credential/uid
+ * verification, no shared secret — see #6424 discussion), so a STATUS
+ * response is not proof the daemon is who it claims to be. This does not
+ * close that gap — the sidecar IPC endpoint itself would need to add
+ * authentication for that — but it does stop a responder on a predictable
+ * socket/pipe path from redirecting daemon discovery off-host, which is the
+ * one part of "what can this URL make us do" this module can cheaply rule
+ * out before the caller `fetch()`s `/api/mcp/install-info` from it and
+ * potentially persists whatever `command`/`args` come back into a coding
+ * agent's config.
+ */
+function isLoopbackHttpUrl(url: string): boolean {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+  return parsed.hostname === "127.0.0.1" || parsed.hostname === "::1" || parsed.hostname === "localhost";
+}
+
+/**
+ * Conventional per-release-channel sidecar IPC socket paths, stable-channel
+ * first. Bounded to the product's own known channels (`@open-design/release`)
+ * so an absent daemon still fails fast — probes run concurrently via
+ * `Promise.allSettled` in the caller, so the wall-clock cost stays bounded by
+ * a single timeout regardless of candidate count, not their sum.
+ *
+ * Honors an explicit `OD_SIDECAR_NAMESPACE` when present (cheap extra check,
+ * mirrors the explicit-namespace precedence `resolveNamespace` already uses
+ * elsewhere); otherwise derives the current platform's namespace suffix from
+ * `process.platform`/`process.arch` and tries every known channel.
+ */
+function conventionalIpcSocketPaths(env: NodeJS.ProcessEnv): string[] {
+  const explicitNamespace = env[SIDECAR_ENV.NAMESPACE];
+  if (explicitNamespace != null && explicitNamespace.length > 0) {
+    return [
+      resolveAppIpcPath({
+        app: APP_KEYS.DAEMON,
+        contract: OPEN_DESIGN_SIDECAR_CONTRACT,
+        env,
+        namespace: explicitNamespace,
+      }),
+    ];
+  }
+  const platform: ReleasePlatform =
+    process.platform === "darwin"
+      ? process.arch === "arm64"
+        ? "mac"
+        : "macIntel"
+      : process.platform === "win32"
+        ? "win"
+        : "linux";
+  const orderedChannels = [
+    RELEASE_CHANNELS.STABLE,
+    RELEASE_CHANNELS.BETA,
+    RELEASE_CHANNELS.BETAS,
+    RELEASE_CHANNELS.PRERELEASE,
+    RELEASE_CHANNELS.PREVIEW,
+  ] as const;
+  return orderedChannels.map((channel) =>
+    resolveAppIpcPath({
+      app: APP_KEYS.DAEMON,
+      contract: OPEN_DESIGN_SIDECAR_CONTRACT,
+      env,
+      namespace: releaseNamespace(channel, platform),
+    }),
+  );
+}
+
 async function discoverDaemonUrlFromToolsDev(
   env: NodeJS.ProcessEnv,
   timeoutMs: number,