@bridge4dev/runner 0.65.0 → 0.66.0

package/dist/commit-message.js

@@ -1,6 +1,7 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { assertClaudeInstalled, claudeExecutableOption } from './agent-binary.js';
 import { scrubbedEnv } from './adapters/claude.js';
+import { activeAccountHome, withAccountHome } from './claude-homes.js';
 import { gitBranchDiff } from './gitops.js';
 import { isSecretPath, maskString } from './policy.js';
 /**
@@ -160,7 +161,9 @@ export async function proposeCommitMessage(input, queryFn = query) {
             prompt: buildPrompt(input, diff),
             options: {
                 cwd: input.worktreePath,
-                env: scrubbedEnv(),
+                // The machine's active account (#422), with the same rule as a session:
+                // its home, and no operator token above it.
+                env: withAccountHome(scrubbedEnv(), activeAccountHome()),
                 // The second place Claude `Options` are built. It must follow the same
                 // constant, or after C3 commit messages would still be written by the
                 // bundled binary while sessions had moved to the system one.

package/dist/config.d.ts

@@ -15,12 +15,12 @@ declare const ConfigSchema: z.ZodObject<{
         name: z.ZodString;
         token: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        name: string;
         id: string;
+        name: string;
         token: string;
     }, {
-        name: string;
         id: string;
+        name: string;
         token: string;
     }>;
     mcp: z.ZodOptional<z.ZodObject<{
@@ -179,10 +179,13 @@ declare const ConfigSchema: z.ZodObject<{
         ws_url: string;
     };
     server: {
-        name: string;
         id: string;
+        name: string;
         token: string;
     };
+    codex?: {
+        auth: "link" | "own";
+    } | undefined;
     checkpoints?: {
         enabled: boolean;
     } | undefined;
@@ -190,8 +193,8 @@ declare const ConfigSchema: z.ZodObject<{
         url: string;
         token: string;
     } | undefined;
-    codex?: {
-        auth: "link" | "own";
+    agents?: {
+        install_enabled: boolean;
     } | undefined;
     limits?: {
         max_sessions?: number | undefined;
@@ -204,19 +207,19 @@ declare const ConfigSchema: z.ZodObject<{
     verify?: {
         enabled: boolean;
     } | undefined;
-    agents?: {
-        install_enabled: boolean;
-    } | undefined;
 }, {
     api: {
         url: string;
         ws_url: string;
     };
     server: {
-        name: string;
         id: string;
+        name: string;
         token: string;
     };
+    codex?: {
+        auth?: "link" | "own" | undefined;
+    } | undefined;
     checkpoints?: {
         enabled?: boolean | undefined;
     } | undefined;
@@ -224,8 +227,8 @@ declare const ConfigSchema: z.ZodObject<{
         url: string;
         token: string;
     } | undefined;
-    codex?: {
-        auth?: "link" | "own" | undefined;
+    agents?: {
+        install_enabled?: boolean | undefined;
     } | undefined;
     limits?: {
         max_sessions?: number | undefined;
@@ -238,9 +241,6 @@ declare const ConfigSchema: z.ZodObject<{
     verify?: {
         enabled?: boolean | undefined;
     } | undefined;
-    agents?: {
-        install_enabled?: boolean | undefined;
-    } | undefined;
 }>;
 export type RunnerConfig = z.infer<typeof ConfigSchema>;
 export declare function loadConfig(): RunnerConfig | null;

package/dist/daemon-exit.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The one way out of the daemon process (#431).
+ *
+ * Its own module, and not four lines inside `cmdDaemon`, for one reason: the
+ * defect this ticket is about WAS those four lines. `supervisor.shutdown();
+ * ws.stop(); process.exit(0);` in a single tick killed one process per session
+ * and left everything that process had started running inside a cgroup systemd
+ * would then refuse to reuse by name. Nothing in the suite could see that,
+ * because no test in this package imports `index.ts` — found by the independent
+ * review of #431, which also pointed out that the next edit to that file would
+ * be just as invisible.
+ *
+ * So the order is code with a test on it rather than a comment:
+ *
+ *  1. **`shutdown()`** — its synchronous half runs before it returns: the cards
+ *     a person was still being asked are withdrawn, the line saying what this
+ *     restart costs goes into the journal, the agents are killed.
+ *  2. **the socket is closed** — after the events above needed it open, and
+ *     before the wait below, which must not be a window in which an `event_ack`
+ *     or a `session_start` reaches a supervisor that has let go of everything.
+ *  3. **the promise is awaited** — the cages, and nothing else. What does not
+ *     finish inside the supervisor's own budget continues on systemd's side:
+ *     the stop has been accepted by then.
+ *  4. **`exit`**, always — including when the wait ends in a rejection. A
+ *     daemon that would not die because a bus call failed is worse than one
+ *     that leaves a scope behind.
+ */
+export interface DaemonExitDeps {
+    /** The supervisor's shutdown. The synchronous half must run before it returns. */
+    shutdown: () => Promise<void>;
+    /** Close the socket, both directions. */
+    stopWs: () => void;
+    /** Write the status file, so `doctor` sees a daemon that is going down. */
+    noteStatus?: () => void;
+    /** End the process. Injected so the order above can be proved. */
+    exit: (code: number) => void;
+}
+/** Build the exit door. The returned function is safe to call more than once. */
+export declare function daemonExit(deps: DaemonExitDeps): (code: number) => void;
+//# sourceMappingURL=daemon-exit.d.ts.map

