@counterfact-labs/cli 0.1.2 → 0.2.3

package/dist/setup-pings/client.js

@@ -0,0 +1,31 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { fileURLToPath, URL } from "node:url";
+export { readTelemetrySettings } from "./policy.js";
+export const disabledSetupPings = Object.freeze({ ping() { }, link() { } });
+export const DEFAULT_CONSOLE_URL = "https://app.counterfactlabs.com";
+export function createSetupPings(input, io = {}) {
+    if (!input.settings.enabled)
+        return disabledSetupPings;
+    const { homeDir, origin } = input;
+    let token;
+    const dispatch = (operation) => {
+        try {
+            const child = (io.spawn ?? spawn)(process.execPath, [fileURLToPath(new URL("./worker.js", import.meta.url))], {
+                cwd: "/", env: {}, detached: true, stdio: ["pipe", "ignore", "ignore"],
+            });
+            child.on("error", () => { });
+            const pipe = child.stdin;
+            pipe?.on("error", () => { });
+            child.unref();
+            pipe?.unref();
+            // Tokens stay in this private channel, never in argv or the child environment.
+            pipe?.end(JSON.stringify({ ...operation, token, homeDir, origin, ...(io.allowLoopback ? { allowLoopback: true } : {}) }));
+        }
+        catch { /* Reporting must never change a command's result. */ }
+    };
+    return {
+        ping(step) { dispatch({ kind: "ping", step }); },
+        link(value) { token = value; dispatch({ kind: "link" }); },
+    };
+}

package/dist/setup-pings/contract.js

@@ -0,0 +1,2 @@
+// Generated from counterfact_saas/src/lib/funnel/steps.ts. Do not edit by hand.
+export const SETUP_PING_STEPS = ["mcp_started", "claude_allow_rule_found", "agent_sign_in_started", "first_analysis_started"];

package/dist/setup-pings/policy.js

@@ -0,0 +1,3 @@
+export function readTelemetrySettings(env) {
+    return Object.freeze({ enabled: env.CF_TELEMETRY !== "0" && env.DO_NOT_TRACK !== "1" && env.CI === undefined });
+}

package/dist/setup-pings/state.js

