@turns/dev 0.0.1

package/dist/auth.js

@@ -0,0 +1,258 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { spawn } from 'node:child_process';
+import WebSocket from 'ws';
+export const DEFAULT_ORIGIN = 'https://turns.dev';
+export const CREDENTIAL_REFRESH_INTERVAL_MS = 24 * 60 * 60 * 1000;
+export function applicationPaths(environment = process.env, platform = process.platform, home = os.homedir()) {
+    const configBase = environment.TURNS_CONFIG_DIR ||
+        (platform === 'win32'
+            ? environment.APPDATA || path.join(home, 'AppData', 'Roaming')
+            : platform === 'darwin'
+                ? path.join(home, 'Library', 'Application Support')
+                : environment.XDG_CONFIG_HOME || path.join(home, '.config'));
+    const stateBase = environment.TURNS_STATE_DIR ||
+        (platform === 'win32'
+            ? environment.LOCALAPPDATA || path.join(home, 'AppData', 'Local')
+            : platform === 'darwin'
+                ? path.join(home, 'Library', 'Application Support')
+                : environment.XDG_STATE_HOME || path.join(home, '.local', 'state'));
+    const configDirectory = path.join(configBase, 'turns');
+    const stateDirectory = path.join(stateBase, 'turns');
+    return {
+        configDirectory,
+        credentials: path.join(configDirectory, 'credentials.json'),
+        machineId: path.join(configDirectory, 'machine-id'),
+        stateDirectory,
+        uploaderState: path.join(stateDirectory, 'native-upload-state.json'),
+        daemonLog: path.join(stateDirectory, 'daemon.log'),
+        linuxService: path.join(home, '.config', 'systemd', 'user', 'turns.service'),
+        macLaunchAgent: path.join(home, 'Library', 'LaunchAgents', 'dev.turns.cli.plist'),
+    };
+}
+export function normalizeOrigin(value = DEFAULT_ORIGIN) {
+    const url = new URL(value || DEFAULT_ORIGIN);
+    if (!['http:', 'https:'].includes(url.protocol))
+        throw new Error('Turns server must use http or https.');
+    url.pathname = '';
+    url.search = '';
+    url.hash = '';
+    return url.toString().replace(/\/$/u, '');
+}
+export function uploadSocketUrl(origin) {
+    const url = new URL('/api/socket', normalizeOrigin(origin));
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    return url.toString();
+}
+function socketUrl(origin, pathname) {
+    const url = new URL(pathname, normalizeOrigin(origin));
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    return url.toString();
+}
+export function readCredentials(paths = applicationPaths()) {
+    try {
+        const value = JSON.parse(fs.readFileSync(paths.credentials, 'utf8'));
+        return value?.accessToken && value?.refreshToken && value?.origin ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCredentials(credentials, paths = applicationPaths()) {
+    fs.mkdirSync(paths.configDirectory, { recursive: true, mode: 0o700 });
+    const temporary = `${paths.credentials}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 0o600 });
+    fs.chmodSync(temporary, 0o600);
+    fs.renameSync(temporary, paths.credentials);
+}
+export function removeCredentials(paths = applicationPaths()) {
+    try {
+        fs.unlinkSync(paths.credentials);
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT')
+            throw error;
+    }
+}
+export function credentialsNeedRefresh(credentials, now = Date.now()) {
+    const refreshedAt = Date.parse(String(credentials?.refreshedAt || credentials?.authenticatedAt || ''));
+    const expiresAt = Date.parse(String(credentials?.expiresAt || ''));
+    return (!Number.isFinite(refreshedAt) ||
+        now - refreshedAt >= CREDENTIAL_REFRESH_INTERVAL_MS ||
+        !Number.isFinite(expiresAt) ||
+        expiresAt - now <= CREDENTIAL_REFRESH_INTERVAL_MS);
+}
+export async function refreshCredentials(credentials, { fetchImpl = fetch, now = Date.now() } = {}) {
+    const response = await fetchImpl(new URL('/api/cli/auth/refresh', credentials.origin), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ refreshToken: credentials.refreshToken }),
+    });
+    const result = (await response.json().catch(() => ({})));
+    if (!response.ok || !result.accessToken || !result.refreshToken || !result.user?.login) {
+        const error = new Error(result.error || `Turns rejected token refresh (HTTP ${response.status}).`);
+        error.code = response.status === 401 ? 'AUTH_REJECTED' : 'AUTH_REFRESH_FAILED';
+        throw error;
+    }
+    return {
+        version: 1,
+        origin: normalizeOrigin(credentials.origin),
+        accessToken: result.accessToken,
+        refreshToken: result.refreshToken,
+        expiresAt: result.expiresAt,
+        user: result.user,
+        authenticatedAt: credentials.authenticatedAt || new Date(now).toISOString(),
+        refreshedAt: new Date(now).toISOString(),
+    };
+}
+export async function exchangeLegacyToken(origin, legacyToken, { fetchImpl = fetch, now = Date.now() } = {}) {
+    const normalized = normalizeOrigin(origin || DEFAULT_ORIGIN);
+    const response = await fetchImpl(new URL('/api/cli/auth/exchange', normalized), {
+        method: 'POST',
+        headers: { authorization: `Bearer ${legacyToken}` },
+    });
+    const result = (await response.json().catch(() => ({})));
+    if (!response.ok || !result.accessToken || !result.refreshToken || !result.user?.login) {
+        throw new Error(result.error || `Turns rejected legacy-token exchange (HTTP ${response.status}).`);
+    }
+    return {
+        version: 1,
+        origin: normalized,
+        accessToken: result.accessToken,
+        refreshToken: result.refreshToken,
+        expiresAt: result.expiresAt,
+        user: result.user,
+        authenticatedAt: new Date(now).toISOString(),
+        refreshedAt: new Date(now).toISOString(),
+    };
+}
+export function openBrowser(url, { environment = process.env, platform = process.platform, spawnImpl = spawn } = {}) {
+    if (environment.TURNS_NO_BROWSER === '1')
+        return false;
+    const command = platform === 'darwin' ? 'open' : platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    try {
+        const child = spawnImpl(command, args, { detached: true, stdio: 'ignore' });
+        child.on?.('error', () => { });
+        child.unref?.();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function waitForAuthentication(socketAddress, { WebSocketImpl = WebSocket, timeoutMs = 10 * 60_000 } = {}) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const socket = new WebSocketImpl(socketAddress, { headers: { 'x-turns-client-kind': 'cli' } });
+        const timer = setTimeout(() => finish(new Error('Timed out waiting for Turns authentication.')), timeoutMs);
+        timer.unref?.();
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                socket.close();
+            }
+            catch { }
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        socket.on('message', (data) => {
+            let message;
+            try {
+                message = JSON.parse(data.toString());
+            }
+            catch {
+                return;
+            }
+            if (message.type === 'waiting')
+                return;
+            if (message.type === 'authenticated' && message.accessToken && message.refreshToken && message.user?.login) {
+                finish(null, message);
+            }
+            else if (message.type === 'error') {
+                finish(new Error(message.error || 'Turns authentication failed.'));
+            }
+        });
+        socket.on('unexpected-response', (_request, response) => {
+            finish(new Error(`Turns rejected authentication (HTTP ${response.statusCode}).`));
+        });
+        socket.on('error', (error) => finish(error));
+        socket.on('close', () => finish(new Error('The authentication connection closed before it completed.')));
+    });
+}
+export async function browserAuthenticate(origin, { fetchImpl = fetch, waitForAuthenticationImpl = waitForAuthentication, openBrowserImpl = openBrowser, output = process.stdout, now = Date.now(), } = {}) {
+    const normalized = normalizeOrigin(origin);
+    const response = await fetchImpl(new URL('/api/cli/auth/start', normalized), { method: 'POST' });
+    const flow = (await response.json().catch(() => ({})));
+    if (!response.ok || (!flow.authUrl && !flow.authPath) || (!flow.socketUrl && !flow.socketPath)) {
+        throw new Error(flow.error || `Could not start Turns authentication (HTTP ${response.status}).`);
+    }
+    const authUrl = flow.authPath ? new URL(flow.authPath, normalized).toString() : flow.authUrl;
+    const authSocket = flow.socketPath ? socketUrl(normalized, flow.socketPath) : flow.socketUrl;
+    const authentication = waitForAuthenticationImpl(authSocket);
+    const opened = openBrowserImpl(authUrl);
+    output.write(`${opened ? 'Opening' : 'Open'} this URL to sign in with GitHub:\n\n  ${authUrl}\n\n`);
+    output.write('Waiting for authentication…\n');
+    const result = await authentication;
+    return {
+        version: 1,
+        origin: normalized,
+        accessToken: result.accessToken,
+        refreshToken: result.refreshToken,
+        expiresAt: result.expiresAt,
+        user: result.user,
+        authenticatedAt: new Date(now).toISOString(),
+        refreshedAt: new Date(now).toISOString(),
+    };
+}
+/** Resolve credentials without contacting the server unless daily refresh is due. */
+export async function authenticate({ origin, forceBrowser = false, interactive = true, paths = applicationPaths(), fetchImpl = fetch, browserAuthenticateImpl = browserAuthenticate, now = Date.now(), } = {}) {
+    const saved = readCredentials(paths);
+    const selectedOrigin = normalizeOrigin(origin || saved?.origin || DEFAULT_ORIGIN);
+    if (!forceBrowser && saved?.origin === selectedOrigin) {
+        if (!credentialsNeedRefresh(saved, now))
+            return saved;
+        try {
+            const refreshed = await refreshCredentials(saved, { fetchImpl, now });
+            writeCredentials(refreshed, paths);
+            return refreshed;
+        }
+        catch (error) {
+            if (!interactive)
+                throw error;
+        }
+    }
+    if (!interactive)
+        throw new Error('Turns authentication is missing or invalid. Run `turns login` in a terminal.');
+    const credentials = await browserAuthenticateImpl(selectedOrigin, { fetchImpl, now });
+    writeCredentials(credentials, paths);
+    return credentials;
+}
+/** Retry an upload-socket rejection with the permanent refresh token first. */
+export async function recoverRejectedCredentials(credentials, { paths = applicationPaths(), fetchImpl = fetch, browserAuthenticateImpl = browserAuthenticate, interactive = true, now = Date.now(), } = {}) {
+    try {
+        const refreshed = await refreshCredentials(credentials, { fetchImpl, now });
+        writeCredentials(refreshed, paths);
+        return refreshed;
+    }
+    catch (error) {
+        if (!interactive)
+            throw error;
+    }
+    return authenticate({
+        origin: credentials.origin,
+        forceBrowser: true,
+        interactive,
+        paths,
+        fetchImpl,
+        browserAuthenticateImpl,
+        now,
+    });
+}

package/dist/daemon.js

@@ -0,0 +1,134 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { applicationPaths } from "./auth.js";
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+/** Resolve linked-worktree installs back to the primary checkout. A service
+ * must not remain pinned to an expendable feature worktree after that branch
+ * has fallen behind or the worktree has been removed. */
+export function canonicalDaemonCliEntry(cliDirectory = HERE) {
+    const built = path.basename(cliDirectory) === 'dist';
+    const cliRoot = built ? path.dirname(cliDirectory) : cliDirectory;
+    const extension = built ? '.js' : path.extname(fileURLToPath(import.meta.url));
+    const localEntry = path.join(cliDirectory, `index${extension}`);
+    const checkout = path.resolve(cliRoot, '..');
+    const dotGit = path.join(checkout, '.git');
+    try {
+        if (fs.statSync(dotGit).isDirectory())
+            return localEntry;
+    }
+    catch { }
+    try {
+        const match = /^gitdir:\s*(.+)\s*$/imu.exec(fs.readFileSync(dotGit, 'utf8'));
+        if (!match)
+            return localEntry;
+        const worktreeGitDirectory = path.resolve(checkout, match[1]);
+        const commonRelative = fs.readFileSync(path.join(worktreeGitDirectory, 'commondir'), 'utf8').trim();
+        const commonGitDirectory = path.resolve(worktreeGitDirectory, commonRelative);
+        const primaryEntry = path.join(path.dirname(commonGitDirectory), 'cli', ...(built ? ['dist'] : []), `index${extension}`);
+        if (fs.statSync(primaryEntry).isFile())
+            return primaryEntry;
+    }
+    catch { }
+    return localEntry;
+}
+export const SYSTEMD_SERVICE_NAME = 'turns.service';
+export const LEGACY_SYSTEMD_SERVICE_NAME = 'turns-native-uploader.service';
+function systemdQuote(value) {
+    return `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('%', '%%')}"`;
+}
+export function linuxServiceUnit({ cliEntry = canonicalDaemonCliEntry(), execPath = process.execPath } = {}) {
+    return `[Unit]
+Description=Continuously upload local AI sessions to turns.dev
+Wants=network-online.target
+After=network-online.target
+
+[Service]
+Type=simple
+# Agent anchors use detached process groups and survive daemon restarts.
+KillMode=process
+WorkingDirectory=%h
+ExecStart=${systemdQuote(execPath)} --max-old-space-size=256 --max-semi-space-size=8 --experimental-strip-types ${systemdQuote(cliEntry)} daemon run
+Restart=on-failure
+RestartSec=5
+Environment=NODE_NO_WARNINGS=1
+
+[Install]
+WantedBy=default.target
+`;
+}
+function systemctl(arguments_, { spawnSyncImpl = spawnSync, allowFailure = false } = {}) {
+    const result = spawnSyncImpl('systemctl', ['--user', ...arguments_], { encoding: 'utf8', stdio: 'pipe' });
+    if (!allowFailure && result.status !== 0) {
+        throw new Error(String(result.stderr || result.stdout || `systemctl ${arguments_.join(' ')} failed`).trim());
+    }
+    return result;
+}
+export function installLinuxDaemon({ paths = applicationPaths(), spawnSyncImpl = spawnSync, } = {}) {
+    fs.mkdirSync(path.dirname(paths.linuxService), { recursive: true, mode: 0o700 });
+    const unit = linuxServiceUnit();
+    const temporary = `${paths.linuxService}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, unit, { mode: 0o644 });
+    fs.renameSync(temporary, paths.linuxService);
+    systemctl(['disable', '--now', LEGACY_SYSTEMD_SERVICE_NAME], { spawnSyncImpl, allowFailure: true });
+    const unitDirectory = path.dirname(paths.linuxService);
+    for (const legacyLink of [
+        path.join(unitDirectory, LEGACY_SYSTEMD_SERVICE_NAME),
+        path.join(unitDirectory, 'default.target.wants', LEGACY_SYSTEMD_SERVICE_NAME),
+    ]) {
+        try {
+            if (fs.lstatSync(legacyLink).isSymbolicLink())
+                fs.unlinkSync(legacyLink);
+        }
+        catch (error) {
+            if (error?.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    systemctl(['daemon-reload'], { spawnSyncImpl });
+    // `enable --now` starts an inactive unit, but deliberately leaves an
+    // already-running unit alone. An install from a different checkout would
+    // therefore rewrite ExecStart while the old daemon kept running until its
+    // next failure or reboot. Enable first, then restart unconditionally so the
+    // process executing after a successful install always matches this unit.
+    systemctl(['enable', SYSTEMD_SERVICE_NAME], { spawnSyncImpl });
+    systemctl(['restart', SYSTEMD_SERVICE_NAME], { spawnSyncImpl });
+    return paths.linuxService;
+}
+export function uninstallLinuxDaemon({ paths = applicationPaths(), spawnSyncImpl = spawnSync, } = {}) {
+    systemctl(['disable', '--now', SYSTEMD_SERVICE_NAME], { spawnSyncImpl, allowFailure: true });
+    try {
+        fs.unlinkSync(paths.linuxService);
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT')
+            throw error;
+    }
+    systemctl(['daemon-reload'], { spawnSyncImpl, allowFailure: true });
+}
+export function linuxDaemonStatus({ spawnSyncImpl = spawnSync } = {}) {
+    const result = systemctl(['is-active', SYSTEMD_SERVICE_NAME], { spawnSyncImpl, allowFailure: true });
+    return {
+        active: result.status === 0 && String(result.stdout).trim() === 'active',
+        status: String(result.stdout || result.stderr || 'unknown').trim(),
+    };
+}
+export function installDaemon(options = {}) {
+    if (process.platform !== 'linux') {
+        throw new Error('Automatic daemon installation is currently supported on Linux with systemd.');
+    }
+    return installLinuxDaemon(options);
+}
+export function uninstallDaemon(options = {}) {
+    if (process.platform !== 'linux') {
+        throw new Error('Automatic daemon removal is currently supported on Linux with systemd.');
+    }
+    return uninstallLinuxDaemon(options);
+}
+export function daemonStatus(options = {}) {
+    if (process.platform !== 'linux')
+        return { active: false, status: 'unsupported' };
+    return linuxDaemonStatus(options);
+}

package/dist/deepseek-trajectories.js

@@ -0,0 +1,196 @@
+import fs from 'node:fs';
+import { zstdDecompressSync } from 'node:zlib';
+const ZSTD_MAGIC = 0xfd2fb528;
+const HEADER_READ_BYTES = 8 * 1024;
+/**
+ * Locate complete frames in DeepSeek Harness's concatenated-zstd container.
+ * An incomplete final frame is deliberately omitted: DSH exposes only the
+ * committed prefix while a durable append is still being written.
+ */
+export function scanDeepseekZstdFrames(buffer, maxFrames = Number.POSITIVE_INFINITY) {
+    const frames = [];
+    let offset = 0;
+    const torn = (start) => ({ frames, tornStart: start });
+    while (offset < buffer.length && frames.length < maxFrames) {
+        const start = offset;
+        if (buffer.length - offset < 4)
+            return torn(start);
+        if (buffer.readUInt32LE(offset) !== ZSTD_MAGIC) {
+            throw new Error(`corrupt DeepSeek trajectory: invalid zstd frame magic at byte ${offset}`);
+        }
+        offset += 4;
+        if (offset === buffer.length)
+            return torn(start);
+        const descriptor = buffer.readUInt8(offset);
+        offset += 1;
+        if ((descriptor & 24) !== 0) {
+            throw new Error(`corrupt DeepSeek trajectory: reserved zstd header bit at byte ${offset - 1}`);
+        }
+        const contentSizeFlag = descriptor >>> 6;
+        const singleSegment = (descriptor & 32) !== 0;
+        const checksum = (descriptor & 4) !== 0;
+        const dictionaryFlag = descriptor & 3;
+        const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+        const contentSizeBytes = contentSizeFlag === 0 ? (singleSegment ? 1 : 0) : 1 << contentSizeFlag;
+        const headerBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+        if (buffer.length - offset < headerBytes)
+            return torn(start);
+        offset += headerBytes;
+        for (;;) {
+            if (buffer.length - offset < 3)
+                return torn(start);
+            const blockHeader = buffer.readUIntLE(offset, 3);
+            offset += 3;
+            const lastBlock = (blockHeader & 1) !== 0;
+            const blockType = (blockHeader >>> 1) & 3;
+            const blockSize = blockHeader >>> 3;
+            if (blockType === 3) {
+                throw new Error(`corrupt DeepSeek trajectory: reserved zstd block type at byte ${offset - 3}`);
+            }
+            const payloadBytes = blockType === 1 ? 1 : blockSize;
+            if (buffer.length - offset < payloadBytes)
+                return torn(start);
+            offset += payloadBytes;
+            if (lastBlock)
+                break;
+        }
+        if (checksum) {
+            if (buffer.length - offset < 4)
+                return torn(start);
+            offset += 4;
+        }
+        frames.push({ start, end: offset });
+    }
+    return { frames };
+}
+function parseHeaderLine(line, file) {
+    let header;
+    try {
+        header = JSON.parse(line);
+    }
+    catch (error) {
+        throw new Error(`invalid DeepSeek trajectory header in ${file}`, { cause: error });
+    }
+    if (!header || header.type !== 'session' || !String(header.id || '').trim()) {
+        throw new Error(`invalid DeepSeek trajectory session header in ${file}`);
+    }
+    return header;
+}
+/** Read only the independently compressed first frame, never the trajectory. */
+export function readDeepseekTrajectoryHeader(file) {
+    if (!file.endsWith('.zstd')) {
+        const descriptor = fs.openSync(file, 'r');
+        try {
+            const buffer = Buffer.alloc(1024 * 1024);
+            const bytes = fs.readSync(descriptor, buffer, 0, buffer.length, 0);
+            const source = buffer.subarray(0, bytes).toString('utf8');
+            const newline = source.indexOf('\n');
+            if (newline < 0)
+                throw new Error(`unfinished DeepSeek trajectory header in ${file}`);
+            return parseHeaderLine(source.slice(0, newline).replace(/\r$/u, ''), file);
+        }
+        finally {
+            fs.closeSync(descriptor);
+        }
+    }
+    const descriptor = fs.openSync(file, 'r');
+    try {
+        let content = Buffer.alloc(HEADER_READ_BYTES);
+        let length = 0;
+        for (;;) {
+            if (length === content.length) {
+                const expanded = Buffer.alloc(content.length * 2);
+                content.copy(expanded);
+                content = expanded;
+            }
+            const bytes = fs.readSync(descriptor, content, length, content.length - length, length);
+            length += bytes;
+            const first = scanDeepseekZstdFrames(content.subarray(0, length), 1).frames[0];
+            if (first) {
+                const plaintext = zstdDecompressSync(content.subarray(first.start, first.end)).toString('utf8');
+                const newline = plaintext.indexOf('\n');
+                if (newline < 0)
+                    throw new Error(`unfinished DeepSeek trajectory header frame in ${file}`);
+                return parseHeaderLine(plaintext.slice(0, newline).replace(/\r$/u, ''), file);
+            }
+            if (bytes === 0)
+                throw new Error(`unfinished DeepSeek trajectory header frame in ${file}`);
+        }
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+/**
+ * Return physical JSONL records from the committed trajectory prefix. Packed
+ * `*-chunks` records intentionally stay packed; the raw reducer consumes the
+ * authoritative surface records and does not need an expanded pre-pass.
+ */
+export function readDeepseekTrajectoryLines(file) {
+    let source;
+    if (file.endsWith('.zstd')) {
+        const compressed = fs.readFileSync(file);
+        const { frames } = scanDeepseekZstdFrames(compressed);
+        source = Buffer.concat(frames.map((frame) => zstdDecompressSync(compressed.subarray(frame.start, frame.end)))).toString('utf8');
+    }
+    else {
+        source = fs.readFileSync(file, 'utf8');
+    }
+    // A plaintext write can be observed midway through its final line. Zstd
+    // frames are committed atomically, but applying the same newline rule keeps
+    // both storage modes equivalent and prevents a transient malformed row.
+    const complete = source.slice(0, source.lastIndexOf('\n') + 1);
+    return complete.split(/\r?\n/u).filter(Boolean);
+}
+/** Bounded-memory variant for the long-lived uploader. Concatenated zstd
+ * frames are decompressed one at a time and plaintext is exposed only through
+ * complete newline-terminated records. */
+export async function* streamDeepseekTrajectoryLines(file) {
+    if (!file.endsWith('.zstd')) {
+        let carry = Buffer.alloc(0);
+        for await (const chunk of fs.createReadStream(file)) {
+            const buffer = carry.length ? Buffer.concat([carry, chunk]) : chunk;
+            let start = 0;
+            for (;;) {
+                const newline = buffer.indexOf(0x0a, start);
+                if (newline < 0)
+                    break;
+                let line = buffer.subarray(start, newline);
+                if (line.at(-1) === 0x0d)
+                    line = line.subarray(0, -1);
+                if (line.length)
+                    yield line.toString('utf8');
+                start = newline + 1;
+            }
+            carry = buffer.subarray(start);
+        }
+        return;
+    }
+    let compressed = Buffer.alloc(0);
+    let plaintextCarry = '';
+    const emitPlaintext = function* (plaintext) {
+        const source = plaintextCarry + plaintext;
+        let start = 0;
+        for (;;) {
+            const newline = source.indexOf('\n', start);
+            if (newline < 0)
+                break;
+            const line = source.slice(start, newline).replace(/\r$/u, '');
+            if (line)
+                yield line;
+            start = newline + 1;
+        }
+        plaintextCarry = source.slice(start);
+    };
+    for await (const chunk of fs.createReadStream(file)) {
+        compressed = compressed.length ? Buffer.concat([compressed, chunk]) : chunk;
+        const { frames } = scanDeepseekZstdFrames(compressed);
+        if (!frames.length)
+            continue;
+        for (const frame of frames) {
+            const plaintext = zstdDecompressSync(compressed.subarray(frame.start, frame.end)).toString('utf8');
+            yield* emitPlaintext(plaintext);
+        }
+        compressed = compressed.subarray(frames.at(-1).end);
+    }
+}

package/dist/directory-policy.js

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import path from 'node:path';
+function canonicalDirectory(value, label) {
+    const resolved = path.resolve(value);
+    let canonical;
+    try {
+        canonical = fs.realpathSync(resolved);
+    }
+    catch {
+        throw new Error(`${label} is unavailable: ${resolved}`);
+    }
+    if (!fs.statSync(canonical).isDirectory())
+        throw new Error(`${label} is not a directory: ${resolved}`);
+    return canonical;
+}
+export function normalizeAllowedDirectories(values = []) {
+    return [...new Set(values.map((value) => canonicalDirectory(value, 'Allowed directory prefix')))];
+}
+export function workingDirectoryIsAllowed(workingDirectory, allowedDirectories = []) {
+    if (!allowedDirectories.length)
+        return true;
+    if (!workingDirectory || !path.isAbsolute(workingDirectory))
+        return false;
+    let canonical;
+    try {
+        canonical = canonicalDirectory(workingDirectory, 'Working directory');
+    }
+    catch {
+        return false;
+    }
+    return allowedDirectories.some((allowed) => {
+        const relative = path.relative(allowed, canonical);
+        return (relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative)));
+    });
+}
+export function assertAllowedWorkingDirectory(workingDirectory, allowedDirectories = []) {
+    if (!workingDirectoryIsAllowed(workingDirectory, allowedDirectories)) {
+        throw new Error(`Working directory is outside the daemon allowlist: ${workingDirectory || '(missing)'}`);
+    }
+    return fs.realpathSync(path.resolve(workingDirectory));
+}