@foxden-app/foxclaw 0.5.77 → 0.6.3

package/dist/opencode/client.js

@@ -0,0 +1,499 @@
+import crypto from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { createOpencodeClient, } from '@opencode-ai/sdk/v2';
+import { OpencodeEventNormalizer } from './events.js';
+const START_TIMEOUT_MS = 15_000;
+const POLL_INTERVAL_MS = 500;
+/** Owns one password-protected localhost `opencode serve` process. */
+export class OpencodeAppClient extends EventEmitter {
+    cliBin;
+    configuredPassword;
+    statePath;
+    logPath;
+    logger;
+    childEnv;
+    normalizer = new OpencodeEventNormalizer();
+    client = null;
+    child = null;
+    serverState = null;
+    connected = false;
+    sseAbort = null;
+    sseLoop = null;
+    pollers = new Map();
+    desiredRunning = false;
+    starting = null;
+    reconnectTimer = null;
+    constructor(cliBin, configuredPassword, statePath, logPath, logger, childEnv = null) {
+        super();
+        this.cliBin = cliBin;
+        this.configuredPassword = configuredPassword;
+        this.statePath = statePath;
+        this.logPath = logPath;
+        this.logger = logger;
+        this.childEnv = childEnv;
+    }
+    getClient() {
+        if (!this.client)
+            throw new Error('OpenCode client is not connected');
+        return this.client;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    getServerStatus() {
+        return {
+            pid: this.serverState?.pid ?? null,
+            port: this.serverState?.port ?? null,
+            running: Boolean(this.serverState && isProcessAlive(this.serverState.pid)),
+            connected: this.connected,
+            url: this.serverState?.url ?? null,
+            version: this.serverState?.version ?? null,
+            managed: this.serverState !== null,
+        };
+    }
+    async start() {
+        this.desiredRunning = true;
+        if (this.connected)
+            return;
+        if (!this.starting) {
+            this.starting = (async () => {
+                if (await this.attachPersistedServer())
+                    return;
+                await this.spawnServer();
+            })().finally(() => {
+                this.starting = null;
+            });
+        }
+        await this.starting;
+    }
+    async stop(options = {}) {
+        this.desiredRunning = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.connected = false;
+        for (const controller of this.pollers.values())
+            controller.abort();
+        this.pollers.clear();
+        this.sseAbort?.abort();
+        if (this.sseLoop) {
+            await Promise.race([this.sseLoop.catch(() => { }), sleep(2_000)]);
+        }
+        this.sseAbort = null;
+        this.sseLoop = null;
+        const state = this.serverState;
+        if (options.terminateServer && state && isProcessAlive(state.pid)) {
+            await terminateProcessGroup(state.pid);
+            this.clearStateForPid(state.pid);
+        }
+        this.child = null;
+        this.client = null;
+        this.serverState = null;
+        this.connected = false;
+        this.normalizer.reset();
+    }
+    async restart() {
+        await this.stop({ terminateServer: true });
+        await this.start();
+    }
+    watchSessionUntilIdle(sessionId, directory) {
+        this.pollers.get(sessionId)?.abort();
+        const controller = new AbortController();
+        this.pollers.set(sessionId, controller);
+        void this.pollSession(sessionId, directory, controller).finally(() => {
+            if (this.pollers.get(sessionId) === controller)
+                this.pollers.delete(sessionId);
+        });
+    }
+    async recoverPendingRequests(directories) {
+        const unique = [...new Set(directories.filter(Boolean))];
+        await Promise.all(unique.map((directory) => this.recoverPendingForDirectory(directory)));
+    }
+    async pollSession(sessionId, directory, controller) {
+        let observedBusy = false;
+        while (!controller.signal.aborted && this.connected) {
+            try {
+                const response = await this.getClient().session.status({ directory });
+                if (response.error)
+                    throw new Error(formatSdkError(response.error));
+                const status = response.data?.[sessionId];
+                if (status?.type === 'busy' || status?.type === 'retry')
+                    observedBusy = true;
+                if (status?.type === 'idle' || (observedBusy && status === undefined)) {
+                    this.emit('event', { kind: 'idle', sessionId });
+                    return;
+                }
+            }
+            catch (error) {
+                this.logger.warn('opencode.session.poll_failed', {
+                    sessionId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            await sleep(POLL_INTERVAL_MS, controller.signal);
+        }
+    }
+    async attachPersistedServer() {
+        const state = this.readState();
+        if (!state)
+            return false;
+        if (!isProcessAlive(state.pid)) {
+            this.clearStateForPid(state.pid);
+            return false;
+        }
+        try {
+            const health = await probeHealth(state.url, state.username, state.password);
+            await this.adoptServer({ ...state, version: health.version ?? state.version });
+            this.logger.info('opencode.serve.attached', { pid: state.pid, port: state.port, version: health.version });
+            return true;
+        }
+        catch (error) {
+            throw new Error(`A managed opencode serve process (${state.pid}) is still running but cannot be attached: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async spawnServer() {
+        const port = await reservePort();
+        const username = 'opencode';
+        const password = this.configuredPassword || crypto.randomBytes(32).toString('base64url');
+        const url = `http://127.0.0.1:${port}`;
+        const args = ['serve', '--hostname=127.0.0.1', `--port=${port}`, '--print-logs'];
+        fs.mkdirSync(path.dirname(this.logPath), { recursive: true, mode: 0o700 });
+        const stdoutFd = fs.openSync(this.logPath, 'a', 0o600);
+        const stderrFd = fs.openSync(this.logPath, 'a', 0o600);
+        let child;
+        try {
+            child = spawn(this.cliBin, args, {
+                detached: true,
+                stdio: ['ignore', stdoutFd, stderrFd],
+                env: {
+                    ...process.env,
+                    ...(this.childEnv ?? {}),
+                    OPENCODE_SERVER_USERNAME: username,
+                    OPENCODE_SERVER_PASSWORD: password,
+                },
+            });
+        }
+        finally {
+            fs.closeSync(stdoutFd);
+            fs.closeSync(stderrFd);
+        }
+        try {
+            await waitForSpawn(child);
+        }
+        catch (error) {
+            throw new Error(`Failed to start opencode serve: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!child.pid)
+            throw new Error('Failed to start opencode serve: child PID is unavailable');
+        child.unref();
+        this.child = child;
+        const state = {
+            pid: child.pid,
+            port,
+            url,
+            username,
+            password,
+            command: [this.cliBin, ...args].join(' '),
+            logPath: this.logPath,
+            startedAt: new Date().toISOString(),
+            version: null,
+        };
+        this.writeState(state);
+        this.serverState = state;
+        child.once('exit', (code, signal) => {
+            if (this.child !== child)
+                return;
+            this.child = null;
+            this.clearStateForPid(child.pid);
+            this.handleDisconnect({ source: 'process-exit', message: `code=${code ?? 'null'} signal=${signal ?? 'null'}` });
+        });
+        child.once('error', (error) => {
+            if (this.child !== child)
+                return;
+            this.child = null;
+            this.clearStateForPid(child.pid);
+            this.handleDisconnect({ source: 'process-error', message: error.message });
+        });
+        try {
+            const health = await waitForHealth(url, username, password, child);
+            this.logger.debug('opencode.serve.ready', { pid: child.pid, port, version: health.version });
+            await this.adoptServer({ ...state, version: health.version ?? null });
+            this.writeState(this.serverState);
+            this.logger.info('opencode.serve.started', { pid: child.pid, port, version: health.version });
+        }
+        catch (error) {
+            await terminateProcessGroup(child.pid);
+            this.clearStateForPid(child.pid);
+            throw error;
+        }
+    }
+    async adoptServer(state) {
+        this.logger.debug('opencode.serve.adopting', { pid: state.pid, port: state.port });
+        this.serverState = state;
+        this.client = createOpencodeClient({
+            baseUrl: state.url,
+            headers: authHeaders(state.username, state.password),
+        });
+        this.connected = true;
+        this.emit('connected');
+        this.startSseLoop();
+        this.logger.debug('opencode.serve.adopted', { pid: state.pid, port: state.port });
+    }
+    startSseLoop() {
+        const controller = new AbortController();
+        this.sseAbort = controller;
+        this.sseLoop = this.runSseLoop(controller).catch((error) => {
+            if (controller.signal.aborted)
+                return;
+            this.logger.error('opencode.sse.failed', { error: error instanceof Error ? error.message : String(error) });
+            this.handleDisconnect({ source: 'sse', message: error instanceof Error ? error.message : String(error) });
+        });
+    }
+    async runSseLoop(controller) {
+        while (!controller.signal.aborted) {
+            try {
+                const subscribed = await this.getClient().global.event({ signal: controller.signal });
+                this.logger.info('opencode.sse.connected');
+                for await (const globalEvent of subscribed.stream) {
+                    const event = unwrapGlobalEvent(globalEvent);
+                    if (event)
+                        this.acceptEvent(event);
+                }
+            }
+            catch (error) {
+                if (controller.signal.aborted)
+                    return;
+                const state = this.serverState;
+                if (state && !isProcessAlive(state.pid)) {
+                    this.clearStateForPid(state.pid);
+                    this.handleDisconnect({ source: 'sse-process-exit', message: error instanceof Error ? error.message : String(error) });
+                    return;
+                }
+                this.logger.warn('opencode.sse.reconnect', { error: error instanceof Error ? error.message : String(error) });
+            }
+            if (!controller.signal.aborted)
+                await sleep(1_000, controller.signal);
+        }
+    }
+    acceptEvent(event) {
+        for (const normalized of this.normalizer.accept(event)) {
+            if (normalized.kind === 'idle')
+                this.pollers.get(normalized.sessionId)?.abort();
+            this.emit('event', normalized);
+        }
+    }
+    async recoverPendingForDirectory(directory) {
+        if (!this.client)
+            return;
+        this.logger.debug('opencode.pending.recover_start', { directory: directory ?? null });
+        const [permissions, questions] = await Promise.all([
+            this.client.permission.list({ ...(directory ? { directory } : {}) }),
+            this.client.question.list({ ...(directory ? { directory } : {}) }),
+        ]);
+        if (!permissions.error) {
+            for (const request of permissions.data ?? []) {
+                this.emit('event', { kind: 'permission', request: request });
+            }
+        }
+        if (!questions.error) {
+            for (const request of questions.data ?? []) {
+                this.emit('event', { kind: 'question', request: request });
+            }
+        }
+        this.logger.debug('opencode.pending.recover_done', { directory: directory ?? null });
+    }
+    handleDisconnect(detail) {
+        const wasConnected = this.connected;
+        this.connected = false;
+        this.sseAbort?.abort();
+        this.client = null;
+        this.normalizer.reset();
+        if (wasConnected) {
+            this.emit('disconnected', detail);
+            this.scheduleReconnect();
+        }
+    }
+    scheduleReconnect() {
+        if (!this.desiredRunning || this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            if (!this.desiredRunning || this.connected)
+                return;
+            void this.start().catch((error) => {
+                this.logger.error('opencode.serve.reconnect_failed', { error: error instanceof Error ? error.message : String(error) });
+                this.scheduleReconnect();
+            });
+        }, 1_000);
+    }
+    writeState(state) {
+        fs.mkdirSync(path.dirname(this.statePath), { recursive: true, mode: 0o700 });
+        const tempPath = `${this.statePath}.${process.pid}.tmp`;
+        fs.writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+        fs.chmodSync(tempPath, 0o600);
+        fs.renameSync(tempPath, this.statePath);
+        fs.chmodSync(this.statePath, 0o600);
+    }
+    readState() {
+        try {
+            const value = JSON.parse(fs.readFileSync(this.statePath, 'utf8'));
+            if (!Number.isInteger(value.pid) || !Number.isInteger(value.port)
+                || typeof value.url !== 'string' || value.url !== `http://127.0.0.1:${value.port}`
+                || typeof value.username !== 'string' || typeof value.password !== 'string'
+                || typeof value.startedAt !== 'string')
+                return null;
+            return value;
+        }
+        catch {
+            return null;
+        }
+    }
+    clearStateForPid(pid) {
+        const current = this.readState();
+        if (current && current.pid !== pid)
+            return;
+        try {
+            fs.unlinkSync(this.statePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                this.logger.warn('opencode.serve.state_clear_failed', { error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+    }
+}
+function unwrapGlobalEvent(value) {
+    const payload = value.payload;
+    return typeof payload.type === 'string' && payload.properties && typeof payload.properties === 'object'
+        ? payload
+        : null;
+}
+async function waitForHealth(url, username, password, child) {
+    const deadline = Date.now() + START_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null || child.signalCode !== null) {
+            throw new Error(`opencode serve exited before becoming ready (code=${child.exitCode ?? 'null'}, signal=${child.signalCode ?? 'null'})`);
+        }
+        try {
+            return await probeHealth(url, username, password);
+        }
+        catch {
+            await sleep(200);
+        }
+    }
+    throw new Error(`Timed out waiting for opencode serve at ${url}`);
+}
+async function probeHealth(url, username, password) {
+    const response = await fetch(`${url}/global/health`, {
+        headers: authHeaders(username, password),
+        signal: AbortSignal.timeout(1_000),
+    });
+    if (response.status === 401)
+        throw new Error('OpenCode server rejected its stored credentials');
+    if (!response.ok)
+        throw new Error(`OpenCode health check returned HTTP ${response.status}`);
+    const value = await response.json();
+    if (value.healthy !== true)
+        throw new Error('OpenCode health check did not report healthy=true');
+    return { healthy: true, ...(typeof value.version === 'string' ? { version: value.version } : {}) };
+}
+function authHeaders(username, password) {
+    return { Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}` };
+}
+function reservePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                server.close();
+                reject(new Error('Failed to reserve a local TCP port'));
+                return;
+            }
+            server.close((error) => error ? reject(error) : resolve(address.port));
+        });
+    });
+}
+function waitForSpawn(child) {
+    return new Promise((resolve, reject) => {
+        const onSpawn = () => {
+            child.off('error', onError);
+            resolve();
+        };
+        const onError = (error) => {
+            child.off('spawn', onSpawn);
+            reject(error);
+        };
+        child.once('spawn', onSpawn);
+        child.once('error', onError);
+    });
+}
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+async function terminateProcessGroup(pid) {
+    try {
+        process.kill(-pid, 'SIGTERM');
+    }
+    catch {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            return;
+        }
+    }
+    const deadline = Date.now() + 5_000;
+    while (Date.now() < deadline && isProcessAlive(pid))
+        await sleep(100);
+    if (!isProcessAlive(pid))
+        return;
+    try {
+        process.kill(-pid, 'SIGKILL');
+    }
+    catch {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch { /* already gone */ }
+    }
+}
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted)
+            return resolve();
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
+}
+export function formatSdkError(error) {
+    if (typeof error === 'object' && error !== null) {
+        const value = error;
+        if (typeof value.data?.message === 'string')
+            return value.data.message;
+        if (typeof value.message === 'string')
+            return value.message;
+        if (typeof value._tag === 'string')
+            return value._tag;
+        if (typeof value.name === 'string')
+            return value.name;
+    }
+    return String(error);
+}

package/dist/opencode/controller.d.ts

@@ -0,0 +1,137 @@
+import type { PermissionRuleset } from '@opencode-ai/sdk/v2';
+import type { AppConfig } from '../config.js';
+import type { TelegramMessagingPort } from '../channels/telegram/telegram_messaging_port.js';
+import type { Logger } from '../logger.js';
+import type { BridgeStore } from '../store/database.js';
+import type { TelegramGateway } from '../telegram/gateway.js';
+import type { OpencodeAppClient } from './client.js';
+/** Telegram-facing OpenCode runtime. It shares FoxClaw's gateway/store/rendering primitives. */
+export declare class OpencodeBridgeCore {
+    private readonly config;
+    private readonly store;
+    private readonly logger;
+    private readonly bot;
+    private readonly app;
+    private readonly messaging;
+    private readonly activeTurns;
+    private readonly watchers;
+    private readonly queuedPrompts;
+    private readonly permissions;
+    private readonly questions;
+    private readonly setupActions;
+    private readonly latestVoiceText;
+    private readonly locks;
+    private readonly finishingSessions;
+    private readonly handlingPermissionIds;
+    private readonly handlingQuestionIds;
+    private disconnectCleanup;
+    private started;
+    constructor(config: AppConfig, store: BridgeStore, logger: Logger, bot: TelegramGateway, app: OpencodeAppClient, messaging: TelegramMessagingPort);
+    registerInboundHandlers(): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    get isRunning(): boolean;
+    get activeTurnCount(): number;
+    getRuntimeStatus(): {
+        connected: boolean;
+        activeTurns: number;
+        botUsername: string | null;
+        server: ReturnType<OpencodeAppClient['getServerStatus']>;
+    };
+    private withLock;
+    private reportError;
+    private unsupportedCommandMessage;
+    private localeForScope;
+    private handleText;
+    private handleCommand;
+    private showHelp;
+    private createAndBind;
+    private showThreads;
+    private resolveSessionTarget;
+    private openSession;
+    private watchSession;
+    private unwatchSession;
+    private showStatus;
+    private showSetup;
+    private setupKeyboard;
+    private sendOrEditPanel;
+    private listProviders;
+    private listModels;
+    private showModels;
+    private setModel;
+    private setVariant;
+    private setMode;
+    private setAgent;
+    private setAccess;
+    private applyAccess;
+    private setActiveMode;
+    private writePrefs;
+    private sendWithBehavior;
+    private takeOver;
+    private dispatchPrompt;
+    private startTrackedTurn;
+    private buildPromptParts;
+    private stageAttachments;
+    private showHistory;
+    private renameSession;
+    private forkSession;
+    private undoSession;
+    private redoSession;
+    private archiveBoundSession;
+    private archiveCachedSession;
+    private archiveSession;
+    private unarchiveSession;
+    private showDiff;
+    private showWhere;
+    private findFiles;
+    private compactSession;
+    private showLoaded;
+    private statusesForSessions;
+    private showSkills;
+    private showMcp;
+    private showProviders;
+    private showAuth;
+    private showPlugins;
+    private showFeatures;
+    private showConfig;
+    private runReview;
+    private showRichDemo;
+    private handleVoiceCommand;
+    private showFastUnsupported;
+    private abort;
+    private requireBoundSession;
+    private effectiveModel;
+    private handleAppEvent;
+    private cleanupAfterDisconnect;
+    private recoverAfterReconnect;
+    private scopesForSession;
+    private isOwnScope;
+    private cwdForSession;
+    private handleTextEvent;
+    private handleToolEvent;
+    private scheduleTurnFlush;
+    private flushTurn;
+    private flushTurnNow;
+    private scheduleToolFlush;
+    private flushTools;
+    private flushToolsNow;
+    private scheduleWatchFlush;
+    private flushWatch;
+    private flushWatchNow;
+    private finishSession;
+    private finishSessionNow;
+    private clearTurnTimers;
+    private handlePermission;
+    private resolvePermission;
+    private approveFromCommand;
+    private replyPermission;
+    private handleQuestion;
+    private resolveQuestion;
+    private answerFromCommand;
+    private maybeSubmitQuestion;
+    private handleCallback;
+    private send;
+    private sendFinalChunk;
+    private editFinalChunk;
+}
+export declare function permissionRules(access: string): PermissionRuleset;