@playcraft/cli 0.1.29 → 0.1.30

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("'", "'\\''")}'`; }