@automaze/proof 0.20260311.0

package/dist/cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.test.js

@@ -0,0 +1,200 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { join } from "path";
+import { mkdtemp, rm, readFile } from "fs/promises";
+import { tmpdir } from "os";
+import { existsSync } from "fs";
+const CLI_PATH = join(import.meta.dir, "cli.ts");
+const TEST_APP_DIR = join(import.meta.dir, "../test-app");
+async function runCli(args, stdin) {
+    const proc = Bun.spawn(["bun", "run", CLI_PATH, ...args], {
+        stdin: stdin ? new Blob([stdin]) : undefined,
+        stdout: "pipe",
+        stderr: "pipe",
+        env: { ...process.env, FORCE_COLOR: "0" },
+    });
+    const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+    ]);
+    const exitCode = await proc.exited;
+    return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode };
+}
+describe("CLI", () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), "proof-cli-test-"));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    describe("help and usage", () => {
+        test("prints usage with --help", async () => {
+            const { stdout, exitCode } = await runCli(["--help"]);
+            expect(exitCode).toBe(0);
+            expect(stdout).toContain("@automaze/proof");
+            expect(stdout).toContain("proof capture");
+            expect(stdout).toContain("--app");
+        });
+        test("prints usage with no args", async () => {
+            const { stdout, exitCode } = await runCli([]);
+            expect(exitCode).toBe(0);
+            expect(stdout).toContain("@automaze/proof");
+        });
+    });
+    describe("arg validation", () => {
+        test("errors when --app is missing", async () => {
+            const { stderr, exitCode } = await runCli(["capture", "--command", "echo hi"]);
+            expect(exitCode).toBe(1);
+            expect(stderr).toContain("--app is required");
+        });
+        test("errors when capture has no --command or --test-file", async () => {
+            const { stderr, exitCode } = await runCli(["capture", "--app", "test"]);
+            expect(exitCode).toBe(1);
+            expect(stderr).toContain("--command or --test-file is required");
+        });
+        test("errors on unknown action", async () => {
+            const { stderr, exitCode } = await runCli(["bogus"]);
+            expect(exitCode).toBe(1);
+            expect(stderr).toContain("Unknown action");
+        });
+    });
+    describe("capture (arg mode)", () => {
+        test("captures terminal output and returns JSON", async () => {
+            const { stdout, exitCode } = await runCli([
+                "capture",
+                "--app", "cli-test",
+                "--dir", tempDir,
+                "--run", "r1",
+                "--command", "echo hello",
+                "--mode", "terminal",
+                "--label", "echo-test",
+            ]);
+            expect(exitCode).toBe(0);
+            const result = JSON.parse(stdout);
+            expect(result.action).toBe("capture");
+            expect(result.appName).toBe("cli-test");
+            expect(result.recordings).toHaveLength(1);
+            expect(result.recordings[0].mode).toBe("terminal");
+            expect(result.recordings[0].label).toBe("echo-test");
+            expect(result.recordings[0].duration).toBeGreaterThanOrEqual(0);
+            expect(existsSync(result.recordings[0].path)).toBe(true);
+        });
+        test("passes --description through to manifest", async () => {
+            const { stdout, exitCode } = await runCli([
+                "capture",
+                "--app", "cli-test",
+                "--dir", tempDir,
+                "--run", "r1",
+                "--command", "echo hi",
+                "--mode", "terminal",
+                "--description", "A test capture",
+            ]);
+            expect(exitCode).toBe(0);
+            const result = JSON.parse(stdout);
+            const manifestPath = join(tempDir, "cli-test", "*", "r1", "proof.json").replace("*", new Date().toISOString().slice(0, 10).replace(/-/g, ""));
+            const manifest = JSON.parse(await readFile(manifestPath, "utf-8"));
+            expect(manifest.entries[0].description).toBe("A test capture");
+        });
+    });
+    describe("JSON stdin mode", () => {
+        test("captures single entry via JSON", async () => {
+            const input = JSON.stringify({
+                action: "capture",
+                appName: "json-test",
+                proofDir: tempDir,
+                run: "j1",
+                command: "echo json-mode",
+                mode: "terminal",
+                label: "json-cap",
+            });
+            const { stdout, exitCode } = await runCli(["--json"], input);
+            expect(exitCode).toBe(0);
+            const result = JSON.parse(stdout);
+            expect(result.action).toBe("capture");
+            expect(result.recordings).toHaveLength(1);
+            expect(result.recordings[0].mode).toBe("terminal");
+            expect(result.recordings[0].label).toBe("json-cap");
+        });
+        test("captures multiple entries via JSON captures array", async () => {
+            const input = JSON.stringify({
+                action: "capture",
+                appName: "multi-test",
+                proofDir: tempDir,
+                run: "m1",
+                captures: [
+                    { command: "echo one", mode: "terminal", label: "first" },
+                    { command: "echo two", mode: "terminal", label: "second" },
+                ],
+            });
+            const { stdout, exitCode } = await runCli(["--json"], input);
+            expect(exitCode).toBe(0);
+            const result = JSON.parse(stdout);
+            expect(result.recordings).toHaveLength(2);
+            expect(result.recordings[0].label).toBe("first");
+            expect(result.recordings[1].label).toBe("second");
+        });
+        test("generates report via JSON", async () => {
+            // First capture something
+            const captureInput = JSON.stringify({
+                action: "capture",
+                appName: "report-test",
+                proofDir: tempDir,
+                run: "rpt",
+                command: "echo for-report",
+                mode: "terminal",
+            });
+            await runCli(["--json"], captureInput);
+            // Then generate report
+            const reportInput = JSON.stringify({
+                action: "report",
+                appName: "report-test",
+                proofDir: tempDir,
+                run: "rpt",
+            });
+            const { stdout, exitCode } = await runCli(["--json"], reportInput);
+            expect(exitCode).toBe(0);
+            const result = JSON.parse(stdout);
+            expect(result.action).toBe("report");
+            expect(result.path).toContain("report.md");
+            expect(existsSync(result.path)).toBe(true);
+        });
+    });
+    describe("report (arg mode)", () => {
+        test("generates report after capture", async () => {
+            // Capture first
+            await runCli([
+                "capture",
+                "--app", "rpt-test",
+                "--dir", tempDir,
+                "--run", "r1",
+                "--command", "echo hi",
+                "--mode", "terminal",
+            ]);
+            // Generate report
+            const { stdout, exitCode } = await runCli([
+                "report",
+                "--app", "rpt-test",
+                "--dir", tempDir,
+                "--run", "r1",
+            ]);
+            expect(exitCode).toBe(0);
+            const result = JSON.parse(stdout);
+            expect(result.action).toBe("report");
+            expect(result.path).toContain("report.md");
+            expect(existsSync(result.path)).toBe(true);
+        });
+    });
+    describe("error handling", () => {
+        test("outputs JSON error on failure", async () => {
+            const input = JSON.stringify({
+                action: "report",
+                appName: "nonexistent",
+                proofDir: tempDir,
+                run: "nope",
+            });
+            const { stderr, exitCode } = await runCli(["--json"], input);
+            expect(exitCode).toBe(1);
+            expect(JSON.parse(stderr).error).toContain("No proof.json found");
+        });
+    });
+});

