@playcraft/cli 0.1.53-beta → 0.1.54

package/dist/video-replication/messages.js

@@ -1,97 +0,0 @@
-const messages = {
-    en: {
-        topic: 'Video understanding and replica comparison with evidence frames',
-        models: 'List authorized video models and supported processing modes',
-        understand: 'Understand a local reference video using a managed video model',
-        jobs: 'Inspect or cancel an existing analysis without submitting new inference',
-        get: 'Read an existing video task state', cancel: 'Explicitly request remote cancellation',
-        workspace: 'Workspace UUID (defaults to the nearest workspace context file)',
-        json: 'Print machine-readable JSON (always enabled)', video: 'Local MP4, MOV or WebM file',
-        question: 'Focused question about the video', context: 'Prior analysis.json for this video',
-        processing: 'auto | agentic | static', fps: 'Static sampling: 1 | 2 | 4 | 8',
-        clip: 'Static clip in original video seconds: start:end',
-        model: 'Authorized model configuration UUID', out: 'Artifact directory',
-        timeout: 'Maximum local wait in seconds; the remote task remains recoverable',
-        resume: 'Resume this existing run UUID; cannot be combined with new inputs',
-        invalidArguments: 'Invalid video command arguments.',
-        workspaceMissing: 'Specify --workspace or run inside a Cloud Workspace checkout.',
-        workspaceMismatch: 'The explicit workspace does not match the checkout context.',
-        videoMissing: 'The video must be a readable regular file.',
-        videoQuota: 'The video exceeds 100 MiB or 180 seconds, or has unsupported dimensions.',
-        videoFormat: 'The file is not a supported MP4, MOV or WebM video.',
-        mediaTool: 'FFmpeg and ffprobe are required. Check the managed runtime installation.',
-        outputConflict: 'The artifact directory belongs to another run. Choose an empty directory.',
-        unsafeOutput: 'The artifact directory contains a linked or unsupported output path.',
-        gitExcludeWarning: 'The local Git ignore rule could not be updated. Video analysis will continue; do not commit .playcraft/video-replication evidence to the repository.',
-        invalidContext: 'The context is invalid or belongs to a different video.',
-        invalidResult: 'The video service returned invalid or incomplete evidence.',
-        sourceChanged: 'The video changed since it was probed or the task was created.',
-        uploadFailed: 'Video upload could not be completed.',
-        modelUnavailable: 'No authorized model supports the requested video processing mode.',
-        resumeMissing: 'The saved request is missing or does not match this run and workspace.',
-        timeoutReached: 'Local waiting ended. Resume this run to check its existing result.',
-        interrupted: 'Interrupted. Remote cancellation was not requested or confirmed.',
-        uncertain: 'The remote outcome is unknown. Check this run; do not submit another analysis.',
-        remoteFailed: 'The remote analysis failed or was cancelled.',
-        failed: 'Video understanding failed. Inspect the saved request and task before retrying.',
-        probing: 'Inspecting the video', uploading: 'Uploading the video',
-        preparing: 'Preparing the video command', loadingModels: 'Loading authorized video models',
-        initializingUpload: 'Initializing the video upload', finalizingUpload: 'Validating the uploaded video',
-        failureStage: 'Stage', failureReason: 'Reason', mediaExit: 'Media tool exit status',
-        mediaTimedOut: 'Media tool timed out', mediaOutputLimit: 'Media tool output exceeded the limit',
-        submitting: 'Submitting the analysis', waiting: 'Waiting for the existing analysis',
-        extracting: 'Extracting evidence frames',
-        summary: 'Summary', observations: 'Observed facts', events: 'Events',
-        inferences: 'Inferences', unknowns: 'Unknowns', hints: 'Reconstruction suggestions',
-        evidence: 'Evidence', entities: 'Entities', assets: 'Assets', rules: 'Candidate rules',
-        transcriptNotice: 'Observed events cover only the demonstrated video. Inferred controls and hidden rules remain uncertain.',
-    },
-    zh: {
-        topic: '视频理解与复刻比较，抽取证据关键帧',
-        models: '列出有权使用的视频模型和处理模式',
-        understand: '使用受管视频模型理解本地参考视频',
-        jobs: '核对或取消已有任务，不新建推理', get: '读取已有视频任务状态', cancel: '明确请求远端取消',
-        workspace: '工作区编号，默认读取最近的工作区上下文文件',
-        json: '输出机器可读的 JSON（始终启用）', video: '本地 MP4、MOV 或 WebM 文件',
-        question: '需要确认的视频问题', context: '同一视频的已有 analysis.json',
-        processing: 'auto | agentic | static', fps: '静态抽样：1 | 2 | 4 | 8',
-        clip: '原视频上的静态片段秒数：开始:结束', model: '有权使用的模型配置编号', out: '制品输出目录',
-        timeout: '本地等待的最长秒数，远端任务仍可恢复', resume: '恢复已有任务编号，不能与新输入组合使用',
-        invalidArguments: '视频命令参数无效。', workspaceMissing: '请指定 --workspace，或在云端工作区目录内运行。',
-        workspaceMismatch: '指定的工作区与当前目录的工作区上下文不一致。',
-        videoMissing: '视频必须是可读的普通文件。', videoQuota: '视频超出 100 MiB、180 秒或支持的画面尺寸。',
-        videoFormat: '文件不是支持的 MP4、MOV 或 WebM 视频。', mediaTool: '需要 FFmpeg 和 ffprobe，请检查受管运行环境安装。',
-        outputConflict: '输出目录属于另一轮任务，请使用空目录。', invalidContext: '上下文无效，或属于另一份视频。',
-        unsafeOutput: '制品目录包含符号链接或不支持的输出路径。',
-        gitExcludeWarning: '无法更新 Git 本地忽略规则。视频分析将继续，请勿将 .playcraft/video-replication 证据提交到仓库。',
-        invalidResult: '视频服务返回的证据无效或不完整。', sourceChanged: '视频在探测后或任务创建后发生了变化。',
-        uploadFailed: '视频上传未完成。', modelUnavailable: '没有有权使用且支持所需视频模式的模型。',
-        resumeMissing: '找不到保存的请求，或请求与任务、工作区不一致。',
-        timeoutReached: '本地等待结束，请恢复此任务核对已有结果。',
-        interrupted: '操作已中断，尚未请求或确认远端取消。',
-        uncertain: '远端结果未知，请核对此任务，不要另建分析。', remoteFailed: '远端分析失败或已取消。',
-        failed: '视频理解失败，请先核对已保存的请求和任务再重试。',
-        probing: '正在探测视频', uploading: '正在上传视频', submitting: '正在提交分析',
-        preparing: '正在准备视频命令', loadingModels: '正在加载有权使用的视频模型',
-        initializingUpload: '正在初始化视频上传', finalizingUpload: '正在校验已上传的视频',
-        failureStage: '失败阶段', failureReason: '具体原因', mediaExit: '媒体工具退出状态',
-        mediaTimedOut: '媒体工具执行超时', mediaOutputLimit: '媒体工具输出超出限制',
-        waiting: '正在等待已有分析', extracting: '正在抽取证据关键帧',
-        summary: '概述', observations: '观察事实', events: '事件', inferences: '推断', unknowns: '未知项',
-        hints: '复刻建议', evidence: '证据', entities: '实体', assets: '素材', rules: '候选规则',
-        transcriptNotice: '观察事件仅覆盖视频展示的路径；操作方式和隐藏规则的推断仍需确认。',
-    },
-};
-export function videoMessage(key) {
-    const locale = process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en';
-    return messages[locale.startsWith('zh') ? 'zh' : 'en'][key];
-}
-export class VideoCliError extends Error {
-    code;
-    exitCode;
-    constructor(code, exitCode = 4, options) {
-        super(videoMessage(code), options);
-        this.code = code;
-        this.exitCode = exitCode;
-    }
-}

