@event4u/agent-switch 2.1.0 → 2.3.0

package/dist/launchers.js

@@ -0,0 +1,228 @@
+/**
+ * Managed desktop launchers (macOS): one small app per app × profile in
+ * `~/Applications/Agent Switch/`, which a Dock or Spotlight click can start.
+ *
+ * Each launcher is an AppleScript applet (`osacompile`) whose only line runs
+ * this CLI's `open <app> <profile>` — the same isolated start the app menu
+ * uses, including "focus the window it already has". The original app is never
+ * copied, patched or re-signed. A locally built applet carries no quarantine
+ * flag, so Gatekeeper does not prompt; swapping its icon breaks the ad-hoc
+ * seal, which is why the bundle is re-signed ad hoc afterwards.
+ *
+ * Every launcher made is recorded in `launchers.json`, so remove, repair and
+ * uninstall touch exactly those bundles.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { findApp } from "./apps.js";
+import { ROOT } from "./profiles.js";
+const MANIFEST = path.join(ROOT, "launchers.json");
+/** macOS-only paths: built with path.posix so they are right on any host. */
+export function launchersDir(home = os.homedir()) {
+    return path.posix.join(home, "Applications", "Agent Switch");
+}
+export function launcherPath(app, profile, home = os.homedir()) {
+    return path.posix.join(launchersDir(home), `${app.displayName} – ${profile}.app`);
+}
+function asLiteral(s) {
+    return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+/** The applet's single line: run `<node> <index.js> open <app> <profile>`,
+ *  carrying a custom AGENT_SWITCH_HOME — a Dock start has none in its env. */
+export function appleScriptFor(node, index, appId, profile, home) {
+    const env = home ? `"AGENT_SWITCH_HOME=" & quoted form of ${asLiteral(home)} & " " & ` : "";
+    return (`do shell script ${env}quoted form of ${asLiteral(node)} & " " & quoted form of ${asLiteral(index)}` +
+        ` & " open " & quoted form of ${asLiteral(appId)} & " " & quoted form of ${asLiteral(profile)}`);
+}
+/** A brew/installer `bin/node` symlink that resolves to the running node — it
+ *  survives an upgrade, the versioned path behind it does not. */
+export function stableNode(execPath, candidates = ["/opt/homebrew/bin/node", "/usr/local/bin/node"], realpath = (p) => fs.realpathSync(p)) {
+    let running;
+    try {
+        running = realpath(execPath);
+    }
+    catch {
+        return execPath;
+    }
+    for (const c of candidates) {
+        try {
+            if (realpath(c) === running)
+                return c;
+        }
+        catch {
+            /* not installed there */
+        }
+    }
+    return execPath;
+}
+/** The main (non-helper) process started with exactly this `--user-data-dir`. */
+export function findMainPid(psOutput, userDataDir) {
+    const flag = `--user-data-dir=${userDataDir}`;
+    for (const line of psOutput.split("\n")) {
+        const m = line.match(/^\s*(\d+)\s+(.*)$/);
+        if (!m)
+            continue;
+        const args = m[2];
+        const at = args.indexOf(flag);
+        if (at < 0 || args.includes("--type="))
+            continue;
+        const next = args[at + flag.length];
+        if (next === undefined || next === " ")
+            return Number(m[1]);
+    }
+    return null;
+}
+/** Brings an already running profile instance to the front. False = none runs
+ *  (or it could not be activated), so the caller starts one. */
+export function findRunning(userDataDir) {
+    if (process.platform !== "darwin")
+        return null;
+    const ps = spawnSync("ps", ["-axo", "pid=,args="], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+    return ps.status === 0 ? findMainPid(ps.stdout, userDataDir) : null;
+}
+export function focusRunning(userDataDir) {
+    const pid = findRunning(userDataDir);
+    if (pid === null)
+        return false;
+    // NSRunningApplication.activate needs no Accessibility/Automation permission.
+    const js = `ObjC.import('AppKit'); const a = $.NSRunningApplication.runningApplicationWithProcessIdentifier(${pid}); a.isNil() ? 'no' : (a.activateWithOptions($.NSApplicationActivateAllWindows) ? 'yes' : 'no')`;
+    const r = spawnSync("osascript", ["-l", "JavaScript", "-e", js], { encoding: "utf8" });
+    return r.status === 0 && r.stdout.trim() === "yes";
+}
+export function upsertEntry(entries, e) {
+    return [...withoutEntry(entries, e.app, e.profile), e];
+}
+export function withoutEntry(entries, app, profile) {
+    return entries.filter((x) => !(x.app === app && x.profile === profile));
+}
+export function entriesFor(entries, provider, profile) {
+    return entries.filter((x) => x.provider === provider && x.profile === profile);
+}
+export function readLaunchers() {
+    try {
+        const raw = JSON.parse(fs.readFileSync(MANIFEST, "utf8"));
+        return Array.isArray(raw) ? raw.filter((x) => x && typeof x.app === "string" && typeof x.profile === "string" && typeof x.path === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeLaunchers(entries) {
+    fs.mkdirSync(ROOT, { recursive: true });
+    fs.writeFileSync(MANIFEST, JSON.stringify(entries, null, 2) + "\n", { mode: 0o600 });
+}
+/** Where the app is installed (first Spotlight hit), or null. */
+export function appBundlePath(app) {
+    const r = spawnSync("mdfind", [`kMDItemCFBundleIdentifier == '${app.bundleId}'`], { encoding: "utf8" });
+    const hit = r.status === 0 ? r.stdout.split("\n").find((l) => l.endsWith(".app")) : undefined;
+    return hit ?? null;
+}
+function appIcon(bundle) {
+    const r = spawnSync("plutil", ["-extract", "CFBundleIconFile", "raw", path.join(bundle, "Contents", "Info.plist")], { encoding: "utf8" });
+    if (r.status !== 0)
+        return null;
+    const name = r.stdout.trim();
+    const file = path.join(bundle, "Contents", "Resources", name.endsWith(".icns") ? name : `${name}.icns`);
+    return fs.existsSync(file) ? file : null;
+}
+/** This CLI as the launcher should call it: a stable node + this index.js. */
+function cliInvocation() {
+    return { node: stableNode(process.execPath), index: path.join(path.dirname(fileURLToPath(import.meta.url)), "index.js") };
+}
+function run(cmd, args) {
+    const r = spawnSync(cmd, args, { encoding: "utf8" });
+    if (r.status !== 0)
+        throw new Error(`${cmd} failed: ${(r.stderr || r.stdout).trim()}`);
+}
+/** Builds (or rebuilds) the launcher for app × profile and records it. */
+export function createLauncher(app, profile) {
+    if (process.platform !== "darwin")
+        throw new Error("launchers are macOS-only for now.");
+    const bundle = appBundlePath(app);
+    if (!bundle)
+        throw new Error(`${app.displayName} is not installed.`);
+    const target = launcherPath(app, profile);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    // Built next to the target, then swapped in: a failed build leaves the old one.
+    // The name must end in .app, or osacompile writes a bare script, not a bundle.
+    const tmp = path.join(path.dirname(target), `.${path.basename(target, ".app")}.building.app`);
+    fs.rmSync(tmp, { recursive: true, force: true });
+    try {
+        const { node, index } = cliInvocation();
+        run("osacompile", ["-o", tmp, "-e", appleScriptFor(node, index, app.id, profile, process.env.AGENT_SWITCH_HOME)]);
+        const icon = appIcon(bundle);
+        if (icon) {
+            // The applet's asset catalog would win over applet.icns and show a blank icon.
+            fs.rmSync(path.join(tmp, "Contents", "Resources", "Assets.car"), { force: true });
+            fs.copyFileSync(icon, path.join(tmp, "Contents", "Resources", "applet.icns"));
+        }
+        run("codesign", ["--force", "--sign", "-", tmp]);
+        fs.rmSync(target, { recursive: true, force: true });
+        fs.renameSync(tmp, target);
+    }
+    finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+    const entry = { app: app.id, provider: app.provider, profile, path: target };
+    writeLaunchers(upsertEntry(readLaunchers(), entry));
+    return entry;
+}
+/** Removes a recorded launcher; a path the manifest doesn't list is never deleted. */
+export function removeLauncher(appId, profile) {
+    const entries = readLaunchers();
+    const hit = entries.find((x) => x.app === appId && x.profile === profile);
+    if (!hit)
+        return false;
+    fs.rmSync(hit.path, { recursive: true, force: true });
+    writeLaunchers(withoutEntry(entries, appId, profile));
+    return true;
+}
+export function removeLaunchersFor(provider, profile) {
+    const mine = entriesFor(readLaunchers(), provider, profile);
+    for (const e of mine)
+        removeLauncher(e.app, e.profile);
+    return mine.length;
+}
+/** A renamed profile's launchers are rebuilt under the new name (best effort:
+ *  one that can't be rebuilt is removed rather than left pointing at nothing). */
+export function renameLaunchersFor(provider, from, to) {
+    for (const e of entriesFor(readLaunchers(), provider, from)) {
+        removeLauncher(e.app, e.profile);
+        const app = findApp(e.app);
+        if (!app)
+            continue;
+        try {
+            createLauncher(app, to);
+        }
+        catch {
+            /* app gone — nothing to rebuild */
+        }
+    }
+}
+/** Rebuilds every recorded launcher — after a move of this CLI or a node upgrade. */
+export function repairLaunchers() {
+    const rebuilt = [];
+    const failed = [];
+    for (const e of readLaunchers()) {
+        const app = findApp(e.app);
+        try {
+            if (!app)
+                throw new Error(`unknown app ${e.app}`);
+            rebuilt.push(createLauncher(app, e.profile));
+        }
+        catch (err) {
+            failed.push({ entry: e, reason: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    return { rebuilt, failed };
+}
+export function removeAllLaunchers() {
+    const entries = readLaunchers();
+    for (const e of entries)
+        fs.rmSync(e.path, { recursive: true, force: true });
+    writeLaunchers([]);
+    return entries.length;
+}

package/dist/locks.js

@@ -87,3 +87,64 @@ export async function withProperLock(target, fn, timeoutMs = DEFAULT_TIMEOUT_MS)
         }
     }
 }
+/**
+ * Synchronous twin of {@link withProperLock} for agent-switch's own small
+ * stores (pools, protection): one read-modify-write at a time across every
+ * CLI and GUI process, so two writers cannot drop each other's change. Same
+ * directory-lock protocol and staleness rule; short waits block the thread
+ * (the critical section is a JSON read and write).
+ */
+export function withFileLockSync(target, fn, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const lockDir = lockDirFor(target);
+    const deadline = Date.now() + timeoutMs;
+    const nap = new Int32Array(new SharedArrayBuffer(4));
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    for (;;) {
+        try {
+            fs.mkdirSync(lockDir);
+            break;
+        }
+        catch (err) {
+            // Windows answers EPERM while another process is removing the lock dir.
+            const busy = err?.code === "EEXIST" || (process.platform === "win32" && err?.code === "EPERM");
+            if (!busy)
+                throw err;
+            if (err.code === "EPERM") {
+                if (Date.now() > deadline)
+                    throw err;
+                Atomics.wait(nap, 0, 0, 10);
+                continue;
+            }
+            let stale = false;
+            try {
+                stale = Date.now() - fs.statSync(lockDir).mtimeMs > STALENESS_MS;
+            }
+            catch {
+                continue;
+            }
+            if (stale) {
+                try {
+                    fs.rmdirSync(lockDir);
+                }
+                catch {
+                    /* raced with another taker — loop */
+                }
+                continue;
+            }
+            if (Date.now() > deadline)
+                throw new Error(`timed out waiting for the lock at ${lockDir}`);
+            Atomics.wait(nap, 0, 0, 10 + Math.floor(Math.random() * 15));
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            fs.rmdirSync(lockDir);
+        }
+        catch {
+            /* already gone */
+        }
+    }
+}

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,157 @@
+/**
+ * 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 { withFileLockSync } from "./locks.js";
+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()) {
+    return withFileLockSync(file, () => {
+        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) {
+    return withFileLockSync(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) {
+    return withFileLockSync(file, () => {
+        const pools = readPools(file);
+        mustFind(pools, id);
+        save(pools.filter((p) => p.id !== id), file);
+    });
+}
+export function addPoolMember(id, member, file = POOLS_FILE) {
+    return withFileLockSync(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) {
+    return withFileLockSync(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) {
+    return withFileLockSync(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;
+}