@playcraft/cli 0.1.38-beta → 0.1.39-prod

package/dist/workspace-runtime/server/terminal-host.js

@@ -1,366 +0,0 @@
-import { productionDirectoryBusy } from '../production/controller.js';
-import { createRequire } from 'node:module';
-import { randomUUID } from 'node:crypto';
-import { lstat } from 'node:fs/promises';
-import { StringDecoder } from 'node:string_decoder';
-import { WebSocketServer } from 'ws';
-import { appendTerminalOutput, createTerminalOutputLog, decodeTerminalBytes, runtimeError, terminalClientFrameSchema, terminalOutputSince, } from '@playcraft/common/cloud-workspace/runtime';
-import { resolveWorkspaceFile } from '../workspaces/files.js';
-import { sessionWorkspaceRoot } from '../workspaces/registry.js';
-import { startLauncherProcess } from '../codex/launcher-client.js';
-import { controlTokenMatches, extractControlToken } from './auth.js';
-const require = createRequire(import.meta.url);
-const commands = new WeakMap();
-const hosts = new WeakMap();
-export function setTerminalCommand(state, command) {
-    commands.set(state, command);
-}
-export function terminalHost(state) {
-    let host = hosts.get(state);
-    if (!host) {
-        host = new TerminalHost(state);
-        hosts.set(state, host);
-    }
-    return host;
-}
-export function disposeTerminalHost(state) {
-    hosts.get(state)?.dispose();
-    hosts.delete(state);
-}
-export class TerminalHost {
-    state;
-    disposed = false;
-    sessions = new Map();
-    spawning = new Map();
-    restored;
-    attempted = new Set();
-    closing = new Set();
-    stops = new Map();
-    confirmed = new Set();
-    sockets = new WebSocketServer({ noServer: true });
-    constructor(state) {
-        this.state = state;
-        // An absent in-memory session cannot prove a restored terminal's old process group stopped.
-        this.restored = new Set((state.journal?.listTerminals?.() ?? []).map(terminal => terminal.terminalId));
-    }
-    async handleUpgrade(request, socket, head) {
-        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
-        const match = /^\/runtime\/terminals\/([^/]+)\/connect$/.exec(url.pathname);
-        if (!match || !controlTokenMatches(this.state.config.controlToken, extractControlToken(request.headers))) {
-            rejectUpgrade(socket, 401, runtimeError('unauthenticated', 'control_token_required'));
-            return;
-        }
-        if (this.disposed || this.state.journal.destroyed()) {
-            rejectUpgrade(socket, 409, runtimeError('capability_unavailable', 'runtime_destroyed'));
-            return;
-        }
-        let terminalId;
-        try {
-            terminalId = decodeURIComponent(match[1]);
-        }
-        catch {
-            rejectUpgrade(socket, 404, { error: 'terminal_not_found' });
-            return;
-        }
-        const terminal = this.state.journal.getTerminal(terminalId);
-        if (!terminal) {
-            rejectUpgrade(socket, 404, { error: 'terminal_not_found' });
-            return;
-        }
-        if (await productionDirectoryBusy(this.state, terminal.workspaceId, terminal.directoryName)) {
-            rejectUpgrade(socket, 409, { error: 'batch_workspace_readonly' });
-            return;
-        }
-        if (terminal.status === 'destroyed') {
-            rejectUpgrade(socket, 409, runtimeError('capability_unavailable', 'terminal_destroyed'));
-            return;
-        }
-        if (this.closing.has(terminalId) || this.restored.has(terminalId) && !this.sessions.has(terminalId)) {
-            rejectUpgrade(socket, 409, runtimeError('capability_unavailable', 'terminal_stop_unconfirmed'));
-            return;
-        }
-        let session = this.sessions.get(terminal.terminalId);
-        if (!session) {
-            try {
-                let pending = this.spawning.get(terminal.terminalId);
-                if (!pending) {
-                    pending = terminalDirectory(this.state, terminal).then((cwd) => this.spawn(terminal, cwd))
-                        .finally(() => this.spawning.delete(terminal.terminalId));
-                    this.spawning.set(terminal.terminalId, pending);
-                }
-                session = await pending;
-            }
-            catch {
-                rejectUpgrade(socket, 409, runtimeError('capability_unavailable', 'pty_unavailable'));
-                return;
-            }
-        }
-        if (this.disposed || this.state.journal.destroyed() || this.closing.has(terminalId) || this.state.journal.getTerminal(terminalId)?.status === 'destroyed') {
-            if (!this.closing.has(terminalId))
-                this.revoke(terminalId, 'terminal_destroyed');
-            rejectUpgrade(socket, 409, runtimeError('capability_unavailable', 'terminal_destroyed'));
-            return;
-        }
-        const active = session;
-        this.sockets.handleUpgrade(request, socket, head, (ws) => this.attach(active, ws));
-    }
-    destroy(terminalId) {
-        const pending = this.stops.get(terminalId);
-        if (pending)
-            return pending;
-        this.closing.add(terminalId);
-        const stopped = (async () => {
-            await this.spawning.get(terminalId);
-            const session = this.sessions.get(terminalId);
-            if (session)
-                await session.stop();
-            else if (!this.confirmed.has(terminalId) && (this.restored.has(terminalId) || this.attempted.has(terminalId)))
-                throw new Error('terminal_stop_unconfirmed');
-            const terminal = this.state.journal.getTerminal(terminalId);
-            if (!terminal)
-                throw new Error('terminal_not_found');
-            const destroyed = terminal.status === 'destroyed' ? terminal : await this.state.journal.putTerminal({
-                ...terminal, status: 'destroyed', destroyedAt: new Date().toISOString(),
-            });
-            this.confirmed.add(terminalId);
-            this.revoke(terminalId, 'terminal_destroyed');
-            this.closing.delete(terminalId);
-            return destroyed;
-        })().finally(() => this.stops.delete(terminalId));
-        this.stops.set(terminalId, stopped);
-        return stopped;
-    }
-    revoke(terminalId, reason) {
-        const session = this.sessions.get(terminalId);
-        if (!session)
-            return;
-        this.sessions.delete(terminalId);
-        const frame = { type: 'revoked', reason };
-        for (const listener of session.listeners)
-            listener(frame);
-        session.listeners.clear();
-        try {
-            session.pty.kill();
-        }
-        catch {
-            /* the process may already have exited */
-        }
-    }
-    dispose() {
-        this.disposed = true;
-        for (const terminalId of [...this.sessions.keys()])
-            this.revoke(terminalId, 'runtime_destroyed');
-        this.sockets.close();
-    }
-    async spawn(terminal, cwd) {
-        if (this.disposed)
-            throw new Error('pty_unavailable');
-        if (this.state.config.workspaceMode === 'multi' || process.env.PLAYCRAFT_LAUNCHER_SOCKET
-            || process.getuid?.() === 1500) {
-            // User shells require the root launcher's fixed development account, even when an
-            // alternative command is installed for local tests. Never fall back to the control user.
-            const socketPath = process.env.PLAYCRAFT_LAUNCHER_SOCKET;
-            if (!socketPath)
-                throw new Error('pty_unavailable');
-            this.attempted.add(terminal.terminalId);
-            const child = await startLauncherProcess({ socketPath, processId: `terminal-${randomUUID()}`,
-                runtimeEpoch: this.state.runtimeEpoch, cwd, argv: [], env: {}, terminal: { cols: 80, rows: 24 } });
-            if (this.disposed) {
-                await child.stop();
-                throw new Error('pty_unavailable');
-            }
-            const session = { terminalId: terminal.terminalId, streamId: randomUUID(), log: createTerminalOutputLog(), listeners: new Set(),
-                stop: () => child.stop(),
-                pty: { write: (data) => { child.stdin?.write(data); }, resize: child.resize,
-                    kill: () => { void child.stop().catch(() => undefined); } } };
-            const decoder = new StringDecoder('utf8');
-            child.stdout?.on('data', (data) => { const text = decoder.write(data); if (text)
-                publish(session, text); });
-            child.onExit((code) => {
-                const tail = decoder.end();
-                if (tail)
-                    publish(session, tail);
-                const stopped = code === undefined ? Promise.resolve(false) : child.stop().then(() => true, () => false);
-                void stopped.then(confirmed => this.exited(terminal.terminalId, session, confirmed ? code : undefined)).catch(() => undefined);
-            });
-            this.sessions.set(terminal.terminalId, session);
-            return session;
-        }
-        const pty = require('node-pty');
-        const command = commands.get(this.state) ?? defaultShell();
-        let finishExit;
-        let didExit = false;
-        const knownExit = new Promise(resolve => { finishExit = () => { didExit = true; resolve(); }; });
-        this.attempted.add(terminal.terminalId);
-        const session = {
-            terminalId: terminal.terminalId,
-            streamId: randomUUID(),
-            log: createTerminalOutputLog(),
-            listeners: new Set(),
-            pty: pty.spawn(command.file, command.args, {
-                name: 'xterm-256color',
-                cols: 80,
-                rows: 24,
-                cwd,
-                env: shellEnv(command.file, cwd),
-            }),
-            stop: async () => {
-                if (!didExit)
-                    session.pty.kill();
-                let timer;
-                try {
-                    await Promise.race([knownExit, new Promise((_resolve, reject) => {
-                            timer = setTimeout(() => reject(new Error('terminal_stop_unconfirmed')), 3000);
-                        })]);
-                }
-                finally {
-                    clearTimeout(timer);
-                }
-            },
-        };
-        const local = session.pty;
-        local.onData((data) => publish(session, data));
-        local.onExit(({ exitCode, signal }) => { finishExit(); void this.exited(terminal.terminalId, session, exitCode, signal).catch(() => undefined); });
-        this.sessions.set(terminal.terminalId, session);
-        return session;
-    }
-    async exited(terminalId, session, code, signal) {
-        session.exited = { code: code ?? null, ...(signal === undefined ? {} : { signal: String(signal) }) };
-        try {
-            if (code !== undefined) {
-                const terminal = this.state.journal.getTerminal(terminalId);
-                if (terminal && terminal.status !== 'destroyed')
-                    await this.state.journal.putTerminal({
-                        ...terminal, status: 'destroyed', destroyedAt: new Date().toISOString(),
-                    });
-                if (terminal)
-                    this.confirmed.add(terminalId);
-            }
-        }
-        finally {
-            for (const listener of session.listeners)
-                listener(exitFrame(session));
-        }
-    }
-    attach(session, ws) {
-        let open = true;
-        let resumed = false;
-        let cursor = 0;
-        const send = (frame) => {
-            if (open && ws.readyState === ws.OPEN)
-                ws.send(JSON.stringify(frame));
-        };
-        const listener = (frame) => {
-            if (!resumed)
-                return;
-            if (frame.type === 'output') {
-                const end = frame.offset + decodeTerminalBytes(frame.data).length;
-                if (end <= cursor)
-                    return;
-                cursor = Math.max(cursor, end);
-            }
-            send(frame);
-        };
-        session.listeners.add(listener);
-        ws.on('message', (raw) => {
-            let body;
-            try {
-                body = JSON.parse(String(raw));
-            }
-            catch {
-                return;
-            }
-            const parsed = terminalClientFrameSchema.safeParse(body);
-            if (!parsed.success || (session.exited || this.closing.has(session.terminalId)) && parsed.data.type !== 'resume')
-                return;
-            const frame = parsed.data;
-            if (frame.type === 'resume') {
-                if (frame.streamId && frame.streamId !== session.streamId) {
-                    send({ type: 'reset', streamId: session.streamId, offset: session.log.end });
-                    cursor = session.log.end;
-                    resumed = true;
-                    if (session.exited)
-                        send(exitFrame(session));
-                    return;
-                }
-                const since = terminalOutputSince(session.log, frame.offset);
-                if (since.gap)
-                    send({ type: 'gap', streamId: session.streamId, offset: since.offset });
-                for (const item of since.frames) {
-                    send({ type: 'output', streamId: session.streamId, offset: item.offset, data: item.data });
-                }
-                cursor = session.log.end;
-                resumed = true;
-                if (session.exited)
-                    send(exitFrame(session));
-                return;
-            }
-            if (!resumed)
-                return;
-            if (frame.type === 'resize') {
-                session.pty.resize(frame.cols, frame.rows);
-                return;
-            }
-            session.pty.write(Buffer.from(decodeTerminalBytes(frame.data)).toString('utf8'));
-        });
-        const detach = () => {
-            open = false;
-            session.listeners.delete(listener);
-        };
-        ws.on('close', detach);
-        ws.on('error', detach);
-    }
-}
-function publish(session, text) {
-    const before = session.log.end;
-    session.log = appendTerminalOutput(session.log, text);
-    const since = terminalOutputSince(session.log, before);
-    for (const item of since.frames) {
-        const frame = {
-            type: 'output',
-            streamId: session.streamId,
-            offset: item.offset,
-            data: item.data,
-        };
-        for (const listener of session.listeners)
-            listener(frame);
-    }
-}
-function exitFrame(session) {
-    return {
-        type: 'exit',
-        streamId: session.streamId,
-        code: session.exited?.code ?? null,
-        ...(session.exited?.signal ? { signal: session.exited.signal } : {}),
-    };
-}
-async function terminalDirectory(state, terminal) {
-    const root = await sessionWorkspaceRoot(state, terminal.workspaceId, terminal.directoryName);
-    if (!terminal.cwd)
-        return root;
-    const resolved = await resolveWorkspaceFile(root, terminal.cwd);
-    const stat = await lstat(resolved);
-    if (!stat.isDirectory() || stat.isSymbolicLink())
-        throw new Error('pty_unavailable');
-    return resolved;
-}
-function defaultShell() {
-    const shell = process.env.SHELL;
-    const file = shell && shell.startsWith('/') ? shell : '/bin/sh';
-    return { file, args: ['-i'] };
-}
-function shellEnv(file, cwd) {
-    return {
-        PATH: process.env.PATH ?? '/usr/bin:/bin',
-        HOME: process.env.HOME ?? cwd,
-        TERM: 'xterm-256color',
-        LANG: process.env.LANG ?? 'C.UTF-8',
-        SHELL: file,
-    };
-}
-function rejectUpgrade(socket, status, body) {
-    const payload = JSON.stringify(body);
-    const title = status === 401 ? 'Unauthorized' : status === 404 ? 'Not Found' : 'Conflict';
-    socket.write(`HTTP/1.1 ${status} ${title}\r\ncontent-type: application/json; charset=utf-8\r\ncontent-length: ${Buffer.byteLength(payload)}\r\nconnection: close\r\n\r\n${payload}`);
-    socket.destroy();
-}

