@leo000001/opencode-quota-sidebar 4.1.0 → 4.1.1

package/dist/cli.d.ts

@@ -12,6 +12,12 @@ type CliServerCommand = {
     shell?: boolean;
 };
 type SpawnedCliServerProcess = ReturnType<typeof spawn>;
+type CliPortResolver = (preferredPort: number, attemptedPorts: ReadonlySet<number>) => Promise<number>;
+type StartedCliServer = {
+    url: string;
+    pid?: number;
+    close: () => void;
+};
 export declare function releaseCliServerProcess(proc: {
     stdin?: {
         destroy: () => void;
@@ -45,12 +51,24 @@ export declare function terminateCliServerProcess(proc: {
 export declare function extractCliServerUrl(output: string): string | undefined;
 export declare function parseCliArgs(argv: string[]): CliCommand;
 export declare function cliBaseUrl(): string;
-export declare function cliServerCommandCandidates(platform?: NodeJS.Platform): CliServerCommand[];
+export declare function cliServerCommandCandidates(platform?: NodeJS.Platform, port?: number): CliServerCommand[];
+export declare function isCliServerPortConflictFailure(failure: unknown): boolean;
+export declare function registerCliShutdownCleanup(cleanup: () => void, options?: {
+    targetProcess?: NodeJS.Process;
+    killProcess?: typeof process.kill;
+}): () => void;
+export declare function reserveCliServerPort(preferredPort?: number, attemptedPorts?: ReadonlySet<number>): Promise<number>;
 export declare function closeCliServerProcess(proc: SpawnedCliServerProcess, platform?: NodeJS.Platform, killProcess?: typeof process.kill, spawnProcess?: typeof spawn): void;
-export declare function tryStartCliOpencodeServer(candidate: CliServerCommand, spawnProcess?: typeof spawn, closeProcess?: typeof closeCliServerProcess): Promise<{
-    url: string;
-    close: () => void;
-}>;
+export declare function tryStartCliOpencodeServer(candidate: CliServerCommand, spawnProcess?: typeof spawn, closeProcess?: typeof closeCliServerProcess): Promise<StartedCliServer>;
+export declare function spawnCliServerWatchdog(targetPid: number | undefined, ttlMs?: number, spawnProcess?: typeof spawn, nodeExecPath?: string): import("child_process").ChildProcess | undefined;
+export declare function startCliOpencodeServer(options?: {
+    platform?: NodeJS.Platform;
+    spawnProcess?: typeof spawn;
+    spawnWatchdogProcess?: typeof spawn;
+    closeProcess?: typeof closeCliServerProcess;
+    reservePort?: CliPortResolver;
+    tempServerTtlMs?: number;
+}): Promise<StartedCliServer>;
 export declare function runCli(argv: string[]): Promise<string>;
 export declare function cliExitCodeForError(message: string): 0 | 1;
 export declare function cliShouldRunMain(argv1?: string, modulePath?: string, resolvePath?: (filePath: string) => string): boolean;

package/dist/cli.js

@@ -2,6 +2,7 @@
 import { realpathSync } from 'node:fs';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
+import { createServer } from 'node:net';
 import { fileURLToPath } from 'node:url';
 import { createOpencodeClient } from '@opencode-ai/sdk/client';
 import { cliCurrentLabel, renderCliDashboard, renderCliHistoryDashboard, } from './cli_render.js';
@@ -38,8 +39,16 @@ function strictFilterHistoryProviders(history, allowedProviderIDs) {
     return filterHistoryProvidersForDisplay(history, allowedProviderIDs);
 }
 const DEFAULT_OPENCODE_BASE_URL = 'http://localhost:4096';
-const CLI_SERVER_TIMEOUT_MS = 10_000;
+const DEFAULT_OPENCODE_HOST = '127.0.0.1';
+const DEFAULT_OPENCODE_PORT = 4096;
+const CLI_SERVER_TIMEOUT_MS = 60_000;
 const CLI_FORCE_EXIT_DELAY_MS = 100;
+const CLI_SERVER_PORT_RETRY_LIMIT = 5;
+const CLI_PORT_RESERVE_RETRY_LIMIT = 16;
+const CLI_TEMP_SERVER_TTL_MS = 10 * 60_000;
+const CLI_TEMP_SERVER_HINT = 'CLI note: if the temporary OpenCode server keeps failing, run `opencode serve` manually to inspect logs, or set `OPENCODE_BASE_URL`.';
+const CLI_SHUTDOWN_HOOK_KEY = Symbol('quota-sidebar.cliShutdownHook');
+const CLI_SHUTDOWN_CALLBACKS_KEY = Symbol('quota-sidebar.cliShutdownCallbacks');
 export function releaseCliServerProcess(proc) {
     // The CLI only needs the child pipes until the server prints its listen URL.
     // After that, unref/destroy them so the parent process can exit cleanly.
@@ -174,24 +183,158 @@ export function cliBaseUrl() {
 function isDefaultBaseUrl() {
     return !process.env.OPENCODE_BASE_URL?.trim();
 }
-export function cliServerCommandCandidates(platform = process.platform) {
-    const directArgs = ['serve', '--hostname=127.0.0.1', '--port=4096'];
+export function cliServerCommandCandidates(platform = process.platform, port = DEFAULT_OPENCODE_PORT) {
+    const directArgs = [
+        'serve',
+        `--hostname=${DEFAULT_OPENCODE_HOST}`,
+        `--port=${port}`,
+    ];
+    const directCommand = `opencode serve --hostname=${DEFAULT_OPENCODE_HOST} --port=${port}`;
     if (platform === 'win32') {
         return [
             { command: 'opencode.cmd', args: directArgs },
             {
-                command: 'opencode serve --hostname=127.0.0.1 --port=4096',
+                command: directCommand,
                 args: [],
                 shell: true,
             },
             {
                 command: 'bash',
-                args: ['-lc', 'opencode serve --hostname=127.0.0.1 --port=4096'],
+                args: ['-lc', directCommand],
             },
         ];
     }
     return [{ command: 'opencode', args: directArgs }];
 }
+function cliServerFailureOutput(failure) {
+    if (typeof failure !== 'object' ||
+        failure === null ||
+        !('output' in failure)) {
+        return '';
+    }
+    const output = failure.output;
+    return typeof output === 'string' ? output : '';
+}
+function cliServerFailureError(failure) {
+    if (typeof failure === 'object' && failure !== null && 'error' in failure) {
+        const error = failure.error;
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    return failure instanceof Error ? failure : new Error(String(failure));
+}
+function isRecoverableCliServerFailure(failure) {
+    return (typeof failure === 'object' &&
+        failure !== null &&
+        'recoverable' in failure &&
+        failure.recoverable === true);
+}
+export function isCliServerPortConflictFailure(failure) {
+    const text = [
+        cliServerFailureError(failure).message,
+        cliServerFailureOutput(failure),
+    ]
+        .filter(Boolean)
+        .join('\n');
+    return /eaddrinuse|address already in use|port .*already in use|listen .*in use/i.test(text);
+}
+function describeCliError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function formatCliTempServerFailure(prefix, error) {
+    return `${prefix}: ${describeCliError(error)}\n\n${CLI_TEMP_SERVER_HINT}`;
+}
+function runCliShutdownCallbacks(targetProcess) {
+    const callbacks = targetProcess[CLI_SHUTDOWN_CALLBACKS_KEY];
+    if (!callbacks)
+        return;
+    for (const callback of Array.from(callbacks)) {
+        try {
+            callback();
+        }
+        catch {
+            // Best-effort cleanup for CLI temp servers.
+        }
+    }
+}
+export function registerCliShutdownCleanup(cleanup, options) {
+    const targetProcess = options?.targetProcess ||
+        process;
+    const callbacks = targetProcess[CLI_SHUTDOWN_CALLBACKS_KEY] ||
+        (targetProcess[CLI_SHUTDOWN_CALLBACKS_KEY] = new Set());
+    callbacks.add(cleanup);
+    if (!targetProcess[CLI_SHUTDOWN_HOOK_KEY]) {
+        targetProcess[CLI_SHUTDOWN_HOOK_KEY] = true;
+        targetProcess.once('exit', () => {
+            runCliShutdownCallbacks(targetProcess);
+        });
+        targetProcess.once('uncaughtExceptionMonitor', () => {
+            runCliShutdownCallbacks(targetProcess);
+        });
+        for (const signal of ['SIGINT', 'SIGTERM']) {
+            targetProcess.once(signal, () => {
+                runCliShutdownCallbacks(targetProcess);
+                if (typeof targetProcess.pid === 'number' && targetProcess.pid > 0) {
+                    ;
+                    (options?.killProcess ?? process.kill)(targetProcess.pid, signal);
+                }
+            });
+        }
+    }
+    return () => {
+        callbacks.delete(cleanup);
+    };
+}
+function tryReserveCliServerPort(port) {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        let settled = false;
+        const finish = (value, error) => {
+            if (settled)
+                return;
+            settled = true;
+            server.removeAllListeners();
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(value);
+        };
+        server.once('error', (error) => {
+            const code = error.code;
+            if (code === 'EADDRINUSE' || code === 'EACCES') {
+                finish(undefined);
+                return;
+            }
+            finish(undefined, error);
+        });
+        server.listen({ host: DEFAULT_OPENCODE_HOST, port, exclusive: true }, () => {
+            const address = server.address();
+            const resolvedPort = typeof address === 'object' && address ? address.port : port;
+            server.close((error) => {
+                if (error) {
+                    finish(undefined, error);
+                    return;
+                }
+                finish(resolvedPort);
+            });
+        });
+        server.unref();
+    });
+}
+export async function reserveCliServerPort(preferredPort = DEFAULT_OPENCODE_PORT, attemptedPorts = new Set()) {
+    if (!attemptedPorts.has(preferredPort)) {
+        const preferred = await tryReserveCliServerPort(preferredPort);
+        if (preferred !== undefined)
+            return preferred;
+    }
+    for (let attempt = 0; attempt < CLI_PORT_RESERVE_RETRY_LIMIT; attempt++) {
+        const fallback = await tryReserveCliServerPort(0);
+        if (fallback === undefined || attemptedPorts.has(fallback))
+            continue;
+        return fallback;
+    }
+    throw new Error('Failed to reserve a local port for the temporary OpenCode server');
+}
 function releaseCliServerPipes(proc, inspect, onError, onExit) {
     if (inspect) {
         proc.stdout?.removeListener('data', inspect);
@@ -307,35 +450,97 @@ export async function tryStartCliOpencodeServer(candidate, spawnProcess = spawn,
     });
     return {
         url,
+        pid: proc.pid,
         close: () => closeProcess(proc),
     };
 }
-async function startCliOpencodeServer() {
-    const candidates = cliServerCommandCandidates();
+export function spawnCliServerWatchdog(targetPid, ttlMs = CLI_TEMP_SERVER_TTL_MS, spawnProcess = spawn, nodeExecPath = process.execPath) {
+    if (typeof targetPid !== 'number' ||
+        targetPid <= 0 ||
+        !Number.isFinite(ttlMs) ||
+        ttlMs <= 0) {
+        return undefined;
+    }
+    const script = [
+        "const { spawn } = require('node:child_process')",
+        `const pid = ${JSON.stringify(targetPid)}`,
+        `const ttl = ${JSON.stringify(Math.floor(ttlMs))}`,
+        'setTimeout(() => {',
+        "  if (process.platform === 'win32') {",
+        "    const killer = spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true })",
+        '    killer.unref?.()',
+        '    process.exit(0)',
+        '  }',
+        '  try {',
+        "    process.kill(-pid, 'SIGTERM')",
+        '  } catch (error) {',
+        "    if (!error || (typeof error === 'object' && error !== null && error.code !== 'ESRCH')) {",
+        "      try { process.kill(pid, 'SIGTERM') } catch {}",
+        '    }',
+        '  }',
+        '  process.exit(0)',
+        '}, ttl)',
+    ].join('\n');
+    const proc = spawnProcess(nodeExecPath, ['-e', script], {
+        stdio: 'ignore',
+        detached: true,
+        windowsHide: true,
+    });
+    proc.unref();
+    return proc;
+}
+export async function startCliOpencodeServer(options) {
+    const platform = options?.platform ?? process.platform;
+    const spawnProcess = options?.spawnProcess ?? spawn;
+    const spawnWatchdogProcess = options?.spawnWatchdogProcess ?? spawn;
+    const closeProcess = options?.closeProcess ?? closeCliServerProcess;
+    const resolvePort = options?.reservePort ?? reserveCliServerPort;
+    const tempServerTtlMs = options?.tempServerTtlMs ?? CLI_TEMP_SERVER_TTL_MS;
     let lastError;
-    for (const candidate of candidates) {
-        try {
-            return await tryStartCliOpencodeServer(candidate);
-        }
-        catch (failure) {
-            lastError = failure;
-            const recoverable = typeof failure === 'object' &&
-                failure !== null &&
-                'recoverable' in failure &&
-                failure.recoverable === true;
-            if (!recoverable) {
-                const error = typeof failure === 'object' && failure !== null && 'error' in failure
-                    ? failure.error
-                    : failure;
-                throw error instanceof Error ? error : new Error(String(error));
+    const attemptedPorts = new Set();
+    for (let attempt = 0; attempt < CLI_SERVER_PORT_RETRY_LIMIT; attempt++) {
+        const port = await resolvePort(DEFAULT_OPENCODE_PORT, attemptedPorts);
+        attemptedPorts.add(port);
+        for (const candidate of cliServerCommandCandidates(platform, port)) {
+            try {
+                const server = await tryStartCliOpencodeServer(candidate, spawnProcess, closeProcess);
+                let watchdogProc;
+                try {
+                    watchdogProc = spawnCliServerWatchdog(server.pid, tempServerTtlMs, spawnWatchdogProcess);
+                }
+                catch (error) {
+                    server.close();
+                    throw new Error(`Failed to start temporary OpenCode server watchdog: ${describeCliError(error)}`);
+                }
+                const stopWatchdog = () => {
+                    if (!watchdogProc)
+                        return;
+                    const proc = watchdogProc;
+                    watchdogProc = undefined;
+                    closeProcess(proc);
+                };
+                return {
+                    ...server,
+                    close: () => {
+                        stopWatchdog();
+                        server.close();
+                    },
+                };
+            }
+            catch (failure) {
+                lastError = failure;
+                if (isCliServerPortConflictFailure(failure))
+                    break;
+                if (!isRecoverableCliServerFailure(failure)) {
+                    throw cliServerFailureError(failure);
+                }
             }
         }
+        if (!isCliServerPortConflictFailure(lastError))
+            break;
     }
-    const error = typeof lastError === 'object' && lastError !== null && 'error' in lastError
-        ? lastError.error
-        : lastError;
-    throw error instanceof Error
-        ? error
+    throw lastError
+        ? cliServerFailureError(lastError)
         : new Error('Failed to start OpenCode server');
 }
 async function resolvePathInfo(directory) {
@@ -360,7 +565,27 @@ async function resolvePathInfo(directory) {
         if (!isDefaultBaseUrl()) {
             throw new Error(`Failed to connect to OpenCode API at ${cliBaseUrl()}: ${error instanceof Error ? error.message : String(error)}`);
         }
-        const server = await startCliOpencodeServer();
+        let server;
+        try {
+            server = await startCliOpencodeServer();
+        }
+        catch (startError) {
+            throw new Error(formatCliTempServerFailure('Failed to auto-start a temporary OpenCode server', startError));
+        }
+        let closed = false;
+        const unregisterTempServerCleanup = registerCliShutdownCleanup(() => {
+            if (closed)
+                return;
+            closed = true;
+            server.close();
+        });
+        const closeTempServer = () => {
+            if (closed)
+                return;
+            closed = true;
+            unregisterTempServerCleanup();
+            server.close();
+        };
         try {
             const client = createOpencodeClient({
                 directory,
@@ -375,12 +600,12 @@ async function resolvePathInfo(directory) {
                 client,
                 worktree: data.worktree || directory,
                 directory: data.directory || directory,
-                close: () => server.close(),
+                close: closeTempServer,
             };
         }
         catch (innerError) {
-            server.close();
-            throw innerError;
+            closeTempServer();
+            throw new Error(formatCliTempServerFailure(`Failed to query the temporary OpenCode server at ${server.url}`, innerError));
         }
     }
 }

package/dist/tui.tsx

@@ -253,7 +253,6 @@ function QuotaGroupBlock(props: {
   group: SidebarQuotaGroup
   bullet: boolean
 }) {
-  const detailColor = quotaToneColor(props.api, props.group.tone)
   const content = (
     <box gap={0}>
       <text>
@@ -261,11 +260,14 @@ function QuotaGroupBlock(props: {
           {props.group.shortLabel}
         </span>
         <Show when={props.group.detail}>
-          <span style={{ fg: detailColor }}> {props.group.detail}</span>
+          <span style={{ fg: props.api.theme.current.textMuted }}>
+            {' '}
+            {props.group.detail}
+          </span>
         </Show>
       </text>
       <For each={props.group.continuationLines}>
-        {(line) => <text fg={detailColor}>{line}</text>}
+        {(line) => <text fg={props.api.theme.current.textMuted}>{line}</text>}
       </For>
     </box>
   )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leo000001/opencode-quota-sidebar",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "description": "OpenCode plugin that shows quota and token usage in TUI sidebar panels and compact session titles",
   "type": "module",
   "main": "./dist/index.js",