@bridge4dev/runner 0.22.1 → 0.27.0

package/dist/agent-auth.d.ts

@@ -0,0 +1,29 @@
+export declare function agentAuthPath(): string;
+/** The token we hold for Claude, or null once it is too old to trust. */
+export declare function storedClaudeToken(): string | null;
+export declare function storeClaudeToken(token: string): void;
+export declare function clearStoredClaudeToken(): void;
+/**
+ * Put a stored token into this process's environment, unless the operator
+ * already set one.
+ *
+ * Their variable wins on purpose: an explicitly exported
+ * `CLAUDE_CODE_OAUTH_TOKEN` in the unit or in `environment.d` is a deliberate
+ * choice, and silently overriding it with something we captured months ago is
+ * the kind of surprise this file exists to prevent.
+ *
+ * Returns true when it applied one.
+ */
+export declare function applyStoredClaudeToken(): boolean;
+/**
+ * The OAuth token `claude setup-token` printed, reassembled out of pty output.
+ *
+ * Written against how the output actually arrives rather than how it looks in a
+ * terminal: the pty wraps at its width, so a ~100-character token is routinely
+ * split across lines. Continuation lines are joined only while they consist
+ * ENTIRELY of token characters — prose ("Store this token securely") contains
+ * spaces or punctuation and stops the join, which is what keeps the reassembly
+ * from swallowing the sentence after it.
+ */
+export declare function extractOauthToken(text: string): string | null;
+//# sourceMappingURL=agent-auth.d.ts.map

package/dist/agent-auth.js

