@playcraft/cli 0.1.50-beta → 0.1.51

package/dist/workspace-runtime/server/desktop-preview-config.js

@@ -1,81 +0,0 @@
-import { readFile, realpath, stat } from 'node:fs/promises';
-import { isAbsolute, join, relative, sep } from 'node:path';
-import { DesktopPreviewError } from './desktop-preview.js';
-import JSON5 from 'json5';
-export async function previewPlan(root) {
-    const config = await optionalJson(root, '.playcraft/workspace.json');
-    const preview = object(config?.preview);
-    if (config?.preview !== undefined) {
-        if (!preview || typeof preview !== 'object' || typeof preview.command !== 'string' || !preview.command.trim()
-            || (preview.cwd !== undefined && typeof preview.cwd !== 'string') || (preview.path !== undefined && typeof preview.path !== 'string')) {
-            throw new DesktopPreviewError('desktop_preview_unconfigured');
-        }
-        const cwd = typeof preview.cwd === 'string' ? preview.cwd : '.';
-        if (isAbsolute(cwd))
-            throw new DesktopPreviewError('desktop_preview_unconfigured');
-        let realRoot;
-        try {
-            realRoot = await realpath(join(root, cwd));
-        }
-        catch {
-            throw new DesktopPreviewError('desktop_preview_unconfigured');
-        }
-        const resolved = relative(await realpath(root), realRoot);
-        if (resolved === '..' || resolved.startsWith(`..${sep}`) || !(await stat(realRoot)).isDirectory()) {
-            throw new DesktopPreviewError('desktop_preview_unconfigured');
-        }
-        return { root: realRoot, command: preview.command, path: entryPath(preview.path), dependencies: await exists(join(realRoot, 'package.json')) };
-    }
-    const manifest = await optionalJson(root, 'package.json');
-    if (manifest) {
-        const dev = object(manifest.scripts)?.dev;
-        const vite = object(manifest.dependencies)?.vite ?? object(manifest.devDependencies)?.vite;
-        if (typeof dev === 'string' && /^\s*vite(?:\s|$)/.test(dev) && typeof vite === 'string') {
-            return { root, command: 'pnpm run dev --host 127.0.0.1 --port {port} --strictPort', path: '/', dependencies: true };
-        }
-        throw new DesktopPreviewError('desktop_preview_unconfigured');
-    }
-    return { root, path: '/', dependencies: false, welcome: !await exists(join(root, 'index.html')) };
-}
-function entryPath(path) {
-    if (path === undefined)
-        return '/';
-    if (typeof path !== 'string' || !path.startsWith('/') || path.startsWith('//') || path.includes('\\')) {
-        throw new DesktopPreviewError('desktop_preview_unconfigured');
-    }
-    const url = new URL(path, 'http://127.0.0.1');
-    if (url.origin !== 'http://127.0.0.1')
-        throw new DesktopPreviewError('desktop_preview_unconfigured');
-    return `${url.pathname}${url.search}${url.hash}`;
-}
-async function exists(path) { try {
-    return (await stat(path)).isFile();
-}
-catch {
-    return false;
-} }
-export async function requiresNodeModules(root) {
-    const manifest = await optionalJson(root, 'package.json');
-    return ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']
-        .some((key) => Object.keys(object(manifest?.[key]) ?? {}).length > 0);
-}
-async function optionalJson(root, path) {
-    try {
-        const resolved = await realpath(join(root, path));
-        const location = relative(await realpath(root), resolved);
-        if (location === '..' || location.startsWith(`..${sep}`))
-            throw new DesktopPreviewError('desktop_preview_unconfigured');
-        const result = object(JSON5.parse(await readFile(resolved, 'utf8')));
-        if (!result)
-            throw new DesktopPreviewError('desktop_preview_unconfigured');
-        return result;
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return undefined;
-        throw new DesktopPreviewError('desktop_preview_unconfigured');
-    }
-}
-function object(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
-}

