@event4u/agent-switch 1.0.0

package/dist/apps.js

@@ -0,0 +1,112 @@
+/**
+ * GUI/desktop app launch layer (foundation).
+ *
+ * Extends agent-switch's per-profile isolation beyond the CLIs to GUI clients
+ * (Claude Desktop, Codex UI, …). Two isolation strategies:
+ *
+ *   - "env"            — export the provider's config-dir env var (the same
+ *                        mechanism the CLIs use) when launching the GUI, so a
+ *                        surface that reads e.g. CODEX_HOME isolates the same
+ *                        way. Reuses the existing profile config dir.
+ *   - "user-data-dir"  — pass Chromium's `--user-data-dir` to an Electron app,
+ *                        giving each profile its own fully isolated data dir
+ *                        (cookies/session). Uses a dedicated per-profile dir.
+ *
+ * `buildLaunch` is pure (path + argv construction only) so both strategies are
+ * unit-testable. The registry starts EMPTY on purpose: concrete apps are
+ * registered by the per-client roadmaps (claude-desktop, codex-ui), not here.
+ */
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { configDir, profileDir } from "./profiles.js";
+/**
+ * Registered launchable GUI apps. Per-client roadmaps add entries (each owns its
+ * verification + caveats); the foundation provides the mechanism.
+ *
+ * claude-desktop: the account is a Chromium web session, isolated per profile
+ * by a distinct `--user-data-dir` (distinct single-instance lock ⇒ parallel
+ * accounts). The profile's own data dir is used — the default
+ * `~/Library/Application Support/Claude` install is never touched.
+ */
+export const APPS = [
+    {
+        id: "claude-desktop",
+        displayName: "Claude Desktop",
+        bundleId: "com.anthropic.claudefordesktop",
+        provider: "claude",
+        strategy: "user-data-dir",
+    },
+    {
+        // Codex IDE extension: the editor reads CODEX_HOME from its process env, so
+        // isolation is the env strategy (reuses the codex profile's config dir).
+        // Targets VS Code; other editors are a future addition.
+        id: "codex-ide",
+        displayName: "VS Code",
+        bundleId: "com.microsoft.VSCode",
+        provider: "codex",
+        strategy: "env",
+        envVar: "CODEX_HOME",
+    },
+    {
+        // Codex desktop app is two-layer (both verified first-hand): CODEX_HOME
+        // isolates the codex agent auth/config (reuses the codex profile dir), and
+        // --user-data-dir isolates the Electron/ChatGPT web session (per-profile
+        // gui dir). Both are set in one launch.
+        id: "codex-desktop",
+        displayName: "Codex",
+        bundleId: "com.openai.codex",
+        provider: "codex",
+        strategy: "env+user-data-dir",
+        envVar: "CODEX_HOME",
+    },
+    {
+        // Antigravity is an Electron/VS Code-fork IDE whose login is a web session in
+        // an Electron user-data dir — isolate per profile via --user-data-dir (same
+        // strategy as claude-desktop). The agy CLI's HOME lever is separate.
+        id: "antigravity",
+        displayName: "Antigravity",
+        bundleId: "com.google.antigravity",
+        provider: "antigravity",
+        strategy: "user-data-dir",
+    },
+];
+export function findApp(id, registry = APPS) {
+    return registry.find((a) => a.id === id) ?? null;
+}
+/** The per-profile Electron user-data dir for a "user-data-dir" app.
+ *  `path.join` keeps separators OS-correct (the string-concat version broke the
+ *  Windows CI: `\`-joined profileDir + `/`-appended tail = mixed separators). */
+export function guiDataDir(app, name) {
+    return path.join(profileDir(app.provider, name), "gui", app.id);
+}
+/**
+ * Build the launch command for an app + profile (pure). macOS `open`:
+ *   - env:            open -n --env <VAR>=<profileConfigDir> -b <bundleId>
+ *   - user-data-dir:  open -n -b <bundleId> --args --user-data-dir=<guiDataDir>
+ * `-n` forces a new instance; distinct dir ⇒ distinct single-instance lock ⇒
+ * profiles run in parallel. Throws on a misconfigured descriptor.
+ */
+export function buildLaunch(app, name) {
+    const wantsEnv = app.strategy === "env" || app.strategy === "env+user-data-dir";
+    const wantsUdd = app.strategy === "user-data-dir" || app.strategy === "env+user-data-dir";
+    if (wantsEnv && !app.envVar) {
+        throw new Error(`app "${app.id}" uses an env strategy but declares no envVar`);
+    }
+    // `open -n [--env VAR=<configDir>] -b <bundle> [--args --user-data-dir=<guiDir>]`.
+    // Some apps isolate two independent layers at once (e.g. Codex desktop: its
+    // agent config via CODEX_HOME + its web session via --user-data-dir).
+    const args = ["-n"];
+    if (wantsEnv)
+        args.push("--env", `${app.envVar}=${configDir(app.provider, name)}`);
+    args.push("-b", app.bundleId);
+    if (wantsUdd)
+        args.push("--args", `--user-data-dir=${guiDataDir(app, name)}`);
+    return { program: "open", args };
+}
+/** Best-effort: is the app installed? (macOS bundle-id lookup; false elsewhere.) */
+export function isInstalled(app) {
+    if (process.platform !== "darwin")
+        return false;
+    const r = spawnSync("mdfind", [`kMDItemCFBundleIdentifier == '${app.bundleId}'`], { encoding: "utf8" });
+    return r.status === 0 && r.stdout.trim().length > 0;
+}