@@ -0,0 +1,136 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { configDir } from './paths.js';
+/**
+ * A Claude login this runner owns, for the one CLI that cannot store one.
+ *
+ * Background, because this file only makes sense with it. The dashboard's
+ * sign-in button relays a real OAuth flow to the machine — and until 0.27.0 it
+ * relayed `claude setup-token`, which is not a login at all. Measured against
+ * the 2.1.220 binary and confirmed by Anthropic's own docs: `setup-token` mints
+ * a long-lived INFERENCE-ONLY token, prints it, and «does not save the token
+ * anywhere». The runner threw the printed token away, then judged the login by
+ * reading `~/.claude/.credentials.json` — a file that command never writes. So
+ * the flow completed, the panel re-probed within a second, and answered «No
+ * Claude login on this server» underneath a success screen. That is the bug
+ * behind every «I signed in and it still says signed out».
+ *
+ * The main path is now `claude auth login`, which persists properly and needs
+ * nothing from this module. This exists for the fallback: a CLI old enough not
+ * to have `auth login` still has `setup-token`, and rather than leave that
+ * machine with no way in, we capture the token it prints and keep it ourselves.
+ * `CLAUDE_CODE_OAUTH_TOKEN` is already on the session env allowlist, so a stored
+ * token reaches the agent exactly like an operator-configured one.
+ *
+ * Stored on the machine, 0600, in the runner's own config directory. DevBridge
+ * never receives it: the token travels from the provider into a pty on this
+ * host and onto this host's disk.
+ */
+const FILE_MODE = 0o600;
+export function agentAuthPath() {
+    return path.join(configDir(), 'agent-auth.json');
+}
+/**
+ * How long a captured token is believed without further evidence.
+ *
+ * `claude setup-token` mints a one-year credential and there is no way to ask
+ * whether it is still good without spending a request. A stored token that
+ * never ages out is a green light nobody can turn off: the panel would keep
+ * saying «signed in» about a revoked account for as long as the file exists.
+ * Eleven months keeps it inside the token's own life while still expiring.
+ */
+const TOKEN_MAX_AGE_MS = 334 * 24 * 60 * 60 * 1000;
+function read() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(agentAuthPath(), 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+/** The token we hold for Claude, or null once it is too old to trust. */
+export function storedClaudeToken() {
+    const file = read();
+    const value = file.claudeOauthToken;
+    if (typeof value !== 'string' || value.length === 0)
+        return null;
+    const stamped = typeof file.updatedAt === 'string' ? Date.parse(file.updatedAt) : NaN;
+    if (Number.isFinite(stamped) && Date.now() - stamped > TOKEN_MAX_AGE_MS)
+        return null;
+    return value;
+}
+export function storeClaudeToken(token) {
+    const dir = configDir();
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const file = agentAuthPath();
+    // Same write-then-rename as the config: a torn file here reads as «signed
+    // out» and sends somebody through the whole login again.
+    const tmp = path.join(dir, `.agent-auth.${process.pid}.tmp`);
+    fs.writeFileSync(tmp, `${JSON.stringify({ claudeOauthToken: token, updatedAt: new Date().toISOString() }, null, 2)}\n`, { mode: FILE_MODE });
+    fs.renameSync(tmp, file);
+    fs.chmodSync(file, FILE_MODE);
+}
+export function clearStoredClaudeToken() {
+    try {
+        fs.rmSync(agentAuthPath(), { force: true });
+    }
+    catch {
+        /* nothing to clear */
+    }
+}
+/**
+ * Put a stored token into this process's environment, unless the operator
+ * already set one.
+ *
+ * Their variable wins on purpose: an explicitly exported
+ * `CLAUDE_CODE_OAUTH_TOKEN` in the unit or in `environment.d` is a deliberate
+ * choice, and silently overriding it with something we captured months ago is
+ * the kind of surprise this file exists to prevent.
+ *
+ * Returns true when it applied one.
+ */
+export function applyStoredClaudeToken() {
+    if (process.env['CLAUDE_CODE_OAUTH_TOKEN'])
+        return false;
+    const token = storedClaudeToken();
+    if (!token)
+        return false;
+    process.env['CLAUDE_CODE_OAUTH_TOKEN'] = token;
+    return true;
+}
+/**
+ * The OAuth token `claude setup-token` printed, reassembled out of pty output.
+ *
+ * Written against how the output actually arrives rather than how it looks in a
+ * terminal: the pty wraps at its width, so a ~100-character token is routinely
+ * split across lines. Continuation lines are joined only while they consist
+ * ENTIRELY of token characters — prose ("Store this token securely") contains
+ * spaces or punctuation and stops the join, which is what keeps the reassembly
+ * from swallowing the sentence after it.
+ */
+export function extractOauthToken(text) {
+    const lines = text.split('\n').map((line) => line.trim());
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        const start = line.match(/sk-ant-oat[0-9]*-[A-Za-z0-9_-]*$/);
+        // The token must run to the end of its line; anything after it on the same
+        // line means this is prose mentioning a token, not the token itself.
+        if (!start)
+            continue;
+        let token = start[0];
+        for (let j = i + 1; j < lines.length; j++) {
+            const next = lines[j] ?? '';
+            if (!/^[A-Za-z0-9_-]+$/.test(next))
+                break;
+            token += next;
+        }
+        // Long enough to be real, short enough not to be a runaway join.
+        if (token.length >= 40 && token.length <= 400)
+            return token;
+    }
+    return null;
+}
+//# sourceMappingURL=agent-auth.js.map

package/dist/auth-relay.d.ts

@@ -24,26 +24,84 @@ export interface AgentAuthStatus {
     expiresAt?: string;
     detail?: string;
 }
+/**
+ * Rejoin a secret the pty split across lines, so the masker can see it.
+ *
+ * `maskString` matches `sk-ant-[A-Za-z0-9_-]{8,}`, which a line break inside
+ * the token defeats — and the pty wraps at its width, so a ~100-character
+ * token arrives in pieces as a matter of course. Measured: the head gets
+ * masked and the tail is printed verbatim into an error detail that travels to
+ * the dashboard. Rejoining first costs nothing and closes it.
+ */
+export declare function rejoinWrappedSecrets(text: string): string;
 /** Strip ANSI/OSC control sequences so text matching sees plain output. */
 export declare function stripControl(raw: string): string;
 export declare function extractLoginUrl(agent: RelayAgent, raw: string): string | null;
 export declare function extractDeviceCode(raw: string): string | null;
