@h-rig/cli 0.0.6-alpha.18 → 0.0.6-alpha.180

package/dist/src/commands/_pi-install.js

@@ -1,184 +0,0 @@
-// @bun
-// packages/cli/src/commands/_pi-install.ts
-import { existsSync, readFileSync, rmSync } from "fs";
-import { homedir } from "os";
-import { resolve } from "path";
-var PI_RIG_PACKAGE_NAME = "@rig/pi-rig";
-var LEGACY_PI_RIG_MARKER = `// Managed by Rig. Source package: @rig/pi-rig.
-export { default } from '@rig/pi-rig';
-`;
-async function defaultCommandRunner(command, options = {}) {
-  const proc = Bun.spawn(command, { cwd: options.cwd, stdout: "pipe", stderr: "pipe" });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited
-  ]);
-  return { exitCode, stdout, stderr };
-}
-function resolvePiRigExtensionPath(homeDir) {
-  return resolve(homeDir, ".pi", "agent", "extensions", "pi-rig");
-}
-function resolvePiRigPackageSource(projectRoot, exists = existsSync) {
-  const localPackage = resolve(projectRoot, "packages", "pi-rig");
-  if (exists(resolve(localPackage, "package.json")))
-    return localPackage;
-  return `npm:${PI_RIG_PACKAGE_NAME}`;
-}
-function resolvePiHomeDir(inputHomeDir) {
-  return inputHomeDir ?? process.env.RIG_PI_HOME_DIR?.trim() ?? homedir();
-}
-function piListContainsPiRig(output) {
-  return output.split(/\r?\n/).some((line) => {
-    const normalized = line.trim();
-    return normalized.includes(PI_RIG_PACKAGE_NAME) || /(?:^|[\\/])packages[\\/]pi-rig(?:$|\s)/.test(normalized);
-  });
-}
-async function safeRun(runner, command, options) {
-  try {
-    return await runner(command, options);
-  } catch (error) {
-    return { exitCode: 1, stdout: "", stderr: error instanceof Error ? error.message : String(error) };
-  }
-}
-function splitInstallCommand(value) {
-  return value.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^['"]|['"]$/g, "")) ?? [];
-}
-async function ensurePiBinaryAvailable(input) {
-  const current = await safeRun(input.runner, ["pi", "--version"]);
-  if (current.exitCode === 0) {
-    const updateCommand = process.env.RIG_PI_UPDATE_COMMAND?.trim();
-    if (updateCommand) {
-      const parts2 = splitInstallCommand(updateCommand);
-      if (parts2.length > 0)
-        await safeRun(input.runner, parts2, input.projectRoot ? { cwd: input.projectRoot } : undefined);
-    }
-    return { ok: true, detail: (current.stdout || current.stderr).trim() || undefined };
-  }
-  const installCommand = process.env.RIG_PI_INSTALL_COMMAND?.trim() || "bunx @earendil-works/pi@latest install";
-  const parts = splitInstallCommand(installCommand);
-  if (parts.length === 0) {
-    return { ok: false, error: (current.stderr || current.stdout).trim() || "pi --version failed" };
-  }
-  const install = await safeRun(input.runner, parts, input.projectRoot ? { cwd: input.projectRoot } : undefined);
-  if (install.exitCode !== 0) {
-    return { ok: false, installedOrUpdated: true, error: (install.stderr || install.stdout).trim() || `Pi install command failed (${install.exitCode})` };
-  }
-  const next = await safeRun(input.runner, ["pi", "--version"]);
-  return {
-    ok: next.exitCode === 0,
-    installedOrUpdated: true,
-    detail: (next.stdout || next.stderr).trim() || undefined,
-    ...next.exitCode === 0 ? {} : { error: (next.stderr || next.stdout).trim() || "pi --version failed after install" }
-  };
-}
-function removeManagedLegacyPiRigBridge(homeDir, exists = existsSync) {
-  const extensionPath = resolvePiRigExtensionPath(homeDir);
-  const indexPath = resolve(extensionPath, "index.ts");
-  if (!exists(indexPath))
-    return;
-  try {
-    const content = readFileSync(indexPath, "utf8");
-    if (content === LEGACY_PI_RIG_MARKER || content.includes("Managed by Rig. Source package: @rig/pi-rig")) {
-      rmSync(extensionPath, { recursive: true, force: true });
-    }
-  } catch {}
-}
-async function checkPiRigInstall(input = {}) {
-  const home = resolvePiHomeDir(input.homeDir);
-  const extensionPath = resolvePiRigExtensionPath(home);
-  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1") {
-    return {
-      extensionPath,
-      pi: { ok: true, label: "pi", detail: "fake-pi" },
-      piRig: { ok: true, label: "pi-rig global extension", detail: extensionPath }
-    };
-  }
-  const exists = input.exists ?? existsSync;
-  const runner = input.commandRunner ?? defaultCommandRunner;
-  const piResult = await safeRun(runner, ["pi", "--version"]);
-  const piListResult = piResult.exitCode === 0 ? await safeRun(runner, ["pi", "list"]) : { exitCode: 1, stdout: "", stderr: "" };
-  const listedPiRig = piListResult.exitCode === 0 && piListContainsPiRig(`${piListResult.stdout}
-${piListResult.stderr}`);
-  const legacyBridge = exists(resolve(extensionPath, "index.ts"));
-  const hasPiRig = listedPiRig;
-  return {
-    extensionPath,
-    pi: {
-      ok: piResult.exitCode === 0,
-      label: "pi",
-      detail: (piResult.stdout || piResult.stderr).trim() || undefined,
-      hint: piResult.exitCode === 0 ? undefined : "Install Pi or run `rig init --yes` to install/update the Pi runtime."
-    },
-    piRig: {
-      ok: hasPiRig,
-      label: "pi-rig global extension",
-      detail: hasPiRig ? piListResult.stdout.trim() || PI_RIG_PACKAGE_NAME : legacyBridge ? `${extensionPath} (legacy bridge; reinstall required)` : undefined,
-      hint: hasPiRig ? undefined : "Run `rig init --yes` to install/enable the global pi-rig package with `pi install`."
-    }
-  };
-}
-async function ensurePiRigInstalled(input) {
-  const home = resolvePiHomeDir(input.homeDir);
-  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1") {
-    const status2 = await checkPiRigInstall({ homeDir: home, commandRunner: input.commandRunner });
-    return { ...status2, installedPath: status2.extensionPath };
-  }
-  const runner = input.commandRunner ?? defaultCommandRunner;
-  const piAvailable = await ensurePiBinaryAvailable({ runner, projectRoot: input.projectRoot });
-  const status = piAvailable.ok ? await checkPiRigInstall({ homeDir: home, commandRunner: runner }) : {
-    extensionPath: resolvePiRigExtensionPath(home),
-    pi: { ok: false, label: "pi", detail: piAvailable.error, hint: "Install/update Pi with RIG_PI_INSTALL_COMMAND or install Pi manually." },
-    piRig: { ok: false, label: "pi-rig global extension", hint: "Pi is required before pi-rig can be installed." }
-  };
-  if (!piAvailable.ok) {
-    throw new Error(`Pi install/update failed: ${piAvailable.error ?? "pi unavailable"}`);
-  }
-  const packageSource = resolvePiRigPackageSource(input.projectRoot);
-  removeManagedLegacyPiRigBridge(home);
-  const install = await runner(["pi", "install", packageSource], { cwd: input.projectRoot });
-  if (install.exitCode !== 0) {
-    throw new Error(`pi-rig install failed: ${(install.stderr || install.stdout).trim() || `exit ${install.exitCode}`}`);
-  }
-  const next = await checkPiRigInstall({ homeDir: home, commandRunner: runner });
-  return { ...next, installedPath: packageSource };
-}
-async function ensureRemotePiRigInstalled(input) {
-  const payload = await input.requestJson("/api/pi-rig/install", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ package: "@rig/pi-rig", scope: "global" })
-  });
-  const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-  const piOk = record.piOk === true || record.ok === true;
-  const piRigOk = record.piRigOk === true || record.installed === true || record.ok === true;
-  const extensionPath = typeof record.extensionPath === "string" ? record.extensionPath : "remote:~/.pi/agent/extensions/pi-rig";
-  return {
-    remote: true,
-    extensionPath,
-    pi: {
-      ok: piOk,
-      label: "pi",
-      detail: typeof record.piVersion === "string" ? record.piVersion : undefined,
-      hint: piOk ? undefined : "Install/update Pi on the selected remote Rig server."
-    },
-    piRig: {
-      ok: piRigOk,
-      label: "pi-rig global extension",
-      detail: extensionPath,
-      hint: piRigOk ? undefined : "Install/enable pi-rig on the selected remote Rig server."
-    }
-  };
-}
-async function buildPiSetupChecks(input = {}) {
-  const status = await checkPiRigInstall(input);
-  return [status.pi, status.piRig];
-}
-export {
-  resolvePiRigPackageSource,
-  resolvePiRigExtensionPath,
-  ensureRemotePiRigInstalled,
-  ensurePiRigInstalled,
-  checkPiRigInstall,
-  buildPiSetupChecks
-};