package/dist/args.js

@@ -0,0 +1,85 @@
+/**
+ * CLI argument parsing — extracted so it is unit-testable without running the
+ * `index.ts` entry point.
+ *
+ * The bug this fixes (round-2 review F1): the old
+ * `positional = rest.filter(a => !a.startsWith("--"))` stripped a flag but NOT
+ * its value, so `--provider codex` left `"codex"` in the positionals — and
+ * `remove --provider codex opfer` then targeted `codex` instead of `opfer`
+ * (destructive, silent). Value-flags consume their value here.
+ */
+import { PROVIDER_IDS, isProviderId } from "./providers.js";
+/** Flags that take a value (the next token), as opposed to boolean switches.
+ *  Every flag read as a string in index.ts MUST be listed here, or its value
+ *  leaks into the positionals and the flag reads back as boolean `true`
+ *  (the bug behind `notify`/`providers --surface` silently losing their args). */
+const VALUE_FLAGS = new Set([
+    "provider",
+    "shell",
+    "source",
+    "threshold",
+    "to",
+    "from",
+    "recent",
+    "kind",
+    "title",
+    "message",
+    "surface",
+    "tag",
+    "ack",
+    "brief",
+]);
+/** Resolve a `--provider` value to a ProviderId; throws (not exits) on invalid
+ *  so callers can test it. Undefined → claude. */
+export function resolveProviderValue(v) {
+    if (v === undefined)
+        return "claude";
+    if (typeof v !== "string" || !isProviderId(v)) {
+        throw new Error(`unknown provider "${String(v)}" (choose: ${PROVIDER_IDS.join(", ")})`);
+    }
+    return v;
+}
+export function parseArgs(argv) {
+    const [cmd, ...rest] = argv;
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (a.startsWith("--")) {
+            const key = a.slice(2);
+            if (VALUE_FLAGS.has(key)) {
+                flags[key] = rest[i + 1]; // consume the value...
+                i++; // ...so it never leaks into positionals
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+        else {
+            positional.push(a);
+        }
+    }
+    return {
+        cmd,
+        providerId: resolveProviderValue(flags.provider),
+        providerExplicit: "provider" in flags,
+        positional,
+        flags,
+    };
+}
+/**
+ * `run` is special: everything after the profile name is passed THROUGH to the
+ * provider binary (including its own `--flags`), so it can't go through the
+ * general parser. Strip only `--provider <val>`, take the name, pass the rest.
+ */
+export function parseRun(rest) {
+    const args = [...rest];
+    let providerId = "claude";
+    const pi = args.indexOf("--provider");
+    if (pi >= 0) {
+        providerId = resolveProviderValue(args[pi + 1]);
+        args.splice(pi, 2);
+    }
+    const name = args.shift();
+    return { providerId, name, args };
+}

package/dist/codex-reset.js

@@ -0,0 +1,93 @@
+/**
+ * Codex banked rate-limit reset credits: list + redeem.
+ *
+ * Endpoints (accept the stored OAuth bearer; extracted from the openai.chatgpt
+ * VS Code extension and confirmed by the community `codex-reset` tool — Codex
+ * itself only exposes `/reset` from v0.135):
+ *
+ *   GET  /backend-api/wham/rate-limit-reset-credits
+ *        → { credits: [{ id, status: "available"|…, … }], available_count, … }
+ *   POST /backend-api/wham/rate-limit-reset-credits/consume
+ *        body { credit_id, redeem_request_id }   // redeem_request_id = idempotency UUID
+ *        → { code: "reset", windows_reset, redeemed_at, … }
+ *
+ * SAFETY: a reset credit is scarce and non-refundable, and redeeming is known to
+ * be occasionally buggy upstream. This module only redeems when the caller asks;
+ * the daemon's reset-first path guards it to at most once per reset cycle so a
+ * loop can never burn a user's whole balance. The redeem call itself cannot be
+ * exercised in CI (it would consume a real credit) — the request construction is
+ * unit-tested and it is validated live the first time a limit is hit.
+ */
+import { randomUUID } from "node:crypto";
+import { codexTokenOf } from "./codex-usage.js";
+const BASE = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
+function headers(accessToken, accountId) {
+    return {
+        Authorization: `Bearer ${accessToken}`,
+        ...(accountId ? { "chatgpt-account-id": accountId } : {}),
+        originator: "codex_cli_rs",
+        "User-Agent": "codex_cli_rs/0.134.0",
+        Accept: "application/json",
+        "Content-Type": "application/json",
+    };
+}
+/** Number of currently-available reset credits for a codex home, or null. */
+export async function availableResetCredits(configDir) {
+    const tok = codexTokenOf(configDir);
+    if (!tok)
+        return null;
+    try {
+        const res = await fetch(BASE, { headers: headers(tok.accessToken, tok.accountId), signal: AbortSignal.timeout(10_000) });
+        if (!res.ok)
+            return null;
+        const raw = await res.json();
+        if (typeof raw?.available_count === "number")
+            return raw.available_count;
+        if (Array.isArray(raw?.credits))
+            return raw.credits.filter((c) => c?.status === "available").length;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Redeem ONE available reset credit for a codex home. Returns {ok:false} when
+ * there is nothing to redeem or the call fails — never throws. The
+ * `redeem_request_id` is a fresh UUID (the documented idempotency key).
+ */
+export async function redeemResetCredit(configDir) {
+    const tok = codexTokenOf(configDir);
+    if (!tok)
+        return { ok: false, reason: "no token" };
+    const h = headers(tok.accessToken, tok.accountId);
+    let creditId;
+    try {
+        const res = await fetch(BASE, { headers: h, signal: AbortSignal.timeout(10_000) });
+        if (!res.ok)
+            return { ok: false, reason: `list ${res.status}` };
+        const raw = await res.json();
+        const credits = Array.isArray(raw?.credits) ? raw.credits : [];
+        creditId = credits.find((c) => c?.status === "available")?.id ?? null;
+        if (!creditId)
+            return { ok: false, reason: "no available credit" };
+    }
+    catch (e) {
+        return { ok: false, reason: String(e?.message ?? e) };
+    }
+    try {
+        const res = await fetch(`${BASE}/consume`, {
+            method: "POST",
+            headers: h,
+            body: JSON.stringify({ credit_id: creditId, redeem_request_id: randomUUID() }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok)
+            return { ok: false, reason: `consume ${res.status}` };
+        const raw = await res.json();
+        return { ok: raw?.code === "reset", windowsReset: typeof raw?.windows_reset === "number" ? raw.windows_reset : undefined };
+    }
+    catch (e) {
+        return { ok: false, reason: String(e?.message ?? e) };
+    }
+}

package/dist/codex-usage.js

@@ -0,0 +1,105 @@
+/**
+ * Codex usage readout — live, from the ChatGPT backend.
+ *
+ * Codex has no `usage` CLI command, and `/backend-api/codex/*` is Cloudflare-
+ * gated (a bearer token gets a 403). But the `wham/*` endpoints DO accept the
+ * stored OAuth bearer, and `GET /backend-api/wham/usage` returns the live rate
+ * limits + banked reset credits (verified). Shape:
+ *
+ *   { plan_type, rate_limit: { allowed, limit_reached,
+ *       primary_window:   { used_percent, limit_window_seconds, reset_at },
+ *       secondary_window: null | {…} },
+ *     rate_limit_reset_credits: { available_count } }
+ *
+ * We map the windows to the same UsageSnapshot the Claude readout produces, and
+ * carry the reset-credit count so the GUI can show "N resets available".
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+const WHAM_USAGE = "https://chatgpt.com/backend-api/wham/usage";
+const CODEX_VERSION = "0.134.0"; // only used for the User-Agent string
+/** Read a codex profile's OAuth access token + account id from its auth.json. */
+export function codexTokenOf(configDir) {
+    try {
+        const raw = fs.readFileSync(path.join(configDir, "auth.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        const accessToken = parsed?.tokens?.access_token;
+        if (typeof accessToken !== "string" || !accessToken)
+            return null;
+        const accountId = typeof parsed?.tokens?.account_id === "string" ? parsed.tokens.account_id : null;
+        return { accessToken, accountId };
+    }
+    catch {
+        return null;
+    }
+}
+/** limit_window_seconds → a short window key + label (18000 = 5h, 604800 = 7d,
+ *  2592000 = 30d; anything else falls back to hours/days). */
+function windowMeta(seconds) {
+    if (seconds === 18000)
+        return { key: "five_hour", label: "5h" };
+    if (seconds === 604800)
+        return { key: "seven_day", label: "7d" };
+    if (seconds === 2592000)
+        return { key: "monthly", label: "30d" };
+    if (typeof seconds === "number" && seconds > 0) {
+        return seconds >= 86400
+            ? { key: `w_${seconds}`, label: `${Math.round(seconds / 86400)}d` }
+            : { key: `w_${seconds}`, label: `${Math.round(seconds / 3600)}h` };
+    }
+    return { key: "window", label: "—" };
+}
+function toWindow(w) {
+    if (!w || typeof w !== "object")
+        return null;
+    const utilization = typeof w.used_percent === "number" ? Math.round(w.used_percent) : null;
+    const resetsAt = typeof w.reset_at === "number" ? new Date(w.reset_at * 1000).toISOString() : null;
+    if (utilization === null && resetsAt === null)
+        return null;
+    const { key, label } = windowMeta(w.limit_window_seconds);
+    return { key, label, utilization, resetsAt };
+}
+/** Pure parse of a `wham/usage` response into a UsageSnapshot. Exported for
+ *  tests; degrades to null when no window carries data. */
+export function parseCodexUsage(raw, capturedAt = new Date().toISOString()) {
+    const rl = raw?.rate_limit;
+    if (!rl || typeof rl !== "object")
+        return null;
+    const windows = [];
+    for (const w of [rl.primary_window, rl.secondary_window]) {
+        const win = toWindow(w);
+        if (win)
+            windows.push(win);
+    }
+    const available = raw?.rate_limit_reset_credits?.available_count;
+    const resetCredits = typeof available === "number" ? available : null;
+    if (windows.length === 0 && resetCredits === null)
+        return null;
+    return { windows, routines: null, capturedAt, resetCredits };
+}
+/** Live Codex usage for one profile home, or null (no token / network / 4xx). */
+export async function readCodexUsage(configDir, capturedAt = new Date().toISOString()) {
+    const tok = codexTokenOf(configDir);
+    if (!tok)
+        return null;
+    let raw;
+    try {
+        const res = await fetch(WHAM_USAGE, {
+            headers: {
+                Authorization: `Bearer ${tok.accessToken}`,
+                ...(tok.accountId ? { "chatgpt-account-id": tok.accountId } : {}),
+                originator: "codex_cli_rs",
+                "User-Agent": `codex_cli_rs/${CODEX_VERSION}`,
+                Accept: "application/json",
+            },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok)
+            return null;
+        raw = await res.json();
+    }
+    catch {
+        return null;
+    }
+    return parseCodexUsage(raw, capturedAt);
+}

package/dist/credentials.js

@@ -0,0 +1,66 @@
+/**
+ * Per-OS credential access — a read-only abstraction over where Claude Code
+ * keeps a profile's OAuth credential.
+ *
+ * By design there is NO `write()`: agent-switch never writes Claude Code's
+ * credential storage. The only supported way to place a credential is seeding
+ * a plaintext `.credentials.json` file inside the config dir (see `import`),
+ * which Claude Code then migrates into its own store on first use.
+ *
+ * Backends:
+ *   - darwin  → Keychain (hashed service per config dir), then the plaintext
+ *               file as a fallback. Claude Code reads in this same order, so a
+ *               stale hashed entry can shadow a file seed — hence `clearStale`.
+ *   - linux   → plaintext `.credentials.json` under CLAUDE_CONFIG_DIR only.
+ *   - win32   → plaintext `.credentials.json` under CLAUDE_CONFIG_DIR only.
+ *
+ * Everything degrades gracefully: an unreadable credential returns null, and
+ * removal/clear are best-effort.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as keychain from "./keychain.js";
+/** The plaintext credential file every OS uses as the seed / fallback. */
+function readCredentialFile(configDir) {
+    try {
+        return fs.readFileSync(path.join(configDir, ".credentials.json"), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/** linux/win32: credentials live only as a plaintext file under CLAUDE_CONFIG_DIR. */
+class FileCredentialStore {
+    read(configDir) {
+        return readCredentialFile(configDir);
+    }
+    readDefault(defaultConfigDir) {
+        return readCredentialFile(defaultConfigDir);
+    }
+    removeEntry() {
+        return false; // no OS store; the file is removed with the profile dir
+    }
+    clearStale() {
+        /* no OS store to shadow the seed */
+    }
+}
+/** darwin: Keychain first (hashed service), then the plaintext file fallback. */
+class DarwinCredentialStore {
+    read(configDir) {
+        return keychain.getPassword(keychain.serviceNameFor(configDir)) ?? readCredentialFile(configDir);
+    }
+    readDefault(defaultConfigDir) {
+        // The default install uses the un-suffixed service; file as parity fallback.
+        return keychain.readDefaultCredential() ?? readCredentialFile(defaultConfigDir);
+    }
+    removeEntry(configDir) {
+        return keychain.deletePassword(keychain.serviceNameFor(configDir));
+    }
+    clearStale(configDir) {
+        keychain.deletePassword(keychain.serviceNameFor(configDir));
+    }
+}
+/** The credential store for a platform (defaults to the host platform). */
+export function credentialStore(platform = process.platform) {
+    return platform === "darwin" ? new DarwinCredentialStore() : new FileCredentialStore();
+}