@event4u/agent-switch 2.1.0 → 2.2.0

package/dist/doctor.js

@@ -1,21 +1,146 @@
 /**
- * `agent-switch doctor` — a per-OS, per-provider self-check.
+ * `agent-switch doctor [--json]` — a per-OS, per-provider self-check.
  *
- * Reports health with actionable fixes and returns an exit code: 0 when there
- * is no hard error, 1 when a provider that has profiles is missing its binary.
- * Read-only — it never mutates a profile.
+ * Every finding is a {@link DoctorCheck} (`id, status, title, detail, fix?`);
+ * the text output and `--json` render the same list. The exit code is 1 only
+ * on a hard error (a provider with profiles but no binary). Read-only — it never
+ * mutates a profile, and it never prints a credential or an env var's value.
  */
 import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
-import { ROOT, activeFor, configDir, listProfiles, profileExists, readGuard } from "./profiles.js";
+import * as os from "node:os";
+import * as path from "node:path";
+import { ROOT, activeFor, configDir, identity, listProfiles, profileExists, readGuard } from "./profiles.js";
 import { allProviders } from "./providers.js";
 import { credentialStore } from "./credentials.js";
 import { sharedLinkHealth } from "./share.js";
 import { checkAuth, liveSessionPids } from "./api.js";
 import { checkTooling, doctorToolingLine } from "./tooling.js";
