@event4u/agent-switch 1.7.0 → 2.1.0

package/dist/keychain.js

@@ -48,6 +48,20 @@ export function deletePassword(service) {
         return false;
     return (security(["delete-generic-password", "-a", os.userInfo().username, "-s", service]) !== null);
 }
+/**
+ * Upsert a generic password entry (`-U` overwrites an existing value). Returns
+ * true on success. This is the ONE credential-store WRITE in agent-switch — used
+ * ONLY by `src/rebind.ts` under Claude Code's lock (ADR-003). Elsewhere the
+ * credential store stays read-only.
+ *
+ * Note: the value is passed on argv (as `security` requires with `-w`), so it is
+ * briefly visible to `ps` — the same trade-off Claude Code's own tooling makes.
+ */
+export function addPassword(service, value) {
+    if (!isMac())
+        return false;
+    return security(["add-generic-password", "-U", "-a", os.userInfo().username, "-s", service, "-w", value]) !== null;
+}
 /** The live credential of the default ~/.claude install (keychain, macOS). */
 export function readDefaultCredential() {
     return getPassword(DEFAULT_SERVICE);

package/dist/notifications.js

@@ -33,11 +33,16 @@ function writeNotifications(list, file) {
  * Append an event (kept newest-last). Deduplicates a byte-identical
  * kind+title+message against the most recent entry within DEDUP_WINDOW_MS.
  * Returns the created notification, or `null` when it was deduplicated.
+ *
+ * `dedupe: false` skips that collapse — for session-awareness events (Claude
+ * finished / is waiting) where each occurrence is a distinct moment the user
+ * wants surfaced, so a solo session's repeated turns are never swallowed.
  */
-export function appendNotification(event, now = Date.now(), file = NOTIFICATIONS_FILE) {
+export function appendNotification(event, now = Date.now(), file = NOTIFICATIONS_FILE, dedupe = true) {
     const list = readNotifications(file);
     const last = list[list.length - 1];
-    if (last &&
+    if (dedupe &&
+        last &&
         last.kind === event.kind &&
         last.title === event.title &&
         last.message === event.message &&

package/dist/profiles.js

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { PROVIDER_IDS, provider, isProviderId } from "./providers.js";
 import { credentialStore } from "./credentials.js";
+import { DEFAULT_GUARD_POLICY, isGuardPolicy } from "./single-load.js";
 export const HOME = os.homedir();
 export const ROOT = process.env.AGENT_SWITCH_HOME ?? path.join(HOME, ".agent-switch");
 export const STATE_FILE = path.join(ROOT, "state.json");
@@ -13,7 +14,6 @@ export function isProfileLabel(v) {
     return typeof v === "string" && PROFILE_LABELS.includes(v);
 }
 export const DEFAULT_AUTOSWITCH = { enabled: false, threshold: 95, tag: "all" };
-export const DEFAULT_SWITCH_STRATEGY = "reset-first";
 /**
  * Providers enabled out of the box. Everything else is available but off by
  * default — the user opts it in from the Providers settings tab. A provider that
@@ -21,6 +21,7 @@ export const DEFAULT_SWITCH_STRATEGY = "reset-first";
  * upgrading never hides an account the user already set up.
  */
 export const PROVIDERS_ON_BY_DEFAULT = ["claude", "codex"];
+export const DEFAULT_REBIND_STATE = { disabled: false, consecutiveFailures: 0 };
 function emptyActive() {
     return { claude: null, codex: null, antigravity: null };
 }
@@ -155,6 +156,14 @@ function normalizeBinaryPaths(raw) {
             out[p] = r[p];
     return out;
 }
+function normalizeRebindState(raw) {
+    const r = (raw ?? {});
+    const consecutiveFailures = typeof r.consecutiveFailures === "number" && r.consecutiveFailures >= 0 ? Math.floor(r.consecutiveFailures) : 0;
+    return { disabled: r.disabled === true, consecutiveFailures };
+}
+function normalizeGuard(raw) {
+    return isGuardPolicy(raw) ? raw : DEFAULT_GUARD_POLICY;
+}
 export function readState() {
     try {
         const raw = JSON.parse(fs.readFileSync(STATE_FILE, "utf8"));
@@ -162,29 +171,22 @@ export function readState() {
         const autoSwitch = normalizeAutoSwitchMap(raw?.autoSwitch);
         const providers = normalizeProvidersMap(raw?.providers);
         const binaryPaths = normalizeBinaryPaths(raw?.binaryPaths);
-        const switchStrategy = raw?.switchStrategy === "rotation-first" ? "rotation-first" : DEFAULT_SWITCH_STRATEGY;
         const osNotifications = raw?.osNotifications === true;
+        const rebind = normalizeRebindState(raw?.rebind);
+        const guard = normalizeGuard(raw?.guard);
         // v1: { active: "<name>" } — a single Claude profile.
         if (typeof raw?.active === "string") {
-            return { active: { ...emptyActive(), claude: raw.active }, labels, autoSwitch, providers, binaryPaths, switchStrategy, osNotifications };
+            return { active: { ...emptyActive(), claude: raw.active }, labels, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
         }
         if (raw?.active && typeof raw.active === "object") {
-            return { active: { ...emptyActive(), ...raw.active }, labels, autoSwitch, providers, binaryPaths, switchStrategy, osNotifications };
+            return { active: { ...emptyActive(), ...raw.active }, labels, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
         }
-        return { active: emptyActive(), labels, autoSwitch, providers, binaryPaths, switchStrategy, osNotifications };
+        return { active: emptyActive(), labels, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
     }
     catch {
         /* absent / unparsable → default */
     }
-    return { active: emptyActive(), labels: {}, autoSwitch: emptyAutoSwitch(), providers: emptyProviders(), binaryPaths: {}, switchStrategy: DEFAULT_SWITCH_STRATEGY, osNotifications: false };
-}
-export function readSwitchStrategy() {
-    return readState().switchStrategy;
-}
-export function setSwitchStrategy(strategy) {
-    const state = readState();
-    state.switchStrategy = strategy;
-    writeState(state);
+    return { active: emptyActive(), labels: {}, autoSwitch: emptyAutoSwitch(), providers: emptyProviders(), binaryPaths: {}, osNotifications: false, rebind: { ...DEFAULT_REBIND_STATE }, guard: DEFAULT_GUARD_POLICY };
 }
 export function readOsNotifications() {
     return readState().osNotifications;
@@ -194,6 +196,32 @@ export function setOsNotifications(on) {
     state.osNotifications = on;
     writeState(state);
 }
+// ---------- single-load guard policy ----------
+/** How the single-load guard reacts to a second load of one profile. */
+export function readGuard() {
+    return readState().guard;
+}
+/** Persist the guard policy. */
+export function setGuard(policy) {
+    const state = readState();
+    state.guard = policy;
+    writeState(state);
+}
+// ---------- rebind kill-switch / circuit-breaker (ADR-003) ----------
+/** Current rollback/circuit-breaker state for the `rebind` write path. */
+export function readRebindKillSwitch() {
+    return readState().rebind;
+}
+/** Persist the rebind kill-switch state (breaker counter + disabled flag). */
+export function writeRebindKillSwitch(next) {
+    const state = readState();
+    state.rebind = normalizeRebindState(next);
+    writeState(state);
+}
+/** Re-enable `rebind`: clear `disabled` + reset the failure counter (`--reset`). */
+export function resetRebindKillSwitch() {
+    writeRebindKillSwitch({ ...DEFAULT_REBIND_STATE });
+}
 export function writeState(state) {
     ensureRoot();
     fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2) + "\n", { mode: 0o600 });

package/dist/providers.js

@@ -77,6 +77,7 @@ const claude = {
     oneShotArgs: (prompt) => ["-p", prompt],
     importFiles: [],
     hasUsageReadout: true,
+    hasLiveSessionSignal: true,
 };
 const codex = {
     id: "codex",
@@ -95,6 +96,7 @@ const codex = {
     oneShotArgs: (prompt) => ["exec", prompt],
     importFiles: ["auth.json"],
     hasUsageReadout: true, // live via wham/usage (ChatGPT backend)
+    hasLiveSessionSignal: false, // rollouts are date-partitioned; no live-pid marker
 };
 const antigravity = {
     id: "antigravity",
@@ -128,6 +130,7 @@ const antigravity = {
     oneShotArgs: (prompt) => ["--print", prompt],
     importFiles: [],
     hasUsageReadout: false,
+    hasLiveSessionSignal: false,
 };
 const PROVIDERS = { claude, codex, antigravity };
 export function provider(id) {

package/dist/rebind-dialog.js

@@ -0,0 +1,65 @@
+/**
+ * The limit-dialog model (Phase 4) — the PURE, testable core behind the CLI's
+ * interactive `agent-switch rebind` picker. It computes the switch-target rows
+ * and the pre-selected best-headroom suggestion; it performs NO switch and does
+ * NO I/O. The switch itself is always a user interaction (§ Out of scope,
+ * road-to-live-rebind.md): this module only shapes what the user is shown and
+ * maps their keystroke to a target. The credential write lives in rebind.ts.
+ *
+ * The suggestion reuses the usage helper `maxUtilization` — the same ranking
+ * `pickSwitchTarget` uses (lowest max-utilization = most headroom); no new
+ * ranking is invented. Unlike `pickSwitchTarget` it is NOT threshold-gated: the
+ * user opened the dialog on demand, so a best-headroom target is always
+ * pre-selected as a convenience (the pick, not the suggestion, is the switch).
+ */
+import { maxUtilization } from "./usage.js";
+/**
+ * Build the dialog model. `runningProfile` is the profile the live session
+ * serves; it is excluded from the suggestion (and, marked `isRunning`, from the
+ * selectable rows). Pure — takes plain data, returns plain data.
+ */
+export function buildRebindDialog(candidates, runningProfile) {
+    const rows = candidates.map((c) => ({
+        profile: c.name,
+        label: c.label ?? null,
+        maxUtil: c.snapshot ? maxUtilization(c.snapshot) : null,
+        isRunning: c.name === runningProfile,
+    }));
+    // Suggestion = lowest known max-utilization among the non-running rows (most
+    // headroom). Same ranking as pickSwitchTarget's `m < best.max`, reusing the
+    // maxUtilization helper — no new ranking invented. Ties keep the first row.
+    let best = null;
+    for (const r of rows) {
+        if (r.isRunning || r.maxUtil === null)
+            continue;
+        if (best === null || r.maxUtil < best.maxUtil)
+            best = r;
+    }
+    return { rows, suggestedProfile: best ? best.profile : null };
+}
+/** The selectable rows (non-running), in dialog order — the list the CLI
+ *  numbers 1..N and that {@link resolveRebindChoice} indexes against. */
+export function selectableRows(dialog) {
+    return dialog.rows.filter((r) => !r.isRunning);
+}
+/**
+ * Map a raw picker keystroke to a target profile or a control action — the pure
+ * selection→target mapping the readline loop delegates to. `q`/`c` (any case) =
+ * cancel; empty = the pre-selected suggestion (or invalid when none); a 1-based
+ * index into the selectable rows = that profile; anything else = invalid. Never
+ * switches — it only resolves intent.
+ */
+export function resolveRebindChoice(input, dialog) {
+    const trimmed = input.trim().toLowerCase();
+    if (trimmed === "q" || trimmed === "c")
+        return { kind: "cancel" };
+    const selectable = selectableRows(dialog);
+    if (trimmed === "") {
+        return dialog.suggestedProfile ? { kind: "target", profile: dialog.suggestedProfile } : { kind: "invalid" };
+    }
+    const n = Number(trimmed);
+    if (Number.isInteger(n) && n >= 1 && n <= selectable.length) {
+        return { kind: "target", profile: selectable[n - 1].profile };
+    }
+    return { kind: "invalid" };
+}