npm - dsh-webui-studio - Versions diffs - 0.1.0 - Mend

dsh-webui-studio 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (40) hide show

package/LICENSE +21 -0
package/PRODUCT.md +74 -0
package/README.md +213 -0
package/README.zh-CN.md +196 -0
package/assets/harmony-icon-mono.png +0 -0
package/assets/harmony-icon.png +0 -0
package/dist/bridge.js +13 -0
package/dist/studio.css +2 -0
package/dist/studio.js +30429 -0
package/docs/harmony-api-requirements.md +24 -0
package/docs/source-baseline.md +55 -0
package/lib/contracts.d.ts +246 -0
package/lib/contracts.js +4 -0
package/lib/host/agent.d.ts +31 -0
package/lib/host/agent.js +128 -0
package/lib/host/backend.d.ts +25 -0
package/lib/host/backend.js +321 -0
package/lib/host/build.d.ts +26 -0
package/lib/host/build.js +137 -0
package/lib/host/drafts.d.ts +23 -0
package/lib/host/drafts.js +394 -0
package/lib/host/preview-worker.d.ts +11 -0
package/lib/host/preview-worker.js +110 -0
package/lib/host/preview.d.ts +42 -0
package/lib/host/preview.js +249 -0
package/lib/host/project-files.d.ts +8 -0
package/lib/host/project-files.js +110 -0
package/lib/host/readiness.d.ts +11 -0
package/lib/host/readiness.js +247 -0
package/lib/host/routes.d.ts +17 -0
package/lib/host/routes.js +163 -0
package/lib/host/runtime-profile.d.ts +16 -0
package/lib/host/runtime-profile.js +85 -0
package/lib/host/source-resolution.d.ts +7 -0
package/lib/host/source-resolution.js +154 -0
package/lib/host/workspace.d.ts +7 -0
package/lib/host/workspace.js +66 -0
package/lib/index.d.ts +18 -0
package/lib/index.js +67 -0
package/package.json +122 -0

package/lib/host/routes.js ADDED Viewed