package/dist/workspace-runtime/server/desktop-preview-service.js

@@ -1,157 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { createServer } from 'node:net';
-import { setTimeout as delay } from 'node:timers/promises';
-import { startLauncherProcess } from '../codex/launcher-client.js';
-import { DesktopPreviewError, quote } from './desktop-preview.js';
-// The supervisor runs under the same developer identity as its service. It proves that the
-// loopback listener belongs to its process group before Runtime probes the configured page.
-const supervisor = String.raw `
-const fs = require('node:fs');
-const {spawn,execFileSync} = require('node:child_process');
-const [command,portText,marker] = process.argv.slice(1);
-const port = Number(portText);
-const child = spawn(process.platform==='linux'?'/usr/bin/bash':'/bin/bash',['-lc',command],{stdio:['ignore','inherit','inherit']});
-child.on('error',()=>process.exit(97));
-child.on('exit',code=>process.exit(code === 0 ? 97 : code || 97));
-function listeners() {
-  if (process.platform === 'linux') {
-    const sockets = ['tcp','tcp6'].flatMap(kind => fs.readFileSync('/proc/net/'+kind,'utf8').trim().split('\n').slice(1).flatMap(line=>{
-      const columns=line.trim().split(/\s+/); const [address,p]=columns[1].split(':');
-      return parseInt(p,16)===port && columns[3]==='0A' ? [{id:columns[9],local:address==='0100007F'||address==='00000000000000000000000001000000'}] : [];
-    }));
-    const owned=new Set();
-    for (const pid of fs.readdirSync('/proc').filter(name=>/^\d+$/.test(name))) {
-      try {
-        const stat=fs.readFileSync('/proc/'+pid+'/stat','utf8');
-        if (Number(stat.slice(stat.lastIndexOf(')')+2).split(' ')[2])!==process.pid) continue;
-        for (const fd of fs.readdirSync('/proc/'+pid+'/fd')) {
-          try { const match=fs.readlinkSync('/proc/'+pid+'/fd/'+fd).match(/^socket:\[(\d+)\]$/); if(match)owned.add(match[1]); } catch {}
-        }
-      } catch {}
-    }
-    return sockets.map(socket=>({local:socket.local,owned:owned.has(socket.id)}));
-  }
-  const pids=new Set(execFileSync('/bin/ps',['-axo','pid=,pgid='],{encoding:'utf8'}).trim().split('\n').flatMap(line=>{
-    const [pid,group]=line.trim().split(/\s+/); return Number(group)===process.pid?[Number(pid)]:[];
-  }));
-  let listing='';try{listing=execFileSync('/usr/sbin/lsof',['-nP','-iTCP:'+port,'-sTCP:LISTEN','-Fpn'],{encoding:'utf8',stdio:['ignore','pipe','ignore']});}catch{}
-  let pid=0;return listing.split('\n').flatMap(line=>{
-    if(line.startsWith('p'))pid=Number(line.slice(1));
-    return line.startsWith('n')?[{local:line.slice(1).startsWith('127.0.0.1:')||line.slice(1).startsWith('[::1]:'),owned:pids.has(pid)}]:[];
-  });
-}
-let ready=false;
-const timer=setInterval(()=>{
-  try {
-    const found=listeners();
-    if(found.some(socket=>!socket.local||!socket.owned)){console.log(marker+':port');process.exit(98);}
-    if(!ready&&found.some(socket=>socket.owned)){ready=true;clearInterval(timer);console.log(marker+':ready');}
-  } catch {console.log(marker+':failed');process.exit(97);}
-},50);
-`;
-export async function startManagedPreview(input) {
-    const { state, options } = input;
-    const socketPath = options.launcherSocket ?? process.env.PLAYCRAFT_LAUNCHER_SOCKET;
-    if (!socketPath)
-        throw new DesktopPreviewError('desktop_preview_start_failed');
-    const port = await reservePort();
-    const url = new URL(input.path, `http://127.0.0.1:${port}/`).href;
-    const marker = `PLAYCRAFT_PREVIEW_${randomUUID()}`;
-    const command = `export HOST=127.0.0.1 PORT=${port} PLAYCRAFT_PREVIEW_PORT=${port}; exec ${quote(process.execPath)} -e ${quote(supervisor)} -- ${quote(input.command.replaceAll('{port}', String(port)))} ${port} ${quote(marker)}`;
-    const processHandle = await launchPreviewProcess({ socketPath,
-        processId: `desktop-preview-service-${randomUUID()}`, runtimeEpoch: state.runtimeEpoch,
-        argv: ['/usr/bin/bash', '-lc', command], cwd: input.root, env: {} }, options, input.deadline, input.cancelled, 'desktop_preview_start_failed');
-    if (!processHandle)
-        return undefined;
-    let alive = true;
-    let stopped = false;
-    let stopping;
-    let owned = false;
-    let failure;
-    let tail = '';
-    processHandle.onExit((code) => { alive = false; failure ??= code === 98 ? 'desktop_preview_port_unavailable' : 'desktop_preview_start_failed'; });
-    processHandle.stdout?.on('data', (chunk) => {
-        tail = (tail + chunk.toString('utf8')).slice(-8192);
-        if (tail.includes(`${marker}:ready`))
-            owned = true;
-        if (tail.includes(`${marker}:port`))
-            failure = 'desktop_preview_port_unavailable';
-        if (tail.includes(`${marker}:failed`))
-            failure = 'desktop_preview_start_failed';
-    });
-    processHandle.stderr?.resume();
-    const stop = () => stopping ??= processHandle.stop().then(() => { stopped = true; alive = false; });
-    try {
-        while (Date.now() < input.deadline) {
-            if (input.cancelled()) {
-                await stop();
-                return undefined;
-            }
-            if (!alive || failure)
-                throw new DesktopPreviewError(failure ?? 'desktop_preview_start_failed');
-            if (owned) {
-                try {
-                    const response = await fetch(url, { signal: AbortSignal.timeout(Math.min(500, Math.max(1, input.deadline - Date.now()))) });
-                    await response.body?.cancel();
-                    if (response.ok && alive)
-                        return { url, alive: () => alive && !stopped && !stopping, stop };
-                }
-                catch { }
-            }
-            await delay(options.pollIntervalMs ?? 100);
-        }
-        throw new DesktopPreviewError('desktop_preview_timeout');
-    }
-    catch (error) {
-        await stop();
-        throw error;
-    }
-}
-/** Starting the launcher is bounded too; late replies are stopped after cancellation. */
-export async function launchPreviewProcess(input, options, deadline, cancelled, failure) {
-    let finished = false;
-    let abandoned = false;
-    let failed = false;
-    let child;
-    void (options.startProcess ?? startLauncherProcess)(input).then((value) => {
-        child = value;
-        finished = true;
-        if (abandoned)
-            void value.stop().catch(() => undefined);
-    }, () => { finished = true; failed = true; });
-    while (!finished) {
-        if (cancelled()) {
-            abandoned = true;
-            return undefined;
-        }
-        if (Date.now() >= deadline) {
-            abandoned = true;
-            throw new DesktopPreviewError('desktop_preview_timeout');
-        }
-        await delay(Math.min(options.pollIntervalMs ?? 50, Math.max(1, deadline - Date.now())));
-    }
-    if (failed || !child)
-        throw new DesktopPreviewError(failure);
-    if (cancelled()) {
-        await child.stop();
-        return undefined;
-    }
-    return child;
-}
-async function reservePort() {
-    const server = createServer();
-    try {
-        await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve); });
-        const address = server.address();
-        if (!address || typeof address === 'string')
-            throw new Error('port_unavailable');
-        return address.port;
-    }
-    catch {
-        throw new DesktopPreviewError('desktop_preview_port_unavailable');
-    }
-    finally {
-        if (server.listening)
-            await new Promise((resolve) => server.close(() => resolve()));
-    }
-}