package/dist/daemon-exit.js

@@ -0,0 +1,29 @@
+import { log } from './log.js';
+/** Build the exit door. The returned function is safe to call more than once. */
+export function daemonExit(deps) {
+    let leaving = false;
+    return (code) => {
+        /**
+         * A second signal does not shorten the first departure.
+         *
+         * Two `SIGTERM`s, or «Update runner» racing a restart command, used to run
+         * the whole thing twice: a second `verify.shutdown()` signalling a group
+         * that is already dying, and an `exit` from the second call cutting the
+         * first call's wait for its cages — the very wait this door exists for.
+         */
+        if (leaving) {
+            log.warn('daemon: already leaving, this second request changes nothing', { code });
+            return;
+        }
+        leaving = true;
+        const cages = deps.shutdown();
+        deps.stopWs();
+        deps.noteStatus?.();
+        void cages
+            .catch((error) => {
+            log.warn('daemon: the cages did not all stop cleanly', { error: String(error) });
+        })
+            .finally(() => deps.exit(code));
+    };
+}
+//# sourceMappingURL=daemon-exit.js.map

package/dist/index.js

@@ -15,6 +15,9 @@ import { loadConfig, mergeIntoPairedConfig, requireConfig, saveConfig, } from '.
 import { log } from './log.js';
 import { installIsWritable, installPrefixFor, isSupervisedProcess, restartCapability, manualUpdateCommand, resolveInstalledPackageDir, } from './self-update.js';
 import { applyStoredClaudeToken } from './agent-auth.js';
+import { discardAbandonedStagingHomes, recoverInterruptedSwaps, refreshAccountIdentity, } from './claude-homes.js';
+import { ACCOUNT_AGENTS, ACCOUNT_COMMANDS } from './account-commands.js';
+import { MACHINE_ACCOUNT_ID } from './login-marks.js';
 import { Supervisor } from './supervisor.js';
 import { readStatusFile, isPidAlive, writeStatusFile, STATUS_FRESH_MS } from './status-file.js';
 import { RunnerWsClient } from './ws-client.js';
