@bbigbang/agent-node 0.1.0

package/dist/codexAppServerRpc.js

@@ -0,0 +1,273 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getRuntimeDriver } from '@bbigbang/protocol';
+import { normalizeSkillRootsWithBuiltins } from './builtinSkillRoots.js';
+import { buildCodexAppServerInitializeParams, CodexAppServerClient } from './codexAppServerClient.js';
+import { buildCodexAppServerChildEnv } from './codexAppServerEnv.js';
+const TRANSIENT_REQUEST_TIMEOUT_MS = 30_000;
+export class CodexAppServerRpc {
+    config;
+    spawnImpl;
+    constructor(params) {
+        this.config = params.config;
+        this.spawnImpl = params.spawnImpl ?? spawn;
+    }
+    async listModels(params) {
+        const workspaceRoot = this.resolveWorkspaceRoot(params.workspaceRoot);
+        return await this.withClient(workspaceRoot, async (client) => {
+            const response = await client.request('model/list', {
+                ...(params.cursor ? { cursor: params.cursor } : {}),
+                ...(typeof params.limit === 'number' ? { limit: params.limit } : {}),
+                ...(typeof params.includeHidden === 'boolean' ? { includeHidden: params.includeHidden } : {}),
+            }, TRANSIENT_REQUEST_TIMEOUT_MS);
+            return normalizeModelListResponse(response);
+        });
+    }
+    async listSkills(params) {
+        const workspaceRoot = this.resolveWorkspaceRoot(params.workspaceRoot);
+        const skillRoots = normalizeSkillRootsWithBuiltins(normalizeStringArray(params.skillRoots));
+        const allowedSkillRoots = [workspaceRoot, ...skillRoots];
+        return await this.withClient(workspaceRoot, async (client) => {
+            const response = await client.request('skills/list', {
+                cwds: [workspaceRoot],
+                ...(params.forceReload === true ? { forceReload: true } : {}),
+                perCwdExtraUserRoots: skillRoots.length > 0
+                    ? [{ cwd: workspaceRoot, extraUserRoots: skillRoots }]
+                    : [],
+            }, TRANSIENT_REQUEST_TIMEOUT_MS);
+            return normalizeSkillListResponse(response, workspaceRoot, allowedSkillRoots);
+        });
+    }
+    async listThreads(params) {
+        const workspaceRoot = this.resolveWorkspaceRoot(params.workspaceRoot);
+        return await this.withClient(workspaceRoot, async (client) => {
+            const response = await client.request('thread/list', {
+                cwd: workspaceRoot,
+                ...(params.cursor ? { cursor: params.cursor } : {}),
+                ...(typeof params.limit === 'number' ? { limit: params.limit } : {}),
+                ...(typeof params.archived === 'boolean' ? { archived: params.archived } : {}),
+                ...(params.searchTerm ? { searchTerm: params.searchTerm } : {}),
+                ...(params.useStateDbOnly === true ? { useStateDbOnly: true } : {}),
+            }, TRANSIENT_REQUEST_TIMEOUT_MS);
+            return normalizeThreadListResponse(response, workspaceRoot);
+        });
+    }
+    async readThread(params) {
+        const workspaceRoot = this.resolveWorkspaceRoot(params.workspaceRoot);
+        return await this.withClient(workspaceRoot, async (client) => {
+            const response = await client.request('thread/read', {
+                threadId: params.threadId,
+                includeTurns: params.includeTurns ?? true,
+            }, TRANSIENT_REQUEST_TIMEOUT_MS);
+            const result = normalizeThreadReadResponse(response);
+            if (normalizePathForCompare(result.thread.cwd) !== normalizePathForCompare(workspaceRoot)) {
+                throw new Error('Codex thread belongs to a different workspace.');
+            }
+            return result;
+        });
+    }
+    async withClient(workspaceRoot, fn) {
+        this.assertCodexAppServerAvailable();
+        fs.mkdirSync(workspaceRoot, { recursive: true });
+        const driver = getRuntimeDriver('codex_app_server');
+        const child = this.spawnImpl(driver.command, [...driver.args], {
+            cwd: workspaceRoot,
+            env: buildCodexAppServerChildEnv(process.env, driver.defaultEnv ?? {}),
+            detached: process.platform !== 'win32',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const client = new CodexAppServerClient({
+            child,
+            requestTimeoutMs: TRANSIENT_REQUEST_TIMEOUT_MS,
+        });
+        try {
+            await client.request('initialize', buildCodexAppServerInitializeParams(), TRANSIENT_REQUEST_TIMEOUT_MS);
+            client.notify('initialized', {});
+            return await fn(client);
+        }
+        finally {
+            await client.dispose().catch(() => { });
+        }
+    }
+    resolveWorkspaceRoot(workspaceRoot) {
+        const normalized = normalizeOptionalString(workspaceRoot) ?? this.config.workspaceRoot;
+        return path.resolve(normalized);
+    }
+    assertCodexAppServerAvailable() {
+        if (this.config.runtimeDrivers.some((driver) => driver.agentType === 'codex_app_server'))
+            return;
+        throw new Error('codex_app_server runtime is not available on this node.');
+    }
+}
+function normalizeModelListResponse(value) {
+    const payload = value;
+    const models = (Array.isArray(payload?.data) ? payload.data : [])
+        .map(normalizeModel)
+        .filter(Boolean);
+    const defaultModel = models.find((model) => model.isDefault)?.model ?? models[0]?.model ?? null;
+    return {
+        models,
+        nextCursor: normalizeOptionalString(payload?.nextCursor),
+        defaultModel,
+    };
+}
+function normalizeModel(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const model = value;
+    const id = normalizeOptionalString(model.id) ?? normalizeOptionalString(model.model);
+    const modelValue = normalizeOptionalString(model.model) ?? id;
+    if (!id || !modelValue)
+        return null;
+    return {
+        id,
+        model: modelValue,
+        displayName: normalizeOptionalString(model.displayName) ?? modelValue,
+        ...(normalizeOptionalString(model.description) ? { description: normalizeOptionalString(model.description) } : {}),
+        hidden: model.hidden === true,
+        supportedReasoningEfforts: normalizeReasoningEfforts(model.supportedReasoningEfforts),
+        defaultReasoningEffort: normalizeReasoningEffort(model.defaultReasoningEffort),
+        additionalSpeedTiers: normalizeStringArray(model.additionalSpeedTiers),
+        isDefault: model.isDefault === true,
+    };
+}
+function normalizeSkillListResponse(value, workspaceRoot, allowedSkillRoots) {
+    const payload = value;
+    const data = (Array.isArray(payload?.data) ? payload.data : []).map((entry) => {
+        const record = entry;
+        const cwd = normalizeOptionalString(record?.cwd) ?? '';
+        if (normalizePathForCompare(cwd) !== normalizePathForCompare(workspaceRoot)) {
+            throw new Error('Codex skills list included a different workspace.');
+        }
+        return {
+            cwd,
+            skills: (Array.isArray(record?.skills) ? record.skills : [])
+                .map(normalizeSkill)
+                .filter((skill) => Boolean(skill))
+                .filter((skill) => isPathUnderAnyRoot(skill.path, allowedSkillRoots, workspaceRoot)),
+            errors: Array.isArray(record?.errors) ? record.errors : [],
+        };
+    });
+    return { data };
+}
+function normalizeSkill(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const skill = value;
+    const name = normalizeOptionalString(skill.name);
+    const description = normalizeOptionalString(skill.description) ?? '';
+    const pathValue = normalizeOptionalString(skill.path);
+    if (!name || !pathValue)
+        return null;
+    return {
+        name,
+        description,
+        ...(normalizeOptionalString(skill.shortDescription) ? { shortDescription: normalizeOptionalString(skill.shortDescription) } : {}),
+        path: pathValue,
+        ...(normalizeOptionalString(skill.scope) ? { scope: normalizeOptionalString(skill.scope) } : {}),
+        enabled: skill.enabled !== false,
+        ...('interface' in skill ? { interface: skill.interface } : {}),
+        ...('dependencies' in skill ? { dependencies: skill.dependencies } : {}),
+    };
+}
+function normalizeThreadListResponse(value, workspaceRoot) {
+    const payload = value;
+    const threads = (Array.isArray(payload?.data) ? payload.data : [])
+        .map(normalizeThread)
+        .filter(Boolean);
+    if (threads.some((thread) => normalizePathForCompare(thread.cwd) !== normalizePathForCompare(workspaceRoot))) {
+        throw new Error('Codex thread list included a different workspace.');
+    }
+    return {
+        threads,
+        nextCursor: normalizeOptionalString(payload?.nextCursor),
+        backwardsCursor: normalizeOptionalString(payload?.backwardsCursor),
+    };
+}
+function normalizeThreadReadResponse(value) {
+    const payload = value;
+    const thread = normalizeThread(payload?.thread);
+    if (!thread) {
+        throw new Error('Codex app-server did not return a thread.');
+    }
+    return { thread };
+}
+function normalizeThread(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const thread = value;
+    const id = normalizeOptionalString(thread.id);
+    const cwd = normalizeOptionalString(thread.cwd);
+    if (!id || !cwd)
+        return null;
+    return {
+        id,
+        forkedFromId: normalizeOptionalString(thread.forkedFromId),
+        preview: normalizeOptionalString(thread.preview) ?? '',
+        createdAt: numberValue(thread.createdAt) ?? 0,
+        updatedAt: numberValue(thread.updatedAt) ?? 0,
+        status: normalizeOptionalString(thread.status) ?? 'unknown',
+        path: normalizeOptionalString(thread.path),
+        cwd,
+        ...(normalizeOptionalString(thread.modelProvider) ? { modelProvider: normalizeOptionalString(thread.modelProvider) } : {}),
+        ...('source' in thread ? { source: thread.source } : {}),
+        name: normalizeOptionalString(thread.name),
+        turns: Array.isArray(thread.turns) ? thread.turns : [],
+    };
+}
+function normalizeOptionalString(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim();
+    return normalized ? normalized : null;
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => normalizeOptionalString(item))
+        .filter((item) => Boolean(item));
+}
+function normalizeReasoningEfforts(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        if (typeof item === 'string')
+            return normalizeReasoningEffort(item);
+        return normalizeReasoningEffort(item?.reasoningEffort);
+    })
+        .filter((item) => Boolean(item));
+}
+function normalizeReasoningEffort(value) {
+    const normalized = normalizeOptionalString(value);
+    if (normalized === 'none'
+        || normalized === 'minimal'
+        || normalized === 'low'
+        || normalized === 'medium'
+        || normalized === 'high'
+        || normalized === 'xhigh') {
+        return normalized;
+    }
+    return null;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function normalizePathForCompare(value) {
+    return path.resolve(value);
+}
+function isPathUnderAnyRoot(pathValue, roots, workspaceRoot) {
+    const candidate = path.isAbsolute(pathValue)
+        ? path.resolve(pathValue)
+        : path.resolve(workspaceRoot, pathValue);
+    return roots.some((root) => isPathUnderRoot(candidate, root, workspaceRoot));
+}
+function isPathUnderRoot(candidate, root, workspaceRoot) {
+    const resolvedRoot = path.isAbsolute(root)
+        ? path.resolve(root)
+        : path.resolve(workspaceRoot, root);
+    const relative = path.relative(resolvedRoot, candidate);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}