@bbigbang/agent-node 0.1.0

package/dist/claudeSessionControls.js

@@ -0,0 +1,78 @@
+import { CLAUDE_SESSION_MODEL_OPTIONS } from '@bbigbang/protocol';
+const CLAUDE_SESSION_MODES = [
+    {
+        id: 'default',
+        label: 'Always Ask',
+        description: 'Prompts for permission the first time a tool is used',
+    },
+    {
+        id: 'acceptEdits',
+        label: 'Accept File Edits',
+        description: 'Automatically approves edit-focused tools without prompting',
+    },
+    {
+        id: 'plan',
+        label: 'Plan Mode',
+        description: 'Analyze the codebase without executing tools or edits',
+    },
+    {
+        id: 'bypassPermissions',
+        label: 'Bypass',
+        description: 'Skip all permission prompts (use with caution)',
+    },
+];
+const CLAUDE_SESSION_MODE_IDS = new Set(CLAUDE_SESSION_MODES.map((mode) => mode.id));
+const CLAUDE_SESSION_MODELS = CLAUDE_SESSION_MODEL_OPTIONS.map((model) => ({ ...model }));
+const CLAUDE_SESSION_MODEL_IDS = new Set(CLAUDE_SESSION_MODELS.map((model) => model.id));
+const CLAUDE_SESSION_COMMANDS = [
+    {
+        name: 'rewind',
+        description: 'Rewind tracked files to a previous Claude user message',
+        argumentHint: '[user_message_uuid]',
+    },
+];
+const CLAUDE_SESSION_COMMAND_NAMES = new Set(CLAUDE_SESSION_COMMANDS.map((command) => command.name));
+export function listClaudeSessionModes() {
+    return CLAUDE_SESSION_MODES.map((mode) => ({ ...mode }));
+}
+export function listClaudeSessionModels() {
+    return CLAUDE_SESSION_MODELS.map((model) => ({ ...model }));
+}
+export function listClaudeSessionCommands() {
+    return CLAUDE_SESSION_COMMANDS.map((command) => ({ ...command }));
+}
+export function normalizeClaudeSessionModeId(value) {
+    const trimmed = value?.trim() ?? '';
+    if (trimmed && CLAUDE_SESSION_MODE_IDS.has(trimmed)) {
+        return trimmed;
+    }
+    return 'default';
+}
+export function isClaudeSessionModeId(value) {
+    return Boolean(value && CLAUDE_SESSION_MODE_IDS.has(value));
+}
+export function isClaudeSessionModelId(value) {
+    return Boolean(value && CLAUDE_SESSION_MODEL_IDS.has(value));
+}
+export function getDefaultClaudeSessionModelId() {
+    return CLAUDE_SESSION_MODELS.find((model) => model.isDefault)?.id ?? CLAUDE_SESSION_MODELS[0].id;
+}
+export function isClaudeSessionCommandName(value) {
+    return Boolean(value && CLAUDE_SESSION_COMMAND_NAMES.has(value));
+}
+export function buildClaudeSessionControlState(params) {
+    const normalizedModeId = normalizeClaudeSessionModeId(params.modeId);
+    const normalizedModelId = isClaudeSessionModelId(params.modelId) ? params.modelId : null;
+    const defaultModelId = getDefaultClaudeSessionModelId();
+    const effectiveModelId = params.effectiveModelId?.trim() || normalizedModelId || defaultModelId;
+    return {
+        sessionId: params.sessionId,
+        modeId: normalizedModeId,
+        modelId: normalizedModelId,
+        effectiveModelId,
+        checkpointingEnabled: true,
+        availableModes: listClaudeSessionModes(),
+        availableModels: listClaudeSessionModels(),
+        availableCommands: listClaudeSessionCommands(),
+    };
+}

package/dist/claudeTranscriptFs.js

