@intactfile/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+/**
+ * IntactFile CLI. Repairs run entirely on this machine — files never leave it.
+ * Diagnosis is free; repair/batch require an active Business subscription.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, parse } from "node:path";
+import { createInterface } from "node:readline";
+import { Command } from "commander";
+import { ApiError, balance, clearAuth, consume, EntitlementError, getToken, login as apiLogin, magic as apiMagic, recover as apiRecover, repairPath, diagnosePath, requireBusiness, setToken, UnsupportedError, } from "@intactfile/node-core";
+const program = new Command();
+program
+    .name("intactfile")
+    .description("Repair corrupted files locally — your files never leave your machine.")
+    .version("0.1.0");
+/* ------------------------------- helpers ------------------------------- */
+function ask(query) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => rl.question(query, (a) => (rl.close(), resolve(a.trim()))));
+}
+/** Password prompt with echo muted. */
+function askHidden(query) {
+    process.stdout.write(query);
+    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    rl._writeToOutput = () => { };
+    return new Promise((resolve) => rl.question("", (a) => {
+        rl.close();
+        process.stdout.write("\n");
+        resolve(a);
+    }));
+}
+const die = (msg) => {
+    console.error(`✗ ${msg}`);
+    process.exit(1);
+};
+/** Extension to give the repaired output, preferring the input's own. */
+const OUT_EXT = {
+    zip: ".zip",
+    pdf: ".pdf",
+    video: ".mp4",
+    jpeg: ".jpg",
+    png: ".png",
+    sqlite: ".sqlite",
+    archive: "",
+};
+function defaultOut(input, family) {
+    const p = parse(input);
+    const ext = p.ext || OUT_EXT[family];
+    return join(p.dir, `${p.name}.repaired${ext}`);
+}
+function printReport(family, report) {
+    const outcome = report.outcome ?? (family === "zip" ? "(see counts)" : "unknown");
+    console.log(`  format:   ${family}`);
+    console.log(`  outcome:  ${String(outcome)}`);
+    if (report.damageClass)
+        console.log(`  damage:   ${String(report.damageClass)}`);
+    if (report.bytesIn != null)
+        console.log(`  bytes in: ${Number(report.bytesIn).toLocaleString()}`);
+    if (report.bytesOut != null)
+        console.log(`  bytes out:${Number(report.bytesOut).toLocaleString()}`);
+    const notes = report.notes;
+    if (Array.isArray(notes) && notes.length) {
+        for (const n of notes.slice(0, 4))
+            console.log(`  · ${String(n)}`);
+    }
+}
+/** Write a repair result to disk; returns the paths written. */
+function writeResult(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 safe = basename(f.name.replace(/[/\\]+/g, "_")) || "file";
+            const dest = join(dir, safe);
+            mkdirSync(dirname(dest), { recursive: true });
+            writeFileSync(dest, f.data);
+            written.push(dest);
+        }
+        return written;
+    }
+    const dest = out ?? defaultOut(input, r.family);
+    writeFileSync(dest, r.bytes);
+    return [dest];
+}
+/* -------------------------------- login -------------------------------- */
+program
+    .command("login")
+    .description("Sign in (email + password). Use --link to get a one-time email link instead.")
+    .option("--link <email>", "email yourself a one-time sign-in link")
+    .option("--magic <token>", "complete sign-in with the token from that email link")
+    .action(async (opts) => {
+    try {
+        if (opts.magic) {
+            const res = await apiMagic(opts.magic.trim());
+            if (res.token)
+                setToken(res.token);
+            console.log("✓ Signed in.");
+            return summarize(res.subscription);
+        }
+        if (opts.link) {
+            const res = await apiRecover(opts.link.trim());
+            if (res.reason === "recovery-not-available") {
+                return die("Email sign-in isn't available right now — write to info@intactfile.com.");
+            }
+            console.log("✓ If that email has a purchase, a one-time link is on its way.\n" +
+                "  Open it, copy the token after `magic=`, then run:\n" +
+                "  intactfile login --magic <token>");
+            return;
+        }
+        const email = await ask("Email: ");
+        const password = await askHidden("Password: ");
+        const res = await apiLogin(email, password);
+        if (res.token)
+            setToken(res.token);
+        console.log("✓ Signed in.");
+        summarize(res.subscription);
+    }
+    catch (e) {
+        handle(e);
+    }
+});
+program
+    .command("logout")
+    .description("Forget the stored token on this machine.")
+    .action(() => {
+    clearAuth();
+    console.log("✓ Signed out.");
+});
+program
+    .command("status")
+    .description("Show the signed-in plan and remaining monthly repairs.")
+    .action(async () => {
+    const token = getToken();
+    if (!token)
+        return console.log("Not signed in. Run `intactfile login`.");
+    try {
+        const res = await balance(token);
+        if (res.token)
+            setToken(res.token);
+        console.log(`Credits balance: ${res.balance}`);
+        summarize(res.subscription);
+    }
+    catch (e) {
+        handle(e);
+    }
+});
+function summarize(sub) {
+    if (!sub)
+        return console.log("Plan: none (no active subscription).");
+    console.log(`Plan: ${sub.tier} · ${sub.monthlyRemaining} repairs left this month · active until ${sub.activeUntil.slice(0, 10)}`);
+}
+/* ------------------------------- diagnose ------------------------------ */
+program
+    .command("diagnose <file>")
+    .description("Inspect a file and report what's wrong. Free, fully local, no sign-in.")
+    .action(async (file) => {
+    try {
+        const d = await diagnosePath(file);
+        console.log(`File:       ${basename(file)}`);
+        console.log(`Format:     ${d.format}${d.family !== "unknown" ? ` (${d.family})` : ""}`);
+        console.log(`Confidence: ${d.confidence}`);
+        if (d.family === "unknown") {
+            console.log("Verdict:    Not a format IntactFile can repair.");
+        }
+        else {
+            console.log("Verdict:    Repairable format — run `intactfile repair` (Business plan).");
+        }
+        for (const n of d.notes.slice(0, 6))
+            console.log(`  · ${n}`);
+    }
+    catch (e) {
+        handle(e);
+    }
+});
+/* -------------------------------- repair ------------------------------- */
+program
+    .command("repair <file>")
+    .description("Repair a corrupted file locally (Business plan).")
+    .option("-o, --out <path>", "output path (or directory for archives)")
+    .option("-r, --reference <clip>", "healthy reference clip/photo (missing-moov video, JPEG donor)")
+    .option("-p, --password <pw>", "archive password (RAR/7z)")
+    .action(async (file, opts) => {
+    try {
+        const sub = await requireBusiness();
+        if (sub.monthlyRemaining <= 0) {
+            return die("Monthly repair allowance exhausted — it resets on your billing cycle.");
+        }
+        const r = await repairPath(file, { referencePath: opts.reference, password: opts.password });
+        printReport(r.family, r.report);
+        if (!r.usable) {
+            return die("Couldn't produce a usable result — nothing was charged.");
+        }
+        const written = writeResult(file, opts.out, r);
+        await meter();
+        console.log(`✓ Wrote:\n${written.map((w) => `  ${w}`).join("\n")}`);
+    }
+    catch (e) {
+        handle(e);
+    }
+});
+/* -------------------------------- batch -------------------------------- */
+program
+    .command("batch <files...>")
+    .description("Repair up to 100 files (Business plan). Each is metered separately.")
+    .option("-o, --outdir <dir>", "directory to write results into")
+    .action(async (files, opts) => {
+    try {
+        await requireBusiness();
+        if (files.length > 100)
+            return die(`Batch is capped at 100 files (got ${files.length}).`);
+        let ok = 0;
+        let failed = 0;
+        for (const file of files) {
+            try {
+                const sub = await requireBusiness();
+                if (sub.monthlyRemaining <= 0) {
+                    console.error("✗ Monthly allowance exhausted — stopping.");
+                    break;
+                }
+                const r = await repairPath(file);
+                if (!r.usable) {
+                    console.log(`- ${basename(file)}: no usable result (skipped)`);
+                    failed++;
+                    continue;
+                }
+                const out = opts.outdir
+                    ? join(opts.outdir, basename(defaultOut(file, r.family)))
+                    : undefined;
+                if (opts.outdir)
+                    mkdirSync(opts.outdir, { recursive: true });
+                const written = writeResult(file, out, r);
+                await meter();
+                console.log(`✓ ${basename(file)} → ${written[0] ?? "(extracted)"}`);
+                ok++;
+            }
+            catch (e) {
+                failed++;
+                console.log(`✗ ${basename(file)}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        console.log(`\nDone: ${ok} repaired, ${failed} skipped/failed.`);
+    }
+    catch (e) {
+        handle(e);
+    }
+});
+/** Best-effort meter against the ledger (never blocks a delivered result). */
+async function meter() {
+    const token = getToken();
+    if (!token)
+        return;
+    try {
+        const res = await consume(token);
+        if (res.token)
+            setToken(res.token);
+    }
+    catch {
+        /* offline/again-later: the file is already the user's; don't fail on metering */
+    }
+}
+function handle(e) {
+    if (e instanceof EntitlementError)
+        return die(e.message);
+    if (e instanceof UnsupportedError)
+        return die(e.message);
+    if (e instanceof ApiError)
+        return die(e.message);
+    return die(e instanceof Error ? e.message : String(e));
+}
+program.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@intactfile/cli",
+  "version": "0.1.0",
+  "description": "IntactFile CLI — repair corrupted files locally (video, ZIP/Office, PDF, JPEG, PNG, SQLite, RAR/7z). Your files never leave your machine. Business plan for repairs; diagnosis is free.",
+  "type": "module",
+  "license": "UNLICENSED",
+  "bin": {
+    "intactfile": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "@intactfile/node-core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}