dsh-webui-studio 0.1.0 → 0.2.0

package/lib/host/source-resolution.js

@@ -1,4 +1,4 @@
-import { lstat, readFile, realpath } from 'node:fs/promises';
+import { lstat, readFile, readdir, realpath } from 'node:fs/promises';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const MAX_SOURCE_BYTES = 1024 * 1024;
@@ -16,6 +16,16 @@ function relativeSource(path) {
     }
     return normalized;
 }
+function clientExport(manifest) {
+    if (typeof manifest.exports !== 'object' || manifest.exports === null)
+        return undefined;
+    const entry = manifest.exports['./client'];
+    const target = typeof entry === 'string' ? entry
+        : typeof entry === 'object' && entry !== null && typeof entry.default === 'string'
+            ? entry.default
+            : undefined;
+    return target === undefined ? undefined : relativeSource(target);
+}
 function sourceReference(file) {
     const trimmed = file.trim();
     if (trimmed.startsWith('file:')) {
@@ -54,33 +64,44 @@ async function packageRoot(path, expectedName) {
     try {
         const root = await realpath(path);
         const manifest = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
-        return manifest.name === expectedName ? { name: expectedName, root, kind: 'dependency' } : undefined;
+        const client = clientExport(manifest);
+        return manifest.name === expectedName
+            ? { name: expectedName, root, kind: 'dependency', ...(client === undefined ? {} : { client }) }
+            : undefined;
     }
     catch {
         return undefined;
     }
 }
-async function packageRoots(draftRoot, profileDir) {
-    const draft = await realpath(draftRoot);
-    const manifest = JSON.parse(await readFile(join(profileDir, 'package.json'), 'utf8'));
-    const dependencies = Object.keys(manifest.dependencies ?? {});
-    const bundles = manifest.dsh?.profile?.bundles ?? [];
-    const roots = [{
-            name: JSON.parse(await readFile(join(draft, 'package.json'), 'utf8')).name,
+async function installedPackageNames(nodeModules) {
+    const entries = (await readdir(nodeModules)).filter(name => !name.startsWith('.'));
+    const names = await Promise.all(entries.map(async (name) => name.startsWith('@')
+        ? readdir(join(nodeModules, name)).then(packages => packages.filter(item => !item.startsWith('.')).map(item => `${name}/${item}`))
+        : [name]));
+    return names.flat();
+}
+async function packageRoots(draftRoot, nodeModulesDirs) {
+    const roots = [];
+    if (draftRoot !== undefined) {
+        const draft = await realpath(draftRoot);
+        const draftManifest = JSON.parse(await readFile(join(draft, 'package.json'), 'utf8'));
+        const draftClient = clientExport(draftManifest);
+        roots.push({
+            name: draftManifest.name,
             root: draft,
             kind: 'draft',
-        }];
-    for (const name of dependencies) {
-        const installed = await packageRoot(join(profileDir, 'node_modules', ...name.split('/')), name);
-        if (installed !== undefined)
-            roots.push(installed);
+            ...(draftClient === undefined ? {} : { client: draftClient }),
+        });
     }
-    for (const name of bundles.filter(name => !dependencies.includes(name))) {
-        const installed = await packageRoot(join(profileDir, 'node_modules', ...name.split('/')), name);
-        if (installed !== undefined)
-            roots.push(installed);
+    for (const nodeModules of nodeModulesDirs) {
+        for (const name of await installedPackageNames(nodeModules)) {
+            const installed = await packageRoot(join(nodeModules, ...name.split('/')), name);
+            if (installed !== undefined)
+                roots.push(installed);
+        }
     }
-    return roots.filter((item, index, all) => all.findIndex(candidate => candidate.root === item.root) === index);
+    return roots.filter((item, index, all) => all.findIndex(candidate => candidate.root === item.root
+        || item.kind === 'dependency' && candidate.kind === 'dependency' && candidate.name === item.name) === index);
 }
 function result(source, file, kind, confidence, packageName) {
     return {
@@ -104,13 +125,30 @@ async function exactMatch(path, roots) {
     const root = matches[0];
     return root === undefined ? undefined : { root, file: posix(relative(root.root, target)) };
 }
+async function pluginClientMatch(path, roots) {
+    const route = path.trim().replace(/[?#].*$/, '');
+    const root = roots.find(item => route === `/plugins/${item.name}/client.js` && item.client !== undefined);
+    return root?.client === undefined ? undefined : exactMatch(resolve(root.root, root.client), [root]);
+}
 export class StudioSourceResolver {
+    draftRoot;
+    profileDir;
+    packageDirs;
     #roots;
-    constructor(draftRoot, profileDir) {
-        this.#roots = packageRoots(draftRoot, profileDir);
+    constructor(draftRoot, profileDir, packageDirs = []) {
+        this.draftRoot = draftRoot;
+        this.profileDir = profileDir;
+        this.packageDirs = packageDirs;
+    }
+    roots() {
+        return this.#roots ??= packageRoots(this.draftRoot, [join(this.profileDir, 'node_modules'), ...this.packageDirs]);
     }
     async resolve(source) {
-        const roots = await this.#roots;
+        const roots = await this.roots();
+        const pluginClient = await pluginClientMatch(source.file, roots);
+        if (pluginClient !== undefined) {
+            return result(source, pluginClient.file, pluginClient.root.kind, 'exact', pluginClient.root.name);
+        }
         const reference = sourceReference(source.file);
         if (reference.absolute !== undefined) {
             const match = await exactMatch(reference.absolute, roots);
@@ -130,10 +168,13 @@ export class StudioSourceResolver {
         return result(source, source.file, reference.generated ? 'generated' : 'unknown', 'candidate');
     }
     async readDependency(packageName, file) {
+        return (await this.readDependencyTarget(packageName, file)).source;
+    }
+    async readDependencyTarget(packageName, file) {
         const relativeFile = relativeSource(file);
         if (packageName === '' || relativeFile === undefined)
             throw new Error('dependency source reference is invalid');
-        const roots = (await this.#roots).filter(root => root.kind === 'dependency' && root.name === packageName);
+        const roots = (await this.roots()).filter(root => root.kind === 'dependency' && root.name === packageName);
         if (roots.length !== 1)
             throw new Error(`dependency package ${JSON.stringify(packageName)} is not uniquely installed in Preview`);
         const match = await exactMatch(resolve(roots[0].root, relativeFile), roots);
@@ -149,6 +190,10 @@ export class StudioSourceResolver {
         const content = await readFile(target);
         if (content.includes(0))
             throw new Error('binary dependency sources cannot be read');
-        return content.toString('utf8');
+        const manifest = JSON.parse(await readFile(join(roots[0].root, 'package.json'), 'utf8'));
+        if (typeof manifest.version !== 'string' || manifest.version === '') {
+            throw new Error(`dependency package ${JSON.stringify(packageName)} does not declare a version`);
+        }
+        return { package: packageName, file: relativeFile, version: manifest.version, source: content.toString('utf8') };
     }
 }

package/lib/host/studio-service.d.ts

@@ -0,0 +1,129 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { TypertContribution } from '@deepseek-ai/dsh-typert-registry/types';
+import type { StudioAutomaticPatchRequest, StudioCreateDraftInput, StudioElementStyleSource, StudioPreviewUpdate, StudioSourceLocation, StudioWorkspaceState } from '../contracts.js';
+import { StudioBackend } from './backend.js';
+export declare const STUDIO_LOCAL: TypertContribution;
+export declare class StudioService extends TypertRemoteService {
+    private readonly backend;
+    constructor(ctx: Context, backend: StudioBackend);
+    currentGet(signal: AbortSignal): import("../contracts.js").StudioCurrentInstanceView;
+    currentPreviewStatus(signal: AbortSignal): import("../contracts.js").StudioPreviewStatus;
+    currentPreviewUpdate(input: StudioPreviewUpdate, signal: AbortSignal): import("../contracts.js").StudioPreviewStatus;
+    currentResolveSource(input: {
+        source: StudioSourceLocation;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioSourceCandidate>;
+    currentAgentCreate(input: {
+        agentPreset?: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioAgentBinding>;
+    currentAgentAttach(input: {
+        sessionId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioAgentBinding>;
+    currentAgentLeave(signal: AbortSignal): Promise<import("../contracts.js").StudioCurrentInstanceView>;
+    draftsList(signal: AbortSignal): Promise<import("../contracts.js").StudioDraftView[]>;
+    draftsCreate(input: StudioCreateDraftInput, signal: AbortSignal): Promise<import("../contracts.js").StudioDraftView>;
+    draftsRename(input: {
+        draftId: string;
+        label: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioDraftView>;
+    draftsExport(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioDraftView>;
+    draftsStart(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioDraftView>;
+    draftsStop(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioDraftView>;
+    workspaceGet(signal: AbortSignal): Promise<StudioWorkspaceState>;
+    workspaceUpdate(input: StudioWorkspaceState, signal: AbortSignal): Promise<StudioWorkspaceState>;
+    harmonyProfile(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioHarmonyProfile>;
+    harmonyInspect(input: {
+        draftId: string;
+        package?: string;
+        file?: string;
+    }, signal: AbortSignal): Promise<import("dsh-harmony").HarmonyInspection>;
+    harmonyUpdateProfile(input: {
+        draftId: string;
+        order?: string[];
+        patchOrder?: string[];
+        disabled?: string[];
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioHarmonyProfileUpdateResult>;
+    projectState(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioProjectState>;
+    projectActivate(input: {
+        draftId: string;
+        graphRev: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioProjectState>;
+    projectFiles(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioProjectFile[]>;
+    projectReadFile(input: {
+        draftId: string;
+        path: string;
+    }, signal: AbortSignal): Promise<{
+        path: string;
+        content: string;
+    }>;
+    projectWriteFile(input: {
+        draftId: string;
+        path: string;
+        content: string;
+    }, signal: AbortSignal): Promise<{
+        path: string;
+        saved: true;
+    }>;
+    projectBuild(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioBuildResult>;
+    projectCancelBuild(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<{
+        canceled: boolean;
+    }>;
+    elementsStyles(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<StudioElementStyleSource[]>;
+    elementsSaveSource(input: {
+        draftId: string;
+        styles: StudioElementStyleSource[];
+    }, signal: AbortSignal): Promise<{
+        files: string[];
+    }>;
+    patchesAnalyzeAutomatic(input: StudioAutomaticPatchRequest & {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioAutomaticPatchPlan>;
+    patchesCreateAutomatic(input: StudioAutomaticPatchRequest & {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioAutomaticPatchWriteResult>;
+    readinessInspect(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioReadinessReport>;
+    readinessPack(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioReadinessReport>;
+    previewStatus(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioPreviewStatus>;
+    previewUpdate(input: StudioPreviewUpdate & {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioPreviewStatus>;
+    previewResolveSource(input: {
+        draftId: string;
+        source: StudioSourceLocation;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioSourceCandidate>;
+    agentCreate(input: {
+        draftId: string;
+        agentPreset?: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioAgentBinding>;
+    agentAttach(input: {
+        draftId: string;
+        sessionId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioAgentBinding>;
+    agentLeave(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<import("../contracts.js").StudioDraftView>;
+}

package/lib/host/studio-service.js

@@ -0,0 +1,53 @@
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { STUDIO_INVOCATIONS } from '../studio-remote.js';
+export const STUDIO_LOCAL = {
+    package: 'dsh-webui-studio/studio',
+    face: 'host',
+    schemas: [],
+    model: { services: [], events: [], objects: [] },
+    invocations: STUDIO_INVOCATIONS,
+};
+export class StudioService extends TypertRemoteService {
+    backend;
+    constructor(ctx, backend) {
+        super(ctx, 'studio');
+        this.backend = backend;
+    }
+    currentGet(signal) { signal.throwIfAborted(); return this.backend.currentGet(); }
+    currentPreviewStatus(signal) { signal.throwIfAborted(); return this.backend.currentPreviewStatus(); }
+    currentPreviewUpdate(input, signal) { signal.throwIfAborted(); return this.backend.currentPreviewUpdate(input); }
+    currentResolveSource(input, signal) { signal.throwIfAborted(); return this.backend.currentResolveSource(input); }
+    currentAgentCreate(input, signal) { signal.throwIfAborted(); return this.backend.currentAgentCreate(input); }
+    currentAgentAttach(input, signal) { signal.throwIfAborted(); return this.backend.currentAgentAttach(input); }
+    currentAgentLeave(signal) { signal.throwIfAborted(); return this.backend.currentAgentLeave(); }
+    draftsList(signal) { signal.throwIfAborted(); return this.backend.draftsList(); }
+    draftsCreate(input, signal) { signal.throwIfAborted(); return this.backend.draftsCreate(input); }
+    draftsRename(input, signal) { signal.throwIfAborted(); return this.backend.draftsRename(input); }
+    draftsExport(input, signal) { signal.throwIfAborted(); return this.backend.draftsExport(input); }
+    draftsStart(input, signal) { signal.throwIfAborted(); return this.backend.draftsStart(input); }
+    draftsStop(input, signal) { signal.throwIfAborted(); return this.backend.draftsStop(input); }
+    workspaceGet(signal) { signal.throwIfAborted(); return this.backend.workspaceGet(); }
+    workspaceUpdate(input, signal) { signal.throwIfAborted(); return this.backend.workspaceUpdate(input); }
+    harmonyProfile(input, signal) { signal.throwIfAborted(); return this.backend.harmonyProfile(input); }
+    harmonyInspect(input, signal) { signal.throwIfAborted(); return this.backend.harmonyInspect(input); }
+    harmonyUpdateProfile(input, signal) { signal.throwIfAborted(); return this.backend.harmonyUpdateProfile(input); }
+    projectState(input, signal) { signal.throwIfAborted(); return this.backend.projectState(input); }
+    projectActivate(input, signal) { signal.throwIfAborted(); return this.backend.projectActivate(input); }
+    projectFiles(input, signal) { signal.throwIfAborted(); return this.backend.projectFiles(input); }
+    projectReadFile(input, signal) { signal.throwIfAborted(); return this.backend.projectReadFile(input); }
+    projectWriteFile(input, signal) { signal.throwIfAborted(); return this.backend.projectWriteFile(input); }
+    projectBuild(input, signal) { return this.backend.projectBuild(input, signal); }
+    projectCancelBuild(input, signal) { signal.throwIfAborted(); return this.backend.projectCancelBuild(input); }
+    elementsStyles(input, signal) { signal.throwIfAborted(); return this.backend.elementsStyles(input); }
+    elementsSaveSource(input, signal) { signal.throwIfAborted(); return this.backend.elementsSaveSource(input); }
+    patchesAnalyzeAutomatic(input, signal) { signal.throwIfAborted(); return this.backend.patchesAnalyzeAutomatic(input); }
+    patchesCreateAutomatic(input, signal) { signal.throwIfAborted(); return this.backend.patchesCreateAutomatic(input); }
+    readinessInspect(input, signal) { signal.throwIfAborted(); return this.backend.readinessInspect(input); }
+    readinessPack(input, signal) { signal.throwIfAborted(); return this.backend.readinessPack(input); }
+    previewStatus(input, signal) { signal.throwIfAborted(); return this.backend.previewStatus(input); }
+    previewUpdate(input, signal) { signal.throwIfAborted(); return this.backend.previewUpdate(input); }
+    previewResolveSource(input, signal) { signal.throwIfAborted(); return this.backend.previewResolveSource(input); }
+    agentCreate(input, signal) { signal.throwIfAborted(); return this.backend.agentCreate(input); }
+    agentAttach(input, signal) { signal.throwIfAborted(); return this.backend.agentAttach(input); }
+    agentLeave(input, signal) { signal.throwIfAborted(); return this.backend.agentLeave(input); }
+}

package/lib/index.d.ts

@@ -1,10 +1,14 @@
 import type { Context } from '@deepseek-ai/cordis';
+import '@deepseek-ai/cordis-plugin-loader';
+import '@deepseek-ai/dsh-client-modules';
 import '@deepseek-ai/dsh-agent';
 import '@deepseek-ai/dsh-host-apiproxy';
 import '@deepseek-ai/dsh-host-webserver';
+import '@deepseek-ai/dsh-skill';
 import '@deepseek-ai/dsh-system-prompt';
 import '@deepseek-ai/dsh-subprocess';
 import '@deepseek-ai/dsh-tools';
+import 'dsh-harmony';
 export declare const name = "harmony-studio";
 export declare const inject: string[];
 export declare function apply(ctx: Context): void;
@@ -13,6 +17,7 @@ export { StudioBuildError, StudioBuildRunner, resolveBuildArgv } from './host/bu
 export type { StudioBuildOutput } from './host/build.js';
 export { StudioDraftRegistry, dshHomeFromProfile } from './host/drafts.js';
 export { inspectReadiness, StudioPackRunner } from './host/readiness.js';
+export { createStudioMcpRoute, STUDIO_MCP_PATH } from './host/mcp.js';
 export { StudioPreviewSupervisor } from './host/preview.js';
 export { createStudioRoutes, isTrustedStudioRequest } from './host/routes.js';
 export { StudioWorkspaceStore } from './host/workspace.js';

package/lib/index.js

@@ -1,67 +1,101 @@
-import { randomBytes } from 'node:crypto';
 import { readFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import '@deepseek-ai/cordis-plugin-loader';
+import '@deepseek-ai/dsh-client-modules';
 import '@deepseek-ai/dsh-agent';
 import '@deepseek-ai/dsh-host-apiproxy';
 import '@deepseek-ai/dsh-host-webserver';
+import '@deepseek-ai/dsh-skill';
 import '@deepseek-ai/dsh-system-prompt';
 import '@deepseek-ai/dsh-subprocess';
 import '@deepseek-ai/dsh-tools';
+import 'dsh-harmony';
 import { STUDIO_PATH } from './contracts.js';
 import { StudioBackend } from './host/backend.js';
 import { dshHomeFromProfile, StudioDraftRegistry, studioCommands } from './host/drafts.js';
+import { createStudioMcpRoute } from './host/mcp.js';
 import { applyPreviewWorker } from './host/preview-worker.js';
 import { createStudioRoutes } from './host/routes.js';
+import { STUDIO_LOCAL, StudioService } from './host/studio-service.js';
 import { StudioWorkspaceStore } from './host/workspace.js';
 export const name = 'harmony-studio';
-export const inject = ['harmony', 'agents', 'tools', 'systemPrompt', 'webServer', 'subprocess'];
+export const inject = ['webServer'];
+const runtimeInject = ['harmony', 'agents', 'tools', 'skills', 'systemPrompt', 'webServer', 'subprocess', 'loader', 'clientModules', 'typert'];
 export function apply(ctx) {
-    ctx.effect(() => {
-        if (ctx.webServer.host !== '127.0.0.1') {
-            ctx.logger.warn('harmony-studio: Studio is disabled because dsh web is not bound to 127.0.0.1');
-            return () => { };
-        }
-        const harmony = ctx.harmony;
-        const assets = {
-            script: readFileSync(new URL('../dist/studio.js', import.meta.url)),
-            style: readFileSync(new URL('../dist/studio.css', import.meta.url)),
-            bridge: readFileSync(new URL('../dist/bridge.js', import.meta.url)),
-            icon: readFileSync(new URL('../assets/harmony-icon.png', import.meta.url)),
-            iconMono: readFileSync(new URL('../assets/harmony-icon-mono.png', import.meta.url)),
-        };
-        const previewRoot = process.env.DSH_STUDIO_PREVIEW_DRAFT_ROOT;
-        if (previewRoot !== undefined) {
-            const controlToken = process.env.DSH_STUDIO_PREVIEW_CONTROL_TOKEN;
+    if (ctx.webServer.host !== '127.0.0.1') {
+        ctx.logger.warn('harmony-studio: Studio is disabled because dsh web is not bound to 127.0.0.1');
+        return;
+    }
+    const assets = {
+        script: readFileSync(new URL('../dist/studio.js', import.meta.url)),
+        style: readFileSync(new URL('../dist/studio.css', import.meta.url)),
+        bridge: readFileSync(new URL('../dist/bridge.js', import.meta.url)),
+        icon: readFileSync(new URL('../assets/harmony-icon.png', import.meta.url)),
+        iconMono: readFileSync(new URL('../assets/harmony-icon-mono.png', import.meta.url)),
+    };
+    const previewRoot = process.env.DSH_STUDIO_PREVIEW_DRAFT_ROOT;
+    if (previewRoot !== undefined) {
+        ctx.inject(runtimeInject, previewCtx => {
             const parentOrigin = process.env.DSH_STUDIO_PREVIEW_PARENT_ORIGIN;
             const bridgeCapability = process.env.DSH_STUDIO_PREVIEW_BRIDGE_CAPABILITY;
-            if (controlToken === undefined || parentOrigin === undefined || bridgeCapability === undefined) {
+            const packageDirsSource = process.env.DSH_STUDIO_PREVIEW_PACKAGE_DIRS;
+            if (parentOrigin === undefined || bridgeCapability === undefined || packageDirsSource === undefined) {
                 throw new Error('harmony-studio: Preview worker environment is incomplete');
             }
-            applyPreviewWorker(ctx, harmony, { root: previewRoot, controlToken, parentOrigin, bridgeCapability, bridge: assets.bridge });
-            return () => { };
-        }
-        const token = randomBytes(32).toString('hex');
-        const host = `127.0.0.1:${ctx.webServer.port}`;
-        const dshHome = dshHomeFromProfile(harmony.profileDir);
-        const backend = new StudioBackend(harmony, ctx.agents, ctx.subprocess, new StudioDraftRegistry(dshHome), new StudioWorkspaceStore(dshHome), studioCommands, `http://${host}`);
+            const packageDirs = JSON.parse(packageDirsSource);
+            if (!Array.isArray(packageDirs) || !packageDirs.every(item => typeof item === 'string')) {
+                throw new Error('harmony-studio: Preview package directories are invalid');
+            }
+            applyPreviewWorker(previewCtx, previewCtx.harmony, {
+                root: previewRoot,
+                packageDirs,
+                parentOrigin,
+                bridgeCapability,
+                bridge: assets.bridge,
+            });
+        });
+        return;
+    }
+    let runtimeReady = false;
+    ctx.effect(() => {
+        const dispose = createStudioRoutes(assets, () => runtimeReady).map(route => ctx.webServer.register(route));
+        return () => {
+            for (const stop of dispose.reverse())
+                stop();
+        };
+    }, 'harmony-studio: static routes');
+    ctx.inject(runtimeInject, runtimeCtx => runtimeCtx.effect(() => {
+        const host = `127.0.0.1:${runtimeCtx.webServer.port}`;
+        const dshHome = dshHomeFromProfile(runtimeCtx.harmony.profile().dir);
+        const currentBridgeCapability = randomBytes(24).toString('base64url');
+        const backend = new StudioBackend(runtimeCtx.harmony, runtimeCtx.agents, runtimeCtx.subprocess, new StudioDraftRegistry(dshHome), new StudioWorkspaceStore(dshHome), studioCommands, `http://${host}`, currentBridgeCapability);
+        new StudioService(runtimeCtx, backend);
         const dispose = [
-            ...createStudioRoutes(backend, assets, { token, host, origin: `http://${host}` }).map(route => ctx.webServer.register(route)),
-            ctx.webServer.tapIndex(html => {
-                const script = `<script src="${STUDIO_PATH}/bridge.js"></script>`;
+            runtimeCtx.typert.register(STUDIO_LOCAL),
+            runtimeCtx.webServer.register(createStudioMcpRoute(backend)),
+            runtimeCtx.webServer.tapIndex(html => {
+                const script = `<script>window.__DSH_STUDIO_PREVIEW__=${JSON.stringify({
+                    parentOrigin: `http://${host}`,
+                    capability: currentBridgeCapability,
+                })}</script><script src="${STUDIO_PATH}/bridge.js"></script>`;
                 const head = html.indexOf('<head>');
                 return head === -1 ? `${script}${html}` : `${html.slice(0, head + 6)}${script}${html.slice(head + 6)}`;
             }),
         ];
+        runtimeReady = true;
         return async () => {
+            runtimeReady = false;
             for (const stop of dispose.reverse())
                 stop();
             await backend.dispose();
         };
-    }, 'harmony-studio: routes');
+    }, 'harmony-studio: runtime routes'));
 }
 export { StudioBackend } from './host/backend.js';
 export { StudioBuildError, StudioBuildRunner, resolveBuildArgv } from './host/build.js';
 export { StudioDraftRegistry, dshHomeFromProfile } from './host/drafts.js';
 export { inspectReadiness, StudioPackRunner } from './host/readiness.js';
+export { createStudioMcpRoute, STUDIO_MCP_PATH } from './host/mcp.js';
 export { StudioPreviewSupervisor } from './host/preview.js';
 export { createStudioRoutes, isTrustedStudioRequest } from './host/routes.js';
 export { StudioWorkspaceStore } from './host/workspace.js';

package/lib/studio-remote.d.ts

@@ -0,0 +1,126 @@
+import type { InvocationDescriptor, RemoteResult, TypertRemoteContribution } from '@deepseek-ai/dsh-typert-protocol';
+import type { StudioAgentBinding, StudioAutomaticPatchPlan, StudioAutomaticPatchRequest, StudioAutomaticPatchWriteResult, StudioBuildResult, StudioCreateDraftInput, StudioCurrentInstanceView, StudioDraftView, StudioElementStyleSource, StudioHarmonyInspection, StudioHarmonyProfile, StudioHarmonyProfileUpdateResult, StudioPreviewStatus, StudioPreviewUpdate, StudioProjectFile, StudioProjectState, StudioReadinessReport, StudioSourceCandidate, StudioSourceLocation, StudioWorkspaceState } from './contracts.js';
+export interface StudioRemote {
+    currentGet(signal?: AbortSignal): Promise<RemoteResult<StudioCurrentInstanceView>>;
+    currentPreviewStatus(signal?: AbortSignal): Promise<RemoteResult<StudioPreviewStatus>>;
+    currentPreviewUpdate(input: StudioPreviewUpdate, signal?: AbortSignal): Promise<RemoteResult<StudioPreviewStatus>>;
+    currentResolveSource(input: {
+        source: StudioSourceLocation;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioSourceCandidate>>;
+    currentAgentCreate(input: {
+        agentPreset?: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioAgentBinding>>;
+    currentAgentAttach(input: {
+        sessionId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioAgentBinding>>;
+    currentAgentLeave(signal?: AbortSignal): Promise<RemoteResult<StudioCurrentInstanceView>>;
+    draftsList(signal?: AbortSignal): Promise<RemoteResult<StudioDraftView[]>>;
+    draftsCreate(input: StudioCreateDraftInput, signal?: AbortSignal): Promise<RemoteResult<StudioDraftView>>;
+    draftsRename(input: {
+        draftId: string;
+        label: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioDraftView>>;
+    draftsExport(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioDraftView>>;
+    draftsStart(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioDraftView>>;
+    draftsStop(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioDraftView>>;
+    workspaceGet(signal?: AbortSignal): Promise<RemoteResult<StudioWorkspaceState>>;
+    workspaceUpdate(input: StudioWorkspaceState, signal?: AbortSignal): Promise<RemoteResult<StudioWorkspaceState>>;
+    harmonyProfile(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioHarmonyProfile>>;
+    harmonyInspect(input: {
+        draftId: string;
+        package?: string;
+        file?: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioHarmonyInspection>>;
+    harmonyUpdateProfile(input: {
+        draftId: string;
+        order?: string[];
+        patchOrder?: string[];
+        disabled?: string[];
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioHarmonyProfileUpdateResult>>;
+    projectState(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioProjectState>>;
+    projectActivate(input: {
+        draftId: string;
+        graphRev: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioProjectState>>;
+    projectFiles(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioProjectFile[]>>;
+    projectReadFile(input: {
+        draftId: string;
+        path: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<{
+        path: string;
+        content: string;
+    }>>;
+    projectWriteFile(input: {
+        draftId: string;
+        path: string;
+        content: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<{
+        path: string;
+        saved: true;
+    }>>;
+    projectBuild(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioBuildResult>>;
+    projectCancelBuild(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<{
+        canceled: boolean;
+    }>>;
+    elementsStyles(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioElementStyleSource[]>>;
+    elementsSaveSource(input: {
+        draftId: string;
+        styles: StudioElementStyleSource[];
+    }, signal?: AbortSignal): Promise<RemoteResult<{
+        files: string[];
+    }>>;
+    patchesAnalyzeAutomatic(input: StudioAutomaticPatchRequest & {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioAutomaticPatchPlan>>;
+    patchesCreateAutomatic(input: StudioAutomaticPatchRequest & {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioAutomaticPatchWriteResult>>;
+    readinessInspect(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioReadinessReport>>;
+    readinessPack(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioReadinessReport>>;
+    previewStatus(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioPreviewStatus>>;
+    previewUpdate(input: StudioPreviewUpdate & {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioPreviewStatus>>;
+    previewResolveSource(input: {
+        draftId: string;
+        source: StudioSourceLocation;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioSourceCandidate>>;
+    agentCreate(input: {
+        draftId: string;
+        agentPreset?: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioAgentBinding>>;
+    agentAttach(input: {
+        draftId: string;
+        sessionId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioAgentBinding>>;
+    agentLeave(input: {
+        draftId: string;
+    }, signal?: AbortSignal): Promise<RemoteResult<StudioDraftView>>;
+}
+export declare function invokeStudioRemote(remote: StudioRemote, method: string, payload: any, signal?: AbortSignal): Promise<RemoteResult<unknown>> | undefined;
+export declare const STUDIO_INVOCATIONS: readonly InvocationDescriptor[];
+export declare const STUDIO_REMOTE: TypertRemoteContribution;