@@ -0,0 +1,147 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const CLAUDE_RUNTIME_DIRNAME = '.claude-runtime';
+const CLAUDE_PROJECTS_DIRNAME = 'projects';
+const MAX_TRANSCRIPT_BYTES = 2 * 1024 * 1024;
+const TRANSCRIPT_HEADER_READ_BYTES = 16 * 1024;
+export class ClaudeTranscriptFsError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export function listClaudeTranscriptFiles(workspaceRoot, maxFiles = 1000) {
+    const rootPath = getClaudeProjectsRoot(workspaceRoot);
+    const files = [];
+    const normalizedMax = Math.max(1, Math.min(maxFiles, 5000));
+    const rootStat = fs.statSync(rootPath, { throwIfNoEntry: false });
+    if (!rootStat) {
+        return { rootPath, files: [], truncated: false };
+    }
+    if (!rootStat.isDirectory()) {
+        throw new ClaudeTranscriptFsError('not_directory', 'Claude transcript root is not a directory.');
+    }
+    const stack = [rootPath];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        const entries = fs.readdirSync(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const absolutePath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(absolutePath);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.jsonl')) {
+                continue;
+            }
+            const stat = fs.statSync(absolutePath, { throwIfNoEntry: false });
+            if (!stat?.isFile())
+                continue;
+            const header = readClaudeTranscriptHeader(absolutePath, stat.size);
+            files.push({
+                path: toRelativeTranscriptPath(rootPath, absolutePath),
+                size: stat.size,
+                modifiedAt: Math.floor(stat.mtimeMs),
+                sessionId: header.sessionId,
+                cwd: header.cwd,
+            });
+        }
+    }
+    files.sort((a, b) => {
+        if (a.modifiedAt !== b.modifiedAt)
+            return b.modifiedAt - a.modifiedAt;
+        return a.path.localeCompare(b.path);
+    });
+    return {
+        rootPath,
+        files: files.slice(0, normalizedMax),
+        truncated: files.length > normalizedMax,
+    };
+}
+export function readClaudeTranscriptFile(workspaceRoot, relativePath) {
+    const rootPath = getClaudeProjectsRoot(workspaceRoot);
+    const absolutePath = resolveTranscriptPath(rootPath, relativePath);
+    const stat = fs.statSync(absolutePath, { throwIfNoEntry: false });
+    if (!stat)
+        throw new ClaudeTranscriptFsError('not_found', 'Claude transcript not found.');
+    if (!stat.isFile())
+        throw new ClaudeTranscriptFsError('not_file', 'Claude transcript path is not a file.');
+    if (stat.size > MAX_TRANSCRIPT_BYTES) {
+        throw new ClaudeTranscriptFsError('file_too_large', `Claude transcript exceeds ${MAX_TRANSCRIPT_BYTES} bytes.`);
+    }
+    const contentBuffer = fs.readFileSync(absolutePath);
+    if (looksBinary(contentBuffer)) {
+        throw new ClaudeTranscriptFsError('binary_file', 'Claude transcript is not a text file.');
+    }
+    return {
+        rootPath,
+        path: normalizeRelativePath(relativePath),
+        content: contentBuffer.toString('utf8'),
+        size: stat.size,
+        modifiedAt: Math.floor(stat.mtimeMs),
+    };
+}
+function getClaudeProjectsRoot(workspaceRoot) {
+    return path.join(path.resolve(workspaceRoot), CLAUDE_RUNTIME_DIRNAME, CLAUDE_PROJECTS_DIRNAME);
+}
+function resolveTranscriptPath(rootPath, relativePath) {
+    const normalized = normalizeRelativePath(relativePath);
+    const absolutePath = path.resolve(rootPath, normalized);
+    const resolvedRoot = path.resolve(rootPath);
+    if (absolutePath !== resolvedRoot && !absolutePath.startsWith(`${resolvedRoot}${path.sep}`)) {
+        throw new ClaudeTranscriptFsError('path_outside_workspace', 'Transcript path escapes Claude transcript root.');
+    }
+    return absolutePath;
+}
+function toRelativeTranscriptPath(rootPath, absolutePath) {
+    const relative = path.relative(path.resolve(rootPath), path.resolve(absolutePath));
+    return normalizeRelativePath(relative);
+}
+function normalizeRelativePath(relativePath) {
+    return relativePath.replace(/^\/+/, '').split(path.sep).join('/').trim();
+}
+function looksBinary(content) {
+    const limit = Math.min(content.length, 8000);
+    for (let index = 0; index < limit; index += 1) {
+        if (content[index] === 0)
+            return true;
+    }
+    return false;
+}
+function readClaudeTranscriptHeader(absolutePath, fileSize) {
+    const bytesToRead = Math.max(1, Math.min(fileSize, TRANSCRIPT_HEADER_READ_BYTES));
+    const fd = fs.openSync(absolutePath, 'r');
+    try {
+        const buffer = Buffer.allocUnsafe(bytesToRead);
+        const bytesRead = fs.readSync(fd, buffer, 0, bytesToRead, 0);
+        if (bytesRead <= 0)
+            return {};
+        const text = buffer.toString('utf8', 0, bytesRead);
+        let sessionId;
+        let cwd;
+        for (const line of text.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const parsed = JSON.parse(trimmed);
+                sessionId = typeof parsed.sessionId === 'string' && parsed.sessionId.trim()
+                    ? parsed.sessionId.trim()
+                    : sessionId;
+                cwd = typeof parsed.cwd === 'string' && parsed.cwd.trim()
+                    ? parsed.cwd.trim()
+                    : cwd;
+                if (sessionId && cwd)
+                    break;
+            }
+            catch {
+                continue;
+            }
+        }
+        return { sessionId, cwd };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}