+export interface AuthRelayDeps {
+    /**
+     * How we find out whether Claude is signed in, after the CLI says it is.
+     * Injected so a test can exercise the contract without an OAuth provider.
+     */
+    claudeStatus?: () => Promise<AgentAuthStatus>;
+}
 export declare class AuthRelay {
     private readonly commands;
+    private readonly deps;
     private active;
-    constructor(commands?: Record<RelayAgent, string>);
+    constructor(commands?: Record<RelayAgent, string>, deps?: AuthRelayDeps);
     /** Start (or restart) a login flow and wait until the sign-in URL appears. */
     start(agent: RelayAgent): Promise<LoginStartResult>;
+    private startWith;
     /** Paste the confirmation code back into the waiting CLI (Claude flow). */
     submitCode(agent: RelayAgent, code: string): Promise<LoginCodeResult>;
+    /**
+     * The CLI exited 0 — but is the machine actually signed in?
+     *
+     * Asked rather than assumed. Reporting a success the panel then contradicts
+     * one second later is worse than reporting a failure: it sends the person
+     * looking for a permissions problem that does not exist, which is exactly
+     * what happened on axon-prod-01.
+     */
+    private confirmSignedIn;
     cancel(): void;
 }
 /**
- * Claude: the subscription token's expiry is recorded in the CLI's own
- * credentials file. The RUNNER reads it (its own host user's file) — the
- * agent itself is still denied this path by layer-1 policy.
+ * Claude: the subscription login is recorded in the CLI's own credentials file.
+ * The RUNNER reads it (its own host user's file) — the agent itself is still
+ * denied this path by layer-1 policy.
+ *
+ * `expiresAt` is NOT the login. It is the expiry of a short-lived access token
+ * (~8 hours on a live file), and next to it sits `refreshToken` with
+ * `refreshTokenExpiresAt` ~26 days out, which the CLI spends silently on its
+ * next run. Judging the login by `expiresAt` alone is why every server nobody
+ * had touched since the morning reported "login expired — re-login needed"
+ * over a login that was good for another three weeks (#121). Codex has carried
+ * exactly this guard since day one (`readCodexCredential`); Claude did not.
+ *
+ * Deliberately NOT asking the CLI. `claude auth status --json` looks like an
+ * arbiter and is not one: measured live (SDK binary 2.1.218), it answers
+ * `loggedIn: true` for a credential whose access token has expired AND which
+ * carries no refresh token at all — i.e. for a genuinely dead login. It never
+ * leaves the machine, so it cannot see a server-side revocation either. It
+ * would have cost a ~800 ms / ~300 MB subprocess per poll under `MemoryMax=2G`
+ * (gotcha #100) and echoed the account's e-mail and org name to every member of
+ * the organization, in exchange for no truth at all. A revoked login is caught
+ * instead by `noteAgentAuthFailure` below — from a real refusal, not a guess.
  */
 export declare function claudeAuthStatus(homedir?: string): Promise<AgentAuthStatus>;
+/** A session just failed to authenticate as this agent. */
+export declare function noteAgentAuthFailure(agent: RelayAgent): void;
+/** The agent just worked — whatever was wrong with the sign-in is not. */
+export declare function clearAgentAuthFailure(agent: RelayAgent): void;
+/**
+ * Is a refusal still being held against this agent?
+ *
+ * Exported so the wiring in `supervisor.ts` can be pinned by a test without
+ * shelling out to the agent CLIs: this predicate IS the mechanism the panel's
+ * demotion reads, and three unguarded lines were carrying it (QA-117 M6).
+ */
+export declare function agentAuthFailureActive(agent: RelayAgent): boolean;
 /**
  * Codex reports its own login state via an exit code (0 signed in / 1 not).
  * Probed against the RUNNER's home: the host user can be signed in while our