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

package/dist/src/agent-command.d.ts

@@ -0,0 +1,3 @@
+import type { RunnerContext } from "@rig/core/runtime-runner-context";
+import type { CommandOutcome } from "@rig/contracts";
+export declare function executeAgent(context: RunnerContext, args: string[]): Promise<CommandOutcome>;

package/dist/src/agent-command.js

@@ -0,0 +1,233 @@
+// @bun
+// packages/harness-plugin/src/agent-command.ts
+import {
+  CliError,
+  requireNoExtraArgs,
+  takeFlag,
+  takeOption
+} from "@rig/std-shared/cli-args";
+import { agentId } from "@rig/core/safe-identifiers";
+import { ISOLATION_BACKEND, REPO_OPERATIONS_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { requireCapabilityForRoot } from "@rig/core/capability-loaders";
+import { buildPluginHostContext } from "@rig/core/plugin-host-context";
+import { withMutedConsole } from "@rig/std-shared/cli-muted-console";
+import { parseEnumOption } from "@rig/std-shared/cli-args";
+var MISSING_ISOLATION_BACKEND_HINT = "Install @rig/isolation-plugin (it ships in the default bundle) so runtime provisioning can resolve a backend.";
+var RepoOperationsCap = defineCapability(REPO_OPERATIONS_CAPABILITY);
+async function resolveRepoOperations(projectRoot) {
+  const hostCtx = await buildPluginHostContext(projectRoot);
+  const repoOps = hostCtx ? await RepoOperationsCap.resolve(hostCtx.pluginHost) : null;
+  if (!repoOps) {
+    throw new CliError(`No REPO_OPERATIONS capability is registered for project root "${projectRoot}".`, 2, { hint: "Install @rig/repos-plugin (it ships in the default bundle) before running repo operations." });
+  }
+  return repoOps;
+}
+async function resolveIsolationBackend(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, defineCapability(ISOLATION_BACKEND), `No ISOLATION_BACKEND capability is registered for project root "${projectRoot}". ` + MISSING_ISOLATION_BACKEND_HINT);
+}
+function splitAtDoubleDash(args) {
+  const separatorIndex = args.indexOf("--");
+  if (separatorIndex === -1) {
+    return { options: args, commandParts: [] };
+  }
+  return {
+    options: args.slice(0, separatorIndex),
+    commandParts: args.slice(separatorIndex + 1)
+  };
+}
+async function attachEventBusToProvisionedRuntime(context, workspaceDir) {
+  const previousWorkspace = process.env.RIG_TASK_WORKSPACE;
+  process.env.RIG_TASK_WORKSPACE = workspaceDir;
+  try {
+    await context.eventBus.attachRuntimeWorkspace(context.projectRoot);
+  } finally {
+    if (previousWorkspace === undefined) {
+      delete process.env.RIG_TASK_WORKSPACE;
+    } else {
+      process.env.RIG_TASK_WORKSPACE = previousWorkspace;
+    }
+  }
+}
+async function runProjectMainSyncPreflight(context, options) {
+  if (context.dryRun) {
+    if (context.outputMode === "text" && !options.disabled) {
+      console.log("[dry-run] project-rig pre-run sync check");
+    }
+    return;
+  }
+  const repoOps = await resolveRepoOperations(context.projectRoot);
+  const result = await repoOps.ensureProjectMainFreshBeforeRun({
+    projectRoot: context.projectRoot,
+    disabled: options.disabled,
+    runBootstrap: async () => {
+      const bootstrap = await context.runCommand(["bun", "run", "bootstrap"]);
+      if (bootstrap.exitCode !== 0) {
+        throw new CliError(bootstrap.stderr || bootstrap.stdout || "bun run bootstrap failed during project pre-run sync", bootstrap.exitCode || 1);
+      }
+    }
+  });
+  if (context.outputMode !== "text") {
+    return;
+  }
+  switch (result.status) {
+    case "disabled":
+      console.log("Project pre-run sync skipped (--skip-project-sync).");
+      break;
+    case "skipped_not_main":
+      console.log(`Project pre-run sync skipped (current branch: ${result.branch}).`);
+      break;
+    case "up_to_date":
+      break;
+    case "local_ahead":
+      console.log(`Project pre-run sync skipped (local main ahead by ${result.localAhead} commit(s)).`);
+      break;
+    case "updated":
+      console.log(`Project pre-run sync updated local main from origin/main (+${result.remoteAhead}) and bootstrapped.`);
+      break;
+  }
+}
+async function executeAgent(context, args) {
+  const [command = "list", ...rest] = args;
+  const backend = await resolveIsolationBackend(context.projectRoot);
+  switch (command) {
+    case "list": {
+      requireNoExtraArgs(rest, "rig agent list");
+      const runtimes = await backend.listAgentRuntimes(context.projectRoot);
+      if (context.outputMode === "text") {
+        if (runtimes.length === 0) {
+          console.log("No agent runtimes.");
+        } else {
+          for (const runtime of runtimes) {
+            console.log(`${runtime.id} (${runtime.mode}) workspace=${runtime.workspaceDir} created=${runtime.createdAt}`);
+          }
+        }
+      }
+      return { ok: true, group: "agent", command, details: { runtimes } };
+    }
+    case "prepare": {
+      let pending = rest;
+      const idResult = takeOption(pending, "--id");
+      pending = idResult.rest;
+      const modeResult = takeOption(pending, "--mode");
+      pending = modeResult.rest;
+      const taskResult = takeOption(pending, "--task");
+      pending = taskResult.rest;
+      requireNoExtraArgs(pending, "rig agent prepare --task <id> [--id <id>] [--mode worktree]");
+      const mode = parseEnumOption(modeResult.value, ["worktree"], { fallback: "worktree", label: "isolation mode" });
+      const id = idResult.value || agentId("agent");
+      const taskId = taskResult.value?.trim();
+      if (!taskId) {
+        throw new CliError("Usage: rig agent prepare --task <id> [--id <id>] [--mode worktree]");
+      }
+      const runtime = await withMutedConsole(context.outputMode === "json", () => backend.ensureAgentRuntime({
+        projectRoot: context.projectRoot,
+        id,
+        taskId,
+        mode
+      }));
+      await attachEventBusToProvisionedRuntime(context, runtime.workspaceDir);
+      if (context.outputMode === "text") {
+        console.log(`Prepared runtime ${runtime.id} (${runtime.mode})`);
+        console.log(`Workspace: ${runtime.workspaceDir}`);
+      }
+      return { ok: true, group: "agent", command, details: { runtime } };
+    }
+    case "run": {
+      const { options, commandParts } = splitAtDoubleDash(rest);
+      if (commandParts.length === 0) {
+        throw new CliError("Usage: rig agent run [--id <id>] [--mode worktree] [--skip-project-sync] -- <command...>");
+      }
+      let pending = options;
+      const idResult = takeOption(pending, "--id");
+      pending = idResult.rest;
+      const modeResult = takeOption(pending, "--mode");
+      pending = modeResult.rest;
+      const taskResult = takeOption(pending, "--task");
+      pending = taskResult.rest;
+      const skipProjectSyncResult = takeFlag(pending, "--skip-project-sync");
+      pending = skipProjectSyncResult.rest;
+      requireNoExtraArgs(pending, "rig agent run --task <id> [--id <id>] [--mode worktree] [--skip-project-sync] -- <command...>");
+      const mode = parseEnumOption(modeResult.value, ["worktree"], { fallback: "worktree", label: "isolation mode" });
+      const id = idResult.value || agentId("agent-run");
+      const taskId = taskResult.value?.trim();
+      if (!taskId) {
+        throw new CliError("Usage: rig agent run --task <id> [--id <id>] [--mode worktree] [--skip-project-sync] -- <command...>");
+      }
+      await runProjectMainSyncPreflight(context, { disabled: skipProjectSyncResult.value });
+      try {
+        const runtime = await withMutedConsole(context.outputMode === "json", () => backend.ensureAgentRuntime({
+          projectRoot: context.projectRoot,
+          id,
+          taskId,
+          mode
+        }));
+        await attachEventBusToProvisionedRuntime(context, runtime.workspaceDir);
+        const result = await backend.runInAgentRuntime({
+          projectRoot: context.projectRoot,
+          runtime,
+          command: commandParts,
+          inheritStdio: context.outputMode === "text"
+        });
+        if (result.exitCode !== 0) {
+          throw new CliError(`Agent runtime command failed (${result.exitCode}) in ${runtime.id}${result.stderr ? `
+${result.stderr.trim()}` : ""}`, result.exitCode);
+        }
+        return {
+          ok: true,
+          group: "agent",
+          command,
+          details: {
+            runtimeId: runtime.id,
+            mode: runtime.mode,
+            command: commandParts,
+            exitCode: result.exitCode,
+            sandboxBackend: result.sandboxBackend,
+            sandboxEnabled: result.sandboxEnabled,
+            stdout: result.stdout,
+            stderr: result.stderr
+          }
+        };
+      } catch (error) {
+        throw error;
+      }
+    }
+    case "cleanup": {
+      let pending = rest;
+      const allResult = takeFlag(pending, "--all");
+      pending = allResult.rest;
+      const idResult = takeOption(pending, "--id");
+      pending = idResult.rest;
+      requireNoExtraArgs(pending, "rig agent cleanup (--id <id> | --all)");
+      if (!allResult.value && !idResult.value) {
+        throw new CliError("Provide --id <id> or --all.", 1, { hint: "Run `rig agent list` to find agent ids." });
+      }
+      const runtimes = await backend.listAgentRuntimes(context.projectRoot);
+      const targets = allResult.value ? runtimes.map((runtime) => runtime.id) : [idResult.value];
+      for (const id of targets) {
+        await backend.cleanupAgentRuntime({
+          projectRoot: context.projectRoot,
+          id
+        });
+      }
+      if (context.outputMode === "text") {
+        console.log(`Cleaned runtimes: ${targets.join(", ")}`);
+      }
+      return {
+        ok: true,
+        group: "agent",
+        command,
+        details: {
+          cleaned: targets,
+          count: targets.length,
+          all: allResult.value
+        }
+      };
+    }
+    default:
+      throw new CliError(`Unknown agent command: ${command}`, 1, { hint: "Run `rig agent --help` to list agent commands." });
+  }
+}
+export {
+  executeAgent
+};