@@ -0,0 +1,163 @@
+import { STUDIO_API_PATH, STUDIO_PATH } from '../contracts.js';
+const MAX_BODY_BYTES = 1024 * 1024;
+function remoteIsLoopback(request) {
+    const address = request.socket.remoteAddress;
+    return address === '::1' || address === '127.0.0.1' || address?.startsWith('127.') === true
+        || address?.startsWith('::ffff:127.') === true;
+}
+export function isTrustedStudioRequest(request) {
+    if (!remoteIsLoopback(request))
+        return false;
+    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));
+}
+function sendAsset(request, response, contentType, body) {
+    response.writeHead(200, {
+        'cache-control': 'no-cache',
+        'content-length': body.length,
+        'content-type': contentType,
+    });
+    response.end(request.method === 'HEAD' ? undefined : body);
+}
+function documentHtml(token) {
+    return `<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="light dark" />
+    <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>
+    <script type="module" src="${STUDIO_PATH}/assets/studio.js"></script>
+  </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 rejectUntrusted(request, response) {
+    if (isTrustedStudioRequest(request))
+        return false;
+    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) });
+        }
+    };
+    return [
+        {
+            kind: 'exact',
+            path: STUDIO_PATH,
+            handler(request, response) {
+                if (rejectUntrusted(request, response))
+                    return;
+                if (request.method !== 'GET' && request.method !== 'HEAD')
+                    return sendJson(response, 405, { error: 'method not allowed' });
+                sendAsset(request, response, 'text/html; charset=utf-8', page);
+            },
+        },
+        {
+            kind: 'exact',
+            path: `${STUDIO_PATH}/bridge.js`,
+            handler(request, response) {
+                if (rejectUntrusted(request, response))
+                    return;
+                if (request.method !== 'GET' && request.method !== 'HEAD')
+                    return sendJson(response, 405, { error: 'method not allowed' });
+                sendAsset(request, response, 'text/javascript; charset=utf-8', assets.bridge);
+            },
+        },
+        {
+            kind: 'exact',
+            path: `${STUDIO_PATH}/assets/studio.js`,
+            handler(request, response) {
+                if (rejectUntrusted(request, response))
+                    return;
+                if (request.method !== 'GET' && request.method !== 'HEAD')
+                    return sendJson(response, 405, { error: 'method not allowed' });
+                sendAsset(request, response, 'text/javascript; charset=utf-8', assets.script);
+            },
+        },
+        {
+            kind: 'exact',
+            path: `${STUDIO_PATH}/assets/studio.css`,
+            handler(request, response) {
+                if (rejectUntrusted(request, response))
+                    return;
+                if (request.method !== 'GET' && request.method !== 'HEAD')
+                    return sendJson(response, 405, { error: 'method not allowed' });
+                sendAsset(request, response, 'text/css; charset=utf-8', assets.style);
+            },
+        },
+        {
+            kind: 'exact',
+            path: `${STUDIO_PATH}/assets/harmony-icon.png`,
+            handler(request, response) {
+                if (rejectUntrusted(request, response))
+                    return;
+                if (request.method !== 'GET' && request.method !== 'HEAD')
+                    return sendJson(response, 405, { error: 'method not allowed' });
+                sendAsset(request, response, 'image/png', assets.icon);
+            },
+        },
+        {
+            kind: 'exact',
+            path: `${STUDIO_PATH}/assets/harmony-icon-mono.png`,
+            handler(request, response) {
+                if (rejectUntrusted(request, response))
+                    return;
+                if (request.method !== 'GET' && request.method !== 'HEAD')
+                    return sendJson(response, 405, { error: 'method not allowed' });
+                sendAsset(request, response, 'image/png', assets.iconMono);
+            },
+        },
+        { kind: 'prefix', path: STUDIO_API_PATH, handler: apiHandler },
+    ];
+}

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

@@ -0,0 +1,16 @@
+import type { StudioDraftRecord } from '../contracts.js';
+import type { StudioCommandRunner } from './drafts.js';
+interface DraftManifest {
+    name?: unknown;
+    packageManager?: unknown;
+    dependencies?: Record<string, unknown>;
+    devDependencies?: Record<string, unknown>;
+    optionalDependencies?: Record<string, unknown>;
+    peerDependencies?: Record<string, unknown>;
+}
+export declare function bundledPnpmCommand(args: readonly string[]): [string, string[]];
+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 {};

package/lib/host/runtime-profile.js ADDED Viewed

@@ -0,0 +1,85 @@
+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';
+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');
+export function bundledPnpmCommand(args) {
+    return [process.execPath, [PNPM_ENTRY, ...args]];
+}
+function terminalToken(value) {
+    return /^[\w@%+=:,./-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+}
+export function terminalCommandLine(cwd, command, args) {
+    return `${cwd}\n$ ${[command, ...args].map(terminalToken).join(' ')}\n`;
+}
+function hasDependencies(manifest) {
+    return [manifest.dependencies, manifest.devDependencies, manifest.optionalDependencies, manifest.peerDependencies]
+        .some(dependencies => dependencies !== undefined && Object.keys(dependencies).length > 0);
+}
+export async function assertDraftPackageIdentity(draft) {
+    const manifest = JSON.parse(await readFile(join(draft.root, 'package.json'), 'utf8'));
+    if (manifest.name !== draft.name) {
+        throw new Error(`Draft package.json name must remain ${JSON.stringify(draft.name)}`);
+    }
+    return manifest;
+}
+export async function installDraftDependencies(draft, commands, onOutput, signal) {
+    signal?.throwIfAborted();
+    const manifest = await assertDraftPackageIdentity(draft);
+    if (!hasDependencies(manifest))
+        return;
+    const manager = resolvePackageManager(draft.root, manifest);
+    const [command, args] = manager === 'pnpm' ? bundledPnpmCommand(['install']) : [manager, ['install']];
+    onOutput?.(terminalCommandLine(draft.root, command, args));
+    try {
+        await commands.run(command, args, 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('Draft dependency installation 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) {
+    signal?.throwIfAborted();
+    if (draft.profileMode !== 'main-home')
+        throw new Error('Custom Draft profiles are not implemented yet');
+    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)]));
+    dependencies[draft.name] = `link:${draft.root}`;
+    dependencies['dsh-webui-studio'] = `link:${studioPackageRoot}`;
+    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));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    const [command, args] = bundledPnpmCommand(['install', '--prefer-offline']);
+    onOutput?.(terminalCommandLine(profileDir, command, args));
+    try {
+        await commands.run(command, args, profileDir, 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('Profile dependency installation failed. Check the startup terminal for details.');
+    }
+    return profileDir;
+}

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

@@ -0,0 +1,7 @@
+import type { StudioSourceCandidate, StudioSourceLocation } from '../contracts.js';
+export declare class StudioSourceResolver {
+    #private;
+    constructor(draftRoot: string, profileDir: string);
+    resolve(source: StudioSourceLocation): Promise<StudioSourceCandidate>;
+    readDependency(packageName: string, file: string): Promise<string>;
+}

package/lib/host/source-resolution.js ADDED Viewed

@@ -0,0 +1,154 @@
+import { lstat, readFile, 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;
+function inside(root, target) {
+    const path = relative(root, target);
+    return path === '' || (path !== '..' && !path.startsWith(`..${sep}`) && !isAbsolute(path));
+}
+function posix(path) {
+    return path.split(sep).join('/');
+}
+function relativeSource(path) {
+    const normalized = path.replaceAll('\\', '/').replace(/^\.\//, '');
+    if (normalized === '' || normalized.startsWith('/') || normalized.split('/').some(part => part === '' || part === '.' || part === '..')) {
+        return undefined;
+    }
+    return normalized;
+}
+function sourceReference(file) {
+    const trimmed = file.trim();
+    if (trimmed.startsWith('file:')) {
+        try {
+            return { absolute: fileURLToPath(trimmed), generated: false };
+        }
+        catch {
+            return { generated: false };
+        }
+    }
+    if (trimmed.startsWith('/@fs/'))
+        return { absolute: trimmed.slice('/@fs'.length).replace(/[?#].*$/, ''), generated: false };
+    if (isAbsolute(trimmed))
+        return { absolute: trimmed.replace(/[?#].*$/, ''), generated: false };
+    const bundler = trimmed.match(/^(?:webpack|webpack-internal|vite):\/\/(.*)$/);
+    if (bundler !== null) {
+        const body = bundler[1].replace(/[?#].*$/, '');
+        const relativeMarker = body.indexOf('/./');
+        if (relativeMarker !== -1) {
+            const packageName = body.slice(0, relativeMarker).replace(/^\/+|\/+$/g, '');
+            return {
+                relative: relativeSource(body.slice(relativeMarker + 3)),
+                ...(packageName === '' ? {} : { package: packageName }),
+                generated: true,
+            };
+        }
+        if (body.startsWith('/'))
+            return { absolute: body.replace(/^\/{2}/, '/'), generated: true };
+        return { generated: true };
+    }
+    if (/^https?:\/\//.test(trimmed))
+        return { generated: true };
+    return { relative: relativeSource(trimmed.replace(/[?#].*$/, '')), generated: false };
+}
+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;
+    }
+    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,
+            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);
+    }
+    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);
+    }
+    return roots.filter((item, index, all) => all.findIndex(candidate => candidate.root === item.root) === index);
+}
+function result(source, file, kind, confidence, packageName) {
+    return {
+        ...(packageName === undefined ? {} : { package: packageName }),
+        file: file.slice(0, 4_000),
+        ...(source.line === undefined ? {} : { line: source.line }),
+        ...(source.column === undefined ? {} : { column: source.column }),
+        kind,
+        confidence,
+    };
+}
+async function exactMatch(path, roots) {
+    let target;
+    try {
+        target = await realpath(path);
+    }
+    catch {
+        return undefined;
+    }
+    const matches = roots.filter(item => inside(item.root, target)).sort((left, right) => right.root.length - left.root.length);
+    const root = matches[0];
+    return root === undefined ? undefined : { root, file: posix(relative(root.root, target)) };
+}
+export class StudioSourceResolver {
+    #roots;
+    constructor(draftRoot, profileDir) {
+        this.#roots = packageRoots(draftRoot, profileDir);
+    }
+    async resolve(source) {
+        const roots = await this.#roots;
+        const reference = sourceReference(source.file);
+        if (reference.absolute !== undefined) {
+            const match = await exactMatch(reference.absolute, roots);
+            if (match !== undefined)
+                return result(source, match.file, match.root.kind, 'exact', match.root.name);
+        }
+        if (reference.relative !== undefined) {
+            const candidates = roots.filter(root => reference.package === undefined || root.name === reference.package);
+            const matches = (await Promise.all(candidates.map(async (root) => {
+                const match = await exactMatch(resolve(root.root, reference.relative), [root]);
+                return match === undefined ? undefined : { root, file: match.file };
+            }))).filter(match => match !== undefined);
+            const unique = matches.filter((match, index, all) => all.findIndex(candidate => candidate.root.root === match.root.root && candidate.file === match.file) === index);
+            if (unique.length === 1)
+                return result(source, unique[0].file, unique[0].root.kind, 'candidate', unique[0].root.name);
+        }
+        return result(source, source.file, reference.generated ? 'generated' : 'unknown', 'candidate');
+    }
+    async readDependency(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);
+        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);
+        if (match === undefined || match.root !== roots[0] || match.file !== relativeFile) {
+            throw new Error('dependency source escapes its installed package root');
+        }
+        const target = resolve(match.root.root, match.file);
+        const info = await lstat(target);
+        if (!info.isFile())
+            throw new Error('dependency source is not a file');
+        if (info.size > MAX_SOURCE_BYTES)
+            throw new Error('dependency source exceeds the 1 MiB Studio limit');
+        const content = await readFile(target);
+        if (content.includes(0))
+            throw new Error('binary dependency sources cannot be read');
+        return content.toString('utf8');
+    }
+}

package/lib/host/workspace.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { StudioWorkspaceState } from '../contracts.js';
+export declare class StudioWorkspaceStore {
+    readonly file: string;
+    constructor(dshHome: string);
+    read(availableDraftIds: readonly string[]): Promise<StudioWorkspaceState>;
+    write(state: StudioWorkspaceState, availableDraftIds: readonly string[]): Promise<StudioWorkspaceState>;
+}

package/lib/host/workspace.js ADDED Viewed

@@ -0,0 +1,66 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+function parseWorkspace(value) {
+    if (typeof value !== 'object' || value === null)
+        throw new Error('Studio workspace state must be an object');
+    const candidate = value;
+    if (!Array.isArray(candidate.openDraftIds) || candidate.openDraftIds.some(id => typeof id !== 'string')) {
+        throw new Error('Studio workspace openDraftIds must be an array of Draft ids');
+    }
+    if (new Set(candidate.openDraftIds).size !== candidate.openDraftIds.length) {
+        throw new Error('Studio workspace openDraftIds must not contain duplicates');
+    }
+    if (candidate.selectedDraftId !== undefined && typeof candidate.selectedDraftId !== 'string') {
+        throw new Error('Studio workspace selectedDraftId must be a Draft id');
+    }
+    if (candidate.openDraftIds.length === 0 && candidate.selectedDraftId !== undefined) {
+        throw new Error('Studio workspace cannot select a closed Draft');
+    }
+    if (candidate.openDraftIds.length > 0
+        && (candidate.selectedDraftId === undefined || !candidate.openDraftIds.includes(candidate.selectedDraftId))) {
+        throw new Error('Studio workspace selectedDraftId must identify an open Draft');
+    }
+    return {
+        openDraftIds: [...candidate.openDraftIds],
+        ...(candidate.selectedDraftId === undefined ? {} : { selectedDraftId: candidate.selectedDraftId }),
+    };
+}
+export class StudioWorkspaceStore {
+    file;
+    constructor(dshHome) {
+        this.file = join(dshHome, 'studio', 'workspace.json');
+    }
+    async read(availableDraftIds) {
+        let stored;
+        try {
+            stored = parseWorkspace(JSON.parse(await readFile(this.file, 'utf8')));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return { openDraftIds: [] };
+            throw error;
+        }
+        const available = new Set(availableDraftIds);
+        const openDraftIds = stored.openDraftIds.filter(id => available.has(id));
+        if (openDraftIds.length === 0)
+            return { openDraftIds };
+        return {
+            openDraftIds,
+            selectedDraftId: stored.selectedDraftId !== undefined && openDraftIds.includes(stored.selectedDraftId)
+                ? stored.selectedDraftId
+                : openDraftIds[0],
+        };
+    }
+    async write(state, availableDraftIds) {
+        const next = parseWorkspace(state);
+        const available = new Set(availableDraftIds);
+        if (next.openDraftIds.some(id => !available.has(id)))
+            throw new Error('Studio workspace references an unknown Draft');
+        await mkdir(dirname(this.file), { recursive: true });
+        const temporary = join(dirname(this.file), `.workspace.${randomUUID()}.tmp`);
+        await writeFile(temporary, `${JSON.stringify(next, null, 2)}\n`, { flag: 'wx' });
+        await rename(temporary, this.file);
+        return next;
+    }
+}

package/lib/index.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import type { Context } from '@deepseek-ai/cordis';
+import '@deepseek-ai/dsh-agent';
+import '@deepseek-ai/dsh-host-apiproxy';
+import '@deepseek-ai/dsh-host-webserver';
+import '@deepseek-ai/dsh-system-prompt';
+import '@deepseek-ai/dsh-subprocess';
+import '@deepseek-ai/dsh-tools';
+export declare const name = "harmony-studio";
+export declare const inject: string[];
+export declare function apply(ctx: Context): void;
+export { StudioBackend } from './host/backend.js';
+export { StudioBuildError, StudioBuildRunner, resolveBuildArgv } from './host/build.js';
+export type { StudioBuildOutput } from './host/build.js';
+export { StudioDraftRegistry, dshHomeFromProfile } from './host/drafts.js';
+export { inspectReadiness, StudioPackRunner } from './host/readiness.js';
+export { StudioPreviewSupervisor } from './host/preview.js';
+export { createStudioRoutes, isTrustedStudioRequest } from './host/routes.js';
+export { StudioWorkspaceStore } from './host/workspace.js';

package/lib/index.js ADDED Viewed

@@ -0,0 +1,67 @@
+import { randomBytes } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import '@deepseek-ai/dsh-agent';
+import '@deepseek-ai/dsh-host-apiproxy';
+import '@deepseek-ai/dsh-host-webserver';
+import '@deepseek-ai/dsh-system-prompt';
+import '@deepseek-ai/dsh-subprocess';
+import '@deepseek-ai/dsh-tools';
+import { STUDIO_PATH } from './contracts.js';
+import { StudioBackend } from './host/backend.js';
+import { dshHomeFromProfile, StudioDraftRegistry, studioCommands } from './host/drafts.js';
+import { applyPreviewWorker } from './host/preview-worker.js';
+import { createStudioRoutes } from './host/routes.js';
+import { StudioWorkspaceStore } from './host/workspace.js';
+export const name = 'harmony-studio';
+export const inject = ['harmony', 'agents', 'tools', 'systemPrompt', 'webServer', 'subprocess'];
+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;
+            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) {
+                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 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>`;
+                const head = html.indexOf('<head>');
+                return head === -1 ? `${script}${html}` : `${html.slice(0, head + 6)}${script}${html.slice(head + 6)}`;
+            }),
+        ];
+        return async () => {
+            for (const stop of dispose.reverse())
+                stop();
+            await backend.dispose();
+        };
+    }, 'harmony-studio: 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 { StudioPreviewSupervisor } from './host/preview.js';
+export { createStudioRoutes, isTrustedStudioRequest } from './host/routes.js';
+export { StudioWorkspaceStore } from './host/workspace.js';