@interlok/cli 0.0.0-stage → 1.3.0

package/dist/proxy.js

@@ -0,0 +1,361 @@
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { createInterface } from "node:readline";
+export const isToolCall = (m) => m?.method === "tools/call" && m.id !== undefined;
+/** A tools/call answer the model can read: MCP reports a refused call as a result with isError. */
+export function refusal(id, text) {
+    return { jsonrpc: "2.0", id, result: { isError: true, content: [{ type: "text", text }] } };
+}
+function client(cfg) {
+    const f = cfg.fetch ?? fetch;
+    return async (path, init = {}) => {
+        const r = await f(`${cfg.api}${path}`, {
+            ...init,
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${cfg.key}`,
+                "x-interlok-agent": cfg.agent,
+            },
+            signal: AbortSignal.timeout(30_000),
+        });
+        const text = await r.text();
+        let body = text;
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            /* keep text */
+        }
+        if (!r.ok)
+            throw Object.assign(new Error(`Interlok ${r.status}: ${body?.error ?? text}`), {
+                status: r.status,
+            });
+        return body;
+    };
+}
+/** MCP `_meta` key an agent may use to say what it is trying to do (intent, alternatives, confidence). */
+export const DECISION_META_KEY = "interlok/decision";
+/**
+ * Take the agent's decision record off the call. It is for Interlok, so it never reaches the MCP
+ * server: the key is deleted from the message in place, before the message can be forwarded.
+ */
+export function takeDecisionRecord(msg) {
+    const meta = msg.params?._meta;
+    if (!meta || typeof meta !== "object" || !(DECISION_META_KEY in meta))
+        return undefined;
+    const record = meta[DECISION_META_KEY];
+    delete meta[DECISION_META_KEY];
+    if (!Object.keys(meta).length)
+        delete msg.params._meta;
+    return record && typeof record === "object" && !Array.isArray(record) ? record : undefined;
+}
+/** One line for the model: why, and what to do next. */
+export function guidanceText(g) {
+    if (!g || typeof g !== "object")
+        return "";
+    const next = {
+        with_changes: "Change the call to address this before trying again.",
+        later: "Try again later.",
+        do_not_retry: "Do not retry this call.",
+        after_determination: "Wait for a person to decide.",
+        ask_a_person: "Ask a person before trying again.",
+    };
+    const parts = [g.alternative ? `Suggested instead: ${g.alternative}.` : "", next[g.retry] ?? ""];
+    return parts.filter(Boolean).join(" ");
+}
+/** Decide one tools/call. Shadow never blocks; Gate forwards only on allow or a human release. */
+export function decider(cfg) {
+    const call = client(cfg);
+    const log = cfg.log ?? ((l) => process.stderr.write(`[interlok] ${l}\n`));
+    const sleep = cfg.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    return async (msg) => {
+        const tool = String(msg.params?.name ?? "");
+        const args = (msg.params?.arguments ?? {});
+        const decision_record = takeDecisionRecord(msg);
+        if (cfg.shadowRun) {
+            try {
+                await call(`/api/v1/shadow/runs/${encodeURIComponent(cfg.shadowRun)}/events`, {
+                    method: "POST",
+                    body: JSON.stringify({ tool, args, connection_name: cfg.connection }),
+                });
+            }
+            catch (e) {
+                log(`shadow: could not record ${tool}: ${e.message}`);
+            }
+            return { forward: true };
+        }
+        let v;
+        try {
+            v = await call("/api/v1/gate", {
+                method: "POST",
+                body: JSON.stringify({
+                    agent: { name: cfg.agent },
+                    connection: { name: cfg.connection, kind: "mcp" },
+                    tool,
+                    args,
+                    chokepoint: "mcp_tool",
+                    environment: cfg.environment,
+                    request_id: msg.id === undefined || msg.id === null ? undefined : `${cfg.connection}:${msg.id}`,
+                    wait_ms: Math.min(cfg.waitSeconds, 25) * 1000,
+                    ...(decision_record ? { decision_record } : {}),
+                }),
+            });
+        }
+        catch (e) {
+            log(`gate unreachable for ${tool}: ${e.message}`);
+            return cfg.failOpen
+                ? { forward: true }
+                : {
+                    forward: false,
+                    message: `Interlok could not be reached, so ${tool} was not run (fail closed).`,
+                };
+        }
+        if (v.effect === "allow" || v.status === "released")
+            return { forward: true };
+        if (v.effect === "deny" || !v.hold) {
+            log(`denied ${tool}: ${v.reason}`);
+            return {
+                forward: false,
+                message: `Interlok denied ${tool}: ${v.reason || "policy"}${v.rule_id ? ` (rule ${v.rule_id})` : ""}. ${guidanceText(v.guidance) || "Do not retry this call."}`,
+            };
+        }
+        // Held: wait for a person, up to waitSeconds in total (the first 25 s were spent in the gate call).
+        log(`held ${tool} as ${v.hold.tag_number}: waiting for a person`);
+        const deadline = Date.now() + Math.max(0, cfg.waitSeconds - 25) * 1000;
+        while (Date.now() < deadline) {
+            await sleep(Math.min(5000, Math.max(0, deadline - Date.now())));
+            try {
+                const h = await call(`/api/v1/holds/${encodeURIComponent(v.hold.id)}`);
+                if (h.state === "released")
+                    return { forward: true };
+                if (h.state && h.state !== "open")
+                    return {
+                        forward: false,
+                        message: `${tool} was ${h.state} (${v.hold.tag_number}). Do not retry without asking a person.`,
+                    };
+            }
+            catch (e) {
+                log(`hold ${v.hold.tag_number}: ${e.message}`);
+            }
+        }
+        return {
+            forward: false,
+            message: `${tool} is held for a person to decide (${v.hold.tag_number}, ${v.reason}). It was not run. Tell the user and retry after it is released.`,
+        };
+    };
+}
+/** Register the server's tools once its tools/list answer comes back: pins descriptions for drift. */
+export async function registerTools(cfg, tools, transport, url) {
+    if (cfg.shadowRun || !Array.isArray(tools) || !tools.length)
+        return;
+    try {
+        await client(cfg)("/api/v1/connections", {
+            method: "POST",
+            body: JSON.stringify({
+                name: cfg.connection,
+                kind: "mcp",
+                transport,
+                url,
+                tools: tools.slice(0, 500).map((t) => ({
+                    name: String(t.name),
+                    description: t.description,
+                    input_schema: t.inputSchema,
+                    annotations: t.annotations,
+                })),
+            }),
+        });
+    }
+    catch (e) {
+        (cfg.log ?? ((l) => process.stderr.write(`[interlok] ${l}\n`)))(`could not register tools: ${e.message}`);
+    }
+}
+/**
+ * The message pump shared by both transports. `toServer` / `toClient` write one message each way.
+ * Tool calls are decided concurrently so a held call never blocks pings, cancellations or other calls.
+ */
+export function interceptor(cfg, toServer, toClient, transport) {
+    const decide = decider(cfg);
+    const listIds = new Set();
+    return {
+        fromClient(m) {
+            if (m?.method === "tools/list" && m.id !== undefined)
+                listIds.add(String(m.id));
+            if (!isToolCall(m))
+                return toServer(m);
+            void decide(m).then((d) => (d.forward ? toServer(m) : toClient(refusal(m.id, d.message ?? "refused"))), () => toClient(refusal(m.id, "Interlok could not decide this call; it was not run.")));
+        },
+        fromServer(m) {
+            if (m?.id !== undefined && listIds.delete(String(m.id)) && m.result?.tools)
+                void registerTools(cfg, m.result.tools, transport);
+            toClient(m);
+        },
+    };
+}
+/* ------------------------------ stdio ------------------------------ */
+export async function proxyStdio(cfg, command, args) {
+    // The server gets the caller's environment minus Interlok's own credentials.
+    const env = { ...process.env };
+    for (const k of ["INTERLOK_API_KEY", "INTERLOK_SHADOW_RUN"])
+        delete env[k];
+    const child = spawn(command, args, { stdio: ["pipe", "pipe", "inherit"], env });
+    const send = (stream) => (m) => stream.write(JSON.stringify(m) + "\n");
+    const io = interceptor(cfg, send(child.stdin), send(process.stdout), "stdio");
+    const pump = (input, onMsg, raw) => createInterface({ input, crlfDelay: Infinity }).on("line", (line) => {
+        if (!line.trim())
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return raw(line); // not ours to judge; pass it on
+        }
+        for (const m of Array.isArray(parsed) ? parsed : [parsed])
+            onMsg(m);
+    });
+    pump(process.stdin, io.fromClient, (l) => child.stdin.write(l + "\n"));
+    pump(child.stdout, io.fromServer, (l) => process.stdout.write(l + "\n"));
+    process.stdin.on("end", () => child.stdin.end());
+    return new Promise((resolve, reject) => {
+        child.on("error", reject);
+        child.on("exit", (c) => resolve(c ?? 1));
+    });
+}
+/* --------------------------- streamable HTTP --------------------------- */
+const HOP = new Set([
+    "host",
+    "connection",
+    "content-length",
+    "transfer-encoding",
+    "keep-alive",
+    "upgrade",
+]);
+function readBody(req, limit = 8 * 1024 * 1024) {
+    return new Promise((resolve, reject) => {
+        let n = 0;
+        const chunks = [];
+        req.on("data", (c) => {
+            n += c.length;
+            if (n > limit) {
+                reject(new Error("request too large"));
+                req.destroy();
+            }
+            else
+                chunks.push(c);
+        });
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        req.on("error", reject);
+    });
+}
+/** Streamable HTTP: the client talks to http://127.0.0.1:<port>/mcp; the proxy talks to --upstream. */
+export function proxyHttp(cfg, upstream, port, host = "127.0.0.1") {
+    const f = cfg.fetch ?? fetch;
+    const decide = decider(cfg);
+    async function forward(req, res, body) {
+        const headers = {};
+        for (const [k, v] of Object.entries(req.headers))
+            if (!HOP.has(k) && typeof v === "string" && !k.startsWith("x-interlok"))
+                headers[k] = v;
+        const up = await f(upstream, { method: req.method, headers, body: body || undefined });
+        const out = {};
+        up.headers.forEach((v, k) => {
+            if (!HOP.has(k) && k !== "content-encoding")
+                out[k] = v;
+        });
+        const isList = body?.includes('"tools/list"');
+        if (isList && up.headers.get("content-type")?.includes("application/json")) {
+            const text = await up.text();
+            try {
+                const j = JSON.parse(text);
+                if (j?.result?.tools)
+                    void registerTools(cfg, j.result.tools, "streamable-http", upstream);
+            }
+            catch {
+                /* pass through as-is */
+            }
+            res.writeHead(up.status, out).end(text);
+            return;
+        }
+        res.writeHead(up.status, out);
+        if (!up.body)
+            return res.end();
+        const reader = up.body.getReader();
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            res.write(Buffer.from(value));
+        }
+        res.end();
+    }
+    const server = createServer(async (req, res) => {
+        try {
+            if (req.method !== "POST")
+                return await forward(req, res);
+            const body = await readBody(req);
+            let msg;
+            try {
+                msg = JSON.parse(body);
+            }
+            catch {
+                return await forward(req, res, body);
+            }
+            const calls = (Array.isArray(msg) ? msg : [msg]).filter(isToolCall);
+            if (calls.length > 1) {
+                res.writeHead(400, { "content-type": "application/json" });
+                return res.end(JSON.stringify({ error: "batched tool calls are not supported through Interlok" }));
+            }
+            if (calls.length === 1) {
+                const d = await decide(calls[0]);
+                if (!d.forward) {
+                    res.writeHead(200, { "content-type": "application/json" });
+                    return res.end(JSON.stringify(refusal(calls[0].id, d.message ?? "refused")));
+                }
+            }
+            await forward(req, res, body);
+        }
+        catch (e) {
+            if (!res.headersSent)
+                res.writeHead(502, { "content-type": "application/json" });
+            res.end(JSON.stringify({ error: `proxy: ${e.message}` }));
+        }
+    });
+    return new Promise((resolve) => server.listen(port, host, () => resolve(server)));
+}
+/* ------------------------------ command ------------------------------ */
+export async function proxyCommand(args, value, has) {
+    const api = (process.env.INTERLOK_URL ??
+        process.env.INTERLOK_API_URL ??
+        value("--url") ??
+        "https://interlok.io").replace(/\/$/, "");
+    const key = process.env.INTERLOK_API_KEY ?? value("--api-key") ?? "";
+    if (!key)
+        throw new Error("INTERLOK_API_KEY is required (Console → Settings → API keys)");
+    const sep = args.indexOf("--");
+    const child = sep >= 0 ? args.slice(sep + 1) : [];
+    const upstream = value("--upstream");
+    if (!child.length && !upstream)
+        throw new Error("usage: interlok proxy --name <server> -- <command…>  |  --upstream <url> [--port 8787] [--host 127.0.0.1]");
+    const env = value("--env");
+    const cfg = {
+        api,
+        key,
+        agent: value("--agent") ?? process.env.INTERLOK_AGENT ?? "mcp-agent",
+        connection: value("--name") ?? (upstream ? new URL(upstream).host : child[child.length - 1]),
+        shadowRun: value("--shadow") ?? process.env.INTERLOK_SHADOW_RUN,
+        environment: env === "staging" || env === "dev" || env === "production" ? env : undefined,
+        waitSeconds: Number(value("--wait") ?? 300),
+        failOpen: has("--fail-open"),
+    };
+    process.stderr.write(`[interlok] ${cfg.shadowRun ? `shadow run ${cfg.shadowRun}: recording, never blocking` : "gate: risky calls wait for a person"} · ${cfg.connection}\n`);
+    if (upstream) {
+        const port = Number(value("--port") ?? 8787);
+        // Loopback by default. Cloud agent builders (Copilot Studio, Agentforce, AgentCore) need the
+        // proxy behind your HTTPS ingress: bind to 0.0.0.0 inside a container, never straight to the internet.
+        const host = value("--host") ?? "127.0.0.1";
+        await proxyHttp(cfg, upstream, port, host);
+        process.stderr.write(`[interlok] point your MCP client at http://${host}:${port}/mcp\n`);
+        return new Promise(() => { });
+    }
+    process.exitCode = await proxyStdio(cfg, child[0], child.slice(1));
+}

package/dist/scan.d.ts

@@ -0,0 +1,7 @@
+export type Finding = {
+    severity: "critical" | "warning";
+    code: string;
+    file: string;
+    message: string;
+};
+export declare function scan(path: string): Promise<Finding[]>;

package/dist/scan.js

@@ -0,0 +1,41 @@
+import { readFile, readdir } from "node:fs/promises";
+import { statSync } from "node:fs";
+import { join } from "node:path";
+const SKIP = new Set(["node_modules", ".git", "dist", ".next", ".output"]);
+async function files(path) {
+    if (!statSync(path).isDirectory())
+        return [path];
+    const out = [];
+    for (const name of await readdir(path)) {
+        if (SKIP.has(name))
+            continue;
+        const p = join(path, name);
+        if (statSync(p).isDirectory())
+            out.push(...(await files(p)));
+        else if (/\.(json|ya?ml|toml|ts|js|py)$/i.test(name))
+            out.push(p);
+    }
+    return out;
+}
+export async function scan(path) {
+    const findings = [];
+    for (const file of await files(path)) {
+        const text = await readFile(file, "utf8").catch(() => "");
+        if (/\b(delete|truncate|deploy|create_release|apply|write)\b/i.test(text) &&
+            !/interlok|gate|policy/i.test(text))
+            findings.push({
+                severity: "critical",
+                code: "ILK001",
+                file,
+                message: "Write-capable tool path has no visible Interlok boundary",
+            });
+        if (/(api[_-]?key|token|secret)\s*[:=]\s*["'][^"']{8,}/i.test(text))
+            findings.push({
+                severity: "warning",
+                code: "ILK002",
+                file,
+                message: "Credential-like value is embedded in configuration",
+            });
+    }
+    return findings;
+}

package/dist/verify.d.ts

@@ -0,0 +1,34 @@
+type Entry = {
+    seq: number;
+    prev_hash: string;
+    payload: unknown;
+    payload_hash: string;
+    entry_hash: string;
+    signature: string;
+    signer_kid: string;
+};
+type Bundle = {
+    entries: Entry[];
+    keys?: Record<string, JsonWebKey>;
+    public_keys?: Record<string, JsonWebKey>;
+};
+type Result = {
+    ok: true;
+    checked: number;
+    detail?: string;
+} | {
+    ok: false;
+    seq: number;
+    reason: string;
+};
+export declare function verifyBundle(bundle: Bundle): Promise<Result>;
+/**
+ * Verifies a downloaded bundle offline. Beyond the signatures:
+ *  - interlok.shadow.v1: the event list matches the signed manifest hash. For report 1.1 the
+ *    coverage and the run diff must also match the hashes the receipt signed, so neither a reach
+ *    tier nor a coverage number can be edited after the fact.
+ *  - interlok.public.v1: the published snapshot matches the hash signed when it was published.
+ */
+export declare function verifyParsed(bundle: Bundle & Record<string, any>): Promise<Result>;
+export declare function verifyFile(path: string): Promise<Result>;
+export {};

package/dist/verify.js

@@ -0,0 +1,123 @@
+import { createHash, webcrypto } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { canonical } from "./canonical.js";
+import { payloadRootV2 } from "./proof-verify.js";
+const sha = (s) => createHash("sha256").update(s).digest("hex");
+const b64url = (s) => Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/"), "base64");
+export async function verifyBundle(bundle) {
+    const keys = bundle.keys ?? bundle.public_keys ?? {};
+    let prev = bundle.entries[0]?.prev_hash ?? "0".repeat(64);
+    for (const e of bundle.entries) {
+        if (e.prev_hash !== prev)
+            return { ok: false, seq: e.seq, reason: "prev_hash mismatch" };
+        if (e.payload?.record_version === 2) {
+            const salts = e.field_salts;
+            if (!salts)
+                return { ok: false, seq: e.seq, reason: "v2 record exported without its field salts" };
+            if ((await payloadRootV2(e.payload, salts).catch(() => "")) !== e.payload_hash)
+                return { ok: false, seq: e.seq, reason: "payload tampered" };
+        }
+        else if (sha(canonical(e.payload)) !== e.payload_hash)
+            return { ok: false, seq: e.seq, reason: "payload tampered" };
+        if (sha(`${e.seq}|${e.prev_hash}|${e.payload_hash}`) !== e.entry_hash)
+            return { ok: false, seq: e.seq, reason: "entry_hash mismatch" };
+        const jwk = keys[e.signer_kid];
+        if (!jwk)
+            return { ok: false, seq: e.seq, reason: `unknown signer ${e.signer_kid}` };
+        const key = await webcrypto.subtle.importKey("jwk", jwk, { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+        const ok = await webcrypto.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, key, b64url(e.signature), Buffer.from(e.entry_hash));
+        if (!ok)
+            return { ok: false, seq: e.seq, reason: "bad signature" };
+        prev = e.entry_hash;
+    }
+    return { ok: true, checked: bundle.entries.length };
+}
+/**
+ * Verifies a downloaded bundle offline. Beyond the signatures:
+ *  - interlok.shadow.v1: the event list matches the signed manifest hash. For report 1.1 the
+ *    coverage and the run diff must also match the hashes the receipt signed, so neither a reach
+ *    tier nor a coverage number can be edited after the fact.
+ *  - interlok.public.v1: the published snapshot matches the hash signed when it was published.
+ */
+export async function verifyParsed(bundle) {
+    if (bundle.format === "interlok.assessor-bundle/v1")
+        return verifyAssessor(bundle);
+    if (!Array.isArray(bundle.entries))
+        return { ok: false, seq: 0, reason: "not an Interlok evidence file (no entries)" };
+    const result = await verifyBundle(bundle);
+    if (!result.ok)
+        return result;
+    const first = bundle.entries[0];
+    const data = (first?.payload?.data ?? {});
+    const seq = first?.seq ?? 0;
+    if (bundle.format === "interlok.shadow.v1") {
+        if (data.event_manifest_hash !== sha(canonical(bundle.events ?? [])))
+            return { ok: false, seq, reason: "Shadow event manifest tampered" };
+        if (data.report_version === "1.1") {
+            if (data.coverage_hash !== undefined &&
+                data.coverage_hash !== sha(canonical(bundle.coverage ?? null)))
+                return { ok: false, seq, reason: "coverage does not match the signed receipt" };
+            if (data.diff_hash !== undefined && data.diff_hash !== sha(canonical(bundle.diff ?? null)))
+                return { ok: false, seq, reason: "run diff does not match the signed receipt" };
+            return { ...result, detail: "events, coverage, and run diff match the signed receipt" };
+        }
+        return { ...result, detail: "events match the signed receipt" };
+    }
+    if (bundle.format === "interlok.public.v1") {
+        if (data.snapshot_hash !== sha(canonical(bundle.snapshot ?? null)))
+            return { ok: false, seq, reason: "published snapshot does not match the signed receipt" };
+        return { ...result, detail: "the published report matches what was signed" };
+    }
+    return result;
+}
+/**
+ * interlok.assessor-bundle/v1: a signed attestation plus every ledger record it covers. Checks the
+ * attestation document against its signed hash and signature, every record, and that the records
+ * are exactly the range the attestation names (first, last and head hash).
+ */
+async function verifyAssessor(b) {
+    const att = b.attestation ?? {};
+    const ledger = b.ledger ?? {};
+    const entries = Array.isArray(ledger.entries) ? ledger.entries : [];
+    const keys = ledger.keys ?? {};
+    if (sha(canonical(att.document ?? null)) !== att.document_hash)
+        return { ok: false, seq: 0, reason: "attestation document does not match its signed hash" };
+    const jwk = keys[att.signer_kid];
+    if (!jwk)
+        return { ok: false, seq: 0, reason: `unknown attestation signer ${att.signer_kid}` };
+    const key = await webcrypto.subtle.importKey("jwk", jwk, { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+    const signed = await webcrypto.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, key, b64url(String(att.signature ?? "")), Buffer.from(String(att.document_hash ?? "")));
+    if (!signed)
+        return { ok: false, seq: 0, reason: "bad signature on the attestation" };
+    const range = att.document?.ledger_range ?? null;
+    if (!range) {
+        if (entries.length)
+            return { ok: false, seq: 0, reason: "attestation covers no records but the file has some" };
+        return {
+            ok: true,
+            checked: 0,
+            detail: "attestation signature verified; no records in the period",
+        };
+    }
+    const chain = await verifyBundle({ entries, keys });
+    if (!chain.ok)
+        return chain;
+    const first = entries[0];
+    const last = entries[entries.length - 1];
+    if (!first || Number(first.seq) !== range.from_seq || Number(last.seq) !== range.to_seq)
+        return {
+            ok: false,
+            seq: Number(first?.seq ?? 0),
+            reason: "records are not the attested range",
+        };
+    if (last.entry_hash !== range.head_hash)
+        return { ok: false, seq: Number(last.seq), reason: "last record is not the attested head" };
+    return {
+        ok: true,
+        checked: chain.checked,
+        detail: "attestation signature and range verified against the records",
+    };
+}
+export async function verifyFile(path) {
+    return verifyParsed(JSON.parse(await readFile(path, "utf8")));
+}

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "@interlok/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.3.0",
+  "description": "Scan agent configurations, put MCP servers behind the Interlok gate, run Shadow observations, and verify receipts offline.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anytechlabs/interlok-vercel.git",
+    "directory": "cli"
+  },
+  "homepage": "https://interlok.io/integrations/agents",
+  "type": "module",
+  "bin": {
+    "interlok": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^22.16.5",
+    "typescript": "^5.8.3",
+    "vitest": "^5.0.1"
+  },
+  "dependencies": {
+    "fflate": "^0.8.3"
+  }
+}