@event4u/agent-switch 2.0.0 → 2.2.0

package/dist/mappings.js

@@ -12,6 +12,9 @@
  * canonicalized) paths; values are `{ provider, name }`. A path may map a
  * different profile per provider, so the stored value is keyed by provider:
  * `{ "<path>": { claude: "<name>", codex: "<name>", ... } }`.
+ *
+ * A rule can be paused without losing it: `paused` lists `{ "<path>": [provider] }`
+ * next to `mappings`, and resolution skips a paused rule as if it were absent.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -39,14 +42,30 @@ export function normalizePath(p) {
     }
     return canonicalizeWin32(resolved);
 }
-export function loadMappings() {
-    let data;
+function readFile() {
     try {
-        data = JSON.parse(fs.readFileSync(MAPPINGS_FILE, "utf8"));
+        return JSON.parse(fs.readFileSync(MAPPINGS_FILE, "utf8"));
     }
     catch {
+        return null;
+    }
+}
+function loadPaused() {
+    const raw = readFile()?.paused;
+    if (!raw || typeof raw !== "object")
         return {};
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (Array.isArray(value))
+            out[key] = value.filter((v) => typeof v === "string");
     }
+    return out;
+}
+const isPaused = (paused, key, providerId) => !!paused[key]?.includes(providerId);
+export function loadMappings() {
+    const data = readFile();
+    if (!data)
+        return {};
     const raw = data && typeof data.mappings === "object" ? data.mappings : {};
     const out = {};
     for (const [key, value] of Object.entries(raw)) {
@@ -58,11 +77,29 @@ export function loadMappings() {
     }
     return out;
 }
-function save(mappings) {
+/** Write mappings; paused flags of rules that no longer exist are dropped. */
+function save(mappings, paused = loadPaused()) {
     ensureRoot();
-    fs.writeFileSync(MAPPINGS_FILE, JSON.stringify({ schema: 2, mappings }, null, 2) + "\n", {
-        mode: 0o600,
-    });
+    const kept = {};
+    for (const [key, providers] of Object.entries(paused)) {
+        const live = providers.filter((p) => mappings[key]?.[p]);
+        if (live.length > 0)
+            kept[key] = live;
+    }
+    const body = Object.keys(kept).length > 0 ? { schema: 2, mappings, paused: kept } : { schema: 2, mappings };
+    fs.writeFileSync(MAPPINGS_FILE, JSON.stringify(body, null, 2) + "\n", { mode: 0o600 });
+}
+/** Pause or resume one folder rule. False when the folder has no rule for the provider. */
+export function setPaused(dir, providerId, on) {
+    const key = normalizePath(dir);
+    const mappings = loadMappings();
+    if (!mappings[key]?.[providerId])
+        return false;
+    const paused = loadPaused();
+    const rest = (paused[key] ?? []).filter((p) => p !== providerId);
+    paused[key] = on ? [...rest, providerId] : rest;
+    save(mappings, paused);
+    return true;
 }
 export function setMapping(dir, providerId, name) {
     const key = normalizePath(dir);
@@ -93,10 +130,11 @@ export function removeMapping(dir, providerId) {
 /** Nearest mapped ancestor of `dir` (inclusive) for a provider; null if none. */
 export function resolveMapping(dir, providerId) {
     const mappings = loadMappings();
+    const paused = loadPaused();
     let current = normalizePath(dir);
     for (;;) {
         const entry = mappings[current];
-        if (entry && entry[providerId])
+        if (entry && entry[providerId] && !isPaused(paused, current, providerId))
             return { path: current, name: entry[providerId] };
         const parent = path.dirname(current);
         if (parent === current)
@@ -123,9 +161,10 @@ export function pruneMappings(providerId, name) {
 /** All mappings as flat rows for display. */
 export function mappingRows() {
     const rows = [];
+    const paused = loadPaused();
     for (const [key, entry] of Object.entries(loadMappings())) {
         for (const [provider, name] of Object.entries(entry)) {
-            rows.push({ path: key, provider: provider, name: name });
+            rows.push({ path: key, provider: provider, name: name, paused: isPaused(paused, key, provider) });
         }
     }
     return rows.sort((a, b) => a.path.localeCompare(b.path) || a.provider.localeCompare(b.provider));

package/dist/pools.js

@@ -0,0 +1,144 @@
+/**
+ * Pools — explicit, user-created groups of profiles that a folder rule may point
+ * at (`map pool:<id> [dir]`). Additive and opt-in: the store starts empty, an
+ * upgrade creates nothing, and labels (Work/Personal/Other) and
+ * `autoSwitch.tag` are never read or changed here. Membership is many-to-many
+ * and keyed by `provider/name`; a pool may hold profiles of several providers,
+ * and a lookup only ever considers members of the provider being started.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ROOT, ensureRoot, labelFor, listAllProfiles, PROFILE_LABELS } from "./profiles.js";
+import { isProviderId } from "./providers.js";
+export const POOLS_FILE = path.join(ROOT, "pools.json");
+export const POOL_PREFIX = "pool:";
+export function isPoolRef(v) {
+    return v.startsWith(POOL_PREFIX);
+}
+export function poolIdOf(ref) {
+    return ref.slice(POOL_PREFIX.length);
+}
+/** `claude/work` → `{ provider, name }`, or null when it is not a member key. */
+export function parseMember(v) {
+    const m = /^([a-z]+)\/([A-Za-z0-9_-]+)$/.exec(v);
+    if (!m || !isProviderId(m[1]))
+        return null;
+    return { provider: m[1], name: m[2] };
+}
+export function slugify(name) {
+    return name
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40);
+}
+export function readPools(file = POOLS_FILE) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!Array.isArray(raw?.pools))
+            return [];
+        return raw.pools
+            .filter((p) => p && typeof p.id === "string" && typeof p.name === "string")
+            .map((p) => ({
+            id: p.id,
+            name: p.name,
+            members: Array.isArray(p.members) ? p.members.filter((m) => typeof m === "string" && parseMember(m)) : [],
+            createdAt: typeof p.createdAt === "string" ? p.createdAt : "",
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function save(pools, file) {
+    if (file === POOLS_FILE)
+        ensureRoot();
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ schema: 1, pools }, null, 2) + "\n", { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+export function findPool(id, file = POOLS_FILE) {
+    return readPools(file).find((p) => p.id === id) ?? null;
+}
+function mustFind(pools, id) {
+    const p = pools.find((x) => x.id === id);
+    if (!p)
+        throw new Error(`no pool "${id}" (pools: ${pools.map((x) => x.id).join(", ") || "none"})`);
+    return p;
+}
+export function createPool(name, file = POOLS_FILE, now = new Date()) {
+    const display = name.trim();
+    const id = slugify(display);
+    if (!id)
+        throw new Error("pool name needs at least one letter or digit");
+    const pools = readPools(file);
+    if (pools.some((p) => p.id === id))
+        throw new Error(`a pool "${id}" already exists`);
+    const pool = { id, name: display, members: [], createdAt: now.toISOString() };
+    save([...pools, pool], file);
+    return pool;
+}
+/** Renames the display name only — the id stays, so folder rules keep working. */
+export function renamePool(id, name, file = POOLS_FILE) {
+    const pools = readPools(file);
+    const p = mustFind(pools, id);
+    if (!name.trim())
+        throw new Error("pool name must not be empty");
+    p.name = name.trim();
+    save(pools, file);
+    return p;
+}
+export function deletePool(id, file = POOLS_FILE) {
+    const pools = readPools(file);
+    mustFind(pools, id);
+    save(pools.filter((p) => p.id !== id), file);
+}
+export function addPoolMember(id, member, file = POOLS_FILE) {
+    if (!parseMember(member))
+        throw new Error(`"${member}" is not a profile key (expected provider/name, e.g. claude/work)`);
+    const pools = readPools(file);
+    const p = mustFind(pools, id);
+    if (!p.members.includes(member))
+        p.members.push(member);
+    save(pools, file);
+    return p;
+}
+export function removePoolMember(id, member, file = POOLS_FILE) {
+    const pools = readPools(file);
+    const p = mustFind(pools, id);
+    p.members = p.members.filter((m) => m !== member);
+    save(pools, file);
+    return p;
+}
+/** Keep memberships pointing at a profile across a rename / drop them on remove. */
+export function renamePoolMember(from, to, file = POOLS_FILE) {
+    const pools = readPools(file);
+    let changed = false;
+    for (const p of pools) {
+        if (!p.members.includes(from))
+            continue;
+        p.members = p.members.filter((m) => m !== from);
+        if (to && !p.members.includes(to))
+            p.members.push(to);
+        changed = true;
+    }
+    if (changed)
+        save(pools, file);
+}
+/**
+ * "Suggest from tags": one proposed pool per label in use. A preview only —
+ * nothing is stored until the user confirms (`pool suggest --confirm`), and a
+ * proposal whose id already exists is marked so it is never overwritten.
+ */
+export function suggestPoolsFromLabels(profiles = listAllProfiles(), label = labelFor, existing = readPools()) {
+    const out = [];
+    for (const l of PROFILE_LABELS) {
+        const members = profiles.filter((p) => label(p.provider, p.name) === l).map((p) => `${p.provider}/${p.name}`);
+        if (members.length === 0)
+            continue;
+        const id = slugify(l);
+        out.push({ id, name: l, members, exists: existing.some((p) => p.id === id) });
+    }
+    return out;
+}

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, FRESH_INSTALL_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");
@@ -12,6 +13,11 @@ export const PROFILE_LABELS = ["Work", "Personal", "Other"];
 export function isProfileLabel(v) {
     return typeof v === "string" && PROFILE_LABELS.includes(v);
 }
+/** The account colours the GUI offers (its swatches use the same names). */
+export const PROFILE_COLORS = ["orange", "red", "yellow", "green", "teal", "blue", "purple", "pink"];
+export function isProfileColor(v) {
+    return typeof v === "string" && PROFILE_COLORS.includes(v);
+}
 export const DEFAULT_AUTOSWITCH = { enabled: false, threshold: 95, tag: "all" };
 /**
  * Providers enabled out of the box. Everything else is available but off by
@@ -32,7 +38,13 @@ export function die(msg) {
     process.exit(1);
 }
 export function ensureRoot() {
+    // A fresh install pins its fresh-install defaults (guard: warn) on the first
+    // write, so the first profile it gets cannot flip it into looking like an
+    // upgraded 2.1.0 install (profiles, no state.json → block).
+    const fresh = !fs.existsSync(STATE_FILE) && listAllProfiles().length === 0;
     fs.mkdirSync(ROOT, { recursive: true, mode: 0o700 });
+    if (fresh)
+        fs.writeFileSync(STATE_FILE, JSON.stringify(readState(), null, 2) + "\n", { mode: 0o600 });
 }
 function validateName(name) {
     if (!/^[A-Za-z0-9_-]+$/.test(name))
@@ -101,6 +113,16 @@ function normalizeLabels(raw) {
     }
     return out;
 }
+function normalizeColors(raw) {
+    const out = {};
+    if (raw && typeof raw === "object") {
+        for (const [k, v] of Object.entries(raw)) {
+            if (isProfileColor(v))
+                out[k] = v;
+        }
+    }
+    return out;
+}
 function normalizeAutoSwitch(raw) {
     const r = (raw ?? {});
     const threshold = typeof r.threshold === "number" && r.threshold >= 1 && r.threshold <= 100 ? Math.round(r.threshold) : DEFAULT_AUTOSWITCH.threshold;
@@ -160,28 +182,38 @@ function normalizeRebindState(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"));
         const labels = normalizeLabels(raw?.labels);
+        const colors = normalizeColors(raw?.colors);
+        const disabled = Array.isArray(raw?.disabled) ? raw.disabled.filter((k) => typeof k === "string") : [];
         const autoSwitch = normalizeAutoSwitchMap(raw?.autoSwitch);
         const providers = normalizeProvidersMap(raw?.providers);
         const binaryPaths = normalizeBinaryPaths(raw?.binaryPaths);
         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, osNotifications, rebind };
+            return { active: { ...emptyActive(), claude: raw.active }, labels, colors, disabled, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
         }
         if (raw?.active && typeof raw.active === "object") {
-            return { active: { ...emptyActive(), ...raw.active }, labels, autoSwitch, providers, binaryPaths, osNotifications, rebind };
+            return { active: { ...emptyActive(), ...raw.active }, labels, colors, disabled, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
         }
-        return { active: emptyActive(), labels, autoSwitch, providers, binaryPaths, osNotifications, rebind };
+        return { active: emptyActive(), labels, colors, disabled, autoSwitch, providers, binaryPaths, osNotifications, rebind, guard };
     }
     catch {
         /* absent / unparsable → default */
     }
-    return { active: emptyActive(), labels: {}, autoSwitch: emptyAutoSwitch(), providers: emptyProviders(), binaryPaths: {}, osNotifications: false, rebind: { ...DEFAULT_REBIND_STATE } };
+    // Fresh = nothing at all yet. `add` without `use` writes no state.json, so a
+    // 2.1.0 install can have profiles and no state file — that user must keep the
+    // pre-2.2 default (block), not be treated as new.
+    const fresh = !fs.existsSync(STATE_FILE) && listAllProfiles().length === 0;
+    return { active: emptyActive(), labels: {}, colors: {}, disabled: [], autoSwitch: emptyAutoSwitch(), providers: emptyProviders(), binaryPaths: {}, osNotifications: false, rebind: { ...DEFAULT_REBIND_STATE }, guard: fresh ? FRESH_INSTALL_GUARD_POLICY : DEFAULT_GUARD_POLICY };
 }
 export function readOsNotifications() {
     return readState().osNotifications;
@@ -191,6 +223,17 @@ 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() {
@@ -231,9 +274,40 @@ export function setLabel(providerId, name, label) {
         delete state.labels[key];
     writeState(state);
 }
-/** Drop a removed profile's label so it can't linger as an orphan. */
+/** Drop a removed profile's label, colour and disabled flag so they can't
+ *  linger as orphans (a reused name starts clean). */
 export function clearLabel(providerId, name) {
     setLabel(providerId, name, null);
+    setColor(providerId, name, null);
+    setDisabled(providerId, name, false);
+}
+export function isDisabled(providerId, name) {
+    return readState().disabled.includes(labelKey(providerId, name));
+}
+/** Disable (or re-enable) a profile. Disabling the active one clears the slot. */
+export function setDisabled(providerId, name, disabled) {
+    const state = readState();
+    const key = labelKey(providerId, name);
+    state.disabled = state.disabled.filter((k) => k !== key);
+    if (disabled) {
+        state.disabled.push(key);
+        if (state.active[providerId] === name)
+            state.active[providerId] = null;
+    }
+    writeState(state);
+}
+export function colorOf(providerId, name) {
+    return readState().colors[labelKey(providerId, name)] ?? null;
+}
+/** Set (or clear, with null) a profile's colour. */
+export function setColor(providerId, name, color) {
+    const state = readState();
+    const key = labelKey(providerId, name);
+    if (color)
+        state.colors[key] = color;
+    else
+        delete state.colors[key];
+    writeState(state);
 }
 /**
  * Rename a profile: move its config dir, carry its Claude credential across the
@@ -276,6 +350,11 @@ export function renameProfile(providerId, from, to, store = credentialStore()) {
         state.labels[toKey] = state.labels[fromKey];
         delete state.labels[fromKey];
     }
+    if (state.colors[fromKey] !== undefined) {
+        state.colors[toKey] = state.colors[fromKey];
+        delete state.colors[fromKey];
+    }
+    state.disabled = state.disabled.map((k) => (k === fromKey ? toKey : k));
     writeState(state);
 }
 export function readAutoSwitch(providerId) {

package/dist/protection.js

@@ -0,0 +1,93 @@
+/**
+ * Session protection — a per-profile policy, separate from the near-limit
+ * notifications (`autoswitch`, 95 %) and the context alerts. Default ON at 98 %
+ * for every profile, including ones that existed before this file did: a
+ * profile with no stored entry simply reads the default.
+ *
+ * What it does today: the daemon WARNS when a polled profile reaches its
+ * threshold. It does not pause anything. A real pause needs the provider to
+ * hold the session (Claude Code's own auto-continue), which agent-switch cannot
+ * verify from here, so every notice says "warn" — never "paused".
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ROOT, ensureRoot } from "./profiles.js";
+export const PROTECTION_FILE = path.join(ROOT, "protection.json");
+export const DEFAULT_PROTECTION = { enabled: true, thresholdPct: 98 };
+function key(providerId, name) {
+    return `${providerId}/${name}`;
+}
+function validThreshold(v) {
+    return typeof v === "number" && Number.isInteger(v) && v >= 1 && v <= 100;
+}
+function load(file) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        return raw && typeof raw.profiles === "object" && raw.profiles ? raw.profiles : {};
+    }
+    catch {
+        return {};
+    }
+}
+function save(profiles, file) {
+    if (file === PROTECTION_FILE)
+        ensureRoot();
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ schema: 1, profiles }, null, 2) + "\n", { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function normalize(raw) {
+    return {
+        enabled: typeof raw?.enabled === "boolean" ? raw.enabled : DEFAULT_PROTECTION.enabled,
+        thresholdPct: validThreshold(raw?.thresholdPct) ? raw.thresholdPct : DEFAULT_PROTECTION.thresholdPct,
+    };
+}
+export function readProtection(providerId, name, file = PROTECTION_FILE) {
+    return normalize(load(file)[key(providerId, name)]);
+}
+export function setProtection(providerId, name, patch, file = PROTECTION_FILE) {
+    if (patch.thresholdPct !== undefined && !validThreshold(patch.thresholdPct)) {
+        throw new Error("threshold must be a whole number between 1 and 100");
+    }
+    const all = load(file);
+    const next = normalize({ ...normalize(all[key(providerId, name)]), ...patch });
+    all[key(providerId, name)] = next;
+    save(all, file);
+    return next;
+}
+/** Carry a profile's policy across a rename; drop it on remove. */
+export function renameProtection(providerId, from, to, file = PROTECTION_FILE) {
+    const all = load(file);
+    if (!(key(providerId, from) in all))
+        return;
+    all[key(providerId, to)] = all[key(providerId, from)];
+    delete all[key(providerId, from)];
+    save(all, file);
+}
+export function forgetProtection(providerId, name, file = PROTECTION_FILE) {
+    const all = load(file);
+    if (!(key(providerId, name) in all))
+        return;
+    delete all[key(providerId, name)];
+    save(all, file);
+}
+/**
+ * The threshold warning for one profile, or null. Pure. Fires once per reset
+ * cycle of the window that crossed (`lastCycle` = what was announced before).
+ */
+export function protectionNotice(target, snap, policy, lastCycle) {
+    if (!policy.enabled)
+        return null;
+    const hit = snap.windows.find((w) => typeof w.utilization === "number" && w.utilization >= policy.thresholdPct);
+    if (!hit)
+        return null;
+    const cycle = `${hit.key}@${hit.resetsAt ?? ""}`;
+    if (cycle === lastCycle)
+        return null;
+    return {
+        cycle,
+        title: "Session protection: limit almost reached",
+        message: `${target} reached ${hit.utilization}% of its ${hit.label} limit (protection threshold ${policy.thresholdPct}%). ` +
+            `This is a warning only — agent-switch does not pause running sessions.`,
+    };
+}

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) {