tide-commander 1.153.0 → 1.154.0

package/dist/src/packages/server/runtime/codex-runner-router.js

@@ -0,0 +1,99 @@
+/**
+ * CodexRunnerRouter
+ *
+ * Codex agents can run two ways: the default per-turn `codex exec` runner (the
+ * ClaudeRunner shell driving a CodexBackend), or the experimental persistent
+ * `codex app-server` runner that streams word-by-word agent-message deltas.
+ * Which one a NEW launch uses is decided per-run from the LIVE setting
+ * (isCodexAppServerModeEnabled) — no server restart needed to switch, mirroring
+ * ClaudeRunnerRouter's headless/interactive split.
+ *
+ * The router owns one instance of each runner and delegates the RuntimeRunner
+ * surface to whichever currently owns the agent (live thread/process wins over
+ * the setting), tearing the other down on a mode switch so one agent never has
+ * two live backends.
+ */
+import { ClaudeRunner } from '../claude/runner.js';
+import { CodexBackend } from '../codex/backend.js';
+import { CodexAppServerRunner } from '../codex/app-server/codex-app-server-runner.js';
+import { isCodexAppServerModeEnabled } from '../services/system-prompt-service.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('CodexRouter');
+export class CodexRunnerRouter {
+    exec;
+    appServer;
+    owner = new Map();
+    constructor(callbacks) {
+        this.exec = new ClaudeRunner(callbacks, new CodexBackend());
+        this.appServer = new CodexAppServerRunner(callbacks);
+    }
+    currentMode() {
+        return isCodexAppServerModeEnabled() ? 'app-server' : 'exec';
+    }
+    runnerFor(mode) {
+        return mode === 'app-server' ? this.appServer : this.exec;
+    }
+    ownerOf(agentId) {
+        if (this.appServer.isRunning(agentId))
+            return 'app-server';
+        if (this.exec.isRunning(agentId))
+            return 'exec';
+        return this.owner.get(agentId);
+    }
+    ownerRunner(agentId) {
+        return this.runnerFor(this.ownerOf(agentId) ?? this.currentMode());
+    }
+    start() {
+        this.exec.start?.();
+        this.appServer.start?.();
+    }
+    async run(request) {
+        const mode = this.currentMode();
+        const prev = this.ownerOf(request.agentId);
+        if (prev && prev !== mode) {
+            log.log(`Agent ${request.agentId.slice(0, 8)} switching ${prev} → ${mode}; stopping old runner first`);
+            await this.runnerFor(prev).stop(request.agentId, false);
+        }
+        this.owner.set(request.agentId, mode);
+        return this.runnerFor(mode).run(request);
+    }
+    sendMessage(agentId, message) {
+        return this.ownerRunner(agentId).sendMessage(agentId, message);
+    }
+    async stop(agentId, clearQueue) {
+        await this.exec.stop(agentId, clearQueue);
+        await this.appServer.stop(agentId, clearQueue);
+        this.owner.delete(agentId);
+    }
+    async stopAll(killProcesses, clearQueue) {
+        await this.exec.stopAll(killProcesses, clearQueue);
+        await this.appServer.stopAll(killProcesses, clearQueue);
+        this.owner.clear();
+    }
+    isRunning(agentId) {
+        return this.exec.isRunning(agentId) || this.appServer.isRunning(agentId);
+    }
+    hasRecentActivity(agentId, withinMs) {
+        return this.ownerRunner(agentId).hasRecentActivity(agentId, withinMs);
+    }
+    onNextActivity(agentId, callback) {
+        this.ownerRunner(agentId).onNextActivity(agentId, callback);
+    }
+    supportsStdin() {
+        return true;
+    }
+    closesStdinAfterPrompt() {
+        // Mode-dependent: exec closes stdin per turn, app-server keeps it open. The
+        // caller uses this to decide queue-vs-write; report per current owner so the
+        // right delivery path is chosen for the agent that's actually running.
+        return this.currentMode() === 'exec';
+    }
+    getTurnState(agentId) {
+        return this.ownerRunner(agentId).getTurnState?.(agentId);
+    }
+    getActiveProcessesState() {
+        const execState = this.exec.getActiveProcessesState().map((p) => ({ agentId: p.agentId, pid: p.pid }));
+        const appState = this.appServer.getActiveProcessesState();
+        return [...execState, ...appState];
+    }
+}

