dsh-webui-studio 0.1.0

package/lib/host/backend.js

@@ -0,0 +1,321 @@
+import { StudioAgentController } from './agent.js';
+import { StudioBuildError, StudioBuildRunner } from './build.js';
+import { StudioPreviewSupervisor } from './preview.js';
+import { applyProjectPatch, listProjectFiles, readProjectFile, writeProjectFile } from './project-files.js';
+import { inspectReadiness, StudioPackRunner } from './readiness.js';
+import { assertDraftPackageIdentity } from './runtime-profile.js';
+function failure(rpcId, code, message, details = {}) {
+    return { type: 'server-response', rpcId, result: { ok: false, error: { code, message, details } } };
+}
+function success(rpcId, value) {
+    return { type: 'server-response', rpcId, result: { ok: true, value } };
+}
+function objectPayload(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        throw new Error('request payload must be an object');
+    return payload;
+}
+function draftId(payload) {
+    const id = objectPayload(payload).draftId;
+    if (typeof id !== 'string')
+        throw new Error('draftId is required');
+    return id;
+}
+class StudioDraftController {
+    record;
+    projectState;
+    previewState = { connected: false, mode: 'browse' };
+    builds;
+    packs;
+    agent;
+    preview;
+    constructor(record, profileDir, parentOrigin, commands, harmonyBinEntry, agents, subprocess) {
+        this.record = record;
+        this.preview = new StudioPreviewSupervisor(record, profileDir, parentOrigin, commands, harmonyBinEntry);
+        this.builds = new StudioBuildRunner(subprocess);
+        this.packs = new StudioPackRunner(subprocess);
+        this.agent = new StudioAgentController(agents, this);
+    }
+    view() {
+        const agent = this.agent.snapshot();
+        return {
+            ...this.record,
+            runtime: this.preview.snapshot(),
+            ...(this.projectState === undefined ? {} : { project: this.projectState }),
+            ...(agent === undefined ? {} : { agent }),
+        };
+    }
+    async start() {
+        await this.preview.start();
+        this.projectState = await this.preview.state();
+        return this.view();
+    }
+    async stop() {
+        await this.agent.dispose();
+        await this.builds.cancel();
+        await this.preview.stop();
+        this.projectState = undefined;
+        this.previewState = { connected: false, mode: 'browse' };
+        return this.view();
+    }
+    async dispose() {
+        await this.agent.dispose();
+        await this.builds.dispose();
+        await this.packs.dispose();
+        await this.preview.dispose();
+    }
+    project() {
+        if (this.projectState === undefined)
+            throw new Error('Draft Preview Host is not running');
+        return this.projectState;
+    }
+    async refreshProject() {
+        this.projectState = await this.preview.state();
+        return this.projectState;
+    }
+    async activate(graphRev) {
+        this.projectState = await this.preview.activate(graphRev);
+        return this.projectState;
+    }
+    selection() {
+        return this.previewState.selection;
+    }
+    updatePreview(update) {
+        const next = { ...this.previewState, ...update };
+        if (next.selection === null)
+            delete next.selection;
+        if (next.registry === null)
+            delete next.registry;
+        this.previewState = next;
+        return this.previewState;
+    }
+    previewStatus() {
+        return this.previewState;
+    }
+    resolveSource(source) {
+        return this.preview.resolveSource(source);
+    }
+    readDependencySource(packageName, file) {
+        return this.preview.readDependencySource(packageName, file);
+    }
+    async inspectHarmony(input) {
+        return (await this.preview.inspect(input)).harmony;
+    }
+    async readiness() {
+        const inspection = await this.preview.inspect();
+        return inspectReadiness(this.record.root, this.record.name, inspection.harmony, `${this.record.runtimeHome}/profiles/web`, inspection.dependencies);
+    }
+    async pack() {
+        const report = await this.readiness();
+        report.pack = await this.packs.run(this.record.root);
+        return report;
+    }
+    async readFile(path) {
+        return readProjectFile(this.record.root, path);
+    }
+    async applyPatch(path, before, after) {
+        return applyProjectPatch(this.record.root, path, before, after);
+    }
+    async build(signal) {
+        const current = this.project();
+        if (current.state !== 'active')
+            throw new Error('Draft must be active before it can be built');
+        await assertDraftPackageIdentity(this.record);
+        const build = await this.builds.run(current.root, signal);
+        this.projectState = await this.preview.applyBuild();
+        return { build, project: this.projectState };
+    }
+    cancelBuild() {
+        return this.builds.cancel();
+    }
+    createAgent(agentPreset) {
+        return this.agent.create(agentPreset);
+    }
+    async disposeAgent() {
+        await this.agent.dispose();
+    }
+}
+/** Stable-Host control plane for persistent, isolated Draft Preview runtimes. */
+export class StudioBackend {
+    harmony;
+    agents;
+    subprocess;
+    registry;
+    workspace;
+    commands;
+    parentOrigin;
+    controllers = new Map();
+    controllerCreations = new Map();
+    constructor(harmony, agents, subprocess, registry, workspace, commands, parentOrigin) {
+        this.harmony = harmony;
+        this.agents = agents;
+        this.subprocess = subprocess;
+        this.registry = registry;
+        this.workspace = workspace;
+        this.commands = commands;
+        this.parentOrigin = parentOrigin;
+    }
+    async call(message) {
+        const { method, payload, rpcId } = message;
+        try {
+            if (method === 'studio.drafts.list')
+                return success(rpcId, await this.list());
+            if (method === 'studio.drafts.create')
+                return success(rpcId, await this.create(payload));
+            if (method === 'studio.workspace.get') {
+                const records = await this.registry.list();
+                return success(rpcId, await this.workspace.read(records.map(record => record.id)));
+            }
+            if (method === 'studio.workspace.update') {
+                const records = await this.registry.list();
+                return success(rpcId, await this.workspace.write(objectPayload(payload), records.map(record => record.id)));
+            }
+            const controller = await this.controller(draftId(payload));
+            if (method === 'studio.drafts.rename') {
+                const label = objectPayload(payload).label;
+                if (typeof label !== 'string')
+                    throw new Error('Draft name is required');
+                const record = await this.registry.rename(controller.record.id, label);
+                controller.record = record;
+                return success(rpcId, controller.view());
+            }
+            if (method === 'studio.drafts.export') {
+                const record = await this.registry.export(controller.record.id);
+                controller.record = record;
+                return success(rpcId, controller.view());
+            }
+            if (method === 'studio.drafts.start')
+                return success(rpcId, await controller.start());
+            if (method === 'studio.drafts.stop')
+                return success(rpcId, await controller.stop());
+            if (method === 'studio.project.state')
+                return success(rpcId, await controller.refreshProject());
+            if (method === 'studio.project.activate') {
+                const graphRev = objectPayload(payload).graphRev;
+                if (typeof graphRev !== 'string')
+                    throw new Error('graphRev is required');
+                return success(rpcId, await controller.activate(graphRev));
+            }
+            if (method === 'studio.project.files')
+                return success(rpcId, await listProjectFiles(controller.record.root));
+            if (method === 'studio.project.readFile') {
+                const path = objectPayload(payload).path;
+                if (typeof path !== 'string')
+                    throw new Error('path is required');
+                return success(rpcId, { path, content: await controller.readFile(path) });
+            }
+            if (method === 'studio.project.writeFile') {
+                const { path, content } = objectPayload(payload);
+                if (typeof path !== 'string' || typeof content !== 'string')
+                    throw new Error('path and content are required');
+                await writeProjectFile(controller.record.root, path, content);
+                return success(rpcId, { path, saved: true });
+            }
+            if (method === 'studio.project.build')
+                return success(rpcId, await controller.build(new AbortController().signal));
+            if (method === 'studio.project.cancelBuild')
+                return success(rpcId, { canceled: await controller.cancelBuild() });
+            if (method === 'studio.readiness.inspect')
+                return success(rpcId, await controller.readiness());
+            if (method === 'studio.readiness.pack')
+                return success(rpcId, await controller.pack());
+            if (method === 'studio.harmony.inspect') {
+                const input = objectPayload(payload);
+                return success(rpcId, await controller.inspectHarmony({
+                    ...(typeof input.package === 'string' ? { package: input.package } : {}),
+                    ...(typeof input.file === 'string' ? { file: input.file } : {}),
+                }));
+            }
+            if (method === 'studio.preview.status')
+                return success(rpcId, controller.previewStatus());
+            if (method === 'studio.preview.update')
+                return success(rpcId, controller.updatePreview(this.previewStatus(payload)));
+            if (method === 'studio.preview.resolveSource') {
+                const source = objectPayload(payload).source;
+                if (typeof source?.file !== 'string')
+                    throw new Error('source is required');
+                return success(rpcId, await controller.resolveSource(source));
+            }
+            if (method === 'studio.agent.create') {
+                const preset = objectPayload(payload).agentPreset;
+                if (preset !== undefined && typeof preset !== 'string')
+                    throw new Error('agentPreset must be a string');
+                return success(rpcId, await controller.createAgent(preset));
+            }
+            if (method === 'studio.agent.dispose') {
+                await controller.disposeAgent();
+                return success(rpcId, { disposed: true });
+            }
+            return failure(rpcId, 'studio-method-forbidden', `method ${method} is not exposed by Studio`);
+        }
+        catch (error) {
+            const code = error instanceof StudioBuildError ? error.code : 'studio-request-failed';
+            const details = error instanceof StudioBuildError ? error.output : undefined;
+            return failure(rpcId, code, error instanceof Error ? error.message : String(error), details);
+        }
+    }
+    async dispose() {
+        await Promise.all([...this.controllerCreations.values()].map(creation => creation.catch(() => undefined)));
+        await Promise.all([...this.controllers.values()].map(controller => controller.dispose()));
+        this.controllers.clear();
+        this.controllerCreations.clear();
+    }
+    async list() {
+        const records = await this.registry.list();
+        return records.map(record => this.controllers.get(record.id)?.view() ?? {
+            ...record,
+            runtime: { state: 'stopped', log: '' },
+        });
+    }
+    async create(payload) {
+        const candidate = objectPayload(payload);
+        if ((candidate.profileMode !== 'main-home' && candidate.profileMode !== 'custom')
+            || typeof candidate.source !== 'object' || candidate.source === null
+            || (candidate.source.kind !== 'new' && candidate.source.kind !== 'existing')
+            || (candidate.destinationDirectory !== undefined && typeof candidate.destinationDirectory !== 'string')) {
+            throw new Error('Draft source and profileMode are invalid');
+        }
+        const record = await this.registry.create(candidate);
+        return this.makeController(record).view();
+    }
+    async controller(id) {
+        const current = this.controllers.get(id);
+        if (current !== undefined)
+            return current;
+        const pending = this.controllerCreations.get(id);
+        if (pending !== undefined)
+            return pending;
+        const creation = this.registry.get(id).then(record => this.controllers.get(id) ?? this.makeController(record));
+        this.controllerCreations.set(id, creation);
+        try {
+            return await creation;
+        }
+        finally {
+            if (this.controllerCreations.get(id) === creation)
+                this.controllerCreations.delete(id);
+        }
+    }
+    makeController(record) {
+        const controller = new StudioDraftController(record, this.harmony.profileDir, this.parentOrigin, this.commands, this.harmony.binEntry, this.agents, this.subprocess);
+        this.controllers.set(record.id, controller);
+        return controller;
+    }
+    previewStatus(payload) {
+        const candidate = objectPayload(payload);
+        if (typeof candidate.connected !== 'boolean' || (candidate.mode !== 'browse' && candidate.mode !== 'inspect')
+            || (candidate.graphRev !== undefined && typeof candidate.graphRev !== 'string')) {
+            throw new Error('Preview status is invalid');
+        }
+        if (candidate.registry !== undefined && candidate.registry !== null && (typeof candidate.registry !== 'object'
+            || !Array.isArray(candidate.registry.elements) || !Array.isArray(candidate.registry.variables))) {
+            throw new Error('Preview registry is invalid');
+        }
+        return {
+            connected: candidate.connected,
+            mode: candidate.mode,
+            ...(candidate.graphRev === undefined ? {} : { graphRev: candidate.graphRev }),
+            ...(candidate.selection === undefined ? {} : { selection: candidate.selection }),
+            ...(candidate.registry === undefined ? {} : { registry: candidate.registry }),
+        };
+    }
+}