package/dist/workspace/messages.js

@@ -1,67 +0,0 @@
-const messages = {
-    en: {
-        description: 'Download cloud workspaces and push local commits back',
-        clone: 'Clone the current workspace files, including uncommitted changes',
-        push: 'Push local commits back; reject concurrent cloud changes',
-        workspaceId: 'Cloud workspace identifier', directory: 'Engineering directory, or root for the whole workspace',
-        target: 'Local checkout directory', url: 'PlayCraft service base address, including any environment prefix',
-        token: 'Personal access token', json: 'Print structured output',
-        invalidTarget: 'Invalid workspace identifier, directory, or service address.',
-        directoryExists: 'The target directory already exists. Choose an empty new directory.',
-        metadataMissing: 'No workspace checkout metadata found. Run workspace clone first.',
-        cleanRequired: 'Commit or discard local changes before running workspace push.',
-        notReady: 'Workspace access is not ready. Open the workspace and retry.',
-        conflict: 'Cloud files changed since this checkout. Clone again and merge your changes before pushing.',
-        failed: 'Workspace transfer failed', cloned: 'Workspace cloned:', pushed: 'Local commits pushed to the cloud workspace.',
-        tooLarge: 'The service rejected this transfer because of its size. Check the workspace quota and the service upload configuration; direct download cannot upload your changes.',
-        byteCount: '{value} bytes',
-        quotaExceeded: 'Push would use {actual}, exceeding the workspace quota of {limit}. Reduce the committed files or ask an administrator to increase the quota. Cloud files were not changed.',
-        diskFull: 'Insufficient disk space for transfer staging or file replacement. Required: {actual}; available after reserved space: {limit}. Free disk space and retry.',
-        diskFullUnknown: 'The disk filled while preparing or applying the transfer. Free disk space on the local computer or sandbox and retry. Your local commits are preserved.',
-        diskUnavailable: 'Could not check available workspace storage. Retry or ask an administrator to check the sandbox disk.',
-        proxyTooLarge: 'The upload gateway rejected the transfer (413). Ask an administrator to increase the gateway upload limit; direct download cannot upload your changes.',
-        timeout: 'Workspace transfer timed out. Your local commits are preserved. Retry the push to confirm its result; ask an administrator to check service timeouts if it repeats.',
-        network: 'Could not reach the workspace service. Check the service address and your connection, then retry. Your local commits are preserved.',
-        busy: 'The workspace has an active task, terminal, or file write. Wait for it to finish, then retry the push.',
-        gitMissing: 'Git is not installed or is unavailable on the command path. Install Git and retry.',
-        gitFailed: 'Git could not prepare or apply the workspace transfer. Check local repository integrity and available disk space; retry or contact an administrator.',
-        baseMissing: 'The original workspace snapshot is missing from this local repository. Clone the workspace again and merge your local files before pushing.',
-        invalidTransfer: 'The workspace contains an unsupported path, symbolic link, or invalid transfer data. Check the committed files before retrying.',
-        upgradeRequired: 'This server does not support incremental workspace transfer. Upgrade the server before pushing with this command.',
-        preflight: 'Push preflight passed: {files} files, {bytes} of content. Preparing incremental transfer.',
-        upload: 'Uploading incremental transfer: {bytes}.',
-        login: 'Log in to the target environment using playcraft login --url',
-    },
-    zh: {
-        description: '下载云工作区，并将本地提交推送回来', clone: '克隆当前工作区文件，包含尚未提交的修改',
-        push: '把本地提交推送回来；云端有新修改时拒绝覆盖', workspaceId: '云工作区标识',
-        directory: '工程目录；root 表示整个工作区', target: '本地克隆目录',
-        url: 'PlayCraft 服务基址，保留环境路径前缀', token: '个人访问令牌', json: '输出结构化结果',
-        invalidTarget: '工作区标识、目录或服务地址无效。', directoryExists: '目标目录已存在，请选择新的目录。',
-        metadataMissing: '未找到工作区克隆信息，请先运行 workspace clone。', cleanRequired: '请先提交或丢弃本地修改，再运行 workspace push。',
-        notReady: '工作区访问尚未就绪，请打开工作区后重试。', conflict: '云端文件在克隆后发生变化，请重新克隆并合并本地修改后再推送。',
-        failed: '工作区传输失败', cloned: '工作区已克隆到：', pushed: '本地提交已推送回云工作区。',
-        tooLarge: '服务端因大小拒绝了本次传输。请检查工作区配额及服务上传配置；直接下载无法把本地修改推回云端。',
-        byteCount: '{value} 字节',
-        quotaExceeded: '推送后工作区将占用 {actual}，超过配额 {limit}。请减少已提交的文件，或联系管理员提高配额。云端文件未被修改。',
-        diskFull: '暂存传输包或替换文件所需的磁盘空间不足。需要 {actual}；保留余量后可用 {limit}。请释放磁盘空间后重试。',
-        diskFullUnknown: '准备或应用传输时磁盘已满。请释放本机或沙箱磁盘空间后重试，本地提交已保留。',
-        diskUnavailable: '无法检查工作区存储空间。请重试，或联系管理员检查沙箱磁盘。',
-        proxyTooLarge: '上传网关拒绝了本次传输（413）。请联系管理员提高网关上传上限；直接下载无法把本地修改推回云端。',
-        timeout: '工作区传输超时。本地提交已保留，可重试推送以确认结果；若持续发生，请联系管理员检查服务超时配置。',
-        network: '无法连接工作区服务。请检查服务地址和网络后重试，本地提交已保留。',
-        busy: '工作区有正在执行的任务、终端或文件写入。请等待结束后重试推送。',
-        gitMissing: '未安装 Git 或命令路径中无法找到 Git。请安装后重试。',
-        gitFailed: 'Git 无法准备或应用工作区传输。请检查本地仓库完整性及磁盘空间，重试或联系管理员。',
-        baseMissing: '本地仓库缺少最初的工作区快照。请重新克隆工作区，并合并本地文件后再推送。',
-        invalidTransfer: '工作区包含不支持的路径、符号链接或无效传输数据。请检查已提交文件后重试。',
-        upgradeRequired: '当前服务端尚不支持工作区增量传输。请升级服务端后再使用此命令推送。',
-        preflight: '推送预检查通过：{files} 个文件，内容共 {bytes}。正在准备增量传输。',
-        upload: '正在上传增量传输包：{bytes}。',
-        login: '请使用 playcraft login --url 登录目标环境',
-    },
-};
-export function workspaceMessage(key, values = {}) {
-    const locale = process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en';
-    return messages[locale.startsWith('zh') ? 'zh' : 'en'][key].replace(/\{(\w+)\}/g, (placeholder, name) => String(values[name] ?? placeholder));
-}

