@arach/lattices 0.2.0 → 0.6.1

package/bin/cli/capture.ts

@@ -0,0 +1,252 @@
+import {
+  hasFlag,
+  nonFlagArgs,
+  parseFlagValue,
+  parseOptionalNumber,
+} from "./helpers.ts";
+import { withDaemon } from "./daemon.ts";
+
+export async function captureCommand(subcommand?: string, ...rawArgs: string[]): Promise<void> {
+  const sub = subcommand || "window";
+  const dashIndex = rawArgs.indexOf("--");
+  const commandArgs = dashIndex >= 0 ? rawArgs.slice(0, dashIndex) : rawArgs;
+  const childArgs = dashIndex >= 0 ? rawArgs.slice(dashIndex + 1) : [];
+  const jsonFlag = hasFlag(commandArgs, "json");
+  const positional = nonFlagArgs(commandArgs);
+
+  if (["stop", "stop-recording", "stopRecording"].includes(sub)) {
+    const params: Record<string, unknown> = {};
+    const runId = positional[0] || parseFlagValue(commandArgs, "run-id") || parseFlagValue(commandArgs, "runId") || parseFlagValue(commandArgs, "id");
+    const stopFile = parseFlagValue(commandArgs, "stop-file") || parseFlagValue(commandArgs, "stopFile");
+    const finishedFile = parseFlagValue(commandArgs, "finished-file") || parseFlagValue(commandArgs, "finishedFile");
+    const timeoutMs = Number(parseFlagValue(commandArgs, "timeout-ms") || parseFlagValue(commandArgs, "timeoutMs") || 30000);
+    if (runId) params.runId = runId;
+    if (stopFile) params.stopFile = stopFile;
+    if (finishedFile) params.finishedFile = finishedFile;
+    if (Number.isFinite(timeoutMs)) params.timeoutMs = timeoutMs;
+    params.wait = !hasFlag(commandArgs, "no-wait");
+
+    await withDaemon(async ({ daemonCall }) => {
+      const result = await daemonCall("capture.stopRecording", params, timeoutMs + 5000) as any;
+      if (jsonFlag) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      console.log(result.finished ? "Recording finished." : "Recording stop requested.");
+      if (result.run?.id) console.log(`  run: ${result.run.id}`);
+      if (result.marker) console.log(`  marker: ${result.marker}`);
+    });
+    return;
+  }
+
+  const isRecordCommand = [
+    "record-command",
+    "recordCommand",
+    "record-run",
+    "recordRun",
+    "record-exec",
+    "recordExec",
+  ].includes(sub);
+
+  if (isRecordCommand) {
+    if (!childArgs.length) {
+      console.log(`lattices capture record-command — record while running a command
+
+Usage:
+  lattices capture record-command --app Scout --filename demo.mov -- <command> [...args]
+`);
+      return;
+    }
+
+    const params: Record<string, unknown> = { source: "cli" };
+    const explicitWid = positional[0] ? Number(positional[0]) : NaN;
+    if (Number.isFinite(explicitWid)) params.wid = explicitWid;
+
+    const session = parseFlagValue(commandArgs, "session");
+    const app = parseFlagValue(commandArgs, "app");
+    const title = parseFlagValue(commandArgs, "title");
+    const filename = parseFlagValue(commandArgs, "filename");
+    const runId = parseFlagValue(commandArgs, "run-id") || parseFlagValue(commandArgs, "runId");
+    const mode = parseFlagValue(commandArgs, "mode");
+    const fps = parseOptionalNumber(commandArgs, "fps");
+    const scale = parseOptionalNumber(commandArgs, "scale");
+    const timeoutMs = Number(parseFlagValue(commandArgs, "timeout-ms") || parseFlagValue(commandArgs, "timeoutMs") || 30000);
+    if (session) params.session = session;
+    if (app) params.app = app;
+    if (title) params.title = title;
+    if (filename) params.filename = filename;
+    if (runId) params.runId = runId;
+    if (mode) params.mode = mode;
+    if (fps !== undefined) params.fps = fps;
+    if (scale !== undefined) params.scale = scale;
+
+    for (const [flag, key] of [["x", "x"], ["y", "y"], ["width", "width"], ["height", "height"], ["w", "w"], ["h", "h"]] as const) {
+      const value = parseOptionalNumber(commandArgs, flag);
+      if (value !== undefined) params[key] = value;
+    }
+
+    const recordsRegion = hasFlag(commandArgs, "region") ||
+      (params.x !== undefined && params.y !== undefined &&
+        (params.width !== undefined || params.w !== undefined) &&
+        (params.height !== undefined || params.h !== undefined));
+    const method = recordsRegion ? "capture.recordRegion" : "capture.recordWindow";
+
+    await withDaemon(async ({ daemonCall }) => {
+      const start = await daemonCall(method, params, 20000) as any;
+      let childExitCode = 0;
+      let childError: string | undefined;
+
+      try {
+        const proc = Bun.spawn(childArgs, {
+          cwd: process.cwd(),
+          env: process.env,
+          stdin: "inherit",
+          stdout: "inherit",
+          stderr: "inherit",
+        });
+        childExitCode = await proc.exited;
+      } catch (error) {
+        childExitCode = 127;
+        childError = (error as Error).message;
+      }
+
+      const stop = await daemonCall(
+        "capture.stopRecording",
+        { runId: start.run?.id, wait: true, timeoutMs },
+        timeoutMs + 5000
+      ) as any;
+
+      if (jsonFlag) {
+        console.log(JSON.stringify({
+          ok: childExitCode === 0 && stop.ok !== false,
+          child: {
+            command: childArgs,
+            exitCode: childExitCode,
+            error: childError,
+          },
+          recording: start,
+          stopResult: stop,
+        }, null, 2));
+      } else {
+        const artifact = start.artifact || {};
+        const run = stop.run || start.run || {};
+        console.log(`Recording finished.`);
+        console.log(`  run: ${run.id || start.run?.id || "?"}`);
+        console.log(`  artifact: ${artifact.path || "?"}`);
+        console.log(`  child exit: ${childExitCode}`);
+        if (childError) console.log(`  child error: ${childError}`);
+      }
+
+      if (childExitCode !== 0 && !hasFlag(commandArgs, "ignore-child-failure")) {
+        process.exitCode = childExitCode;
+      }
+    });
+    return;
+  }
+
+  const isRecord = ["record", "record-window", "recording", "video"].includes(sub);
+  const isRecordRegion = ["record-region", "recordRegion", "region-recording"].includes(sub) ||
+    (sub === "record" && ["region", "rect"].includes(positional[0] || ""));
+
+  if (isRecord || isRecordRegion) {
+    const params: Record<string, unknown> = { source: "cli" };
+    const targetKind = sub === "record" ? positional[0] : undefined;
+    const positionalOffset = targetKind === "window" || targetKind === "region" || targetKind === "rect" ? 1 : 0;
+    const explicitWid = positional[positionalOffset] ? Number(positional[positionalOffset]) : NaN;
+    if (Number.isFinite(explicitWid)) params.wid = explicitWid;
+
+    const session = parseFlagValue(commandArgs, "session");
+    const app = parseFlagValue(commandArgs, "app");
+    const title = parseFlagValue(commandArgs, "title");
+    const filename = parseFlagValue(commandArgs, "filename");
+    const runId = parseFlagValue(commandArgs, "run-id") || parseFlagValue(commandArgs, "runId");
+    const mode = parseFlagValue(commandArgs, "mode");
+    const fps = parseOptionalNumber(commandArgs, "fps");
+    const scale = parseOptionalNumber(commandArgs, "scale");
+    const durationMs = parseOptionalNumber(commandArgs, "duration-ms", "durationMs", "duration");
+    if (session) params.session = session;
+    if (app) params.app = app;
+    if (title) params.title = title;
+    if (filename) params.filename = filename;
+    if (runId) params.runId = runId;
+    if (mode) params.mode = mode;
+    if (fps !== undefined) params.fps = fps;
+    if (scale !== undefined) params.scale = scale;
+
+    for (const [flag, key] of [["x", "x"], ["y", "y"], ["width", "width"], ["height", "height"], ["w", "w"], ["h", "h"]] as const) {
+      const value = parseOptionalNumber(commandArgs, flag);
+      if (value !== undefined) params[key] = value;
+    }
+
+    await withDaemon(async ({ daemonCall }) => {
+      const method = isRecordRegion ? "capture.recordRegion" : "capture.recordWindow";
+      const result = await daemonCall(method, params, 20000) as any;
+
+      if (durationMs !== undefined && durationMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, durationMs));
+        const stop = await daemonCall(
+          "capture.stopRecording",
+          { runId: result.run?.id, wait: true, timeoutMs: 30000 },
+          35000
+        ) as any;
+        result.stopResult = stop;
+      }
+
+      if (jsonFlag) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      const artifact = result.artifact || {};
+      const run = result.stopResult?.run || result.run || {};
+      console.log(`Recording ${result.stopResult ? "finished" : "started"}.`);
+      console.log(`  run: ${run.id || result.run?.id || "?"}`);
+      console.log(`  artifact: ${artifact.path || "?"}`);
+      if (!result.stopResult) {
+        console.log(`  stop: lattices capture stop ${result.run?.id || ""}`);
+      }
+    });
+    return;
+  }
+
+  if (!["window", "screenshot", "shot"].includes(sub)) {
+    console.log(`lattices capture — capture run artifacts
+
+Usage:
+  lattices capture window [wid] [--json]
+  lattices capture screenshot [wid] [--session name] [--app name]
+  lattices capture record window [wid] [--app name] [--duration-ms 5000] [--json]
+  lattices capture record region --x N --y N --width N --height N [--duration-ms 5000]
+  lattices capture record-command --app Scout --filename demo.mov -- <command> [...args]
+  lattices capture stop <run-id>
+`);
+    return;
+  }
+
+  const params: Record<string, unknown> = { source: "cli" };
+  const explicitWid = positional[0] ? Number(positional[0]) : NaN;
+  if (Number.isFinite(explicitWid)) params.wid = explicitWid;
+  const session = parseFlagValue(commandArgs, "session");
+  const app = parseFlagValue(commandArgs, "app");
+  const title = parseFlagValue(commandArgs, "title");
+  const filename = parseFlagValue(commandArgs, "filename");
+  const runId = parseFlagValue(commandArgs, "run-id") || parseFlagValue(commandArgs, "runId");
+  if (session) params.session = session;
+  if (app) params.app = app;
+  if (title) params.title = title;
+  if (filename) params.filename = filename;
+  if (runId) params.runId = runId;
+
+  await withDaemon(async ({ daemonCall }) => {
+    const result = await daemonCall("capture.screenshotWindow", params, 20000) as any;
+    if (jsonFlag) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    const artifact = result.artifact || {};
+    const run = result.run || {};
+    const target = result.target || {};
+    console.log(`Captured ${target.app || "window"} ${target.wid ? `wid:${target.wid}` : ""}`);
+    console.log(`  run: ${run.id || "?"}`);
+    console.log(`  artifact: ${artifact.path || "?"}`);
+  });
+}

