@filmwhisper/mcp-server 0.1.0

package/dist/__tests__/tools/integration.test.js

@@ -0,0 +1,707 @@
+/**
+ * Integration test: Full E2E workflow across all 18 MCP tools.
+ * Uses InMemoryTransport — no subprocess needed.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { createServer } from "../../server.js";
+import { ProjectStore, atomicWrite } from "../../storage/project-store.js";
+import { SqliteStore } from "../../storage/sqlite-store.js";
+function parseResult(result) {
+    const content = result.content;
+    return JSON.parse(content[0].text);
+}
+async function createTestEnv() {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "fw-integ-"));
+    // Create a fake media file for scanning
+    const mediaFile = path.join(tmpDir, "clip01.mp4");
+    await fs.writeFile(mediaFile, "fake-video-content-for-hashing");
+    const mediaFile2 = path.join(tmpDir, "clip02.mov");
+    await fs.writeFile(mediaFile2, "second-fake-video-content");
+    const deps = {
+        projectStore: new ProjectStore(),
+        projects: new Map(),
+    };
+    const server = createServer(deps);
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await server.connect(serverTransport);
+    const client = new Client({ name: "test-client", version: "1.0.0" });
+    await client.connect(clientTransport);
+    return { tmpDir, client, server, deps };
+}
+describe("All 25 tools listed", () => {
+    let tmpDir;
+    let client;
+    let server;
+    beforeEach(async () => {
+        ({ tmpDir, client, server } = await createTestEnv());
+    });
+    afterEach(async () => {
+        await client.close();
+        await server.close();
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it("should list all 29 tools including fw_auto_assemble and export tools", async () => {
+        const { tools } = await client.listTools();
+        const names = tools.map((t) => t.name).sort();
+        const expected = [
+            "fw_asset_remove",
+            "fw_auto_assemble",
+            "fw_export",
+            "fw_get_asset",
+            "fw_get_frames",
+            "fw_get_timeline",
+            "fw_get_transcript",
+            "fw_get_waveform",
+            "fw_job_cancel",
+            "fw_job_status",
+            "fw_list_assets",
+            "fw_process",
+            "fw_project_delete",
+            "fw_project_init",
+            "fw_project_relink",
+            "fw_project_rescan",
+            "fw_project_status",
+            "fw_redo",
+            "fw_render_preview",
+            "fw_review_set",
+            "fw_search",
+            "fw_set_analysis",
+            "fw_timeline_add",
+            "fw_timeline_batch",
+            "fw_timeline_clear",
+            "fw_timeline_remove",
+            "fw_timeline_reorder",
+            "fw_timeline_trim",
+            "fw_undo",
+        ];
+        expect(names).toEqual(expected);
+    });
+});
+describe("E2E workflow: init → inspect → edit → undo → redo → delete", () => {
+    let tmpDir;
+    let client;
+    let server;
+    let deps;
+    beforeEach(async () => {
+        ({ tmpDir, client, server, deps } = await createTestEnv());
+    });
+    afterEach(async () => {
+        // Close any remaining sqlite stores
+        for (const ctx of deps.projects.values()) {
+            try {
+                ctx.sqliteStore.close();
+            }
+            catch { /* cleanup */ }
+        }
+        await client.close();
+        await server.close();
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it("full workflow with all tool categories", async () => {
+        // === 1. PROJECT INIT ===
+        const initResult = await client.callTool({
+            name: "fw_project_init",
+            arguments: { name: "Test Project", source_path: tmpDir },
+        });
+        expect(initResult.isError).toBeFalsy();
+        const initData = parseResult(initResult);
+        expect(initData.project_id).toBeTruthy();
+        expect(initData.assets_discovered).toBe(2);
+        const projectId = initData.project_id;
+        // === 2. PROJECT STATUS ===
+        const statusResult = await client.callTool({
+            name: "fw_project_status",
+            arguments: { project_id: projectId },
+        });
+        expect(statusResult.isError).toBeFalsy();
+        const status = parseResult(statusResult);
+        expect(status.assets.total).toBe(2);
+        expect(status.engine_status).toBe("stopped");
+        // === 3. LIST ASSETS ===
+        const listResult = await client.callTool({
+            name: "fw_list_assets",
+            arguments: { project_id: projectId },
+        });
+        expect(listResult.isError).toBeFalsy();
+        const listData = parseResult(listResult);
+        expect(listData.assets).toHaveLength(2);
+        const assetHash = listData.assets[0].asset_hash;
+        // === 4. GET ASSET ===
+        const getAssetResult = await client.callTool({
+            name: "fw_get_asset",
+            arguments: { project_id: projectId, asset_id: assetHash },
+        });
+        expect(getAssetResult.isError).toBeFalsy();
+        const assetData = parseResult(getAssetResult);
+        expect(assetData.asset_hash).toBe(assetHash);
+        expect(assetData.transcode_status).toBe("pending");
+        // === 5. GET TRANSCRIPT (no transcript yet) ===
+        const transcriptResult = await client.callTool({
+            name: "fw_get_transcript",
+            arguments: { project_id: projectId, asset_id: assetHash },
+        });
+        expect(transcriptResult.isError).toBe(true);
+        // === 6. TIMELINE ADD ===
+        const addResult = await client.callTool({
+            name: "fw_timeline_add",
+            arguments: {
+                project_id: projectId,
+                asset_hash: assetHash,
+                in_point_ms: 0,
+                out_point_ms: 5000,
+            },
+        });
+        expect(addResult.isError).toBeFalsy();
+        const addData = parseResult(addResult);
+        expect(addData.clip.asset_hash).toBe(assetHash);
+        expect(addData.revision).toBe(1);
+        const clipId = addData.clip.id;
+        // Add a second clip
+        const assetHash2 = listData.assets[1].asset_hash;
+        const add2Result = await client.callTool({
+            name: "fw_timeline_add",
+            arguments: {
+                project_id: projectId,
+                asset_hash: assetHash2,
+                in_point_ms: 1000,
+                out_point_ms: 3000,
+            },
+        });
+        expect(add2Result.isError).toBeFalsy();
+        const add2Data = parseResult(add2Result);
+        const clipId2 = add2Data.clip.id;
+        expect(add2Data.revision).toBe(2);
+        // === 7. GET TIMELINE ===
+        const timelineResult = await client.callTool({
+            name: "fw_get_timeline",
+            arguments: { project_id: projectId },
+        });
+        expect(timelineResult.isError).toBeFalsy();
+        const timeline = parseResult(timelineResult);
+        expect(timeline.clips).toHaveLength(2);
+        expect(timeline.total_duration_ms).toBe(7000);
+        expect(timeline.revision).toBe(2);
+        // === 8. TIMELINE TRIM ===
+        const trimResult = await client.callTool({
+            name: "fw_timeline_trim",
+            arguments: {
+                project_id: projectId,
+                clip_id: clipId,
+                in_point_ms: 500,
+                out_point_ms: 4000,
+                expected_revision: 2,
+            },
+        });
+        expect(trimResult.isError).toBeFalsy();
+        const trimData = parseResult(trimResult);
+        expect(trimData.clip.in_point_ms).toBe(500);
+        expect(trimData.clip.out_point_ms).toBe(4000);
+        expect(trimData.revision).toBe(3);
+        // === 9. TIMELINE REORDER ===
+        const reorderResult = await client.callTool({
+            name: "fw_timeline_reorder",
+            arguments: {
+                project_id: projectId,
+                clip_id: clipId2,
+                new_position: 0,
+                expected_revision: 3,
+            },
+        });
+        expect(reorderResult.isError).toBeFalsy();
+        const reorderData = parseResult(reorderResult);
+        expect(reorderData.clips[0].id).toBe(clipId2);
+        expect(reorderData.revision).toBe(4);
+        // === 10. REVIEW SET ===
+        const reviewResult = await client.callTool({
+            name: "fw_review_set",
+            arguments: {
+                project_id: projectId,
+                asset_hash: assetHash,
+                segment_index: 0,
+                status: "keep",
+                reviewer: "ai",
+            },
+        });
+        expect(reviewResult.isError).toBeFalsy();
+        const reviewData = parseResult(reviewResult);
+        expect(reviewData.review.status).toBe("keep");
+        // === 11. UNDO ===
+        const undoResult = await client.callTool({
+            name: "fw_undo",
+            arguments: { project_id: projectId },
+        });
+        expect(undoResult.isError).toBeFalsy();
+        const undoData = parseResult(undoResult);
+        expect(undoData.undone_operations.length).toBeGreaterThan(0);
+        // === 12. REDO ===
+        const redoResult = await client.callTool({
+            name: "fw_redo",
+            arguments: { project_id: projectId },
+        });
+        expect(redoResult.isError).toBeFalsy();
+        const redoData = parseResult(redoResult);
+        expect(redoData.redone_operations.length).toBeGreaterThan(0);
+        // === 13. TIMELINE BATCH ===
+        const currentTimeline = parseResult(await client.callTool({
+            name: "fw_get_timeline",
+            arguments: { project_id: projectId },
+        }));
+        const batchResult = await client.callTool({
+            name: "fw_timeline_batch",
+            arguments: {
+                project_id: projectId,
+                operations: [
+                    { type: "add", asset_hash: assetHash, in_point_ms: 6000, out_point_ms: 8000 },
+                    { type: "trim", clip_id: clipId, in_point_ms: 0, out_point_ms: 3000 },
+                ],
+                expected_revision: currentTimeline.revision,
+            },
+        });
+        expect(batchResult.isError).toBeFalsy();
+        const batchData = parseResult(batchResult);
+        expect(batchData.results).toHaveLength(2);
+        expect(batchData.results.every((r) => r.success)).toBe(true);
+        // === 14. TIMELINE REMOVE ===
+        const tl = parseResult(await client.callTool({
+            name: "fw_get_timeline",
+            arguments: { project_id: projectId },
+        }));
+        const lastClip = tl.clips[tl.clips.length - 1];
+        const removeResult = await client.callTool({
+            name: "fw_timeline_remove",
+            arguments: {
+                project_id: projectId,
+                clip_id: lastClip.id,
+                expected_revision: tl.revision,
+            },
+        });
+        expect(removeResult.isError).toBeFalsy();
+        expect(parseResult(removeResult).removed).toBe(true);
+        // === 15. TIMELINE CLEAR ===
+        const clearResult = await client.callTool({
+            name: "fw_timeline_clear",
+            arguments: { project_id: projectId },
+        });
+        expect(clearResult.isError).toBeFalsy();
+        expect(parseResult(clearResult).clips_removed).toBeGreaterThanOrEqual(1);
+        // === 16. PROJECT RESCAN ===
+        // Add a new file to source
+        await fs.writeFile(path.join(tmpDir, "new-clip.mp4"), "new-content");
+        const rescanResult = await client.callTool({
+            name: "fw_project_rescan",
+            arguments: { project_id: projectId },
+        });
+        expect(rescanResult.isError).toBeFalsy();
+        const rescan = parseResult(rescanResult);
+        expect(rescan.assets_new).toBe(1);
+        // === 17. ASSET REMOVE ===
+        const allAssets = parseResult(await client.callTool({
+            name: "fw_list_assets",
+            arguments: { project_id: projectId },
+        }));
+        const removeAssetResult = await client.callTool({
+            name: "fw_asset_remove",
+            arguments: {
+                project_id: projectId,
+                asset_ids: [allAssets.assets[0].asset_hash],
+            },
+        });
+        expect(removeAssetResult.isError).toBeFalsy();
+        expect(parseResult(removeAssetResult).removed_count).toBe(1);
+        // === 18. PROJECT DELETE ===
+        const deleteResult = await client.callTool({
+            name: "fw_project_delete",
+            arguments: { project_id: projectId, confirm: true },
+        });
+        expect(deleteResult.isError).toBeFalsy();
+        expect(parseResult(deleteResult).deleted_assets_count).toBeGreaterThanOrEqual(0);
+    });
+});
+describe("Error handling", () => {
+    let tmpDir;
+    let client;
+    let server;
+    beforeEach(async () => {
+        ({ tmpDir, client, server } = await createTestEnv());
+    });
+    afterEach(async () => {
+        await client.close();
+        await server.close();
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it("returns project_not_found for unknown project", async () => {
+        const result = await client.callTool({
+            name: "fw_list_assets",
+            arguments: { project_id: "proj_nonexistent" },
+        });
+        expect(result.isError).toBe(true);
+        const data = parseResult(result);
+        expect(data.error.code).toBe("project_not_found");
+    });
+    it("returns asset_not_found for unknown asset", async () => {
+        // First create a project
+        const init = await client.callTool({
+            name: "fw_project_init",
+            arguments: { name: "Test", source_path: tmpDir },
+        });
+        const projectId = parseResult(init).project_id;
+        const result = await client.callTool({
+            name: "fw_get_asset",
+            arguments: { project_id: projectId, asset_id: "nonexistent_hash" },
+        });
+        expect(result.isError).toBe(true);
+        const data = parseResult(result);
+        expect(data.error.code).toBe("asset_not_found");
+    });
+    it("returns revision_conflict on stale revision", async () => {
+        const init = await client.callTool({
+            name: "fw_project_init",
+            arguments: { name: "Test", source_path: tmpDir },
+        });
+        const projectId = parseResult(init).project_id;
+        const assets = parseResult(await client.callTool({
+            name: "fw_list_assets",
+            arguments: { project_id: projectId },
+        }));
+        const assetHash = assets.assets[0].asset_hash;
+        // Add a clip (revision becomes 1)
+        await client.callTool({
+            name: "fw_timeline_add",
+            arguments: {
+                project_id: projectId,
+                asset_hash: assetHash,
+                in_point_ms: 0,
+                out_point_ms: 5000,
+            },
+        });
+        // Try to add with stale revision (expected 0, actual is 1)
+        const result = await client.callTool({
+            name: "fw_timeline_add",
+            arguments: {
+                project_id: projectId,
+                asset_hash: assetHash,
+                in_point_ms: 1000,
+                out_point_ms: 2000,
+                expected_revision: 0,
+            },
+        });
+        expect(result.isError).toBe(true);
+        const data = parseResult(result);
+        expect(data.error.code).toBe("revision_conflict");
+    });
+});
+describe("fw_search — L0 in-memory search", () => {
+    let tmpDir;
+    let client;
+    let server;
+    let deps;
+    beforeEach(async () => {
+        ({ tmpDir, client, server, deps } = await createTestEnv());
+    });
+    afterEach(async () => {
+        for (const ctx of deps.projects.values()) {
+            try {
+                ctx.sqliteStore.close();
+            }
+            catch { /* cleanup */ }
+        }
+        await client.close();
+        await server.close();
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    async function initProjectWithSegments() {
+        const initResult = await client.callTool({
+            name: "fw_project_init",
+            arguments: { name: "Search Test", source_path: tmpDir },
+        });
+        const initData = parseResult(initResult);
+        const projectId = initData.project_id;
+        const ctx = deps.projects.get(projectId);
+        // Load assets to get their hashes
+        const listResult = await client.callTool({
+            name: "fw_list_assets",
+            arguments: { project_id: projectId },
+        });
+        const { assets } = parseResult(listResult);
+        // Inject segments into first asset's .fw.json
+        const assetHash = assets[0].asset_hash;
+        const assetFilePath = path.join(ctx.projectPath, ".fw", "assets", `${assetHash}.fw.json`);
+        const rawAsset = JSON.parse(await fs.readFile(assetFilePath, "utf-8"));
+        rawAsset.segments = [
+            {
+                segment_index: 0,
+                start_ms: 0,
+                end_ms: 5000,
+                editorial_role: "interview",
+                energy: 0.7,
+                story_value: 0.8,
+                summary: "The quick brown fox jumps over the lazy dog",
+            },
+            {
+                segment_index: 1,
+                start_ms: 5000,
+                end_ms: 10000,
+                editorial_role: "b-roll",
+                energy: 0.3,
+                story_value: 0.4,
+                summary: "Scenic mountain landscape with flowing river",
+            },
+        ];
+        await atomicWrite(assetFilePath, JSON.stringify(rawAsset, null, 2));
+        return { projectId, assetHash };
+    }
+    it("fw_search is listed in available tools", async () => {
+        const { tools } = await client.listTools();
+        const names = tools.map((t) => t.name);
+        expect(names).toContain("fw_search");
+    });
+    it("returns matching segments from project assets", async () => {
+        const { projectId, assetHash } = await initProjectWithSegments();
+        const result = await client.callTool({
+            name: "fw_search",
+            arguments: { project_id: projectId, query: "fox" },
+        });
+        expect(result.isError).toBeFalsy();
+        const data = parseResult(result);
+        expect(data.backend_used).toBe("memory");
+        expect(data.results).toHaveLength(1);
+        expect(data.results[0].asset_hash).toBe(assetHash);
+        expect(data.results[0].segment_index).toBe(0);
+        expect(data.results[0].snippet).toContain("fox");
+    });
+    it("returns empty array when no segments match", async () => {
+        const { projectId } = await initProjectWithSegments();
+        const result = await client.callTool({
+            name: "fw_search",
+            arguments: { project_id: projectId, query: "unicorn" },
+        });
+        expect(result.isError).toBeFalsy();
+        const data = parseResult(result);
+        expect(data.results).toHaveLength(0);
+        expect(data.backend_used).toBe("memory");
+    });
+    it("respects the limit parameter", async () => {
+        const { projectId } = await initProjectWithSegments();
+        // Inject a third segment also matching "mountain" into the second asset
+        const listResult2 = await client.callTool({
+            name: "fw_list_assets",
+            arguments: { project_id: projectId },
+        });
+        const assets2 = parseResult(listResult2).assets;
+        const assetHash2 = assets2[1].asset_hash;
+        const ctx = deps.projects.get(projectId);
+        const assetFilePath2 = path.join(ctx.projectPath, ".fw", "assets", `${assetHash2}.fw.json`);
+        const rawAsset2 = JSON.parse(await fs.readFile(assetFilePath2, "utf-8"));
+        rawAsset2.segments = [
+            { segment_index: 0, start_ms: 0, end_ms: 5000, editorial_role: "b-roll", energy: 0.4, story_value: 0.5, summary: "Scenic mountain peak at sunrise" },
+        ];
+        await atomicWrite(assetFilePath2, JSON.stringify(rawAsset2, null, 2));
+        // "mountain" matches segment 1 of asset 1 and segment 0 of asset 2 — 2 total, limit=1 → next_cursor
+        const result = await client.callTool({
+            name: "fw_search",
+            arguments: { project_id: projectId, query: "mountain", limit: 1 },
+        });
+        expect(result.isError).toBeFalsy();
+        const data = parseResult(result);
+        expect(data.results).toHaveLength(1);
+        expect(data.next_cursor).toBeDefined();
+    });
+    it("fw_process, fw_job_status, and fw_job_cancel are listed in available tools", async () => {
+        const { tools } = await client.listTools();
+        const names = tools.map((t) => t.name);
+        expect(names).toContain("fw_process");
+        expect(names).toContain("fw_job_status");
+        expect(names).toContain("fw_job_cancel");
+    });
+    it("falls through to L0 when threshold exceeded but no FTS5 data", async () => {
+        const originalThreshold = process.env.FW_SEARCH_THRESHOLD;
+        process.env.FW_SEARCH_THRESHOLD = "1"; // threshold=1, we have 2 assets
+        try {
+            const initResult = await client.callTool({
+                name: "fw_project_init",
+                arguments: { name: "Threshold Test", source_path: tmpDir },
+            });
+            const { project_id: projectId } = parseResult(initResult);
+            const result = await client.callTool({
+                name: "fw_search",
+                arguments: { project_id: projectId, query: "anything" },
+            });
+            // No FTS5 data populated, so falls through to L0 in-memory scan
+            expect(result.isError).toBeUndefined();
+            const data = parseResult(result);
+            expect(data.backend_used).toBe("memory");
+        }
+        finally {
+            if (originalThreshold === undefined) {
+                delete process.env.FW_SEARCH_THRESHOLD;
+            }
+            else {
+                process.env.FW_SEARCH_THRESHOLD = originalThreshold;
+            }
+        }
+    });
+});
+describe("Process tools — fw_process, fw_job_status, fw_job_cancel", () => {
+    let tmpDir;
+    let client;
+    let server;
+    let deps;
+    beforeEach(async () => {
+        ({ tmpDir, client, server, deps } = await createTestEnv());
+    });
+    afterEach(async () => {
+        for (const ctx of deps.projects.values()) {
+            try {
+                ctx.sqliteStore.close();
+            }
+            catch { /* cleanup */ }
+        }
+        await client.close();
+        await server.close();
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it("fw_process returns error when engineManager is not available", async () => {
+        const initResult = await client.callTool({
+            name: "fw_project_init",
+            arguments: { name: "Test", source_path: tmpDir },
+        });
+        const { project_id: projectId } = parseResult(initResult);
+        // deps.engineManager is undefined in test env
+        const result = await client.callTool({
+            name: "fw_process",
+            arguments: { project_id: projectId },
+        });
+        expect(result.isError).toBe(true);
+        const data = parseResult(result);
+        expect(data.error.code).toBe("invalid_input");
+    });
+    it("fw_process returns project_not_found for unknown project", async () => {
+        const result = await client.callTool({
+            name: "fw_process",
+            arguments: { project_id: "proj_nonexistent" },
+        });
+        expect(result.isError).toBe(true);
+        const data = parseResult(result);
+        expect(data.error.code).toBe("project_not_found");
+    });
+    it("fw_job_status returns error for unknown job_id", async () => {
+        const result = await client.callTool({
+            name: "fw_job_status",
+            arguments: { job_id: "job_nonexistent" },
+        });
+        expect(result.isError).toBe(true);
+        const data = parseResult(result);
+        expect(data.error.code).toBe("invalid_input");
+    });
+    it("fw_job_status requires job_id or project_id", async () => {
+        const result = await client.callTool({
+            name: "fw_job_status",
+            arguments: {},
+        });
+        expect(result.isError).toBe(true);
+        const data = parseResult(result);
+        expect(data.error.code).toBe("invalid_input");
+    });
+    it("fw_job_status lists jobs for a project", async () => {
+        const initResult = await client.callTool({
+            name: "fw_project_init",
+            arguments: { name: "Job List Test", source_path: tmpDir },
+        });
+        const { project_id: projectId } = parseResult(initResult);
+        const result = await client.callTool({
+            name: "fw_job_status",
+            arguments: { project_id: projectId },
+        });
+        expect(result.isError).toBeFalsy();
+        const data = parseResult(result);
+        expect(Array.isArray(data.jobs)).toBe(true);
+        expect(data.jobs).toHaveLength(0);
+    });
+    it("SqliteStore createJob and getJob work correctly", async () => {
+        const store = new SqliteStore(":memory:");
+        const jobId = store.createJob("proj_test", "transcode", { asset_hash: "abc123" });
+        expect(typeof jobId).toBe("string");
+        const job = store.getJob(jobId);
+        expect(job).not.toBeNull();
+        expect(job.job_id).toBe(jobId);
+        expect(job.project_id).toBe("proj_test");
+        expect(job.type).toBe("transcode");
+        expect(job.status).toBe("pending");
+        expect(job.progress).toBe(0);
+        expect(job.params).toEqual({ asset_hash: "abc123" });
+        store.close();
+    });
+    it("SqliteStore updateJobProgress sets status to running", async () => {
+        const store = new SqliteStore(":memory:");
+        const jobId = store.createJob("proj_test", "transcode", {});
+        store.updateJobProgress(jobId, 0.5, "encoding");
+        const job = store.getJob(jobId);
+        expect(job.status).toBe("running");
+        expect(job.progress).toBe(0.5);
+        expect(job.step).toBe("encoding");
+        store.close();
+    });
+    it("SqliteStore updateJobResult sets status to completed", async () => {
+        const store = new SqliteStore(":memory:");
+        const jobId = store.createJob("proj_test", "transcode", {});
+        store.updateJobResult(jobId, { proxy_path: "/tmp/proxy.mp4" });
+        const job = store.getJob(jobId);
+        expect(job.status).toBe("completed");
+        expect(job.progress).toBe(1);
+        expect(job.result).toEqual({ proxy_path: "/tmp/proxy.mp4" });
+        store.close();
+    });
+    it("SqliteStore updateJobError sets status to failed", async () => {
+        const store = new SqliteStore(":memory:");
+        const jobId = store.createJob("proj_test", "transcode", {});
+        store.updateJobError(jobId, "ffmpeg exited with code 1");
+        const job = store.getJob(jobId);
+        expect(job.status).toBe("failed");
+        expect(job.error).toBe("ffmpeg exited with code 1");
+        store.close();
+    });
+    it("SqliteStore cancelJob sets status to cancelled", async () => {
+        const store = new SqliteStore(":memory:");
+        const jobId = store.createJob("proj_test", "transcode", {});
+        store.cancelJob(jobId);
+        const job = store.getJob(jobId);
+        expect(job.status).toBe("cancelled");
+        store.close();
+    });
+    it("SqliteStore markCrashedJobs marks running jobs as failed", async () => {
+        const store = new SqliteStore(":memory:");
+        const jobId1 = store.createJob("proj_test", "transcode", {});
+        const jobId2 = store.createJob("proj_test", "transcribe", {});
+        const jobId3 = store.createJob("proj_test", "analyze", {});
+        // Mark first two as running
+        store.updateJobProgress(jobId1, 0.3);
+        store.updateJobProgress(jobId2, 0.6);
+        // Leave jobId3 as pending
+        store.markCrashedJobs();
+        const job1 = store.getJob(jobId1);
+        const job2 = store.getJob(jobId2);
+        const job3 = store.getJob(jobId3);
+        expect(job1.status).toBe("failed");
+        expect(job1.error).toBe("daemon_crashed");
+        expect(job2.status).toBe("failed");
+        expect(job2.error).toBe("daemon_crashed");
+        // Pending job should remain unchanged
+        expect(job3.status).toBe("pending");
+        store.close();
+    });
+    it("fw_job_cancel returns error for unknown job_id", async () => {
+        const result = await client.callTool({
+            name: "fw_job_cancel",
+            arguments: { job_id: "job_nonexistent" },
+        });
+        expect(result.isError).toBe(true);
+        const data = parseResult(result);
+        expect(data.error.code).toBe("invalid_input");
+    });
+});
+//# sourceMappingURL=integration.test.js.map