@cygnuxlabs/tracekit 0.0.0-stage → 1.2.2

package/dist/verify/zip.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The zip reader of docs/format-v2.md §9: one canonical layout, stored and deflated entries (Web Crypto's sibling
+ * DecompressionStream), no zip64, under the bundle limits. Names that could escape a directory, symlinks and duplicate
+ * entries are refused.
+ */
+export declare const MAX_ENTRIES = 10000;
+export declare const MAX_ENTRY: number;
+export declare const MAX_TOTAL: number;
+export declare class Unusable extends Error {
+}
+/**
+ * {name: bytes} of a zip in the one layout of docs/format-v2.md §9, entry by entry under the count and size caps: the
+ * end record ends the file, with no comment; the central directory sits between the last entry and it; the entries are
+ * contiguous from offset 0, each local header repeating its central entry; no zip64, extra or comment field, or
+ * general-purpose flag.
+ */
+export declare function readZip(data: Uint8Array): Promise<Map<string, Uint8Array>>;

package/dist/verify/zip.js

@@ -0,0 +1,145 @@
+/**
+ * The zip reader of docs/format-v2.md §9: one canonical layout, stored and deflated entries (Web Crypto's sibling
+ * DecompressionStream), no zip64, under the bundle limits. Names that could escape a directory, symlinks and duplicate
+ * entries are refused.
+ */
+export const MAX_ENTRIES = 10_000;
+export const MAX_ENTRY = 64 << 20;
+export const MAX_TOTAL = 512 << 20;
+const NAME = /^[A-Za-z0-9_-][A-Za-z0-9._-]*(\/[A-Za-z0-9._-]+)*$/;
+export class Unusable extends Error {
+}
+let CRC;
+function crc32(data) {
+    if (!CRC) {
+        CRC = new Uint32Array(256);
+        for (let n = 0; n < 256; n++) {
+            let c = n;
+            for (let k = 0; k < 8; k++)
+                c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+            CRC[n] = c >>> 0;
+        }
+    }
+    let c = 0xffffffff;
+    for (const b of data)
+        c = CRC[(c ^ b) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+/** The first `limit` bytes a raw deflate stream inflates to; stops reading there, so a zip bomb costs nothing. */
+async function inflate(raw, limit) {
+    const reader = new Blob([raw]).stream().pipeThrough(new DecompressionStream("deflate-raw")).getReader();
+    const parts = [];
+    let n = 0;
+    while (n < limit) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        parts.push(value);
+        n += value.length;
+    }
+    if (n >= limit)
+        await reader.cancel().catch(() => { });
+    const out = new Uint8Array(n);
+    let at = 0;
+    for (const p of parts)
+        out.set(p, (at += p.length) - p.length);
+    return out.subarray(0, limit);
+}
+/**
+ * {name: bytes} of a zip in the one layout of docs/format-v2.md §9, entry by entry under the count and size caps: the
+ * end record ends the file, with no comment; the central directory sits between the last entry and it; the entries are
+ * contiguous from offset 0, each local header repeating its central entry; no zip64, extra or comment field, or
+ * general-purpose flag.
+ */
+export async function readZip(data) {
+    const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const need = (at, n) => {
+        if (at < 0 || at + n > data.length)
+            throw new Unusable("truncated zip");
+    };
+    const eocd = data.length - 22;
+    if (eocd < 0 || v.getUint32(eocd, true) !== 0x06054b50)
+        throw new Unusable("not a zip file, or bytes after its end record");
+    const count = v.getUint16(eocd + 10, true), cdSize = v.getUint32(eocd + 12, true), cdOffset = v.getUint32(eocd + 16, true);
+    if (v.getUint16(eocd + 4, true) || v.getUint16(eocd + 6, true) || v.getUint16(eocd + 8, true) !== count
+        || v.getUint16(eocd + 20, true) || cdOffset + cdSize !== eocd)
+        throw new Unusable("not the canonical zip layout: end record");
+    if (count > MAX_ENTRIES)
+        throw new Unusable("too many entries");
+    const entries = [];
+    for (let at = cdOffset; at < eocd;) {
+        if (at + 46 > eocd)
+            throw new Unusable("truncated zip");
+        const n = v.getUint16(at + 28, true);
+        if (v.getUint32(at, true) !== 0x02014b50 || v.getUint16(at + 30, true) || v.getUint16(at + 32, true) || at + 46 + n > eocd)
+            throw new Unusable("bad central directory entry");
+        const raw = data.subarray(at + 46, at + 46 + n);
+        entries.push({ name: new TextDecoder().decode(raw), raw, flags: v.getUint16(at + 8, true),
+            method: v.getUint16(at + 10, true), crc: v.getUint32(at + 16, true), csize: v.getUint32(at + 20, true),
+            usize: v.getUint32(at + 24, true), attr: v.getUint32(at + 38, true), local: v.getUint32(at + 42, true) });
+        at += 46 + n;
+    }
+    if (entries.length !== count)
+        throw new Unusable("not the canonical zip layout: entry count");
+    let pos = 0;
+    for (const e of entries) {
+        const n = JSON.stringify(e.name.slice(0, 80));
+        if (e.csize === 0xffffffff || e.usize === 0xffffffff || e.local === 0xffffffff)
+            throw new Unusable("zip64 is not supported");
+        if (e.method !== 0 && e.method !== 8 || e.method === 0 && e.csize !== e.usize)
+            throw new Unusable(`${n}: compression method ${e.method} (only stored and deflate)`);
+        if (e.flags & 1)
+            throw new Unusable(`${n} is encrypted`);
+        if (e.flags)
+            throw new Unusable(`${n}: general-purpose flags 0x${e.flags.toString(16)}`);
+        if (e.local !== pos)
+            throw new Unusable(`not the canonical zip layout: ${n} does not follow the entry before it`);
+        need(e.local, 30 + e.raw.length);
+        const local = data.subarray(e.local + 30, e.local + 30 + e.raw.length);
+        if (v.getUint32(e.local, true) !== 0x04034b50 || v.getUint16(e.local + 6, true) !== e.flags
+            || v.getUint16(e.local + 8, true) !== e.method || v.getUint32(e.local + 14, true) !== e.crc
+            || v.getUint32(e.local + 18, true) !== e.csize || v.getUint32(e.local + 22, true) !== e.usize
+            || v.getUint16(e.local + 26, true) !== e.raw.length || v.getUint16(e.local + 28, true)
+            || local.some((b, i) => b !== e.raw[i]))
+            throw new Unusable(`bad local header for ${n}: it does not repeat the central entry`);
+        pos = e.local + 30 + e.raw.length + e.csize;
+    }
+    if (pos !== cdOffset)
+        throw new Unusable("not the canonical zip layout: bytes before the central directory");
+    const files = new Map();
+    let total = 0;
+    for (const e of entries) {
+        const n = e.name;
+        if (!NAME.test(n) || n.split("/").some((p) => /^\.+$/.test(p)))
+            throw new Unusable(`bad entry name ${JSON.stringify(n.slice(0, 80))}`);
+        if (files.has(n))
+            throw new Unusable(`duplicate entry ${n}`);
+        if (((e.attr >>> 16) & 0o170000) === 0o120000)
+            throw new Unusable(`symlink entry ${n}`);
+        const start = e.local + 30 + e.raw.length;
+        need(start, e.csize);
+        const body = data.subarray(start, start + e.csize);
+        const cap = Math.min(MAX_ENTRY, MAX_TOTAL - total);
+        const limit = Math.min(e.usize, cap + 1);
+        let out;
+        if (e.method === 0)
+            out = body.subarray(0, limit);
+        else {
+            try {
+                out = await inflate(body, limit);
+            }
+            catch (x) {
+                throw new Unusable(`${n}: ${x.message}`);
+            }
+        }
+        if (out.length > cap)
+            throw new Unusable(`${n} is larger than the bundle limits`);
+        if (out.length !== e.usize)
+            throw new Unusable(`${n}: ${out.length} bytes, not the ${e.usize} its entry says`);
+        if (crc32(out) !== e.crc)
+            throw new Unusable(`${n}: bad CRC-32`);
+        files.set(n, out);
+        total += out.length;
+    }
+    return files;
+}

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@cygnuxlabs/tracekit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.2.2",
+  "description": "Tracekit for TypeScript/JavaScript agents: a native client of the Tracekit signer: policy-gated tool calls and signed evidence, no runtime dependencies.",
+  "author": "Cygnux Labs",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/v2/client.js",
+  "types": "dist/v2/client.d.ts",
+  "exports": {
+    ".": { "types": "./dist/v2/client.d.ts", "import": "./dist/v2/client.js" },
+    "./v1": { "types": "./dist/v1.d.ts", "import": "./dist/v1.js" },
+    "./v2": { "types": "./dist/v2/client.d.ts", "import": "./dist/v2/client.js" },
+    "./v2/openai-agents": { "types": "./dist/v2/adapters/openai-agents.d.ts", "import": "./dist/v2/adapters/openai-agents.js" },
+    "./v2/vercel-ai": { "types": "./dist/v2/adapters/vercel-ai.d.ts", "import": "./dist/v2/adapters/vercel-ai.js" },
+    "./v2/claude-agent-sdk": { "types": "./dist/v2/adapters/claude-agent-sdk.d.ts", "import": "./dist/v2/adapters/claude-agent-sdk.js" },
+    "./v2/executor": { "types": "./dist/v2/executor.d.ts", "import": "./dist/v2/executor.js" },
+    "./verify": { "types": "./dist/verify/index.d.ts", "import": "./dist/verify/index.js" }
+  },
+  "bin": { "tracekit": "bin/tracekit.mjs" },
+  "files": ["dist", "bin", "README.md"],
+  "engines": { "node": ">=18" },
+  "scripts": {
+    "build": "tsc -p .",
+    "test": "npm run build && node --test test/*.test.mjs"
+  },
+  "optionalDependencies": {
+    "@cygnuxlabs/tracekit-signer-darwin-arm64": "1.2.2",
+    "@cygnuxlabs/tracekit-signer-linux-x64-gnu": "1.2.2",
+    "@cygnuxlabs/tracekit-signer-linux-arm64-gnu": "1.2.2",
+    "@cygnuxlabs/tracekit-signer-win32-x64": "1.2.2"
+  },
+  "peerDependencies": { "@openai/agents": ">=0.20.0", "ai": ">=7.0.0", "@anthropic-ai/claude-agent-sdk": ">=0.3.0" },
+  "peerDependenciesMeta": {
+    "@openai/agents": { "optional": true }, "ai": { "optional": true }, "@anthropic-ai/claude-agent-sdk": { "optional": true }
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "@types/node": "^22.0.0",
+    "openai": "*",
+    "@anthropic-ai/sdk": "*"
+  },
+  "repository": { "type": "git", "url": "https://github.com/Cygnux-Labs/Tracekit" }
+}