package/dist/codexAppServerClient.js

@@ -0,0 +1,188 @@
+import readline from 'node:readline';
+import { log } from '@bbigbang/runtime-acp';
+export const DEFAULT_CODEX_APP_SERVER_REQUEST_TIMEOUT_MS = 300_000;
+const STDERR_BUFFER_MAX_CHARS = 8192;
+export class CodexAppServerClient {
+    child;
+    rl;
+    pending = new Map();
+    requestHandlers = new Map();
+    defaultRequestTimeoutMs;
+    exitPromise;
+    nextId = 1;
+    disposed = false;
+    stderrBuffer = '';
+    notificationHandler = null;
+    exitHandler = null;
+    resolveExitPromise = null;
+    constructor(params) {
+        this.child = params.child;
+        this.defaultRequestTimeoutMs = params.requestTimeoutMs ?? DEFAULT_CODEX_APP_SERVER_REQUEST_TIMEOUT_MS;
+        this.rl = readline.createInterface({ input: this.child.stdout });
+        this.exitPromise = new Promise((resolve) => {
+            this.resolveExitPromise = resolve;
+        });
+        this.rl.on('line', (line) => {
+            void this.handleLine(line);
+        });
+        this.child.stderr.on('data', (chunk) => {
+            this.stderrBuffer += chunk.toString();
+            if (this.stderrBuffer.length > STDERR_BUFFER_MAX_CHARS) {
+                this.stderrBuffer = this.stderrBuffer.slice(-STDERR_BUFFER_MAX_CHARS);
+            }
+        });
+        this.child.on('error', (error) => {
+            this.handleChildExit(error instanceof Error ? error : new Error(String(error)));
+        });
+        this.child.on('exit', (code, signal) => {
+            const message = code === 0 && !signal
+                ? 'Codex app-server exited.'
+                : `Codex app-server exited with code ${code ?? 'null'} and signal ${signal ?? 'null'}.`;
+            this.handleChildExit(new Error([message, this.stderrBuffer.trim()].filter(Boolean).join('\n')));
+        });
+    }
+    setNotificationHandler(handler) {
+        this.notificationHandler = handler;
+    }
+    setExitHandler(handler) {
+        this.exitHandler = handler;
+    }
+    setRequestHandler(method, handler) {
+        this.requestHandlers.set(method, handler);
+    }
+    request(method, params, timeoutMs = this.defaultRequestTimeoutMs) {
+        if (this.disposed) {
+            return Promise.reject(new Error('Codex app-server client is closed.'));
+        }
+        const id = this.nextId++;
+        const payload = { id, method, params };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Codex app-server request timed out for ${method}.`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.writeLine(JSON.stringify(payload));
+        });
+    }
+    notify(method, params) {
+        if (this.disposed)
+            return;
+        const payload = { method, params };
+        this.writeLine(JSON.stringify(payload));
+    }
+    async dispose() {
+        if (this.disposed) {
+            await this.exitPromise;
+            return;
+        }
+        this.disposed = true;
+        this.rl.close();
+        try {
+            this.child.stdin.end();
+        }
+        catch {
+            // Ignore stream shutdown errors during disposal.
+        }
+        terminateChildProcessTree(this.child);
+        await this.exitPromise;
+    }
+    writeLine(line) {
+        const stdin = this.child.stdin;
+        if (this.disposed || stdin.destroyed || !stdin.writable)
+            return;
+        stdin.write(`${line}\n`);
+    }
+    handleChildExit(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+        this.disposed = true;
+        this.exitHandler?.(error);
+        this.resolveExitPromise?.();
+        this.resolveExitPromise = null;
+    }
+    async handleLine(line) {
+        if (!line.trim())
+            return;
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch (error) {
+            log.warn('[codex-app-server] failed to parse JSON-RPC line', {
+                error: String(error?.message ?? error),
+                line,
+            });
+            return;
+        }
+        if (typeof message.id === 'number') {
+            const id = message.id;
+            if ('result' in message || 'error' in message) {
+                const pending = this.pending.get(id);
+                if (!pending)
+                    return;
+                clearTimeout(pending.timer);
+                this.pending.delete(id);
+                if (message.error) {
+                    pending.reject(new Error(message.error?.message ?? 'Codex app-server request failed.'));
+                }
+                else {
+                    pending.resolve(message.result);
+                }
+                return;
+            }
+            if (typeof message.method === 'string') {
+                const request = message;
+                const handler = this.requestHandlers.get(request.method);
+                try {
+                    const result = handler ? await handler(request.params) : {};
+                    this.writeLine(JSON.stringify({ id: request.id, result }));
+                }
+                catch (error) {
+                    this.writeLine(JSON.stringify({
+                        id: request.id,
+                        error: { message: String(error?.message ?? error) },
+                    }));
+                }
+                return;
+            }
+        }
+        if (typeof message.method === 'string') {
+            this.notificationHandler?.(message.method, message.params);
+        }
+    }
+}
+export function buildCodexAppServerInitializeParams() {
+    return {
+        clientInfo: {
+            name: 'bigbang',
+            title: 'Bigbang',
+            version: '0.1.0',
+        },
+        capabilities: {
+            experimentalApi: true,
+        },
+    };
+}
+export function terminateChildProcessTree(child) {
+    if (!child || child.killed)
+        return;
+    if (process.platform !== 'win32' && typeof child.pid === 'number' && child.pid > 0) {
+        try {
+            process.kill(-child.pid, 'SIGTERM');
+            return;
+        }
+        catch {
+            // Fall back to killing the direct child.
+        }
+    }
+    try {
+        child.kill('SIGTERM');
+    }
+    catch {
+        // Ignore best-effort shutdown failures.
+    }
+}

package/dist/codexAppServerEnv.js

@@ -0,0 +1,14 @@
+const CODEX_CHILD_ENV_DENYLIST = [
+    'CODEX_SANDBOX_NETWORK_DISABLED',
+    'CODEX_THREAD_ID',
+];
+export function buildCodexAppServerChildEnv(baseEnv, runtimeEnv = {}) {
+    const env = {
+        ...baseEnv,
+        ...runtimeEnv,
+    };
+    for (const key of CODEX_CHILD_ENV_DENYLIST) {
+        delete env[key];
+    }
+    return env;
+}