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

package/dist/src/service.d.ts

@@ -7,7 +7,7 @@
  * (`(await import("./service")).svc`), so merely evaluating rig.config.ts never
  * drags the provider impl into scope.
  */
-import type { RuntimeInstructionService } from "@rig/runtime/control-plane/provider-instruction-port";
+import type { RuntimeInstructionService } from "@rig/contracts";
 /** The concrete agent-harness instruction service the runtime port resolves. */
 export declare const svc: RuntimeInstructionService;
 /** Back-compat alias. */

package/dist/src/session-asset-materializer-service.d.ts

@@ -0,0 +1,13 @@
+import type { SessionAssetMaterializerService } from "@rig/contracts";
+/**
+ * Provider-owned implementation of the SESSION_ASSET_MATERIALIZER capability.
+ *
+ * This is the logic that previously lived inline in the runtime's
+ * `plugin-host-context`: extract plugin-contributed skills + config-declared Pi
+ * packages from the loaded rig.config and materialize them into the workspace's
+ * `.pi/` directory. It moved here (provider domain) so the plugin-host assembler
+ * in @rig/core can trigger materialization through the capability seam without a
+ * floor->plugin import. Every step is non-fatal — a write failure logs and
+ * continues so it can never deadlock harness boot.
+ */
+export declare const sessionAssetMaterializer: SessionAssetMaterializerService;

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

