@vibe-forge/tsconfigs 0.7.2 → 0.9.0

package/dist/packages/adapters/codex/src/runtime/native-hooks.js

@@ -0,0 +1,69 @@
+import { resolve } from 'node:path';
+import { buildNodeScriptCommand, hasManagedHookPlugins, mergeManagedHookGroups, prepareManagedHookRuntime, readJsonFileOrDefault, resolveManagedHookScriptPath, writeJsonFile } from '@vibe-forge/hooks';
+export const CODEX_NATIVE_HOOK_EVENTS = [
+    'SessionStart',
+    'UserPromptSubmit',
+    'PreToolUse',
+    'PostToolUse',
+    'Stop'
+];
+const isRecord = (value) => (value != null && typeof value === 'object' && !Array.isArray(value));
+const MANAGED_COMMAND_PATH = resolveManagedHookScriptPath('call-hook.js');
+const MANAGED_COMMAND_MARKERS = [
+    MANAGED_COMMAND_PATH,
+    'vf-call-hook',
+    'codex-hook.js',
+    'call-hook.js'
+];
+const isManagedGroup = (group) => (Array.isArray(group.hooks) &&
+    group.hooks.some(hook => MANAGED_COMMAND_MARKERS.some(marker => hook.command.includes(marker))));
+const createManagedGroup = (command, eventName) => ({
+    ...(eventName === 'PreToolUse' || eventName === 'PostToolUse'
+        ? { matcher: '^Bash$' }
+        : {}),
+    hooks: [{
+            type: 'command',
+            command,
+            timeout: 600,
+            statusMessage: `running vibe-forge ${eventName} hook`
+        }]
+});
+export const ensureCodexNativeHooksInstalled = async (ctx) => {
+    const { env, logger, assets } = ctx;
+    env.__VF_PROJECT_AI_CODEX_NATIVE_HOOKS_AVAILABLE__ = '0';
+    const enabled = hasManagedHookPlugins({ assets });
+    try {
+        const { mockHome, nodePath } = prepareManagedHookRuntime(ctx);
+        const hooksPath = resolve(mockHome, '.codex', 'hooks.json');
+        const projectHooksPath = resolve(ctx.cwd, '.codex', 'hooks.json');
+        const existing = await readJsonFileOrDefault(hooksPath, {});
+        const projectHooks = await readJsonFileOrDefault(projectHooksPath, {});
+        const projectHooksConfig = isRecord(projectHooks) && isRecord(projectHooks.hooks)
+            ? projectHooks.hooks
+            : undefined;
+        const projectManagedEvents = new Set(CODEX_NATIVE_HOOK_EVENTS.filter((eventName) => {
+            const hooks = projectHooksConfig?.[eventName];
+            return Array.isArray(hooks) && hooks.some(group => isManagedGroup(group));
+        }));
+        const command = buildNodeScriptCommand({
+            nodePath,
+            scriptPath: MANAGED_COMMAND_PATH
+        });
+        const merged = mergeManagedHookGroups({
+            existing,
+            eventNames: CODEX_NATIVE_HOOK_EVENTS,
+            enabled,
+            isManagedGroup,
+            createGroup: (eventName) => createManagedGroup(command, eventName),
+            shouldManageEvent: (eventName) => !projectManagedEvents.has(eventName)
+        });
+        await writeJsonFile(hooksPath, merged);
+        env.__VF_PROJECT_AI_CODEX_NATIVE_HOOKS_AVAILABLE__ = enabled ? '1' : '0';
+        return enabled;
+    }
+    catch (error) {
+        logger.warn('[codex hooks] failed to install native hook bridge', error);
+        env.__VF_PROJECT_AI_CODEX_NATIVE_HOOKS_AVAILABLE__ = '0';
+        return false;
+    }
+};

