@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/provider/codex-exec-records.js

@@ -0,0 +1,203 @@
+// @bun
+// packages/runtime/src/control-plane/provider/codex-exec-records.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function normalizeString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeIsoTimestamp(value) {
+  const normalized = normalizeString(value);
+  if (!normalized) {
+    return null;
+  }
+  const timestamp = Date.parse(normalized);
+  return Number.isNaN(timestamp) ? null : new Date(timestamp).toISOString();
+}
+function isCodexExecRecord(record) {
+  const type = normalizeString(record.type);
+  return type === "thread.started" || type === "thread.completed" || type === "turn.started" || type === "turn.completed" || type === "item.started" || type === "item.completed";
+}
+function extractCodexAssistantMessageText(record) {
+  if (normalizeString(record.type) !== "item.completed") {
+    return null;
+  }
+  const item = asRecord(record.item);
+  if (!item || normalizeString(item.type) !== "agent_message") {
+    return null;
+  }
+  return normalizeString(item.text);
+}
+function codexToolName(itemType, item) {
+  if (itemType === "command_execution") {
+    return "Bash";
+  }
+  const server = normalizeString(item.server);
+  const tool = normalizeString(item.tool);
+  if (server && tool) {
+    return `mcp__${server}__${tool}`;
+  }
+  return tool;
+}
+function codexToolInput(itemType, item) {
+  if (itemType === "command_execution") {
+    return {
+      command: normalizeString(item.command)
+    };
+  }
+  return item.arguments ?? item.input ?? null;
+}
+function codexToolResult(itemType, item) {
+  if (itemType === "command_execution") {
+    return {
+      command: normalizeString(item.command),
+      stdout: normalizeString(item.aggregated_output),
+      exit_code: typeof item.exit_code === "number" ? item.exit_code : null,
+      status: normalizeString(item.status)
+    };
+  }
+  const error = asRecord(item.error);
+  if (error) {
+    return {
+      content: normalizeString(error.message) ?? JSON.stringify(error),
+      error
+    };
+  }
+  return item.result ?? item.output ?? item;
+}
+function codexToolError(itemType, item) {
+  if (itemType === "command_execution") {
+    return typeof item.exit_code === "number" && item.exit_code !== 0 || normalizeString(item.status) === "failed";
+  }
+  return item.error != null || normalizeString(item.status) === "failed";
+}
+function buildCodexLogsFromRecord(input) {
+  const entryType = normalizeString(input.record.type);
+  if (entryType !== "item.started" && entryType !== "item.completed") {
+    return [];
+  }
+  const item = asRecord(input.record.item);
+  if (!item) {
+    return [];
+  }
+  const itemTypeRaw = normalizeString(item.type);
+  const itemType = itemTypeRaw === "command_execution" || itemTypeRaw === "mcp_tool_call" ? itemTypeRaw : null;
+  const createdAt = normalizeIsoTimestamp(input.record.timestamp) ?? input.createdAtFallback;
+  if (!itemType) {
+    if (itemTypeRaw === "agent_message" && input.includeMessageLogs) {
+      const text = normalizeString(item.text);
+      if (!text) {
+        return [];
+      }
+      return [{
+        id: normalizeString(item.id) ?? `${input.runId}-codex-message-${Date.now()}`,
+        runId: input.runId,
+        title: "Assistant output",
+        detail: JSON.stringify({
+          type: "assistant",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text }]
+          }
+        }),
+        tone: "info",
+        status: input.status,
+        payload: { text },
+        createdAt
+      }];
+    }
+    return [];
+  }
+  const itemId = normalizeString(item.id);
+  if (!itemId) {
+    return [];
+  }
+  if (entryType === "item.started") {
+    input.pendingToolUses.set(itemId, {
+      id: itemId,
+      itemType,
+      name: codexToolName(itemType, item),
+      input: codexToolInput(itemType, item),
+      timestamp: createdAt,
+      record: item
+    });
+    return [];
+  }
+  const pending = input.pendingToolUses.get(itemId) ?? null;
+  if (pending) {
+    input.pendingToolUses.delete(itemId);
+  }
+  const toolName = pending?.name ?? codexToolName(itemType, item);
+  const toolInput = pending?.input ?? codexToolInput(itemType, item);
+  const toolResult = codexToolResult(itemType, item);
+  const isError = codexToolError(itemType, item);
+  const stdout = asRecord(toolResult)?.stdout;
+  return [{
+    id: `${input.runId}-codex-tool-${itemId}`,
+    runId: input.runId,
+    title: "Tool activity",
+    detail: JSON.stringify({
+      type: "agent_tool_activity",
+      provider: "codex",
+      item_type: itemType,
+      tool_use_id: itemId,
+      tool_name: toolName,
+      tool_input: toolInput,
+      tool_result: toolResult,
+      is_error: isError,
+      raw: {
+        started: pending?.record ?? null,
+        completed: item
+      }
+    }),
+    tone: isError ? "error" : "tool",
+    status: input.status,
+    payload: {
+      toolUseId: itemId,
+      toolName,
+      toolInput,
+      content: typeof stdout === "string" ? stdout : null,
+      isError
+    },
+    createdAt: pending?.timestamp ?? createdAt
+  }];
+}
+function flushPendingCodexToolUseLogs(input) {
+  const logs = [];
+  for (const pending of input.pendingToolUses.values()) {
+    logs.push({
+      id: `${input.runId}-codex-tool-${pending.id}`,
+      runId: input.runId,
+      title: "Tool activity",
+      detail: JSON.stringify({
+        type: "agent_tool_use",
+        provider: "codex",
+        item_type: pending.itemType,
+        tool_use_id: pending.id,
+        tool_name: pending.name,
+        tool_input: pending.input,
+        raw: pending.record
+      }),
+      tone: "tool",
+      status: input.status,
+      payload: {
+        toolUseId: pending.id,
+        toolName: pending.name,
+        toolInput: pending.input
+      },
+      createdAt: pending.timestamp
+    });
+  }
+  input.pendingToolUses.clear();
+  return logs;
+}
+export {
+  isCodexExecRecord,
+  flushPendingCodexToolUseLogs,
+  extractCodexAssistantMessageText,
+  buildCodexLogsFromRecord
+};