package/bin/cli/daemon.ts

@@ -0,0 +1,22 @@
+export type DaemonClient = typeof import("../daemon-client.ts");
+
+export async function withDaemon<T>(
+  fn: (client: DaemonClient) => Promise<T>,
+  opts?: { message?: string; exitCode?: number }
+): Promise<T> {
+  const message = opts?.message ?? "Daemon not running. Start with: lattices app";
+  const exitCode = opts?.exitCode ?? 1;
+
+  const client = await import("../daemon-client.ts");
+  if (!(await client.isDaemonRunning())) {
+    console.error(message);
+    process.exit(exitCode);
+  }
+
+  try {
+    return await fn(client);
+  } catch (e: unknown) {
+    console.error(`Error: ${(e as Error).message}`);
+    process.exit(exitCode);
+  }
+}

package/bin/cli/helpers.ts

@@ -0,0 +1,105 @@
+import { execSync } from "node:child_process";
+
+export interface ExecOpts {
+  encoding?: string;
+  stdio?: string | string[];
+  cwd?: string;
+  [key: string]: any;
+}
+
+export function run(cmd: string, opts: ExecOpts = {}): string {
+  return execSync(cmd, { encoding: "utf8", ...opts } as any).trim();
+}
+
+export function runQuiet(cmd: string): string | null {
+  try {
+    return run(cmd, { stdio: "pipe" });
+  } catch {
+    return null;
+  }
+}
+
+export function parseFlagValue(args: string[], name: string): string | undefined {
+  const prefix = `--${name}=`;
+  const exact = `--${name}`;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith(prefix)) return args[i].slice(prefix.length);
+    if (args[i] === exact) return args[i + 1];
+  }
+  return undefined;
+}
+
+export function parseOptionalNumber(args: string[], ...names: string[]): number | undefined {
+  for (const name of names) {
+    const raw = parseFlagValue(args, name);
+    if (raw === undefined || raw === "") continue;
+    const value = Number(raw);
+    if (Number.isFinite(value)) return value;
+  }
+  return undefined;
+}
+
+export function hasFlag(args: string[], name: string): boolean {
+  return args.includes(`--${name}`);
+}
+
+export function nonFlagArgs(args: string[]): string[] {
+  const valueFlags = new Set([
+    "id", "state", "ttl", "ttlMs", "x", "y", "gap", "placement", "style", "name", "scale",
+    "hud-url", "hudUrl", "hud-html", "hudHTML", "hudHtml", "hud-title", "hudTitle",
+    "hud-width", "hudWidth", "hud-height", "hudHeight", "width", "height",
+    "manifest", "root", "max-depth", "maxDepth", "read-access", "readAccess",
+    "pause", "limit", "session", "app", "name", "bundle-id", "bundleId", "bundleIdentifier",
+    "path", "app-path", "appPath", "title", "filename", "run-id", "runId",
+    "text", "tty", "wid", "treatment", "mode", "phase", "transport", "capture",
+    "appearance", "cursor-style", "cursorStyle", "shape", "marker-shape", "markerShape",
+    "cursor-shape", "cursorShape", "angle-deg", "angleDeg", "rotation-deg", "rotationDeg",
+    "rotation", "angle", "color", "duration-ms", "durationMs",
+    "type-interval-ms", "typeIntervalMs", "typing-interval-ms", "typingIntervalMs", "label",
+    "caption", "treatment-label", "treatmentLabel", "variant",
+    "caption-title", "captionTitle", "caption-body", "captionBody",
+    "caption-detail", "captionDetail", "caption-tags", "captionTags",
+    "caption-mode", "captionMode", "caption-eyebrow", "captionEyebrow",
+    "caption-lead-ms", "captionLeadMs", "caption-sound", "captionSound",
+    "caption-placement", "captionPlacement", "caption-margin", "captionMargin",
+    "caption-x", "captionX", "caption-y", "captionY",
+    "caption-x-ratio", "captionXRatio", "caption-y-ratio", "captionYRatio",
+    "caption-left-ratio", "captionLeftRatio", "caption-top-ratio", "captionTopRatio",
+    "sound", "sfx",
+    "trail", "effect", "path-style", "pathStyle", "motion", "easing", "velocity",
+    "trajectory", "curve", "arc", "glow", "bloom", "idle", "settle", "presence",
+    "edge", "edge-effect", "edgeEffect", "arrival",
+    "fps", "w", "h", "stop-file", "stopFile", "finished-file", "finishedFile",
+    "timeout-ms", "timeoutMs", "duration",
+    "x", "y", "x-ratio", "xRatio", "y-ratio", "yRatio",
+    "relative-x", "relativeX", "relative-y", "relativeY",
+    "window-x", "windowX", "window-y", "windowY", "button",
+  ]);
+  const out: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg.startsWith("--")) {
+      out.push(arg);
+      continue;
+    }
+    const flagName = arg.slice(2);
+    if (!arg.includes("=") && valueFlags.has(flagName)) i++;
+  }
+  return out;
+}
+
+export function relativeTime(iso: string): string {
+  const ms = Date.now() - new Date(iso).getTime();
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return "just now";
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  const d = Math.floor(h / 24);
+  return `${d}d ago`;
+}
+
+export function pause(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/bin/cli/layer.ts

@@ -0,0 +1,178 @@
+import { withDaemon, type DaemonClient } from "./daemon.ts";
+
+export async function layerCommand(sub?: string, ...rest: string[]): Promise<void> {
+  await withDaemon(async (client) => {
+    const { daemonCall } = client;
+
+    if (sub === "create") {
+      await layerCreateCommand(client, rest);
+      return;
+    }
+    if (sub === "snap") {
+      await layerSnapCommand(client, rest[0]);
+      return;
+    }
+    if (sub === "session" || sub === "sessions") {
+      await layerSessionCommand(client, rest[0]);
+      return;
+    }
+    if (sub === "clear") {
+      await daemonCall("session.layers.clear");
+      console.log("Cleared all session layers.");
+      return;
+    }
+    if (sub === "delete" || sub === "rm") {
+      if (!rest[0]) { console.log("Usage: lattices layer delete <name>"); return; }
+      await daemonCall("session.layers.delete", { name: rest[0] });
+      console.log(`Deleted session layer "${rest[0]}".`);
+      return;
+    }
+
+    if (sub === undefined || sub === null || sub === "") {
+      const result = await daemonCall("layers.list") as any;
+      if (!result.layers.length) {
+        console.log("No layers configured.");
+        return;
+      }
+      console.log("Layers:\n");
+      for (const layer of result.layers) {
+        const active = layer.index === result.active ? " \x1b[32m● active\x1b[0m" : "";
+        console.log(`  [${layer.index}] ${layer.label}  (${layer.projectCount} projects)${active}`);
+      }
+      return;
+    }
+    const idx = parseInt(sub, 10);
+    if (!isNaN(idx)) {
+      await daemonCall("layer.activate", { index: idx, mode: "launch" });
+      console.log(`Activated layer ${idx}`);
+    } else {
+      await daemonCall("layer.activate", { name: sub, mode: "launch" });
+      console.log(`Activated layer "${sub}"`);
+    }
+  });
+}
+
+// ── Layer create: build a session layer from window specs ────────────
+// Usage: lattices layer create <name> [wid:123 wid:456 ...]
+//        lattices layer create <name> --json '[{"app":"Chrome","tile":"left"},...]'
+export async function layerCreateCommand(client: DaemonClient, args: string[]): Promise<void> {
+  const { daemonCall } = client;
+  const name = args[0];
+  if (!name) {
+    console.log("Usage: lattices layer create <name> [wid:123 ...] [--json '<specs>']");
+    return;
+  }
+
+  const jsonIdx = args.indexOf("--json");
+  if (jsonIdx !== -1 && args[jsonIdx + 1]) {
+    // JSON mode: parse window specs with tile positions
+    const specs = JSON.parse(args[jsonIdx + 1]) as Array<{
+      wid?: number; app?: string; title?: string; tile?: string;
+    }>;
+
+    // Collect wids, resolve app-based specs
+    const windowIds: number[] = [];
+    const windows: Array<{ app: string; contentHint?: string }> = [];
+    const tiles: Array<{ wid?: number; app?: string; title?: string; tile: string }> = [];
+
+    for (const spec of specs) {
+      if (spec.wid) {
+        windowIds.push(spec.wid);
+        if (spec.tile) tiles.push({ wid: spec.wid, tile: spec.tile });
+      } else if (spec.app) {
+        windows.push({ app: spec.app, contentHint: spec.title });
+        if (spec.tile) tiles.push({ app: spec.app, title: spec.title, tile: spec.tile });
+      }
+    }
+
+    await daemonCall("session.layers.create", {
+      name,
+      ...(windowIds.length ? { windowIds } : {}),
+      ...(windows.length ? { windows } : {}),
+    }) as any;
+
+    console.log(`Created session layer "${name}" with ${specs.length} window(s).`);
+
+    // Apply tile positions
+    for (const t of tiles) {
+      try {
+        await daemonCall("window.place", {
+          ...(t.wid ? { wid: t.wid } : { app: t.app, title: t.title }),
+          placement: t.tile,
+        });
+      } catch { /* window may not be resolved yet */ }
+    }
+
+    if (tiles.length) console.log(`Tiled ${tiles.length} window(s).`);
+    return;
+  }
+
+  // Simple wid mode: lattices layer create <name> wid:123 wid:456
+  const wids = args.slice(1)
+    .filter(a => a.startsWith("wid:"))
+    .map(a => parseInt(a.slice(4), 10))
+    .filter(n => !isNaN(n));
+
+  await daemonCall("session.layers.create", {
+    name,
+    ...(wids.length ? { windowIds: wids } : {}),
+  }) as any;
+
+  console.log(`Created session layer "${name}"${wids.length ? ` with ${wids.length} window(s)` : ""}.`);
+}
+
+// ── Layer snap: snapshot current visible windows into a session layer ─
+export async function layerSnapCommand(client: DaemonClient, name?: string): Promise<void> {
+  const { daemonCall } = client;
+  const layerName = name || `snap-${new Date().toISOString().slice(11, 19).replace(/:/g, "")}`;
+
+  // Get all current windows
+  const windows = await daemonCall("windows.list") as any[];
+  const visibleWids = windows
+    .filter((w: any) => !w.isMinimized && w.app !== "lattices")
+    .map((w: any) => w.wid);
+
+  if (!visibleWids.length) {
+    console.log("No visible windows to snapshot.");
+    return;
+  }
+
+  await daemonCall("session.layers.create", {
+    name: layerName,
+    windowIds: visibleWids,
+  });
+
+  console.log(`Snapped ${visibleWids.length} window(s) → session layer "${layerName}".`);
+}
+
+// ── Layer session: list or switch session layers ─────────────────────
+export async function layerSessionCommand(client: DaemonClient, nameOrIndex?: string): Promise<void> {
+  const { daemonCall } = client;
+  const result = await daemonCall("session.layers.list") as any;
+
+  if (!nameOrIndex) {
+    // List session layers
+    if (!result.layers.length) {
+      console.log("No session layers. Create one with: lattices layer create <name>");
+      return;
+    }
+    console.log("Session layers:\n");
+    for (let i = 0; i < result.layers.length; i++) {
+      const l = result.layers[i];
+      const active = i === result.activeIndex ? " \x1b[32m● active\x1b[0m" : "";
+      const winCount = l.windows?.length || 0;
+      console.log(`  [${i}] ${l.name}  (${winCount} windows)${active}`);
+    }
+    return;
+  }
+
+  // Switch by index or name
+  const idx = parseInt(nameOrIndex, 10);
+  if (!isNaN(idx)) {
+    await daemonCall("session.layers.switch", { index: idx });
+    console.log(`Switched to session layer ${idx}.`);
+  } else {
+    await daemonCall("session.layers.switch", { name: nameOrIndex });
+    console.log(`Switched to session layer "${nameOrIndex}".`);
+  }
+}

package/bin/cli/runs.ts

@@ -0,0 +1,43 @@
+import { hasFlag, nonFlagArgs, parseFlagValue } from "./helpers.ts";
+import { withDaemon } from "./daemon.ts";
+
+function runLine(run: any): string {
+  const count = Array.isArray(run.artifacts) ? run.artifacts.length : 0;
+  const completed = run.completedAt ? ` completed=${run.completedAt}` : "";
+  return `  ${run.id}  ${run.state || "?"}  artifacts=${count}  ${run.title || "Untitled run"}${completed}`;
+}
+
+export async function runsCommand(rawArgs: string[] = []): Promise<void> {
+  const jsonFlag = hasFlag(rawArgs, "json");
+  const positional = nonFlagArgs(rawArgs);
+  const sub = positional[0];
+
+  await withDaemon(async ({ daemonCall }) => {
+    if (sub && sub !== "list") {
+      const run = await daemonCall("runs.get", { id: sub }) as any;
+      if (jsonFlag) {
+        console.log(JSON.stringify(run, null, 2));
+        return;
+      }
+      console.log(runLine(run));
+      console.log(`  artifacts: ${run.artifactDirectoryPath}`);
+      for (const artifact of run.artifacts || []) {
+        console.log(`    ${artifact.kind}  ${artifact.path}`);
+      }
+      return;
+    }
+
+    const limit = Number(parseFlagValue(rawArgs, "limit") || 20);
+    const runs = await daemonCall("runs.list", { limit }) as any[];
+    if (jsonFlag) {
+      console.log(JSON.stringify(runs, null, 2));
+      return;
+    }
+    if (!runs.length) {
+      console.log("No runs yet.");
+      return;
+    }
+    console.log(`Runs (${runs.length}):\n`);
+    for (const run of runs) console.log(runLine(run));
+  });
+}