@h-rig/cli-surface-plugin 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/control-plane/agent-binary-build.d.ts

@@ -0,0 +1,9 @@
+export type AgentBinaryBuildOptions = {
+    entrypoint: string;
+    outputPath: string;
+    cwd: string;
+    define?: Record<string, string>;
+    env?: Record<string, string | undefined>;
+};
+export declare function materializeSelfExecRole(outputPath: string, define?: Record<string, string>): void;
+export declare function buildAgentBinary(entrypoint: string, outputPath: string, cwd: string, defines?: Record<string, string>): Promise<void>;

package/dist/src/control-plane/agent-binary-build.js

@@ -0,0 +1,88 @@
+// @bun
+// packages/cli-surface-plugin/src/control-plane/agent-binary-build.ts
+import { chmodSync, copyFileSync, linkSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { basename, dirname, resolve } from "path";
+import { runtimeProvisioningEnv } from "@rig/core/runtime-provisioning-env";
+
+// packages/cli-surface-plugin/src/control-plane/embedded-native-assets.ts
+var embeddedNatives = null;
+
+// packages/cli-surface-plugin/src/control-plane/agent-binary-build.ts
+function materializeSelfExecRole(outputPath, define) {
+  const selfPath = process.execPath;
+  mkdirSync(dirname(outputPath), { recursive: true });
+  rmSync(outputPath, { force: true });
+  try {
+    linkSync(selfPath, outputPath);
+  } catch {
+    copyFileSync(selfPath, outputPath);
+  }
+  chmodSync(outputPath, 493);
+  const role = basename(outputPath).replace(/\.exe$/i, "");
+  writeFileSync(`${outputPath}.rig-runconfig.json`, `${JSON.stringify({ role, define: define ?? {} }, null, 2)}
+`, { mode: 384 });
+}
+function hasEmbeddedNatives() {
+  return embeddedNatives !== null;
+}
+async function buildAgentBinary(entrypoint, outputPath, cwd, defines) {
+  if (hasEmbeddedNatives()) {
+    materializeSelfExecRole(outputPath, defines);
+    return;
+  }
+  await buildRuntimeBinary({
+    entrypoint,
+    outputPath,
+    cwd,
+    ...defines ? { define: defines } : {},
+    env: runtimeProvisioningEnv()
+  });
+}
+async function buildRuntimeBinary(options) {
+  mkdirSync(dirname(options.outputPath), { recursive: true });
+  await withTemporaryEnv({
+    ...options.env,
+    ...options.define ? { RIG_BUILD_CONFIG_JSON: JSON.stringify(options.define) } : {}
+  }, async () => {
+    const result = await Bun.build({
+      entrypoints: [resolve(options.cwd, options.entrypoint)],
+      compile: { outfile: options.outputPath },
+      target: "bun",
+      format: "esm",
+      minify: true,
+      bytecode: true,
+      ...options.define ? { define: { __RIG_BUILD_CONFIG__: JSON.stringify(options.define) } } : {}
+    });
+    if (!result.success) {
+      throw new Error(result.logs.map((log) => log.message).join(`
+`) || `Failed to compile ${options.entrypoint}`);
+    }
+  });
+  chmodSync(options.outputPath, 493);
+}
+async function withTemporaryEnv(env, callback) {
+  const previous = {};
+  for (const [key, value] of Object.entries(env)) {
+    previous[key] = process.env[key];
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+  try {
+    return await callback();
+  } finally {
+    for (const [key, value] of Object.entries(previous)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+export {
+  materializeSelfExecRole,
+  buildAgentBinary
+};

package/dist/src/control-plane/embedded-native-assets.d.ts

@@ -0,0 +1,7 @@
+export type EmbeddedNative = {
+    name: string;
+    fileName: string;
+    filePath: string;
+    size: number;
+};
+export declare const embeddedNatives: Record<string, EmbeddedNative> | null;

package/dist/src/control-plane/embedded-native-assets.js

@@ -0,0 +1,6 @@
+// @bun
+// packages/cli-surface-plugin/src/control-plane/embedded-native-assets.ts
+var embeddedNatives = null;
+export {
+  embeddedNatives
+};

package/dist/src/control-plane/guard.d.ts

@@ -0,0 +1,17 @@
+import { type CompletionConfig, type GuardContext, type GuardDecision, type IsolationConfig, type MatchedRule, type PolicyConfig, type PolicyMode, type PolicyRule, type RuntimeImageConfig, type RuntimeSnapshotConfig, type SandboxConfig } from "@rig/contracts";
+export declare function resetPolicyCache(): void;
+/**
+ * Seed the policy cache from raw JSON content (e.g. baked at compile time).
+ * When seeded, loadPolicy() returns the seeded config without disk I/O.
+ */
+export declare function seedPolicyFromContent(rawJson: string): void;
+export declare function loadPolicy(projectRoot: string): PolicyConfig;
+export declare function matchRule(rule: PolicyRule, input: string): boolean;
+export declare function resolveAction(mode: PolicyMode, matched: MatchedRule[]): "allow" | "block" | "warn";
+export declare function isHarnessPath(projectRoot: string, rawPath: string): boolean;
+export declare function evaluate(context: GuardContext): GuardDecision;
+export declare function loadSandboxConfig(projectRoot: string): SandboxConfig;
+export declare function loadIsolationConfig(projectRoot: string): IsolationConfig;
+export declare function loadCompletionConfig(projectRoot: string): CompletionConfig;
+export declare function loadRuntimeImageConfig(projectRoot: string): RuntimeImageConfig;
+export declare function loadRuntimeSnapshotConfig(projectRoot: string): RuntimeSnapshotConfig;