package/dist/src/packages/server/runtime/codex-runtime-provider.js

@@ -1,9 +1,11 @@
-import { ClaudeRunner } from '../claude/runner.js';
-import { CodexBackend } from '../codex/backend.js';
+import { CodexRunnerRouter } from './codex-runner-router.js';
 class CodexRuntimeProvider {
     name = 'codex';
     createRunner(callbacks) {
-        return new ClaudeRunner(callbacks, new CodexBackend());
+        // The router picks per-launch between the default `codex exec` runner and
+        // the experimental persistent `codex app-server` runner (streaming), driven
+        // by the live isCodexAppServerModeEnabled() setting.
+        return new CodexRunnerRouter(callbacks);
     }
 }
 export function createCodexRuntimeProvider() {

package/dist/src/packages/server/services/claude-credentials-service.js

@@ -14,7 +14,7 @@ import * as os from 'os';
 import * as path from 'path';
 import * as crypto from 'crypto';
 import { createLogger } from '../utils/logger.js';
-import { resetClaudeRateLimitCache } from './claude-usage-service.js';
+import { fetchClaudeRateLimitsForToken, resetClaudeRateLimitCache, } from './claude-usage-service.js';
 const log = createLogger('ClaudeCredentials');
 const CLAUDE_DIR = path.join(os.homedir(), '.claude');
 const ACTIVE_FILE = '.credentials.json';
@@ -157,6 +157,213 @@ export function listClaudeCredentialProfiles() {
     });
     return { claudeDir: dir, active, profiles };
 }
