@h-rig/harness-plugin 0.0.6-alpha.186

package/dist/src/session-hook-materializer-service.js

@@ -0,0 +1,142 @@
+// @bun
+// packages/harness-plugin/src/session-hook-materializer-service.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { buildTypedHookShimCommand } from "@rig/core/hook-materializer";
+var MARKER_PLUGIN = "_rigPlugin";
+var MARKER_HOOK_ID = "_rigHookId";
+function matcherToString(matcher) {
+  if (matcher.kind === "all")
+    return;
+  if (matcher.kind === "tool")
+    return matcher.name;
+  return matcher.pattern;
+}
+function isPluginOwned(cmd) {
+  return typeof cmd[MARKER_PLUGIN] === "string";
+}
+function createPiNoopSessionHookAdapter() {
+  return {
+    id: "pi",
+    materialize() {
+      return {
+        adapterId: "pi",
+        status: "skipped",
+        reason: "Pi sessions do not consume Claude Code settings hooks."
+      };
+    }
+  };
+}
+function createClaudeCodeSessionHookAdapter() {
+  return {
+    id: "claude-code",
+    materialize(projectRoot, entries) {
+      return writeClaudeCodeHookSettings(projectRoot, entries);
+    }
+  };
+}
+function defaultAgentSessionHookAdapters(env = process.env) {
+  if (env.RIG_AGENT_SESSION_HOOK_ADAPTER === "claude-code") {
+    return [createClaudeCodeSessionHookAdapter()];
+  }
+  if (env.RIG_AGENT_SESSION_HOOK_ADAPTER === "pi" || typeof env.PI_CODING_AGENT_SESSION_DIR === "string" && env.PI_CODING_AGENT_SESSION_DIR.trim().length > 0 || env.RIG_RUN_PROCESS === "1") {
+    return [createPiNoopSessionHookAdapter()];
+  }
+  return [createClaudeCodeSessionHookAdapter()];
+}
+function materializeSessionHookAdapters(projectRoot, entries, adapters = defaultAgentSessionHookAdapters()) {
+  return adapters.map((adapter) => adapter.materialize(projectRoot, entries));
+}
+function materializeHooks(projectRoot, entries) {
+  const result = createClaudeCodeSessionHookAdapter().materialize(projectRoot, entries);
+  return result.status === "materialized" ? result.path : resolve(projectRoot, ".claude", "settings.json");
+}
+function applyClaudeCodeSessionHooksToSettings(existing, entries, projectRoot, options = {}) {
+  const hooks = typeof existing.hooks === "object" && existing.hooks !== null && !Array.isArray(existing.hooks) ? existing.hooks : {};
+  const replacePluginOwned = options.replacePluginOwned ?? true;
+  if (replacePluginOwned) {
+    for (const event of Object.keys(hooks)) {
+      const groups = hooks[event] ?? [];
+      const cleaned = [];
+      for (const group of groups) {
+        const operatorHooks = group.hooks.filter((h) => !isPluginOwned(h));
+        if (operatorHooks.length > 0) {
+          cleaned.push({ ...group, hooks: operatorHooks });
+        }
+      }
+      if (cleaned.length > 0) {
+        hooks[event] = cleaned;
+      } else {
+        delete hooks[event];
+      }
+    }
+  }
+  const materializedEvents = new Set;
+  for (const { pluginName, hook, typed } of entries) {
+    const command = hook.command ?? (typed ? buildTypedHookShimCommand(pluginName, hook, projectRoot) : undefined);
+    if (!command) {
+      continue;
+    }
+    const event = hook.event;
+    materializedEvents.add(event);
+    const matcherString = matcherToString(hook.matcher);
+    const groups = hooks[event] ??= [];
+    let group = groups.find((g) => g.matcher === matcherString);
+    if (!group) {
+      group = matcherString === undefined ? { hooks: [] } : { matcher: matcherString, hooks: [] };
+      groups.push(group);
+    }
+    const alreadyPresent = group.hooks.some((candidate) => candidate[MARKER_PLUGIN] === pluginName && candidate[MARKER_HOOK_ID] === hook.id);
+    if (alreadyPresent) {
+      continue;
+    }
+    group.hooks.push({
+      type: "command",
+      command,
+      [MARKER_PLUGIN]: pluginName,
+      [MARKER_HOOK_ID]: hook.id
+    });
+  }
+  const next = { ...existing };
+  if (Object.keys(hooks).length > 0) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+  return { settings: next, events: [...materializedEvents].sort() };
+}
+function writeClaudeCodeHookSettings(projectRoot, entries) {
+  const settingsPath = resolve(projectRoot, ".claude", "settings.json");
+  const existing = existsSync(settingsPath) ? safeReadJson(settingsPath) : {};
+  const { settings, events } = applyClaudeCodeSessionHooksToSettings(existing, entries, projectRoot);
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf-8");
+  return {
+    adapterId: "claude-code",
+    status: "materialized",
+    path: settingsPath,
+    events
+  };
+}
+function safeReadJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+var sessionHookMaterializer = {
+  materializeSessionHooks(projectRoot, entries) {
+    return materializeSessionHookAdapters(projectRoot, entries, defaultAgentSessionHookAdapters());
+  }
+};
+export {
+  sessionHookMaterializer,
+  materializeSessionHookAdapters,
+  materializeHooks,
+  defaultAgentSessionHookAdapters,
+  createPiNoopSessionHookAdapter,
+  createClaudeCodeSessionHookAdapter,
+  applyClaudeCodeSessionHooksToSettings
+};