package/dist/src/control-plane/provider/rig-task-run-skill.js

@@ -0,0 +1,39 @@
+// @bun
+// packages/runtime/src/control-plane/provider/rig-task-run-skill.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var SKILL_FILENAME = "rig-task-run.md";
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+var cachedBody = null;
+function loadRigTaskRunSkillBody() {
+  if (cachedBody !== null) {
+    return cachedBody;
+  }
+  const path = resolveSkillPath();
+  if (!path) {
+    cachedBody = "";
+    return cachedBody;
+  }
+  const raw = readFileSync(path, "utf-8");
+  const match = raw.match(FRONTMATTER_RE);
+  cachedBody = (match ? match[2] ?? raw : raw).trim();
+  return cachedBody;
+}
+function resolveSkillPath() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve(here, "..", "..", "..", "skills", SKILL_FILENAME),
+    resolve(here, "..", "..", "skills", SKILL_FILENAME),
+    resolve(here, "..", "skills", SKILL_FILENAME)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+export {
+  loadRigTaskRunSkillBody
+};

package/dist/src/control-plane/provider/runtime-instructions.js

@@ -0,0 +1,96 @@
+// @bun
+// packages/runtime/src/control-plane/provider/runtime-instructions.ts
+var CLAUDE_ROUTER_TOOL_NAMES = [
+  "`mcp__rig_runtime_tools__read`",
+  "`mcp__rig_runtime_tools__write`",
+  "`mcp__rig_runtime_tools__edit`",
+  "`mcp__rig_runtime_tools__glob`",
+  "`mcp__rig_runtime_tools__grep`"
+].join(", ");
+var CODEX_DYNAMIC_TOOL_NAMES = [
+  "`shell`",
+  "`read`",
+  "`write`",
+  "`edit`",
+  "`glob`",
+  "`grep`"
+].join(", ");
+function normalizeRuntimeInstructionProvider(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "codex" || normalized === "codex-cli" || normalized === "codex-app-server" || normalized === "gpt-codex") {
+    return "codex";
+  }
+  if (normalized === "pi" || normalized === "rig-pi" || normalized === "@rig/pi") {
+    return "pi";
+  }
+  return "claude-code";
+}
+function buildProviderTaskRunInstructionLines(provider) {
+  if (provider === "codex") {
+    return [
+      `Use the Rig-owned dynamic tools instead: ${CODEX_DYNAMIC_TOOL_NAMES}.`,
+      "Those file tools can read and search within the task worktree, `$PROJECT_RIG_ROOT`, and `$MONOREPO_MAIN_ROOT`, but `write` and `edit` stay restricted to the scoped task workspace.",
+      "Codex shell work must go through the Rig-owned `shell` tool, which executes through Rig's gatewayed binaries.",
+      "When you need shell access, call `shell` with a narrow `command` and an optional workspace-relative `workdir`.",
+      "Do not invoke absolute host shell paths like `/bin/bash`, `/bin/zsh`, `/usr/bin/env`, or `/usr/bin/git`.",
+      "Parallel Rig tool calls are supported when each call stays scoped and bounded.",
+      "Prefer `read` / `write` / `edit` / `glob` / `grep` over shell one-liners whenever those tools fit.",
+      "Never run repo-wide `rg` or `grep` against `.` or without an explicit narrow path; start with a scoped router `glob`/`grep`, `rg --files <dir>`, or pipe through `head` before widening."
+    ];
+  }
+  if (provider === "pi") {
+    return [
+      "Use Pi's built-in `read`, `write`, `edit`, and `bash` tools from the isolated Rig task worktree.",
+      "Keep file writes inside the scoped task workspace unless Rig explicitly tells you a path is host/project metadata.",
+      "Prefer `read`, `write`, and `edit` over shell one-liners whenever those tools fit.",
+      "When shell access is needed, keep commands narrow and bounded; avoid repo-wide searches without an explicit path and output cap."
+    ];
+  }
+  return [
+    "Claude's built-in `Read`, `Edit`, `Write`, `Glob`, `Grep`, and `NotebookEdit` tools are disabled for this task runtime.",
+    `Use the Rig-owned file tools exposed by the runtime router instead: ${CLAUDE_ROUTER_TOOL_NAMES}.`,
+    "Those file tools can read and search within the task worktree, `$PROJECT_RIG_ROOT`, and `$MONOREPO_MAIN_ROOT`, but `write` and `edit` stay restricted to the scoped task workspace.",
+    "Use `.rig/bin/bash` or `.rig/bin/sh` only for shell work that is not naturally a file-tool operation.",
+    "Do not issue parallel Bash tool calls. Run shell commands serially; Claude Code's parallel Bash mode can lose cwd state inside the isolated worktree."
+  ];
+}
+function buildProviderRuntimeContextLines(provider) {
+  if (provider === "codex") {
+    return [
+      "Codex file and shell work must go through Rig-owned dynamic tools.",
+      `Use the dynamic tools instead: ${CODEX_DYNAMIC_TOOL_NAMES}.`,
+      "`read`/`glob`/`grep` may inspect the task worktree, `$PROJECT_RIG_ROOT`, and `$MONOREPO_MAIN_ROOT`.",
+      "`write` and `edit` remain restricted to the scoped task workspace.",
+      "Codex shell work must stay inside Rig's gatewayed binaries via the `shell` tool.",
+      "Do not invoke absolute host shell paths like `/bin/bash`, `/bin/zsh`, `/usr/bin/env`, or `/usr/bin/git`.",
+      "Parallel Rig tool calls are supported when each call stays scoped and bounded.",
+      "Never run repo-wide `rg` or `grep` against `.` or without an explicit narrow path; start with a scoped router `glob`/`grep`, `rg --files <dir>`, or pipe through `head` before widening."
+    ];
+  }
+  if (provider === "pi") {
+    return [
+      "Pi runs from the isolated Rig task worktree with its built-in `read`, `write`, `edit`, and `bash` tools enabled.",
+      "Keep writes scoped to the task workspace unless Rig-provided instructions name an explicit metadata path.",
+      "Prefer Pi file tools over shell one-liners for file reads and edits.",
+      "Keep shell commands narrow and bounded; cap broad searches before widening."
+    ];
+  }
+  return [
+    "Claude's built-in Read/Edit/Write/Glob/Grep/NotebookEdit tools are disabled in this runtime.",
+    "Use the Rig-owned router tools instead:",
+    "`read`/`glob`/`grep` may inspect the task worktree, `$PROJECT_RIG_ROOT`, and `$MONOREPO_MAIN_ROOT`.",
+    "`write` and `edit` remain restricted to the scoped task workspace.",
+    "mcp__rig_runtime_tools__read",
+    "mcp__rig_runtime_tools__write",
+    "mcp__rig_runtime_tools__edit",
+    "mcp__rig_runtime_tools__glob",
+    "mcp__rig_runtime_tools__grep",
+    "Use `.rig/bin/bash` or `.rig/bin/sh` only for shell-oriented work.",
+    "Run shell commands serially; parallel Bash calls can lose cwd state inside the isolated worktree."
+  ];
+}
+export {
+  normalizeRuntimeInstructionProvider,
+  buildProviderTaskRunInstructionLines,
+  buildProviderRuntimeContextLines
+};