package/dist/workspace-runtime/server/types.js

@@ -1 +0,0 @@
-export {};

package/dist/workspace-runtime/server/workspace-transfer.js

@@ -1,99 +0,0 @@
-import { createReadStream } from 'node:fs';
-import { stat } from 'node:fs/promises';
-import { pipeline } from 'node:stream/promises';
-import { applyWorkspaceTransfer, createWorkspaceTransfer, WORKSPACE_TRANSFER_MAX_BYTES, WorkspaceTransferError } from '../workspaces/transfer.js';
-import { revisionScope, sessionWorkspaceRoot } from '../workspaces/registry.js';
-import { workspaceDirectoryOccupied } from '../workspaces/directory-maintenance.js';
-import { publishSourceEvents } from './dispatch.js';
-export async function handleWorkspaceTransfer(state, request, response, url) {
-    const workspaceId = url.searchParams.get('workspaceId') ?? undefined;
-    const directoryName = url.searchParams.get('directoryName') ?? 'basic';
-    const root = await sessionWorkspaceRoot(state, workspaceId, directoryName);
-    const controller = new AbortController();
-    const abort = () => controller.abort();
-    const close = () => { if (!response.writableEnded)
-        abort(); };
-    request.once('aborted', abort);
-    response.once('close', close);
-    try {
-        if (request.method === 'GET') {
-            const snapshot = await createWorkspaceTransfer(root);
-            try {
-                controller.signal.throwIfAborted();
-                response.writeHead(200, { 'content-type': 'application/octet-stream', 'cache-control': 'private, no-store',
-                    'content-length': (await stat(snapshot.bundlePath)).size, 'x-content-type-options': 'nosniff',
-                    'x-playcraft-workspace-tree': snapshot.tree, 'x-playcraft-workspace-head': snapshot.head });
-                await pipeline(createReadStream(snapshot.bundlePath), response, { signal: controller.signal });
-            }
-            finally {
-                await snapshot.cleanup();
-            }
-            return;
-        }
-        const expectedTree = request.headers['x-playcraft-workspace-tree'];
-        if (typeof expectedTree !== 'string' || !/^[a-f0-9]{40,64}$/.test(expectedTree))
-            throw new WorkspaceTransferError('invalid_workspace_transfer');
-        if (Number(request.headers['content-length'] ?? 0) > WORKSPACE_TRANSFER_MAX_BYTES)
-            throw new WorkspaceTransferError('workspace_transfer_too_large');
-        const chunks = [];
-        let size = 0;
-        for await (const chunk of request) {
-            size += chunk.length;
-            if (size > WORKSPACE_TRANSFER_MAX_BYTES)
-                throw new WorkspaceTransferError('workspace_transfer_too_large');
-            chunks.push(Buffer.from(chunk));
-        }
-        const directories = directoryName === 'root'
-            ? [...new Set(['root', 'basic', ...(state.journal.getWorkspace(workspaceId ?? '')?.directories ?? []).map(item => item.directoryName)])].sort()
-            : [...new Set(['root', directoryName])].sort();
-        const lockKeys = [...new Set([...directories.map(name => `directory:${workspaceId}:${name}`),
-                ...directories.map(name => `workspace:${revisionScope(state, workspaceId, name) ?? 'single'}`)])];
-        const locked = async (index) => index < lockKeys.length
-            ? state.journal.exclusive(lockKeys[index], () => locked(index + 1))
-            : apply();
-        const apply = async () => {
-            controller.signal.throwIfAborted();
-            if (state.journal.destroyed())
-                throw new WorkspaceTransferError('runtime_destroyed');
-            for (const directory of directories) {
-                if (await workspaceDirectoryOccupied(state, workspaceId ?? 'workspace', directory))
-                    throw new WorkspaceTransferError('workspace_transfer_busy');
-            }
-            return applyWorkspaceTransfer(root, Buffer.concat(chunks, size), expectedTree);
-        };
-        const result = await locked(0);
-        if (result.changedPaths.length > 0) {
-            const groups = new Map([[directoryName, result.changedPaths]]);
-            if (directoryName === 'root')
-                for (const path of result.changedPaths) {
-                    const [directory, ...parts] = path.split('/');
-                    if (directory && directories.includes(directory) && parts.length)
-                        groups.set(directory, [...(groups.get(directory) ?? []), parts.join('/')]);
-                }
-            const events = [];
-            for (const [directory, paths] of groups)
-                events.push(await state.journal.allocateSourceEvent({
-                    runtimeId: state.config.runtimeId, generation: state.config.generation, runtimeEpoch: state.runtimeEpoch,
-                    workspaceId, type: 'files.changed', occurredAt: new Date().toISOString(), payload: { workspaceId, directoryName: directory, paths },
-                }));
-            await publishSourceEvents(state, events);
-        }
-        writeJson(response, 200, result);
-    }
-    catch (error) {
-        if (response.headersSent)
-            response.destroy(error instanceof Error ? error : undefined);
-        else if (!controller.signal.aborted) {
-            const code = error instanceof WorkspaceTransferError ? error.code : 'workspace_transfer_failed';
-            writeJson(response, code === 'workspace_transfer_too_large' ? 413 : code === 'invalid_workspace_transfer' ? 400 : 409, { error: code });
-        }
-    }
-    finally {
-        request.off('aborted', abort);
-        response.off('close', close);
-    }
-}
-function writeJson(response, status, body) {
-    response.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'private, no-store' });
-    response.end(JSON.stringify(body));
-}