package/dist/workspace-runtime/server/desktop-preview-static.js

@@ -1,53 +0,0 @@
-import { createServer } from 'node:http';
-import { readFile, realpath, stat } from 'node:fs/promises';
-import { extname, join, relative, sep } from 'node:path';
-const types = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.mjs': 'text/javascript; charset=utf-8',
-    '.css': 'text/css; charset=utf-8', '.json': 'application/json', '.svg': 'image/svg+xml',
-    '.png': 'image/png', '.jpg': 'image/jpeg', '.webp': 'image/webp', '.wasm': 'application/wasm' };
-export async function startStaticPreview(root, welcome = false) {
-    const realRoot = await realpath(root);
-    const server = createServer((request, response) => {
-        void (async () => {
-            try {
-                const pathname = decodeURIComponent(new URL(request.url ?? '/', 'http://localhost').pathname);
-                if (welcome && pathname === '/') {
-                    response.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
-                    response.end(welcomePage());
-                    return;
-                }
-                const segments = pathname.split('/').filter(Boolean);
-                if (segments.some((segment) => segment.startsWith('.')))
-                    throw new Error('hidden_path');
-                const target = await realpath(join(realRoot, ...segments, ...(pathname.endsWith('/') ? ['index.html'] : [])));
-                const path = relative(realRoot, target);
-                if (path === '..' || path.startsWith(`..${sep}`) || !(await stat(target)).isFile())
-                    throw new Error('outside_root');
-                const body = await readFile(target);
-                response.writeHead(200, { 'content-type': types[extname(target)] ?? 'application/octet-stream', 'cache-control': 'no-store' });
-                response.end(request.method === 'HEAD' ? undefined : body);
-            }
-            catch {
-                response.writeHead(404);
-                response.end();
-            }
-        })();
-    });
-    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve); });
-    const address = server.address();
-    if (!address || typeof address === 'string')
-        throw new Error('preview_port_unavailable');
-    let stopped = false;
-    return { url: `http://127.0.0.1:${address.port}/`, alive: () => server.listening && !stopped,
-        async stop() {
-            if (stopped)
-                return;
-            stopped = true;
-            server.closeAllConnections();
-            await new Promise((resolve) => server.close(() => resolve()));
-        } };
-}
-function welcomePage() {
-    const messages = { en: { title: 'Your workspace desktop is ready', body: 'Add a project to see its preview here.' },
-        zh: { title: '工作区桌面已就绪', body: '添加项目后，这里会显示项目预览。' } };
-    return `<!doctype html><html lang="en"><meta charset="utf-8"><title>${messages.en.title}</title><style>body{margin:0;background:#f1f0eb;color:#252724;font:22px system-ui;display:grid;min-height:100vh;place-items:center}main{max-width:680px;padding:48px}h1{font-size:42px}p{line-height:1.7;color:#596159}</style><main><h1>${messages.en.title}</h1><p>${messages.en.body}</p><h2 lang="zh">${messages.zh.title}</h2><p lang="zh">${messages.zh.body}</p></main></html>`;
-}