package/dist/detect.d.ts

@@ -0,0 +1,2 @@
+import type { RecordingMode } from "./types";
+export declare function detectMode(projectDir: string): Promise<Exclude<RecordingMode, "auto">>;

package/dist/detect.js

@@ -0,0 +1,31 @@
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join } from "path";
+const BROWSER_CONFIG_PATTERNS = [
+    "playwright.config.ts",
+    "playwright.config.js",
+    "playwright.config.mjs",
+];
+export async function detectMode(projectDir) {
+    for (const config of BROWSER_CONFIG_PATTERNS) {
+        if (existsSync(join(projectDir, config))) {
+            return "browser";
+        }
+    }
+    const pkgPath = join(projectDir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+            const allDeps = {
+                ...pkg.dependencies,
+                ...pkg.devDependencies,
+                ...pkg.peerDependencies,
+            };
+            if (allDeps["@playwright/test"] || allDeps["playwright"]) {
+                return "browser";
+            }
+        }
+        catch { }
+    }
+    return "terminal";
+}

package/dist/detect.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/detect.test.js

@@ -0,0 +1,54 @@
+import { describe, test, expect } from "bun:test";
+import { detectMode } from "./detect";
+import { join } from "path";
+import { mkdtemp, writeFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+describe("detectMode", () => {
+    let tempDir;
+    async function makeTempDir() {
+        tempDir = await mkdtemp(join(tmpdir(), "proof-test-"));
+        return tempDir;
+    }
+    async function cleanup() {
+        if (tempDir)
+            await rm(tempDir, { recursive: true, force: true });
+    }
+    test("returns 'browser' when playwright.config.ts exists", async () => {
+        const dir = await makeTempDir();
+        await writeFile(join(dir, "playwright.config.ts"), "export default {};");
+        expect(await detectMode(dir)).toBe("browser");
+        await cleanup();
+    });
+    test("returns 'browser' when playwright.config.js exists", async () => {
+        const dir = await makeTempDir();
+        await writeFile(join(dir, "playwright.config.js"), "module.exports = {};");
+        expect(await detectMode(dir)).toBe("browser");
+        await cleanup();
+    });
+    test("returns 'browser' when @playwright/test is in devDependencies", async () => {
+        const dir = await makeTempDir();
+        const pkg = { devDependencies: { "@playwright/test": "^1.50.0" } };
+        await writeFile(join(dir, "package.json"), JSON.stringify(pkg));
+        expect(await detectMode(dir)).toBe("browser");
+        await cleanup();
+    });
+    test("returns 'browser' when playwright is in dependencies", async () => {
+        const dir = await makeTempDir();
+        const pkg = { dependencies: { playwright: "^1.50.0" } };
+        await writeFile(join(dir, "package.json"), JSON.stringify(pkg));
+        expect(await detectMode(dir)).toBe("browser");
+        await cleanup();
+    });
+    test("returns 'terminal' when no playwright signals found", async () => {
+        const dir = await makeTempDir();
+        expect(await detectMode(dir)).toBe("terminal");
+        await cleanup();
+    });
+    test("returns 'terminal' when package.json has no playwright deps", async () => {
+        const dir = await makeTempDir();
+        const pkg = { dependencies: { express: "^4.0.0" } };
+        await writeFile(join(dir, "package.json"), JSON.stringify(pkg));
+        expect(await detectMode(dir)).toBe("terminal");
+        await cleanup();
+    });
+});

package/dist/duration.d.ts

@@ -0,0 +1 @@
+export declare function getVideoDuration(filePath: string): Promise<number>;

package/dist/duration.js

@@ -0,0 +1,23 @@
+import { spawn } from "child_process";
+export async function getVideoDuration(filePath) {
+    try {
+        const output = await new Promise((resolve, reject) => {
+            const proc = spawn("ffprobe", [
+                "-v", "quiet",
+                "-print_format", "json",
+                "-show_format",
+                filePath,
+            ], { stdio: ["ignore", "pipe", "pipe"] });
+            let stdout = "";
+            proc.stdout.on("data", (data) => { stdout += data.toString(); });
+            proc.on("close", (code) => code === 0 ? resolve(stdout) : reject(new Error("ffprobe failed")));
+            proc.on("error", reject);
+        });
+        const parsed = JSON.parse(output);
+        const seconds = parseFloat(parsed.format?.duration ?? "0");
+        return Math.round(seconds * 1000);
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import type { ProofConfig, Recording, CaptureOptions, RecordingMode, ProofManifest, ProofEntry, ReportFormat, ReportOptions } from "./types";
+export type { ProofConfig, Recording, CaptureOptions, RecordingMode, ProofManifest, ProofEntry, ReportFormat, ReportOptions, };
+export { getCursorHighlightScript } from "./modes/visual";
+export declare class Proof {
+    private config;
+    private runDir;
+    private runName;
+    private initTime;
+    constructor(config: ProofConfig);
+    private formatDate;
+    private formatTime;
+    private formatTimestamp;
+    private ensureRunDir;
+    private resolveMode;
+    private appendToManifest;
+    capture(options: CaptureOptions): Promise<Recording>;
+    report(options?: ReportOptions): Promise<string | string[]>;
+}