@compyle/unagent 1.0.0

package/dist/bridge/node-bridge.js

@@ -0,0 +1,772 @@
+import { createHash, randomUUID } from "crypto";
+import { createInterface } from "readline";
+import { once } from "events";
+import { ClaudeClient } from "../client/claude.js";
+import { CodexClient } from "../client/codex/index.js";
+import { convertSnakeCaseToCamelCase } from "../client/config-utils.js";
+import { CLAUDE_FIELD_MAPPINGS, CODEX_FIELD_MAPPINGS } from "../client/field-mappings.js";
+import { applyCodexExtraHeaders, mergeHeaderRecords, normalizeExtraHeaders, resolveEnvHeaders, serializeAnthropicHeaders, } from "../client/extra-headers.js";
+import { resolveCodexHomeDir } from "../client/codex/codex-home.js";
+import { toolRegistry } from "../tools/tool-registry.js";
+import { z } from "zod";
+const CUSTOM_TOOLS_MCP_NAME = "custom-tools";
+const HASH_EXCLUDED_KEYS = new Set([
+    "resume",
+    "resumesessionid",
+    "resume_session_id",
+    "sessionid",
+    "session_id",
+    "threadid",
+    "thread_id",
+]);
+let activeClient = null;
+let abortTimer = null;
+let stdinInterface = null;
+let pythonToolInvoker = null;
+function requestAbort() {
+    if (!activeClient) {
+        process.exit(1);
+        return;
+    }
+    activeClient.abort();
+    if (!abortTimer) {
+        abortTimer = setTimeout(() => {
+            process.exit(1);
+        }, 5000);
+    }
+}
+process.on("SIGINT", requestAbort);
+process.on("SIGTERM", requestAbort);
+function serializeError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        };
+    }
+    return {
+        name: "Error",
+        message: String(error),
+    };
+}
+function serializeEvent(event) {
+    if (event.type === "error") {
+        return {
+            ...event,
+            error: serializeError(event.error),
+        };
+    }
+    return event;
+}
+function toCallToolResult(result) {
+    if (result && typeof result === "object" && "content" in result) {
+        const contentVal = result.content;
+        const isError = Boolean(result.isError);
+        if (Array.isArray(contentVal)) {
+            return { content: contentVal, ...(isError ? { isError } : {}) };
+        }
+        if (typeof contentVal === "string") {
+            return {
+                content: [{ type: "text", text: contentVal }],
+                ...(isError ? { isError } : {}),
+            };
+        }
+    }
+    if (Array.isArray(result)) {
+        return { content: result };
+    }
+    if (typeof result === "string") {
+        return { content: [{ type: "text", text: result }] };
+    }
+    return { content: [{ type: "text", text: String(result) }] };
+}
+class PythonToolInvoker {
+    send;
+    pending = new Map();
+    constructor(send) {
+        this.send = send;
+    }
+    call(toolName, args) {
+        const requestId = randomUUID();
+        this.send({
+            type: "bridge.python_tool_call",
+            requestId,
+            tool: toolName,
+            args,
+        });
+        return new Promise((resolve, reject) => {
+            this.pending.set(requestId, { resolve, reject });
+        });
+    }
+    handleResult(payload) {
+        const entry = this.pending.get(payload.requestId);
+        if (!entry)
+            return;
+        this.pending.delete(payload.requestId);
+        if (payload.type === "bridge.python_tool_error" || payload.error) {
+            entry.reject(new Error(payload.error?.message ?? "Python tool error"));
+            return;
+        }
+        entry.resolve(payload.result);
+    }
+    shutdown() {
+        for (const [requestId, entry] of this.pending) {
+            entry.reject(new Error(`Python tool request ${requestId} cancelled`));
+        }
+        this.pending.clear();
+    }
+}
+function normalizePythonInputSchema(schema) {
+    if (!schema || typeof schema !== "object") {
+        return undefined;
+    }
+    if (isZodSchema(schema)) {
+        return schema;
+    }
+    const schemaRecord = schema;
+    const isObjectSchema = schemaRecord.type === "object" || "properties" in schemaRecord;
+    if (isObjectSchema) {
+        return buildObjectSchema(schemaRecord);
+    }
+    return buildSchema(schemaRecord);
+}
+function buildObjectSchema(schema) {
+    const properties = isRecord(schema.properties) ? schema.properties : {};
+    const required = new Set(Array.isArray(schema.required)
+        ? schema.required.filter((item) => typeof item === "string")
+        : []);
+    const shape = {};
+    for (const [name, propertySchema] of Object.entries(properties)) {
+        let fieldSchema = buildSchema(asRecord(propertySchema));
+        if (!required.has(name)) {
+            fieldSchema = fieldSchema.optional();
+        }
+        shape[name] = fieldSchema;
+    }
+    let objectSchema = z.object(shape);
+    if (schema.additionalProperties === false) {
+        objectSchema = objectSchema.strict();
+    }
+    else if (isRecord(schema.additionalProperties)) {
+        objectSchema = objectSchema.catchall(buildSchema(schema.additionalProperties));
+    }
+    return objectSchema;
+}
+function buildSchema(schema) {
+    if (schema.const !== undefined) {
+        return isLiteralValue(schema.const) ? z.literal(schema.const) : z.any();
+    }
+    const enumValues = Array.isArray(schema.enum) ? schema.enum : null;
+    if (enumValues && enumValues.length > 0) {
+        const literalValues = enumValues.filter(isLiteralValue);
+        if (literalValues.length === 0) {
+            return z.any();
+        }
+        if (literalValues.every((value) => typeof value === "string")) {
+            return z.enum(literalValues);
+        }
+        const literals = literalValues.map((value) => z.literal(value));
+        return buildUnion(literals);
+    }
+    const typeValue = schema.type;
+    if (Array.isArray(typeValue)) {
+        const types = typeValue.filter((entry) => typeof entry === "string");
+        const hasNull = types.includes("null");
+        const nonNullTypes = types.filter((entry) => entry !== "null");
+        let unionSchema;
+        if (nonNullTypes.length === 0) {
+            unionSchema = z.any();
+        }
+        else if (nonNullTypes.length === 1) {
+            unionSchema = buildSchema({ ...schema, type: nonNullTypes[0] });
+        }
+        else {
+            const unionItems = nonNullTypes.map((entry) => buildSchema({ ...schema, type: entry }));
+            unionSchema = buildUnion(unionItems);
+        }
+        return hasNull ? unionSchema.nullable() : unionSchema;
+    }
+    const schemaType = typeof typeValue === "string" ? typeValue : undefined;
+    let baseSchema;
+    switch (schemaType) {
+        case "string": {
+            let stringSchema = z.string();
+            if (typeof schema.minLength === "number") {
+                stringSchema = stringSchema.min(schema.minLength);
+            }
+            if (typeof schema.maxLength === "number") {
+                stringSchema = stringSchema.max(schema.maxLength);
+            }
+            if (typeof schema.pattern === "string") {
+                try {
+                    stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+                }
+                catch {
+                }
+            }
+            baseSchema = stringSchema;
+            break;
+        }
+        case "number": {
+            let numberSchema = z.number();
+            if (typeof schema.minimum === "number") {
+                numberSchema = numberSchema.min(schema.minimum);
+            }
+            if (typeof schema.maximum === "number") {
+                numberSchema = numberSchema.max(schema.maximum);
+            }
+            if (typeof schema.exclusiveMinimum === "number") {
+                numberSchema = numberSchema.gt(schema.exclusiveMinimum);
+            }
+            if (typeof schema.exclusiveMaximum === "number") {
+                numberSchema = numberSchema.lt(schema.exclusiveMaximum);
+            }
+            baseSchema = numberSchema;
+            break;
+        }
+        case "integer": {
+            let intSchema = z.number().int();
+            if (typeof schema.minimum === "number") {
+                intSchema = intSchema.min(schema.minimum);
+            }
+            if (typeof schema.maximum === "number") {
+                intSchema = intSchema.max(schema.maximum);
+            }
+            baseSchema = intSchema;
+            break;
+        }
+        case "boolean":
+            baseSchema = z.boolean();
+            break;
+        case "array": {
+            const itemSchema = isRecord(schema.items) ? buildSchema(schema.items) : z.any();
+            let arraySchema = z.array(itemSchema);
+            if (typeof schema.minItems === "number") {
+                arraySchema = arraySchema.min(schema.minItems);
+            }
+            if (typeof schema.maxItems === "number") {
+                arraySchema = arraySchema.max(schema.maxItems);
+            }
+            baseSchema = arraySchema;
+            break;
+        }
+        case "object":
+            baseSchema = buildObjectSchema(schema);
+            break;
+        case "null":
+            baseSchema = z.null();
+            break;
+        default:
+            baseSchema = z.any();
+    }
+    if (schema.nullable === true) {
+        return baseSchema.nullable();
+    }
+    return baseSchema;
+}
+function isZodSchema(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.parse === "function" && typeof candidate.safeParse === "function";
+}
+function isLiteralValue(value) {
+    if (value === null) {
+        return true;
+    }
+    const valueType = typeof value;
+    return valueType === "string" || valueType === "number" || valueType === "boolean";
+}
+function buildUnion(items) {
+    if (items.length === 0) {
+        return z.any();
+    }
+    const [first, ...rest] = items;
+    if (!first) {
+        return z.any();
+    }
+    if (rest.length === 0) {
+        return first;
+    }
+    return z.union([first, ...rest]);
+}
+function registerPythonTools(definitions, invoker) {
+    const now = new Date();
+    return definitions.map((toolDef) => {
+        const normalizedInputSchema = normalizePythonInputSchema(toolDef.inputSchema) ?? z.any();
+        const toolName = toolDef.name;
+        const registered = {
+            id: toolDef.id ?? `py-${toolName}-${randomUUID().slice(0, 8)}`,
+            name: toolName,
+            description: toolDef.description ?? "",
+            inputSchema: normalizedInputSchema,
+            createdAt: now,
+            handler: async (args) => {
+                const result = await invoker.call(toolName, args);
+                return toCallToolResult(result);
+            },
+        };
+        toolRegistry.register(registered);
+        return registered;
+    });
+}
+function handleIncomingLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return;
+    try {
+        const payload = JSON.parse(trimmed);
+        if (payload.type === "bridge.abort") {
+            if (activeClient) {
+                requestAbort();
+            }
+            return;
+        }
+        if (payload.type === "bridge.python_tool_result" ||
+            payload.type === "bridge.python_tool_error") {
+            pythonToolInvoker?.handleResult(payload);
+        }
+    }
+    catch {
+    }
+}
+function writePayload(payload) {
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
+async function readInitialRequest() {
+    stdinInterface = createInterface({ input: process.stdin });
+    const [line] = (await once(stdinInterface, "line"));
+    return line;
+}
+function resolveProvider(params) {
+    const client = asRecord(params).client;
+    if (client === "claude" || client === "codex") {
+        return client;
+    }
+    return null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    return value;
+}
+function resolveString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function shouldExcludeHashKey(key) {
+    return HASH_EXCLUDED_KEYS.has(key.toLowerCase());
+}
+function isCustomToolsMcpName(name) {
+    return name.toLowerCase() === CUSTOM_TOOLS_MCP_NAME;
+}
+function stripCustomToolsMcpFromValue(value) {
+    if (isRecord(value)) {
+        let removed = false;
+        const nextRecord = {};
+        for (const [name, config] of Object.entries(value)) {
+            if (isCustomToolsMcpName(name)) {
+                removed = true;
+                continue;
+            }
+            nextRecord[name] = config;
+        }
+        if (!removed) {
+            return value;
+        }
+        return Object.keys(nextRecord).length > 0 ? nextRecord : undefined;
+    }
+    if (Array.isArray(value)) {
+        let removed = false;
+        const filtered = [];
+        for (const entry of value) {
+            if (typeof entry === "string") {
+                if (isCustomToolsMcpName(entry)) {
+                    removed = true;
+                    continue;
+                }
+                filtered.push(entry);
+                continue;
+            }
+            if (isRecord(entry)) {
+                const nextEntry = stripCustomToolsMcpFromValue(entry);
+                if (nextEntry === undefined) {
+                    removed = true;
+                    continue;
+                }
+                if (nextEntry !== entry) {
+                    removed = true;
+                }
+                filtered.push(nextEntry);
+                continue;
+            }
+            filtered.push(entry);
+        }
+        if (!removed) {
+            return value;
+        }
+        return filtered.length > 0 ? filtered : undefined;
+    }
+    return value;
+}
+function normalizeHashIgnoreList(value) {
+    if (!value) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value
+            .filter((item) => typeof item === "string" && item.trim().length > 0)
+            .map((item) => item.trim());
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? [trimmed] : [];
+    }
+    return [];
+}
+function normalizeHashIgnoreKey(value) {
+    return value.replace(/_/g, "").toLowerCase();
+}
+function applyHashIgnoreToRecord(record, ignoreList) {
+    if (ignoreList.length === 0) {
+        return record;
+    }
+    const ignoreSet = new Set(ignoreList.map((item) => normalizeHashIgnoreKey(item)));
+    const filtered = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (ignoreSet.has(normalizeHashIgnoreKey(key))) {
+            continue;
+        }
+        filtered[key] = value;
+    }
+    return filtered;
+}
+function normalizeHashValue(value, seen = new WeakSet()) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => {
+            const normalized = normalizeHashValue(item, seen);
+            return normalized === undefined ? null : normalized;
+        });
+    }
+    if (typeof value === "object") {
+        if (seen.has(value)) {
+            return "[Circular]";
+        }
+        seen.add(value);
+        const record = {};
+        for (const key of Object.keys(value).sort()) {
+            if (shouldExcludeHashKey(key)) {
+                continue;
+            }
+            const lowerKey = key.toLowerCase();
+            let nextValue = value[key];
+            if (lowerKey === "mcp_servers" || lowerKey === "mcpservers") {
+                nextValue = stripCustomToolsMcpFromValue(nextValue);
+            }
+            const normalized = normalizeHashValue(nextValue, seen);
+            if (normalized !== undefined) {
+                record[key] = normalized;
+            }
+        }
+        seen.delete(value);
+        return record;
+    }
+    return undefined;
+}
+function stableStringify(value) {
+    return JSON.stringify(normalizeHashValue(value));
+}
+function buildCodexHomeHashSourceFromConfig(provider, config) {
+    const homeDirHashIgnore = normalizeHashIgnoreList(config.homeDirHashIgnore ??
+        config.home_dir_hash_ignore);
+    const systemPrompt = resolveString(config.systemPrompt)
+        ?? resolveString(config.prompt);
+    const mcpServers = stripCustomToolsMcpFromValue(config.mcpServers);
+    const otherConfig = stripCustomToolsMcpFromValue(config.otherConfig);
+    const hashSource = {
+        client: provider,
+        description: config.description,
+        systemPrompt,
+        tools: config.tools,
+        allowedTools: config.allowedTools,
+        disallowedTools: config.disallowedTools,
+        model: config.model,
+        baseURL: config.baseURL,
+        mcpServers,
+        permissionMode: config.permissionMode,
+        settingSources: config.settingSources,
+        addDirs: config.addDirs,
+        cwd: config.cwd,
+        homeDir: config.homeDir,
+        skillDir: config.skillDir,
+        extraHeaders: config.extraHeaders,
+        otherConfig,
+    };
+    return applyHashIgnoreToRecord(hashSource, homeDirHashIgnore);
+}
+function createCodexHomeKeyFromConfig(provider, config) {
+    const hashSource = buildCodexHomeHashSourceFromConfig(provider, config);
+    const serialized = stableStringify(hashSource);
+    return createHash("sha256").update(serialized).digest("hex");
+}
+function normalizeBridgeConfig(provider, config) {
+    const fieldMappings = provider === "claude" ? CLAUDE_FIELD_MAPPINGS : CODEX_FIELD_MAPPINGS;
+    const normalizedConfig = convertSnakeCaseToCamelCase({ ...config }, fieldMappings);
+    const envRecord = isRecord(normalizedConfig.env)
+        ? { ...normalizedConfig.env }
+        : {};
+    const extraHeadersValue = normalizedConfig.extraHeaders ??
+        config.extra_headers;
+    const extraHeaders = normalizeExtraHeaders(extraHeadersValue);
+    if (extraHeaders) {
+        if (provider === "claude") {
+            const resolvedEnvHeaders = resolveEnvHeaders(extraHeaders.envHeaders, envRecord);
+            const mergedHeaders = mergeHeaderRecords(extraHeaders.headers, resolvedEnvHeaders);
+            const customHeaderValue = serializeAnthropicHeaders(mergedHeaders);
+            if (customHeaderValue) {
+                envRecord.ANTHROPIC_CUSTOM_HEADERS = customHeaderValue;
+            }
+        }
+        else {
+            const existingConfig = isRecord(normalizedConfig.config)
+                ? normalizedConfig.config
+                : {};
+            const updatedConfig = applyCodexExtraHeaders(existingConfig, extraHeaders);
+            if (Object.keys(updatedConfig).length > 0) {
+                normalizedConfig.config = updatedConfig;
+            }
+        }
+    }
+    let codexHomeDir;
+    if (provider === "codex") {
+        const explicitCodexHome = resolveString(envRecord.CODEX_HOME);
+        let codexHomeKey = resolveString(normalizedConfig.codexHomeKey) ??
+            resolveString(normalizedConfig.codex_home_key);
+        if (!explicitCodexHome && !codexHomeKey) {
+            codexHomeKey = createCodexHomeKeyFromConfig(provider, normalizedConfig);
+            normalizedConfig.codexHomeKey = codexHomeKey;
+        }
+        const resolution = resolveCodexHomeDir(explicitCodexHome, codexHomeKey);
+        codexHomeDir = resolution.codexHomeDir;
+        if (!explicitCodexHome) {
+            envRecord.CODEX_HOME = codexHomeDir;
+            if (normalizedConfig
+                .allowConfigWriteWithUserCodexHome === undefined) {
+                normalizedConfig
+                    .allowConfigWriteWithUserCodexHome = true;
+            }
+        }
+    }
+    if (Object.keys(envRecord).length > 0 || "env" in normalizedConfig) {
+        normalizedConfig.env = envRecord;
+    }
+    return { config: normalizedConfig, codexHomeDir };
+}
+function createClient(provider, config) {
+    if (provider === "claude") {
+        const apiKey = config.apiKey ??
+            config.api_key ??
+            process.env.ANTHROPIC_API_KEY ??
+            "";
+        const clientConfig = {
+            ...config,
+            apiKey,
+        };
+        return new ClaudeClient(clientConfig);
+    }
+    const apiKey = config.apiKey ??
+        config.api_key ??
+        process.env.CODEX_API_KEY ??
+        process.env.OPENAI_API_KEY ??
+        "";
+    const clientConfig = {
+        ...config,
+        apiKey,
+    };
+    return new CodexClient(clientConfig);
+}
+function prepareConfig(provider, config) {
+    const normalized = normalizeBridgeConfig(provider, config).config;
+    const pythonToolsValue = normalized._pythonTools;
+    const pythonTools = Array.isArray(pythonToolsValue)
+        ? pythonToolsValue
+        : [];
+    if ("_pythonTools" in normalized) {
+        delete normalized._pythonTools;
+    }
+    let proxyTools = [];
+    if (pythonTools.length > 0) {
+        if (!pythonToolInvoker) {
+            pythonToolInvoker = new PythonToolInvoker(writePayload);
+        }
+        proxyTools = registerPythonTools(pythonTools, pythonToolInvoker);
+    }
+    const existingTools = Array.isArray(normalized.tools)
+        ? normalized.tools.filter((tool) => tool && typeof tool === "object" && "handler" in tool)
+        : [];
+    if (proxyTools.length > 0 || existingTools.length > 0) {
+        normalized.tools = [...existingTools, ...proxyTools];
+    }
+    return normalized;
+}
+async function runStream(client, params) {
+    activeClient = client;
+    const { events } = await client.runStream(params);
+    for await (const event of events) {
+        writePayload(serializeEvent(event));
+    }
+}
+async function runResume(client, params) {
+    activeClient = client;
+    const { events } = await client.resume(params);
+    for await (const event of events) {
+        writePayload(serializeEvent(event));
+    }
+}
+async function runOnce(client, params) {
+    activeClient = client;
+    const result = await client.run(params);
+    for (const event of result.events) {
+        writePayload(serializeEvent(event));
+    }
+    writePayload({
+        type: "bridge.result",
+        success: result.success,
+        data: result.data,
+        error: result.error ? serializeError(result.error) : undefined,
+    });
+}
+async function main() {
+    try {
+        const input = await readInitialRequest();
+        if (!input.trim()) {
+            throw new Error("Missing JSON request on stdin.");
+        }
+        let request;
+        try {
+            request = JSON.parse(input);
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON request: ${error.message}`);
+        }
+        stdinInterface?.on("line", handleIncomingLine);
+        if (request.action === "normalizeConfig") {
+            const params = request.params ?? {};
+            const provider = resolveProvider(params);
+            if (!provider) {
+                throw new Error('Unable to resolve client. Set params.client to "claude" or "codex".');
+            }
+            const result = normalizeBridgeConfig(provider, asRecord(request.config));
+            writePayload({
+                type: "bridge.result",
+                success: true,
+                data: {
+                    config: result.config,
+                    ...(result.codexHomeDir ? { codexHomeDir: result.codexHomeDir } : {}),
+                },
+            });
+            writePayload({ type: "bridge.done", success: true });
+            return;
+        }
+        if (request.action === "prepareCodexConfig") {
+            await handlePrepareCodexConfig(request);
+            return;
+        }
+        const params = request.params ?? (request.query ? { query: request.query } : null);
+        if (request.action === "resume") {
+            if (!params) {
+                throw new Error("Missing params in request.");
+            }
+            const provider = resolveProvider(params);
+            if (!provider) {
+                throw new Error('Unable to resolve client. Set params.client to "claude" or "codex".');
+            }
+            const sessionId = typeof params.sessionId === "string" ? params.sessionId.trim() : "";
+            if (!sessionId) {
+                throw new Error("Missing sessionId in request.");
+            }
+            const config = prepareConfig(provider, asRecord(request.config));
+            const client = createClient(provider, config);
+            await runResume(client, params);
+            writePayload({ type: "bridge.done", success: true });
+            return;
+        }
+        const provider = resolveProvider(params);
+        if (!provider) {
+            throw new Error('Unable to resolve client. Set params.client to "claude" or "codex".');
+        }
+        const query = typeof params?.query === "string" ? params.query.trim() : "";
+        if (!query) {
+            throw new Error("Missing query in request.");
+        }
+        const config = prepareConfig(provider, asRecord(request.config));
+        const client = createClient(provider, config);
+        const useStream = request.stream !== false;
+        if (useStream) {
+            await runStream(client, params);
+        }
+        else {
+            await runOnce(client, params);
+        }
+        writePayload({ type: "bridge.done", success: true });
+    }
+    finally {
+        pythonToolInvoker?.shutdown();
+        pythonToolInvoker = null;
+        stdinInterface?.close();
+        stdinInterface = null;
+        if (abortTimer) {
+            clearTimeout(abortTimer);
+            abortTimer = null;
+        }
+        activeClient = null;
+    }
+}
+async function handlePrepareCodexConfig(request) {
+    const config = prepareConfig("codex", asRecord(request.config));
+    const apiKey = config.apiKey ??
+        process.env.CODEX_API_KEY ??
+        process.env.OPENAI_API_KEY ??
+        "codex-placeholder";
+    const clientConfig = {
+        ...config,
+        apiKey,
+    };
+    const client = new CodexClient(clientConfig);
+    const codexHomeDir = client.codexHomeDir;
+    writePayload({
+        type: "bridge.result",
+        success: true,
+        data: { codexHomeDir }
+    });
+    writePayload({ type: "bridge.done", success: true });
+}
+main().catch((error) => {
+    writePayload({
+        type: "bridge.error",
+        error: serializeError(error),
+    });
+    process.exitCode = 1;
+});
+//# sourceMappingURL=node-bridge.js.map