package/dist/src/commands/_policy.js

@@ -1,79 +0,0 @@
-// @bun
-// packages/cli/src/commands/_policy.ts
-import { appendFileSync, mkdirSync } from "fs";
-import { resolve } from "path";
-
-// packages/cli/src/runner.ts
-import { EventBus } from "@rig/runtime/control-plane/runtime/events";
-import { CliError } from "@rig/runtime/control-plane/errors";
-import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
-import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
-import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
-import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
-function formatCommand(parts) {
-  return parts.map((part) => /[^a-zA-Z0-9_./:-]/.test(part) ? JSON.stringify(part) : part).join(" ");
-}
-
-// packages/cli/src/commands/_policy.ts
-import { evaluate as evaluate2, loadPolicy as loadPolicy2, resolveAction as resolveAction2 } from "@rig/runtime/control-plane/runtime/guard";
-import { resolveHarnessPaths } from "@rig/runtime/control-plane/native/utils";
-function resolveEffectivePolicyMode(context) {
-  const envMode = process.env.RIG_BASH_MODE;
-  if (envMode === "off" || envMode === "observe" || envMode === "enforce") {
-    return envMode;
-  }
-  return context.policyMode || loadPolicy2(context.projectRoot).mode;
-}
-function appendControlledBashAudit(context, mode, command, args, matchedRuleIds, action) {
-  if (mode === "off") {
-    return;
-  }
-  const logsDir = resolveHarnessPaths(context.projectRoot).logsDir;
-  const logFile = resolve(logsDir, "controlled-bash.jsonl");
-  mkdirSync(logsDir, { recursive: true });
-  const payload = {
-    timestamp: new Date().toISOString(),
-    mode,
-    cwd: process.cwd(),
-    pid: process.pid,
-    ppid: process.ppid,
-    argv: args,
-    command,
-    matchedRuleIds
-  };
-  if (action) {
-    payload.action = action;
-  }
-  appendFileSync(logFile, `${JSON.stringify(payload)}
-`, "utf-8");
-}
-async function enforceNativeCommandPolicy(context, args, options) {
-  const mode = resolveEffectivePolicyMode(context);
-  const command = formatCommand([options.commandPrefix, ...args]);
-  const decision = evaluate2({
-    projectRoot: context.projectRoot,
-    evaluation: { type: "command", command }
-  });
-  const action = resolveAction2(mode, decision.matchedRules);
-  const matchedRuleIds = decision.matchedRules.map((rule) => rule.id);
-  await context.emitEvent("policy.decision", {
-    target: "command",
-    command,
-    mode,
-    allowed: action !== "block",
-    matchedRuleIds,
-    reasons: decision.matchedRules.map((rule) => rule.reason)
-  });
-  if (options.writeAuditLog) {
-    appendControlledBashAudit(context, mode, command, args, matchedRuleIds, action === "block" ? "blocked" : action === "warn" ? "warn" : undefined);
-  }
-  if (action === "block") {
-    throw new CliError2(`Policy blocked command: ${command}`, 126);
-  }
-}
-export {
-  resolveEffectivePolicyMode,
-  enforceNativeCommandPolicy,
-  appendControlledBashAudit
-};