@@ -25,6 +28,7 @@ import { buildUnit, cpuQuotaPercent, devbridgeSliceOverridePath, limitsOverrideI
 import { defaultCageProbe, initSessionCage, readSliceLimits, listSessionScopes, sessionCage, sweepOrphanSessionScopes, SESSION_TASKS_MAX, } from './session-cage.js';
 import { SEARCH_GUARD_ENABLED, claudeSettingsPath, installSearchGuard, removeSearchGuard, searchGuardCommand, searchGuardHome, searchGuardHookPath, searchGuardStatus, } from './claude-settings.js';
 import { readOomKills, recordCrash, takeLastExit } from './crash-note.js';
+import { daemonExit } from './daemon-exit.js';
 import { agentAuthStatuses } from './auth-relay.js';
 import { addSafeDirectory, agentConfigContour, dockerCheck, ensureAgentPath, firstUnreachableAncestor, hasSafeDirectory, inspectPath, knownWorkspacePaths, lingerEnabled, nodeCheck, otherHomeWithAgents, runnerIdentity, safeDirectoryCommand, systemctlHint, systemdUserBusReachable, } from './environment.js';
 import { mcpConfigDir } from './paths.js';
@@ -514,6 +518,13 @@ function runnerCapabilities(apiUrlOverride) {
          * `kind: 'oom'` is inferred from the cgroup counter — see `crash-note.ts`.
          */
         ...(LAST_EXIT ? { lastExit: LAST_EXIT } : {}),
+        /**
+         * #422 (R11): the agents this runner keeps several logins for. Static per
+         * version – the LIST of accounts is always asked with `agent_accounts`,
+         * never read from here (a snapshot taken at start, #395). The dashboard
+         * shows the account window only to an agent named here.
+         */
+        accounts: [...ACCOUNT_AGENTS],
         /** Commands beyond the stage-A/B set. */
         commands: [
             'purge_session',
@@ -577,6 +588,10 @@ function runnerCapabilities(apiUrlOverride) {
             // ANSWERS the command, with a sentence saying why — which is a better
             // outcome than a frame nobody replies to.
             'runner_restart',
+            // #422: list, sign in to, switch and forget agent logins (plan §8).
+            // Unconditional: they read and write only the runner's own state, and an
+            // agent they do not serve yet is answered with a sentence.
+            ...ACCOUNT_COMMANDS,
         ],
     };
 }
@@ -954,6 +969,31 @@ async function cmdDaemon() {
     if (applyStoredClaudeToken()) {
         log.info('daemon: using the Claude token stored on this server');
     }
+    /**
+     * #422: a swap of Claude homes the previous daemon died inside is finished or
+     * undone before anything can run under an account; and who the machine login
+     * is gets asked once, in the background (R14 c) – the verdict and the list read
+     * the answer, the minute poll never asks.
+     */
+    try {
+        recoverInterruptedSwaps();
+    }
+    catch (error) {
+        log.warn('daemon: could not finish an interrupted swap of Claude homes', {
+            error: String(error),
+        });
+    }
+    try {
+        // A sign-in the previous daemon accepted but never adopted (S2): nothing can
+        // be adopting before the supervisor exists.
+        discardAbandonedStagingHomes();
+    }
+    catch (error) {
+        log.warn('daemon: could not remove sign-in homes a previous daemon left', {
+            error: String(error),
+        });
+    }
+    void refreshAccountIdentity(MACHINE_ACCOUNT_ID).catch(() => undefined);
     const agents = installedAgents();
     const ws = new RunnerWsClient(config.api.ws_url, config.server.token, runnerCapabilities());
     const codex = agents.includes('codex') ? bootstrapCodex(config) : null;
@@ -1019,11 +1059,7 @@ async function cmdDaemon() {
                 from: outcome.fromVersion,
                 to: outcome.toVersion ?? 'unknown',
             });
-            const timer = setTimeout(() => {
-                supervisor.shutdown();
-                ws.stop();
-                process.exit(0);
-            }, RESTART_DELAY_MS);
+            const timer = setTimeout(() => leave(0), RESTART_DELAY_MS);
             timer.unref();
         },
         // #396: the same exit, asked for directly rather than as the tail of an
@@ -1035,11 +1071,7 @@ async function cmdDaemon() {
                 sessions: supervisor.activeSessionIds.length,
                 told: Boolean(note),
             });
-            const timer = setTimeout(() => {
-                supervisor.shutdown();
-                ws.stop();
-                process.exit(0);
-            }, RESTART_DELAY_MS);
+            const timer = setTimeout(() => leave(0), RESTART_DELAY_MS);
             timer.unref();
         },
     });
@@ -1052,13 +1084,21 @@ async function cmdDaemon() {
         activeSessionIds: supervisor.activeSessionIds,
         updatedAt: new Date().toISOString(),
     });
+    /**
+     * The one way out of this process — the order lives in `daemon-exit.ts`,
+     * where a test can hold it (#431).
+     */
+    const leave = daemonExit({
+        shutdown: () => supervisor.shutdown(),
+        stopWs: () => ws.stop(),
+        noteStatus: updateStatus,
+        exit: (code) => process.exit(code),
+    });
     ws.on('open', updateStatus);
     ws.on('close', updateStatus);
     ws.on('revoked', (reason) => {
         log.error(`daemon: access revoked (${reason}) — exiting`);
-        supervisor.shutdown();
-        updateStatus();
-        process.exit(3);
+        leave(3);
     });
     const statusTimer = setInterval(updateStatus, 30_000);
     statusTimer.unref();
@@ -1072,10 +1112,7 @@ async function cmdDaemon() {
     limitsTimer.unref();
     const shutdown = (signal) => {
         log.info(`daemon: ${signal} received, shutting down`);
-        supervisor.shutdown();
-        ws.stop();
-        updateStatus();
-        process.exit(0);
+        leave(0);
     };
     process.on('SIGINT', () => shutdown('SIGINT'));
     process.on('SIGTERM', () => shutdown('SIGTERM'));
@@ -1381,6 +1418,15 @@ async function runnerChecks() {
     });
     return checks;
 }
