dsh-webui-studio 0.1.0 → 0.2.0

package/lib/host/preview.js

@@ -1,9 +1,13 @@
-import { randomBytes } from 'node:crypto';
+import { randomBytes, randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { basename, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { STUDIO_PREVIEW_API_PATH } from '../contracts.js';
-import { installDraftDependencies, materializeDraftProfile, terminalCommandLine } from './runtime-profile.js';
-const START_TIMEOUT_MS = 30_000;
+import { NodePeerClient } from 'the-binding-of-dsh';
+import { STUDIO_PREVIEW_REMOTE, } from './preview-worker.js';
+import { studioPreviewPortPool } from './preview-port.js';
+import { buildDraft, installDraftDependencies, materializeDraftProfile, terminalCommandLine } from './runtime-profile.js';
+const START_TIMEOUT_MS = 60_000;
 const LOG_LIMIT = 64_000;
 function appendLog(current, chunk) {
     return `${current}${chunk.toString()}`.slice(-LOG_LIMIT);
@@ -11,6 +15,22 @@ function appendLog(current, chunk) {
 function studioPackageRoot() {
     return fileURLToPath(new URL('../../', import.meta.url));
 }
+function harmonyPackageRoot(harmonyBinEntry) {
+    return dirname(dirname(harmonyBinEntry));
+}
+export function dshPackageModules(harmonyBinEntry) {
+    const configured = process.env.DSH_HARMONY_DSH_ENTRY;
+    const dshEntry = configured === undefined
+        ? createRequire(harmonyBinEntry).resolve('@deepseek-ai/dsh/lib/bin.js')
+        : resolve(configured);
+    let directory = dirname(dshEntry);
+    while (dirname(directory) !== directory) {
+        if (basename(directory) === 'node_modules')
+            return directory;
+        directory = dirname(directory);
+    }
+    throw new Error(`harmony-studio: cannot locate node_modules for ${JSON.stringify(dshEntry)}`);
+}
 function waitForExit(child, timeoutMs) {
     if (child.exitCode !== null || child.signalCode !== null)
         return Promise.resolve(true);
@@ -33,18 +53,21 @@ export class StudioPreviewSupervisor {
     commands;
     harmonyBinEntry;
     stopTimeoutMs;
+    portPool;
     child;
-    controlToken;
+    peerClient;
     runtime = { state: 'stopped', log: '' };
     startAbort;
     startPromise;
-    constructor(draft, mainProfileDir, parentOrigin, commands, harmonyBinEntry, stopTimeoutMs = 5_000) {
+    previewPort;
+    constructor(draft, mainProfileDir, parentOrigin, commands, harmonyBinEntry, stopTimeoutMs = 5_000, portPool = studioPreviewPortPool) {
         this.draft = draft;
         this.mainProfileDir = mainProfileDir;
         this.parentOrigin = parentOrigin;
         this.commands = commands;
         this.harmonyBinEntry = harmonyBinEntry;
         this.stopTimeoutMs = stopTimeoutMs;
+        this.portPool = portPool;
     }
     snapshot() {
         return { ...this.runtime };
@@ -72,22 +95,22 @@ export class StudioPreviewSupervisor {
         this.runtime = { state: 'starting', log: '[studio] Preparing Draft dependencies and isolated profile\n' };
         try {
             await installDraftDependencies(this.draft, this.commands, chunk => { this.runtime.log = appendLog(this.runtime.log, chunk); }, signal);
-            await materializeDraftProfile(this.draft, this.mainProfileDir, studioPackageRoot(), this.commands, chunk => { this.runtime.log = appendLog(this.runtime.log, chunk); }, signal);
+            await buildDraft(this.draft, this.commands, chunk => { this.runtime.log = appendLog(this.runtime.log, chunk); }, signal);
+            await materializeDraftProfile(this.draft, this.mainProfileDir, studioPackageRoot(), harmonyPackageRoot(this.harmonyBinEntry), this.commands, chunk => { this.runtime.log = appendLog(this.runtime.log, chunk); }, signal);
             signal.throwIfAborted();
-            const hostArgs = [this.harmonyBinEntry, 'web', '--port', '0'];
+            this.previewPort = this.portPool.claim();
+            const hostArgs = [this.harmonyBinEntry, 'web', '--port', String(this.previewPort ?? 0), '--no-open'];
             this.runtime.log = appendLog(this.runtime.log, `[studio] Profile dependencies ready\n[studio] Starting Preview Host\nDSH_HOME=${this.draft.runtimeHome}\n${terminalCommandLine(this.draft.worktreeDir, process.execPath, hostArgs)}`);
-            const controlToken = randomBytes(32).toString('hex');
             const bridgeCapability = randomBytes(24).toString('base64url');
-            this.controlToken = controlToken;
             const child = spawn(process.execPath, hostArgs, {
                 cwd: this.draft.worktreeDir,
                 env: {
                     ...process.env,
                     DSH_HOME: this.draft.runtimeHome,
                     DSH_STUDIO_PREVIEW_DRAFT_ROOT: this.draft.root,
-                    DSH_STUDIO_PREVIEW_CONTROL_TOKEN: controlToken,
                     DSH_STUDIO_PREVIEW_PARENT_ORIGIN: this.parentOrigin,
                     DSH_STUDIO_PREVIEW_BRIDGE_CAPABILITY: bridgeCapability,
+                    DSH_STUDIO_PREVIEW_PACKAGE_DIRS: JSON.stringify([dshPackageModules(this.harmonyBinEntry)]),
                     DSH_HARMONY_REACT_TRACE: '1',
                 },
                 stdio: ['ignore', 'pipe', 'pipe'],
@@ -97,12 +120,11 @@ export class StudioPreviewSupervisor {
                 this.runtime.log = appendLog(this.runtime.log, chunk);
                 const match = this.runtime.log.match(/dsh web:\s+(http:\/\/127\.0\.0\.1:\d+)/);
                 if (match?.[1] !== undefined) {
+                    const { error: _error, ...runtime } = this.runtime;
                     this.runtime = {
-                        ...this.runtime,
-                        state: 'running',
+                        ...runtime,
                         previewUrl: `${match[1]}/#dsh-studio-preview=${encodeURIComponent(bridgeCapability)}`,
                         bridgeCapability,
-                        error: undefined,
                     };
                 }
             });
@@ -111,18 +133,28 @@ export class StudioPreviewSupervisor {
                 if (this.child !== child)
                     return;
                 this.child = undefined;
-                this.controlToken = undefined;
+                const peerClient = this.peerClient;
+                this.peerClient = undefined;
+                void peerClient?.close();
+                this.releasePreviewPort();
                 if (this.runtime.state === 'stopped')
                     return;
                 const error = `Preview Host exited (${signal ?? code ?? 'unknown'})`;
                 this.runtime = { state: 'failed', error, log: this.runtime.log };
             });
-            await this.waitUntilRunning(child, signal);
+            await this.waitForPreviewUrl(child, signal);
+            const peerClient = new NodePeerClient({
+                baseUrl: new URL('/', this.runtime.previewUrl),
+                contribution: STUDIO_PREVIEW_REMOTE,
+            });
+            this.peerClient = peerClient;
             await this.waitForWorker(child, signal);
-            await this.worker('state', {}, signal);
+            await this.invoke(this.remote().state(signal));
+            this.runtime = { ...this.runtime, state: 'running' };
             return this.snapshot();
         }
         catch (error) {
+            await this.closePeer();
             await this.terminateChild();
             if (signal.aborted) {
                 this.runtime = { state: 'stopped', log: this.runtime.log };
@@ -135,8 +167,8 @@ export class StudioPreviewSupervisor {
     async stop() {
         this.startAbort?.abort(new Error('Preview start canceled'));
         const start = this.startPromise;
-        this.controlToken = undefined;
         this.runtime = { state: 'stopped', log: this.runtime.log };
+        await this.closePeer();
         await this.terminateChild();
         if (start !== undefined) {
             try {
@@ -144,7 +176,6 @@ export class StudioPreviewSupervisor {
             }
             catch { }
         }
-        this.controlToken = undefined;
         this.runtime = { state: 'stopped', log: this.runtime.log };
         return this.snapshot();
     }
@@ -163,72 +194,122 @@ export class StudioPreviewSupervisor {
         }
         if (this.child === child)
             this.child = undefined;
+        this.releasePreviewPort();
+    }
+    releasePreviewPort() {
+        this.portPool.release(this.previewPort);
+        this.previewPort = undefined;
     }
     async state() {
-        return (await this.worker('state', {})).project;
+        return this.invoke(this.remote().state());
     }
     async activate(graphRev) {
-        return (await this.worker('activate', { graphRev })).project;
+        return this.invoke(this.remote().activate(graphRev));
     }
     async applyBuild() {
-        return (await this.worker('apply-build', {})).project;
+        await this.commands.run(process.execPath, [this.harmonyBinEntry, 'harmony', 'reload', this.draft.name], this.draft.worktreeDir, chunk => { this.runtime.log = appendLog(this.runtime.log, chunk); }, undefined, { ...process.env, DSH_HOME: this.draft.runtimeHome });
+        await this.reconnectPeer();
+        return this.invoke(this.remote().applyBuild(randomUUID()));
     }
     async inspect(input = {}) {
-        return this.worker('inspect', input);
+        return this.invoke(this.remote().inspect(input));
+    }
+    async profile() {
+        return this.invoke(this.remote().profile());
+    }
+    async updateProfile(input) {
+        const operation = { ...input, operationId: randomUUID() };
+        try {
+            return await this.invoke(this.remote().updateProfile(operation));
+        }
+        catch (error) {
+            if (!this.isGenerationLoss(error))
+                throw error;
+        }
+        await this.reconnectPeer();
+        return this.invoke(this.remote().updateProfile(operation));
     }
     async resolveSource(source) {
-        return this.worker('resolve-source', { source });
+        return this.invoke(this.remote().resolveSource(source));
     }
     async readDependencySource(packageName, file) {
-        return this.worker('read-source', { package: packageName, file });
+        return this.invoke(this.remote().readSource(packageName, file));
+    }
+    async readPatchTarget(packageName, file) {
+        return this.invoke(this.remote().readPatchTarget(packageName, file));
     }
     async dispose() {
         await this.stop();
     }
-    async waitUntilRunning(child, signal) {
+    async waitForPreviewUrl(child, signal) {
         const started = Date.now();
-        while (this.child === child && this.runtime.state === 'starting' && Date.now() - started < START_TIMEOUT_MS) {
+        while (this.child === child && this.runtime.previewUrl === undefined && Date.now() - started < START_TIMEOUT_MS) {
             await this.delay(50, signal);
         }
         signal.throwIfAborted();
-        if (this.runtime.state !== 'running')
-            throw new Error(this.runtime.error ?? 'Preview Host did not publish its URL before timeout');
+        if (this.runtime.previewUrl === undefined) {
+            throw new Error(`${this.runtime.error ?? 'Preview Host did not publish its URL before timeout'}\n${this.runtime.log}`);
+        }
     }
     async waitForWorker(child, signal) {
         const started = Date.now();
-        let lastError = 'worker route was not reachable';
+        let lastError = 'Preview worker is still preparing the Draft';
         while (this.child === child && Date.now() - started < START_TIMEOUT_MS) {
             try {
                 const requestSignal = AbortSignal.any([signal, AbortSignal.timeout(1_000)]);
-                await this.worker('health', {}, requestSignal);
-                return;
+                await this.peerClient?.connect(requestSignal);
+                const health = await this.invoke(this.remote().health(requestSignal));
+                if (health.ready)
+                    return;
+                if (health.error !== undefined)
+                    throw new Error(health.error);
             }
             catch (error) {
                 signal.throwIfAborted();
                 lastError = error instanceof Error ? error.message : String(error);
-                await this.delay(50, signal);
             }
+            await this.delay(50, signal);
         }
         signal.throwIfAborted();
         throw new Error(`Preview worker did not become ready before timeout: ${lastError}`);
     }
-    async worker(method, payload, signal) {
-        if (this.runtime.previewUrl === undefined || this.controlToken === undefined)
+    remote() {
+        if (this.peerClient === undefined)
             throw new Error('Preview Host is not running');
-        const endpoint = new URL(`${STUDIO_PREVIEW_API_PATH}/${method}`, this.runtime.previewUrl);
-        const response = await fetch(endpoint, {
-            method: 'POST',
-            headers: { authorization: `Bearer ${this.controlToken}`, 'content-type': 'application/json' },
-            body: JSON.stringify(payload),
-            signal,
-        });
-        const text = await response.text();
-        if (text === '')
-            throw new Error(`Preview worker returned an empty HTTP ${response.status} response`);
-        const body = JSON.parse(text);
-        if (!response.ok || !body.ok)
-            throw new Error(body.ok ? `Preview worker failed with HTTP ${response.status}` : body.error);
-        return body.value;
+        return this.peerClient.remote.studioPreviewWorker;
+    }
+    async invoke(result) {
+        const settled = await result;
+        if (settled.ok)
+            return settled.value;
+        throw new Error(`${settled.error.code}: ${settled.error.message}`);
+    }
+    async closePeer() {
+        const peerClient = this.peerClient;
+        this.peerClient = undefined;
+        await peerClient?.close();
+    }
+    isGenerationLoss(error) {
+        return error instanceof Error && error.message.includes('Node peer connection closed');
+    }
+    async reconnectPeer() {
+        const peerClient = this.peerClient;
+        if (peerClient === undefined || this.runtime.state !== 'running') {
+            throw new Error('Preview Host is not running');
+        }
+        const signal = AbortSignal.timeout(START_TIMEOUT_MS);
+        let lastError;
+        while (!signal.aborted) {
+            try {
+                await peerClient.connect(signal);
+                return;
+            }
+            catch (error) {
+                lastError = error;
+            }
+            await this.delay(50, signal);
+        }
+        throw new Error('Preview peer did not reconnect after Harmony reload', { cause: lastError });
     }
     async delay(milliseconds, signal) {
         signal.throwIfAborted();

package/lib/host/readiness.d.ts

@@ -1,6 +1,6 @@
 import type { SubprocessRuntime } from '@deepseek-ai/dsh-subprocess';
-import type { StudioHarmonyInspection, StudioPackResult, StudioReadinessReport, StudioPatchDependency } from '../contracts.js';
-export declare function inspectReadiness(root: string, projectName: string, inspection: StudioHarmonyInspection, profileDir: string, dependencies?: StudioPatchDependency[]): StudioReadinessReport;
+import type { StudioHarmonyInspection, StudioPackResult, StudioReadinessReport } from '../contracts.js';
+export declare function inspectReadiness(root: string, projectName: string, inspection: StudioHarmonyInspection, profileDir: string): StudioReadinessReport;
 export declare class StudioPackRunner {
     private readonly subprocess;
     private readonly timeoutMs;

package/lib/host/readiness.js

@@ -43,7 +43,7 @@ function artifactFinding(root, path, label) {
 function readManifest(root) {
     return JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
 }
-export function inspectReadiness(root, projectName, inspection, profileDir, dependencies = []) {
+export function inspectReadiness(root, projectName, inspection, profileDir) {
     const manifest = readManifest(root);
     const findings = [];
     if (typeof manifest.name !== 'string' || manifest.name === '') {
@@ -110,7 +110,6 @@ export function inspectReadiness(root, projectName, inspection, profileDir, depe
         }
     }
     const declared = new Set([...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.peerDependencies ?? {})]);
-    const declaredAfter = new Set(stringArray(harmony?.after));
     for (const dependency of stringArray(manifest.dsh?.client?.inject)) {
         if (!declared.has(dependency)) {
             findings.push(finding('warning', 'ambient-client-service', `Client inject ${JSON.stringify(dependency)} is supplied by the current profile but is not declared as a dependency or peer dependency`));
@@ -123,28 +122,26 @@ export function inspectReadiness(root, projectName, inspection, profileDir, depe
     }
     const patches = inspection.patches.filter(patch => patch.owner === projectName);
     for (const patch of patches) {
-        if (!declared.has(patch.target.package)) {
-            findings.push(finding('warning', 'ambient-patch-target', `Patch target ${JSON.stringify(patch.target.package)} is available in this Preview but is not declared as a dependency or peer dependency`, { patch: patch.key }));
-        }
-        if (patch.target.version === undefined) {
-            findings.push(finding('warning', 'unbounded-target-version', `Patch ${JSON.stringify(patch.key)} does not constrain the target package version`, { patch: patch.key }));
+        const file = patch.targets[0]?.file;
+        const targets = new Map(patch.targets.map(target => [`${target.package}\0${target.version ?? ''}`, target]));
+        for (const target of targets.values()) {
+            if (!declared.has(target.package)) {
+                findings.push(finding('warning', 'ambient-patch-target', `Patch target ${JSON.stringify(target.package)} is available in this Preview but is not declared as a dependency or peer dependency`, { patch: patch.key }));
+            }
+            if (target.version === undefined) {
+                findings.push(finding('warning', 'unbounded-target-version', `Patch ${JSON.stringify(patch.key)} does not constrain target package ${JSON.stringify(target.package)}`, { patch: patch.key }));
+            }
         }
         if (patch.state === 'failed') {
-            findings.push(finding('error', 'patch-failed', patch.error ?? `Patch ${JSON.stringify(patch.key)} failed against the current provider stack`, { patch: patch.key, file: patch.file }));
+            findings.push(finding('error', 'patch-failed', patch.error ?? `Patch ${JSON.stringify(patch.key)} failed against the current provider stack`, { patch: patch.key, file }));
         }
         else if (patch.state === 'disabled') {
-            findings.push(finding('warning', 'patch-disabled', `Patch ${JSON.stringify(patch.key)} is disabled in the current profile`, { patch: patch.key, file: patch.file }));
+            findings.push(finding('warning', 'patch-disabled', `Patch ${JSON.stringify(patch.key)} is disabled in the current profile`, { patch: patch.key, file }));
         }
-        else if (patch.state === 'pending' || !patch.loaded) {
-            findings.push(finding('warning', 'patch-unverified', `Patch ${JSON.stringify(patch.key)} has not been exercised by the current Preview`, { patch: patch.key, file: patch.file }));
+        else if (patch.state === 'pending') {
+            findings.push(finding('warning', 'patch-unverified', `Patch ${JSON.stringify(patch.key)} has not been exercised by the current Preview`, { patch: patch.key, file }));
         }
     }
-    for (const dependency of dependencies) {
-        const explicit = dependency.providerCandidates.filter(provider => declared.has(provider) && declaredAfter.has(provider));
-        if (dependency.providerCandidates.length === 1 && explicit.length === 1)
-            continue;
-        findings.push(finding('warning', 'differential-provider-stack', `Patch ${JSON.stringify(dependency.patch)} fails against the base target but succeeds against the current transformed stack. Earlier provider candidates: ${dependency.providerCandidates.map(provider => JSON.stringify(provider)).join(', ')}. Inspect the ordered Patch steps before declaring a dependency or dsh.harmony.after relationship`, { patch: dependency.patch, file: dependency.target.file }));
-    }
     const orderPath = join(profileDir, 'harmony.json');
     if (existsSync(orderPath)) {
         const order = JSON.parse(readFileSync(orderPath, 'utf8')).order;

package/lib/host/routes.d.ts

@@ -1,6 +1,5 @@
 import type { IncomingMessage } from 'node:http';
 import type { WebRoute } from '@deepseek-ai/dsh-host-webserver';
-import type { StudioBackend } from './backend.js';
 export interface StudioAssets {
     script: Buffer;
     style: Buffer;
@@ -8,10 +7,5 @@ export interface StudioAssets {
     icon: Buffer;
     iconMono: Buffer;
 }
-export interface StudioRouteSecurity {
-    token: string;
-    origin: string;
-    host: string;
-}
 export declare function isTrustedStudioRequest(request: IncomingMessage): boolean;
-export declare function createStudioRoutes(backend: StudioBackend, assets: StudioAssets, security: StudioRouteSecurity): WebRoute[];
+export declare function createStudioRoutes(assets: StudioAssets, ready?: () => boolean): WebRoute[];

package/lib/host/routes.js

@@ -1,5 +1,4 @@
-import { STUDIO_API_PATH, STUDIO_PATH } from '../contracts.js';
-const MAX_BODY_BYTES = 1024 * 1024;
+import { STUDIO_PATH } from '../contracts.js';
 function remoteIsLoopback(request) {
     const address = request.socket.remoteAddress;
     return address === '::1' || address === '127.0.0.1' || address?.startsWith('127.') === true
@@ -11,18 +10,6 @@ export function isTrustedStudioRequest(request) {
     const fetchSite = request.headers['sec-fetch-site'];
     return fetchSite === undefined || fetchSite === 'same-origin' || fetchSite === 'none';
 }
-async function readJson(request) {
-    const chunks = [];
-    let size = 0;
-    for await (const chunk of request) {
-        const buffer = Buffer.from(chunk);
-        size += buffer.length;
-        if (size > MAX_BODY_BYTES)
-            throw new Error('request body is too large');
-        chunks.push(buffer);
-    }
-    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
-}
 function sendJson(response, status, value) {
     response.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
     response.end(JSON.stringify(value));
@@ -35,9 +22,9 @@ function sendAsset(request, response, contentType, body) {
     });
     response.end(request.method === 'HEAD' ? undefined : body);
 }
-function documentHtml(token) {
+function documentHtml() {
     return `<!doctype html>
-<html lang="zh-CN">
+<html lang="en">
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
@@ -45,7 +32,6 @@ function documentHtml(token) {
     <meta name="referrer" content="no-referrer" />
     <title>DeepSeek WebUI Studio</title>
     <link rel="stylesheet" href="${STUDIO_PATH}/assets/studio.css" />
-    <script>window.__DSH_STUDIO__={token:${JSON.stringify(token)}};</script>
   </head>
   <body>
     <div id="root"></div>
@@ -53,10 +39,30 @@ function documentHtml(token) {
   </body>
 </html>`;
 }
-function hasStudioCapability(request, security) {
-    return request.headers.host === security.host
-        && request.headers.origin === security.origin
-        && request.headers['x-dsh-studio-token'] === security.token;
+function harmonySetupHtml() {
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="light dark" />
+    <title>DeepSeek WebUI Studio</title>
+    <style>html,body,iframe{width:100%;height:100%;margin:0;border:0}body{overflow:hidden}</style>
+  </head>
+  <body>
+    <iframe src="/" title="Install Harmony for DeepSeek WebUI Studio"></iframe>
+    <script>
+      const waitForHarmony = async () => {
+        try {
+          const status = await fetch('/dsh-harmony/runtime').then(response => response.json())
+          if (status.state === 'active') return location.reload()
+        } catch {}
+        setTimeout(waitForHarmony, 750)
+      }
+      waitForHarmony()
+    </script>
+  </body>
+</html>`;
 }
 function rejectUntrusted(request, response) {
     if (isTrustedStudioRequest(request))
@@ -64,43 +70,29 @@ function rejectUntrusted(request, response) {
     sendJson(response, 403, { error: 'Studio is available from the local machine only.' });
     return true;
 }
-export function createStudioRoutes(backend, assets, security) {
-    const page = Buffer.from(documentHtml(security.token));
-    const apiHandler = async (request, response) => {
-        if (rejectUntrusted(request, response))
-            return;
-        if (!hasStudioCapability(request, security))
-            return sendJson(response, 403, { error: 'invalid Studio capability' });
-        if (request.method !== 'POST')
-            return sendJson(response, 405, { error: 'method not allowed' });
-        if ((request.headers['content-type'] ?? '').split(';')[0] !== 'application/json') {
-            return sendJson(response, 415, { error: 'content-type must be application/json' });
-        }
-        const path = new URL(request.url ?? '/', 'http://localhost').pathname;
-        const method = path.slice(`${STUDIO_API_PATH}/`.length);
-        try {
-            const body = await readJson(request);
-            const candidate = body;
-            if (candidate.type !== 'client-request' || typeof candidate.rpcId !== 'string'
-                || candidate.method !== method) {
-                return sendJson(response, 400, { error: 'invalid client-request' });
-            }
-            sendJson(response, 200, await backend.call(candidate));
-        }
-        catch (error) {
-            sendJson(response, 400, { error: error instanceof Error ? error.message : String(error) });
-        }
-    };
+export function createStudioRoutes(assets, ready = () => true) {
+    const page = Buffer.from(documentHtml());
+    const setupPage = Buffer.from(harmonySetupHtml());
     return [
+        {
+            kind: 'prefix',
+            path: `${STUDIO_PATH}/api`,
+            handler(_request, response) {
+                sendJson(response, 404, { error: 'not found' });
+            },
+        },
         {
             kind: 'exact',
             path: STUDIO_PATH,
             handler(request, response) {
                 if (rejectUntrusted(request, response))
                     return;
+                if (new URL(request.url ?? '/', 'http://localhost').pathname !== STUDIO_PATH) {
+                    return sendJson(response, 404, { error: 'not found' });
+                }
                 if (request.method !== 'GET' && request.method !== 'HEAD')
                     return sendJson(response, 405, { error: 'method not allowed' });
-                sendAsset(request, response, 'text/html; charset=utf-8', page);
+                sendAsset(request, response, 'text/html; charset=utf-8', ready() ? page : setupPage);
             },
         },
         {
@@ -158,6 +150,5 @@ export function createStudioRoutes(backend, assets, security) {
                 sendAsset(request, response, 'image/png', assets.iconMono);
             },
         },
-        { kind: 'prefix', path: STUDIO_API_PATH, handler: apiHandler },
     ];
 }

package/lib/host/runtime-profile.d.ts

@@ -12,5 +12,6 @@ export declare function bundledPnpmCommand(args: readonly string[]): [string, st
 export declare function terminalCommandLine(cwd: string, command: string, args: readonly string[]): string;
 export declare function assertDraftPackageIdentity(draft: StudioDraftRecord): Promise<DraftManifest>;
 export declare function installDraftDependencies(draft: StudioDraftRecord, commands: StudioCommandRunner, onOutput?: (chunk: string) => void, signal?: AbortSignal): Promise<void>;
-export declare function materializeDraftProfile(draft: StudioDraftRecord, mainProfileDir: string, studioPackageRoot: string, commands: StudioCommandRunner, onOutput?: (chunk: string) => void, signal?: AbortSignal): Promise<string>;
+export declare function buildDraft(draft: StudioDraftRecord, commands: StudioCommandRunner, onOutput?: (chunk: string) => void, signal?: AbortSignal): Promise<void>;
+export declare function materializeDraftProfile(draft: StudioDraftRecord, mainProfileDir: string, studioPackageRoot: string, harmonyPackageRoot: string, commands: StudioCommandRunner, onOutput?: (chunk: string) => void, signal?: AbortSignal): Promise<string>;
 export {};

package/lib/host/runtime-profile.js

@@ -1,10 +1,11 @@
 import { createRequire } from 'node:module';
 import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
-import { resolvePackageManager } from './build.js';
+import { resolveBuildArgv, resolvePackageManager } from './build.js';
 const PROFILE_FILES = ['cordis.patch.yml', 'cordis.yml', 'harmony.json', 'pnpm-workspace.yaml'];
 const require = createRequire(import.meta.url);
 const PNPM_ENTRY = join(dirname(require.resolve('pnpm')), 'bin', 'pnpm.cjs');
+const BINDING_PACKAGE_ROOT = process.env.DSH_STUDIO_BINDING_ROOT ?? dirname(require.resolve('the-binding-of-dsh/package.json'));
 export function bundledPnpmCommand(args) {
     return [process.execPath, [PNPM_ENTRY, ...args]];
 }
@@ -31,7 +32,7 @@ export async function installDraftDependencies(draft, commands, onOutput, signal
     if (!hasDependencies(manifest))
         return;
     const manager = resolvePackageManager(draft.root, manifest);
-    const [command, args] = manager === 'pnpm' ? bundledPnpmCommand(['install']) : [manager, ['install']];
+    const [command, args] = manager === 'pnpm' ? bundledPnpmCommand(['install', '--prefer-offline']) : [manager, ['install']];
     onOutput?.(terminalCommandLine(draft.root, command, args));
     try {
         await commands.run(command, args, draft.root, onOutput, signal);
@@ -43,27 +44,48 @@ export async function installDraftDependencies(draft, commands, onOutput, signal
         throw new Error('Draft dependency installation failed. Check the startup terminal for details.');
     }
 }
+export async function buildDraft(draft, commands, onOutput, signal) {
+    signal?.throwIfAborted();
+    const [manager, ...args] = resolveBuildArgv(draft.root);
+    const [command, commandArgs] = manager === 'pnpm' ? bundledPnpmCommand(args) : [manager, args];
+    onOutput?.(terminalCommandLine(draft.root, command, commandArgs));
+    try {
+        await commands.run(command, commandArgs, draft.root, onOutput, signal);
+    }
+    catch (error) {
+        signal?.throwIfAborted();
+        const message = (error instanceof Error ? error.message : String(error)).split('\n', 1)[0];
+        onOutput?.(`[studio] ${message}\n`);
+        throw new Error('Initial Draft build failed. Check the startup terminal for details.');
+    }
+}
 function absoluteLink(spec, profileDir) {
     if (!spec.startsWith('link:'))
         return spec;
     const target = spec.slice('link:'.length);
     return `link:${isAbsolute(target) ? target : resolve(profileDir, target)}`;
 }
-export async function materializeDraftProfile(draft, mainProfileDir, studioPackageRoot, commands, onOutput, signal) {
+export async function materializeDraftProfile(draft, mainProfileDir, studioPackageRoot, harmonyPackageRoot, commands, onOutput, signal) {
     signal?.throwIfAborted();
-    if (draft.profileMode !== 'main-home')
-        throw new Error('Custom Draft profiles are not implemented yet');
+    let sourceProfileDir = mainProfileDir;
+    if (draft.profileMode === 'custom') {
+        if (draft.profileDirectory === undefined)
+            throw new Error('Custom Draft profile folder is missing');
+        sourceProfileDir = draft.profileDirectory;
+    }
     const profileDir = join(draft.runtimeHome, 'profiles', 'web');
     await rm(profileDir, { recursive: true, force: true });
     await mkdir(profileDir, { recursive: true });
-    const manifest = JSON.parse(await readFile(join(mainProfileDir, 'package.json'), 'utf8'));
-    const dependencies = Object.fromEntries(Object.entries(manifest.dependencies ?? {}).map(([name, spec]) => [name, absoluteLink(spec, mainProfileDir)]));
+    const manifest = JSON.parse(await readFile(join(sourceProfileDir, 'package.json'), 'utf8'));
+    const dependencies = Object.fromEntries(Object.entries(manifest.dependencies ?? {}).map(([name, spec]) => [name, absoluteLink(spec, sourceProfileDir)]));
     dependencies[draft.name] = `link:${draft.root}`;
     dependencies['dsh-webui-studio'] = `link:${studioPackageRoot}`;
+    dependencies['dsh-harmony'] = `link:${harmonyPackageRoot}`;
+    dependencies['the-binding-of-dsh'] = `link:${BINDING_PACKAGE_ROOT}`;
     await writeFile(join(profileDir, 'package.json'), `${JSON.stringify({ ...manifest, dependencies }, null, 2)}\n`);
     for (const file of PROFILE_FILES) {
         try {
-            await cp(join(mainProfileDir, file), join(profileDir, file));
+            await cp(join(sourceProfileDir, file), join(profileDir, file));
         }
         catch (error) {
             if (error.code !== 'ENOENT')

package/lib/host/source-resolution.d.ts

@@ -1,7 +1,17 @@
 import type { StudioSourceCandidate, StudioSourceLocation } from '../contracts.js';
 export declare class StudioSourceResolver {
     #private;
-    constructor(draftRoot: string, profileDir: string);
+    private readonly draftRoot;
+    private readonly profileDir;
+    private readonly packageDirs;
+    constructor(draftRoot: string | undefined, profileDir: string, packageDirs?: string[]);
+    private roots;
     resolve(source: StudioSourceLocation): Promise<StudioSourceCandidate>;
     readDependency(packageName: string, file: string): Promise<string>;
+    readDependencyTarget(packageName: string, file: string): Promise<{
+        package: string;
+        file: string;
+        version: string;
+        source: string;
+    }>;
 }