package/dist/src/agent-harness/agent-mode.d.ts

@@ -0,0 +1 @@
+export declare function looksLikeShellInvocation(args: string[], mode?: string | undefined): boolean;

package/dist/src/agent-harness/agent-mode.js

@@ -0,0 +1,48 @@
+// @bun
+// packages/harness-plugin/src/agent-harness/agent-mode.ts
+function looksLikeShellInvocation(args, mode = process.env.RIG_AGENT_MODE) {
+  if (mode === "shell") {
+    return true;
+  }
+  if (mode === "agent") {
+    return false;
+  }
+  if (args.length === 0) {
+    return false;
+  }
+  const first = args[0];
+  if (!first) {
+    return false;
+  }
+  const bashLikeFlags = new Set([
+    "-c",
+    "-lc",
+    "-l",
+    "-i",
+    "-s",
+    "--login",
+    "--noprofile",
+    "--norc",
+    "--posix",
+    "--rcfile",
+    "--init-file",
+    "--restricted",
+    "--debug",
+    "--debugger",
+    "--verbose",
+    "--wordexp",
+    "--dump-strings",
+    "--dump-po-strings",
+    "--help"
+  ]);
+  if (bashLikeFlags.has(first)) {
+    return true;
+  }
+  if (!first.startsWith("-")) {
+    return first.endsWith(".sh");
+  }
+  return false;
+}
+export {
+  looksLikeShellInvocation
+};