+/** « · account <email> (saved)» – nothing for the machine login nobody named. */
+function accountLine(account) {
+    if (!account)
+        return '';
+    if (account.id === MACHINE_ACCOUNT_ID) {
+        return account.email ? ` · machine login ${account.email}` : '';
+    }
+    return ` · saved account ${account.email ?? account.id}`;
+}
 async function agentChecks() {
     const me = runnerIdentity();
     // The probes log a verdict line each, which belongs in the journal, not in
@@ -1442,8 +1488,12 @@ async function agentChecks() {
         checks.push({
             ok: signedIn,
             name: `${agent} login`,
+            // Which account the verdict is about (#422): the same rule as the panel,
+            // read from the same file, so doctor and the dashboard cannot answer about
+            // two different logins on one machine.
             detail: (info.detail ?? info.status) +
-                (info.expiresAt ? ` · until ${formatLocalDay(info.expiresAt)}` : ''),
+                (info.expiresAt ? ` · until ${formatLocalDay(info.expiresAt)}` : '') +
+                accountLine(info.activeAccount),
             ...(signedIn
                 ? {}
                 : {

package/dist/login-marks.d.ts

@@ -0,0 +1,31 @@
+import type { RelayAgentName } from './agent-registry.js';
+/**
+ * What the agent actually experienced with a sign-in — per agent AND per account.
+ *
+ * The credentials file cannot tell us the provider revoked a login: the refresh
+ * token still sits there, dated. The one authority on that is a real refusal
+ * from a real run — so a session that failed to authenticate demotes the file's
+ * verdict for a while, and any successful turn clears it again.
+ *
+ * Moved out of `auth-relay.ts` for #422 and keyed by account as well as agent.
+ * With several Claude logins on one machine «Claude was refused» stopped being
+ * a statement about anything: the session that was refused ran under ONE
+ * account, and the machine may have been switched to another since. The mark
+ * belongs to the account the session started under (R14) – which is why both
+ * the account list (`claude-homes.ts`) and the panel verdict (`auth-relay.ts`)
+ * read it from here rather than each keeping a copy.
+ *
+ * Process memory on purpose: no protocol, no disk. The consequence is worth
+ * naming — restarting the daemon forgets the refusal and the panel goes back
+ * to trusting the file until the next session tries. (A saved account also
+ * carries a mark on disk, D2 – see `markLoginExpired` in `claude-homes.ts`.)
+ */
+/** The machine's own login – the one row every agent has. */
+export declare const MACHINE_ACCOUNT_ID = "machine";
+/** A session under this agent and account was just refused. */
+export declare function noteRefusal(agent: RelayAgentName, accountId?: string): void;
+/** The sign-in worked again. Answers whether a refusal was being held. */
+export declare function clearRefusal(agent: RelayAgentName, accountId?: string): boolean;
+/** Is a refusal still being held against this agent and account? */
+export declare function refusalActive(agent: RelayAgentName, accountId?: string): boolean;
+//# sourceMappingURL=login-marks.d.ts.map

package/dist/login-marks.js

@@ -0,0 +1,47 @@
+/**
+ * What the agent actually experienced with a sign-in — per agent AND per account.
+ *
+ * The credentials file cannot tell us the provider revoked a login: the refresh
+ * token still sits there, dated. The one authority on that is a real refusal
+ * from a real run — so a session that failed to authenticate demotes the file's
+ * verdict for a while, and any successful turn clears it again.
+ *
+ * Moved out of `auth-relay.ts` for #422 and keyed by account as well as agent.
+ * With several Claude logins on one machine «Claude was refused» stopped being
+ * a statement about anything: the session that was refused ran under ONE
+ * account, and the machine may have been switched to another since. The mark
+ * belongs to the account the session started under (R14) – which is why both
+ * the account list (`claude-homes.ts`) and the panel verdict (`auth-relay.ts`)
+ * read it from here rather than each keeping a copy.
+ *
+ * Process memory on purpose: no protocol, no disk. The consequence is worth
+ * naming — restarting the daemon forgets the refusal and the panel goes back
+ * to trusting the file until the next session tries. (A saved account also
+ * carries a mark on disk, D2 – see `markLoginExpired` in `claude-homes.ts`.)
+ */
+/** The machine's own login – the one row every agent has. */
+export const MACHINE_ACCOUNT_ID = 'machine';
+const AUTH_FAILURE_TTL_MS = 15 * 60_000;
+const refusals = new Map();
+const keyOf = (agent, accountId) => `${agent}:${accountId}`;
+/** A session under this agent and account was just refused. */
+export function noteRefusal(agent, accountId = MACHINE_ACCOUNT_ID) {
+    refusals.set(keyOf(agent, accountId), Date.now());
+}
+/** The sign-in worked again. Answers whether a refusal was being held. */
+export function clearRefusal(agent, accountId = MACHINE_ACCOUNT_ID) {
+    return refusals.delete(keyOf(agent, accountId));
+}
+/** Is a refusal still being held against this agent and account? */
+export function refusalActive(agent, accountId = MACHINE_ACCOUNT_ID) {
+    const key = keyOf(agent, accountId);
+    const at = refusals.get(key);
+    if (at === undefined)
+        return false;
+    if (Date.now() - at > AUTH_FAILURE_TTL_MS) {
+        refusals.delete(key);
+        return false;
+    }
+    return true;
+}
+//# sourceMappingURL=login-marks.js.map