@modelprofile.com/authswitch 2.2.0 → 3.0.0

package/dist_ts/classes.fileharness.js

@@ -1,4 +1,4 @@
-import { CredentialStore } from './classes.credentialstore.js';
+import { credentialHash, CredentialStore } from './classes.credentialstore.js';
 import { pauseSynchronously } from './helpers.js';
 import { plainText } from './formatting.js';
 /** Shared verified preservation for harnesses with independently replaceable credential slots. */
@@ -61,7 +61,86 @@ export class FileHarness {
             if (accounts.some(other => other.id !== account.id && other.label === account.label))
                 account.details.push(`Account ID: ${account.id}`);
         }
-        return { accounts, saveUnavailableReason: snapshot.unavailable };
+        return { accounts, saveUnavailableReason: snapshot.unavailable, credentialDrift: snapshot.unavailable ? [] : this.credentialDrift(snapshot) };
+    }
+    /**
+     * Credential slots that no longer hold the account the last switch wrote.
+     *
+     * A running harness refreshes its login on its own schedule and writes the result to the same
+     * file, so a switch performed underneath one can be undone minutes later without any error. The
+     * recorded hash detects that the file changed at all; comparing the account distinguishes the
+     * benign case -- the switched-in account rotating its own token -- from the previous login coming
+     * back. Detection is advisory and never turns a read into a failure.
+     */
+    credentialDrift(snapshotArg) {
+        let records;
+        try {
+            records = this.store.switchRecords();
+        }
+        catch {
+            return [];
+        }
+        const drift = [];
+        for (const record of records) {
+            try {
+                const active = snapshotArg.accounts.find(account => account.slotId === record.slotId);
+                if (active && credentialHash(JSON.stringify(active.credential)) === record.credentialHash)
+                    continue;
+                const currentAccountId = active ? this.store.id(active.slotId, active.identity) : null;
+                if (currentAccountId !== null && currentAccountId === record.accountId)
+                    continue;
+                drift.push({
+                    slotId: record.slotId, expectedAccountId: record.accountId, expectedLabel: this.savedLabel(record.accountId),
+                    currentAccountId, currentLabel: active?.label ?? null,
+                    currentIsSaved: currentAccountId !== null && this.savedLabel(currentAccountId) !== null,
+                    switchedAt: record.switchedAt,
+                });
+            }
+            catch { /* One unreadable record must not hide the rest of the state. */ }
+        }
+        return drift;
+    }
+    savedLabel(accountIdArg) {
+        try {
+            return this.store.read(accountIdArg).label;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Instances that keep a replaced or cleared login in memory until they are restarted. */
+    runningCaveat(kindArg) {
+        let count;
+        try {
+            count = this.processes.list().length;
+        }
+        catch {
+            return [`Could not check for running ${this.label} processes. If any are running, restart them: an unrestarted instance can write its previous login back.`];
+        }
+        if (!count)
+            return [];
+        return [`${count} ${this.label} process(es) are still running. They keep the previous login in memory until they are restarted, and a token refresh by one of them can `
+                + `${kindArg === 'replaced' ? 'overwrite the credential file with the previous account' : 'write the cleared login back into the credential file'}. `
+                + `Restart them, then check authswitch ${this.id} active.`];
+    }
+    /**
+     * Record what the credential file holds now, so a later overwrite is detectable.
+     *
+     * The hash is taken from the file after the write, not from the incoming credential, so it is
+     * exactly what a later read computes. A recording failure never invalidates a completed switch.
+     */
+    recordActivation(slotIdArg, accountIdArg) {
+        try {
+            const active = this.snapshot().accounts.find(account => account.slotId === slotIdArg);
+            if (!active || this.store.id(active.slotId, active.identity) !== accountIdArg) {
+                return [`The credential file does not hold the expected account after this operation; check authswitch ${this.id} active.`];
+            }
+            this.store.recordSwitch({ slotId: slotIdArg, accountId: accountIdArg, credentialHash: credentialHash(JSON.stringify(active.credential)) });
+            return [];
+        }
+        catch {
+            return [`The login was written, but this switch could not be recorded for later credential checks.`];
+        }
     }
     readCredential(id) {
         const active = this.snapshot().accounts.find(account => this.store.id(account.slotId, account.identity) === id);
@@ -74,7 +153,6 @@ export class FileHarness {
     /** Backend-only login handoff. Preserve the outgoing credential before replacing its slot. */
     activateCredential(slotId, credential) {
         return this.outcome(() => {
-            this.beforeMutation();
             const target = this.inspect(credential, slotId);
             const snapshot = this.snapshot();
             if (snapshot.unavailable)
@@ -83,7 +161,8 @@ export class FileHarness {
             if (previous)
                 this.store.save(previous);
             this.apply(slotId, previous, target);
-            return `Activated ${plainText(target.label)} (${plainText(slotId)}).`;
+            return [`Activated ${plainText(target.label)} (${plainText(slotId)}).`,
+                ...this.recordActivation(slotId, this.store.id(slotId, target.identity)), ...this.runningCaveat('replaced')];
         });
     }
     resolveAccount(reference) {
@@ -95,7 +174,7 @@ export class FileHarness {
     }
     outcome(action) {
         try {
-            return this.store.locked(() => ({ lines: [action()], problems: [] }));
+            return this.store.locked(() => { const lines = action(); return { lines: Array.isArray(lines) ? lines : [lines], problems: [] }; });
         }
         catch (error) {
             return { lines: [], problems: [error instanceof Error ? error.message : 'Credential operation failed.'] };
@@ -103,9 +182,6 @@ export class FileHarness {
     }
     saveCurrent(options) {
         return this.outcome(() => {
-            // Keeping the login in place only reads the native files, so a running harness is no reason to refuse.
-            if (!options.keepActive)
-                this.beforeMutation();
             const snapshot = this.stableSnapshot();
             if (snapshot.unavailable)
                 throw new Error(snapshot.unavailable);
@@ -114,14 +190,21 @@ export class FileHarness {
                 throw new Error(matches.length ? 'Several logins are active. Select the account or provider to save.' : 'No matching active login to save.');
             const active = matches[0];
             this.store.save(active);
-            if (!options.keepActive)
-                this.apply(active.slotId, active, undefined);
-            return `Saved ${plainText(active.label)} (${plainText(active.slotId)})${options.keepActive ? '; login remains in place.' : `. Start ${this.label} to log in again.`}`;
+            if (options.keepActive)
+                return `Saved ${plainText(active.label)} (${plainText(active.slotId)}); login remains in place.`;
+            this.apply(active.slotId, active, undefined);
+            const cleared = [];
+            try {
+                this.store.clearSwitch(active.slotId);
+            }
+            catch {
+                cleared.push('The login was cleared, but its switch record could not be removed.');
+            }
+            return [`Saved ${plainText(active.label)} (${plainText(active.slotId)}). Start ${this.label} to log in again.`, ...cleared, ...this.runningCaveat('cleared')];
         });
     }
     switchAccount(id) {
         return this.outcome(() => {
-            this.beforeMutation();
             const target = this.saved(this.store.read(id));
             const snapshot = this.snapshot();
             if (snapshot.unavailable)
@@ -130,10 +213,13 @@ export class FileHarness {
             // Refresh the outgoing stash even when this account was already saved.
             if (previous)
                 this.store.save(previous);
-            if (previous?.identity === target.identity)
-                return `${plainText(target.label)} is already active; its latest credential is saved.`;
+            // Re-running a switch for the active account re-arms drift detection against its newest bytes.
+            if (previous?.identity === target.identity) {
+                return [`${plainText(target.label)} is already active; its latest credential is saved.`, ...this.recordActivation(target.slotId, id)];
+            }
             this.apply(target.slotId, previous, target);
-            return `Activated ${plainText(target.label)} (${plainText(target.slotId)}). Start ${this.label} to use it.`;
+            return [`Activated ${plainText(target.label)} (${plainText(target.slotId)}). Start ${this.label} to use it.`,
+                ...this.recordActivation(target.slotId, id), ...this.runningCaveat('replaced')];
         });
     }
     removeAccount(id) {
@@ -149,4 +235,4 @@ export class FileHarness {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.fileharness.js","sourceRoot":"","sources":["../ts/classes.fileharness.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.fileharness.js","sourceRoot":"","sources":["../ts/classes.fileharness.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.harnessprocesses.d.ts

@@ -0,0 +1,62 @@
+import type { IHarnessProcess, IHarnessProcessControl, IHarnessStopOutcome } from './interfaces.harness.js';
+export type THarnessBinary = 'opencode' | 'claude';
+/** A raw same-user process row. The enumerator never filters; identity matching belongs here. */
+export interface IEnumeratedProcess {
+    pid: number;
+    parentPid: number | null;
+    /** Executable name as the platform reports it. Truncated by the platform on Linux. */
+    command: string;
+    /** argv[0] as the process reports it; a native installer may run a version-named file. */
+    executable: string;
+    commandLine: string;
+    startedAt: string | null;
+}
+export interface IHarnessProcessesOptions {
+    /** Same-user process table. Injected by tests and by hosts that own their own inspection. */
+    enumerate?: () => IEnumeratedProcess[];
+    /** Signal delivery, restricted by this class to pids it enumerated itself. */
+    signal?: (pidArg: number, signalArg: 'SIGTERM' | 'SIGKILL') => void;
+    /** Liveness probe for a pid that was signalled. */
+    alive?: (pidArg: number) => boolean;
+    sleep?: (millisecondsArg: number) => Promise<void>;
+    /** Default bounded wait for a graceful stop. Callers may shorten it per operation. */
+    timeoutMs?: number;
+    platform?: NodeJS.Platform;
+    /** This command's own pid, for the ancestor chain that must never be signalled. */
+    selfPid?: number;
+}
+/**
+ * Running instances of one harness binary, and a bounded, consent-driven way to stop them.
+ *
+ * Every signal target is a pid this class enumerated for the current user in this operation, and
+ * the ancestors of the running command are never signalled: stopping the session that invoked
+ * authswitch would kill the switch itself. `SIGKILL` is only ever sent after an explicit force
+ * request, and only to a pid re-verified against a fresh listing, so a recycled pid cannot inherit
+ * a kill meant for the process that already exited.
+ */
+export declare class HarnessProcesses implements IHarnessProcessControl {
+    readonly binary: THarnessBinary;
+    private readonly enumerate;
+    private readonly signal;
+    private readonly alive;
+    private readonly sleep;
+    private readonly platform;
+    private readonly selfPid;
+    private readonly defaultTimeout;
+    constructor(binary: THarnessBinary, optionsArg?: IHarnessProcessesOptions);
+    /** Windows' process list carries no owner, so an enumerated pid cannot be proven to be ours. */
+    get stopUnavailableReason(): string | null;
+    list(): IHarnessProcess[];
+    /** The chain from this command up to init, which owns the terminal this command is running in. */
+    private ancestorPids;
+    stop(processesArg: readonly IHarnessProcess[], optionsArg?: {
+        force?: boolean;
+        timeoutMs?: number;
+    }): Promise<IHarnessStopOutcome>;
+    private deliver;
+    private awaitExit;
+}
+/** Plain-text description of the instances found, for a terminal, a TUI log or a confirmation. */
+export declare const describeHarnessProcesses: (labelArg: string, processesArg: readonly IHarnessProcess[]) => string[];
+/** Plain-text report of what a stop achieved, including every instance that survived it. */
+export declare const describeStopOutcome: (labelArg: string, outcomeArg: IHarnessStopOutcome) => string[];

package/dist_ts/classes.harnessprocesses.js

@@ -0,0 +1,198 @@
+import * as plugins from './plugins.js';
+import { plainText } from './formatting.js';
+/**
+ * How a harness binary is recognised in a process table.
+ *
+ * `comm` is not enough. Claude Code's native installer runs the CLI from a file named after its
+ * version (`~/.local/share/claude/versions/2.1.273`) and its remote agent from
+ * `~/.claude/remote/ccd-cli/<version>`, so the kernel reports a version number as the command name
+ * while argv[0] carries the real identity. Matching argv[0] and its install path finds the
+ * processes that actually hold a login; matching only `comm` finds the launcher and misses every
+ * session. Verified against Claude Code 2.1.260-2.1.273 and OpenCode 1.18.15 on Linux.
+ */
+const executablePatterns = {
+    claude: [/(?:^|[/\\])claude(?:\.exe)?$/i, /[/\\]claude[/\\]versions[/\\][^/\\]+$/, /[/\\]\.claude[/\\]remote[/\\]ccd-cli[/\\][^/\\]+$/],
+    opencode: [/(?:^|[/\\])opencode(?:\.exe)?$/i],
+};
+const MAX_COMMAND_LINE = 200;
+const POSIX_FIELDS = 'pid=,ppid=,uid=,lstart=,comm=,args=';
+/** A bounded read of the current user's process table. Never a pattern-based kill list. */
+const enumeratePosix = () => {
+    const uid = process.getuid();
+    const output = plugins.childProcess.execFileSync('ps', ['-u', String(uid), '-o', POSIX_FIELDS], {
+        encoding: 'utf8', timeout: 5000, maxBuffer: 4 * 1024 * 1024, env: { ...process.env, LC_ALL: 'C' }, windowsHide: true,
+    });
+    const processes = [];
+    for (const line of output.split('\n')) {
+        // pid ppid uid, then the five fixed tokens of lstart, then comm and the full argument vector.
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 9)
+            continue;
+        const [pid, parentPid, owner] = parts.slice(0, 3).map(Number);
+        if (!Number.isInteger(pid) || pid <= 0 || owner !== uid)
+            continue;
+        const started = Date.parse(parts.slice(3, 8).join(' '));
+        const args = parts.slice(9);
+        processes.push({
+            pid, parentPid: Number.isInteger(parentPid) ? parentPid : null, command: parts[8],
+            executable: args[0] ?? parts[8], commandLine: (args.length ? args.join(' ') : parts[8]).slice(0, MAX_COMMAND_LINE),
+            startedAt: Number.isFinite(started) ? new Date(started).toISOString() : null,
+        });
+    }
+    return processes;
+};
+/** Windows reports an image name and a pid, with no owner, parent or start time in this view. */
+const enumerateWindows = () => {
+    const output = plugins.childProcess.execFileSync('tasklist', ['/FO', 'CSV', '/NH'], {
+        encoding: 'utf8', timeout: 5000, maxBuffer: 4 * 1024 * 1024, windowsHide: true,
+    });
+    const processes = [];
+    for (const line of output.split('\n')) {
+        const columns = line.trim().replace(/^"/, '').replace(/"$/, '').split('","');
+        const pid = Number(columns[1]);
+        if (columns.length < 2 || !Number.isInteger(pid) || pid <= 0)
+            continue;
+        processes.push({ pid, parentPid: null, command: columns[0], executable: columns[0], commandLine: columns[0], startedAt: null });
+    }
+    return processes;
+};
+/**
+ * Running instances of one harness binary, and a bounded, consent-driven way to stop them.
+ *
+ * Every signal target is a pid this class enumerated for the current user in this operation, and
+ * the ancestors of the running command are never signalled: stopping the session that invoked
+ * authswitch would kill the switch itself. `SIGKILL` is only ever sent after an explicit force
+ * request, and only to a pid re-verified against a fresh listing, so a recycled pid cannot inherit
+ * a kill meant for the process that already exited.
+ */
+export class HarnessProcesses {
+    binary;
+    enumerate;
+    signal;
+    alive;
+    sleep;
+    platform;
+    selfPid;
+    defaultTimeout;
+    constructor(binary, optionsArg = {}) {
+        this.binary = binary;
+        this.platform = optionsArg.platform ?? process.platform;
+        this.enumerate = optionsArg.enumerate ?? (this.platform === 'win32' ? enumerateWindows : enumeratePosix);
+        this.signal = optionsArg.signal ?? ((pid, signal) => { process.kill(pid, signal); });
+        this.alive = optionsArg.alive ?? (pid => {
+            try {
+                process.kill(pid, 0);
+                return true;
+            }
+            // EPERM means the process exists but is not ours; it is then never a stop target either.
+            catch (error) {
+                return error.code === 'EPERM';
+            }
+        });
+        this.sleep = optionsArg.sleep ?? (milliseconds => new Promise(resolve => { setTimeout(resolve, milliseconds); }));
+        this.selfPid = optionsArg.selfPid ?? process.pid;
+        this.defaultTimeout = optionsArg.timeoutMs ?? 10_000;
+    }
+    /** Windows' process list carries no owner, so an enumerated pid cannot be proven to be ours. */
+    get stopUnavailableReason() {
+        return this.platform === 'win32'
+            ? 'On Windows authswitch lists running instances but does not stop them: the process list does not identify their owner. Close them yourself.'
+            : null;
+    }
+    list() {
+        const table = this.enumerate();
+        const ancestors = this.ancestorPids(table);
+        const patterns = executablePatterns[this.binary];
+        return table
+            .filter(item => patterns.some(pattern => pattern.test(item.executable) || pattern.test(item.command)))
+            .filter(item => item.pid !== this.selfPid)
+            .map(item => ({
+            pid: item.pid, command: plugins.path.basename(item.command), commandLine: plainText(item.commandLine),
+            startedAt: item.startedAt, isAncestor: ancestors.has(item.pid),
+        }))
+            .sort((left, right) => left.pid - right.pid);
+    }
+    /** The chain from this command up to init, which owns the terminal this command is running in. */
+    ancestorPids(tableArg) {
+        const parents = new Map(tableArg.map(item => [item.pid, item.parentPid]));
+        const ancestors = new Set();
+        let current = parents.get(this.selfPid) ?? (this.selfPid === process.pid ? process.ppid : null);
+        // The table is finite and each step moves to a distinct pid, so the walk terminates.
+        while (current !== null && current !== undefined && current > 1 && !ancestors.has(current)) {
+            ancestors.add(current);
+            current = parents.get(current) ?? null;
+        }
+        return ancestors;
+    }
+    async stop(processesArg, optionsArg = {}) {
+        const force = optionsArg.force === true;
+        const timeout = Math.max(0, Math.min(optionsArg.timeoutMs ?? this.defaultTimeout, 120_000));
+        if (this.stopUnavailableReason)
+            return { stopped: [], survivors: [...processesArg], forced: [] };
+        const listed = new Map(this.list().map(item => [item.pid, item]));
+        // Only a pid enumerated in this operation, still present, still not an ancestor, is a target.
+        const targets = processesArg.filter(item => {
+            const current = listed.get(item.pid);
+            return current !== undefined && !current.isAncestor && current.startedAt === item.startedAt;
+        });
+        // Anything the caller passed that is not a valid target is reported, never signalled.
+        const skipped = processesArg.filter(item => !targets.includes(item) && this.alive(item.pid));
+        let remaining = this.deliver(targets, 'SIGTERM');
+        remaining = await this.awaitExit(remaining, timeout);
+        const forced = [];
+        if (force && remaining.length) {
+            // Re-verify against a fresh listing: a pid that exited may already belong to another process.
+            const fresh = new Map(this.list().map(item => [item.pid, item]));
+            const verified = remaining.filter(item => fresh.get(item.pid)?.startedAt === item.startedAt && !fresh.get(item.pid).isAncestor);
+            forced.push(...verified);
+            remaining = [...this.deliver(verified, 'SIGKILL'), ...remaining.filter(item => !verified.includes(item))];
+            remaining = await this.awaitExit(remaining, Math.min(timeout, 2000));
+        }
+        return {
+            stopped: processesArg.filter(item => !remaining.includes(item) && !skipped.includes(item)),
+            survivors: [...remaining, ...skipped],
+            forced,
+        };
+    }
+    deliver(targetsArg, signalArg) {
+        const remaining = [];
+        for (const target of targetsArg) {
+            try {
+                this.signal(target.pid, signalArg);
+                remaining.push(target);
+            }
+            catch (error) {
+                // ESRCH is the process we wanted gone; anything else stays reported as still running.
+                if (error.code !== 'ESRCH')
+                    remaining.push(target);
+            }
+        }
+        return remaining;
+    }
+    async awaitExit(processesArg, timeoutArg) {
+        let remaining = processesArg.filter(item => this.alive(item.pid));
+        const deadline = Date.now() + timeoutArg;
+        while (remaining.length && Date.now() < deadline) {
+            await this.sleep(Math.min(250, Math.max(1, deadline - Date.now())));
+            remaining = remaining.filter(item => this.alive(item.pid));
+        }
+        return remaining;
+    }
+}
+const started = (processArg) => processArg.startedAt === null ? 'start time unavailable' : `started ${processArg.startedAt.replace('T', ' ').slice(0, 16)} UTC`;
+/** Plain-text description of the instances found, for a terminal, a TUI log or a confirmation. */
+export const describeHarnessProcesses = (labelArg, processesArg) => [
+    `${processesArg.length} ${plainText(labelArg)} process(es) are running:`,
+    ...processesArg.map(item => `  pid ${item.pid}  ${started(item)}  ${item.commandLine}`
+        + (item.isAncestor ? '  [runs this command; it is never stopped from inside itself]' : '')),
+];
+/** Plain-text report of what a stop achieved, including every instance that survived it. */
+export const describeStopOutcome = (labelArg, outcomeArg) => {
+    const lines = [];
+    if (outcomeArg.stopped.length)
+        lines.push(`Stopped ${outcomeArg.stopped.length} ${plainText(labelArg)} process(es)${outcomeArg.forced.length ? `, ${outcomeArg.forced.length} of them with SIGKILL` : ''}.`);
+    for (const survivor of outcomeArg.survivors)
+        lines.push(`pid ${survivor.pid} did not exit and is still running: ${survivor.commandLine}`);
+    return lines;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.harnessprocesses.js","sourceRoot":"","sources":["../ts/classes.harnessprocesses.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.limits.d.ts

@@ -0,0 +1,24 @@
+import * as plugins from './plugins.js';
+import type { IAccountList, IAccountLimits, IActiveAccounts } from './interfaces.list.js';
+/**
+ * One row per account and limit type, projected from the account list.
+ *
+ * Nothing here talks to a provider: the list is already the read-only, per-account-isolated lookup,
+ * so a single failing account costs its own rows a number and nothing else.
+ */
+export declare const accountLimits: (listArg: IAccountList) => IAccountLimits;
+/**
+ * One row per active credential slot.
+ *
+ * A harness with no active login still gets a row: "nothing is active here" is an answer, and
+ * silently dropping the provider would read as "this provider does not exist".
+ */
+export declare const activeAccounts: (listArg: IAccountList) => IActiveAccounts;
+/** Condensed presentation for `authswitch limits` and `authswitch active`. */
+export declare class CondensedRenderer {
+    private readonly out;
+    constructor(out: plugins.smartconsole.SmartConsole);
+    private notes;
+    renderLimits(limitsArg: IAccountLimits): Promise<void>;
+    renderActive(activeArg: IActiveAccounts): Promise<void>;
+}