muonroi-cli 1.4.0 → 1.4.1

package/src/verify/environment.ts

@@ -1,115 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import type { VerifyEnvironmentManifest, VerifyRecipe } from "../types/index";
-import { mergeSandboxSettings, normalizeSandboxSettings, type SandboxSettings } from "../utils/settings";
-import { normalizeVerifyRecipe } from "./recipes";
-
-export interface LoadedVerifyEnvironment {
-  path: string;
-  recipe: VerifyRecipe;
-  sandboxSettings: SandboxSettings;
-}
-
-const VERIFY_ENVIRONMENT_FILES = [".muonroi-cli/environment.json", "environment.json"];
-const GENERATED_VERIFY_ENVIRONMENT = ".muonroi-cli/environment.json";
-
-function readJson(filePath: string): VerifyEnvironmentManifest | null {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf8")) as VerifyEnvironmentManifest;
-  } catch {
-    return null;
-  }
-}
-
-function asStringArray(value: unknown): string[] {
-  if (typeof value === "string" && value.trim()) return [value.trim()];
-  if (!Array.isArray(value)) return [];
-  return value
-    .filter((entry): entry is string => typeof entry === "string" && entry.trim() !== "")
-    .map((entry) => entry.trim());
-}
-
-function normalizeManifestRecipe(raw: VerifyEnvironmentManifest): VerifyRecipe | null {
-  const base = raw.recipe && typeof raw.recipe === "object" ? raw.recipe : raw;
-  return normalizeVerifyRecipe({
-    ecosystem: base.ecosystem ?? raw.ecosystem ?? "custom",
-    appKind: base.appKind ?? raw.appKind ?? "unknown",
-    appLabel: base.appLabel ?? raw.appLabel ?? "Custom verify environment",
-    shellInitCommands: base.shellInitCommands ?? base.shellInit ?? raw.shellInitCommands ?? raw.shellInit ?? [],
-    bootstrapCommands: base.bootstrapCommands ?? base.bootstrap ?? raw.bootstrapCommands ?? raw.bootstrap ?? [],
-    installCommands: base.installCommands ?? base.install ?? raw.installCommands ?? raw.install ?? [],
-    buildCommands: base.buildCommands ?? base.build ?? raw.buildCommands ?? raw.build ?? [],
-    testCommands: base.testCommands ?? base.test ?? raw.testCommands ?? raw.test ?? [],
-    startCommand: base.startCommand ?? base.start ?? raw.startCommand ?? raw.start,
-    startPort: base.startPort ?? raw.startPort,
-    smokeKind: base.smokeKind ?? raw.smokeKind ?? "none",
-    smokeTarget: base.smokeTarget ?? raw.smokeTarget,
-    evidence: asStringArray(base.evidence ?? raw.evidence),
-    notes: asStringArray(base.notes ?? raw.notes),
-  });
-}
-
-export function loadVerifyEnvironment(cwd: string, baseSettings: SandboxSettings = {}): LoadedVerifyEnvironment | null {
-  for (const candidate of VERIFY_ENVIRONMENT_FILES) {
-    const filePath = path.join(cwd, candidate);
-    if (!fs.existsSync(filePath)) continue;
-    const manifest = readJson(filePath);
-    if (!manifest) continue;
-    const recipe = normalizeManifestRecipe(manifest);
-    if (!recipe) continue;
-    const sandboxSettings = mergeSandboxSettings(baseSettings, normalizeSandboxSettings(manifest.sandbox));
-    return {
-      path: filePath,
-      recipe,
-      sandboxSettings,
-    };
-  }
-  return null;
-}
-
-function pickPersistentSandboxSettings(settings: SandboxSettings): SandboxSettings {
-  const persistent: SandboxSettings = {};
-  if (settings.allowNet !== undefined) persistent.allowNet = settings.allowNet;
-  if (settings.allowedHosts?.length) persistent.allowedHosts = settings.allowedHosts;
-  if (settings.ports?.length) persistent.ports = settings.ports;
-  if (settings.cpus) persistent.cpus = settings.cpus;
-  if (settings.memory) persistent.memory = settings.memory;
-  if (settings.diskSize) persistent.diskSize = settings.diskSize;
-  if (settings.secrets?.length) persistent.secrets = settings.secrets;
-  if (settings.from) persistent.from = settings.from;
-  if (settings.verifyBaseFrom) persistent.verifyBaseFrom = settings.verifyBaseFrom;
-  if (settings.guestWorkdir) persistent.guestWorkdir = settings.guestWorkdir;
-  if (settings.syncHostWorkspace !== undefined) persistent.syncHostWorkspace = settings.syncHostWorkspace;
-  if (settings.shellInit?.length) persistent.shellInit = settings.shellInit;
-  return persistent;
-}
-
-export function saveVerifyEnvironment(
-  cwd: string,
-  recipe: VerifyRecipe,
-  sandboxSettings: SandboxSettings = {},
-): string {
-  const filePath = path.join(cwd, GENERATED_VERIFY_ENVIRONMENT);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  const payload: VerifyEnvironmentManifest = {
-    recipe: {
-      ecosystem: recipe.ecosystem,
-      appKind: recipe.appKind,
-      appLabel: recipe.appLabel,
-      shellInitCommands: recipe.shellInitCommands,
-      bootstrapCommands: recipe.bootstrapCommands,
-      installCommands: recipe.installCommands,
-      buildCommands: recipe.buildCommands,
-      testCommands: recipe.testCommands,
-      startCommand: recipe.startCommand,
-      startPort: recipe.startPort,
-      smokeKind: recipe.smokeKind,
-      smokeTarget: recipe.smokeTarget,
-      evidence: recipe.evidence,
-      notes: recipe.notes,
-    },
-    sandbox: pickPersistentSandboxSettings(sandboxSettings),
-  };
-  fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-  return filePath;
-}