package/lib/host/build.d.ts

@@ -0,0 +1,26 @@
+import type { SubprocessRuntime } from '@deepseek-ai/dsh-subprocess';
+export type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+export interface StudioBuildOutput {
+    argv: string[];
+    stdout: string;
+    stderr: string;
+    truncated: boolean;
+}
+export declare class StudioBuildError extends Error {
+    readonly code: 'studio-build-busy' | 'studio-build-config' | 'studio-build-failed' | 'studio-build-timeout' | 'studio-build-canceled';
+    readonly output?: StudioBuildOutput | undefined;
+    constructor(code: 'studio-build-busy' | 'studio-build-config' | 'studio-build-failed' | 'studio-build-timeout' | 'studio-build-canceled', message: string, output?: StudioBuildOutput | undefined);
+}
+export declare function resolvePackageManager(root: string, manifest: {
+    packageManager?: unknown;
+}): PackageManager;
+export declare function resolveBuildArgv(root: string): string[];
+export declare class StudioBuildRunner {
+    private readonly subprocess;
+    private readonly timeoutMs;
+    private active?;
+    constructor(subprocess: SubprocessRuntime, timeoutMs?: number);
+    run(root: string, signal?: AbortSignal): Promise<StudioBuildOutput>;
+    cancel(): Promise<boolean>;
+    dispose(): Promise<void>;
+}