package/dist/workspace-runtime/server/desktop-preview.js

@@ -1,189 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { setTimeout as delay } from 'node:timers/promises';
-import { join } from 'node:path';
-import { lstat } from 'node:fs/promises';
-import { workspaceRoot, WorkspaceContextError } from '../workspaces/registry.js';
-import { startStaticPreview } from './desktop-preview-static.js';
-import { previewPlan, requiresNodeModules } from './desktop-preview-config.js';
-import { launchPreviewProcess, startManagedPreview } from './desktop-preview-service.js';
-import { planInstall, scheduleDependencyInstall, readDependencies } from '../workspaces/dependencies.js';
-export class DesktopPreviewError extends Error {
-    code;
-    constructor(code) {
-        super(code);
-        this.code = code;
-        this.name = 'DesktopPreviewError';
-    }
-}
-/** One visible browser; project services and browser profiles survive workspace switches. */
-export class DesktopPreviewHost {
-    state;
-    options;
-    pending = new Map();
-    servers = new Map();
-    emptyDependencyReady = new Map();
-    activeBrowser;
-    activation = Promise.resolve();
-    disposed = false;
-    disposal;
-    requestedKey;
-    constructor(state, options = {}) {
-        this.state = state;
-        this.options = options;
-    }
-    open(workspaceId, directoryName = 'basic') {
-        if (!this.canNavigate())
-            return Promise.resolve();
-        const key = workspaceId ? `${workspaceId}:${directoryName}` : 'single';
-        this.requestedKey = key;
-        const existing = this.pending.get(key);
-        if (existing)
-            return existing;
-        const task = this.openWorkspace(key, workspaceId, directoryName).catch((error) => {
-            if (error instanceof DesktopPreviewError || error instanceof WorkspaceContextError)
-                throw error;
-            throw new DesktopPreviewError('desktop_preview_start_failed');
-        }).finally(() => this.pending.delete(key));
-        this.pending.set(key, task);
-        return task;
-    }
-    dispose() {
-        if (this.disposal)
-            return this.disposal;
-        this.disposed = true;
-        this.disposal = (async () => {
-            const stopped = await Promise.allSettled([
-                ...(this.activeBrowser ? [this.activeBrowser.process.stop()] : []),
-                ...[...this.servers.values()].map(({ server }) => server.stop()),
-            ]);
-            await Promise.allSettled([...this.pending.values()]);
-            this.servers.clear();
-            this.activeBrowser = undefined;
-            if (stopped.some((result) => result.status === 'rejected'))
-                throw new DesktopPreviewError('desktop_preview_start_failed');
-        })();
-        return this.disposal;
-    }
-    canNavigate() {
-        return !this.disposed && !this.state.journal.destroyed() && (this.options.canNavigate?.() ?? true);
-    }
-    async openWorkspace(key, workspaceId, directoryName = 'basic') {
-        const root = await workspaceRoot(this.state, workspaceId, directoryName);
-        const deadline = Date.now() + (this.options.timeoutMs ?? 90_000);
-        if (!this.canNavigate())
-            return;
-        const plan = await previewPlan(root);
-        if (!this.canNavigate())
-            return;
-        if (plan.dependencies) {
-            const dependencyDeadline = Math.min(deadline, Date.now() + (this.options.dependencyTimeoutMs ?? 60_000));
-            if (!await this.ensureDependencies(key, plan.root, dependencyDeadline))
-                return;
-        }
-        if (!this.canNavigate())
-            return;
-        const signature = JSON.stringify(plan);
-        const entry = this.servers.get(key);
-        let server = entry?.server;
-        if (!server?.alive() || entry?.signature !== signature) {
-            await server?.stop();
-            if (!this.canNavigate())
-                return;
-            server = plan.command ? await startManagedPreview({ state: this.state, options: this.options,
-                root: plan.root, command: plan.command, path: plan.path, deadline, cancelled: () => !this.canNavigate() }) : await startStaticPreview(root, plan.welcome);
-            if (!server)
-                return;
-            if (!this.canNavigate()) {
-                await server.stop();
-                return;
-            }
-            this.servers.set(key, { server, signature });
-        }
-        const current = this.activation.then(() => this.activate(key, root, server, deadline));
-        this.activation = current.catch(() => undefined);
-        await current;
-    }
-    async ensureDependencies(key, root, deadline) {
-        const initialPlan = await planInstall(root);
-        if (initialPlan.kind === 'install' && !await requiresNodeModules(root)
-            && this.emptyDependencyReady.get(root) === initialPlan.lockHash)
-            return this.canNavigate();
-        let finished = false;
-        const install = () => {
-            finished = false;
-            void scheduleDependencyInstall(this.state, key, root, () => this.canNavigate()).finally(() => { finished = true; });
-        };
-        if (!this.canNavigate())
-            return false;
-        install();
-        while (Date.now() < deadline) {
-            if (!this.canNavigate())
-                return false;
-            if (finished) {
-                const current = await planInstall(root);
-                if (!this.canNavigate())
-                    return false;
-                const record = readDependencies(this.state, key);
-                if (record.status === 'failed')
-                    throw new DesktopPreviewError('dependencies_not_ready');
-                if (current.kind === 'skip' && record.status === 'none')
-                    return true;
-                if (current.kind === 'install' && record.status === 'ready' && !await requiresNodeModules(root)) {
-                    this.emptyDependencyReady.set(root, current.lockHash);
-                    return this.canNavigate();
-                }
-                if (current.kind === 'install' && record.lockHash === current.lockHash) {
-                    const modules = await lstat(join(root, 'node_modules')).catch(() => undefined);
-                    if (record.status === 'ready' && modules?.isDirectory() && !modules.isSymbolicLink())
-                        return true;
-                }
-                // A changed manifest or lockfile needs a current install before this project can start.
-                if (!this.canNavigate())
-                    return false;
-                install();
-            }
-            await delay(this.options.pollIntervalMs ?? 100);
-        }
-        if (!this.canNavigate())
-            return false;
-        throw new DesktopPreviewError('dependencies_not_ready');
-    }
-    async activate(key, root, server, deadline) {
-        const canActivate = () => this.canNavigate() && this.requestedKey === key;
-        if (!canActivate())
-            return;
-        if (this.activeBrowser?.alive && this.activeBrowser.key === key && this.activeBrowser.server === server)
-            return;
-        if (Date.now() >= deadline)
-            throw new DesktopPreviewError('desktop_preview_timeout');
-        const socketPath = this.options.launcherSocket ?? process.env.PLAYCRAFT_LAUNCHER_SOCKET;
-        if (!socketPath)
-            throw new DesktopPreviewError('desktop_browser_unavailable');
-        if (this.activeBrowser)
-            await this.activeBrowser.process.stop();
-        this.activeBrowser = undefined;
-        if (!canActivate())
-            return;
-        const profile = join(this.options.profileRoot ?? '/home/playcraft-dev/.cache/playcraft-desktop', key);
-        const executable = this.options.browserExecutable ?? '/usr/bin/chromium';
-        const command = `test -x ${quote(executable)} || exit 127; mkdir -p -- ${quote(profile)} || exit 1; exec ${quote(executable)} --no-first-run --no-default-browser-check --disable-dev-shm-usage --start-maximized --user-data-dir=${quote(profile)} --app=${quote(server.url)}`;
-        const child = await launchPreviewProcess({ socketPath,
-            processId: `desktop-preview-browser-${randomUUID()}`, runtimeEpoch: this.state.runtimeEpoch,
-            argv: ['/usr/bin/bash', '-lc', command], cwd: root, env: { DISPLAY: process.env.DISPLAY ?? ':0' } }, this.options, deadline, () => !canActivate(), 'desktop_browser_start_failed');
-        if (!child)
-            return;
-        const browser = { key, server, process: child, alive: true };
-        let exitCode;
-        child.onExit((code) => { browser.alive = false; exitCode = code; });
-        child.stdout?.resume();
-        child.stderr?.resume();
-        this.activeBrowser = browser;
-        await delay(150);
-        if (!browser.alive) {
-            await child.stop();
-            this.activeBrowser = undefined;
-            throw new DesktopPreviewError(exitCode === 127 ? 'desktop_browser_unavailable' : 'desktop_browser_start_failed');
-        }
-    }
-}
-export function quote(value) { return `'${value.replaceAll("'", "'\\''")}'`; }