@@ -0,0 +1,261 @@
+import { Buffer } from "node:buffer";
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { link, lstat, mkdir, open, unlink } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { setTimeout } from "node:timers/promises";
+import { SETUP_PING_STEPS } from "./contract.js";
+const idName = "install-id";
+const linkName = "link.attempted";
+const temporaryName = ".install.tmp";
+const stepName = (step) => `${step}.attempted`;
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const hasCode = (error, code) => error?.code === code;
+const sameSlot = (left, right) => left.dev === right.dev && left.ino === right.ino
+    && left.mtimeMs === right.mtimeMs && left.size === right.size;
+class IncompleteStateFile extends Error {
+}
+async function stateDirectory(homeDir, create) {
+    if (!isAbsolute(homeDir) || !(await lstat(homeDir)).isDirectory())
+        throw new Error("Invalid home");
+    let directory = homeDir;
+    for (const part of [".config", "counterfact-labs", "setup-pings"]) {
+        directory = join(directory, part);
+        if (create) {
+            try {
+                await mkdir(directory, { mode: 0o700 });
+            }
+            catch (error) {
+                if (!hasCode(error, "EEXIST"))
+                    throw error;
+            }
+        }
+        const info = await lstat(directory);
+        if (!info.isDirectory())
+            throw new Error("Invalid state directory");
+        if (part === "setup-pings" && (info.mode & 0o777) !== 0o700)
+            throw new Error("State directory is not private");
+    }
+    return directory;
+}
+async function readPrivateFile(path, size) {
+    let file;
+    try {
+        file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            return undefined;
+        throw error;
+    }
+    try {
+        const info = await file.stat();
+        if (!info.isFile() || (info.mode & 0o777) !== 0o600)
+            throw new Error("Invalid state file");
+        if (info.size < size)
+            throw new IncompleteStateFile("Incomplete state file");
+        if (info.size > size)
+            throw new Error("Invalid state size");
+        // Bound reads even if another process changes the file after stat.
+        const buffer = Buffer.alloc(size + 1);
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+        if (bytesRead < size)
+            throw new IncompleteStateFile("Incomplete state size");
+        if (bytesRead > size)
+            throw new Error("Invalid state size");
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        await file.close();
+    }
+}
+async function readIdentity(directory) {
+    for (let count = 0; count < 25; count++) {
+        try {
+            const value = await readPrivateFile(join(directory, idName), 36);
+            if (value !== undefined && !uuid.test(value))
+                throw new Error("Invalid installation ID");
+            return value;
+        }
+        catch (error) {
+            if (!(error instanceof IncompleteStateFile))
+                throw error;
+            // A delayed stale remover may let a publisher link another writer's unfinished slot.
+            await setTimeout(10);
+        }
+    }
+    throw new Error("Incomplete installation ID publication");
+}
+async function readMarkers(directory) {
+    const steps = [];
+    for (const step of SETUP_PING_STEPS) {
+        if (await readPrivateFile(join(directory, stepName(step)), 0) !== undefined)
+            steps.push(step);
+    }
+    const linked = await readPrivateFile(join(directory, linkName), 0) !== undefined;
+    return { steps, linked };
+}
+async function publishIdentity(directory) {
+    const temporary = join(directory, temporaryName);
+    for (let count = 0; count < 25; count++) {
+        const winner = await readIdentity(directory);
+        if (winner)
+            return winner;
+        let file;
+        try {
+            file = await open(temporary, "wx", 0o600);
+        }
+        catch (error) {
+            if (!hasCode(error, "EEXIST"))
+                throw error;
+            const winner = await readIdentity(directory);
+            if (winner)
+                return winner;
+            const slot = await readTemporary(directory);
+            // A worker can exit after writing the UUID but before publishing its link.
+            if (slot?.value)
+                await linkIdentity(directory);
+            else if (slot?.stale)
+                await removeTemporary(directory, slot);
+            else
+                await setTimeout(10);
+            continue;
+        }
+        try {
+            try {
+                await file.writeFile(randomUUID(), "utf8");
+            }
+            finally {
+                await file.close();
+            }
+            await linkIdentity(directory);
+            const installId = await readIdentity(directory);
+            // A delayed stale-slot cleanup can unlink our file before the link is made.
+            if (installId)
+                return installId;
+        }
+        finally {
+            await clearTemporary(directory);
+        }
+    }
+    throw new Error("Incomplete installation ID publication");
+}
+async function linkIdentity(directory) {
+    // A hard link publishes only complete bytes and cannot overwrite a winner.
+    try {
+        await link(join(directory, temporaryName), join(directory, idName));
+    }
+    catch (error) {
+        // A reader may remove the slot after observing the already published ID.
+        if (!hasCode(error, "EEXIST") && !hasCode(error, "ENOENT"))
+            throw error;
+    }
+}
+async function readTemporary(directory) {
+    const temporary = join(directory, temporaryName);
+    for (let count = 0; count < 25; count++) {
+        try {
+            const info = await lstat(temporary);
+            if (!info.isFile() || (info.mode & 0o777) !== 0o600)
+                throw new Error("Invalid publication slot");
+            let contents;
+            try {
+                contents = info.size === 36 ? await readPrivateFile(temporary, 36) : undefined;
+            }
+            catch (error) {
+                // A stale slot may have become a new writer's incomplete file before open.
+                if (!sameSlot(info, await lstat(temporary)))
+                    continue;
+                throw error;
+            }
+            // This exceeds the worker's hard lifetime, so an incomplete writer cannot still be active.
+            return { value: contents && uuid.test(contents) ? contents : undefined, stale: Date.now() - info.mtimeMs > 5000,
+                info };
+        }
+        catch (error) {
+            if (hasCode(error, "ENOENT"))
+                return undefined;
+            throw error;
+        }
+    }
+    throw new Error("Installation ID publication keeps changing");
+}
+async function clearTemporary(directory) {
+    for (let count = 0; count < 25; count++) {
+        const slot = await readTemporary(directory);
+        if (!slot)
+            return;
+        // A concurrent creator may still be finishing its slot after an ID was published.
+        if (!slot.value && !slot.stale) {
+            await setTimeout(10);
+            continue;
+        }
+        if (await removeTemporary(directory, slot))
+            return;
+    }
+    throw new Error("Incomplete publication slot");
+}
+async function removeTemporary(directory, slot) {
+    try {
+        const temporary = join(directory, temporaryName);
+        const current = await lstat(temporary);
+        // Another recovering worker may already have replaced the stale slot.
+        if (!sameSlot(current, slot.info))
+            return false;
+        await unlink(temporary);
+    }
+    catch (error) {
+        if (!hasCode(error, "ENOENT"))
+            throw error;
+    }
+    return true;
+}
+async function createMarker(directory, name) {
+    try {
+        const file = await open(join(directory, name), "wx", 0o600);
+        await file.close();
+        return true;
+    }
+    catch (error) {
+        if (hasCode(error, "EEXIST"))
+            return false;
+        throw error;
+    }
+}
+export async function claimStep(homeDir, step) {
+    try {
+        if (!SETUP_PING_STEPS.includes(step))
+            return null;
+        const directory = await stateDirectory(homeDir, true);
+        const markers = await readMarkers(directory);
+        let installId = await readIdentity(directory);
+        // A missing ID beside old markers is damaged state, not a new installation.
+        if (!installId && (markers.steps.length || markers.linked))
+            return null;
+        installId ??= await publishIdentity(directory);
+        await clearTemporary(directory);
+        if (markers.steps.includes(step) || !await createMarker(directory, stepName(step)))
+            return null;
+        return { installId };
+    }
+    catch {
+        return null;
+    }
+}
+export async function claimLink(homeDir) {
+    try {
+        const directory = await stateDirectory(homeDir, false);
+        const markers = await readMarkers(directory);
+        const installId = await readIdentity(directory);
+        const step = markers.steps[0];
+        if (!installId || !step || markers.linked)
+            return null;
+        await clearTemporary(directory);
+        if (!await createMarker(directory, linkName))
+            return null;
+        return { installId, step };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/setup-pings/worker.js

@@ -0,0 +1,95 @@
+import { Buffer } from "node:buffer";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import process from "node:process";
+import { clearTimeout, setTimeout } from "node:timers";
+import { fileURLToPath, URL } from "node:url";
+import { SETUP_PING_STEPS } from "./contract.js";
+import { claimLink, claimStep } from "./state.js";
+import { DEFAULT_CONSOLE_URL } from "./client.js";
+function parseOperation(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const operation = raw;
+    if (typeof operation.homeDir !== "string" || typeof operation.origin !== "string")
+        return null;
+    if (operation.kind !== "ping" && operation.kind !== "link")
+        return null;
+    if (operation.kind === "ping" && !SETUP_PING_STEPS.includes(operation.step))
+        return null;
+    if (operation.kind === "link" && !operation.token)
+        return null;
+    if (operation.token !== undefined && (typeof operation.token !== "string" || !/^[\x21-\x7e]{1,4096}$/.test(operation.token)))
+        return null;
+    const base = new URL(operation.origin);
+    const production = base.origin === DEFAULT_CONSOLE_URL;
+    const loopback = operation.allowLoopback === true && base.protocol === "http:" && ["127.0.0.1", "[::1]"].includes(base.hostname);
+    if ((!production && !loopback) || base.username || base.password || base.search || base.hash)
+        return null;
+    const url = new URL(`${base.href.replace(/\/+$/, "")}/api/funnel/step`);
+    return { operation, url };
+}
+export async function runWorker(raw, io = {}) {
+    let request;
+    let httpDeadline;
+    let stopped = false;
+    let finish;
+    const finished = new Promise(resolve => { finish = () => { stopped = true; resolve(); }; });
+    const deadline = setTimeout(finish, 750);
+    void (async () => {
+        try {
+            const parsed = parseOperation(raw);
+            if (!parsed)
+                return;
+            const { operation, url } = parsed;
+            const claim = operation.kind === "ping"
+                ? await (io.claimStep ?? claimStep)(operation.homeDir, operation.step).then(value => value && { ...value, step: operation.step })
+                : await (io.claimLink ?? claimLink)(operation.homeDir);
+            if (!claim || stopped)
+                return;
+            const body = JSON.stringify({ installId: claim.installId, step: claim.step });
+            const headers = { "content-type": "application/json", "content-length": Buffer.byteLength(body) };
+            if (operation.token)
+                headers.authorization = `Bearer ${operation.token}`;
+            const send = io.request ?? (url.protocol === "https:" ? httpsRequest : httpRequest);
+            request = send(url, { method: "POST", headers, agent: false }, response => {
+                // Status is final: no redirects, response body, retries or server text.
+                response.destroy();
+                finish();
+            });
+            request.on("error", finish);
+            // An absolute timer also covers DNS and TLS before a socket is ready.
+            httpDeadline = setTimeout(finish, 500);
+            request.end(body);
+            await finished;
+        }
+        catch { /* Disk and transport failures are deliberately silent. */ }
+        finally {
+            finish();
+        }
+    })();
+    await finished;
+    clearTimeout(deadline);
+    clearTimeout(httpDeadline);
+    request?.destroy();
+}
+async function main() {
+    // A hard process deadline also covers hung filesystem work and unread stdin.
+    const deadline = setTimeout(() => process.exit(0), 750);
+    try {
+        let input = "";
+        for await (const chunk of process.stdin) {
+            input += chunk;
+            if (Buffer.byteLength(input) > 16384)
+                return;
+        }
+        await runWorker(JSON.parse(input));
+    }
+    catch { /* No telemetry failure is printed. */ }
+    finally {
+        clearTimeout(deadline);
+        process.exit(0);
+    }
+}
+if (process.argv[1] === fileURLToPath(import.meta.url))
+    void main();

package/dist/transport/base64url.js

@@ -0,0 +1,9 @@
+/** Node's decoder ignores invalid characters and trailing bits; signed tokens require canonical bytes. */
+export function decodeBase64url(value) {
+    if (!/^[A-Za-z0-9_-]+$/.test(value))
+        throw new Error();
+    const bytes = Buffer.from(value, "base64url");
+    if (bytes.toString("base64url") !== value)
+        throw new Error();
+    return bytes;
+}

package/dist/transport/http-response.js

@@ -0,0 +1,89 @@
+/** Owns response bounds and cleanup for direct HTTP clients; callers own destinations and payload formats. */
+export function requestBoundedResponse(start, limits) {
+    return new Promise((resolve, reject) => {
+        let req, response;
+        let done = false;
+        let timer;
+        const fail = () => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            req?.destroy();
+            response?.destroy();
+            reject(new Error("HTTP response failed"));
+        };
+        try {
+            for (const limit of [limits.maxBytes, limits.timeoutMs, limits.bodyTimeoutMs ?? limits.timeoutMs]) {
+                if (!Number.isSafeInteger(limit) || limit < 1)
+                    throw new Error();
+            }
+            // This starts before dialing and never resets on data, so trickled bytes cannot prolong it.
+            timer = setTimeout(fail, limits.timeoutMs);
+            req = start(incoming => {
+                incoming.on("error", fail);
+                incoming.on("aborted", fail);
+                if (done) {
+                    incoming.destroy();
+                    return;
+                }
+                if (response) {
+                    incoming.destroy();
+                    fail();
+                    return;
+                }
+                response = incoming;
+                try {
+                    if (limits.bodyTimeoutMs !== undefined) {
+                        clearTimeout(timer);
+                        timer = setTimeout(fail, limits.bodyTimeoutMs);
+                    }
+                    const length = incoming.headers["content-length"];
+                    const encoding = incoming.headers["content-encoding"];
+                    if (encoding !== undefined && encoding !== "identity" ||
+                        length !== undefined && (!/^\d+$/.test(length) || Number(length) > limits.maxBytes))
+                        throw new Error();
+                    limits.validate?.(incoming);
+                }
+                catch {
+                    fail();
+                    return;
+                }
+                const chunks = [];
+                let bytes = 0;
+                incoming.on("data", (chunk) => {
+                    if (done)
+                        return;
+                    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                    bytes += buffer.length;
+                    if (bytes > limits.maxBytes) {
+                        fail();
+                        return;
+                    }
+                    chunks.push(buffer);
+                });
+                incoming.on("end", () => {
+                    if (done)
+                        return;
+                    if (!incoming.complete) {
+                        fail();
+                        return;
+                    }
+                    done = true;
+                    clearTimeout(timer);
+                    resolve({ response: incoming, body: Buffer.concat(chunks) });
+                });
+                incoming.on("close", () => { if (!incoming.complete)
+                    fail(); });
+            });
+            req.on("error", fail);
+            if (done)
+                req.destroy();
+            else
+                req.end(limits.requestBody);
+        }
+        catch {
+            fail();
+        }
+    });
+}

package/dist/transport/tls-exporter.js

@@ -0,0 +1,5 @@
+import { RELAY_TLS_EXPORTER_LABEL } from "../contract/messages.js";
+/** Each peer must derive these bytes independently from its actual socket. */
+export function relayExportedKeyMaterial(socket) {
+    return socket.exportKeyingMaterial(32, RELAY_TLS_EXPORTER_LABEL, Buffer.alloc(0));
+}

package/package.json

@@ -1,16 +1,62 @@
 {
   "name": "@counterfact-labs/cli",
-  "version": "0.1.2",
-  "license": "UNLICENSED",
-  "description": "Check an agent from your terminal or coding agent",
+  "version": "0.2.3",
   "type": "module",
-  "bin": { "counterfact-labs": "dist/main.js" },
-  "engines": { "node": ">=20" },
-  "files": ["dist", "!dist/**/*.test.js", "!dist/test-helpers.js"],
+  "files": [
+    "dist/**/*.js",
+    "dist/gatekeeper/trust/production.json",
+    "bundle/sealed.json",
+    "bundle/client-release.json"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
-    "prebuild": "node scripts/copy-api-types.mjs",
-    "build": "node scripts/build.mjs",
-    "test": "npm run build && node --test dist/*.test.js dist/commands/*.test.js",
-    "prepack": "npm run build"
-  }
+    "lint": "eslint .",
+    "bundle:seal": "tsx bundle/seal/cli.ts",
+    "bundle:check": "tsx bundle/seal/cli.ts check",
+    "bench:replay": "tsx bench/replay.ts",
+    "bench:importer": "tsx bench/importer-coverage.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test ${TEST_SHARD:+--test-shard=$TEST_SHARD} --test-concurrency=4 --test-timeout=600000 \"core/**/*.test.ts\" \"adapters/**/*.test.ts\" \"cli/**/*.test.ts\" \"bench/**/*.test.ts\" \"bundle/**/*.test.ts\" \"contract/**/*.test.ts\" \"gatekeeper/**/*.test.ts\" \"relay/**/*.test.ts\" \"transport/**/*.test.ts\" \"packages/core/src/**/*.test.ts\" \"packages/core/*.test.ts\" \"packages/setup-pings/src/**/*.test.ts\" \"scripts/**/*.test.ts\"",
+    "build:core": "npm run build --workspace @counterfact-labs/analysis-core",
+    "build:setup-pings": "npm run build --workspace @counterfact-labs/setup-pings",
+    "prepare": "npm run build:core && npm run build:setup-pings",
+    "pretest": "npm run build:core && npm run build:setup-pings",
+    "release:core": "tsx scripts/release-core.ts",
+    "build:cli": "npm run build:setup-pings && tsx scripts/build-cli.ts",
+    "prepack": "npm run build:core && npm run build:cli",
+    "pack:integration": "tsx scripts/integration/pack.ts",
+    "release:cli": "tsx scripts/release-cli.ts"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "0.128.0",
+    "zod": "4.6.5",
+    "asn1js": "3.0.6",
+    "pkijs": "3.2.5"
+  },
+  "devDependencies": {
+    "@eslint/js": "9.39.5",
+    "@types/node": "24.19.0",
+    "esbuild": "0.28.2",
+    "eslint": "9.39.5",
+    "js-yaml": "4.3.2",
+    "tsx": "4.23.15",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.64.0",
+    "@counterfact-labs/analysis-core": "0.7.1",
+    "@counterfact-labs/setup-pings": "0.1.0"
+  },
+  "workspaces": [
+    "packages/*"
+  ],
+  "bin": {
+    "counterfact-labs": "dist/cli/main.js"
+  },
+  "exports": {
+    ".": "./dist/cli/main.js",
+    "./gatekeeper": "./dist/gatekeeper/client.js"
+  },
+  "license": "UNLICENSED",
+  "description": "Analyze an agent from your terminal or coding agent"
 }

package/LICENSE

@@ -1 +0,0 @@
-Copyright (c) 2026 Counterfact Labs, Inc. All rights reserved. This software is provided to access the Counterfact service and may be used only for that purpose. No other rights are granted.

package/dist/api-types.js

@@ -1,2 +0,0 @@
-// This file is copied into the command-line package before its build. Keep it self-contained.
-export const CLI_BODY_LIMIT = 2 * 1024 * 1024;