@kaiba-cloud/orbital-harness-codex 0.0.0-stage → 0.0.1

package/dist/plugin.js

@@ -0,0 +1,104 @@
+import { createRequire as __orbitalCreateRequire } from 'node:module';
+const require = __orbitalCreateRequire(import.meta.url);
+import {
+  servePlugin
+} from "./chunks/chunk-MJXEEIFC.js";
+
+// src/plugin.ts
+import { fileURLToPath } from "node:url";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var SERVER = "orbital";
+function quote(value) {
+  return JSON.stringify(value);
+}
+function serverBlock(program, harness) {
+  const [command = "orbital", ...rest] = program;
+  const args = [...rest, "mcp", "--attach", "--harness", harness, "--agent", harness];
+  return [`[mcp_servers.${SERVER}]`, `command = ${quote(command)}`, `args = [${args.map(quote).join(", ")}]`, ""].join("\n");
+}
+function headerName(line) {
+  const match = /^\s*\[\[?\s*([^\]]+?)\s*\]\]?\s*(?:#.*)?$/.exec(line);
+  if (!match) return null;
+  return match[1].split(".").map((part) => part.trim().replace(/^(["'])(.*)\1$/, "$2")).join(".");
+}
+function splitSections(text) {
+  const sections = [{ name: null, lines: [] }];
+  let inString = null;
+  for (const line of text.split("\n")) {
+    const name = inString === null ? headerName(line) : null;
+    if (name !== null) sections.push({ name, lines: [line] });
+    else sections.at(-1).lines.push(line);
+    for (const fence of ['"""', "'''"]) {
+      const count = line.split(fence).length - 1;
+      if (count % 2 === 1) inString = inString === fence ? null : inString === null ? fence : inString;
+    }
+  }
+  return sections;
+}
+function ownsServer(name) {
+  return name === `mcp_servers.${SERVER}` || (name?.startsWith(`mcp_servers.${SERVER}.`) ?? false);
+}
+function definesInOtherForm(sections) {
+  return sections.some((section) => section.lines.some((line) => section.name === null && new RegExp(`^\\s*mcp_servers\\s*\\.\\s*${SERVER}\\b`).test(line) || section.name === "mcp_servers" && new RegExp(`^\\s*${SERVER}\\s*=`).test(line)));
+}
+function mergeServer(existing, block, force) {
+  if (existing === null || existing.trim() === "") return { text: block, outcome: "added" };
+  const sections = splitSections(existing);
+  if (definesInOtherForm(sections)) return { text: existing, outcome: "unsupported" };
+  const owned = sections.filter((section) => ownsServer(section.name));
+  if (owned.length === 0) {
+    const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+    return { text: `${existing}${separator}${block}`, outcome: "added" };
+  }
+  const current = owned.map((section) => section.lines.join("\n")).join("\n").trimEnd();
+  if (current === block.trimEnd()) return { text: existing, outcome: "same" };
+  if (!force) return { text: existing, outcome: "kept" };
+  let placed = false;
+  const kept = sections.flatMap((section) => {
+    if (section.lines.length === 0) return [];
+    if (!ownsServer(section.name)) return [section.lines.join("\n")];
+    if (placed) return [];
+    placed = true;
+    return [block];
+  });
+  const joined = kept.join("\n");
+  return { text: joined.endsWith("\n") ? joined : `${joined}
+`, outcome: "replaced" };
+}
+function installServer(folder, program, harness, force) {
+  const file = join(folder, "config.toml");
+  const existing = existsSync(file) ? readFileSync(file, "utf8") : null;
+  const merged = mergeServer(existing, serverBlock(program, harness), force);
+  if (merged.outcome === "unsupported") return { written: [], notes: [`${file} defines the MCP server ${SERVER} in a form that install does not edit: it kept the file`] };
+  if (merged.outcome === "kept") return { written: [], notes: [`${file} already defines the MCP server ${SERVER} differently: it kept the file, and --force replaces the definition`] };
+  if (merged.outcome === "same") return { written: [], notes: [] };
+  mkdirSync(folder, { recursive: true });
+  writeFileSync(file, merged.text);
+  return { written: [file], notes: [`codex reaches the orbital tools through the MCP server ${SERVER} in ${file}, when it trusts this project`] };
+}
+
+// src/plugin.ts
+var NAME = "orbital-harness-codex";
+var HARNESS = "codex";
+var FOLDER = { folder: ".codex", instructions: "AGENTS.md", agents: "agents", skills: "skills" };
+var EGRESS = ["api.openai.com", "chatgpt.com", "auth.openai.com"];
+function plugin() {
+  return {
+    name: NAME,
+    version: "0.0.1",
+    permissions: { network: [], secrets: [], models: [] },
+    ports: {
+      harnesses: {
+        harnesses: [{ id: HARNESS, description: "The OpenAI Codex CLI: its own login, its shell and file edits, and the orbital tools.", callsModel: false, browser: true, folder: FOLDER }],
+        command: async () => ({ command: [process.execPath, fileURLToPath(new URL("turn.js", import.meta.url))], egress: EGRESS }),
+        install: async (request) => installServer(request.folder, request.program, HARNESS, request.force)
+      }
+    }
+  };
+}
+
+// src/main.ts
+servePlugin(() => plugin());

package/dist/turn.js

@@ -0,0 +1,280 @@
+import { createRequire as __orbitalCreateRequire } from 'node:module';
+const require = __orbitalCreateRequire(import.meta.url);
+import {
+  browserEnv,
+  browserServerBlock,
+  isBrowserServer,
+  replaceMcpServers,
+  textPart,
+  thinkingPart,
+  toolCallPart,
+  toolResultPart
+} from "./chunks/chunk-MJXEEIFC.js";
+
+// src/turn.ts
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { createInterface } from "node:readline";
+
+// src/args.ts
+var DEFAULT_PROVIDER = "openai";
+var DEFAULT_MODEL = "default";
+var MCP_SERVER = "orbital";
+function modelOf(model) {
+  if (!model) return { provider: DEFAULT_PROVIDER, model: null };
+  const colon = model.indexOf(":");
+  if (colon === -1) return { provider: DEFAULT_PROVIDER, model };
+  return { provider: model.slice(0, colon), model: model.slice(colon + 1) };
+}
+function toml(value) {
+  return JSON.stringify(value);
+}
+function mcpOverrides(command, env) {
+  const [program, ...args] = command;
+  if (!program) return [];
+  const names = Object.keys(env);
+  return [
+    `mcp_servers.${MCP_SERVER}.command=${toml(program)}`,
+    `mcp_servers.${MCP_SERVER}.args=${toml(args)}`,
+    ...names.length > 0 ? [`mcp_servers.${MCP_SERVER}.env_vars=${toml(names)}`] : []
+  ];
+}
+function codexArgs(spec, threadId) {
+  const choice = modelOf(spec.model);
+  const overrides = [
+    ...choice.provider === DEFAULT_PROVIDER ? [] : [`model_provider=${toml(choice.provider)}`],
+    `developer_instructions=${toml(spec.systemPrompt)}`,
+    ...mcpOverrides(spec.tools.command, spec.tools.env)
+  ];
+  return [
+    "exec",
+    ...threadId ? ["resume", threadId] : [],
+    "--json",
+    "--skip-git-repo-check",
+    "--dangerously-bypass-approvals-and-sandbox",
+    "--disable",
+    "multi_agent",
+    "--disable",
+    "goals",
+    ...choice.model ? ["-m", choice.model] : [],
+    ...overrides.flatMap((override) => ["-c", override]),
+    "--",
+    spec.prompt
+  ];
+}
+function childEnv(spec, base, codexHome) {
+  const merged = { ...base, ...spec.env, ...spec.tools.env, ...spec.browser && browserEnv(spec.browser), CODEX_HOME: codexHome };
+  return Object.fromEntries(Object.entries(merged).filter((entry) => typeof entry[1] === "string"));
+}
+
+// src/lines.ts
+var NO_USAGE = { input_tokens: 0, cached_input_tokens: 0, cache_write_input_tokens: 0, output_tokens: 0, reasoning_output_tokens: 0 };
+function failureText(message) {
+  try {
+    const parsed = JSON.parse(message);
+    return typeof parsed.error?.message === "string" ? parsed.error.message : message;
+  } catch {
+    return message;
+  }
+}
+function callOf(item) {
+  if (item.type === "command_execution") return toolCallPart({ id: item.id, name: "Bash", input: { command: item.command ?? "" } });
+  if (item.type === "mcp_tool_call") return toolCallPart({ id: item.id, name: `mcp__${item.server ?? "mcp"}__${item.tool ?? "tool"}`, input: item.arguments ?? {} });
+  if (item.type === "file_change") {
+    const changes = item.changes ?? [];
+    return toolCallPart({ id: item.id, name: "apply_patch", input: { path: changes[0]?.path ?? "", changes } });
+  }
+  return null;
+}
+function mcpText(item) {
+  if (item.error?.message) return item.error.message;
+  return (item.result?.content ?? []).flatMap((part) => part.type === "text" && part.text ? [part.text] : part.type === "image" ? ["[image]"] : []).join("\n");
+}
+function resultOf(item) {
+  if (item.type === "command_execution") return toolResultPart({ callId: item.id, name: "Bash", text: item.aggregated_output ?? "", isError: item.status !== "completed" || (item.exit_code ?? 0) !== 0 });
+  if (item.type === "mcp_tool_call") return toolResultPart({ callId: item.id, name: `mcp__${item.server ?? "mcp"}__${item.tool ?? "tool"}`, text: mcpText(item), isError: item.status !== "completed" });
+  if (item.type === "file_change") return toolResultPart({ callId: item.id, name: "apply_patch", text: (item.changes ?? []).map((change) => `${change.kind} ${change.path}`).join("\n"), isError: item.status !== "completed" });
+  return null;
+}
+var TurnLines = class {
+  threadId = null;
+  answer = null;
+  failure = null;
+  completed = false;
+  usage = null;
+  called = /* @__PURE__ */ new Set();
+  handle(event) {
+    if (event.type === "thread.started") {
+      this.threadId = event.thread_id;
+      return [];
+    }
+    if (event.type === "turn.completed") {
+      this.completed = true;
+      this.usage = event.usage;
+      return [];
+    }
+    if (event.type === "turn.failed") {
+      this.failure = failureText(event.error.message);
+      return [];
+    }
+    if (event.type === "item.started") return this.started(event.item);
+    if (event.type === "item.completed") return this.finished(event.item);
+    return [];
+  }
+  started(item) {
+    const call = callOf(item);
+    if (!call || this.called.has(item.id)) return [];
+    this.called.add(item.id);
+    return [{ role: "ROLE_AGENT", parts: [call] }];
+  }
+  finished(item) {
+    if (item.type === "agent_message" && item.text) {
+      this.answer = item.text;
+      return [{ role: "ROLE_AGENT", parts: [textPart(item.text)] }];
+    }
+    if (item.type === "reasoning" && item.text) return [{ role: "ROLE_AGENT", parts: [thinkingPart(item.text)] }];
+    const result = resultOf(item);
+    if (!result) return [];
+    return [...this.started(item), { role: "ROLE_USER", parts: [result] }];
+  }
+  usageLine(provider, model, previous) {
+    if (!this.usage) return null;
+    const total = this.usage;
+    const delta = (key) => Math.max(0, total[key] - previous[key]);
+    const cached = delta("cached_input_tokens");
+    return { type: "usage", models: [{ provider, model, inputTokens: Math.max(0, delta("input_tokens") - cached), outputTokens: delta("output_tokens"), cacheReadTokens: cached, cacheWriteTokens: delta("cache_write_input_tokens"), costUsd: 0, llmCalls: 1 }] };
+  }
+  totalUsage() {
+    return this.usage;
+  }
+};
+
+// src/session.ts
+import { existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var CONFIG = "config.toml";
+function sourceHome(env) {
+  return env.CODEX_HOME ? env.CODEX_HOME : join(env.HOME ?? homedir(), ".codex");
+}
+function stateFile(sessionDir) {
+  return join(sessionDir, "codex", "state.json");
+}
+function readState(sessionDir) {
+  const file = stateFile(sessionDir);
+  if (!existsSync(file)) return { threadId: null, usage: NO_USAGE };
+  try {
+    const raw = JSON.parse(readFileSync(file, "utf8"));
+    return { threadId: typeof raw.threadId === "string" ? raw.threadId : null, usage: { ...NO_USAGE, ...raw.usage } };
+  } catch {
+    return { threadId: null, usage: NO_USAGE };
+  }
+}
+function writeState(sessionDir, state) {
+  mkdirSync(join(sessionDir, "codex"), { recursive: true });
+  writeFileSync(stateFile(sessionDir), `${JSON.stringify(state)}
+`);
+}
+function linked(target) {
+  try {
+    return lstatSync(target).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function browserConfig(config, browser) {
+  const swapped = replaceMcpServers(config, (server) => isBrowserServer(server.command, server.args) ? browserServerBlock(server.name, browser) : null);
+  return swapped.replaced.length > 0 ? swapped.text : null;
+}
+function share(home, source, name) {
+  const from = join(source, name);
+  const target = join(home, name);
+  if (!existsSync(from)) {
+    if (linked(target)) rmSync(target);
+    return;
+  }
+  if (linked(target) && readlinkSync(target) === from) return;
+  if (linked(target)) rmSync(target);
+  if (!existsSync(target)) symlinkSync(from, target);
+}
+function prepareHome(sessionDir, source, browser) {
+  const home = join(sessionDir, "codex", "home");
+  mkdirSync(home, { recursive: true });
+  share(home, source, "auth.json");
+  const config = join(source, CONFIG);
+  const generated = browser && existsSync(config) ? browserConfig(readFileSync(config, "utf8"), browser) : null;
+  rmSync(join(home, CONFIG), { force: true });
+  if (generated === null) share(home, source, CONFIG);
+  else writeFileSync(join(home, CONFIG), generated, { mode: 384 });
+  return home;
+}
+
+// src/turn.ts
+var STOP_GRACE_MS = 3e3;
+var NOISE = /^(WARNING: proceeding|Reading additional input from stdin)/;
+var line = (value) => process.stdout.write(`${JSON.stringify(value)}
+`);
+function fail(message) {
+  line({ type: "error", message });
+  process.exit(1);
+}
+function stop(child) {
+  if (child.exitCode !== null || child.signalCode !== null) process.exit(143);
+  child.kill("SIGTERM");
+  const timer = setTimeout(() => child.kill("SIGKILL"), STOP_GRACE_MS);
+  child.once("exit", () => {
+    clearTimeout(timer);
+    process.exit(143);
+  });
+}
+function exitOf(child) {
+  return new Promise((resolve) => {
+    child.once("error", () => resolve(127));
+    child.once("close", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
+  });
+}
+function closed(reader) {
+  return new Promise((resolve) => reader.once("close", resolve));
+}
+async function main() {
+  const file = process.env.ORBITAL_HARNESS_TURN;
+  if (!file) fail("ORBITAL_HARNESS_TURN names no turn spec.");
+  const spec = JSON.parse(readFileSync2(file, "utf8"));
+  const state = readState(spec.sessionDir);
+  const resumed = spec.resume && state.threadId !== null;
+  const previous = resumed ? state.usage : NO_USAGE;
+  const home = prepareHome(spec.sessionDir, sourceHome(process.env), spec.browser);
+  const child = spawn("codex", codexArgs(spec, resumed ? state.threadId : null), { cwd: spec.workspaceDir, env: childEnv(spec, process.env, home), stdio: ["ignore", "pipe", "pipe"] });
+  process.once("SIGTERM", () => stop(child));
+  process.once("SIGINT", () => stop(child));
+  const turn = new TurnLines();
+  const noise = [];
+  const errors = createInterface({ input: child.stderr });
+  errors.on("line", (text) => {
+    if (text.trim() !== "" && !NOISE.test(text)) noise.push(text);
+  });
+  const events = createInterface({ input: child.stdout });
+  events.on("line", (text) => {
+    let event;
+    try {
+      event = JSON.parse(text);
+    } catch {
+      return;
+    }
+    for (const entry of turn.handle(event)) line({ type: "message", message: { messageId: randomUUID(), role: entry.role, parts: entry.parts } });
+    if (event.type === "thread.started") writeState(spec.sessionDir, { threadId: event.thread_id, usage: previous });
+  });
+  const [code] = await Promise.all([exitOf(child), closed(events), closed(errors)]);
+  const { provider, model } = modelOf(spec.model);
+  const usage = turn.usageLine(provider, model ?? DEFAULT_MODEL, previous);
+  if (usage) line(usage);
+  const total = turn.totalUsage();
+  if (turn.threadId && total) writeState(spec.sessionDir, { threadId: turn.threadId, usage: total });
+  if (turn.failure) fail(turn.failure);
+  if (code !== 0) fail(`codex exited with code ${code}${noise.length > 0 ? `: ${noise.slice(-5).join(" ")}` : ""}.`);
+  if (!turn.completed || !turn.answer) fail("Codex answered nothing.");
+  line({ type: "result", text: turn.answer });
+  process.exit(0);
+}
+main().catch((error) => fail(error instanceof Error ? error.message : String(error)));

package/orbital-plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "orbital-harness-codex",
+  "command": ["node", "dist/plugin.js"],
+  "harnesses": [{ "id": "codex", "folder": ".codex", "instructions": "AGENTS.md", "agents": "agents", "skills": "skills" }]
+}

package/package.json

@@ -1,6 +1,29 @@
 {
   "name": "@kaiba-cloud/orbital-harness-codex",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "The adapter of the harness codex for orbital: its folder .codex, its install, and a turn program on the OpenAI Codex CLI",
+  "version": "0.0.1",
+  "license": "UNLICENSED",
+  "type": "module",
+  "engines": {
+    "node": ">=22.18"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "check-types": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@kaiba-cloud/orbital-sdk": "workspace:*",
+    "@modelcontextprotocol/sdk": "^1.31.0",
+    "esbuild": "^0.25.0",
+    "typescript": "~5.9.3",
+    "zod": "^4.6.7"
+  },
+  "files": [
+    "orbital-plugin.json",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}