@leo000001/opencode-quota-sidebar 4.0.5 → 4.0.11

package/dist/cli.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { spawn } from 'node:child_process';
 import { type HistoryPeriod } from './period.js';
 type CliCommand = {
     period: HistoryPeriod;
@@ -10,9 +11,46 @@ type CliServerCommand = {
     args: string[];
     shell?: boolean;
 };
+type SpawnedCliServerProcess = ReturnType<typeof spawn>;
+export declare function releaseCliServerProcess(proc: {
+    stdin?: {
+        destroy: () => void;
+    } | null;
+    stdout?: {
+        destroy: () => void;
+    } | null;
+    stderr?: {
+        destroy: () => void;
+    } | null;
+    unref: () => void;
+}): void;
+export declare function terminateCliServerProcess(proc: {
+    pid?: number;
+    killed?: boolean;
+    kill: (signal?: NodeJS.Signals) => boolean;
+    stdin?: {
+        destroy: () => void;
+    } | null;
+    stdout?: {
+        destroy: () => void;
+    } | null;
+    stderr?: {
+        destroy: () => void;
+    } | null;
+    unref: () => void;
+}, options?: {
+    platform?: NodeJS.Platform;
+    killProcess?: typeof process.kill;
+}): void;
+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 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 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

@@ -15,6 +15,42 @@ import { filterHistoryProvidersForDisplay, filterUsageProvidersForDisplay, listC
 import { createUsageService } from './usage_service.js';
 const DEFAULT_OPENCODE_BASE_URL = 'http://localhost:4096';
 const CLI_SERVER_TIMEOUT_MS = 10_000;
+const CLI_FORCE_EXIT_DELAY_MS = 100;
+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.
+    proc.stdin?.destroy();
+    proc.stdout?.destroy();
+    proc.stderr?.destroy();
+    proc.unref();
+}
+export function terminateCliServerProcess(proc, options) {
+    releaseCliServerProcess(proc);
+    if (proc.killed)
+        return;
+    const platform = options?.platform ?? process.platform;
+    const killProcess = options?.killProcess ?? process.kill;
+    if (platform !== 'win32' && typeof proc.pid === 'number' && proc.pid > 0) {
+        try {
+            killProcess(-proc.pid, 'SIGTERM');
+            return;
+        }
+        catch {
+            // Fall back to the direct child pid when group termination is unavailable.
+        }
+    }
+    proc.kill('SIGTERM');
+}
+export function extractCliServerUrl(output) {
+    for (const line of output.split('\n')) {
+        if (!line.startsWith('opencode server listening'))
+            continue;
+        const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
+        if (match)
+            return match[1];
+    }
+    return undefined;
+}
 const HELP_TEXT = `opencode-quota
 
 Usage:
@@ -132,12 +168,49 @@ export function cliServerCommandCandidates(platform = process.platform) {
     }
     return [{ command: 'opencode', args: directArgs }];
 }
-async function tryStartCliOpencodeServer(candidate) {
+function releaseCliServerPipes(proc, inspect, onError, onExit) {
+    if (inspect) {
+        proc.stdout?.removeListener('data', inspect);
+        proc.stderr?.removeListener('data', inspect);
+    }
+    if (onError)
+        proc.removeListener('error', onError);
+    if (onExit)
+        proc.removeListener('exit', onExit);
+    proc.stdout?.unpipe();
+    proc.stderr?.unpipe();
+    proc.stdout?.destroy();
+    proc.stderr?.destroy();
+}
+export function closeCliServerProcess(proc, platform = process.platform, killProcess = process.kill, spawnProcess = spawn) {
+    const pid = proc.pid;
+    if (typeof pid !== 'number' || pid <= 0)
+        return;
+    if (platform === 'win32') {
+        const killer = spawnProcess('taskkill', ['/PID', String(pid), '/T', '/F'], {
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        killer.unref();
+        return;
+    }
+    try {
+        killProcess(-pid, 'SIGTERM');
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== 'ESRCH')
+            throw error;
+    }
+}
+export async function tryStartCliOpencodeServer(candidate, spawnProcess = spawn, closeProcess = closeCliServerProcess) {
     let proc;
     try {
-        proc = spawn(candidate.command, candidate.args, {
+        proc = spawnProcess(candidate.command, candidate.args, {
             env: process.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
             shell: candidate.shell ?? false,
+            detached: true,
             windowsHide: true,
         });
     }
@@ -150,52 +223,67 @@ async function tryStartCliOpencodeServer(candidate) {
         };
     }
     const url = await new Promise((resolve, reject) => {
+        let inspect;
+        let onError;
+        let onExit;
+        let output = '';
+        let settled = false;
         const id = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            releaseCliServerPipes(proc, inspect, onError, onExit);
+            closeProcess(proc);
             reject(new Error(`Timeout waiting for OpenCode server to start after ${CLI_SERVER_TIMEOUT_MS}ms`));
         }, CLI_SERVER_TIMEOUT_MS);
-        let output = '';
-        let settled = false;
-        const inspect = (chunk) => {
+        id.unref?.();
+        const fail = (failure) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(id);
+            releaseCliServerPipes(proc, inspect, onError, onExit);
+            reject(failure);
+        };
+        inspect = (chunk) => {
             output += chunk.toString();
-            const lines = output.split('\n');
-            for (const line of lines) {
-                if (!line.startsWith('opencode server listening'))
-                    continue;
-                const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
-                if (!match)
-                    continue;
+            const url = extractCliServerUrl(output);
+            if (url) {
                 clearTimeout(id);
                 settled = true;
-                resolve(match[1]);
+                releaseCliServerPipes(proc, inspect, onError, onExit);
+                // The CLI only needs the startup line; after that the detached server
+                // must not keep the parent process alive.
+                proc.stdin?.destroy();
+                proc.unref();
+                resolve(url);
                 return;
             }
         };
         proc.stdout?.on('data', inspect);
         proc.stderr?.on('data', inspect);
-        proc.on('error', (error) => {
-            clearTimeout(id);
+        onError = (error) => {
             const code = error.code;
-            reject({
+            fail({
                 error,
                 output,
                 recoverable: code === 'ENOENT' || code === 'EINVAL',
             });
-        });
-        proc.on('exit', (code) => {
-            if (settled)
-                return;
-            clearTimeout(id);
+        };
+        onExit = (code) => {
             let message = `OpenCode server exited with code ${code}`;
             if (output.trim())
                 message += `\n${output}`;
             const recoverable = /not recognized as an internal or external command/i.test(output) ||
                 /command not found/i.test(output);
-            reject({ error: new Error(message), output, recoverable });
-        });
+            fail({ error: new Error(message), output, recoverable });
+        };
+        proc.on('error', onError);
+        proc.on('exit', onExit);
     });
     return {
         url,
-        close: () => proc.kill(),
+        close: () => closeProcess(proc),
     };
 }
 async function startCliOpencodeServer() {
@@ -249,23 +337,40 @@ async function resolvePathInfo(directory) {
             throw new Error(`Failed to connect to OpenCode API at ${cliBaseUrl()}: ${error instanceof Error ? error.message : String(error)}`);
         }
         const server = await startCliOpencodeServer();
-        const client = createOpencodeClient({
-            directory,
-            baseUrl: server.url,
-        });
-        const response = await client.path.get({
-            query: { directory },
-            throwOnError: true,
-        });
-        const data = response.data;
-        return {
-            client,
-            worktree: data.worktree || directory,
-            directory: data.directory || directory,
-            close: () => server.close(),
-        };
+        try {
+            const client = createOpencodeClient({
+                directory,
+                baseUrl: server.url,
+            });
+            const response = await client.path.get({
+                query: { directory },
+                throwOnError: true,
+            });
+            const data = response.data;
+            return {
+                client,
+                worktree: data.worktree || directory,
+                directory: data.directory || directory,
+                close: () => server.close(),
+            };
+        }
+        catch (innerError) {
+            server.close();
+            throw innerError;
+        }
     }
 }
+function writeCliLine(stream, value) {
+    return new Promise((resolve, reject) => {
+        stream.write(`${value}\n`, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
 export async function runCli(argv) {
     const command = parseCliArgs(argv);
     const cwd = process.cwd();
@@ -292,6 +397,7 @@ export async function runCli(argv) {
             statePath,
             client: client,
             directory,
+            worktree,
             persistence: {
                 markDirty: () => { },
                 scheduleSave: () => { },
@@ -350,16 +456,21 @@ export function cliShouldRunMain(argv1 = process.argv[1], modulePath = fileURLTo
     return resolvePath(modulePath) === resolvePath(argv1);
 }
 async function main() {
+    let exitCode = 0;
     try {
         const output = await runCli(process.argv.slice(2));
-        process.stdout.write(`${output}\n`);
+        await writeCliLine(process.stdout, output);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        const exitCode = cliExitCodeForError(message);
+        exitCode = cliExitCodeForError(message);
         const stream = exitCode === 0 ? process.stdout : process.stderr;
-        stream.write(`${message}\n`);
+        await writeCliLine(stream, message);
+    }
+    finally {
         process.exitCode = exitCode;
+        const forceExit = setTimeout(() => process.exit(exitCode), CLI_FORCE_EXIT_DELAY_MS);
+        forceExit.unref?.();
     }
 }
 if (cliShouldRunMain()) {

package/dist/cli_render.d.ts

@@ -1,6 +1,6 @@
-import type { QuotaSnapshot } from './types.js';
-import { type UsageSummary } from './usage.js';
-import type { HistoryUsageResult } from './usage_service.js';
+import type { QuotaSnapshot } from "./types.js";
+import { type UsageSummary } from "./usage.js";
+import type { HistoryUsageResult } from "./usage_service.js";
 export declare function renderCliDashboard(input: {
     label: string;
     usage: UsageSummary;
@@ -14,4 +14,4 @@ export declare function renderCliHistoryDashboard(input: {
     width?: number;
     showCost?: boolean;
 }): string;
-export declare function cliCurrentLabel(period: 'day' | 'week' | 'month'): "Today" | "This Week" | "This Month";
+export declare function cliCurrentLabel(period: "day" | "week" | "month"): "Today" | "This Week" | "This Month";