chat-recall 0.5.6 → 0.5.8

package/dist/telemetry-consent.js

@@ -0,0 +1,115 @@
+/**
+ * Whether this machine may report operational telemetry, and what counts as it.
+ *
+ * TWO INDEPENDENT GATES, both of which must open. They are separate on purpose:
+ * one answers "is the user willing", the other "is the operator entitled", and
+ * conflating them is how a product ends up collecting from someone who said no.
+ *
+ *   1. CONSENT — the user's setting, checked on this machine. It wins over
+ *      everything. No server response can override it, because a server should
+ *      not be able to talk a client into sending data its owner declined.
+ *
+ *   2. ELIGIBILITY — the server says whether this tenant's plan includes it.
+ *      The client cannot know its own plan (the entitlement lives in the control
+ *      plane), so it is told, and it defaults to NOT eligible: an older server
+ *      that says nothing gets nothing.
+ *
+ * The server enforces (2) again at ingest. This gate is an optimisation — it
+ * stops the data leaving a machine that shouldn't send it — not the boundary.
+ *
+ * ── What may be reported, and what may never be ──────────────────────────
+ * Operational facts about the COLLECTOR, never about the user's work:
+ *
+ *   allowed   walk duration, sessions considered/shipped, bytes uploaded,
+ *             429/failure counts, breaker trips, RSS peak, CLI version, OS,
+ *             error CLASS plus a redacted message
+ *   forbidden transcript content, prompts, file paths, project names, session
+ *             ids, repository names, anything derived from what the user wrote
+ *
+ * `assertNoSensitiveKeys` enforces the second list structurally rather than by
+ * review, because "no paths" is exactly the promise that erodes one convenient
+ * field at a time.
+ */
+import { loadSettings } from '@chat-recall/engine/core/settings.js';
+/** Env kill-switch, for a machine where editing settings is not practical. */
+const ENV_OFF = () => {
+    const v = (process.env.CHAT_RECALL_TELEMETRY || '').trim().toLowerCase();
+    return v === '0' || v === 'off' || v === 'false' || v === 'no';
+};
+/**
+ * Has the user opted out?
+ *
+ * Default is ON for the operational facts above — an opt-OUT, which is what the
+ * product intends and what the docs must say plainly. Anything that touches user
+ * CONTENT is not covered by this and is not collected at all, at any setting.
+ */
+export function userConsents() {
+    if (ENV_OFF())
+        return false;
+    try {
+        const s = loadSettings();
+        return s.privacy?.telemetry !== false;
+    }
+    catch {
+        // Unreadable settings must not be read as consent.
+        return false;
+    }
+}
+/** Eligibility as last reported by a server, keyed by server URL. */
+const eligible = new Map();
+/** Record what the server said about this tenant's plan. */
+export function setTelemetryEligible(serverUrl, allowed) {
+    eligible.set(serverUrl.replace(/\/+$/, ''), allowed);
+}
+/** Default NO: a server that never said yes never gets telemetry. */
+export function serverAllowsTelemetry(serverUrl) {
+    return eligible.get(serverUrl.replace(/\/+$/, '')) === true;
+}
+/** Test seam. */
+export function _resetTelemetryEligibility() { eligible.clear(); }
+/** Both gates, for one target. */
+export function mayReport(serverUrl) {
+    return userConsents() && serverAllowsTelemetry(serverUrl);
+}
+/**
+ * Keys that must never appear in a telemetry payload.
+ *
+ * Checked structurally so the promise survives the next person adding "just the
+ * project name for context". A violation throws in development and drops the
+ * event in production — never sends it anyway.
+ */
+const FORBIDDEN_KEY = /(path|dir|file|project|repo|session|prompt|content|text|title|branch|url|email|user|home|cwd)/i;
+/** Every forbidden key in `obj`, deeply. Empty means safe to send. */
+export function findSensitiveKeys(obj, where = '') {
+    const out = [];
+    const walk = (v, at) => {
+        if (!v || typeof v !== 'object')
+            return;
+        if (Array.isArray(v)) {
+            v.forEach((e, i) => walk(e, `${at}[${i}]`));
+            return;
+        }
+        for (const [k, val] of Object.entries(v)) {
+            if (FORBIDDEN_KEY.test(k))
+                out.push({ key: k, where: at || '(root)' });
+            walk(val, at ? `${at}.${k}` : k);
+        }
+    };
+    walk(obj, where);
+    return out;
+}
+/**
+ * Throw when a payload carries a forbidden key.
+ *
+ * Deliberately loud: a telemetry event that leaks a file path is a privacy
+ * incident, and the cheapest place to stop it is the type of failure a developer
+ * cannot ignore.
+ */
+export function assertNoSensitiveKeys(payload) {
+    const bad = findSensitiveKeys(payload);
+    if (bad.length > 0) {
+        throw new Error(`telemetry payload carries forbidden key(s): ${bad.map((b) => `${b.where}.${b.key}`).join(', ')}. `
+            + 'Operational telemetry must describe the COLLECTOR, never the user\'s work.');
+    }
+}
+//# sourceMappingURL=telemetry-consent.js.map