package/src/verify/evidence.ts

@@ -1,104 +0,0 @@
-import type { VerifyArtifact } from "../types/index";
-import type { VerifyProjectProfile } from "./recipes";
-
-export const VERIFY_ARTIFACT_DIR = ".muonroi-cli/verify-artifacts";
-export const VERIFY_SCREENSHOT_PATH = `${VERIFY_ARTIFACT_DIR}/verify-screenshot.png`;
-export const VERIFY_VIDEO_PATH = `${VERIFY_ARTIFACT_DIR}/verify-smoke.webm`;
-export const VERIFY_LOG_PATH = `${VERIFY_ARTIFACT_DIR}/app.log`;
-
-export function getVerifyArtifacts(): VerifyArtifact[] {
-  return [
-    { kind: "log", path: VERIFY_LOG_PATH, description: "Captured app stdout/stderr from the verify run" },
-    {
-      kind: "screenshot",
-      path: VERIFY_SCREENSHOT_PATH,
-      description: "Final browser screenshot from smoke verification",
-    },
-    { kind: "video", path: VERIFY_VIDEO_PATH, description: "Recorded browser smoke flow" },
-  ];
-}
-
-export function buildReadinessGuidance(profile: VerifyProjectProfile): string[] {
-  if (profile.recipe.smokeKind !== "http" || !profile.recipe.startCommand || !profile.recipe.startPort) {
-    return [
-      "- If you start any process, capture stdout/stderr into a log file under .muonroi-cli/verify-artifacts whenever practical.",
-    ];
-  }
-
-  const target = profile.recipe.smokeTarget ?? `http://127.0.0.1:${profile.recipe.startPort}`;
-  return [
-    `- Start the app with logs redirected to ${VERIFY_LOG_PATH} so failures leave evidence.`,
-    `- Before running browser checks, wait for readiness at ${target}. Prefer a bounded curl loop or equivalent readiness check instead of guessing.`,
-    "- If readiness never succeeds, include the final log tail and exact readiness command output in the report.",
-  ];
-}
-
-export function buildBrowserGuidance(profile: VerifyProjectProfile): string[] {
-  if (profile.recipe.smokeKind === "http" && profile.recipe.smokeTarget) {
-    return [
-      `- REQUIRED: After the dev server is running, you MUST run browser smoke tests against ${profile.recipe.smokeTarget}.`,
-      "- The agent-browser command runs on the HOST, not inside the sandbox. It WILL work. Do not skip it or assume it is unavailable.",
-      "- CRITICAL SEQUENCING: The dev server MUST stay running for the entire browser test. Do NOT stop the server until after recording is stopped and the browser is closed.",
-      "",
-      // biome-ignore lint/suspicious/noTemplateCurlyInString: shell variable reference in prompt text
-      "- IMPORTANT: All artifact paths MUST be absolute. Use `$(pwd)/${VERIFY_ARTIFACT_DIR}` to construct them. Example: `$(pwd)/.muonroi-cli/verify-artifacts/verify-smoke.webm`.",
-      "",
-      "- Browser smoke test procedure (run each step as a SEPARATE bash tool call):",
-      `  1. mkdir -p ${VERIFY_ARTIFACT_DIR}`,
-      `  2. agent-browser record start "$(pwd)/${VERIFY_VIDEO_PATH}"`,
-      "  3. sleep 1",
-      `  4. agent-browser --screenshot-dir "$(pwd)/${VERIFY_ARTIFACT_DIR}" open ${profile.recipe.smokeTarget}`,
-      "  5. agent-browser wait --load networkidle",
-      "  6. sleep 2",
-      `  7. agent-browser --screenshot-dir "$(pwd)/${VERIFY_ARTIFACT_DIR}" screenshot`,
-      "  8. agent-browser get title",
-      "",
-      "- INTERACTIVE TESTING (do this now, while recording is still running):",
-      "  Act like a real user doing an integration test. The goal is to verify the app actually works, not just that it loads.",
-      "  - Run each agent-browser command as a SEPARATE bash tool call. Do NOT chain them.",
-      "  - After each interaction, run `sleep 2` so the recording captures the result.",
-      "  - Use `agent-browser snapshot` to see the page structure and interactive elements.",
-      "  - Click links, buttons, and navigation using `agent-browser click <ref>` (refs from snapshot).",
-      "  - After each click, `agent-browser wait --load networkidle && sleep 2`, then snapshot and screenshot.",
-      "  - Check for console errors using `agent-browser console`.",
-      "  - Test at least: home page loads with content, primary navigation works, no JS errors in console.",
-      "  - If the app has forms, try filling one. If it has a login page, verify it renders.",
-      "  - Spend 3-5 interactions exploring the critical path. Do not rush.",
-      "",
-      "- Teardown (after interactive testing, run each as a separate bash call):",
-      "  9. agent-browser record stop",
-      "  10. sleep 2",
-      `  11. ls -la "$(pwd)/${VERIFY_VIDEO_PATH}" (verify the video file exists and has a non-zero size)`,
-      "  12. agent-browser close",
-      "  13. Only NOW stop the dev server (kill the background process).",
-      "",
-      `- Keep all screenshots and video under ${VERIFY_ARTIFACT_DIR}. Include their exact paths in the Evidence section.`,
-      "- If the video file does not exist after `record stop`, note that in Blockers.",
-      "- If any browser command fails, report the exact error output. Do not skip browser checks.",
-    ];
-  }
-
-  if ((profile.sandboxSettings.ports?.length ?? 0) > 1) {
-    return [
-      "- Multiple forwarded ports are configured, so browser smoke testing is ambiguous.",
-      "- Skip browser checks unless the user clearly identifies which forwarded localhost URL to verify.",
-    ];
-  }
-
-  if (profile.recipe.smokeKind === "cli") {
-    return ["- This project appears to need CLI-style runtime validation rather than browser smoke testing."];
-  }
-
-  return [
-    "- No unambiguous forwarded localhost URL is configured, so browser smoke testing is optional and should usually be skipped.",
-    "- If the app can still be verified with bash-only checks, do that and explain why browser checks were skipped.",
-  ];
-}
-
-export function buildEvidenceGuidance(): string[] {
-  const artifacts = getVerifyArtifacts();
-  return [
-    "- Always include exact artifact file paths in the Evidence section when they exist.",
-    ...artifacts.map((artifact) => `- Artifact target: ${artifact.path} (${artifact.description}).`),
-  ];
-}