package/dist/packages/adapters/codex/src/runtime/proxy.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from '@vibe-forge/utils/create-logger';
+export declare const CODEX_PROXY_META_HEADER_NAME = "X-Vibe-Forge-Proxy-Meta";
+type CodexProxyLogger = Logger;
+interface CodexProxyLogContext {
+    cwd: string;
+    ctxId: string;
+    sessionId: string;
+}
+export interface CodexProxyMeta {
+    upstreamBaseUrl: string;
+    queryParams?: Record<string, string>;
+    headers?: Record<string, string>;
+    maxOutputTokens?: number;
+    logContext?: CodexProxyLogContext;
+}
+export declare const encodeCodexProxyMeta: (meta: CodexProxyMeta) => string;
+export declare const ensureCodexProxyServer: (logger?: CodexProxyLogger) => Promise<{
+    baseUrl: string;
+}>;
+export {};

package/dist/packages/adapters/codex/src/runtime/proxy.js

@@ -0,0 +1,299 @@
+import { createLogger } from '@vibe-forge/utils/create-logger';
+import { Buffer } from 'node:buffer';
+import { createServer } from 'node:http';
+import { Readable } from 'node:stream';
+export const CODEX_PROXY_META_HEADER_NAME = 'X-Vibe-Forge-Proxy-Meta';
+const REQUEST_HEADERS_TO_DROP = new Set([
+    'connection',
+    'content-length',
+    'host',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'te',
+    'trailer',
+    'transfer-encoding',
+    'upgrade'
+]);
+const RESPONSE_HEADERS_TO_DROP = new Set([
+    'connection',
+    'content-length',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'te',
+    'trailer',
+    'transfer-encoding',
+    'upgrade'
+]);
+let proxyServerPromise;
+let proxyServerLogger;
+const requestLoggerCache = new Map();
+export const encodeCodexProxyMeta = (meta) => Buffer.from(JSON.stringify(meta), 'utf8').toString('base64url');
+const decodeCodexProxyMeta = (rawValue) => {
+    const decoded = Buffer.from(rawValue, 'base64url').toString('utf8');
+    return JSON.parse(decoded);
+};
+const readRequestBody = async (req) => {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks);
+};
+const isPlainObject = (value) => value != null && typeof value === 'object' && !Array.isArray(value);
+const normalizeContentType = (value) => {
+    const normalizedValue = Array.isArray(value) ? value[0] : value;
+    return normalizedValue?.split(';', 1)[0]?.trim().toLowerCase();
+};
+const looksLikeJsonPayload = (buffer) => {
+    const text = buffer.toString('utf8').trimStart();
+    return text.startsWith('{') || text.startsWith('[');
+};
+const maybeInjectMaxOutputTokens = (requestBodyBuffer, req, proxyMeta) => {
+    if (requestBodyBuffer.length === 0)
+        return undefined;
+    const normalizedMaxOutputTokens = (typeof proxyMeta.maxOutputTokens === 'number' &&
+        Number.isFinite(proxyMeta.maxOutputTokens) &&
+        proxyMeta.maxOutputTokens > 0)
+        ? Math.floor(proxyMeta.maxOutputTokens)
+        : undefined;
+    if (normalizedMaxOutputTokens == null)
+        return requestBodyBuffer;
+    const contentType = normalizeContentType(req.headers['content-type']);
+    const shouldInspectJson = contentType === 'application/json' ||
+        contentType?.endsWith('+json') === true ||
+        looksLikeJsonPayload(requestBodyBuffer);
+    if (!shouldInspectJson)
+        return requestBodyBuffer;
+    const requestBodyText = requestBodyBuffer.toString('utf8');
+    try {
+        const parsedBody = JSON.parse(requestBodyText);
+        if (!isPlainObject(parsedBody) || parsedBody.max_output_tokens != null) {
+            return requestBodyText;
+        }
+        parsedBody.max_output_tokens = normalizedMaxOutputTokens;
+        return JSON.stringify(parsedBody);
+    }
+    catch {
+        return requestBodyText;
+    }
+};
+const toFetchBody = (body) => {
+    if (body == null)
+        return undefined;
+    if (typeof body === 'string')
+        return body;
+    return new Uint8Array(body);
+};
+const writeJsonError = (res, statusCode, message) => {
+    if (res.headersSent) {
+        res.end();
+        return;
+    }
+    res.writeHead(statusCode, {
+        'Content-Type': 'application/json'
+    });
+    res.end(JSON.stringify({
+        error: {
+            message
+        }
+    }));
+};
+const buildUpstreamUrl = (upstreamBaseUrl, requestUrl, queryParams) => {
+    const normalizedBaseUrl = upstreamBaseUrl.endsWith('/')
+        ? upstreamBaseUrl.slice(0, -1)
+        : upstreamBaseUrl;
+    const upstreamUrl = new URL(`${normalizedBaseUrl}${requestUrl}`);
+    for (const [key, value] of Object.entries(queryParams)) {
+        upstreamUrl.searchParams.set(key, value);
+    }
+    return upstreamUrl;
+};
+const normalizeHeaderValue = (value) => (Array.isArray(value) ? value.join(', ') : value);
+const summarizeProxyMeta = (proxyMeta) => ({
+    upstreamBaseUrl: proxyMeta.upstreamBaseUrl,
+    queryParamKeys: Object.keys(proxyMeta.queryParams ?? {}),
+    headerKeys: Object.keys(proxyMeta.headers ?? {}),
+    hasMaxOutputTokens: typeof proxyMeta.maxOutputTokens === 'number'
+});
+const summarizeRequest = (req) => ({
+    method: req.method,
+    requestUrl: req.url,
+    contentType: normalizeContentType(req.headers['content-type']),
+    hasAuthorizationHeader: normalizeHeaderValue(req.headers.authorization) != null
+});
+const summarizeUpstreamUrl = (upstreamUrl) => ({
+    upstreamOrigin: upstreamUrl.origin,
+    upstreamPath: upstreamUrl.pathname,
+    queryParamKeys: Array.from(new Set(upstreamUrl.searchParams.keys()))
+});
+const getErrorCause = (err) => (err instanceof Error && 'cause' in err ? err.cause : undefined);
+const getRequestLogger = (logContext) => {
+    if (logContext == null)
+        return undefined;
+    const cacheKey = `${logContext.cwd}\n${logContext.ctxId}\n${logContext.sessionId}`;
+    const cached = requestLoggerCache.get(cacheKey);
+    if (cached != null)
+        return cached;
+    const logger = createLogger(logContext.cwd, `${logContext.ctxId}/${logContext.sessionId}/adapter-codex`, 'proxy');
+    requestLoggerCache.set(cacheKey, logger);
+    return logger;
+};
+const handleProxyRequest = async (req, res, logger) => {
+    const rawMetaHeader = normalizeHeaderValue(req.headers[CODEX_PROXY_META_HEADER_NAME.toLowerCase()]);
+    if (typeof rawMetaHeader !== 'string' || rawMetaHeader.trim() === '') {
+        logger?.warn('[codex proxy] missing proxy metadata header', summarizeRequest(req));
+        writeJsonError(res, 400, `Missing required ${CODEX_PROXY_META_HEADER_NAME} header`);
+        return;
+    }
+    let proxyMeta;
+    try {
+        proxyMeta = decodeCodexProxyMeta(rawMetaHeader);
+    }
+    catch {
+        logger?.warn('[codex proxy] invalid proxy metadata header', summarizeRequest(req));
+        writeJsonError(res, 400, `Invalid ${CODEX_PROXY_META_HEADER_NAME} header`);
+        return;
+    }
+    const requestLogger = getRequestLogger(proxyMeta.logContext) ?? logger;
+    if (typeof proxyMeta.upstreamBaseUrl !== 'string' || proxyMeta.upstreamBaseUrl.trim() === '') {
+        requestLogger?.warn('[codex proxy] invalid proxy metadata', {
+            ...summarizeRequest(req),
+            ...summarizeProxyMeta(proxyMeta)
+        });
+        writeJsonError(res, 400, 'Invalid proxy metadata: upstreamBaseUrl is required');
+        return;
+    }
+    let requestBodyBuffer;
+    try {
+        requestBodyBuffer = await readRequestBody(req);
+    }
+    catch {
+        writeJsonError(res, 400, 'Failed to read request body');
+        return;
+    }
+    const upstreamBody = maybeInjectMaxOutputTokens(requestBodyBuffer, req, proxyMeta);
+    const upstreamHeaders = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+        const normalizedKey = key.toLowerCase();
+        const normalizedValue = normalizeHeaderValue(value);
+        if (normalizedValue == null)
+            continue;
+        if (REQUEST_HEADERS_TO_DROP.has(normalizedKey))
+            continue;
+        if (normalizedKey === CODEX_PROXY_META_HEADER_NAME.toLowerCase())
+            continue;
+        upstreamHeaders.set(key, normalizedValue);
+    }
+    for (const [key, value] of Object.entries(proxyMeta.headers ?? {})) {
+        upstreamHeaders.set(key, value);
+    }
+    const requestUrl = req.url ?? '/responses';
+    const upstreamUrl = buildUpstreamUrl(proxyMeta.upstreamBaseUrl, requestUrl, proxyMeta.queryParams ?? {});
+    requestLogger?.debug('[codex proxy] forwarding request', {
+        ...summarizeRequest(req),
+        ...summarizeProxyMeta(proxyMeta),
+        ...summarizeUpstreamUrl(upstreamUrl)
+    });
+    const abortController = new AbortController();
+    const abortRequest = () => abortController.abort();
+    const abortOnRequestAborted = () => abortRequest();
+    const abortOnResponseClosed = () => {
+        if (!res.writableEnded) {
+            requestLogger?.warn('[codex proxy] downstream connection closed before response completed', {
+                ...summarizeRequest(req),
+                ...summarizeProxyMeta(proxyMeta),
+                ...summarizeUpstreamUrl(upstreamUrl)
+            });
+            abortRequest();
+        }
+    };
+    req.once('aborted', abortOnRequestAborted);
+    res.once('close', abortOnResponseClosed);
+    try {
+        const upstreamResponse = await fetch(upstreamUrl, {
+            method: req.method ?? 'POST',
+            headers: upstreamHeaders,
+            body: toFetchBody(upstreamBody),
+            signal: abortController.signal
+        });
+        if (!upstreamResponse.ok) {
+            requestLogger?.warn('[codex proxy] upstream returned error status', {
+                ...summarizeRequest(req),
+                ...summarizeProxyMeta(proxyMeta),
+                ...summarizeUpstreamUrl(upstreamUrl),
+                status: upstreamResponse.status,
+                statusText: upstreamResponse.statusText
+            });
+        }
+        const responseHeaders = new Headers();
+        upstreamResponse.headers.forEach((value, key) => {
+            if (RESPONSE_HEADERS_TO_DROP.has(key.toLowerCase()))
+                return;
+            responseHeaders.set(key, value);
+        });
+        res.writeHead(upstreamResponse.status, Object.fromEntries(responseHeaders.entries()));
+        if (upstreamResponse.body == null) {
+            res.end();
+            return;
+        }
+        Readable.fromWeb(upstreamResponse.body).pipe(res);
+    }
+    catch (err) {
+        if (abortController.signal.aborted) {
+            res.end();
+            return;
+        }
+        requestLogger?.error('[codex proxy] upstream request failed', {
+            err,
+            cause: getErrorCause(err),
+            ...summarizeRequest(req),
+            ...summarizeProxyMeta(proxyMeta),
+            ...summarizeUpstreamUrl(upstreamUrl)
+        });
+        writeJsonError(res, 502, err instanceof Error ? err.message : String(err));
+    }
+    finally {
+        req.off('aborted', abortOnRequestAborted);
+        res.off('close', abortOnResponseClosed);
+    }
+};
+export const ensureCodexProxyServer = async (logger) => {
+    if (logger != null) {
+        proxyServerLogger = logger;
+    }
+    if (proxyServerPromise == null) {
+        proxyServerPromise = new Promise((resolve, reject) => {
+            proxyServerLogger?.info('[codex proxy] starting local proxy server');
+            const server = createServer((req, res) => {
+                void handleProxyRequest(req, res, proxyServerLogger);
+            });
+            server.once('error', (err) => {
+                proxyServerLogger?.error('[codex proxy] local proxy server failed', { err });
+                proxyServerPromise = undefined;
+                reject(err);
+            });
+            server.once('close', () => {
+                proxyServerLogger?.info('[codex proxy] local proxy server closed');
+                proxyServerPromise = undefined;
+            });
+            server.listen(0, '127.0.0.1', () => {
+                const address = server.address();
+                if (address == null || typeof address === 'string') {
+                    server.close();
+                    reject(new Error('Failed to resolve local Codex proxy address'));
+                    return;
+                }
+                server.unref();
+                proxyServerLogger?.info('[codex proxy] local proxy server ready', {
+                    baseUrl: `http://127.0.0.1:${address.port}`
+                });
+                resolve({
+                    baseUrl: `http://127.0.0.1:${address.port}`
+                });
+            });
+        });
+    }
+    return proxyServerPromise;
+};

