@playcraft/cli 0.1.54 → 0.1.55-beta

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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,157 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,189 @@
+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("'", "'\\''")}'`; }