package/dist/src/skill-materializer.d.ts

@@ -0,0 +1,25 @@
+import type { SkillRegistration } from "@rig/contracts";
+export interface PluginSkillEntry {
+    /** The plugin that owns this skill. Recorded in the marker file. */
+    pluginName: string;
+    /** The plugin's skill registration. `path` is resolved against projectRoot
+     *  unless absolute. */
+    skill: SkillRegistration;
+}
+export interface MaterializedSkill {
+    id: string;
+    pluginName: string;
+    directory: string;
+}
+/**
+ * Materialize plugin-contributed skills into `.pi/skills/<id>/SKILL.md`.
+ *
+ * Removes any previously-materialized plugin skill directories (identified by
+ * the `.rig-plugin` marker file) before re-inserting the current set, so the
+ * function is idempotent and never touches operator-authored skill
+ * directories. Skills whose source file is missing or fails frontmatter
+ * parsing are skipped with a warning rather than failing the boot.
+ *
+ * @returns the skills that were written.
+ */
+export declare function materializeSkills(projectRoot: string, entries: readonly PluginSkillEntry[]): Promise<MaterializedSkill[]>;

package/dist/src/skill-materializer.js

@@ -0,0 +1,86 @@
+// @bun
+// packages/harness-plugin/src/skill-materializer.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { resolve } from "path";
+var MARKER_FILENAME = ".rig-plugin";
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+function parseFrontmatter(raw) {
+  const m = raw.match(FRONTMATTER_RE);
+  if (!m) {
+    return { meta: {}, body: raw };
+  }
+  const yaml = m[1] ?? "";
+  const body = m[2] ?? "";
+  const meta = {};
+  for (const line of yaml.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const idx = trimmed.indexOf(":");
+    if (idx === -1)
+      continue;
+    const key = trimmed.slice(0, idx).trim();
+    let value = trimmed.slice(idx + 1).trim();
+    if (typeof value === "string") {
+      const s = value;
+      if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+        value = s.slice(1, -1);
+      } else if (s === "true")
+        value = true;
+      else if (s === "false")
+        value = false;
+      else if (/^-?\d+$/.test(s))
+        value = parseInt(s, 10);
+      else if (/^-?\d+\.\d+$/.test(s))
+        value = parseFloat(s);
+    }
+    meta[key] = value;
+  }
+  return { meta, body };
+}
+function assertValidSkillFrontmatter(path, raw) {
+  const { meta } = parseFrontmatter(raw);
+  if (typeof meta.name !== "string") {
+    throw new Error(`SKILL.md missing required field "name": ${path}`);
+  }
+}
+function skillDirName(id) {
+  return id.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+async function materializeSkills(projectRoot, entries) {
+  const skillsRoot = resolve(projectRoot, ".pi", "skills");
+  if (existsSync(skillsRoot)) {
+    for (const name of readdirSync(skillsRoot)) {
+      const dir = resolve(skillsRoot, name);
+      if (existsSync(resolve(dir, MARKER_FILENAME))) {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }
+  }
+  const written = [];
+  for (const { pluginName, skill } of entries) {
+    const sourcePath = resolve(projectRoot, skill.path);
+    if (!existsSync(sourcePath)) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${sourcePath} does not exist`);
+      continue;
+    }
+    let body;
+    try {
+      body = readFileSync(sourcePath, "utf-8");
+      assertValidSkillFrontmatter(sourcePath, body);
+    } catch (err) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${err instanceof Error ? err.message : err}`);
+      continue;
+    }
+    const dir = resolve(skillsRoot, skillDirName(skill.id));
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(resolve(dir, "SKILL.md"), body, "utf-8");
+    writeFileSync(resolve(dir, MARKER_FILENAME), `${JSON.stringify({ plugin: pluginName, skillId: skill.id }, null, 2)}
+`, "utf-8");
+    written.push({ id: skill.id, pluginName, directory: dir });
+  }
+  return written;
+}
+export {
+  materializeSkills
+};

