@playcraft/cli 0.1.41-prod → 0.1.43-beta

package/dist/workspace/transfer-client.js

@@ -0,0 +1,233 @@
+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 });
+    for (let attempt = 0; operation.operationId && ['queued', 'dispatched', 'accepted'].includes(operation.status ?? '') && attempt < 60; attempt++) {
+        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

@@ -0,0 +1,48 @@
+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));
+}