package/dist/telemetry-consent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry-consent.js","sourceRoot":"","sources":["../src/telemetry-consent.ts"],"names":[],"mappings":"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"}

package/dist/telemetry.d.ts

@@ -0,0 +1,22 @@
+/** One reportable fact about a collector run. `kind` is the event class. */
+export interface TelemetryEvent {
+    kind: string;
+    /** Numbers only, plus the few enumerated strings below. No free text. */
+    [k: string]: string | number | boolean | undefined;
+}
+/**
+ * Record an event. Cheap and synchronous — it never blocks the caller and never
+ * throws, because a measurement must not be able to break the thing it measures.
+ */
+export declare function record(event: TelemetryEvent): void;
+/** Pending events, for tests and `doctor`. */
+export declare function pending(): readonly TelemetryEvent[];
+export declare function _clearForTests(): void;
+/**
+ * Ship whatever is queued to every eligible target, then clear.
+ *
+ * Called after a sync completes — the connection is warm, the numbers are final,
+ * and there is no separate schedule to get wrong.
+ */
+export declare function flush(): Promise<void>;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"AAqCA,4EAA4E;AAC5E,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,yEAAyE;IACzE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;CACpD;AAKD;;;GAGG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAWlD;AAED,8CAA8C;AAC9C,wBAAgB,OAAO,IAAI,SAAS,cAAc,EAAE,CAAkB;AACtE,wBAAgB,cAAc,IAAI,IAAI,CAAsB;AAE5D;;;;;GAKG;AACH,wBAAsB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAsC3C"}

package/dist/telemetry.js