package/dist/src/tooling/browser-tool-entrypoint.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/src/tooling/browser-tool-entrypoint.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/harness-plugin/src/tooling/browser-tool-entrypoint.ts
+import { existsSync, rmSync } from "fs";
+import { basename, dirname, resolve } from "path";
+import { loadRuntimeContext } from "@rig/core/runtime-context";
+function currentCommand() {
+  return basename(process.argv[1] || "");
+}
+function runtimeContextPath() {
+  const explicit = process.env.RIG_RUNTIME_CONTEXT_FILE?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  return resolve(dirname(resolve(process.argv[1] || "")), "..", "runtime-context.json");
+}
+function loadBrowserContext() {
+  const contextPath = runtimeContextPath();
+  if (!existsSync(contextPath)) {
+    throw new Error(`Runtime context file not found for ${currentCommand()}: ${contextPath}`);
+  }
+  const runtimeContext = loadRuntimeContext(contextPath);
+  if (!runtimeContext.browser?.required) {
+    throw new Error(`No browser contract is configured for ${runtimeContext.taskId}.`);
+  }
+  if (!runtimeContext.hostProjectRoot) {
+    throw new Error(`Runtime browser command ${currentCommand()} requires hostProjectRoot in runtime context.`);
+  }
+  return {
+    browser: runtimeContext.browser,
+    hostProjectRoot: runtimeContext.hostProjectRoot
+  };
+}
+async function runConfiguredCommand(command, browser, hostProjectRoot) {
+  if (!command) {
+    throw new Error(`No backing command is configured for ${currentCommand()}.`);
+  }
+  const attachUrl = new URL(browser.effectiveAttachUrl);
+  const child = Bun.spawn({
+    cmd: ["/bin/bash", "-lc", command],
+    cwd: hostProjectRoot,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env: {
+      ...process.env,
+      RIG_STATE_DIR: browser.stateDir,
+      T3CODE_STATE_DIR: browser.stateDir,
+      RIG_BROWSER_PROFILE: browser.effectiveProfile,
+      RIG_BROWSER_REMOTE_DEBUGGING_PORT: attachUrl.port,
+      RIG_BROWSER_ATTACH_URL: browser.effectiveAttachUrl
+    }
+  });
+  return await child.exited;
+}
+function printAttachInfo(browser, hostProjectRoot) {
+  const payload = {
+    preset: browser.preset,
+    mode: browser.mode,
+    stateDir: browser.stateDir,
+    hostProjectRoot,
+    defaultProfile: browser.defaultProfile,
+    effectiveProfile: browser.effectiveProfile,
+    defaultAttachUrl: browser.defaultAttachUrl,
+    effectiveAttachUrl: browser.effectiveAttachUrl,
+    launchHelper: browser.launchHelper,
+    checkHelper: browser.checkHelper,
+    attachInfoHelper: browser.attachInfoHelper,
+    e2eHelper: browser.e2eHelper,
+    resetProfileHelper: browser.resetProfileHelper,
+    devCommand: browser.devCommand,
+    launchCommand: browser.launchCommand,
+    checkCommand: browser.checkCommand,
+    e2eCommand: browser.e2eCommand
+  };
+  if (process.argv.includes("--json")) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log("Rig Browser");
+  console.log(`  Preset: ${browser.preset}`);
+  console.log(`  Mode: ${browser.mode}`);
+  console.log(`  State dir: ${browser.stateDir}`);
+  console.log(`  Default profile: ${browser.defaultProfile}`);
+  console.log(`  Effective profile: ${browser.effectiveProfile}`);
+  console.log(`  Default attach URL: ${browser.defaultAttachUrl}`);
+  console.log(`  Effective attach URL: ${browser.effectiveAttachUrl}`);
+  console.log(`  Launch helper: ${browser.launchHelper}${browser.devCommand ? " [--dev]" : ""}`);
+  console.log(`  Check helper: ${browser.checkHelper}`);
+  console.log(`  E2E helper: ${browser.e2eHelper}`);
+  console.log(`  Reset helper: ${browser.resetProfileHelper}`);
+}
+function resetProfile(browser) {
+  const profileRoot = resolve(browser.stateDir, "browser", "profiles", browser.effectiveProfile);
+  rmSync(profileRoot, { recursive: true, force: true });
+  console.log(`Removed Rig Browser profile: ${profileRoot}`);
+}
+async function main() {
+  const { browser, hostProjectRoot } = loadBrowserContext();
+  const command = currentCommand();
+  if (command === browser.attachInfoHelper) {
+    printAttachInfo(browser, hostProjectRoot);
+    return;
+  }
+  if (command === browser.resetProfileHelper) {
+    resetProfile(browser);
+    return;
+  }
+  if (command === browser.launchHelper) {
+    const launchCommand = process.argv.includes("--dev") ? browser.devCommand : browser.launchCommand;
+    process.exit(await runConfiguredCommand(launchCommand, browser, hostProjectRoot));
+  }
+  if (command === browser.checkHelper) {
+    process.exit(await runConfiguredCommand(browser.checkCommand, browser, hostProjectRoot));
+  }
+  if (command === browser.e2eHelper) {
+    process.exit(await runConfiguredCommand(browser.e2eCommand ?? browser.checkCommand, browser, hostProjectRoot));
+  }
+  throw new Error(`Unknown Rig Browser helper: ${command}`);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/dist/src/tooling/browser-tools.d.ts

@@ -0,0 +1,3 @@
+export declare function runtimeBrowserToolBinaryName(): string;
+export declare function runtimeBrowserToolNames(): string[];
+export declare function materializeRuntimeBrowserTools(targetDir: string): Promise<string>;

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

@@ -0,0 +1,27 @@
+// @bun
+// packages/harness-plugin/src/tooling/browser-tools.ts
+import { existsSync, rmSync, symlinkSync } from "fs";
+import { resolve } from "path";
+import { RUNTIME_BROWSER_TOOL_NAMES } from "@rig/contracts";
+function runtimeBrowserToolBinaryName() {
+  return `rig-browser-tool${process.platform === "win32" ? ".exe" : ""}`;
+}
+function runtimeBrowserToolNames() {
+  return [...RUNTIME_BROWSER_TOOL_NAMES];
+}
+async function materializeRuntimeBrowserTools(targetDir) {
+  const binaryPath = resolve(targetDir, runtimeBrowserToolBinaryName());
+  for (const tool of runtimeBrowserToolNames()) {
+    const toolPath = resolve(targetDir, tool);
+    if (existsSync(toolPath)) {
+      rmSync(toolPath, { force: true, recursive: true });
+    }
+    symlinkSync(binaryPath, toolPath);
+  }
+  return binaryPath;
+}
+export {
+  runtimeBrowserToolNames,
+  runtimeBrowserToolBinaryName,
+  materializeRuntimeBrowserTools
+};

package/dist/src/tooling/claude-router-binary.d.ts

@@ -0,0 +1,3 @@
+export declare function runtimeClaudeToolRouterFileName(): string;
+export declare function ensureClaudeToolRouterBinaryPath(projectRoot: string, outputPath?: string): Promise<string>;
+export declare function materializeClaudeToolRouterBinary(projectRoot: string, targetDir: string): Promise<string>;

package/dist/src/tooling/claude-router-binary.js

@@ -0,0 +1,62 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/harness-plugin/src/tooling/claude-router-binary.ts
+import { chmodSync, copyFileSync, existsSync, mkdirSync, statSync } from "fs";
+import { tmpdir } from "os";
+import { dirname, resolve } from "path";
+
+// packages/harness-plugin/src/tooling/embedded-native-assets.ts
+var embeddedNatives = null;
+
+// packages/harness-plugin/src/tooling/claude-router-binary.ts
+import { getNativeExtractor } from "@rig/core/native-extract";
+var { hasEmbeddedNatives } = getNativeExtractor(embeddedNatives);
+var sharedRouterOutputDir = resolve(tmpdir(), "rig-native");
+var sharedRouterOutputPath = resolve(sharedRouterOutputDir, `rig-tool-router-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+function runtimeClaudeToolRouterFileName() {
+  return `rig-tool-router${process.platform === "win32" ? ".exe" : ""}`;
+}
+async function requireNativeToolchainRuntimeBinaryBuild(_projectRoot) {
+  const { runtimeBinaryBuildService } = await import("@rig/core/native-toolchain/runtime-binary-build");
+  return runtimeBinaryBuildService;
+}
+async function ensureClaudeToolRouterBinaryPath(projectRoot, outputPath = sharedRouterOutputPath) {
+  const sourcePath = resolve(projectRoot, "packages/harness-plugin/src/tooling/claude-router.ts");
+  mkdirSync(dirname(outputPath), { recursive: true });
+  const needsBuild = !existsSync(outputPath) || statSync(sourcePath).mtimeMs > statSync(outputPath).mtimeMs;
+  if (!needsBuild) {
+    return outputPath;
+  }
+  const service = await requireNativeToolchainRuntimeBinaryBuild(projectRoot);
+  const engine = service.createRuntimeBinaryBuildEngine({ embeddedNatives });
+  await engine.buildRuntimeBinary({
+    sourcePath: "packages/harness-plugin/src/tooling/claude-router.ts",
+    outputPath,
+    cwd: projectRoot
+  });
+  chmodSync(outputPath, 493);
+  return outputPath;
+}
+async function materializeClaudeToolRouterBinary(projectRoot, targetDir) {
+  if (hasEmbeddedNatives()) {
+    const targetPath2 = resolve(targetDir, runtimeClaudeToolRouterFileName());
+    const service = await requireNativeToolchainRuntimeBinaryBuild(projectRoot);
+    service.materializeSelfExecRole(targetPath2);
+    return targetPath2;
+  }
+  const sourcePath = await ensureClaudeToolRouterBinaryPath(projectRoot);
+  const targetPath = resolve(targetDir, runtimeClaudeToolRouterFileName());
+  mkdirSync(targetDir, { recursive: true });
+  const needsCopy = !existsSync(targetPath) || statSync(sourcePath).mtimeMs > statSync(targetPath).mtimeMs;
+  if (needsCopy) {
+    copyFileSync(sourcePath, targetPath);
+    chmodSync(targetPath, 493);
+  }
+  return targetPath;
+}
+export {
+  runtimeClaudeToolRouterFileName,
+  materializeClaudeToolRouterBinary,
+  ensureClaudeToolRouterBinaryPath
+};

package/dist/src/tooling/claude-router.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+export declare const CLAUDE_ROUTER_SERVER_NAME = "rig_runtime_tools";
+export declare const CLAUDE_DISABLED_FILE_TOOLS: readonly ["Read", "Edit", "Write", "NotebookEdit", "Glob", "Grep"];
+type RouterConfigOptions = {
+    binDir: string;
+    stateDir: string;
+    contextFile: string;
+};
+export type ToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+};
+export declare const CLAUDE_ROUTER_TOOL_DEFINITIONS: ToolDefinition[];
+export declare function claudeRuntimeToolCliArgs(configPath: string): string[];
+export declare function codexRuntimeToolCliArgs(options: RouterConfigOptions): string[];
+export declare function writeClaudeRuntimeToolRouterConfig(options: RouterConfigOptions): string;
+export declare function runClaudeToolRouterServer(): Promise<void>;
+export declare function invokeRuntimeTool(toolName: string, args: Record<string, unknown>, options?: {
+    env?: Record<string, string | undefined>;
+}): Promise<Record<string, unknown>>;
+export {};