@ai-sdk/harness-codex 1.0.0-canary.2 → 1.0.0-canary.4

package/src/codex-bridge-protocol.ts

@@ -20,15 +20,6 @@ export const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
   instructions: z.string().optional(),
   reasoningEffort: z.enum(['low', 'medium', 'high']).optional(),
   webSearch: z.boolean().optional(),
-  skills: z
-    .array(
-      z.object({
-        name: z.string(),
-        description: z.string(),
-        content: z.string(),
-      }),
-    )
-    .optional(),
   // Resume signal. When supplied, the bridge calls
   // `codex.resumeThread(resumeThreadId, …)` instead of starting a fresh thread.
   // The host sources the id from lifecycle state `data` cached from a prior

package/src/codex-harness.ts

@@ -1,5 +1,6 @@
 import { randomBytes } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
+import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
   commonTool,
@@ -19,16 +20,20 @@ import {
   type HarnessV1Skill,
   type HarnessV1StreamPart,
 } from '@ai-sdk/harness';
-import { classifyDiskLog, SandboxChannel } from '@ai-sdk/harness/utils';
 import {
-  safeParseJSON,
+  classifyDiskLog,
+  markBridgeStarting,
+  SandboxChannel,
+  waitForBridgeReady,
+} from '@ai-sdk/harness/utils';
+import {
   type Experimental_SandboxProcess,
+  type Experimental_SandboxSession,
 } from '@ai-sdk/provider-utils';
 import { WebSocket } from 'ws';
 import { z } from 'zod';
 import { resolveCodexEnv, type CodexAuthOptions } from './codex-auth';
 import {
-  bridgeReadySchema,
   outboundMessageSchema,
   type InboundMessage,
   type OutboundMessage,
@@ -37,6 +42,11 @@ import {
 type CodexChannel = SandboxChannel<OutboundMessage, InboundMessage>;
 type CodexRespawnStrategy = 'replay' | 'rerun';
 
+type WriteSkillsResult = {
+  readonly homeDir: string;
+  readonly codexHomeDir: string;
+};
+
 /*
  * The model the adapter pins when the consumer configures none. The Codex SDK
  * does not report the model it resolves to at runtime (no model field on any
@@ -258,7 +268,6 @@ export function createCodex(
             channel: attachChannel,
             // The live bridge was spawned by another process; no process handle.
             proc: undefined,
-            skills: startOpts.skills,
             model: settings.model ?? DEFAULT_CODEX_MODEL,
             reasoningEffort: settings.reasoningEffort,
             webSearch: settings.webSearch,
@@ -302,10 +311,24 @@ export function createCodex(
 
       const port = resolveBridgePort(sandboxSession, settings.port);
       const token = randomBytes(32).toString('hex');
+      const codexSkillSetup =
+        startOpts.skills && startOpts.skills.length > 0
+          ? await writeSkills({
+              sandbox: session,
+              skills: startOpts.skills,
+              abortSignal: startOpts.abortSignal,
+            })
+          : undefined;
       const env = {
         ...resolveCodexEnv(settings.auth),
         BRIDGE_CHANNEL_TOKEN: token,
         BRIDGE_WS_PORT: String(port),
+        ...(codexSkillSetup
+          ? {
+              HOME: codexSkillSetup.homeDir,
+              CODEX_HOME: codexSkillSetup.codexHomeDir,
+            }
+          : {}),
         ...(respawnStrategy === 'replay'
           ? { BRIDGE_REPLAY_FROM_DISK: '1' }
           : {}),
@@ -318,6 +341,13 @@ export function createCodex(
         });
       }
 
+      await markBridgeStarting({
+        sandbox: session,
+        bridgeStateDir,
+        bridgeType: 'codex',
+        abortSignal: startOpts.abortSignal,
+      });
+
       const proc = await session.spawn({
         command: `node ${BOOTSTRAP_DIR}/bridge.mjs --workdir ${workDir} --bridge-state-dir ${bridgeStateDir} --bootstrap-dir ${BOOTSTRAP_DIR}`,
         env,
@@ -326,9 +356,27 @@ export function createCodex(
 
       const { port: boundPort } = await waitForBridgeReady({
         proc,
+        sandbox: session,
+        bridgeStateDir,
+        bridgeType: 'codex',
         timeoutMs,
         abortSignal: startOpts.abortSignal,
+        createTimeoutError: () =>
+          new Error('codex bridge did not become ready in time.'),
+        createExitError: () =>
+          new Error('codex bridge exited before becoming ready.'),
       });
+      void drainRest(proc.stdout);
+      /*
+       * Bridge stderr is the only diagnostic channel for what happens
+       * inside the sandbox once the bridge is running (uncaught
+       * exceptions, Codex SDK errors, network failures). Forward it
+       * line-by-line to the host console so a mid-turn bridge crash can
+       * be inspected from `pnpm dev` logs without redeploying. The
+       * bridge itself writes nothing to stderr in steady state, so this
+       * is silent on the happy path.
+       */
+      void forwardBridgeStderr(proc.stderr);
 
       const wsUrl =
         (await sandboxSession.getPortUrl({
@@ -355,7 +403,6 @@ export function createCodex(
         sessionId: startOpts.sessionId,
         channel,
         proc,
-        skills: startOpts.skills,
         model: settings.model ?? DEFAULT_CODEX_MODEL,
         reasoningEffort: settings.reasoningEffort,
         webSearch: settings.webSearch,
@@ -405,86 +452,119 @@ async function readBridgeAsset(name: string): Promise<string> {
   throw lastErr ?? new Error(`bridge asset not found: ${name}`);
 }
 
-async function waitForBridgeReady({
-  proc,
-  timeoutMs,
+async function writeSkills({
+  sandbox,
+  skills,
   abortSignal,
 }: {
-  proc: Experimental_SandboxProcess;
-  timeoutMs: number;
-  abortSignal: AbortSignal | undefined;
-}): Promise<{ port: number }> {
-  const reader = proc.stdout.pipeThrough(new TextDecoderStream()).getReader();
+  sandbox: Experimental_SandboxSession;
+  skills: ReadonlyArray<HarnessV1Skill>;
+  abortSignal?: AbortSignal;
+}): Promise<WriteSkillsResult> {
+  for (const skill of skills) {
+    safeCodexSkillName(skill.name);
+    for (const file of skill.files ?? []) {
+      safeCodexSkillFilePath({
+        skillName: skill.name,
+        filePath: file.path,
+      });
+    }
+  }
 
-  const decoder = lineDecoder();
+  const homeDir = await resolveSandboxHomeDir({ sandbox, abortSignal });
+  const codexHomeDir = path.posix.join(homeDir, '.codex');
+  await sandbox.run({
+    command: `mkdir -p ${shellQuote(codexHomeDir)}`,
+    abortSignal,
+  });
 
-  const deadline = Date.now() + timeoutMs;
-  try {
-    while (true) {
-      if (abortSignal?.aborted) {
-        await proc.kill();
-        throw abortSignal.reason ?? new DOMException('Aborted', 'AbortError');
-      }
-      const remaining = deadline - Date.now();
-      if (remaining <= 0) {
-        await proc.kill();
-        throw new Error('codex bridge did not become ready in time.');
-      }
-      const { value, done } = (await Promise.race([
-        reader.read(),
-        new Promise(resolve =>
-          setTimeout(
-            () => resolve({ value: undefined, done: false }),
-            remaining,
-          ),
-        ),
-      ])) as ReadableStreamReadResult<string>;
-      if (done) {
-        throw new Error('codex bridge exited before becoming ready.');
-      }
-      if (value === undefined) continue;
-      for (const line of decoder.push(value)) {
-        const parsed = await safeParseJSON({
-          text: line,
-          schema: bridgeReadySchema,
-        });
-        if (parsed.success) return { port: parsed.value.port };
-      }
+  const rootDir = path.posix.join(homeDir, '.agents', 'skills');
+  await sandbox.run({
+    command: `mkdir -p ${shellQuote(rootDir)}`,
+    abortSignal,
+  });
+
+  for (const skill of skills) {
+    const name = safeCodexSkillName(skill.name);
+    const skillDir = path.posix.join(rootDir, name);
+    const content = `---\nname: ${skill.name}\ndescription: ${skill.description}\n---\n\n${skill.content}`;
+
+    await sandbox.writeTextFile({
+      path: path.posix.join(skillDir, 'SKILL.md'),
+      content,
+      abortSignal,
+    });
+
+    for (const file of skill.files ?? []) {
+      const filePath = safeCodexSkillFilePath({
+        skillName: skill.name,
+        filePath: file.path,
+      });
+      await sandbox.writeTextFile({
+        path: path.posix.join(skillDir, filePath),
+        content: file.content,
+        abortSignal,
+      });
     }
-  } finally {
-    reader.releaseLock();
-    void drainRest(proc.stdout);
-    /*
-     * Bridge stderr is the only diagnostic channel for what happens
-     * inside the sandbox once the bridge is running (uncaught
-     * exceptions, Codex SDK errors, network failures). Forward it
-     * line-by-line to the host console so a mid-turn bridge crash can
-     * be inspected from `pnpm dev` logs without redeploying. The
-     * bridge itself writes nothing to stderr in steady state, so this
-     * is silent on the happy path.
-     */
-    void forwardBridgeStderr(proc.stderr);
   }
-}
 
-function lineDecoder() {
-  let buffer = '';
   return {
-    push(chunk: string): string[] {
-      buffer += chunk;
-      const lines: string[] = [];
-      let nl: number;
-      while ((nl = buffer.indexOf('\n')) !== -1) {
-        const raw = buffer.slice(0, nl);
-        buffer = buffer.slice(nl + 1);
-        const line = raw.replace(/\r$/, '').trim();
-        if (line.length > 0) lines.push(line);
-      }
-      return lines;
-    },
+    homeDir,
+    codexHomeDir,
   };
 }
 
+async function resolveSandboxHomeDir({
+  sandbox,
+  abortSignal,
+}: {
+  sandbox: Experimental_SandboxSession;
+  abortSignal?: AbortSignal;
+}): Promise<string> {
+  const result = await sandbox.run({
+    command: 'printf "%s" "$HOME"',
+    abortSignal,
+  });
+  const homeDir = result.stdout.trim();
+  if (result.exitCode !== 0 || !homeDir || !path.posix.isAbsolute(homeDir)) {
+    throw new Error(
+      `Unable to resolve sandbox HOME directory: ${result.stderr || result.stdout}`,
+    );
+  }
+  return homeDir;
+}
+
+function safeCodexSkillName(name: string): string {
+  if (!/^[A-Za-z0-9._-]+$/.test(name) || name === '.' || name === '..') {
+    throw new Error(`Invalid Codex skill name: ${name}`);
+  }
+  return name;
+}
+
+function safeCodexSkillFilePath({
+  skillName,
+  filePath,
+}: {
+  skillName: string;
+  filePath: string;
+}): string {
+  const normalized = path.posix.normalize(filePath);
+  if (
+    normalized === '.' ||
+    normalized.startsWith('../') ||
+    path.posix.isAbsolute(normalized)
+  ) {
+    throw new Error(
+      `Invalid Codex skill file path for ${skillName}: ${filePath}`,
+    );
+  }
+  return normalized;
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
 async function forwardBridgeStderr(
   stream: ReadableStream<Uint8Array>,
 ): Promise<void> {
@@ -536,7 +616,6 @@ function createSession({
   sessionId,
   channel,
   proc,
-  skills,
   model,
   reasoningEffort,
   webSearch,
@@ -554,7 +633,6 @@ function createSession({
   channel: CodexChannel;
   /** Undefined on `attach` — the live bridge was spawned by another process. */
   proc: Experimental_SandboxProcess | undefined;
-  skills: ReadonlyArray<HarnessV1Skill> | undefined;
   model: string | undefined;
   reasoningEffort: 'low' | 'medium' | 'high' | undefined;
   webSearch: boolean | undefined;
@@ -758,15 +836,6 @@ function createSession({
         reasoningEffort,
         webSearch,
         ...(permissionMode ? { permissionMode } : {}),
-        ...(skills && skills.length > 0
-          ? {
-              skills: skills.map(s => ({
-                name: s.name,
-                description: s.description,
-                content: s.content,
-              })),
-            }
-          : {}),
         ...(pendingResumeThreadId
           ? { resumeThreadId: pendingResumeThreadId }
           : {}),