@@ -0,0 +1,125 @@
+/**
+ * Report how the COLLECTOR is doing, to the user's own server.
+ *
+ * ── Why this exists ──────────────────────────────────────────────────────
+ * Every performance fact known about this product came from one developer
+ * machine. "How long does a first sync take for a customer with 5,000 sessions?"
+ * had no answer, because nothing measured a customer. The collector already
+ * computes everything needed — walk duration, sessions considered, bytes shipped,
+ * 429 counts, breaker trips, RSS peak — and then throws it away.
+ *
+ * ── What it is not ───────────────────────────────────────────────────────
+ * Not analytics, not usage tracking, not anything about what the user is doing.
+ * `assertNoSensitiveKeys` refuses a payload carrying a path, project, session id,
+ * prompt or content key, so the promise is enforced by the type of failure a
+ * developer cannot ignore rather than by review.
+ *
+ * ── Gates ────────────────────────────────────────────────────────────────
+ * Both must open (see telemetry-consent.ts): the user has not opted out, AND the
+ * server says this tenant's plan includes it. The server checks the plan again at
+ * ingest, so this gate exists to stop the data LEAVING a machine that should not
+ * send it — the client is never the boundary.
+ *
+ * ── Failure policy ───────────────────────────────────────────────────────
+ * Fire-and-forget, and silent. Telemetry that logs its own failures produces
+ * noise about the thing that was supposed to reduce noise, and a collector must
+ * never fail a sync because it could not report on the sync.
+ */
+import { hostname, platform } from 'os';
+import { mayReport, assertNoSensitiveKeys } from './telemetry-consent.js';
+import { fetchWithTimeout } from './http.js';
+import { loadAllCredentials } from './sync-client.js';
+const cliVersion = () => {
+    try {
+        return typeof __CLI_VERSION__ === 'string' ? __CLI_VERSION__ : 'dev';
+    }
+    catch {
+        return 'dev';
+    }
+};
+const MAX_QUEUE = 50;
+const queue = [];
+/**
+ * Record an event. Cheap and synchronous — it never blocks the caller and never
+ * throws, because a measurement must not be able to break the thing it measures.
+ */
+export function record(event) {
+    try {
+        assertNoSensitiveKeys(event);
+    }
+    catch (err) {
+        // A forbidden key is a developer error, not a runtime condition. Loud in
+        // development, dropped in production — never sent either way.
+        if (process.env.NODE_ENV !== 'production')
+            throw err;
+        return;
+    }
+    if (queue.length >= MAX_QUEUE)
+        queue.shift(); // newest matter most
+    queue.push(event);
+}
+/** Pending events, for tests and `doctor`. */
+export function pending() { return queue; }
+export function _clearForTests() { queue.length = 0; }
+/**
+ * Ship whatever is queued to every eligible target, then clear.
+ *
+ * Called after a sync completes — the connection is warm, the numbers are final,
+ * and there is no separate schedule to get wrong.
+ */
+export async function flush() {
+    if (queue.length === 0)
+        return;
+    let targets = [];
+    try {
+        targets = loadAllCredentials();
+    }
+    catch {
+        return;
+    }
+    const eligible = targets.filter((t) => mayReport(t.serverUrl));
+    if (eligible.length === 0) {
+        // Nothing may receive these. Drop them rather than growing a queue that will
+        // never drain — a user who opted out must not accumulate a backlog either.
+        queue.length = 0;
+        return;
+    }
+    const events = queue.map((e) => ({
+        ...e,
+        ts: Date.now(),
+        cliVersion: cliVersion(),
+        os: platform(),
+        // A STABLE, NON-IDENTIFYING machine marker. The server overwrites device_id
+        // from the authenticated token anyway (it is the only side that can resolve
+        // it), so this is a fallback for older servers and is deliberately a hash,
+        // never the hostname itself.
+        deviceId: hashHost(),
+    }));
+    queue.length = 0;
+    await Promise.allSettled(eligible.map(async (t) => {
+        try {
+            await fetchWithTimeout(`${t.serverUrl.replace(/\/+$/, '')}/api/client-events`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    ...(t.token ? { authorization: `Bearer ${t.token}` } : {}),
+                },
+                body: JSON.stringify({ events }),
+            }, 10_000);
+        }
+        catch { /* fire and forget — see the header */ }
+    }));
+}
+/** sha256 of the hostname, first 12 — stable per machine, not reversible. */
+function hashHost() {
+    try {
+        // Lazy so the crypto import is not paid by callers that never report.
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { createHash } = require('node:crypto');
+        return createHash('sha256').update(hostname()).digest('hex').slice(0, 12);
+    }
+    catch {
+        return '';
+    }
+}
+//# sourceMappingURL=telemetry.js.map

package/dist/telemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.js","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"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"}

package/dist/tick-queue.d.ts

@@ -0,0 +1,67 @@
+/**
+ * One background task at a time, in priority order, with same-kind coalescing.
+ *
+ * ── What it replaces ─────────────────────────────────────────────────────
+ * Three independent in-flight booleans — `syncInFlight`, `intentDrainInFlight`,
+ * `codeIndexInFlight`. Each correctly stopped its OWN tick from overlapping
+ * itself, and none of them knew about the others, so a code-intelligence sweep
+ * could run at the same time as a full sync walk and an intent drain. All three
+ * are heavy: the sweep spawns codeindex and holds its output, the walk holds a
+ * session container, the drain copies files. Measured with a sweep and a walk
+ * overlapping, the main thread sat at 80–95% and RSS more than doubled.
+ *
+ * They also could not express what the daemon actually wants: shipping to the
+ * server matters more than refreshing code intelligence, so if both are due, the
+ * sweep should wait.
+ *
+ * ── Semantics ────────────────────────────────────────────────────────────
+ * SERIAL — exactly one task runs at a time.
+ *
+ * COALESCED PER KIND — if a kind is already waiting, a new request for that kind
+ * is dropped rather than queued twice. Both would do the same work against the
+ * same state, and the second would find nothing to do. This preserves what the
+ * booleans got right (no self-overlap) without the "silently skipped" behaviour:
+ * a request that arrives while its kind is RUNNING sets a re-run flag, so a file
+ * change during a walk still gets a walk afterwards instead of being lost.
+ *
+ * PRIORITISED — lower number first, and only among tasks already waiting. A
+ * running task is never preempted; a long sweep still finishes.
+ */
+export type TickKind = string;
+export interface TickQueueOpts {
+    /** Reports every state change; the daemon logs through it. */
+    onError?: (kind: TickKind, err: unknown) => void;
+}
+export declare class TickQueue {
+    private readonly opts;
+    private waiting;
+    private running;
+    /** Kinds that asked to run while they were already running. */
+    private rerun;
+    constructor(opts?: TickQueueOpts);
+    /** The kind currently executing, or null when idle. Diagnostics only. */
+    get active(): TickKind | null;
+    get depth(): number;
+    /**
+     * Ask for `kind` to run. Returns immediately — this is a scheduler, not a
+     * `await`-able task.
+     */
+    request(kind: TickKind, priority: number, run: () => Promise<void>): void;
+    private pump;
+    /** Tests: settle the queue. */
+    drain(): Promise<void>;
+}
+/**
+ * Priorities for the daemon's ticks. Lower runs first.
+ *
+ * Shipping to the server is the product; everything else is enrichment. Code
+ * intelligence is last because it is the heaviest and the least urgent — it
+ * refreshes on a 180-minute cadence, so waiting out a walk costs nothing.
+ */
+export declare const TICK_PRIORITY: {
+    readonly sync: 10;
+    readonly intents: 20;
+    readonly codeIndex: 30;
+    readonly housekeeping: 40;
+};
+//# sourceMappingURL=tick-queue.d.ts.map

