@playcraft/cli 0.1.40-beta → 0.1.41-prod

package/dist/workspace/transfer-client.js

@@ -1,174 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { RESOURCE_GRANT_ACTIONS, workspaceSessionScopeSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { PlayCraftHttpClient } from '../utils/playcraft-http-client.js';
-import { transferGit, WORKSPACE_TRANSFER_MAX_BYTES } from '../workspace-runtime/workspaces/transfer.js';
-import { workspaceMessage as message } from './messages.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);
-    const response = await fetch(workspaceServiceUrl(client.baseUrl, path), {
-        ...init, headers, redirect: 'error', signal: AbortSignal.timeout(180_000),
-    });
-    if (response.ok)
-        return response;
-    const body = await response.json().catch(() => ({}));
-    const value = body && typeof body === 'object' ? body : {};
-    const code = String(value.reason ?? value.code ?? value.message ?? value.error ?? response.status);
-    if (code.includes('workspace_transfer_conflict'))
-        throw new Error(message('conflict'));
-    if (code.includes('workspace_transfer_too_large'))
-        throw new Error(message('tooLarge'));
-    if (response.status === 401)
-        throw new Error(`${message('login')} ${client.baseUrl}`);
-    throw new Error(`${message('failed')}: ${code}`);
-}
-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 readBounded(response) {
-    const chunks = [];
-    let length = 0;
-    if (!response.body)
-        throw new Error(message('failed'));
-    const reader = response.body.getReader();
-    try {
-        while (true) {
-            const next = await reader.read();
-            if (next.done)
-                break;
-            length += next.value.byteLength;
-            if (length > WORKSPACE_TRANSFER_MAX_BYTES)
-                throw new Error(message('tooLarge'));
-            chunks.push(next.value);
-        }
-    }
-    finally {
-        await reader.cancel();
-    }
-    return Buffer.concat(chunks);
-}
-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))
-            throw new Error(message('failed'));
-        const bundlePath = join(temporary, 'workspace.bundle');
-        await writeFile(bundlePath, await readBounded(response), { mode: 0o600 });
-        await mkdir(target);
-        created = true;
-        transferGit(temporary, ['clone', '--', bundlePath, target]);
-        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 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 temporary = await mkdtemp(join(tmpdir(), 'playcraft-push-'));
-    try {
-        const bundlePath = join(temporary, 'workspace.bundle');
-        transferGit(root, ['bundle', 'create', bundlePath, 'HEAD']);
-        const bundle = await readFile(bundlePath);
-        if (bundle.byteLength > WORKSPACE_TRANSFER_MAX_BYTES)
-            throw new Error(message('tooLarge'));
-        const response = await request(client, `/runtime/workspaces/${meta.workspaceId}/git-bundle?directoryName=${encodeURIComponent(meta.directoryName)}`, {
-            method: 'POST', headers: { 'content-type': 'application/octet-stream', 'x-playcraft-workspace-tree': meta.tree }, body: bundle,
-        });
-        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'));
-    }
-    finally {
-        await rm(temporary, { recursive: true, force: true });
-    }
-}