package/dist/packages/adapters/codex/src/runtime/session-common.d.ts

@@ -0,0 +1,49 @@
+import type { AdapterCtx, AdapterQueryOptions } from '@vibe-forge/types';
+import type { CodexInputItem, CodexSandboxPolicy } from '#~/types.js';
+export type CodexApprovalPolicy = 'never' | 'unlessTrusted' | 'onRequest';
+export type CodexOutboundApprovalPolicy = 'never' | 'untrusted' | 'on-request';
+export declare function toCodexOutboundApprovalPolicy(approvalPolicy: CodexApprovalPolicy): CodexOutboundApprovalPolicy;
+/**
+ * Build `--enable <name>` / `--disable <name>` args from a features map.
+ */
+export declare function buildFeatureArgs(features: Record<string, boolean>): string[];
+/**
+ * Map an array of vibe-forge `AdapterMessageContent` to Codex `turn/start` input items.
+ */
+export declare function mapContentToCodexInput(content: Array<{
+    type: string;
+    text?: string;
+    url?: string;
+    [k: string]: unknown;
+}>): CodexInputItem[];
+export interface CodexSessionBase {
+    logger: AdapterCtx['logger'];
+    cwd: string;
+    binaryPath: string;
+    spawnEnv: NodeJS.ProcessEnv;
+    useYolo: boolean;
+    approvalPolicy: CodexApprovalPolicy;
+    sandboxPolicy: CodexSandboxPolicy;
+    features: Record<string, boolean>;
+    configOverrideArgs: string[];
+    resolvedModel: string | undefined;
+    resolvedMaxOutputTokens: number | null | undefined;
+    threadCacheKey: string;
+    cachedThreadId: string | undefined;
+}
+export declare const getErrorSummary: (err: unknown) => string;
+export declare const getErrorDetails: (err: unknown) => unknown;
+export declare const getErrorMessage: (err: unknown) => string;
+export declare const toAdapterErrorData: (err: unknown, overrides?: Partial<{
+    message: string;
+    code: string;
+    details: unknown;
+    fatal: boolean;
+}>) => {
+    fatal: boolean;
+    details?: unknown;
+    code?: string | undefined;
+    message: string;
+};
+export declare const isInvalidEncryptedContentError: (err: unknown) => boolean;
+export declare function resolveSessionBase(ctx: AdapterCtx, options: AdapterQueryOptions): Promise<CodexSessionBase>;