@playola-radio/slipstream 0.1.0

package/dist/cas.js

@@ -0,0 +1,99 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { access, open, mkdir, readFile, rename, unlink } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { DIR_MODE, FILE_MODE, StorageError, assertOwnerOnly, fsyncDir, mkdirpDurable, writeAll, } from "./storage.js";
+export async function createCas(rootDir) {
+    const base = join(rootDir, 'sha256');
+    await mkdirpDurable(base);
+    await assertOwnerOnly(rootDir, 'dir');
+    await assertOwnerOnly(base, 'dir');
+    /** sha256 -> durably published (temp+fsync+rename+dir-fsync completed this process). */
+    const durable = new Set();
+    /** shard dirs whose creation has been fsync'd into `base`. */
+    const durableShards = new Set();
+    /** In-flight publishes, keyed by sha, so concurrent same-hash puts share one write. */
+    const inFlight = new Map();
+    const pathFor = (sha256) => join(base, sha256.slice(0, 2), sha256);
+    const has = async (sha256) => {
+        try {
+            await access(pathFor(sha256));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const publish = async (sha256, bytes) => {
+        const dest = pathFor(sha256);
+        const shard = dirname(dest);
+        if (!durableShards.has(shard)) {
+            try {
+                await mkdir(shard, { recursive: true, mode: DIR_MODE });
+            }
+            catch (err) {
+                throw new StorageError('mkdir-shard', err);
+            }
+            await fsyncDir(base); // persist the new shard directory entry
+            durableShards.add(shard);
+        }
+        const tmp = `${dest}.${randomUUID()}.tmp`;
+        let handle;
+        try {
+            try {
+                handle = await open(tmp, 'wx', FILE_MODE);
+                await writeAll(handle, bytes);
+                await handle.sync();
+            }
+            catch (err) {
+                throw new StorageError('write-blob', err);
+            }
+            finally {
+                await handle?.close();
+            }
+            try {
+                await rename(tmp, dest);
+            }
+            catch (err) {
+                throw new StorageError('rename-blob', err);
+            }
+            await fsyncDir(shard); // persist the rename into the shard directory
+        }
+        finally {
+            await unlink(tmp).catch(() => { });
+        }
+        durable.add(sha256);
+        return { sha256, size: bytes.length };
+    };
+    const put = async (bytes) => {
+        const sha256 = createHash('sha256').update(bytes).digest('hex');
+        if (durable.has(sha256))
+            return { sha256, size: bytes.length };
+        const existing = inFlight.get(sha256);
+        if (existing)
+            return existing;
+        const pending = publish(sha256, bytes).finally(() => inFlight.delete(sha256));
+        inFlight.set(sha256, pending);
+        return pending;
+    };
+    const read = (sha256) => readFile(pathFor(sha256));
+    const ensureDurable = async (sha256) => {
+        if (durable.has(sha256))
+            return;
+        const dest = pathFor(sha256);
+        let handle;
+        try {
+            handle = await open(dest, 'r');
+            await handle.sync();
+        }
+        catch (err) {
+            throw new StorageError('fsync-blob', err);
+        }
+        finally {
+            await handle?.close();
+        }
+        await fsyncDir(dirname(dest)); // persist the blob's shard entry
+        durable.add(sha256);
+    };
+    return { put, read, has, ensureDurable, pathFor };
+}
+export { StorageError } from "./storage.js";

package/dist/change-view.js

@@ -0,0 +1,201 @@
+// Renders a `file.changed` event as the file's *current* content, line-numbered,
+// with an `x` beside each changed line and a blank beside unchanged ones — the
+// after-state, not a diff. Unchanged lines far from any change are elided, with
+// a `⋯` marking each gap.
+import { isValidHex } from "./store-reader.js";
+// Control chars must never reach the terminal verbatim: C0 (0x00–0x1f), DEL, and
+// C1 (0x80–0x9f, e.g. U+009B = CSI) are all replaced.
+const sanitize = (s) => s.replace(/[\x00-\x1f\x7f-\x9f]/g, '�');
+// Above this size a content blob is summarized rather than fetched and printed,
+// unless the caller passes `full`.
+const MAX_RENDER_BYTES = 128 * 1024;
+// Above this before×after line-cell product the O(n·m) alignment is skipped and
+// content is shown unmarked, bounding time and memory even under `full`.
+const MAX_ALIGN_CELLS = 8_000_000;
+/** Split file text into display lines. A trailing newline is a line terminator,
+ *  not an extra blank line; empty text is zero lines. */
+export function splitLines(text) {
+    if (text === '')
+        return [];
+    const parts = text.split(/\r?\n/);
+    if (parts[parts.length - 1] === '')
+        parts.pop();
+    return parts;
+}
+/** For each after-line, true if it is NOT part of the longest common subsequence
+ *  with the before-lines — i.e. it is new or replaced rather than carried over. */
+export function markChanges(before, after) {
+    const n = before.length;
+    const m = after.length;
+    const w = m + 1;
+    const dp = new Int32Array((n + 1) * w);
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            dp[i * w + j] = before[i] === after[j]
+                ? dp[(i + 1) * w + (j + 1)] + 1
+                : Math.max(dp[(i + 1) * w + j], dp[i * w + (j + 1)]);
+        }
+    }
+    const changed = new Array(m).fill(true);
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (before[i] === after[j]) {
+            changed[j] = false;
+            i++;
+            j++;
+        }
+        else if (dp[(i + 1) * w + j] >= dp[i * w + (j + 1)])
+            i++;
+        else
+            j++;
+    }
+    return changed;
+}
+/** Render after-content as numbered, marked display lines with `context` lines of
+ *  unchanged context around each changed run and `⋯` between elided gaps. Returns
+ *  [] when nothing changed. */
+export function renderMarkedLines(before, after, context) {
+    const changed = markChanges(before, after);
+    const m = after.length;
+    const visible = new Array(m).fill(false);
+    for (let k = 0; k < m; k++) {
+        if (!changed[k])
+            continue;
+        const lo = Math.max(0, k - context);
+        const hi = Math.min(m - 1, k + context);
+        for (let v = lo; v <= hi; v++)
+            visible[v] = true;
+    }
+    const width = String(m).length;
+    const out = [];
+    let prev = -1;
+    for (let k = 0; k < m; k++) {
+        if (!visible[k])
+            continue;
+        if (prev !== -1 && k > prev + 1)
+            out.push('⋯');
+        out.push(numberedLine(changed[k] ? 'x' : ' ', k + 1, width, after[k]));
+        prev = k;
+    }
+    return out;
+}
+function numberedLine(mark, n, width, text) {
+    return `${mark} ${String(n).padStart(width)} ${sanitize(text)}`;
+}
+/** Render every after-line unmarked (used when the before-side can't be compared). */
+function renderUnmarked(after) {
+    const width = String(after.length).length;
+    return after.map((line, i) => numberedLine(' ', i + 1, width, line));
+}
+function human(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function parseSnapshot(v) {
+    if (typeof v !== 'object' || v === null)
+        return { kind: 'invalid' };
+    const s = v;
+    if (s.kind === 'content') {
+        if (typeof s.sha256 === 'string' && isValidHex(s.sha256)
+            && typeof s.size === 'number' && Number.isInteger(s.size) && s.size >= 0) {
+            return { kind: 'content', sha256: s.sha256, size: s.size };
+        }
+        return { kind: 'invalid' };
+    }
+    if (s.kind === 'absent')
+        return { kind: 'absent' };
+    if (s.kind === 'unavailable' && typeof s.reason === 'string') {
+        return { kind: 'unavailable', reason: s.reason };
+    }
+    return { kind: 'invalid' };
+}
+function sizeSummary(before, afterSize) {
+    const a = human(afterSize);
+    if (before.kind === 'content')
+        return `${human(before.size)} → ${a}`;
+    if (before.kind === 'absent')
+        return `new, ${a}`;
+    return a;
+}
+/** Render one `file.changed` event as a header line plus either the marked
+ *  after-content or an honest one-line note about why it isn't shown. */
+export async function renderChange(ev, getText, opts) {
+    const path = typeof ev.data.path === 'string' ? sanitize(ev.data.path) : '(path unavailable)';
+    // Surface the grouping hint on the header so the changes view has the same task
+    // membership the disk/HTTP readers carry in `data` (parity, not a new view).
+    const hint = typeof ev.data.task_hint_id === 'string' ? ` · task/${sanitize(ev.data.task_hint_id)}` : '';
+    const header = `#${ev.seq.toString()} ${path}${hint}`;
+    const note = (msg) => [header, `  ${msg}`];
+    const cap = opts.full ? Number.POSITIVE_INFINITY : MAX_RENDER_BYTES;
+    const after = parseSnapshot(ev.data.after);
+    if (after.kind === 'invalid')
+        return note('(snapshot missing or malformed)');
+    if (after.kind === 'absent')
+        return note('(deleted)');
+    if (after.kind === 'unavailable')
+        return note(`(content unavailable: ${sanitize(after.reason)})`);
+    if (!opts.full && after.size > MAX_RENDER_BYTES) {
+        return note(`(large file, ${human(after.size)} — content hidden; rerun with --full)`);
+    }
+    const afterBlob = await getText(after.sha256, cap);
+    if (afterBlob.kind === 'missing')
+        return note(`(content unavailable: ${sanitize(afterBlob.reason)})`);
+    if (afterBlob.kind === 'oversize') {
+        return note(`(large file, ${human(afterBlob.size)} — content hidden; rerun with --full)`);
+    }
+    if (afterBlob.kind === 'binary')
+        return note(`(binary, ${sizeSummary(before(ev), after.size)})`);
+    const afterLines = splitLines(afterBlob.text);
+    if (afterLines.length === 0)
+        return note('(empty file)');
+    const beforeSnap = before(ev);
+    const beforeRes = await resolveBefore(beforeSnap, getText, opts, cap);
+    if ('reason' in beforeRes) {
+        if (opts.full)
+            return [header, `  (${beforeRes.reason})`, ...renderUnmarked(afterLines)];
+        return note(`(${beforeRes.reason}; rerun with --full)`);
+    }
+    const beforeLines = beforeRes.lines;
+    if (beforeLines.length * afterLines.length > MAX_ALIGN_CELLS) {
+        if (opts.full)
+            return [header, '  (too large to align; showing content unmarked)', ...renderUnmarked(afterLines)];
+        return note('(too large to compare line-by-line; rerun with --full)');
+    }
+    const body = renderMarkedLines(beforeLines, afterLines, opts.context);
+    if (body.length === 0) {
+        const removed = beforeLines.length - afterLines.length;
+        const msg = removed > 0
+            ? `(${removed} line${removed === 1 ? '' : 's'} removed)`
+            : '(no line-level change; whitespace or newline only)';
+        if (opts.full)
+            return [header, `  ${msg}`, ...renderUnmarked(afterLines)];
+        return note(msg);
+    }
+    // A new file has no baseline, so every line is marked; the note explains why.
+    if (beforeSnap.kind === 'absent')
+        return [header, '  (new file)', ...body];
+    return [header, ...body];
+}
+function before(ev) { return parseSnapshot(ev.data.before); }
+async function resolveBefore(before, getText, opts, cap) {
+    if (before.kind === 'absent')
+        return { lines: [] };
+    if (before.kind === 'unavailable')
+        return { reason: `before unavailable: ${sanitize(before.reason)}` };
+    if (before.kind !== 'content')
+        return { reason: 'before snapshot malformed' };
+    if (!opts.full && before.size > MAX_RENDER_BYTES)
+        return { reason: 'before too large to compare' };
+    const blob = await getText(before.sha256, cap);
+    if (blob.kind === 'missing')
+        return { reason: `before unavailable: ${sanitize(blob.reason)}` };
+    if (blob.kind === 'oversize')
+        return { reason: 'before too large to compare' };
+    if (blob.kind === 'binary')
+        return { reason: 'before was binary' };
+    return { lines: splitLines(blob.text) };
+}

package/dist/claude-root-transcript.js

@@ -0,0 +1,110 @@
+import { constants } from 'node:fs';
+import { open, realpath } from 'node:fs/promises';
+import { HEAD_LINE_CAP, HEAD_SCAN_BYTES, HEAD_SCAN_LINES } from "./transcript/fs-io.js";
+const RUNTIMES = new Map([
+    ['2.1.280', 'sdk-ts'], // Conductor's observed Claude Code launch
+    ['2.1.283', 'sdk-cli'], // Terminal's observed Claude Code launch
+]);
+const FATAL_UTF8 = new TextDecoder('utf8', { fatal: true });
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value : null;
+}
+/**
+ * Verify the explicit root transcript from complete, bounded startup records.
+ * Claude can write cwd-less preamble lines before the first user/attachment
+ * record, and may still be writing the last line while attach reads. Every
+ * complete bounded line is parsed; the first identity record fixes the root
+ * cwd and identity, while later records must not conflict with the binding.
+ */
+export async function verifyClaudeRootTranscript(path, sessionId, worktree) {
+    let handle;
+    try {
+        handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        if (!(await handle.stat()).isFile())
+            return { ok: false, reason: 'unavailable' };
+        // The extra byte distinguishes an exact bound from a head with more records.
+        const bytes = Buffer.alloc(HEAD_SCAN_BYTES + 1);
+        let total = 0;
+        while (total < bytes.length) {
+            const { bytesRead } = await handle.read(bytes, total, bytes.length - total, total);
+            if (bytesRead === 0)
+                break;
+            total += bytesRead;
+        }
+        let start = 0;
+        let lines = 0;
+        let version;
+        let entrypoint;
+        let rootCwd;
+        for (let i = 0; i < total && lines < HEAD_SCAN_LINES; i += 1) {
+            if (bytes[i] !== 0x0a)
+                continue;
+            if (i - start > HEAD_LINE_CAP || i >= HEAD_SCAN_BYTES)
+                return { ok: false, reason: 'gap' };
+            let parsed;
+            try {
+                parsed = record(JSON.parse(FATAL_UTF8.decode(bytes.subarray(start, i))));
+            }
+            catch {
+                return { ok: false, reason: 'gap' };
+            }
+            if (!parsed)
+                return { ok: false, reason: 'gap' };
+            lines += 1;
+            start = i + 1;
+            if (Object.hasOwn(parsed, 'sessionId') && parsed.sessionId !== sessionId)
+                return { ok: false, reason: 'mismatch' };
+            const hasIdentityField = Object.hasOwn(parsed, 'cwd') || Object.hasOwn(parsed, 'version')
+                || Object.hasOwn(parsed, 'entrypoint') || Object.hasOwn(parsed, 'isSidechain');
+            if (!hasIdentityField)
+                continue;
+            if (version === undefined) {
+                if (parsed.sessionId !== sessionId || typeof parsed.cwd !== 'string' || parsed.cwd.length === 0
+                    || typeof parsed.version !== 'string' || parsed.version.length === 0
+                    || typeof parsed.entrypoint !== 'string' || parsed.userType !== 'external'
+                    || parsed.isSidechain !== false || (parsed.type !== 'user' && parsed.type !== 'attachment')) {
+                    return { ok: false, reason: 'mismatch' };
+                }
+                const allowedEntrypoint = RUNTIMES.get(parsed.version);
+                if (allowedEntrypoint === undefined)
+                    return { ok: false, reason: 'unsupported-version' };
+                if (parsed.entrypoint !== allowedEntrypoint)
+                    return { ok: false, reason: 'mismatch' };
+                try {
+                    if (await realpath(parsed.cwd) !== worktree)
+                        return { ok: false, reason: 'mismatch' };
+                }
+                catch {
+                    return { ok: false, reason: 'mismatch' };
+                }
+                version = parsed.version;
+                entrypoint = parsed.entrypoint;
+                rootCwd = parsed.cwd;
+            }
+            else if ((Object.hasOwn(parsed, 'version') && parsed.version !== version)
+                || (Object.hasOwn(parsed, 'entrypoint') && parsed.entrypoint !== entrypoint)
+                || (Object.hasOwn(parsed, 'cwd') && parsed.cwd !== rootCwd)
+                || (Object.hasOwn(parsed, 'userType') && parsed.userType !== 'external')
+                || (Object.hasOwn(parsed, 'isSidechain') && parsed.isSidechain !== false)) {
+                return { ok: false, reason: 'mismatch' };
+            }
+        }
+        if (lines < HEAD_SCAN_LINES && total > HEAD_SCAN_BYTES)
+            return { ok: false, reason: 'gap' };
+        if (lines < HEAD_SCAN_LINES && total - start > HEAD_LINE_CAP)
+            return { ok: false, reason: 'gap' };
+        // A torn record inside the bounded head may still be written; attach is retryable.
+        if (lines < HEAD_SCAN_LINES && start < total)
+            return { ok: false, reason: 'not-yet' };
+        if (version === undefined)
+            return { ok: false, reason: lines === HEAD_SCAN_LINES ? 'gap' : 'not-yet' };
+        return { ok: true };
+    }
+    catch {
+        return { ok: false, reason: 'unavailable' };
+    }
+    finally {
+        await handle?.close();
+    }
+}