package/lib/host/build.js

@@ -0,0 +1,137 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const BUILD_TIMEOUT_MS = 120_000;
+const OUTPUT_LIMIT_BYTES = 256 * 1024;
+export class StudioBuildError extends Error {
+    code;
+    output;
+    constructor(code, message, output) {
+        super(message);
+        this.code = code;
+        this.output = output;
+        this.name = 'StudioBuildError';
+    }
+}
+export function resolvePackageManager(root, manifest) {
+    if (manifest.packageManager !== undefined) {
+        if (typeof manifest.packageManager !== 'string') {
+            throw new StudioBuildError('studio-build-config', 'Draft packageManager must be a string');
+        }
+        const name = manifest.packageManager.split('@', 1)[0];
+        if (name === 'npm' || name === 'pnpm' || name === 'yarn' || name === 'bun')
+            return name;
+        throw new StudioBuildError('studio-build-config', `Draft packageManager ${JSON.stringify(name)} is not supported`);
+    }
+    const candidates = [
+        { name: 'pnpm', files: ['pnpm-lock.yaml'] },
+        { name: 'npm', files: ['package-lock.json'] },
+        { name: 'yarn', files: ['yarn.lock'] },
+        { name: 'bun', files: ['bun.lock', 'bun.lockb'] },
+    ];
+    const matches = candidates.filter(candidate => candidate.files.some(file => existsSync(join(root, file))));
+    if (matches.length === 0) {
+        throw new StudioBuildError('studio-build-config', 'Draft must declare packageManager or contain a supported lockfile');
+    }
+    if (matches.length > 1) {
+        throw new StudioBuildError('studio-build-config', 'Draft contains lockfiles for multiple package managers');
+    }
+    return matches[0].name;
+}
+export function resolveBuildArgv(root) {
+    const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+    if (typeof manifest.scripts?.build !== 'string' || manifest.scripts.build.trim() === '') {
+        throw new StudioBuildError('studio-build-config', 'Draft must define a non-empty scripts.build');
+    }
+    return [resolvePackageManager(root, manifest), 'run', 'build'];
+}
+function outputOf(handle, argv) {
+    const stdout = handle.collected.stdout?.readFrom(0);
+    const stderr = handle.collected.stderr?.readFrom(0);
+    return {
+        argv,
+        stdout: stdout?.text ?? '',
+        stderr: stderr?.text ?? '',
+        truncated: stdout?.lossy === true || stderr?.lossy === true,
+    };
+}
+export class StudioBuildRunner {
+    subprocess;
+    timeoutMs;
+    active;
+    constructor(subprocess, timeoutMs = BUILD_TIMEOUT_MS) {
+        this.subprocess = subprocess;
+        this.timeoutMs = timeoutMs;
+    }
+    async run(root, signal) {
+        if (this.active !== undefined)
+            throw new StudioBuildError('studio-build-busy', 'a Draft build is already running');
+        const argv = resolveBuildArgv(root);
+        const active = { controller: new AbortController(), canceled: false, timedOut: false };
+        this.active = active;
+        const externalAbort = () => {
+            active.canceled = true;
+            active.controller.abort();
+        };
+        signal?.addEventListener('abort', externalAbort, { once: true });
+        if (signal?.aborted === true)
+            externalAbort();
+        const timeout = setTimeout(() => {
+            active.timedOut = true;
+            active.controller.abort();
+        }, this.timeoutMs);
+        try {
+            argv[0] = await this.subprocess.resolveExecutable(argv[0], undefined, active.controller.signal);
+            active.handle = this.subprocess.spawn({
+                argv,
+                cwd: root,
+                stdio: {
+                    stdin: 'ignore',
+                    stdout: { maxBytes: OUTPUT_LIMIT_BYTES },
+                    stderr: { maxBytes: OUTPUT_LIMIT_BYTES },
+                },
+                graceMs: 2_000,
+                signal: active.controller.signal,
+            });
+            const outcome = await active.handle.done;
+            const output = outputOf(active.handle, argv);
+            if (active.timedOut)
+                throw new StudioBuildError('studio-build-timeout', 'Draft build timed out', output);
+            if (active.canceled)
+                throw new StudioBuildError('studio-build-canceled', 'Draft build was canceled', output);
+            if (outcome.exitCode !== 0) {
+                throw new StudioBuildError('studio-build-failed', `Draft build exited with ${outcome.exitCode === null ? outcome.signal ?? 'a signal' : `code ${outcome.exitCode}`}`, output);
+            }
+            return output;
+        }
+        catch (error) {
+            if (error instanceof StudioBuildError)
+                throw error;
+            if (active.timedOut)
+                throw new StudioBuildError('studio-build-timeout', 'Draft build timed out');
+            if (active.canceled)
+                throw new StudioBuildError('studio-build-canceled', 'Draft build was canceled');
+            throw new StudioBuildError('studio-build-failed', error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', externalAbort);
+            if (active.controller.signal.aborted && active.handle !== undefined)
+                await active.handle.waitForExit();
+            if (this.active === active)
+                this.active = undefined;
+        }
+    }
+    async cancel() {
+        const active = this.active;
+        if (active === undefined)
+            return false;
+        active.canceled = true;
+        active.controller.abort();
+        if (active.handle !== undefined)
+            await active.handle.waitForExit();
+        return true;
+    }
+    async dispose() {
+        await this.cancel();
+    }
+}

package/lib/host/drafts.d.ts

@@ -0,0 +1,23 @@
+import type { StudioCreateDraftInput, StudioDraftRecord } from '../contracts.js';
+export interface StudioCommandRunner {
+    run(command: string, args: string[], cwd?: string, onOutput?: (chunk: string) => void, signal?: AbortSignal): Promise<void>;
+}
+export declare const studioCommands: StudioCommandRunner;
+export declare class StudioDraftRegistry {
+    private readonly commands;
+    readonly root: string;
+    readonly recordsDir: string;
+    readonly repositoriesDir: string;
+    readonly worktreesDir: string;
+    readonly runtimesDir: string;
+    private readonly recordMutations;
+    constructor(dshHome: string, commands?: StudioCommandRunner);
+    list(): Promise<StudioDraftRecord[]>;
+    get(id: string): Promise<StudioDraftRecord>;
+    create(input: StudioCreateDraftInput): Promise<StudioDraftRecord>;
+    rename(id: string, label: string): Promise<StudioDraftRecord>;
+    export(id: string): Promise<StudioDraftRecord>;
+    private mutate;
+    private replace;
+}
+export declare function dshHomeFromProfile(profileDir: string): string;