+// The Claude Code CLI's public OAuth client (PKCE, no secret) — same values
+// the CLI itself uses to refresh ~/.claude/.credentials.json.
+const OAUTH_TOKEN_URL = 'https://console.anthropic.com/v1/oauth/token';
+const OAUTH_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
+const OAUTH_REFRESH_TIMEOUT_MS = 10_000;
+const GRANT_USAGE_TTL_OK_MS = 2 * 60 * 1000;
+const GRANT_USAGE_TTL_ERR_MS = 45 * 1000;
+// After a failed refresh, leave the grant alone for a while — retrying a
+// rotated/invalid refresh token can trip reuse detection and revoke the grant.
+const GRANT_REFRESH_FAIL_COOLDOWN_MS = 30 * 60 * 1000;
+const grantUsageCache = new Map();
+const grantUsageInFlight = new Map();
+export function resetClaudeProfileUsageCacheForTests() {
+    grantUsageCache.clear();
+    grantUsageInFlight.clear();
+}
+/** Read the OAuth tokens from a credentials file (they never leave the server). */
+function readProfileTokens(filePath) {
+    try {
+        const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        const oauth = data?.claudeAiOauth;
+        return {
+            accessToken: typeof oauth?.accessToken === 'string' && oauth.accessToken ? oauth.accessToken : null,
+            expiresAt: typeof oauth?.expiresAt === 'number' ? oauth.expiresAt : null,
+            refreshToken: typeof oauth?.refreshToken === 'string' && oauth.refreshToken ? oauth.refreshToken : null,
+            refreshTokenExpiresAt: typeof oauth?.refreshTokenExpiresAt === 'number' ? oauth.refreshTokenExpiresAt : null,
+        };
+    }
+    catch {
+        return { accessToken: null, expiresAt: null, refreshToken: null, refreshTokenExpiresAt: null };
+    }
+}
+/** Refresh an OAuth grant the way the CLI does. Returns tokens or an error string. */
+async function refreshOAuthGrant(refreshToken) {
+    try {
+        const response = await fetch(OAUTH_TOKEN_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                grant_type: 'refresh_token',
+                refresh_token: refreshToken,
+                client_id: OAUTH_CLIENT_ID,
+            }),
+            signal: AbortSignal.timeout(OAUTH_REFRESH_TIMEOUT_MS),
+        });
+        if (!response.ok) {
+            return { error: `Token refresh failed (${response.status}) — sign in to this account again` };
+        }
+        const body = await response.json();
+        const accessToken = typeof body.access_token === 'string' ? body.access_token : '';
+        if (!accessToken)
+            return { error: 'Token refresh returned no access token' };
+        const expiresIn = typeof body.expires_in === 'number' ? body.expires_in : 3600;
+        return {
+            accessToken,
+            refreshToken: typeof body.refresh_token === 'string' && body.refresh_token ? body.refresh_token : null,
+            expiresAt: Date.now() + expiresIn * 1000,
+        };
+    }
+    catch (err) {
+        const reason = err?.name === 'TimeoutError' ? 'request timed out' : (err?.message ?? 'request failed');
+        return { error: `Could not reach the OAuth token endpoint (${reason})` };
+    }
+}
+/** Write refreshed tokens into a credentials file, preserving everything else. */
+function writeRefreshedTokens(filePath, refreshed) {
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    const oauth = (data.claudeAiOauth ?? {});
+    oauth.accessToken = refreshed.accessToken;
+    oauth.expiresAt = refreshed.expiresAt;
+    if (refreshed.refreshToken)
+        oauth.refreshToken = refreshed.refreshToken;
+    data.claudeAiOauth = oauth;
+    writeCredentialsAtomic(filePath, JSON.stringify(data));
+}
+function grantCacheKey(token) {
+    return crypto.createHash('sha256').update(token).digest('hex').slice(0, 12);
+}
+/**
+ * Fetch (refreshing first when needed and allowed) the gauges for one grant.
+ * Cached per grant so repeated listings don't hammer Anthropic.
+ */
+function fetchUsageForGrant(cacheKey, group) {
+    const cached = grantUsageCache.get(cacheKey);
+    if (cached && Date.now() < cached.validUntil)
+        return Promise.resolve(cached);
+    const inFlight = grantUsageInFlight.get(cacheKey);
+    if (inFlight)
+        return inFlight;
+    const promise = (async () => {
+        const now = Date.now();
+        const { tokens } = group;
+        let accessToken = tokens.accessToken;
+        let error = null;
+        const accessExpired = typeof tokens.expiresAt === 'number' && tokens.expiresAt <= now;
+        if (accessExpired) {
+            if (group.includesActive) {
+                // The CLI owns the active grant; it refreshes on its next session.
+                accessToken = null;
+                error = 'Token expired — start any Claude session to refresh it';
+            }
+            else if (!tokens.refreshToken) {
+                accessToken = null;
+                error = 'Token expired and no refresh token stored — sign in to this account again';
+            }
+            else if (typeof tokens.refreshTokenExpiresAt === 'number' && tokens.refreshTokenExpiresAt <= now) {
+                accessToken = null;
+                error = 'Session expired — sign in to this account again';
+            }
+            else {
+                const refreshed = await refreshOAuthGrant(tokens.refreshToken);
+                if ('error' in refreshed) {
+                    accessToken = null;
+                    error = refreshed.error;
+                    const entry = {
+                        rateLimits: null,
+                        error,
+                        fetchedAt: Date.now(),
+                        validUntil: Date.now() + GRANT_REFRESH_FAIL_COOLDOWN_MS,
+                    };
+                    grantUsageCache.set(cacheKey, entry);
+                    return entry;
+                }
+                for (const filePath of group.paths) {
+                    try {
+                        writeRefreshedTokens(filePath, refreshed);
+                    }
+                    catch (err) {
+                        log.warn(`Refreshed grant but failed to persist to ${filePath}: ${err}`);
+                    }
+                }
+                log.log(`Refreshed dormant Claude credentials for profile(s): ${group.ids.join(', ')}`);
+                accessToken = refreshed.accessToken;
+            }
+        }
+        if (!accessToken) {
+            const entry = {
+                rateLimits: null,
+                error: error ?? 'No OAuth token in credentials file',
+                fetchedAt: Date.now(),
+                validUntil: Date.now() + GRANT_USAGE_TTL_ERR_MS,
+            };
+            grantUsageCache.set(cacheKey, entry);
+            return entry;
+        }
+        const result = await fetchClaudeRateLimitsForToken(accessToken);
+        const entry = {
+            rateLimits: result.rateLimits,
+            error: result.error,
+            fetchedAt: Date.now(),
+            validUntil: Date.now() + (result.error ? GRANT_USAGE_TTL_ERR_MS : GRANT_USAGE_TTL_OK_MS),
+        };
+        grantUsageCache.set(cacheKey, entry);
+        return entry;
+    })().finally(() => grantUsageInFlight.delete(cacheKey));
+    grantUsageInFlight.set(cacheKey, promise);
+    return promise;
+}
+/**
+ * Session (5h) + weekly rate-limit gauges for every stored credential profile,
+ * keyed by profile id ("active" or name). Dormant grants are refreshed first
+ * (once per grant, tokens persisted back to every copy) so limits stay visible
+ * for accounts that haven't run in days.
+ */
+export async function getClaudeCredentialProfilesUsage() {
+    const list = listClaudeCredentialProfiles();
+    const candidates = [...(list.active ? [list.active] : []), ...list.profiles];
+    // Group profiles by grant: same refresh token (or same access token when a
+    // file has no refresh token) = same login, refreshed and fetched once.
+    const groups = new Map();
+    const usage = [];
+    for (const meta of candidates) {
+        if (!meta.valid) {
+            usage.push({ id: meta.id, rateLimits: null, error: 'Invalid credentials file', fetchedAt: Date.now() });
+            continue;
+        }
+        const tokens = readProfileTokens(meta.path);
+        const grantToken = tokens.refreshToken ?? tokens.accessToken;
+        if (!grantToken) {
+            usage.push({ id: meta.id, rateLimits: null, error: 'No OAuth token in credentials file', fetchedAt: Date.now() });
+            continue;
+        }
+        const key = grantCacheKey(grantToken);
+        const existing = groups.get(key);
+        if (existing) {
+            existing.ids.push(meta.id);
+            if (!existing.paths.includes(meta.path))
+                existing.paths.push(meta.path);
+            existing.includesActive = existing.includesActive || meta.id === 'active';
+            // Prefer a non-expired access token from any copy of the grant.
+            const expired = typeof existing.tokens.expiresAt === 'number' && existing.tokens.expiresAt <= Date.now();
+            if (expired && tokens.accessToken && (tokens.expiresAt ?? 0) > Date.now()) {
+                existing.tokens = tokens;
+            }
+        }
+        else {
+            groups.set(key, { ids: [meta.id], paths: [meta.path], includesActive: meta.id === 'active', tokens });
+        }
+    }
+    await Promise.all(Array.from(groups.entries()).map(async ([key, group]) => {
+        const entry = await fetchUsageForGrant(key, group);
+        for (const id of group.ids) {
+            usage.push({ id, rateLimits: entry.rateLimits, error: entry.error, fetchedAt: entry.fetchedAt });
+        }
+    }));
+    return { usage };
+}
 function assertValidName(name) {
     if (!isValidProfileName(name)) {
         throw new Error(`Invalid profile name "${name}". Use 1–64 chars: letters, digits, dot, underscore, hyphen; must start with alphanumeric.`);

package/dist/src/packages/server/services/claude-usage-service.js

@@ -304,35 +304,12 @@ function parseRetryAfterMs(headerValue) {
     return undefined;
 }
 /**
- * Fetch the live session/weekly rate-limit gauges — the data behind the
- * progress bars in the CLI's `/usage` panel — using the OAuth token the CLI
- * keeps in `~/.claude/.credentials.json`. Returns the gauges or an error
- * string (never throws); the caller folds either into the snapshot.
- *
- * This is the RAW network call. Go through `getClaudeRateLimits()` instead —
- * it caches, dedupes, and rate-limits calls to this so we don't hammer (and get
- * 429'd by) the Anthropic endpoint.
+ * Fetch the `/usage` gauges for an arbitrary Claude OAuth access token.
+ * RAW network call, no caching — exported for the multi-account switcher,
+ * which shows each stored profile's session/weekly limits and does its own
+ * per-fingerprint caching (claude-credentials-service).
  */
-async function fetchClaudeRateLimitsFromApi() {
-    let accessToken;
-    try {
-        if (!fs.existsSync(CREDENTIALS_PATH)) {
-            return { rateLimits: null, error: 'No Claude CLI credentials found' };
-        }
-        const credentials = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, 'utf-8'));
-        const oauth = credentials?.claudeAiOauth;
-        if (!oauth || typeof oauth.accessToken !== 'string' || oauth.accessToken === '') {
-            return { rateLimits: null, error: 'Claude CLI credentials are missing an OAuth token' };
-        }
-        if (typeof oauth.expiresAt === 'number' && oauth.expiresAt <= Date.now()) {
-            return { rateLimits: null, error: 'Claude CLI OAuth token has expired — run any Claude session to refresh it' };
-        }
-        accessToken = oauth.accessToken;
-    }
-    catch (err) {
-        log.warn(`Failed to read Claude credentials at ${CREDENTIALS_PATH}: ${err}`);
-        return { rateLimits: null, error: 'Failed to read Claude CLI credentials' };
-    }
+export async function fetchClaudeRateLimitsForToken(accessToken) {
     try {
         const response = await fetch(OAUTH_USAGE_URL, {
             headers: {
@@ -368,6 +345,36 @@ async function fetchClaudeRateLimitsFromApi() {
         return { rateLimits: null, error: `Could not reach Anthropic usage endpoint (${reason})` };
     }
 }
+/**
+ * Fetch the live session/weekly rate-limit gauges — the data behind the
+ * progress bars in the CLI's `/usage` panel — using the OAuth token the CLI
+ * keeps in `~/.claude/.credentials.json`. Returns the gauges or an error
+ * string (never throws); the caller folds either into the snapshot.
+ *
+ * This is the RAW network call. Go through `getClaudeRateLimits()` instead —
+ * it caches, dedupes, and rate-limits calls to this so we don't hammer (and get
+ * 429'd by) the Anthropic endpoint.
+ */
+async function fetchClaudeRateLimitsFromApi() {
+    try {
+        if (!fs.existsSync(CREDENTIALS_PATH)) {
+            return { rateLimits: null, error: 'No Claude CLI credentials found' };
+        }
+        const credentials = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, 'utf-8'));
+        const oauth = credentials?.claudeAiOauth;
+        if (!oauth || typeof oauth.accessToken !== 'string' || oauth.accessToken === '') {
+            return { rateLimits: null, error: 'Claude CLI credentials are missing an OAuth token' };
+        }
+        if (typeof oauth.expiresAt === 'number' && oauth.expiresAt <= Date.now()) {
+            return { rateLimits: null, error: 'Claude CLI OAuth token has expired — run any Claude session to refresh it' };
+        }
+        return await fetchClaudeRateLimitsForToken(oauth.accessToken);
+    }
+    catch (err) {
+        log.warn(`Failed to read Claude credentials at ${CREDENTIALS_PATH}: ${err}`);
+        return { rateLimits: null, error: 'Failed to read Claude CLI credentials' };
+    }
+}
 // Account-wide, so a single cache line serves every agent/client. Never keyed.
 let rateLimitCache = null;
 // Last successful gauges, kept so we can serve them (stale) while backing off —