@bridge4dev/runner 0.66.0 → 0.68.0

package/dist/supervisor.js

@@ -19,7 +19,7 @@ import { applySession, gitBranches, gitCommit, gitDiff, gitLog, gitPush, gitRefs
 import { fsView } from './fsview.js';
 import { publishFile } from './file-publish.js';
 import { agentAuthStatuses, AuthRelay, clearAgentAuthFailure, noteAgentAuthFailure, } from './auth-relay.js';
-import { isAccountCommand, runAccountCommand } from './account-commands.js';
+import { isAccountCommand, runAccountCommand, } from './account-commands.js';
 import { isSupervisedProcess, selfUpdate } from './self-update.js';
 import { installAgent } from './agent-install.js';
 import { autoUpdateRefusal, claimAgentAutoUpdate } from './agent-auto-update.js';
@@ -3337,7 +3337,11 @@ export class Supervisor {
                 activeMs: Supervisor.spentMs(running),
                 errorMessage: event.errorMessage ?? 'Agent turn failed',
             });
+            return;
         }
+        // The turn is over – so an account switch that arrived while it was running
+        // can be carried out now, without costing that turn (#422 S4.1).
+        this.applyPendingAccountSwitch(running);
     }
     /**
      * Hold a turn that produced nothing, in case it was never a turn (#300).
@@ -3578,6 +3582,93 @@ export class Supervisor {
         }
         running.session.stop('session_parked');
     }
+    /**
+     * Move the sessions running right now onto the account just made active (#422 S4.1).
+     *
+     * A process reads its account ONCE, at its start: `CLAUDE_CONFIG_DIR` for
+     * Claude, the link `codex-home/auth.json` resolves to for Codex. Neither can
+     * be changed under a live process, so «apply to the open sessions» is parking
+     * them – the conversation is kept (`--resume` / `thread/resume`) and the next
+     * message starts a process on the account the machine is now set to.
+     *
+     * A session in the middle of a turn is not killed for this: it is marked and
+     * parked at the end of its turn (`applyPendingAccountSwitch`). Which is why
+     * the answer counts the two separately – the window says so in words.
+     */
+    applyAccountToSessions(agent, accountId, label) {
+        let switched = 0;
+        let pending = 0;
+        for (const running of this.sessions.values()) {
+            if (agentByDbValue(running.descriptor.agent)?.wireKey !== agent)
+                continue;
+            const session = running.session;
+            // Parked already: whatever starts it next reads the active account then.
+            if (!session)
+                continue;
+            // Already there, or an adapter that does not name an account at all – a
+            // switch has nothing to do to it, and a stale mark must not outlive it.
+            if (!session.accountId || session.accountId === accountId) {
+                delete running.accountSwitchPending;
+                continue;
+            }
+            if (this.isParkable(running)) {
+                delete running.accountSwitchPending;
+                this.parkForAccount(running, label);
+                switched += 1;
+            }
+            else {
+                running.accountSwitchPending = { id: accountId, ...(label ? { label } : {}) };
+                pending += 1;
+            }
+        }
+        if (switched || pending) {
+            log.info('supervisor: the account switch reached the open sessions', {
+                agent,
+                account: accountId,
+                switched,
+                pending,
+            });
+        }
+        return { switched, pending };
+    }
+    /**
+     * Park a session because the account under it changed – its own words.
+     *
+     * `quiet`, then a note of its own: «the runner switched to another session»
+     * is simply untrue here, and this is the one thing the person needs to read
+     * to know why their session is waiting for a message (the same reason #126
+     * gave the rewind its own wording).
+     */
+    parkForAccount(running, label) {
+        this.sendEvent(running, 'system_note', {
+            // The word the dashboard reads to tell «parked» from «your turn» (#124) –
+            // the state IS parked; only the reason differs.
+            code: 'session_parked',
+            text: label
+                ? `The agent account on this server was switched to ${label} — send a message and this session carries on under it, with everything above kept.`
+                : 'The agent account on this server was switched — send a message and this session carries on under the new one, with everything above kept.',
+        });
+        this.park(running, { quiet: true });
+    }
+    /**
+     * The turn is over – carry out a switch that arrived while it was running.
+     *
+     * Still not parkable (a card is open, a question is waiting): the mark stays
+     * and the next end of a turn tries again. Nothing here ever kills a turn.
+     */
+    applyPendingAccountSwitch(running) {
+        const wanted = running.accountSwitchPending;
+        if (!wanted)
+            return;
+        if (!running.session || running.session.accountId === wanted.id) {
+            delete running.accountSwitchPending;
+            return;
+        }
+        if (!this.isParkable(running))
+            return;
+        delete running.accountSwitchPending;
+        this.parkForAccount(running, wanted.label);
+    }
     /**
      * The agent is producing output while this runner still says a human is
      * expected — put `lastReported` back to RUNNING (ticket #185).
@@ -7494,7 +7585,11 @@ export class Supervisor {
                     // #422: the five account commands – their own module, one door each
                     // over `claude-homes.ts` (plan §8).
                     if (isAccountCommand(frame.name)) {
-                        return void reply(await runAccountCommand(frame.name, frame.args ?? {}, this.authRelay));
+                        return void reply(
+                        // The fourth argument is «apply to the sessions already running»
+                        // (#422 S4.1): the commands know the accounts, this class knows
+                        // the sessions, so the switch reaches them from here.
+                        await runAccountCommand(frame.name, frame.args ?? {}, this.authRelay, (...args) => this.applyAccountToSessions(...args)));
                     }
                     return void reply({ ok: false, error: `Unknown command` });
             }

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const RUNNER_VERSION = "0.66.0";
+export declare const RUNNER_VERSION = "0.68.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in sync with package.json by the release script (manual for now).
-export const RUNNER_VERSION = '0.66.0';
+export const RUNNER_VERSION = '0.68.0';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bridge4dev/runner",
-  "version": "0.66.0",
+  "version": "0.68.0",
   "description": "DevBridge dev runner — connects a dev server to DevBridge and runs agent sessions (Claude Code / Codex)",
   "homepage": "https://bridge4.dev",
   "license": "MIT",