package/dist/tick-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tick-queue.d.ts","sourceRoot":"","sources":["../src/tick-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAQ9B,MAAM,WAAW,aAAa;IAC5B,8DAA8D;IAC9D,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;CAClD;AAED,qBAAa,SAAS;IAMR,OAAO,CAAC,QAAQ,CAAC,IAAI;IALjC,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,OAAO,CAAyB;IACxC,+DAA+D;IAC/D,OAAO,CAAC,KAAK,CAAuB;gBAEP,IAAI,GAAE,aAAkB;IAErD,yEAAyE;IACzE,IAAI,MAAM,IAAI,QAAQ,GAAG,IAAI,CAAyB;IACtD,IAAI,KAAK,IAAI,MAAM,CAAgC;IAEnD;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;YAY3D,IAAI;IAuBlB,+BAA+B;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAK7B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;CAKhB,CAAC"}

package/dist/tick-queue.js

@@ -0,0 +1,104 @@
+/**
+ * One background task at a time, in priority order, with same-kind coalescing.
+ *
+ * ── What it replaces ─────────────────────────────────────────────────────
+ * Three independent in-flight booleans — `syncInFlight`, `intentDrainInFlight`,
+ * `codeIndexInFlight`. Each correctly stopped its OWN tick from overlapping
+ * itself, and none of them knew about the others, so a code-intelligence sweep
+ * could run at the same time as a full sync walk and an intent drain. All three
+ * are heavy: the sweep spawns codeindex and holds its output, the walk holds a
+ * session container, the drain copies files. Measured with a sweep and a walk
+ * overlapping, the main thread sat at 80–95% and RSS more than doubled.
+ *
+ * They also could not express what the daemon actually wants: shipping to the
+ * server matters more than refreshing code intelligence, so if both are due, the
+ * sweep should wait.
+ *
+ * ── Semantics ────────────────────────────────────────────────────────────
+ * SERIAL — exactly one task runs at a time.
+ *
+ * COALESCED PER KIND — if a kind is already waiting, a new request for that kind
+ * is dropped rather than queued twice. Both would do the same work against the
+ * same state, and the second would find nothing to do. This preserves what the
+ * booleans got right (no self-overlap) without the "silently skipped" behaviour:
+ * a request that arrives while its kind is RUNNING sets a re-run flag, so a file
+ * change during a walk still gets a walk afterwards instead of being lost.
+ *
+ * PRIORITISED — lower number first, and only among tasks already waiting. A
+ * running task is never preempted; a long sweep still finishes.
+ */
+export class TickQueue {
+    opts;
+    waiting = [];
+    running = null;
+    /** Kinds that asked to run while they were already running. */
+    rerun = new Set();
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    /** The kind currently executing, or null when idle. Diagnostics only. */
+    get active() { return this.running; }
+    get depth() { return this.waiting.length; }
+    /**
+     * Ask for `kind` to run. Returns immediately — this is a scheduler, not a
+     * `await`-able task.
+     */
+    request(kind, priority, run) {
+        if (this.running === kind) {
+            // Its state changed underneath it; run once more when it finishes rather
+            // than dropping the request (a file change during a walk must not be lost).
+            this.rerun.add(kind);
+            return;
+        }
+        if (this.waiting.some((w) => w.kind === kind))
+            return; // coalesced
+        this.waiting.push({ kind, priority, run });
+        void this.pump();
+    }
+    async pump() {
+        if (this.running !== null)
+            return;
+        const next = this.waiting
+            .map((w, i) => ({ w, i }))
+            .sort((a, b) => (a.w.priority - b.w.priority) || (a.i - b.i))[0];
+        if (!next)
+            return;
+        this.waiting.splice(next.i, 1);
+        const { kind, priority, run } = next.w;
+        this.running = kind;
+        try {
+            await run();
+        }
+        catch (err) {
+            this.opts.onError?.(kind, err);
+        }
+        finally {
+            this.running = null;
+            if (this.rerun.delete(kind)) {
+                // Re-queue at its own priority; it takes its turn like anything else.
+                this.waiting.push({ kind, priority, run });
+            }
+            void this.pump();
+        }
+    }
+    /** Tests: settle the queue. */
+    async drain() {
+        while (this.running !== null || this.waiting.length > 0) {
+            await new Promise((r) => setImmediate(r));
+        }
+    }
+}
+/**
+ * Priorities for the daemon's ticks. Lower runs first.
+ *
+ * Shipping to the server is the product; everything else is enrichment. Code
+ * intelligence is last because it is the heaviest and the least urgent — it
+ * refreshes on a 180-minute cadence, so waiting out a walk costs nothing.
+ */
+export const TICK_PRIORITY = {
+    sync: 10,
+    intents: 20,
+    codeIndex: 30,
+    housekeeping: 40,
+};
+//# sourceMappingURL=tick-queue.js.map