package/dist/workspace/transfer-client.js

@@ -1,237 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { createReadStream, createWriteStream, existsSync } from 'node:fs';
-import { mkdir, mkdtemp, readFile, rm, stat, statfs, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { Readable, Transform } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import { RESOURCE_GRANT_ACTIONS, workspaceSessionScopeSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { PlayCraftHttpClient } from '../utils/playcraft-http-client.js';
-import { createWorkspacePushTransfer, inspectWorkspaceCommit, RAW_ATTRIBUTES, runTransferGit, transferGit } from '../workspace-runtime/workspaces/transfer.js';
-import { workspaceMessage as message } from './messages.js';
-import { normalizeWorkspaceTransferError, transferByteCount, workspaceTransferFailure } from './transfer-errors.js';
-const META_FILE = '.playcraft-workspace.json';
-export function workspaceServiceUrl(baseUrl, path) {
-    const base = new URL(baseUrl);
-    if (!['http:', 'https:'].includes(base.protocol) || base.username || base.password || base.search || base.hash)
-        throw new Error(message('invalidTarget'));
-    return `${base.toString().replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`;
-}
-async function request(client, path, init = {}) {
-    const headers = new Headers(init.headers);
-    headers.set('Authorization', `Bearer ${client.token}`);
-    headers.set('X-Request-Id', client.requestId);
-    let response;
-    try {
-        response = await fetch(workspaceServiceUrl(client.baseUrl, path), {
-            ...init, headers, redirect: 'error', signal: AbortSignal.timeout(15 * 60_000),
-        });
-    }
-    catch (error) {
-        throw normalizeWorkspaceTransferError(error);
-    }
-    if (response.ok)
-        return response;
-    const body = await response.json().catch(() => ({}));
-    const value = body && typeof body === 'object' ? body : {};
-    const nested = value.error && typeof value.error === 'object' ? value.error : {};
-    const code = String(nested.code ?? value.reason ?? value.code ?? value.message ?? value.error ?? response.status);
-    const rawDetails = nested.details ?? value.details;
-    const details = rawDetails && typeof rawDetails === 'object' ? rawDetails : undefined;
-    if (response.status === 401)
-        throw new Error(`${message('login')} ${client.baseUrl}`);
-    if (code.startsWith('workspace_transfer_') || code === 'invalid_workspace_transfer')
-        throw workspaceTransferFailure(code, details);
-    if (response.status === 413)
-        throw workspaceTransferFailure('workspace_transfer_proxy_too_large');
-    if (response.status === 408 || response.status === 504)
-        throw workspaceTransferFailure('workspace_transfer_timeout');
-    throw workspaceTransferFailure(code, details);
-}
-async function json(client, path, body) {
-    const response = await request(client, path, body === undefined ? {} : {
-        method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body),
-    });
-    const value = await response.json();
-    return (value?.result ?? value);
-}
-async function ensureAccess(client, workspaceId, directoryName) {
-    const workspace = await json(client, `/api/cloud-workspaces/${workspaceId}`);
-    const scope = workspace.projectId
-        ? `/api/projects/${encodeURIComponent(workspace.projectId)}/cloud-workspaces/${workspaceId}`
-        : `/api/cloud-workspaces/${workspaceId}`;
-    let grant = await json(client, `${scope}/runtime-grants`, {
-        clientRequestId: `workspace-cli-${randomUUID()}`, actions: RESOURCE_GRANT_ACTIONS,
-    });
-    for (let attempt = 0; grant.grantStatus === 'pending' && grant.grantRequestId && attempt < 60; attempt++) {
-        await new Promise(resolve => setTimeout(resolve, 500));
-        grant = await json(client, `${scope}/runtime-grants/${encodeURIComponent(grant.grantRequestId)}`);
-    }
-    if (grant.grantStatus !== 'ready')
-        throw new Error(message('notReady'));
-    let operation = await json(client, `/runtime/workspaces/${workspaceId}/ensure`, { clientRequestId: randomUUID(), directoryName: directoryName === 'root' ? 'basic' : directoryName });
-    // Ensure may return a queued receipt before the workspace is prepared; a cold container can
-    // take minutes, so follow the operation instead of relying on the HTTP response to be final.
-    const ensureDeadline = Date.now() + 180_000;
-    while (operation.operationId && ['queued', 'dispatched', 'accepted'].includes(operation.status ?? '')
-        && Date.now() < ensureDeadline) {
-        await new Promise(resolve => setTimeout(resolve, 500));
-        operation = await json(client, `/runtime/operations/${encodeURIComponent(operation.operationId)}`);
-    }
-    if (operation.status !== 'completed')
-        throw new Error(message('notReady'));
-}
-async function localDiskSpace(path, required) {
-    const disk = await statfs(path);
-    const available = disk.bavail * disk.bsize;
-    if (required > available)
-        throw workspaceTransferFailure('workspace_transfer_disk_full', { actual: required, limit: available });
-    return available;
-}
-async function downloadBundle(response, target, temporary) {
-    if (!response.body)
-        throw new Error(message('failed'));
-    try {
-        const available = await localDiskSpace(temporary, Number(response.headers.get('content-length') ?? 0));
-        let bytes = 0;
-        const guard = new Transform({ transform(chunk, _encoding, callback) {
-                bytes += chunk.length;
-                callback(bytes > available ? workspaceTransferFailure('workspace_transfer_disk_full', { actual: bytes, limit: available }) : null, chunk);
-            } });
-        await pipeline(Readable.fromWeb(response.body), guard, createWriteStream(target, { flags: 'wx', mode: 0o600 }));
-        const declared = response.headers.get('content-length');
-        if (declared && Number(declared) !== bytes)
-            throw workspaceTransferFailure('invalid_workspace_transfer');
-    }
-    finally {
-        await response.body.cancel().catch(() => undefined);
-    }
-}
-export async function workspaceClone(options) {
-    const workspaceId = options.workspaceId.trim(), directoryName = options.directory ?? 'basic';
-    if (!/^[a-f0-9-]{36}$/i.test(workspaceId) || !workspaceSessionScopeSchema.safeParse(directoryName).success)
-        throw new Error(message('invalidTarget'));
-    const target = resolve(options.dir?.trim() || `workspace-${workspaceId}-${directoryName}`);
-    if (existsSync(target))
-        throw new Error(message('directoryExists'));
-    const client = new PlayCraftHttpClient(options);
-    await ensureAccess(client, workspaceId, directoryName);
-    const temporary = await mkdtemp(join(tmpdir(), 'playcraft-clone-'));
-    let created = false;
-    try {
-        const response = await request(client, `/runtime/workspaces/${workspaceId}/git-bundle?directoryName=${encodeURIComponent(directoryName)}`);
-        const tree = response.headers.get('x-playcraft-workspace-tree');
-        if (!tree || !/^[a-f0-9]{40,64}$/.test(tree)) {
-            await response.body?.cancel();
-            throw new Error(message('failed'));
-        }
-        const bundlePath = join(temporary, 'workspace.bundle');
-        await downloadBundle(response, bundlePath, temporary);
-        await mkdir(target);
-        created = true;
-        const contentBytes = Number(response.headers.get('x-playcraft-workspace-content-bytes') ?? 0);
-        if (Number.isSafeInteger(contentBytes) && contentBytes > 0)
-            await localDiskSpace(target, contentBytes * 2);
-        await runTransferGit(temporary, ['clone', '--no-checkout', '--', bundlePath, target]);
-        await writeFile(join(target, '.git', 'info', 'attributes'), RAW_ATTRIBUTES);
-        await runTransferGit(target, ['checkout', '--force', 'HEAD']);
-        if (transferGit(target, ['rev-parse', 'HEAD^{tree}']) !== tree)
-            throw new Error(message('failed'));
-        transferGit(target, ['config', '--unset-all', 'remote.origin.url']);
-        const meta = { schemaVersion: 'playcraft.workspace-checkout.v1', workspaceId, directoryName,
-            baseUrl: client.baseUrl, tree };
-        await writeFile(join(target, META_FILE), `${JSON.stringify(meta, null, 2)}\n`);
-        const excludePath = join(target, '.git', 'info', 'exclude');
-        const exclude = await readFile(excludePath, 'utf8').catch(() => '');
-        await writeFile(excludePath, `${exclude}\n/${META_FILE}\n`);
-        if (options.json)
-            console.log(JSON.stringify({ ok: true, command: 'workspace.clone', data: { ...meta, dir: target } }));
-        else
-            console.log(`${message('cloned')} ${target}`);
-    }
-    catch (error) {
-        if (created)
-            await rm(target, { recursive: true, force: true });
-        throw normalizeWorkspaceTransferError(error);
-    }
-    finally {
-        await rm(temporary, { recursive: true, force: true });
-    }
-}
-export async function workspacePush(options = {}) {
-    const root = resolve(options.dir?.trim() || process.cwd());
-    let meta;
-    try {
-        meta = JSON.parse(await readFile(join(root, META_FILE), 'utf8'));
-        if (meta.schemaVersion !== 'playcraft.workspace-checkout.v1' || !/^[a-f0-9-]{36}$/i.test(meta.workspaceId) ||
-            !workspaceSessionScopeSchema.safeParse(meta.directoryName).success || !/^[a-f0-9]{40,64}$/.test(meta.tree))
-            throw new Error();
-        workspaceServiceUrl(meta.baseUrl, '/');
-    }
-    catch {
-        throw new Error(message('metadataMissing'));
-    }
-    if (transferGit(root, ['status', '--porcelain']).length > 0)
-        throw new Error(message('cleanRequired'));
-    const client = new PlayCraftHttpClient({ url: options.url || meta.baseUrl, token: options.token });
-    if (workspaceServiceUrl(client.baseUrl, '/') !== workspaceServiceUrl(meta.baseUrl, '/'))
-        throw new Error(message('invalidTarget'));
-    await ensureAccess(client, meta.workspaceId, meta.directoryName);
-    const targetTree = transferGit(root, ['rev-parse', 'HEAD^{tree}']);
-    const stats = await inspectWorkspaceCommit(root, targetTree).catch(error => { throw normalizeWorkspaceTransferError(error); });
-    const path = `/runtime/workspaces/${meta.workspaceId}/git-bundle?directoryName=${encodeURIComponent(meta.directoryName)}`;
-    const preflightResponse = await request(client, `${path}&preflight=1&contentBytes=${stats.bytes}&fileCount=${stats.files}&expectedTree=${meta.tree}&targetTree=${targetTree}`);
-    if (!preflightResponse.headers.get('content-type')?.includes('application/json')) {
-        await preflightResponse.body?.cancel();
-        throw workspaceTransferFailure('workspace_transfer_upgrade_required');
-    }
-    const preflight = await preflightResponse.json();
-    if (preflight.protocolVersion !== 2)
-        throw workspaceTransferFailure('workspace_transfer_upgrade_required');
-    if (preflight.alreadyApplied && preflight.tree === targetTree) {
-        meta.tree = targetTree;
-        await writeFile(join(root, META_FILE), `${JSON.stringify(meta, null, 2)}\n`);
-        if (options.json)
-            console.log(JSON.stringify({ ok: true, command: 'workspace.push', data: { tree: targetTree, changedPaths: [] } }));
-        else
-            console.log(message('pushed'));
-        return;
-    }
-    if (!options.json)
-        console.error(message('preflight', { files: stats.files, bytes: transferByteCount(stats.bytes) }));
-    let snapshot;
-    try {
-        snapshot = await createWorkspacePushTransfer(root, meta.tree);
-        if (snapshot.tree !== targetTree)
-            throw workspaceTransferFailure('workspace_transfer_conflict');
-        const bundleBytes = (await stat(snapshot.bundlePath)).size;
-        if (!options.json)
-            console.error(message('upload', { bytes: transferByteCount(bundleBytes) }));
-        const stream = createReadStream(snapshot.bundlePath);
-        let response;
-        try {
-            response = await request(client, path, {
-                method: 'POST', headers: { 'content-type': 'application/octet-stream', 'content-length': String(bundleBytes),
-                    'x-playcraft-workspace-tree': meta.tree }, body: stream, duplex: 'half',
-            });
-        }
-        finally {
-            stream.destroy();
-        }
-        const result = await response.json();
-        if (!/^[a-f0-9]{40,64}$/.test(result.tree))
-            throw new Error(message('failed'));
-        meta.tree = result.tree;
-        await writeFile(join(root, META_FILE), `${JSON.stringify(meta, null, 2)}\n`);
-        if (options.json)
-            console.log(JSON.stringify({ ok: true, command: 'workspace.push', data: result }));
-        else
-            console.log(message('pushed'));
-    }
-    catch (error) {
-        throw normalizeWorkspaceTransferError(error);
-    }
-    finally {
-        await snapshot?.cleanup();
-    }
-}

package/dist/workspace/transfer-errors.js

@@ -1,48 +0,0 @@
-import { WorkspaceTransferError } from '../workspace-runtime/workspaces/transfer.js';
-import { workspaceMessage as message } from './messages.js';
-export class WorkspaceCliTransferError extends Error {
-    code;
-    details;
-    constructor(code, text, details) {
-        super(text);
-        this.code = code;
-        this.details = details;
-    }
-}
-export function transferByteCount(value) {
-    return typeof value === 'number' && Number.isFinite(value)
-        ? message('byteCount', { value: value.toLocaleString('en-US') }) : message('byteCount', { value: '—' });
-}
-export function workspaceTransferFailure(code, details) {
-    const key = code === 'workspace_transfer_quota_exceeded' ? 'quotaExceeded'
-        : code === 'workspace_transfer_disk_full' ? typeof details?.actual === 'number' && typeof details.limit === 'number' ? 'diskFull' : 'diskFullUnknown'
-            : code === 'workspace_transfer_storage_unavailable' ? 'diskUnavailable'
-                : code === 'workspace_transfer_proxy_too_large' ? 'proxyTooLarge'
-                    : code === 'workspace_transfer_too_large' ? 'tooLarge'
-                        : code.includes('timeout') ? 'timeout'
-                            : code === 'workspace_transfer_network' ? 'network'
-                                : code === 'workspace_transfer_conflict' ? 'conflict'
-                                    : code === 'workspace_transfer_busy' ? 'busy'
-                                        : code === 'workspace_transfer_git_missing' ? 'gitMissing'
-                                            : code === 'workspace_transfer_base_missing' ? 'baseMissing'
-                                                : code.startsWith('workspace_transfer_git_') ? 'gitFailed'
-                                                    : code === 'invalid_workspace_transfer' || code === 'workspace_transfer_symlink' ? 'invalidTransfer'
-                                                        : code === 'workspace_transfer_upgrade_required' ? 'upgradeRequired' : 'failed';
-    const text = message(key, { actual: transferByteCount(details?.actual), limit: transferByteCount(details?.limit) });
-    return new WorkspaceCliTransferError(code, key === 'failed' ? `${text}: ${code}` : text, details);
-}
-export function normalizeWorkspaceTransferError(error) {
-    if (error instanceof WorkspaceCliTransferError)
-        return error;
-    if (error instanceof WorkspaceTransferError)
-        return workspaceTransferFailure(error.code, error.details);
-    const value = (error && typeof error === 'object' ? error : {});
-    if (value.code === 'ENOSPC')
-        return workspaceTransferFailure('workspace_transfer_disk_full');
-    if (/Timeout|Abort/.test(value.name ?? '') || /TIMEOUT/.test(value.cause?.code ?? ''))
-        return workspaceTransferFailure('workspace_transfer_timeout');
-    if (/UND_ERR_SOCKET|ECONNRESET|ECONNREFUSED|ENOTFOUND|EPIPE/.test(value.cause?.code ?? value.code ?? '') ||
-        error instanceof TypeError && /fetch|network|terminated/i.test(error.message))
-        return workspaceTransferFailure('workspace_transfer_network');
-    return error instanceof Error ? error : new Error(String(error));
-}

package/dist/workspace-runtime/batch/content-changes.js

@@ -1,30 +0,0 @@
-import { gitRead } from './git.js';
-const reference = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
-const excludedDirectories = new Set(['node_modules', 'dist', 'build', 'coverage', 'docs', 'test', 'tests', '__tests__']);
-const contentExtension = /\.(?:[cm]?[jt]sx?|vue|svelte|html?|css|s[ac]ss|less|json5?|ya?ml|xml|glsl|wgsl|vert|frag|lua|py|svg|png|jpe?g|webp|avif|gif|bmp|mp[34]|wav|ogg|m4a|webm|glb|gltf|fbx|obj|bin|atlas|woff2?|ttf|otf)$/i;
-function contentPath(path) {
-    const parts = path.split('/');
-    if (parts.some(part => part.startsWith('.') || excludedDirectories.has(part)))
-        return false;
-    const name = parts.at(-1);
-    if (/^(?:package(?:-lock)?\.json|npm-shrinkwrap\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?|tsconfig(?:\.[^.]+)?\.json|(?:vite|vitest|webpack|eslint|prettier)\.config\..+)$/i.test(name))
-        return false;
-    return contentExtension.test(name);
-}
-/** A completed batch member must change code, runtime configuration, or assets. */
-export async function requireBatchContentChanges(root, before, after) {
-    if (!reference.test(before) || !reference.test(after))
-        throw new Error('batch_change_reference_invalid');
-    const stdout = await gitRead(root, ['diff', '--raw', '--no-abbrev', '--no-renames', '-z', before, after, '--']);
-    const records = stdout.split('\0'), paths = [];
-    for (let index = 0; index + 1 < records.length; index += 2) {
-        const [oldMode, newMode, oldBlob, newBlob] = records[index].slice(1).split(' ');
-        const path = records[index + 1];
-        if ((oldMode === '100644' || oldMode === '100755' || newMode === '100644' || newMode === '100755')
-            && oldBlob !== newBlob && contentPath(path))
-            paths.push(path);
-    }
-    if (!paths.length)
-        throw new Error('batch_generation_no_content_change');
-    return paths;
-}

package/dist/workspace-runtime/batch/control.js

@@ -1,86 +0,0 @@
-import { setTimeout as delay } from 'node:timers/promises';
-import { sandboxBatchMemberStopSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { groupExited, stopProcessGroup } from './processes.js';
-import { settleObservedGenerate } from './generate.js';
-import { memberStatus, readMember, serializeRun, writeMember, writeStopMarker } from './records.js';
-async function prove(record) {
-    let stopped = true;
-    for (const process of record.processes) {
-        if (process.stopped || groupExited(process.pid))
-            process.stopped = true;
-        else {
-            process.stopped = await stopProcessGroup(process);
-            if (!process.stopped)
-                stopped = false;
-        }
-    }
-    return stopped;
-}
-function sessionBusy(state, record) {
-    const session = record.sessionId ? state.journal.getSession(record.sessionId) : undefined;
-    if (!session)
-        return false;
-    return session.turnBlock === 'uncertain' || session.turnStatus === 'starting' || session.turnStatus === 'running';
-}
-/** Read-only besides reconciling process proof. Does not start work or advance a phase. */
-export async function readBatchMemberStatus(state, runId) {
-    const record = await readMember(state, runId);
-    if (!record)
-        return undefined;
-    if (record.phase === 'generate' && record.state === 'running') {
-        const settled = await settleObservedGenerate(state, record);
-        if (settled.state !== 'running')
-            return memberStatus(settled);
-    }
-    const processes = record.processes.map(process => ({ ...process, stopped: process.stopped || groupExited(process.pid) }));
-    const live = processes.some(process => !process.stopped);
-    let next = { ...record, processes };
-    if (live && (record.writersStopped || record.state === 'completed' || record.state === 'stopped' || record.state === 'needs_user' || record.state === 'failed')) {
-        next = { ...next, writersStopped: false, state: record.stopRequested ? 'stopping' : 'unknown', holding: true };
-    }
-    else if (!live && record.state === 'running') {
-        const turnLive = sessionBusy(state, record);
-        next = { ...next, writersStopped: !turnLive, state: record.stopRequested ? 'stopped' : turnLive ? 'running' : 'unknown', holding: turnLive || !record.stopRequested };
-    }
-    if (JSON.stringify(next) !== JSON.stringify(record))
-        next = await writeMember(state, next);
-    return memberStatus(next);
-}
-export async function stopBatchMember(state, runId, body) {
-    const parsed = sandboxBatchMemberStopSchema.safeParse({ ...(body && typeof body === 'object' ? body : {}), runId });
-    if (!parsed.success)
-        throw new Error('invalid_batch_request');
-    const command = parsed.data;
-    return serializeRun(runId, async () => {
-        const existing = await readMember(state, runId);
-        if (existing && command.ownerFence < existing.ownerFence)
-            throw new Error('stale_owner');
-        if (existing?.state === 'completed' && existing.phase === 'deliver' && existing.evidence && existing.writersStopped)
-            return memberStatus(existing);
-        await writeStopMarker(state, runId, command.ownerFence);
-        const session = existing?.sessionId ? state.journal.getSession(existing.sessionId) : undefined;
-        if (session?.threadId && existing?.sessionId) {
-            await state.native?.interrupt?.({ sessionId: existing.sessionId, threadId: session.threadId }).catch(() => undefined);
-            const deadline = Date.now() + 2_000;
-            while (sessionBusy(state, existing) && Date.now() < deadline)
-                await delay(15);
-        }
-        const record = existing ?? {
-            runId, ownerFence: command.ownerFence, occupancyId: '00000000-0000-0000-0000-000000000000', workspaceId: '00000000-0000-0000-0000-000000000000',
-            directoryName: 'basic', phase: 'prepare', state: 'stopping', writersStopped: false, holding: true, stopRequested: true, processes: [],
-            updatedAt: new Date().toISOString(),
-        };
-        const writersStopped = await prove(record) && !sessionBusy(state, record);
-        const saved = await writeMember(state, {
-            ...record, ownerFence: command.ownerFence, stopRequested: true, state: writersStopped ? 'stopped' : 'stopping',
-            writersStopped, holding: !writersStopped,
-        });
-        return memberStatus(saved);
-    });
-}
-export async function rememberProcess(state, runId, process) {
-    const record = await readMember(state, runId);
-    if (!record)
-        return;
-    await writeMember(state, { ...record, processes: [...record.processes.filter(item => item.pid !== process.pid), process] });
-}