mover-os 4.7.7 → 4.7.8

package/src/dashboard/lib/agent-detect.js

@@ -0,0 +1,255 @@
+"use strict";
+
+/**
+ * agent-detect.js — D7 agent detection for the onboarding connect step.
+ *
+ * Scope: claude / codex / gemini ONLY — the three adapters defined in
+ * agent-session.js ADAPTERS. Wider agent survey (Cursor, Windsurf, etc.)
+ * lives in agent-detector.js (the v5 dashboard Library tab surface).
+ *
+ * Contract per agent:
+ *   id       — adapter key matching ADAPTERS in agent-session.js
+ *   present  — binary is on PATH (binary probe, non-interactive, 800ms cap)
+ *   authed   — best-effort, non-interactive auth signal (see per-vendor notes)
+ *   runnable — present AND the ADAPTERS entry is fully wired (not unsupported)
+ *
+ * Auth signals (non-interactive only — footgun §4: never spawn interactive login):
+ *   claude  : ANTHROPIC_API_KEY, CLAUDE_CODE_OAUTH_TOKEN, Claude Code keychain
+ *             credentials on macOS, or ~/.claude/.credentials.json on Windows/Linux.
+ *   codex   : verify-next adapter — authed=false (cannot probe without spawning).
+ *   gemini  : verify-next adapter — authed=false (footgun §4: --acp can prompt
+ *             for login from a non-terminal parent; never probe here).
+ *
+ * Never spawns an interactive process. Only uses:
+ *   - execFile("sh", ["-c", "command -v '<bin>'"], { timeout: 800 }) — async
+ *   - process.env lookup + credential files/keychain reads
+ *
+ * Wired adapters (from ADAPTERS in agent-session.js, 2026-06-18):
+ *   claude-code → wired (cmd + args + normalize + encodeTurn)
+ *   codex       → unsupported (verify-next)
+ *   gemini      → unsupported (verify-next)
+ */
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execFile, execFileSync } = require("child_process");
+
+// Mirror the ADAPTERS wiring state from agent-session.js.
+// Only source of truth for "is this adapter ready to run?"
+// Update this table when a verify-next adapter is promoted.
+const ADAPTER_WIRED = {
+  "claude-code": true,   // verified spike 2026-06-18
+  "codex":       false,  // verify-next (SPEC §2)
+  "gemini":      false,  // verify-next (SPEC §2)
+};
+
+// ─── PATH probe ──────────────────────────────────────────────────────────────
+
+/**
+ * Returns a Promise<boolean> — true if `bin` is callable on PATH.
+ * Uses `command -v` via sh — POSIX, cheap, no interactive spawn.
+ * 800 ms cap matches agent-detector.js convention (fast enough for
+ * the onboarding step, non-blocking for SSE streams).
+ *
+ * SF-2: single-quote escaping — every single-quote in `bin` is replaced
+ * with the '\'' sequence so a caller-supplied name can never inject shell
+ * metacharacters ($/backtick/backslash are inert inside single quotes).
+ */
+function binaryPresent(bin) {
+  if (!bin || typeof bin !== "string") return Promise.resolve(false);
+  // Escape any single-quotes inside the binary name: ' → '\''
+  const safeBin = bin.replace(/'/g, "'\\''");
+  return new Promise((resolve) => {
+    const child = execFile(
+      "sh",
+      ["-c", `command -v '${safeBin}'`],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 800 },
+      (err, stdout) => {
+        if (err) return resolve(false);
+        resolve(Boolean(stdout && stdout.trim()));
+      }
+    );
+    // Belt-and-suspenders: also resolve false if the child emits 'error'
+    // before the callback fires (e.g. ENOENT for sh — extremely unlikely).
+    child.on("error", () => resolve(false));
+  });
+}
+
+function readClaudeOAuthToken() {
+  if (process.env.CLAUDE_CODE_OAUTH_TOKEN) return process.env.CLAUDE_CODE_OAUTH_TOKEN;
+
+  if (process.platform === "darwin") {
+    try {
+      const out = execFileSync(
+        "security",
+        ["find-generic-password", "-s", "Claude Code-credentials", "-w"],
+        { encoding: "utf8", timeout: 1200, stdio: ["ignore", "pipe", "ignore"] }
+      ).trim();
+      if (out) {
+        try {
+          const token = JSON.parse(out)?.claudeAiOauth?.accessToken;
+          if (token) return token;
+        } catch (_) {
+          if (/^ey/.test(out)) return out;
+        }
+      }
+    } catch (_) {}
+  }
+
+  try {
+    const cf = path.join(os.homedir(), ".claude", ".credentials.json");
+    if (fs.existsSync(cf)) {
+      const token = JSON.parse(fs.readFileSync(cf, "utf8"))?.claudeAiOauth?.accessToken;
+      if (token) return token;
+    }
+  } catch (_) {}
+
+  try {
+    const macCf = path.join(os.homedir(), "Library", "Application Support", "Claude", "config.json");
+    if (fs.existsSync(macCf)) {
+      const cfg = JSON.parse(fs.readFileSync(macCf, "utf8"));
+      for (const key of ["oauth:accessToken", "oauthAccessToken", "accessToken"]) {
+        if (cfg[key] && /^ey/.test(String(cfg[key]))) return cfg[key];
+      }
+    }
+  } catch (_) {}
+
+  return null;
+}
+
+// ─── per-vendor descriptors ──────────────────────────────────────────────────
+
+const VENDORS = [
+  {
+    id:    "claude-code",
+    name:  "Claude",
+    bin:   "claude",
+    /**
+     * Auth: subscription-OAuth is the intended mode (SPEC §2). Do not assume
+     * "binary exists" means "signed in"; first-run uses this signal to avoid
+     * a failed embedded spawn and show the sign-in recovery card up front.
+     */
+    auth() {
+      const apiKey = process.env.ANTHROPIC_API_KEY;
+      const keySet = Boolean(apiKey && apiKey.trim());
+      const token = readClaudeOAuthToken();
+      return {
+        authed: keySet || Boolean(token),
+        mode:   keySet ? "api-key" : "subscription-oauth",
+        note:   keySet
+          ? "ANTHROPIC_API_KEY detected — check Claude subscription billing mode"
+          : token
+            ? "Claude CLI sign-in detected"
+            : "Claude CLI installed but no saved sign-in found — run `claude` then `/login`",
+      };
+    },
+  },
+  {
+    id:    "codex",
+    name:  "Codex",
+    bin:   "codex",
+    /**
+     * Auth: verify-next adapter — we deliberately do NOT probe.
+     * `codex app-server` (the JSON-RPC transport) hasn't been spiked;
+     * probing auth non-interactively isn't safe until we understand the
+     * CLI's login flow. Conservative: authed=false until adapter is wired.
+     */
+    auth() {
+      return {
+        authed: false,
+        mode:   "verify-next",
+        note:   "Codex adapter is verify-next — spike `codex app-server` before enabling",
+      };
+    },
+  },
+  {
+    id:    "gemini",
+    name:  "Gemini",
+    bin:   "gemini",
+    /**
+     * Auth: footgun §4 — `gemini --acp` can prompt for login when spawned from
+     * a non-terminal parent. Never probe. authed=false until adapter is wired
+     * AND we have a non-interactive auth-check mechanism confirmed.
+     */
+    auth() {
+      return {
+        authed: false,
+        mode:   "verify-next",
+        note:   "Gemini adapter is verify-next — confirm non-interactive auth path before enabling",
+      };
+    },
+  },
+];
+
+// ─── main export ─────────────────────────────────────────────────────────────
+
+/**
+ * detectAgents() → Promise<Array<AgentStatus>>
+ *
+ * MF-3: now async — three vendor PATH probes run concurrently via
+ * Promise.all, so total wall-clock time ≈ max(probe) ≈ 800ms instead
+ * of 3 × 800ms = 2.4s. Does not block the Node event loop.
+ *
+ * AgentStatus {
+ *   id:       string      — adapter key (matches ADAPTERS in agent-session.js)
+ *   name:     string      — display label
+ *   present:  boolean     — binary on PATH
+ *   authed:   boolean     — best-effort non-interactive auth signal (see above)
+   *   runnable: boolean     — present AND adapter is wired AND auth is ready
+ *   authMode: string      — "subscription-oauth" | "api-key" | "verify-next"
+ *   authNote: string      — one-line explanation for the UI
+ * }
+ */
+async function detectAgents() {
+  // Fan-out: all three PATH probes run concurrently.
+  const presenceResults = await Promise.all(VENDORS.map((v) => binaryPresent(v.bin)));
+
+  return VENDORS.map((v, i) => {
+    const present = presenceResults[i];
+    const authInfo = v.auth();
+    const adapterWired = ADAPTER_WIRED[v.id] === true;
+    // runnable requires the binary, a wired adapter, and a non-interactive auth signal.
+    // For verify-next adapters, presence is informative only.
+    const runnable = present && adapterWired && authInfo.authed;
+    return {
+      id:       v.id,
+      name:     v.name,
+      present,
+      authed:   adapterWired ? authInfo.authed : false,
+      runnable,
+      authMode: authInfo.mode,
+      authNote: authInfo.note,
+    };
+  });
+}
+
+module.exports = { detectAgents };
+
+// ─── self-test (node agent-detect.js) ────────────────────────────────────────
+if (require.main === module) {
+  (async () => {
+  const results = await detectAgents();
+  console.log("\nD7 Agent Detection — " + new Date().toISOString());
+  console.log("─".repeat(62));
+  for (const r of results) {
+    const tick = (b) => (b ? "✓" : "✗");
+    console.log(
+      `${r.name.padEnd(10)} present=${tick(r.present)}  authed=${tick(r.authed)}  runnable=${tick(r.runnable)}`
+    );
+    console.log(`           mode: ${r.authMode}`);
+    console.log(`           note: ${r.authNote}`);
+    console.log();
+  }
+  const runnable = results.filter((r) => r.runnable);
+  const present  = results.filter((r) => r.present && !r.runnable);
+  const none     = results.every((r) => !r.present);
+  if (runnable.length) {
+    console.log("STATUS: READY — runnable adapters: " + runnable.map((r) => r.id).join(", "));
+  } else if (present.length) {
+    console.log("STATUS: PARTIAL — binaries present but adapters not wired: " + present.map((r) => r.id).join(", "));
+  } else if (none) {
+    console.log("STATUS: NONE — no supported agent binary found on PATH");
+  }
+  })();
+}

