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

package/dist/src/agent-harness/controlled-bash.d.ts

@@ -0,0 +1,3 @@
+export declare function runControlledBash(args: string[], options: {
+    readonly projectRootFallbackDir: string;
+}): Promise<number>;

package/dist/src/agent-harness/controlled-bash.js

@@ -0,0 +1,45 @@
+// @bun
+// packages/harness-plugin/src/agent-harness/controlled-bash.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { resolveRigLayout } from "@rig/core/layout";
+function controlledBashCandidates(projectRoot) {
+  const layout = resolveRigLayout(projectRoot);
+  const candidates = [
+    process.env.RIG_CONTROLLED_BASH_BIN?.trim() || "",
+    resolve(layout.binDir, "controlled-bash"),
+    Bun.which("controlled-bash") || ""
+  ];
+  return candidates.filter((candidate) => Boolean(candidate));
+}
+function resolveControlledBash(projectRoot) {
+  for (const candidate of controlledBashCandidates(projectRoot)) {
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+async function runControlledBash(args, options) {
+  const projectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || process.env.PROJECT_RIG_ROOT?.trim() || process.env.RIG_TASK_WORKSPACE?.trim() || process.cwd() || options.projectRootFallbackDir;
+  const controlled = resolveControlledBash(projectRoot);
+  if (!controlled) {
+    console.error("[rig-agent] controlled-bash entrypoint unavailable; refusing to run an unguarded shell.");
+    return 126;
+  }
+  const command = [controlled, ...args];
+  const child = Bun.spawn(command, {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      PROJECT_RIG_ROOT: projectRoot,
+      RIG_BASH_ACTIVE: "1"
+    }
+  });
+  return await child.exited;
+}
+export {
+  runControlledBash
+};

package/dist/src/agent-harness/git-ops.d.ts

@@ -0,0 +1,2 @@
+import { type LifecycleGitAgentService } from "@rig/contracts";
+export declare function loadLifecycleGit(projectRoot: string): Promise<LifecycleGitAgentService>;

package/dist/src/agent-harness/git-ops.js

@@ -0,0 +1,27 @@
+// @bun
+// packages/harness-plugin/src/agent-harness/git-ops.ts
+import { LIFECYCLE_GIT_AGENT } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { buildPluginHostContext } from "@rig/core/plugin-host-context";
+import { loadCapabilityForRoot } from "@rig/core/capability-loaders";
+var LifecycleGitAgentCap = defineCapability(LIFECYCLE_GIT_AGENT);
+var hostContextByRoot = new Map;
+async function ensureHostContext(projectRoot) {
+  let cached = hostContextByRoot.get(projectRoot);
+  if (!cached) {
+    cached = buildPluginHostContext(projectRoot);
+    hostContextByRoot.set(projectRoot, cached);
+  }
+  await cached;
+}
+async function loadLifecycleGit(projectRoot) {
+  await ensureHostContext(projectRoot);
+  const git = await loadCapabilityForRoot(projectRoot, LifecycleGitAgentCap);
+  if (!git) {
+    throw new Error("lifecycle git capability unavailable: load @rig/lifecycle-plugin (default bundle) before running rig-agent git commands.");
+  }
+  return git;
+}
+export {
+  loadLifecycleGit
+};

package/dist/src/agent-harness/repo-ops.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Provider agent-harness repo operations.
+ *
+ * Repo workflow semantics are owned by @rig/repos-plugin. This provider shim only
+ * resolves the repo-operations capability and delegates the legacy harness entry
+ * points so provider code does not perform live git/branch/task-source mutation.
+ */
+import { type RepoPins } from "@rig/contracts";
+export declare function repoEnsure(projectRoot: string, taskId?: string): void;
+export declare function repoPins(projectRoot: string, taskId?: string): RepoPins;
+export declare function repoVerify(projectRoot: string, taskId?: string): boolean;
+export declare function repoDiscover(projectRoot: string, taskId?: string): RepoPins;
+export declare function repoBaseline(projectRoot: string, refresh?: boolean): RepoPins;
+export declare function resetBaseline(projectRoot: string, keepTaskStatus: boolean): void;

package/dist/src/agent-harness/repo-ops.js

@@ -0,0 +1,37 @@
+// @bun
+// packages/harness-plugin/src/agent-harness/repo-ops.ts
+import {
+  REPO_OPERATIONS_CAPABILITY
+} from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { requireInstalledCapability } from "@rig/core/capability-loaders";
+var RepoOperationsCap = defineCapability(REPO_OPERATIONS_CAPABILITY);
+function repoOperations() {
+  return requireInstalledCapability(RepoOperationsCap, "repo operations capability unavailable: load @rig/repos-plugin before using provider harness repo operations.");
+}
+function repoEnsure(projectRoot, taskId) {
+  repoOperations().repoEnsure(projectRoot, taskId);
+}
+function repoPins(projectRoot, taskId) {
+  return repoOperations().repoPins(projectRoot, taskId);
+}
+function repoVerify(projectRoot, taskId) {
+  return repoOperations().repoVerify(projectRoot, taskId);
+}
+function repoDiscover(projectRoot, taskId) {
+  return repoOperations().repoDiscover(projectRoot, taskId);
+}
+function repoBaseline(projectRoot, refresh = false) {
+  return repoOperations().repoBaseline(projectRoot, refresh);
+}
+function resetBaseline(projectRoot, keepTaskStatus) {
+  repoOperations().resetBaseline(projectRoot, keepTaskStatus);
+}
+export {
+  resetBaseline,
+  repoVerify,
+  repoPins,
+  repoEnsure,
+  repoDiscover,
+  repoBaseline
+};

package/dist/src/agent-harness/rig-agent-entrypoint.d.ts

@@ -0,0 +1 @@
+export declare function runRigAgentEntrypoint(): Promise<void>;