package/src/verify/orchestrator.test.ts

@@ -1,159 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("./checkpoint", () => ({
-  ensureVerifyCheckpoint: vi.fn(async () => ({ created: false })),
-}));
-
-import { ensureVerifyCheckpoint } from "./checkpoint";
-import { prepareVerifyRun, runVerifyOrchestration } from "./orchestrator";
-
-const ensureVerifyCheckpointMock = vi.mocked(ensureVerifyCheckpoint);
-const tempDirs: string[] = [];
-
-function makeTempDir(prefix: string): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  tempDirs.push(dir);
-  return dir;
-}
-
-afterEach(() => {
-  ensureVerifyCheckpointMock.mockReset();
-  ensureVerifyCheckpointMock.mockResolvedValue({ created: false });
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-  }
-});
-
-describe("verify orchestrator", () => {
-  it("uses the environment manifest as the highest-priority recipe source", async () => {
-    const dir = makeTempDir("muonroi-verify-orch-manifest-");
-    fs.writeFileSync(
-      path.join(dir, "environment.json"),
-      JSON.stringify(
-        {
-          ecosystem: "custom",
-          appKind: "node",
-          appLabel: "Manifest app",
-          install: ["npm ci"],
-          build: ["npm run build"],
-          smokeKind: "none",
-        },
-        null,
-        2,
-      ),
-    );
-
-    const agent = {
-      getCwd: () => dir,
-      getSandboxSettings: () => ({}),
-      setSandboxSettings: vi.fn(),
-      detectVerifyRecipe: vi.fn(async () => null),
-      runTaskRequest: vi.fn(async () => ({ success: true, output: "ok" })),
-    };
-
-    const prepared = await prepareVerifyRun(agent, {});
-    expect(prepared.profile.recipe.ecosystem).toBe("custom");
-    expect(prepared.profile.recipe.installCommands).toEqual(["npm ci"]);
-    expect(prepared.usedVerifyDetect).toBe(false);
-    expect(agent.detectVerifyRecipe).not.toHaveBeenCalled();
-  });
-
-  it("creates .muonroi-cli/environment.json from verify-detect when no manifest exists", async () => {
-    const dir = makeTempDir("muonroi-verify-orch-generate-");
-    fs.writeFileSync(
-      path.join(dir, "package.json"),
-      JSON.stringify({ dependencies: { next: "15.0.0" }, scripts: { dev: "next dev", build: "next build" } }, null, 2),
-    );
-    fs.writeFileSync(path.join(dir, "package-lock.json"), "");
-
-    const agent = {
-      getCwd: () => dir,
-      getSandboxSettings: () => ({}),
-      setSandboxSettings: vi.fn(),
-      detectVerifyRecipe: vi.fn(async () => ({
-        ecosystem: "custom",
-        appKind: "node",
-        appLabel: "Agent recipe",
-        shellInitCommands: ["export FOO=bar"],
-        bootstrapCommands: ["echo bootstrap"],
-        installCommands: ["npm ci"],
-        buildCommands: ["npm run build"],
-        testCommands: [],
-        startCommand: "npm run start",
-        startPort: "3000",
-        smokeKind: "http" as const,
-        smokeTarget: "http://127.0.0.1:3000",
-        evidence: ["agent-detect"],
-        notes: ["generated"],
-      })),
-      runTaskRequest: vi.fn(async () => ({ success: true, output: "ok" })),
-    };
-
-    const prepared = await prepareVerifyRun(agent, {});
-    expect(prepared.manifestPath).toBe(path.join(dir, ".muonroi-cli", "environment.json"));
-    expect(fs.existsSync(prepared.manifestPath!)).toBe(true);
-    expect(prepared.usedVerifyDetect).toBe(true);
-    expect(prepared.profile.recipe.installCommands).toEqual(["npm ci"]);
-    expect(prepared.profile.recipe.evidence).toContain("agent-detect");
-  });
-
-  it("does not create a manifest when verify-detect returns no recipe", async () => {
-    const dir = makeTempDir("muonroi-verify-orch-no-manifest-");
-    fs.writeFileSync(
-      path.join(dir, "package.json"),
-      JSON.stringify({ dependencies: { next: "15.0.0" }, scripts: { dev: "next dev", build: "next build" } }, null, 2),
-    );
-    fs.writeFileSync(path.join(dir, "package-lock.json"), "");
-
-    const agent = {
-      getCwd: () => dir,
-      getSandboxSettings: () => ({}),
-      setSandboxSettings: vi.fn(),
-      detectVerifyRecipe: vi.fn(async () => null),
-      runTaskRequest: vi.fn(async () => ({ success: true, output: "ok" })),
-    };
-
-    const prepared = await prepareVerifyRun(agent, {});
-    expect(prepared.manifestPath).toBeUndefined();
-    expect(fs.existsSync(path.join(dir, ".muonroi-cli", "environment.json"))).toBe(false);
-    expect(prepared.usedVerifyDetect).toBe(false);
-  });
-
-  it("restores sandbox settings after running verification and wires checkpoint settings", async () => {
-    const dir = makeTempDir("muonroi-verify-orch-run-");
-    fs.writeFileSync(
-      path.join(dir, "package.json"),
-      JSON.stringify({ dependencies: { next: "15.0.0" }, scripts: { dev: "next dev", build: "next build" } }, null, 2),
-    );
-    fs.writeFileSync(path.join(dir, "package-lock.json"), "");
-
-    ensureVerifyCheckpointMock.mockResolvedValue({
-      created: true,
-      checkpointName: "verify-next-demo",
-      guestWorkdir: "/grok/verify/worktree",
-    });
-
-    const originalSettings = { allowNet: false, from: "base" };
-    const agent = {
-      getCwd: () => dir,
-      getSandboxSettings: vi.fn(() => originalSettings),
-      setSandboxSettings: vi.fn(),
-      detectVerifyRecipe: vi.fn(async () => null),
-      runTaskRequest: vi.fn(async () => ({ success: true, output: "verified" })),
-    };
-
-    const result = await runVerifyOrchestration(agent, {});
-    expect(result.success).toBe(true);
-    expect(agent.setSandboxSettings).toHaveBeenCalledTimes(2);
-    expect(agent.setSandboxSettings.mock.calls[0]?.[0]).toMatchObject({
-      from: "verify-next-demo",
-      guestWorkdir: "/grok/verify/worktree",
-      syncHostWorkspace: true,
-      allowNet: true,
-    });
-    expect(agent.setSandboxSettings.mock.calls[1]?.[0]).toBe(originalSettings);
-  });
-});