package/src/dashboard/lib/agent-detector.js

@@ -0,0 +1,92 @@
+"use strict";
+
+const path = require("path");
+const os = require("os");
+const { execFileSync } = require("child_process");
+const { exists, safeStat } = require("./paths");
+
+// Detect which AI agents are installed on the user's machine.
+// `configured` = ~/.<dir> present (means USER OR MOVER OS set it up)
+// `installed`  = configured AND the actual CLI binary is on PATH
+// `runnable`   = installed AND the agent supports CLI invocation (capability flag)
+//
+// The old design treated any config directory as "installed", which made
+// amp/aider/amazon-q show up as installed for users who never installed them
+// (Mover OS itself sometimes creates those directories as side-effects).
+// Codex bug-hunt (2026-05-13) flagged this — now we require an actual binary
+// probe via `command -v <cli>` to count as installed.
+
+const AGENTS = [
+  { id: "claude-code", name: "Claude Code", configPaths: [".claude"],                                                  cliBin: "claude",  capability: true,  hookSupport: true  },
+  { id: "codex",       name: "Codex CLI",   configPaths: [".codex"],                                                   cliBin: "codex",   capability: true,  hookSupport: true  },
+  { id: "gemini",      name: "Gemini CLI",  configPaths: [".gemini"],                                                  cliBin: "gemini",  capability: true,  hookSupport: true  },
+  { id: "cursor",      name: "Cursor",      configPaths: [".cursor", "Library/Application Support/Cursor"],            cliBin: null,      capability: false, hookSupport: false },
+  { id: "windsurf",    name: "Windsurf",    configPaths: [".windsurf", "Library/Application Support/Windsurf"],        cliBin: null,      capability: false, hookSupport: false },
+  { id: "amp",         name: "Amp",         configPaths: [".amp"],                                                     cliBin: "amp",     capability: true,  hookSupport: false },
+  { id: "aider",       name: "Aider",       configPaths: [".aider", ".aider.conf.yml"],                                cliBin: "aider",   capability: true,  hookSupport: false },
+  { id: "amazon-q",    name: "Amazon Q",    configPaths: [".aws/amazonq"],                                             cliBin: "q",       capability: true,  hookSupport: false },
+  { id: "cline",       name: "Cline",       configPaths: [".cline"],                                                   cliBin: null,      capability: false, hookSupport: false },
+  { id: "continue",    name: "Continue",    configPaths: [".continue"],                                                cliBin: null,      capability: false, hookSupport: false }
+];
+
+function hasBinary(cmd) {
+  if (!cmd) return false;
+  try {
+    // `command -v` is POSIX, faster than spawning the actual CLI just to probe.
+    // We bound it tightly via execFileSync so a hung path entry can't stall the dashboard.
+    const out = execFileSync("sh", ["-c", `command -v ${JSON.stringify(cmd)}`], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 800
+    });
+    return Boolean(out && out.trim());
+  } catch (_) {
+    return false;
+  }
+}
+
+function detectAgents() {
+  const home = os.homedir();
+  const out = AGENTS.map(a => {
+    let configured = false;
+    let configPath = null;
+    let lastUsed = null;
+    for (const cp of a.configPaths) {
+      const p = path.join(home, cp);
+      if (exists(p)) {
+        configured = true;
+        configPath = p;
+        const stat = safeStat(p);
+        if (stat) lastUsed = stat.mtime;
+        break;
+      }
+    }
+    // `installed` requires both a config directory AND a callable binary.
+    // GUI-only tools (Cursor, Windsurf, Cline, Continue) have no cliBin —
+    // for those, configured-and-on-disk counts as installed.
+    const binaryFound = a.cliBin ? hasBinary(a.cliBin) : configured;
+    const installed = configured && binaryFound;
+    return {
+      id: a.id,
+      name: a.name,
+      configured,
+      installed,
+      runnable: installed && a.capability,
+      hookSupport: a.hookSupport,
+      configPath,
+      cliBin: a.cliBin || null,
+      lastUsed
+    };
+  });
+
+  return {
+    available: true,
+    agents: out,
+    installedCount: out.filter(a => a.installed).length,
+    runnableCount: out.filter(a => a.runnable).length,
+    hookSupportedCount: out.filter(a => a.installed && a.hookSupport).length,
+    primary: out.find(a => a.runnable) || null
+  };
+}
+
+module.exports = { detectAgents };