package/dist/workspace-runtime/workspaces/archive.js

@@ -1,207 +0,0 @@
-import { constants } from 'node:fs';
-import { lstat, open, opendir, realpath } from 'node:fs/promises';
-import { join, relative, sep } from 'node:path';
-import { Readable, Transform } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import { createDeflateRaw } from 'node:zlib';
-import { isCredentialFile } from './git.js';
-const EXCLUDED_NAMES = new Set(['.git', 'node_modules', '.playcraft.json', '.playcraft-workspace.json']);
-const MAX_SOURCE_BYTES = 2 * 1024 * 1024 * 1024;
-const MAX_ENTRIES = 50_000;
-const UTF8_DESCRIPTOR_FLAGS = 0x0808;
-const CRC_TABLE = Uint32Array.from({ length: 256 }, (_, value) => {
-    let crc = value;
-    for (let bit = 0; bit < 8; bit += 1)
-        crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
-    return crc >>> 0;
-});
-/** Exports working files, including ignored deliverables, without following symbolic links. */
-export async function createWorkspaceArchive(root, options = {}) {
-    const rootReal = await realpath(root);
-    const excludedRoots = await Promise.all((options.excludedRoots ?? []).map(path => realpath(path).catch(() => path)));
-    const entries = [];
-    let bytes = 0;
-    const walk = async (directory) => {
-        options.signal?.throwIfAborted();
-        const info = await lstat(directory);
-        if (!info.isDirectory() || info.isSymbolicLink() || !inside(rootReal, await realpath(directory)))
-            throw new Error('workspace_archive_changed');
-        for await (const entry of await opendir(directory)) {
-            options.signal?.throwIfAborted();
-            if (EXCLUDED_NAMES.has(entry.name) || entry.name.startsWith('.playcraft-credential-'))
-                continue;
-            const target = join(directory, entry.name);
-            const path = relative(rootReal, target).split(sep).join('/');
-            if (isCredentialFile(path) || /(?:^|\/)\.playcraft\/(?:workspace-context(?:\.[^/]*)?|video-replication)(?:\/|$)/.test(path))
-                continue;
-            if (excludedRoots.some(excluded => inside(excluded, target)))
-                continue;
-            const info = await lstat(target);
-            if (info.isSymbolicLink())
-                continue;
-            if (!inside(rootReal, await realpath(target)))
-                throw new Error('workspace_archive_changed');
-            if (info.isDirectory()) {
-                await walk(target);
-                continue;
-            }
-            if (!info.isFile())
-                continue;
-            if (Buffer.byteLength(path) > 65_535 || /[\0\\]/.test(path))
-                throw new Error('workspace_archive_invalid_path');
-            bytes += info.size;
-            if (bytes > (options.maxSourceBytes ?? MAX_SOURCE_BYTES) || entries.length >= (options.maxEntries ?? MAX_ENTRIES))
-                throw new Error('workspace_archive_too_large');
-            entries.push({ path, target, info });
-        }
-    };
-    await walk(rootReal);
-    entries.sort((left, right) => left.path.localeCompare(right.path));
-    return Readable.from(zipFiles(rootReal, entries, options.signal));
-}
-/** Standard ZIP (ZIP archive format, 压缩归档格式) records are streamed with bounded buffers. */
-async function* zipFiles(root, entries, signal) {
-    const central = [];
-    let offset = 0;
-    for (const entry of entries) {
-        signal?.throwIfAborted();
-        if (!inside(root, await realpath(entry.target)))
-            throw new Error('workspace_archive_changed');
-        const handle = await open(entry.target, constants.O_RDONLY | constants.O_NOFOLLOW);
-        try {
-            const info = await handle.stat();
-            if (!info.isFile() || info.dev !== entry.info.dev || info.ino !== entry.info.ino || info.size !== entry.info.size
-                || info.mtimeMs !== entry.info.mtimeMs || info.ctimeMs !== entry.info.ctimeMs)
-                throw new Error('workspace_archive_changed');
-            const name = Buffer.from(entry.path);
-            const stamp = zipTimestamp(info.mtime);
-            const header = Buffer.alloc(30);
-            header.writeUInt32LE(0x04034b50, 0);
-            header.writeUInt16LE(20, 4);
-            header.writeUInt16LE(UTF8_DESCRIPTOR_FLAGS, 6);
-            header.writeUInt16LE(8, 8);
-            header.writeUInt32LE(stamp, 10);
-            header.writeUInt16LE(name.length, 26);
-            const start = offset;
-            yield header;
-            yield name;
-            offset += header.length + name.length;
-            let crc = 0xffffffff;
-            let size = 0;
-            let compressedSize = 0;
-            const checksum = new Transform({ transform(chunk, _encoding, done) {
-                    size += chunk.length;
-                    if (size > info.size) {
-                        done(new Error('workspace_archive_changed'));
-                        return;
-                    }
-                    for (const byte of chunk)
-                        crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
-                    done(null, chunk);
-                } });
-            const compressed = createDeflateRaw();
-            const completion = pipeline(handle.createReadStream({ autoClose: false }), checksum, compressed, { signal });
-            void completion.catch(() => undefined);
-            try {
-                for await (const chunk of compressed) {
-                    signal?.throwIfAborted();
-                    compressedSize += chunk.length;
-                    offset += chunk.length;
-                    yield chunk;
-                }
-                await completion;
-            }
-            finally {
-                compressed.destroy();
-                checksum.destroy();
-                await completion.catch(() => undefined);
-            }
-            if (size !== info.size)
-                throw new Error('workspace_archive_changed');
-            const after = await handle.stat();
-            if (after.size !== info.size || after.mtimeMs !== info.mtimeMs || after.ctimeMs !== info.ctimeMs)
-                throw new Error('workspace_archive_changed');
-            crc = (crc ^ 0xffffffff) >>> 0;
-            const descriptor = Buffer.alloc(16);
-            descriptor.writeUInt32LE(0x08074b50, 0);
-            descriptor.writeUInt32LE(crc, 4);
-            descriptor.writeUInt32LE(compressedSize, 8);
-            descriptor.writeUInt32LE(size, 12);
-            yield descriptor;
-            offset += descriptor.length;
-            const record = Buffer.alloc(46);
-            record.writeUInt32LE(0x02014b50, 0);
-            record.writeUInt16LE(0x0314, 4);
-            record.writeUInt16LE(20, 6);
-            record.writeUInt16LE(UTF8_DESCRIPTOR_FLAGS, 8);
-            record.writeUInt16LE(8, 10);
-            record.writeUInt32LE(stamp, 12);
-            record.writeUInt32LE(crc, 16);
-            record.writeUInt32LE(compressedSize, 20);
-            record.writeUInt32LE(size, 24);
-            record.writeUInt16LE(name.length, 28);
-            record.writeUInt32LE(((info.mode & 0xffff) << 16) >>> 0, 38);
-            record.writeUInt32LE(start, 42);
-            central.push(record, name);
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    const centralStart = offset;
-    for (const record of central) {
-        signal?.throwIfAborted();
-        yield record;
-        offset += record.length;
-    }
-    const end = Buffer.alloc(22);
-    end.writeUInt32LE(0x06054b50, 0);
-    end.writeUInt16LE(entries.length, 8);
-    end.writeUInt16LE(entries.length, 10);
-    end.writeUInt32LE(offset - centralStart, 12);
-    end.writeUInt32LE(centralStart, 16);
-    yield end;
-}
-export async function serveWorkspaceArchive(root, request, response, options = {}) {
-    const controller = new AbortController();
-    const abort = () => controller.abort();
-    const close = () => { if (!response.writableEnded)
-        abort(); };
-    request.once('aborted', abort);
-    response.once('close', close);
-    try {
-        const archive = await createWorkspaceArchive(root, { ...options, signal: controller.signal });
-        response.writeHead(200, {
-            'content-type': 'application/zip', 'content-disposition': 'attachment; filename="workspace.zip"',
-            'cache-control': 'private, no-store', 'x-content-type-options': 'nosniff',
-        });
-        if (request.method === 'HEAD') {
-            archive.destroy();
-            response.end();
-            return;
-        }
-        await pipeline(archive, response, { signal: controller.signal });
-    }
-    catch (error) {
-        if (response.headersSent)
-            response.destroy(error instanceof Error ? error : undefined);
-        else if (!controller.signal.aborted) {
-            const reason = error instanceof Error ? error.message : 'workspace_archive_failed';
-            response.writeHead(reason === 'workspace_archive_too_large' ? 413 : 409, { 'content-type': 'application/json', 'cache-control': 'private, no-store' });
-            response.end(JSON.stringify({ error: reason.startsWith('workspace_archive_') ? reason : 'workspace_archive_failed' }));
-        }
-    }
-    finally {
-        request.off('aborted', abort);
-        response.off('close', close);
-    }
-}
-function inside(root, target) {
-    const path = relative(root, target);
-    return path === '' || (path !== '..' && !path.startsWith(`..${sep}`) && !path.startsWith(sep));
-}
-function zipTimestamp(date) {
-    const year = Math.min(2107, Math.max(1980, date.getUTCFullYear()));
-    return (((year - 1980) << 25) | ((date.getUTCMonth() + 1) << 21) | (date.getUTCDate() << 16)
-        | (date.getUTCHours() << 11) | (date.getUTCMinutes() << 5) | (date.getUTCSeconds() >>> 1)) >>> 0;
-}