package/src/verify/orchestrator.ts

@@ -1,129 +0,0 @@
-import type { TaskRequest, ToolResult, VerifyRecipe } from "../types/index";
-import type { SandboxSettings } from "../utils/settings";
-import { ensureVerifyCheckpoint, type PreparedVerifyCheckpoint } from "./checkpoint";
-import { buildVerifyTaskPrompt } from "./entrypoint";
-import { loadVerifyEnvironment, saveVerifyEnvironment } from "./environment";
-import { inferVerifyProjectProfile, type VerifyProjectProfile } from "./recipes";
-
-export interface VerifyAgentLike {
-  getCwd(): string;
-  getSandboxSettings(): SandboxSettings;
-  setSandboxSettings(settings: SandboxSettings): void;
-  detectVerifyRecipe(settings?: SandboxSettings, abortSignal?: AbortSignal): Promise<VerifyRecipe | null>;
-  runTaskRequest(
-    request: TaskRequest,
-    onActivity?: (detail: string) => void,
-    abortSignal?: AbortSignal,
-  ): Promise<ToolResult>;
-}
-
-export interface PreparedVerifyRun {
-  profile: VerifyProjectProfile;
-  sandboxSettings: SandboxSettings;
-  taskRequest: TaskRequest;
-  checkpoint?: PreparedVerifyCheckpoint;
-  manifestPath?: string;
-  usedVerifyDetect: boolean;
-}
-
-export interface VerifyOrchestratorOptions {
-  onProgress?: (detail: string) => void;
-  abortSignal?: AbortSignal;
-}
-
-function buildRuntimeSandboxSettings(profile: VerifyProjectProfile): SandboxSettings {
-  return {
-    ...profile.sandboxSettings,
-    allowNet: true,
-    allowedHosts: undefined,
-    allowEphemeralInstall: true,
-    hostBrowserCommandsOnHost: true,
-    shellInit: [...new Set([...(profile.sandboxSettings.shellInit ?? []), ...profile.recipe.shellInitCommands])],
-  };
-}
-
-export async function prepareVerifyRun(
-  agent: VerifyAgentLike,
-  options: VerifyOrchestratorOptions = {},
-): Promise<PreparedVerifyRun> {
-  const cwd = agent.getCwd();
-  const baseSettings = agent.getSandboxSettings();
-  const manifest = loadVerifyEnvironment(cwd, baseSettings);
-
-  if (manifest) {
-    options.onProgress?.(`Loaded verify environment manifest: ${manifest.path}`);
-  } else {
-    options.onProgress?.("No verify environment manifest found; running verify-detect to generate one");
-  }
-
-  let profile = inferVerifyProjectProfile(cwd, manifest?.sandboxSettings ?? baseSettings, manifest?.recipe ?? null);
-  let usedVerifyDetect = false;
-  let manifestPath = manifest?.path;
-
-  if (!manifest) {
-    const detectedRecipe = await agent.detectVerifyRecipe(baseSettings, options.abortSignal);
-    if (detectedRecipe) {
-      usedVerifyDetect = true;
-      profile = inferVerifyProjectProfile(cwd, baseSettings, detectedRecipe);
-      options.onProgress?.(`verify-detect selected recipe for ${profile.appLabel}`);
-      manifestPath = saveVerifyEnvironment(cwd, profile.recipe, profile.sandboxSettings);
-      options.onProgress?.(`Created verify environment manifest: ${manifestPath}`);
-    } else {
-      options.onProgress?.(
-        "verify-detect did not return a usable recipe; keeping deterministic fallback without writing a manifest",
-      );
-    }
-  }
-
-  const sandboxSettings = buildRuntimeSandboxSettings(profile);
-  options.onProgress?.("Preparing verify checkpoint");
-  const checkpoint = await ensureVerifyCheckpoint(cwd, profile, sandboxSettings);
-  if (checkpoint.checkpointName) {
-    sandboxSettings.from = checkpoint.checkpointName;
-    if (checkpoint.guestWorkdir) {
-      sandboxSettings.guestWorkdir = checkpoint.guestWorkdir;
-      sandboxSettings.syncHostWorkspace = true;
-    }
-    options.onProgress?.(
-      checkpoint.created
-        ? `Created verify checkpoint: ${checkpoint.checkpointName}`
-        : `Using verify checkpoint: ${checkpoint.checkpointName}`,
-    );
-  } else {
-    options.onProgress?.("No verify checkpoint needed for this recipe");
-  }
-
-  const taskRequest: TaskRequest = {
-    agent: "verify",
-    description: "Run local verification",
-    prompt: buildVerifyTaskPrompt(cwd, sandboxSettings, profile.recipe),
-  };
-
-  return {
-    profile,
-    sandboxSettings,
-    taskRequest,
-    checkpoint,
-    manifestPath,
-    usedVerifyDetect,
-  };
-}
-
-export async function runVerifyOrchestration(
-  agent: VerifyAgentLike,
-  options: VerifyOrchestratorOptions = {},
-): Promise<ToolResult> {
-  const originalSandboxSettings = agent.getSandboxSettings();
-  const prepared = await prepareVerifyRun(agent, options);
-  agent.setSandboxSettings(prepared.sandboxSettings);
-  try {
-    options.onProgress?.("Running verify sub-agent");
-    const result = await agent.runTaskRequest(prepared.taskRequest, options.onProgress, options.abortSignal);
-    return {
-      ...result,
-      verifyRecipe: prepared.profile.recipe,
-    };
-  } finally {
-    agent.setSandboxSettings(originalSandboxSettings);
-  }
-}