@h-rig/provider-plugin 0.0.6-alpha.157 → 0.0.6-alpha.159

package/dist/src/tooling/shell-tools.js

@@ -0,0 +1,217 @@
+// @bun
+// packages/provider-plugin/src/tooling/shell-tools.ts
+import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename, dirname, resolve as resolve2 } from "path";
+import { RUNTIME_SHELL_TOOL_NAMES } from "@rig/contracts";
+
+// packages/provider-plugin/src/tooling/native-extract.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { resolve } from "path";
+
+// packages/provider-plugin/src/tooling/embedded-native-assets.ts
+var embeddedNatives = null;
+
+// packages/provider-plugin/src/tooling/native-extract.ts
+var sharedNativeOutputDir = resolve(tmpdir(), "rig-native");
+var extractionCache = {};
+function extractEmbeddedNative(name) {
+  if (name in extractionCache) {
+    return extractionCache[name] ?? null;
+  }
+  const entry = embeddedNatives?.[name];
+  if (!entry) {
+    extractionCache[name] = null;
+    return null;
+  }
+  try {
+    const targetPath = resolve(sharedNativeOutputDir, entry.fileName);
+    mkdirSync(sharedNativeOutputDir, { recursive: true });
+    const upToDate = existsSync(targetPath) && statSync(targetPath).size === entry.size;
+    if (!upToDate) {
+      const bytes = readFileSync(entry.filePath);
+      const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync(tempPath, bytes, { mode: 493 });
+      renameSync(tempPath, targetPath);
+    }
+    extractionCache[name] = targetPath;
+  } catch {
+    extractionCache[name] = null;
+  }
+  return extractionCache[name] ?? null;
+}
+
+// packages/provider-plugin/src/tooling/shell-tools.ts
+var sharedNativeShellOutputDir = resolve2(tmpdir2(), "rig-native");
+var sharedNativeShellOutputPath = resolve2(sharedNativeShellOutputDir, `rig-shell-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+function runtimeRigShellFileName() {
+  return `rig-shell${process.platform === "win32" ? ".exe" : ""}`;
+}
+async function ensureRigShellBinaryPath(outputPath = sharedNativeShellOutputPath) {
+  const explicitBin = process.env.RIG_NATIVE_SHELL_BIN?.trim();
+  if (explicitBin && existsSync2(explicitBin)) {
+    return explicitBin;
+  }
+  const embedded = extractEmbeddedNative("rig-shell");
+  if (embedded) {
+    return embedded;
+  }
+  const sourcePath = resolveRigShellSourcePath();
+  if (!sourcePath) {
+    const bundledBinary = resolveBundledRigShellBinaryPath();
+    if (bundledBinary) {
+      return bundledBinary;
+    }
+    throw new Error("rig-shell.zig source file not found.");
+  }
+  const zigBinary = Bun.which("zig");
+  if (!zigBinary) {
+    throw new Error("zig is required to build the native Rig shell.");
+  }
+  mkdirSync2(dirname(outputPath), { recursive: true });
+  const sourceDigest = await sha256File(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    zigBinary,
+    platform: process.platform,
+    arch: process.arch,
+    sourcePath,
+    sourceDigest
+  });
+  const manifestPath = nativeBuildManifestPath(outputPath);
+  const needsBuild = !existsSync2(outputPath) || !await hasMatchingNativeBuildManifest(manifestPath, buildKey);
+  if (!needsBuild) {
+    return outputPath;
+  }
+  const build = Bun.spawn([
+    zigBinary,
+    "build-exe",
+    sourcePath,
+    "-O",
+    "ReleaseFast",
+    `-femit-bin=${outputPath}`
+  ], {
+    cwd: dirname(sourcePath),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    build.exited,
+    new Response(build.stdout).text(),
+    new Response(build.stderr).text()
+  ]);
+  if (exitCode !== 0 || !existsSync2(outputPath)) {
+    const details = [stderr.trim(), stdout.trim()].filter(Boolean).join(`
+`);
+    throw new Error(`Failed to build native Rig shell: ${details || `zig exited with code ${exitCode}`}`);
+  }
+  await Bun.write(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`);
+  return outputPath;
+}
+async function materializeRigShellBinary(targetDir) {
+  const sourcePath = await ensureRigShellBinaryPath();
+  const targetPath = resolve2(targetDir, runtimeRigShellFileName());
+  mkdirSync2(targetDir, { recursive: true });
+  const sourceDigest = await sha256File(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    sourcePath,
+    sourceDigest
+  });
+  const needsCopy = !existsSync2(targetPath) || !await hasMatchingNativeBuildManifest(nativeBuildManifestPath(targetPath), buildKey);
+  if (needsCopy) {
+    copyFileSync(sourcePath, targetPath);
+    chmodSync(targetPath, 493);
+    await Bun.write(nativeBuildManifestPath(targetPath), `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`);
+  }
+  return targetPath;
+}
+function resolveRigShellSourcePath() {
+  for (const candidate of rigShellSourceCandidates()) {
+    if (candidate && existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveBundledRigShellBinaryPath() {
+  for (const candidate of rigShellBinaryCandidates()) {
+    if (candidate && existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function rigShellSourceCandidates() {
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const cwd = process.cwd()?.trim() || "";
+  const projectRoot = process.env.PROJECT_RIG_ROOT?.trim() || "";
+  const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || "";
+  return [...new Set([
+    process.env.RIG_NATIVE_SHELL_SOURCE?.trim() || "",
+    cwd ? resolve2(cwd, "packages/provider-plugin/native/rig-shell.zig") : "",
+    projectRoot ? resolve2(projectRoot, "packages/provider-plugin/native/rig-shell.zig") : "",
+    hostProjectRoot ? resolve2(hostProjectRoot, "packages/provider-plugin/native/rig-shell.zig") : "",
+    execDir ? resolve2(execDir, "..", "..", "packages/provider-plugin/native/rig-shell.zig") : "",
+    execDir ? resolve2(execDir, "..", "native", "rig-shell.zig") : "",
+    resolve2(import.meta.dir, "../../native/rig-shell.zig")
+  ].filter(Boolean))];
+}
+function nativePackageBinaryCandidates(fromDir, fileName) {
+  const candidates = [];
+  let cursor = resolve2(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve2(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve2(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve2(cursor, "native", fileName), resolve2(cursor, "native", "bin", fileName));
+    const parent = dirname(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function rigShellBinaryCandidates() {
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const fileName = runtimeRigShellFileName();
+  return [...new Set([
+    process.env.RIG_NATIVE_SHELL_BIN?.trim() || "",
+    ...nativePackageBinaryCandidates(import.meta.dir, fileName),
+    execDir ? resolve2(execDir, fileName) : "",
+    execDir ? resolve2(execDir, "..", fileName) : "",
+    execDir ? resolve2(execDir, "..", "bin", fileName) : ""
+  ].filter(Boolean))];
+}
+function runtimeToolGatewayNames() {
+  return [...RUNTIME_SHELL_TOOL_NAMES];
+}
+function shellBinaryBasename(path) {
+  return basename(path);
+}
+function nativeBuildManifestPath(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+async function hasMatchingNativeBuildManifest(manifestPath, buildKey) {
+  if (!existsSync2(manifestPath)) {
+    return false;
+  }
+  try {
+    const manifest = await Bun.file(manifestPath).json();
+    return manifest.version === 1 && manifest.buildKey === buildKey;
+  } catch {
+    return false;
+  }
+}
+async function sha256File(path) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(await Bun.file(path).arrayBuffer());
+  return hasher.digest("hex");
+}
+export {
+  shellBinaryBasename,
+  runtimeToolGatewayNames,
+  runtimeRigShellFileName,
+  materializeRigShellBinary,
+  ensureRigShellBinaryPath
+};

package/native/darwin-arm64/rig-shell.build-manifest.json

@@ -0,0 +1,4 @@
+{
+  "version": 1,
+  "buildKey": "{\"version\":1,\"sourcePath\":\"/var/folders/zr/6js4xbjs3bgf46v76j145mlw0000gn/T/rig-native/rig-shell-darwin-arm64\",\"sourceDigest\":\"2137bb597a4acd7d3848de48f4f844cda15600cd39ea928c8246602bb2cdaf97\"}"
+}

package/native/darwin-arm64/rig-tools.build-manifest.json

@@ -0,0 +1,4 @@
+{
+  "version": 1,
+  "buildKey": "{\"version\":1,\"sourcePath\":\"/var/folders/zr/6js4xbjs3bgf46v76j145mlw0000gn/T/rig-native/rig-tools-darwin-arm64\",\"sourceDigest\":\"1fce7a9b29f8e24b4b66116ff046d639bba3f1c137cfbc777ef47c9dfc3d3935\"}"
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@h-rig/provider-plugin",
-  "version": "0.0.6-alpha.157",
+  "version": "0.0.6-alpha.159",
   "type": "module",
   "description": "First-party agent-harness provider capability plugin for Rig.",
   "license": "UNLICENSED",
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "native"
   ],
   "exports": {
     ".": {
@@ -20,6 +21,54 @@
     "./index": {
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
+    },
+    "./agent-harness/rig-agent": {
+      "types": "./dist/src/agent-harness/rig-agent.d.ts",
+      "import": "./dist/src/agent-harness/rig-agent.js"
+    },
+    "./agent-harness/rig-agent-entrypoint": {
+      "types": "./dist/src/agent-harness/rig-agent-entrypoint.d.ts",
+      "import": "./dist/src/agent-harness/rig-agent-entrypoint.js"
+    },
+    "./agent-harness/agent-wrapper": {
+      "types": "./dist/src/agent-harness/agent-wrapper.d.ts",
+      "import": "./dist/src/agent-harness/agent-wrapper.js"
+    },
+    "./tooling/gateway": {
+      "types": "./dist/src/tooling/gateway.d.ts",
+      "import": "./dist/src/tooling/gateway.js"
+    },
+    "./pi-settings-materializer": {
+      "types": "./dist/src/pi-settings-materializer.d.ts",
+      "import": "./dist/src/pi-settings-materializer.js"
+    },
+    "./skill-materializer": {
+      "types": "./dist/src/skill-materializer.d.ts",
+      "import": "./dist/src/skill-materializer.js"
+    },
+    "./tooling/browser-tools": {
+      "types": "./dist/src/tooling/browser-tools.d.ts",
+      "import": "./dist/src/tooling/browser-tools.js"
+    },
+    "./tooling/browser-tool-entrypoint": {
+      "types": "./dist/src/tooling/browser-tool-entrypoint.d.ts",
+      "import": "./dist/src/tooling/browser-tool-entrypoint.js"
+    },
+    "./tooling/claude-router": {
+      "types": "./dist/src/tooling/claude-router.d.ts",
+      "import": "./dist/src/tooling/claude-router.js"
+    },
+    "./tooling/claude-router-binary": {
+      "types": "./dist/src/tooling/claude-router-binary.d.ts",
+      "import": "./dist/src/tooling/claude-router-binary.js"
+    },
+    "./tooling/shell-tools": {
+      "types": "./dist/src/tooling/shell-tools.d.ts",
+      "import": "./dist/src/tooling/shell-tools.js"
+    },
+    "./tooling/file-tools": {
+      "types": "./dist/src/tooling/file-tools.d.ts",
+      "import": "./dist/src/tooling/file-tools.js"
     }
   },
   "engines": {
@@ -29,8 +78,8 @@
   "module": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.157",
-    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.157",
-    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.157"
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.159",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.159",
+    "@rig/skill-loader": "npm:@h-rig/skill-loader@0.0.6-alpha.159"
   }
 }

package/dist/src/claude-stream-records.d.ts

@@ -1,24 +0,0 @@
-import type { EngineRunLog } from "@rig/contracts";
-type ClaudeStreamStatus = EngineRunLog["status"];
-export type PendingClaudeToolUse = {
-    id: string;
-    name: string | null;
-    input: unknown;
-    timestamp: string;
-    record: Record<string, unknown>;
-};
-type BuildClaudeLogsFromRecordInput = {
-    runId: string;
-    record: Record<string, unknown>;
-    createdAtFallback: string;
-    status: ClaudeStreamStatus;
-    pendingToolUses: Map<string, PendingClaudeToolUse>;
-    includeMessageLogs?: boolean;
-};
-export declare function buildClaudeLogsFromRecord(input: BuildClaudeLogsFromRecordInput): EngineRunLog[];
-export declare function flushPendingClaudeToolUseLogs(input: {
-    runId: string;
-    status: ClaudeStreamStatus;
-    pendingToolUses: Map<string, PendingClaudeToolUse>;
-}): EngineRunLog[];
-export {};

package/dist/src/claude-stream-records.js

@@ -1,158 +0,0 @@
-// @bun
-// packages/provider-plugin/src/claude-stream-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 buildClaudeLogsFromRecord(input) {
-  const logs = [];
-  const entryType = normalizeString(input.record.type);
-  const createdAt = normalizeIsoTimestamp(input.record.timestamp) ?? input.createdAtFallback;
-  if (entryType === "summary") {
-    return logs;
-  }
-  if (entryType === "system" || entryType === "result") {
-    logs.push({
-      id: normalizeString(input.record.uuid) ?? `${input.runId}-claude-${Date.now()}`,
-      runId: input.runId,
-      title: entryType === "result" ? "Agent result" : "Agent session initialized",
-      detail: JSON.stringify(input.record),
-      tone: entryType === "result" && input.record.is_error === true ? "error" : "info",
-      status: input.status,
-      payload: input.record,
-      createdAt
-    });
-    return logs;
-  }
-  const message = asRecord(input.record.message);
-  if (!message) {
-    return logs;
-  }
-  const role = normalizeString(message.role) ?? entryType ?? "assistant";
-  const content = Array.isArray(message.content) ? message.content : [];
-  for (const item of content) {
-    const contentRecord = asRecord(item);
-    if (!contentRecord) {
-      continue;
-    }
-    const contentType = normalizeString(contentRecord.type);
-    if (contentType === "tool_use") {
-      const toolUseId = normalizeString(contentRecord.id) ?? normalizeString(contentRecord.tool_use_id);
-      if (!toolUseId) {
-        continue;
-      }
-      input.pendingToolUses.set(toolUseId, {
-        id: toolUseId,
-        name: normalizeString(contentRecord.name) ?? normalizeString(contentRecord.tool_name),
-        input: contentRecord.input ?? contentRecord.tool_input ?? {},
-        timestamp: createdAt,
-        record: contentRecord
-      });
-      continue;
-    }
-    if (contentType === "tool_result") {
-      const toolUseId = normalizeString(contentRecord.tool_use_id);
-      const pending = toolUseId ? input.pendingToolUses.get(toolUseId) ?? null : null;
-      if (pending && toolUseId) {
-        input.pendingToolUses.delete(toolUseId);
-      }
-      logs.push({
-        id: toolUseId ? `${input.runId}-claude-tool-${toolUseId}` : normalizeString(input.record.uuid) ?? `${input.runId}-claude-${Date.now()}`,
-        runId: input.runId,
-        title: "Tool activity",
-        detail: JSON.stringify({
-          type: "claude_tool_activity",
-          session_id: normalizeString(input.record.sessionId) ?? normalizeString(input.record.session_id),
-          uuid: normalizeString(input.record.uuid),
-          tool_use_id: toolUseId,
-          tool_name: pending?.name ?? null,
-          tool_input: pending?.input ?? null,
-          tool_result: contentRecord.content ?? contentRecord,
-          is_error: contentRecord.is_error === true,
-          raw: {
-            toolUse: pending?.record ?? null,
-            toolResult: contentRecord
-          }
-        }),
-        tone: contentRecord.is_error === true ? "error" : "tool",
-        status: input.status,
-        payload: {
-          toolUseId,
-          toolName: pending?.name ?? null,
-          toolInput: pending?.input ?? null,
-          content: contentRecord.content ?? null,
-          isError: contentRecord.is_error === true
-        },
-        createdAt: pending?.timestamp ?? createdAt
-      });
-      continue;
-    }
-    if (!input.includeMessageLogs) {
-      continue;
-    }
-    logs.push({
-      id: normalizeString(input.record.uuid) ? `${normalizeString(input.record.uuid)}:${contentType ?? "content"}:${logs.length + 1}` : `${input.runId}-claude-${Date.now()}-${logs.length + 1}`,
-      runId: input.runId,
-      title: role === "assistant" ? "Assistant output" : role === "user" ? "Tool activity" : "Agent output",
-      detail: JSON.stringify({
-        type: role,
-        message: {
-          role,
-          content: [contentRecord]
-        },
-        session_id: normalizeString(input.record.sessionId) ?? normalizeString(input.record.session_id),
-        uuid: normalizeString(input.record.uuid)
-      }),
-      tone: contentType === "text" ? "info" : "tool",
-      status: input.status,
-      payload: contentRecord,
-      createdAt
-    });
-  }
-  return logs;
-}
-function flushPendingClaudeToolUseLogs(input) {
-  const logs = [];
-  for (const pending of input.pendingToolUses.values()) {
-    logs.push({
-      id: `${input.runId}-claude-tool-${pending.id}`,
-      runId: input.runId,
-      title: "Tool activity",
-      detail: JSON.stringify({
-        type: "claude_tool_use",
-        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 {
-  flushPendingClaudeToolUseLogs,
-  buildClaudeLogsFromRecord
-};

package/dist/src/codex-app-server.d.ts

@@ -1,16 +0,0 @@
-export declare const CODEX_APP_SERVER_TASK_RUN_SENTINEL = "__rig_codex_app_server_task_run__";
-export type CodexAppServerTaskRunConfig = {
-    model?: string;
-    prompt: string;
-    runtimeMode: string;
-    interactionMode?: string;
-};
-export declare function buildCodexAppServerArgs(): string[];
-export declare function parseCodexAppServerTaskRunArgs(argv: string[]): CodexAppServerTaskRunConfig | null;
-export declare function runCodexAppServerTaskRun(options: {
-    codexBinary: string;
-    launchArgs: string[];
-    cwd: string;
-    env: Record<string, string | undefined>;
-    config: CodexAppServerTaskRunConfig;
-}): Promise<number>;