package/dist/src/agent-harness/agent-wrapper.d.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env bun
+import { type AgentRuntime, type RuntimeSnapshotSidecar } from "@rig/contracts";
+type AgentWrapperOptions = {
+    projectRoot?: string;
+    argv?: string[];
+};
+type RuntimeProvider = "pi";
+type LineSink = Pick<typeof process.stdout, "write">;
+type PiRpcProviderRunInput = {
+    readonly command: string[];
+    readonly cwd: string;
+    readonly env: Record<string, string>;
+    readonly prompt: string;
+    readonly runId?: string;
+    readonly sessionName?: string;
+    readonly stdout?: LineSink;
+    readonly stderr?: LineSink;
+};
+export declare function finalizeRuntimeSnapshot(snapshotSidecar: Pick<RuntimeSnapshotSidecar, "finalize">, providerCommand: string[], exitCode: number, context: {
+    runtimeId: string;
+    taskId: string;
+}): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    snapshotMissing: true;
+    error: string;
+}>;
+export declare function startOptionalRuntimeSnapshotSidecar(runtime: AgentRuntime, startSidecar: (runtime: AgentRuntime, options?: {
+    instanceId?: string;
+}) => Promise<RuntimeSnapshotSidecar>): Promise<RuntimeSnapshotSidecar | null>;
+export declare function runAgentWrapper(options?: AgentWrapperOptions): Promise<number>;
+export declare function runPiRpcProviderFallback(input: PiRpcProviderRunInput): Promise<number>;
+export declare const runPiRpcProvider: typeof runPiRpcProviderFallback;
+export declare function resolveFinalProviderExitCode(input: {
+    providerExitCode: number;
+    taskClosed: boolean;
+    serverManagedRun: boolean;
+}): number;
+export declare function shouldBypassProviderSandboxOnPlatform(provider: RuntimeProvider, platform: NodeJS.Platform): boolean;
+/**
+ * Whether to run the provider command WITHOUT the outer runtime sandbox wrap.
+ *
+ * GATE-1b: an explicit `sandbox=enforce` (config `workspace.sandbox=enforce` →
+ * `RIG_RUNTIME_SANDBOX=enforce`) is honored on every provider/platform — it is NEVER
+ * silently dropped, not even on the pi/macOS path. The provider-specific bypass
+ * ({@link shouldBypassProviderSandboxOnPlatform}) applies ONLY when the operator has
+ * not explicitly demanded enforcement.
+ */
+export declare function resolveOuterSandboxBypass(provider: RuntimeProvider, platform: NodeJS.Platform, explicitSandboxSetting: string | undefined): boolean;
+export declare function buildProviderArgs(_provider: RuntimeProvider, _runtime: Pick<AgentRuntime, "binDir" | "stateDir" | "contextFile">, argv: string[]): string[];
+export declare function resolveProvider(): RuntimeProvider;
+export declare function isTaskClosed(projectRoot: string, taskId: string): Promise<boolean>;
+export declare function recordSnapshotMissingTaskSourceEvidence(projectRoot: string, taskId: string, runtime: Pick<AgentRuntime, "workspaceDir" | "logsDir" | "sessionDir">, snapshotFinalizeError: string): Promise<void>;
+export declare function resolveRuntimeHandoffPath(hostProjectRoot: string, taskId: string, timestampMs?: number): string;
+export declare function recordRuntimeHandoff(hostProjectRoot: string, runtime: Pick<AgentRuntime, "id" | "mode" | "workspaceDir" | "logsDir" | "sessionDir">, taskId: string, exitCode: number, options?: {
+    snapshotMissing?: boolean;
+    snapshotFinalizeError?: string | null;
+}): void;
+export {};