package/dist/tick-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tick-queue.js","sourceRoot":"","sources":["../src/tick-queue.ts"],"names":[],"mappings":"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"}

package/dist/transport-safety.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Refuse to ship a transcript over a connection anyone can read.
+ *
+ * ── The hole this closes ─────────────────────────────────────────────────
+ * TLS to the hosted service was never in doubt — valid cert, HSTS for a year,
+ * plain HTTP redirected. But NOTHING in the collector required it. A user who
+ * typed `chat-recall login http://recall.mycompany.com` got exactly what they
+ * asked for: every transcript on the machine, in cleartext, over the open
+ * internet, with no warning at any point. `isLocalHost()` existed to relax
+ * upload pacing for LAN targets, not to gate the scheme, so a public host over
+ * plain HTTP passed every check.
+ *
+ * The payload makes this worse than a generic cleartext warning deserves. A sync
+ * body carries whole transcripts: source code, file paths, and — despite
+ * client-side redaction being good — whatever the detectors did not recognise as
+ * a secret. This is the single highest-value thing the product ever puts on a
+ * wire.
+ *
+ * ── Where the line is ────────────────────────────────────────────────────
+ * Plain HTTP is fine to a host only YOU can reach, and that is the whole
+ * exception. Loopback, mDNS/`.lan` names, RFC1918, IPv6 loopback and ULA, and
+ * the CGNAT range Tailscale hands out — a self-hoster on any of those has no
+ * public path to intercept. Everything else needs TLS.
+ *
+ * `CHAT_RECALL_ALLOW_INSECURE_HTTP=1` overrides it, for the real case this
+ * would otherwise break: a corporate host reached through a VPN whose name and
+ * address both look public. That is a deliberate, per-machine decision, which is
+ * exactly the bar an override like this should meet.
+ */
+/** Hosts only reachable from the user's own machine or network. */
+export declare function isPrivateHost(serverUrl: string): boolean;
+/** Explicit, per-machine opt-out for a VPN-reached host that looks public. */
+export declare function insecureHttpAllowed(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Why this target must not be used, or null when it is safe.
+ *
+ * Pure, so both the login gate and the sync-time gate can share one rule and a
+ * test can pin it without a network.
+ */
+export declare function transportRisk(serverUrl: string, env?: NodeJS.ProcessEnv): string | null;
+/** Throwing form, for the login path. */
+export declare function assertTransportSafe(serverUrl: string, env?: NodeJS.ProcessEnv): void;
+//# sourceMappingURL=transport-safety.d.ts.map

package/dist/transport-safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-safety.d.ts","sourceRoot":"","sources":["../src/transport-safety.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,mEAAmE;AACnE,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAgBxD;AAED,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAGjF;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,GAAG,IAAI,CAWf;AAED,yCAAyC;AACzC,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,IAAI,CAGjG"}

package/dist/transport-safety.js

@@ -0,0 +1,100 @@
+/**
+ * Refuse to ship a transcript over a connection anyone can read.
+ *
+ * ── The hole this closes ─────────────────────────────────────────────────
+ * TLS to the hosted service was never in doubt — valid cert, HSTS for a year,
+ * plain HTTP redirected. But NOTHING in the collector required it. A user who
+ * typed `chat-recall login http://recall.mycompany.com` got exactly what they
+ * asked for: every transcript on the machine, in cleartext, over the open
+ * internet, with no warning at any point. `isLocalHost()` existed to relax
+ * upload pacing for LAN targets, not to gate the scheme, so a public host over
+ * plain HTTP passed every check.
+ *
+ * The payload makes this worse than a generic cleartext warning deserves. A sync
+ * body carries whole transcripts: source code, file paths, and — despite
+ * client-side redaction being good — whatever the detectors did not recognise as
+ * a secret. This is the single highest-value thing the product ever puts on a
+ * wire.
+ *
+ * ── Where the line is ────────────────────────────────────────────────────
+ * Plain HTTP is fine to a host only YOU can reach, and that is the whole
+ * exception. Loopback, mDNS/`.lan` names, RFC1918, IPv6 loopback and ULA, and
+ * the CGNAT range Tailscale hands out — a self-hoster on any of those has no
+ * public path to intercept. Everything else needs TLS.
+ *
+ * `CHAT_RECALL_ALLOW_INSECURE_HTTP=1` overrides it, for the real case this
+ * would otherwise break: a corporate host reached through a VPN whose name and
+ * address both look public. That is a deliberate, per-machine decision, which is
+ * exactly the bar an override like this should meet.
+ */
+/** Hosts only reachable from the user's own machine or network. */
+export function isPrivateHost(serverUrl) {
+    let host = '';
+    try {
+        host = new URL(serverUrl).hostname.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    // IPv6 arrives bracket-stripped from URL.hostname.
+    if (host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '0.0.0.0')
+        return true;
+    if (host.endsWith('.local') || host.endsWith('.lan') || host.endsWith('.internal'))
+        return true;
+    if (/^10\./.test(host))
+        return true; // 10.0.0.0/8
+    if (/^192\.168\./.test(host))
+        return true; // 192.168.0.0/16
+    if (/^172\.(1[6-9]|2\d|3[01])\./.test(host))
+        return true; // 172.16.0.0/12
+    if (/^127\./.test(host))
+        return true; // loopback/8
+    // 100.64.0.0/10 — CGNAT, and what Tailscale assigns. A self-hoster reaching
+    // their box over a tailnet is on a private path by construction.
+    if (/^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./.test(host))
+        return true;
+    if (/^f[cd][0-9a-f]{2}:/.test(host))
+        return true; // IPv6 ULA fc00::/7
+    if (/^fe80:/.test(host))
+        return true; // IPv6 link-local
+    return false;
+}
+/** Explicit, per-machine opt-out for a VPN-reached host that looks public. */
+export function insecureHttpAllowed(env = process.env) {
+    const v = (env.CHAT_RECALL_ALLOW_INSECURE_HTTP || '').trim().toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes';
+}
+/**
+ * Why this target must not be used, or null when it is safe.
+ *
+ * Pure, so both the login gate and the sync-time gate can share one rule and a
+ * test can pin it without a network.
+ */
+export function transportRisk(serverUrl, env = process.env) {
+    let url;
+    try {
+        url = new URL(serverUrl);
+    }
+    catch {
+        return `not a valid server URL: ${serverUrl}`;
+    }
+    if (url.protocol === 'https:')
+        return null;
+    if (url.protocol !== 'http:')
+        return `unsupported scheme '${url.protocol}' — use https://`;
+    if (isPrivateHost(serverUrl))
+        return null; // your own network
+    if (insecureHttpAllowed(env))
+        return null; // deliberate override
+    return `refusing to sync to ${url.host} over plain HTTP — your transcripts, `
+        + 'file paths and any secret the redactor did not catch would cross the '
+        + `internet in cleartext. Use https://${url.host} instead. If this host is `
+        + 'only reachable through a VPN, set CHAT_RECALL_ALLOW_INSECURE_HTTP=1.';
+}
+/** Throwing form, for the login path. */
+export function assertTransportSafe(serverUrl, env = process.env) {
+    const risk = transportRisk(serverUrl, env);
+    if (risk)
+        throw new Error(risk);
+}
+//# sourceMappingURL=transport-safety.js.map

package/dist/transport-safety.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-safety.js","sourceRoot":"","sources":["../src/transport-safety.ts"],"names":[],"mappings":"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"}

package/dist/verify-repair.js

@@ -35,7 +35,7 @@ export function forceFullResync(server, sessionIds) {
     let cleared = 0;
     for (const key of Object.keys(data)) {
         // Ledger keys are prefixed ids for non-Claude tools; match either form.
-        const bare = key.replace(/^(opencode_|gemini_|codex_|agy_)/, '');
+        const bare = key.replace(/^(opencode_|gemini_|codex_|agy_|cursor_)/, '');
         if (!wanted.has(key) && !wanted.has(bare))
             continue;
         const row = data[key];

package/dist/verify-repair.js.map

@@ -1 +1 @@
-{"version":3,"file":"verify-repair.js","sourceRoot":"","sources":["../src/verify-repair.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEpF;qEACqE;AACrE,MAAM,UAAU,eAAe,CAAC,MAAc,EAAE,UAAoB;IAClE,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAEtC,MAAM,IAAI,GAAG,cAAc,EAAE,CAAC;IAC9B,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC9E,IAAI,CAAC;YAAC,YAAY,CAAC,IAAI,EAAE,GAAG,IAAI,QAAQ,KAAK,EAAE,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC,CAAC,wBAAwB,CAAC,CAAC;IACxF,CAAC;IAED,MAAM,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC;IACnC,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACpC,wEAAwE;QACxE,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,kCAAkC,EAAE,EAAE,CAAC,CAAC;QACjE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,SAAS;QACpD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;QACtB,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;YAAC,OAAO,EAAE,CAAC;YAAC,SAAS;QAAC,CAAC;QACvF,MAAM,CAAC,GAAG,GAAyC,CAAC;QACpD,OAAO,CAAC,CAAC,CAAC,CAAC,CAAM,cAAc;QAC/B,OAAO,CAAC,CAAC,CAAC,CAAC,CAAM,sBAAsB;QACvC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAM,4DAA4D;QAC7E,OAAO,CAAC,CAAC,CAAC,CAAC,CAAM,sDAAsD;QACvE,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,OAAO,GAAG,CAAC;QAAE,iBAAiB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACjD,OAAO,OAAO,CAAC;AACjB,CAAC"}
+{"version":3,"file":"verify-repair.js","sourceRoot":"","sources":["../src/verify-repair.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEpF;qEACqE;AACrE,MAAM,UAAU,eAAe,CAAC,MAAc,EAAE,UAAoB;IAClE,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAEtC,MAAM,IAAI,GAAG,cAAc,EAAE,CAAC;IAC9B,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC9E,IAAI,CAAC;YAAC,YAAY,CAAC,IAAI,EAAE,GAAG,IAAI,QAAQ,KAAK,EAAE,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC,CAAC,wBAAwB,CAAC,CAAC;IACxF,CAAC;IAED,MAAM,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC;IACnC,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACpC,wEAAwE;QACxE,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,0CAA0C,EAAE,EAAE,CAAC,CAAC;QACzE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,SAAS;QACpD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;QACtB,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;YAAC,OAAO,EAAE,CAAC;YAAC,SAAS;QAAC,CAAC;QACvF,MAAM,CAAC,GAAG,GAAyC,CAAC;QACpD,OAAO,CAAC,CAAC,CAAC,CAAC,CAAM,cAAc;QAC/B,OAAO,CAAC,CAAC,CAAC,CAAC,CAAM,sBAAsB;QACvC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAM,4DAA4D;QAC7E,OAAO,CAAC,CAAC,CAAC,CAAC,CAAM,sDAAsD;QACvE,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,OAAO,GAAG,CAAC;QAAE,iBAAiB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACjD,OAAO,OAAO,CAAC;AACjB,CAAC"}