@intactfile/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/**
+ * IntactFile MCP server (stdio). Lets an AI agent repair corrupted files that
+ * stay on the user's machine — the engines run in-process, nothing is uploaded.
+ *
+ * Discovery is free and safe by construction: `detect_file` and `diagnose_file`
+ * are LOCAL and read-only (no network, no upload), so there is no server-side
+ * abuse surface and no rate limit is needed here. The `repair_file` tool is
+ * gated on an active Business subscription and fails closed when it can't be
+ * verified. The license token is read from the config the CLI writes
+ * (~/.config/intactfile/config.json); it is never printed or logged.
+ *
+ * NOTE: stdout is the JSON-RPC channel — never write to it directly.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, parse } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { ApiError, balance, consume, diagnosePath, EntitlementError, getToken, repairPath, requireBusiness, setToken, UnsupportedError, } from "@intactfile/node-core";
+const text = (t) => ({ content: [{ type: "text", text: t }] });
+const errText = (t) => ({ content: [{ type: "text", text: t }], isError: true });
+const OUT_EXT = {
+    zip: ".zip",
+    pdf: ".pdf",
+    video: ".mp4",
+    jpeg: ".jpg",
+    png: ".png",
+    sqlite: ".sqlite",
+    archive: "",
+};
+function writeOut(input, out, r) {
+    if (r.kind === "archive") {
+        const dir = out ?? join(parse(input).dir, `${parse(input).name}.recovered`);
+        mkdirSync(dir, { recursive: true });
+        const written = [];
+        for (const f of r.files) {
+            if (f.status !== "ok")
+                continue;
+            const dest = join(dir, basename(f.name.replace(/[/\\]+/g, "_")) || "file");
+            mkdirSync(dirname(dest), { recursive: true });
+            writeFileSync(dest, f.data);
+            written.push(dest);
+        }
+        return written;
+    }
+    const p = parse(input);
+    const dest = out ?? join(p.dir, `${p.name}.repaired${p.ext || OUT_EXT[r.family]}`);
+    writeFileSync(dest, r.bytes);
+    return [dest];
+}
+async function meter() {
+    const token = getToken();
+    if (!token)
+        return;
+    try {
+        const res = await consume(token);
+        if (res.token)
+            setToken(res.token);
+    }
+    catch {
+        /* best effort — a delivered result is already the user's */
+    }
+}
+const server = new McpServer({ name: "intactfile", version: "0.1.0" });
+/* ------------------------------ free tools ----------------------------- */
+server.tool("detect_file", "Identify a file's format and whether IntactFile can repair it. Free, fully local — no upload, no sign-in.", { path: z.string().describe("Absolute path to the file on disk") }, async ({ path }) => {
+    try {
+        const d = await diagnosePath(path);
+        return text(`Format: ${d.format}${d.family !== "unknown" ? ` (${d.family})` : ""}\n` +
+            `Confidence: ${d.confidence}\n` +
+            `Repairable: ${d.family !== "unknown" ? "yes — use repair_file (Business plan)" : "no"}`);
+    }
+    catch (e) {
+        return errText(e instanceof Error ? e.message : String(e));
+    }
+});
+server.tool("diagnose_file", "Diagnose a possibly-corrupted file: format, confidence, and notes on what's wrong. Free, fully local — no upload, no sign-in.", { path: z.string().describe("Absolute path to the file on disk") }, async ({ path }) => {
+    try {
+        const d = await diagnosePath(path);
+        const lines = [
+            `File: ${basename(path)}`,
+            `Format: ${d.format}${d.family !== "unknown" ? ` (${d.family})` : ""}`,
+            `Confidence: ${d.confidence}`,
+            d.family !== "unknown"
+                ? "Verdict: repairable format — use repair_file (Business plan)."
+                : "Verdict: not a format IntactFile can repair.",
+            ...d.notes.slice(0, 6).map((n) => `- ${n}`),
+        ];
+        return text(lines.join("\n"));
+    }
+    catch (e) {
+        return errText(e instanceof Error ? e.message : String(e));
+    }
+});
+server.tool("account_status", "Show the signed-in IntactFile plan and remaining monthly repairs.", {}, async () => {
+    const token = getToken();
+    if (!token)
+        return text("Not signed in. Run `intactfile login` in a terminal.");
+    try {
+        const res = await balance(token);
+        if (res.token)
+            setToken(res.token);
+        const s = res.subscription;
+        return text(s
+            ? `Plan: ${s.tier} · ${s.monthlyRemaining} repairs left this month · active until ${s.activeUntil.slice(0, 10)}`
+            : "No active subscription on this account.");
+    }
+    catch (e) {
+        return errText(e instanceof Error ? e.message : String(e));
+    }
+});
+/* --------------------------- business tool ---------------------------- */
+server.tool("repair_file", "Repair a corrupted file locally and write the fixed file to disk. Requires an active IntactFile Business subscription (run `intactfile login` first). Files never leave this machine.", {
+    path: z.string().describe("Absolute path to the corrupted file"),
+    out: z.string().optional().describe("Output path (or directory for archives)"),
+    reference: z
+        .string()
+        .optional()
+        .describe("Healthy reference clip/photo (missing-moov video, JPEG donor)"),
+    password: z.string().optional().describe("Archive password (RAR/7z)"),
+}, async ({ path, out, reference, password }) => {
+    try {
+        const sub = await requireBusiness();
+        if (sub.monthlyRemaining <= 0) {
+            return errText("Monthly repair allowance exhausted — it resets on your billing cycle.");
+        }
+        const r = await repairPath(path, { referencePath: reference, password });
+        if (!r.usable) {
+            return errText(`Couldn't produce a usable result (outcome: ${String(r.report.outcome ?? "failed")}). Nothing was charged.`);
+        }
+        const written = writeOut(path, out, r);
+        await meter();
+        return text(`Repaired (${r.family}, outcome ${String(r.report.outcome ?? "ok")}). Wrote:\n${written
+            .map((w) => `- ${w}`)
+            .join("\n")}`);
+    }
+    catch (e) {
+        if (e instanceof EntitlementError || e instanceof UnsupportedError || e instanceof ApiError) {
+            return errText(e.message);
+        }
+        return errText(e instanceof Error ? e.message : String(e));
+    }
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@intactfile/mcp",
+  "version": "0.1.0",
+  "description": "IntactFile MCP server — repair corrupted files from your AI agent, locally. Discovery + diagnosis are free; repair requires an active Business subscription. Files never leave your machine.",
+  "type": "module",
+  "license": "UNLICENSED",
+  "bin": {
+    "intactfile-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.8",
+    "@intactfile/node-core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}