tide-commander 1.152.0 → 1.154.0

package/dist/src/packages/server/routes/system.js

@@ -11,6 +11,8 @@ import { createLogger } from '../utils/logger.js';
 import { fetchLatestNpmVersion, getVersionRelation } from '../../shared/version.js';
 import { endUpdate, getInstallInfo, isAutoUpdateSupported, isUpdateInProgress, runNpmGlobalUpdate, schedulePostUpdateRestart, tryBeginUpdate, } from '../services/self-update-service.js';
 import { getAutoUpdateStatus, setAutoUpdateEnabled } from '../services/auto-update-service.js';
+import { deleteClaudeCredentialProfile, getClaudeCredentialProfilesUsage, listClaudeCredentialProfiles, renameClaudeCredentialProfile, saveActiveClaudeCredentialProfile, switchClaudeCredentialProfile, } from '../services/claude-credentials-service.js';
+import { deleteProviderCredentialProfile, listProviderCredentialProfiles, renameProviderCredentialProfile, saveActiveProviderCredentialProfile, switchProviderCredentialProfile, } from '../services/provider-credentials-service.js';
 const log = createLogger('SystemRoutes');
 const router = Router();
 const PACKAGE_NAME = 'tide-commander';
@@ -130,8 +132,22 @@ function computeWebBundleInfo() {
         .update(indexContent)
         .digest('hex')
         .slice(0, 16);
+    // The version must describe the dist we SERVE, not the live package.json —
+    // package.json moves ahead of the last build (version bumps, dev work), and
+    // advertising a version the bundle doesn't contain sends phones into an
+    // eternal re-sync loop (pull → still "behind" → pull …). build-info.json is
+    // emitted by the vite build; fall back to package.json for older dists.
+    let version = getInstallInfo().currentVersion;
+    try {
+        const buildInfo = JSON.parse(fs.readFileSync(path.join(dir, 'build-info.json'), 'utf8'));
+        if (buildInfo.version)
+            version = buildInfo.version;
+    }
+    catch {
+        /* pre-build-info dist — package.json is the best guess */
+    }
     return {
-        version: getInstallInfo().currentVersion,
+        version,
         hash,
         fileCount: files.length,
         totalBytes: files.reduce((sum, f) => sum + f.size, 0),
@@ -397,4 +413,203 @@ router.post('/auto-update', (req, res) => {
     log.log(`Auto-update ${enabled ? 'enabled' : 'disabled'} via API`);
     res.json(setAutoUpdateEnabled(enabled));
 });
+/**
+ * Claude CLI OAuth credential profiles (~/.claude/.credentials.json and
+ * ~/.claude/.credentials.<name>.json). Used to switch the active Claude
+ * account when rate limits are hit without manually renaming files.
+ *
+ * Tokens are never returned — only non-secret metadata + fingerprints.
+ */
+router.get('/claude-credentials', (_req, res) => {
+    try {
+        res.json(listClaudeCredentialProfiles());
+    }
+    catch (err) {
+        const message = err.message;
+        log.error(`Failed to list Claude credentials: ${message}`);
+        res.status(500).json({ error: message });
+    }
+});
+/**
+ * Session (5h) + weekly rate-limit gauges per stored credential profile,
+ * keyed by token fingerprint. Cached server-side; expired dormant tokens are
+ * reported (with last-known gauges when available) instead of fetched.
+ */
+router.get('/claude-credentials/usage', async (_req, res) => {
+    try {
+        res.json(await getClaudeCredentialProfilesUsage());
+    }
+    catch (err) {
+        const message = err.message;
+        log.error(`Failed to fetch Claude credentials usage: ${message}`);
+        res.status(500).json({ error: message });
+    }
+});
+router.post('/claude-credentials/switch', (req, res) => {
+    try {
+        const name = req.body?.name;
+        const stashActiveAs = req.body?.stashActiveAs;
+        if (typeof name !== 'string' || !name.trim()) {
+            res.status(400).json({ error: 'Body must include { name: string }' });
+            return;
+        }
+        if (stashActiveAs !== undefined && typeof stashActiveAs !== 'string') {
+            res.status(400).json({ error: 'stashActiveAs must be a string when provided' });
+            return;
+        }
+        const result = switchClaudeCredentialProfile(name.trim(), {
+            stashActiveAs: typeof stashActiveAs === 'string' ? stashActiveAs.trim() : undefined,
+        });
+        res.json(result);
+    }
+    catch (err) {
+        const message = err.message;
+        log.error(`Failed to switch Claude credentials: ${message}`);
+        const status = /not found|Invalid|required|already exists|cannot be/i.test(message) ? 400 : 500;
+        res.status(status).json({ error: message });
+    }
+});
+router.post('/claude-credentials/save', (req, res) => {
+    try {
+        const name = req.body?.name;
+        const force = Boolean(req.body?.force);
+        if (typeof name !== 'string' || !name.trim()) {
+            res.status(400).json({ error: 'Body must include { name: string }' });
+            return;
+        }
+        res.json(saveActiveClaudeCredentialProfile(name.trim(), { force }));
+    }
+    catch (err) {
+        const message = err.message;
+        log.error(`Failed to save Claude credentials profile: ${message}`);
+        const status = /not found|Invalid|already exists|No valid/i.test(message) ? 400 : 500;
+        res.status(status).json({ error: message });
+    }
+});
+router.post('/claude-credentials/rename', (req, res) => {
+    try {
+        const from = req.body?.from;
+        const to = req.body?.to;
+        if (typeof from !== 'string' || !from.trim() || typeof to !== 'string' || !to.trim()) {
+            res.status(400).json({ error: 'Body must include { from: string, to: string }' });
+            return;
+        }
+        res.json(renameClaudeCredentialProfile(from.trim(), to.trim()));
+    }
+    catch (err) {
+        const message = err.message;
+        log.error(`Failed to rename Claude credentials profile: ${message}`);
+        const status = /not found|Invalid|already exists/i.test(message) ? 400 : 500;
+        res.status(status).json({ error: message });
+    }
+});
+router.delete('/claude-credentials/:name', (req, res) => {
+    try {
+        const name = typeof req.params.name === 'string' ? req.params.name : '';
+        if (!name) {
+            res.status(400).json({ error: 'Profile name required' });
+            return;
+        }
+        res.json(deleteClaudeCredentialProfile(name));
+    }
+    catch (err) {
+        const message = err.message;
+        log.error(`Failed to delete Claude credentials profile: ${message}`);
+        const status = /not found|Invalid/i.test(message) ? 400 : 500;
+        res.status(status).json({ error: message });
+    }
+});
+/**
+ * Grok + Codex OAuth credential profiles — same account-switcher model as
+ * Claude, generalized (~/.grok/auth.json, ~/.codex/auth.json + named copies).
+ * Mounted per provider at /grok-credentials/* and /codex-credentials/*.
+ * Tokens are never returned — only non-secret metadata + fingerprints.
+ */
+function mountProviderCredentialRoutes(provider, basePath) {
+    router.get(basePath, (_req, res) => {
+        try {
+            res.json(listProviderCredentialProfiles(provider));
+        }
+        catch (err) {
+            const message = err.message;
+            log.error(`Failed to list ${provider} credentials: ${message}`);
+            res.status(500).json({ error: message });
+        }
+    });
+    router.post(`${basePath}/switch`, (req, res) => {
+        try {
+            const name = req.body?.name;
+            const stashActiveAs = req.body?.stashActiveAs;
+            if (typeof name !== 'string' || !name.trim()) {
+                res.status(400).json({ error: 'Body must include { name: string }' });
+                return;
+            }
+            if (stashActiveAs !== undefined && typeof stashActiveAs !== 'string') {
+                res.status(400).json({ error: 'stashActiveAs must be a string when provided' });
+                return;
+            }
+            res.json(switchProviderCredentialProfile(provider, name.trim(), {
+                stashActiveAs: typeof stashActiveAs === 'string' ? stashActiveAs.trim() : undefined,
+            }));
+        }
+        catch (err) {
+            const message = err.message;
+            log.error(`Failed to switch ${provider} credentials: ${message}`);
+            const status = /not found|Invalid|required|already exists|cannot be|no valid/i.test(message) ? 400 : 500;
+            res.status(status).json({ error: message });
+        }
+    });
+    router.post(`${basePath}/save`, (req, res) => {
+        try {
+            const name = req.body?.name;
+            const force = Boolean(req.body?.force);
+            if (typeof name !== 'string' || !name.trim()) {
+                res.status(400).json({ error: 'Body must include { name: string }' });
+                return;
+            }
+            res.json(saveActiveProviderCredentialProfile(provider, name.trim(), { force }));
+        }
+        catch (err) {
+            const message = err.message;
+            log.error(`Failed to save ${provider} credentials profile: ${message}`);
+            const status = /not found|Invalid|already exists|No valid/i.test(message) ? 400 : 500;
+            res.status(status).json({ error: message });
+        }
+    });
+    router.post(`${basePath}/rename`, (req, res) => {
+        try {
+            const from = req.body?.from;
+            const to = req.body?.to;
+            if (typeof from !== 'string' || !from.trim() || typeof to !== 'string' || !to.trim()) {
+                res.status(400).json({ error: 'Body must include { from: string, to: string }' });
+                return;
+            }
+            res.json(renameProviderCredentialProfile(provider, from.trim(), to.trim()));
+        }
+        catch (err) {
+            const message = err.message;
+            log.error(`Failed to rename ${provider} credentials profile: ${message}`);
+            const status = /not found|Invalid|already exists/i.test(message) ? 400 : 500;
+            res.status(status).json({ error: message });
+        }
+    });
+    router.delete(`${basePath}/:name`, (req, res) => {
+        try {
+            const name = typeof req.params.name === 'string' ? req.params.name : '';
+            if (!name) {
+                res.status(400).json({ error: 'Profile name required' });
+                return;
+            }
+            res.json(deleteProviderCredentialProfile(provider, name));
+        }
+        catch (err) {
+            const message = err.message;
+            log.error(`Failed to delete ${provider} credentials profile: ${message}`);
+            const status = /not found|Invalid/i.test(message) ? 400 : 500;
+            res.status(status).json({ error: message });
+        }
+    });
+}
+mountProviderCredentialRoutes('grok', '/grok-credentials');
+mountProviderCredentialRoutes('codex', '/codex-credentials');
 export default router;

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() {