-const OK = "✅";
-const WARN = "⚠️";
-const ERR = "❌";
+import { readGuiSettings } from "./gui-settings.js";
+/**
+ * Env vars that make a provider CLI ignore the profile's login and use a key
+ * or token from the environment instead (D5) — the same credential in every
+ * profile, often billed per use. Only the NAMES are ever reported.
+ */
+export const AUTH_OVERRIDE_ENV = {
+    ANTHROPIC_API_KEY: "claude",
+    ANTHROPIC_AUTH_TOKEN: "claude",
+    CLAUDE_CODE_OAUTH_TOKEN: "claude",
+    OPENAI_API_KEY: "codex",
+    CODEX_API_KEY: "codex",
+    GEMINI_API_KEY: "antigravity",
+    GOOGLE_API_KEY: "antigravity",
+};
+export function apiKeyOverrideCheck(env = process.env) {
+    const set = Object.keys(AUTH_OVERRIDE_ENV).filter((k) => typeof env[k] === "string" && env[k] !== "");
+    if (set.length === 0) {
+        return { id: "api-key-overrides", status: "ok", title: "No API-key overrides", detail: "No provider key or token is set in the environment, so each profile uses its own login." };
+    }
+    const which = set.map((k) => `${k} (${AUTH_OVERRIDE_ENV[k]})`).join(", ");
+    return {
+        id: "api-key-overrides",
+        status: "warn",
+        title: "API key overrides profile logins",
+        detail: `${which} is set in the environment agent-switch runs in. The provider uses it instead of the profile's login — the same credential in every profile, usually billed per use.`,
+        fix: `Unset it in your shell profile (e.g. \`unset ${set[0]}\`) unless you mean to use a key.`,
+    };
+}
+/** Is `agent-switch` reachable on PATH (the shell wrapper and the GUI call it by name)? */
+export function cliOnPathCheck(env = process.env, platform = process.platform, exists = fs.existsSync) {
+    const dirs = (env.PATH ?? env.Path ?? "").split(platform === "win32" ? ";" : ":").filter(Boolean);
+    const names = platform === "win32" ? ["agent-switch.cmd", "agent-switch.exe", "agent-switch"] : ["agent-switch"];
+    const hit = dirs.flatMap((d) => names.map((n) => path.join(d, n))).find(exists);
+    return hit
+        ? { id: "cli-on-path", status: "ok", title: "agent-switch is on PATH", detail: hit }
+        : {
+            id: "cli-on-path",
+            status: "warn",
+            title: "agent-switch is not on PATH",
+            detail: "The shell wrapper and the desktop app call `agent-switch` by name.",
+            fix: "npm install -g @event4u/agent-switch",
+        };
+}
+function rcCandidates(home) {
+    return [
+        path.join(home, ".zshrc"),
+        path.join(home, ".bashrc"),
+        path.join(home, ".bash_profile"),
+        path.join(home, ".profile"),
+        path.join(home, ".config", "fish", "config.fish"),
+        path.join(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1"),
+        path.join(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1"),
+    ];
+}
+export function shellIntegrationCheck(home = os.homedir(), read = readOrNull) {
+    const found = rcCandidates(home).find((f) => /agent-switch\s+shellenv/.test(read(f) ?? ""));
+    return found
+        ? { id: "shell-integration", status: "ok", title: "Shell integration installed", detail: `Loaded from ${found}.` }
+        : {
+            id: "shell-integration",
+            status: "warn",
+            title: "Shell integration not found",
+            detail: "Without it, `claude`/`codex`/`agy` in a terminal ignore the active profile and folder rules. (Checked the usual zsh, bash, fish and PowerShell profile files.)",
+            fix: 'Run `agent-switch shellenv install` — it adds `eval "$(agent-switch shellenv)"` (or your shell\'s equivalent) to your shell profile.',
+        };
+}
+export function autostartCheck(s) {
+    const a = s.autostart;
+    if (a.state === "enabled") {
+        return { id: "autostart", status: "ok", title: "Starts at login", detail: a.by === "user" ? "Turned on by you." : "On by default since the first launch." };
+    }
+    if (a.state === "disabled") {
+        return { id: "autostart", status: "info", title: "Does not start at login", detail: "Turned off by you; updates keep it off." };
+    }
+    if (s.autostartDegraded) {
+        return {
+            id: "autostart",
+            status: "warn",
+            title: "Start at login could not be confirmed",
+            detail: `The desktop app tried to turn it on but the system did not confirm it (${s.autostartDegraded.reason}). It retries on the next launch.`,
+            fix: "Open the desktop app → Settings → turn on start at login.",
+        };
+    }
+    return { id: "autostart", status: "info", title: "Start at login not set up yet", detail: "The desktop app turns it on at its first launch (default on)." };
+}
+export function antigravityOsCheck(platform = process.platform) {
+    return platform === "darwin"
+        ? { id: "antigravity-os", status: "ok", title: "Antigravity supported on this OS", detail: "Per-profile keychain and account readout work on macOS." }
+        : {
+            id: "antigravity-os",
+            status: "warn",
+            title: "Antigravity is only partly supported here",
+            detail: `On ${platform} agent-switch isolates agy's HOME per profile but cannot read which account is signed in or seed a per-profile keychain — both are macOS-only today.`,
+        };
+}
+/** Two profiles of one provider signed into the same account defeat the isolation. */
+export function signInIsolationCheck(rows) {
+    const seen = new Map();
+    for (const r of rows) {
+        if (!r.identity)
+            continue;
+        const k = `${r.provider}\u0000${r.identity.toLowerCase()}`;
+        seen.set(k, [...(seen.get(k) ?? []), `${r.provider}/${r.name}`]);
+    }
+    const dupes = [...seen.values()].filter((v) => v.length > 1);
+    if (dupes.length === 0) {
+        return { id: "sign-in-isolation", status: "ok", title: "Each profile has its own account", detail: "No two profiles of one provider are signed into the same account (where the account is readable)." };
+    }
+    return {
+        id: "sign-in-isolation",
+        status: "warn",
+        title: "Profiles share an account",
+        detail: `Signed into the same account: ${dupes.map((d) => d.join(" + ")).join("; ")}. They share one set of usage limits.`,
+        fix: "Sign one of them into a different account, or remove the duplicate.",
+    };
+}
+function readOrNull(p) {
+    try {
+        return fs.readFileSync(p, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
 function binaryOnPath(binary) {
     // Timeout so a hung binary can't hang the doctor.
     const probe = spawnSync(binary, ["--version"], { stdio: "ignore", timeout: 5000 });
@@ -37,42 +162,30 @@ function credentialReadable(p, name) {
         return false;
     }
 }
-export async function runDoctor() {
-    let hardError = false;
-    const line = (mark, msg) => console.log(`${mark}  ${msg}`);
-    console.log(`agent-switch doctor — platform ${process.platform}, node ${process.version}`);
-    console.log(process.platform === "darwin"
-        ? "  claude credential store: macOS Keychain (hashed per config dir), file fallback"
-        : "  claude credential store: plaintext .credentials.json per profile");
-    console.log("");
+async function providerChecks(checks) {
     for (const p of allProviders()) {
         const names = listProfiles(p.id);
         const onPath = binaryOnPath(p.binary);
+        const addHint = `agent-switch add <name>${p.id === "claude" ? "" : ` --provider ${p.id}`}`;
         if (onPath === "no") {
-            if (names.length > 0) {
-                line(ERR, `\`${p.binary}\` not on PATH but ${names.length} ${p.id} profile(s) exist — install ${p.id}.`);
-                hardError = true;
-            }
-            else {
-                line(WARN, `\`${p.binary}\` not on PATH (no ${p.id} profiles yet — fine unless you use ${p.id}).`);
-            }
+            checks.push(names.length > 0
+                ? { id: `binary-${p.id}`, status: "error", title: `\`${p.binary}\` not on PATH`, detail: `${names.length} ${p.id} profile(s) exist but the CLI is missing.`, fix: `Install ${p.id}, or link it: agent-switch providers link --provider ${p.id} --path <path>` }
+                : { id: `binary-${p.id}`, status: "info", title: `\`${p.binary}\` not on PATH`, detail: `No ${p.id} profiles yet — fine unless you use ${p.id}.` });
             continue;
         }
-        if (onPath === "error")
-            line(WARN, `could not probe \`${p.binary} --version\`.`);
-        else
-            line(OK, `\`${p.binary}\` is on PATH.`);
+        checks.push(onPath === "error"
+            ? { id: `binary-${p.id}`, status: "warn", title: `Could not probe \`${p.binary} --version\``, detail: "The binary exists but did not answer." }
+            : { id: `binary-${p.id}`, status: "ok", title: `\`${p.binary}\` is on PATH`, detail: "" });
         if (names.length === 0) {
-            line(WARN, `  no ${p.id} profiles yet — \`agent-switch add <name>${p.id === "claude" ? "" : ` --provider ${p.id}`}\`.`);
+            checks.push({ id: `profiles-${p.id}`, status: "info", title: `No ${p.id} profiles yet`, detail: "", fix: addHint });
             continue;
         }
-        line(OK, `  ${names.length} ${p.id} profile(s): ${names.join(", ")}.`);
+        checks.push({ id: `profiles-${p.id}`, status: "ok", title: `${names.length} ${p.id} profile(s)`, detail: names.join(", ") });
         const active = activeFor(p.id);
         if (active && !profileExists(p.id, active)) {
-            line(WARN, `  active ${p.id} profile "${active}" no longer exists.`);
+            checks.push({ id: `active-${p.id}`, status: "warn", title: `Active ${p.id} profile "${active}" no longer exists`, detail: "", fix: `agent-switch use <name>${p.id === "claude" ? "" : ` --provider ${p.id}`}` });
         }
-        // Login validity (Claude only): probe readable credentials in parallel, so
-        // an expired login is caught here instead of failing silently at next use.
+        // Login validity (Claude only): probe readable credentials in parallel.
         // Read-only; offline / transient degrades to a neutral note, never a WARN.
         const authByName = new Map();
         if (p.id === "claude") {
@@ -81,23 +194,32 @@ export async function runDoctor() {
             readable.forEach((n, i) => authByName.set(n, states[i]));
         }
         for (const n of names) {
+            const id = `login-${p.id}-${n}`;
+            const run = `agent-switch run ${n}${p.id === "claude" ? "" : ` --provider ${p.id}`}`;
             if (!credentialReadable(p, n)) {
-                line(WARN, `  ${p.id}/${n}: credential not readable — \`agent-switch run ${n}${p.id === "claude" ? "" : ` --provider ${p.id}`}\` and log in.`);
+                checks.push({ id, status: "warn", title: `${p.id}/${n}: no readable login`, detail: "", fix: `${run} and sign in` });
                 continue;
             }
             const auth = authByName.get(n);
-            if (auth === "expired") {
-                line(WARN, `  ${p.id}/${n}: login expired — \`agent-switch run ${n}\` and /login again.`);
-            }
-            else if (auth === "ok") {
-                line(OK, `  ${p.id}/${n}: credential readable, login valid.`);
-            }
-            else {
-                // Non-Claude (no probe) or Claude "unknown"/offline — don't over-claim.
-                line(OK, `  ${p.id}/${n}: credential readable${p.id === "claude" ? " (login not verified — offline?)" : ""}.`);
-            }
+            if (auth === "expired")
+                checks.push({ id, status: "warn", title: `${p.id}/${n}: login expired`, detail: "", fix: `${run} and /login again` });
+            else if (auth === "ok")
+                checks.push({ id, status: "ok", title: `${p.id}/${n}: login valid`, detail: "" });
+            else
+                checks.push({ id, status: "ok", title: `${p.id}/${n}: login stored`, detail: p.id === "claude" ? "Not verified — offline?" : "" });
         }
     }
+}
+export async function collectDoctorReport() {
+    const checks = [];
+    checks.push(cliOnPathCheck());
+    checks.push(shellIntegrationCheck());
+    checks.push(autostartCheck(readGuiSettings()));
+    checks.push(apiKeyOverrideCheck());
+    checks.push(antigravityOsCheck());
+    await providerChecks(checks);
+    const identities = allProviders().flatMap((p) => listProfiles(p.id).map((n) => ({ provider: p.id, name: n, identity: identity(p.id, n) })));
+    checks.push(signInIsolationCheck(identities));
     // Share-link health (Claude-config sharing).
     for (const n of listProfiles("claude")) {
         const health = sharedLinkHealth(configDir("claude", n));
@@ -106,42 +228,56 @@ export async function runDoctor() {
         const forked = health.filter((h) => h.state === "forked").map((h) => h.name);
         const missing = health.filter((h) => h.state === "missing").map((h) => h.name);
         if (forked.length === 0 && missing.length === 0) {
-            line(OK, `claude/${n}: ${health.length} shared link(s) intact.`);
+            checks.push({ id: `share-${n}`, status: "ok", title: `claude/${n}: ${health.length} shared link(s) intact`, detail: "" });
         }
         else {
             const parts = [forked.length ? `forked: ${forked.join(", ")}` : "", missing.length ? `missing: ${missing.join(", ")}` : ""].filter(Boolean);
-            line(WARN, `claude/${n}: ${parts.join("; ")} — run \`agent-switch share sync\`.`);
+            checks.push({ id: `share-${n}`, status: "warn", title: `claude/${n}: shared links drifted`, detail: parts.join("; "), fix: "agent-switch share sync" });
         }
     }
     // Single-load guard: the policy, and whether any profile is doubled RIGHT NOW.
-    // Reported even when the policy is `warn`/`off` — the point of doctor is to
-    // surface the state, and a silently tolerated duplicate is exactly the thing
-    // the user came here to find.
-    {
-        const policy = readGuard();
-        line(policy === "off" ? WARN : OK, `single-load guard: ${policy}${policy === "off" ? " — a profile can be loaded twice" : ""}.`);
-        const doubled = [];
-        for (const p of allProviders()) {
-            if (!p.hasLiveSessionSignal)
-                continue;
-            for (const n of listProfiles(p.id)) {
-                const count = liveSessionPids(configDir(p.id, n)).length;
-                if (count > 1)
-                    doubled.push(`${p.id}/${n} (${count} sessions)`);
-            }
-        }
-        if (doubled.length > 0) {
-            line(WARN, `  loaded more than once: ${doubled.join(", ")} — they share one account's rate limits.`);
+    const policy = readGuard();
+    checks.push({ id: "guard", status: policy === "off" ? "warn" : "ok", title: `Single-load guard: ${policy}`, detail: policy === "off" ? "A profile can be loaded twice." : "" });
+    const doubled = [];
+    for (const p of allProviders()) {
+        if (!p.hasLiveSessionSignal)
+            continue;
+        for (const n of listProfiles(p.id)) {
+            const count = liveSessionPids(configDir(p.id, n)).length;
+            if (count > 1)
+                doubled.push(`${p.id}/${n} (${count} sessions)`);
         }
     }
-    // Ecosystem tooling (agent-config + rtk) — same detection module as
-    // `agent-switch tooling`, never a second implementation. Both tools are
-    // optional, so an unhealthy row is a WARN, never a blocking error.
+    if (doubled.length > 0) {
+        checks.push({ id: "guard-doubled", status: "warn", title: "A profile is loaded more than once", detail: `${doubled.join(", ")} — they share one account's rate limits.` });
+    }
+    // Ecosystem tooling (agent-config + rtk) — both optional, so never an error.
     for (const t of checkTooling({ ids: ["agent-config", "rtk"] })) {
-        line(t.healthy ? OK : WARN, doctorToolingLine(t));
+        checks.push({ id: `tooling-${t.id}`, status: t.healthy ? "ok" : "warn", title: doctorToolingLine(t), detail: "" });
+    }
+    const readiness = checks.some((c) => c.status === "error") ? "blocked" : checks.some((c) => c.status === "warn") ? "attention" : "ready";
+    return { readiness, platform: process.platform, checks };
+}
+const MARK = { ok: "✅", warn: "⚠️", error: "❌", info: "ℹ️" };
+export async function runDoctor(json = false) {
+    const report = await collectDoctorReport();
+    if (json) {
+        console.log(JSON.stringify(report, null, 2));
+        return report.readiness === "blocked" ? 1 : 0;
+    }
+    console.log(`agent-switch doctor — platform ${process.platform}, node ${process.version}`);
+    console.log(process.platform === "darwin"
+        ? "  claude credential store: macOS Keychain (hashed per config dir), file fallback"
+        : "  claude credential store: plaintext .credentials.json per profile");
+    console.log("");
+    for (const c of report.checks) {
+        console.log(`${MARK[c.status]}  ${c.title}${c.detail ? ` — ${c.detail}` : ""}`);
+        if (c.fix)
+            console.log(`     fix: ${c.fix}`);
     }
     console.log(`\n  profile root: ${ROOT}`);
     console.log("");
-    line(hardError ? ERR : OK, hardError ? "doctor found a blocking problem (see above)." : "no blocking problems.");
-    return hardError ? 1 : 0;
+    const blocked = report.readiness === "blocked";
+    console.log(`${blocked ? MARK.error : MARK.ok}  ${blocked ? "doctor found a blocking problem (see above)." : "no blocking problems."}`);
+    return blocked ? 1 : 0;
 }

package/dist/gui-settings.js

@@ -0,0 +1,67 @@
+/**
+ * GUI preferences that must outlive the webview's `localStorage` — the Pet
+ * intro once-flag (D36) and the launch-at-login preference. The GUI can only
+ * reach the filesystem through this CLI, so it reads and writes them with
+ * `agent-switch gui-settings`; `doctor` reads the autostart preference from the
+ * same file.
+ *
+ * Additive file (`<ROOT>/gui-settings.json`): absent keys mean "never decided",
+ * so an upgrade starts with nothing stored and the GUI migrates its old
+ * `localStorage` flags in once.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ROOT, ensureRoot } from "./profiles.js";
+export const GUI_SETTINGS_FILE = path.join(ROOT, "gui-settings.json");
+function normalizeAutostart(raw) {
+    const r = (raw ?? {});
+    const at = typeof r.at === "string" ? r.at : "";
+    if (r.state === "enabled" && (r.by === "first-run" || r.by === "user"))
+        return { state: "enabled", by: r.by, at };
+    if (r.state === "disabled" && r.by === "user")
+        return { state: "disabled", by: "user", at };
+    return { state: "unset" };
+}
+export function readGuiSettings(file = GUI_SETTINGS_FILE) {
+    let raw = {};
+    try {
+        raw = JSON.parse(fs.readFileSync(file, "utf8")) ?? {};
+    }
+    catch {
+        /* absent / unparsable → nothing decided */
+    }
+    const d = raw.autostartDegraded;
+    return {
+        petWelcomed: raw.petWelcomed === true,
+        autostart: normalizeAutostart(raw.autostart),
+        autostartDegraded: d && typeof d === "object" && typeof d.reason === "string"
+            ? { at: typeof d.at === "string" ? d.at : "", reason: d.reason }
+            : null,
+    };
+}
+export function writeGuiSettings(next, file = GUI_SETTINGS_FILE) {
+    if (file === GUI_SETTINGS_FILE)
+        ensureRoot();
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+/**
+ * Apply one update. Guards the two invariants the roadmap pins: the pet intro
+ * flag only ever goes false → true, and a first-run default never replaces a
+ * stored choice (only `by: "user"` may overwrite one).
+ */
+export function applyGuiSetting(cur, u, now = new Date()) {
+    const at = now.toISOString();
+    if (u.key === "pet-welcomed")
+        return { ...cur, petWelcomed: true };
+    if (u.key === "autostart-degraded") {
+        return { ...cur, autostartDegraded: u.reason ? { at, reason: u.reason } : null };
+    }
+    if (u.state === "disabled" && u.by !== "user")
+        throw new Error("only the user can turn launch-at-login off");
+    if (u.by === "first-run" && cur.autostart.state !== "unset")
+        return cur;
+    const autostart = u.state === "enabled" ? { state: "enabled", by: u.by, at } : { state: "disabled", by: "user", at };
+    return { ...cur, autostart, autostartDegraded: null };
+}

package/dist/hooks.js

@@ -122,6 +122,27 @@ export function readEvents(file) {
         return [];
     }
 }
+/**
+ * Sessions waiting on the user: their last hook event is `Notification` (a
+ * permission prompt, or a long wait for input) and the transcript has not been
+ * written since — a reply or an approval writes to it. `Stop` alone is not
+ * waiting: it ends every turn.
+ */
+export function waitingSessions(events, mtimeMs) {
+    const last = new Map();
+    for (const e of events)
+        if (e.sessionId)
+            last.set(e.sessionId, e);
+    // sessionId → when it started waiting.
+    const out = new Map();
+    for (const [id, e] of last) {
+        const written = mtimeMs(id);
+        // Two seconds of slack: the notification and the transcript line that led to it land together.
+        if (e.event === "Notification" && written !== null && Date.parse(e.at) + 2000 >= written)
+            out.set(id, e.at);
+    }
+    return out;
+}
 /** Append one event, trimming the ring to EVENT_RING_CAP. Tolerant of a
  *  malformed existing file (starts fresh). */
 export function appendEvent(file, rec) {