@@ -0,0 +1,124 @@
+// @bun
+// packages/provider-plugin/src/session-asset-materializer-service.ts
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolvePath } from "path";
+
+// packages/provider-plugin/src/skill-materializer.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { loadSkill } from "@rig/skill-loader";
+var MARKER_FILENAME = ".rig-plugin";
+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 {
+      await loadSkill(sourcePath);
+      body = readFileSync(sourcePath, "utf-8");
+    } 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;
+}
+
+// packages/provider-plugin/src/pi-settings-materializer.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+var SETTINGS_RELATIVE_PATH = ".pi/settings.json";
+var MANAGED_RECORD_RELATIVE_PATH = ".rig/state/pi-managed-packages.json";
+function readJson(path, fallback) {
+  if (!existsSync2(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function packageKey(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry && typeof entry === "object" && typeof entry.source === "string") {
+    return entry.source;
+  }
+  return JSON.stringify(entry);
+}
+function materializePiPackages(projectRoot, declaredPackages) {
+  const settingsPath = resolve2(projectRoot, SETTINGS_RELATIVE_PATH);
+  const managedRecordPath = resolve2(projectRoot, MANAGED_RECORD_RELATIVE_PATH);
+  const settings = readJson(settingsPath, {});
+  const previouslyManaged = new Set(readJson(managedRecordPath, []));
+  const existing = Array.isArray(settings.packages) ? settings.packages : [];
+  const operatorEntries = existing.filter((entry) => !previouslyManaged.has(packageKey(entry)));
+  const operatorKeys = new Set(operatorEntries.map(packageKey));
+  const managedToAdd = declaredPackages.filter((pkg) => !operatorKeys.has(pkg));
+  const nextPackages = [...operatorEntries, ...managedToAdd];
+  if (nextPackages.length > 0 || existsSync2(settingsPath)) {
+    const nextSettings = { ...settings };
+    if (nextPackages.length > 0) {
+      nextSettings.packages = nextPackages;
+    } else {
+      delete nextSettings.packages;
+    }
+    mkdirSync2(dirname(settingsPath), { recursive: true });
+    writeFileSync2(settingsPath, `${JSON.stringify(nextSettings, null, 2)}
+`, "utf-8");
+  }
+  mkdirSync2(dirname(managedRecordPath), { recursive: true });
+  writeFileSync2(managedRecordPath, `${JSON.stringify(managedToAdd, null, 2)}
+`, "utf-8");
+  return { settingsPath, packages: managedToAdd };
+}
+
+// packages/provider-plugin/src/session-asset-materializer-service.ts
+var sessionAssetMaterializer = {
+  async materializeSessionAssets(projectRoot, config) {
+    try {
+      const skillEntries = config.plugins.flatMap((plugin) => (plugin.contributes?.skills ?? []).map((skill) => ({
+        pluginName: plugin.name,
+        skill
+      })));
+      if (skillEntries.length > 0) {
+        await materializeSkills(projectRoot, skillEntries);
+      }
+    } catch (err) {
+      console.warn(`[session-assets] skill materialization failed: ${err instanceof Error ? err.message : err}`);
+    }
+    try {
+      const piPackages = config.runtime?.pi?.packages ?? [];
+      if (piPackages.length > 0 || existsSync3(resolvePath(projectRoot, ".rig/state/pi-managed-packages.json"))) {
+        materializePiPackages(projectRoot, piPackages);
+      }
+    } catch (err) {
+      console.warn(`[session-assets] Pi package materialization failed: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+};
+export {
+  sessionAssetMaterializer
+};

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,46 @@
+// @bun
+// packages/provider-plugin/src/skill-materializer.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { loadSkill } from "@rig/skill-loader";
+var MARKER_FILENAME = ".rig-plugin";
+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 {
+      await loadSkill(sourcePath);
+      body = readFileSync(sourcePath, "utf-8");
+    } 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/binary-build-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/tooling/binary-build-worker.js

@@ -0,0 +1,323 @@
+// @bun
+// packages/provider-plugin/src/tooling/runtime-binary-build.ts
+import { chmodSync, copyFileSync, cpSync, existsSync, linkSync, mkdirSync, renameSync, rmSync, writeFileSync } from "fs";
+import { basename, dirname, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { drainMicrotasks, gcAndSweep } from "bun:jsc";
+import { resolveRigLayout } from "@rig/core/layout";
+import { runtimeProvisioningEnv } from "@rig/core/runtime-provisioning-env";
+
+// packages/provider-plugin/src/tooling/native-extract.ts
+import { tmpdir } from "os";
+import { resolve } from "path";
+var sharedNativeOutputDir = resolve(tmpdir(), "rig-native");
+
+// packages/provider-plugin/src/tooling/runtime-binary-build.ts
+var runtimeBinaryBuildQueue = Promise.resolve();
+async function buildRuntimeBinary(options) {
+  return runSerializedRuntimeBinaryBuild(async () => {
+    const resolved = resolveRuntimeBinaryBuildOptions(options);
+    runBestEffortBuildGc();
+    const manifestPath = runtimeBinaryCacheManifestPath(resolved.outputPath);
+    const buildKey = createRuntimeBinaryBuildKey({
+      entrypoint: resolved.entrypoint,
+      define: resolved.define,
+      env: resolved.env,
+      external: resolved.external
+    });
+    if (await isRuntimeBinaryBuildFresh({ outputPath: resolved.outputPath, manifestPath, buildKey })) {
+      return;
+    }
+    if (shouldUseRuntimeBinaryBuildWorker()) {
+      await buildRuntimeBinaryViaWorker(resolved);
+    } else {
+      await buildRuntimeBinaryInProcess(resolved, { manifestPath, buildKey });
+    }
+    runBestEffortBuildGc();
+  });
+}
+async function buildRuntimeBinaryInProcess(options, manifest) {
+  const tempBuildDir = resolve2(dirname(options.outputPath), `.bun-build-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  const tempOutputPath = resolve2(tempBuildDir, basename(options.outputPath));
+  mkdirSync(tempBuildDir, { recursive: true });
+  await withTemporaryEnv({
+    ...options.env,
+    ...options.define ? { RIG_BUILD_CONFIG_JSON: JSON.stringify(options.define) } : {}
+  }, async () => withTemporaryCwd(tempBuildDir, async () => {
+    const buildResult = await Bun.build({
+      entrypoints: [options.entrypoint],
+      compile: {
+        target: currentCompileTarget(),
+        outfile: tempOutputPath
+      },
+      target: "bun",
+      format: "esm",
+      minify: true,
+      bytecode: true,
+      metafile: true,
+      ...options.external ? { external: options.external } : {},
+      ...options.define ? { define: { __RIG_BUILD_CONFIG__: JSON.stringify(options.define) } } : {}
+    });
+    if (!buildResult.success) {
+      const details = buildResult.logs.map((log) => [log.message, log.position?.file ? `${log.position.file}:${log.position.line}:${log.position.column}` : ""].filter(Boolean).join(" ")).filter(Boolean).join(`
+`);
+      throw new Error(`Failed to build ${options.entrypoint}: ${details || "Bun.build() returned errors"}`);
+    }
+    if (!existsSync(tempOutputPath)) {
+      const emitted = buildResult.outputs.map((output) => output.path).join(", ") || "(none)";
+      throw new Error(`Failed to build ${options.entrypoint}: Bun.build() did not emit ${tempOutputPath}. Emitted: ${emitted}`);
+    }
+    renameSync(tempOutputPath, options.outputPath);
+    chmodSync(options.outputPath, 493);
+    if (manifest) {
+      await writeRuntimeBinaryCacheManifest({
+        manifestPath: manifest.manifestPath,
+        buildKey: manifest.buildKey,
+        cwd: tempBuildDir,
+        metafile: buildResult.metafile
+      });
+    }
+  })).finally(() => {
+    rmSync(tempBuildDir, { recursive: true, force: true });
+  });
+}
+function runBestEffortBuildGc() {
+  try {
+    drainMicrotasks();
+  } catch {}
+  try {
+    gcAndSweep();
+  } catch {}
+}
+function runtimeBinaryCacheManifestPath(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+function resolveRuntimeBinaryBuildOptions(options) {
+  return {
+    ...options,
+    entrypoint: resolve2(options.cwd, options.sourcePath),
+    outputPath: resolve2(options.outputPath)
+  };
+}
+function shouldUseRuntimeBinaryBuildWorker() {
+  if (process.env.RIG_RUNTIME_BUILD_WORKER === "1") {
+    return false;
+  }
+  if (process.env.RIG_RUNTIME_BUILD_IN_PROCESS === "1") {
+    return false;
+  }
+  return true;
+}
+async function buildRuntimeBinaryViaWorker(options) {
+  const workerSourcePath = resolveRuntimeBinaryBuildWorkerSourcePath(options);
+  if (!workerSourcePath || !existsSync(workerSourcePath)) {
+    await buildRuntimeBinaryInProcess(options, {
+      manifestPath: runtimeBinaryCacheManifestPath(options.outputPath),
+      buildKey: createRuntimeBinaryBuildKey({
+        entrypoint: options.entrypoint,
+        define: options.define,
+        env: options.env,
+        external: options.external
+      })
+    });
+    return;
+  }
+  const payloadPath = createRuntimeBinaryBuildWorkerPayloadPath(options.outputPath);
+  const bunCli = resolveRuntimeBinaryBuildWorkerInvocation();
+  await Bun.write(payloadPath, `${JSON.stringify(options)}
+`);
+  const build = Bun.spawn([bunCli.command, workerSourcePath, payloadPath], {
+    cwd: options.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      ...process.env,
+      ...options.env,
+      ...bunCli.env,
+      RIG_RUNTIME_BUILD_WORKER: "1"
+    }
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    build.exited,
+    new Response(build.stdout).text(),
+    new Response(build.stderr).text()
+  ]);
+  rmSync(payloadPath, { force: true });
+  if (exitCode !== 0) {
+    throw new Error(`Failed to build ${options.entrypoint}: ${(stderr || stdout || `worker exited ${exitCode}`).trim()}`);
+  }
+}
+function createRuntimeBinaryBuildWorkerPayloadPath(outputPath) {
+  return resolve2(dirname(outputPath), `.bun-build-worker-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+}
+function resolveRuntimeBinaryBuildWorkerSourcePath(options) {
+  const envRoots = [
+    options.cwd?.trim(),
+    process.env.RIG_HOST_PROJECT_ROOT?.trim(),
+    process.env.PROJECT_RIG_ROOT?.trim()
+  ].filter(Boolean);
+  for (const root of envRoots) {
+    const candidate = resolve2(root, "packages/provider-plugin/src/tooling/binary-build-worker.ts");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  const localCandidate = resolve2(import.meta.dir, "binary-build-worker.ts");
+  return existsSync(localCandidate) ? localCandidate : null;
+}
+function resolveRuntimeBinaryBuildWorkerInvocation() {
+  const bunPath = Bun.which("bun");
+  if (bunPath) {
+    return { command: bunPath, env: {} };
+  }
+  if (process.execPath?.trim()) {
+    return {
+      command: process.execPath,
+      env: { BUN_BE_BUN: "1" }
+    };
+  }
+  throw new Error("bun is required to run the runtime binary build worker.");
+}
+function currentCompileTarget() {
+  if (process.platform === "darwin") {
+    return process.arch === "arm64" ? "bun-darwin-arm64" : "bun-darwin-x64";
+  }
+  if (process.platform === "linux") {
+    return process.arch === "arm64" ? "bun-linux-arm64" : "bun-linux-x64";
+  }
+  return "bun-windows-x64";
+}
+function createRuntimeBinaryBuildKey(input) {
+  return JSON.stringify({
+    version: 1,
+    bunVersion: Bun.version,
+    platform: process.platform,
+    arch: process.arch,
+    entrypoint: input.entrypoint,
+    define: sortRecord(input.define),
+    external: input.external ? [...input.external].sort() : undefined,
+    env: sortRecord(input.env)
+  });
+}
+async function isRuntimeBinaryBuildFresh(input) {
+  if (!existsSync(input.outputPath) || !existsSync(input.manifestPath)) {
+    return false;
+  }
+  let manifest = null;
+  try {
+    manifest = await Bun.file(input.manifestPath).json();
+  } catch {
+    return false;
+  }
+  if (!manifest || manifest.version !== 1 || manifest.buildKey !== input.buildKey) {
+    return false;
+  }
+  for (const [filePath, expectedDigest] of Object.entries(manifest.inputs || {})) {
+    if (!existsSync(filePath)) {
+      return false;
+    }
+    if (await sha256File(filePath) !== expectedDigest) {
+      return false;
+    }
+  }
+  return true;
+}
+async function writeRuntimeBinaryCacheManifest(input) {
+  const inputs = {};
+  for (const inputPath of Object.keys(input.metafile?.inputs || {}).sort()) {
+    const normalized = normalizeBuildInputPath(input.cwd, inputPath);
+    if (!normalized || !existsSync(normalized)) {
+      continue;
+    }
+    inputs[normalized] = await sha256File(normalized);
+  }
+  const manifest = {
+    version: 1,
+    buildKey: input.buildKey,
+    inputs
+  };
+  await Bun.write(input.manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function normalizeBuildInputPath(cwd, inputPath) {
+  if (!inputPath) {
+    return null;
+  }
+  if (inputPath.startsWith("file://")) {
+    return fileURLToPath(inputPath);
+  }
+  if (inputPath.startsWith("<")) {
+    return null;
+  }
+  return resolve2(cwd, inputPath);
+}
+async function sha256File(path) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(await Bun.file(path).arrayBuffer());
+  return hasher.digest("hex");
+}
+function sortRecord(value) {
+  if (!value) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)));
+}
+async function runSerializedRuntimeBinaryBuild(action) {
+  const previous = runtimeBinaryBuildQueue;
+  let release;
+  runtimeBinaryBuildQueue = new Promise((resolve3) => {
+    release = resolve3;
+  });
+  await previous;
+  try {
+    return await action();
+  } finally {
+    release();
+  }
+}
+async function withTemporaryEnv(env, action) {
+  if (!env) {
+    return action();
+  }
+  const previousValues = new Map;
+  for (const [key, value] of Object.entries(env)) {
+    previousValues.set(key, process.env[key]);
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+  try {
+    return await action();
+  } finally {
+    for (const [key, value] of previousValues.entries()) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+async function withTemporaryCwd(cwd, action) {
+  const previousCwd = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await action();
+  } finally {
+    process.chdir(previousCwd);
+  }
+}
+
+// packages/provider-plugin/src/tooling/binary-build-worker.ts
+var payloadPath = process.argv[2];
+if (!payloadPath) {
+  console.error("usage: binary-build-worker <payload.json>");
+  process.exit(2);
+}
+var payload = await Bun.file(payloadPath).json();
+await buildRuntimeBinary({
+  ...payload,
+  outputPath: payload.outputPath
+});

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/provider-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>;