@lumenkey/cli 0.3.0 → 0.4.0-rc.1

package/dist/studio/run-journal.js

@@ -0,0 +1,125 @@
+import { randomUUID } from 'node:crypto';
+import { link, open, readdir, rename, unlink } from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { assertRegularFile, assertStudioRoot } from './paths.js';
+import { hasFsCode, StudioError } from './errors.js';
+import { prepareDocumentAuthority } from './document-authority.js';
+const integer = z.number().int().nonnegative().safe();
+export const uuid = z.string().uuid();
+export const errorCode = z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,79}$/);
+export const isoDate = z.string().datetime({ offset: true });
+const diagnosticSchema = z.object({ code: errorCode, message: z.string().max(1000), type: z.string().max(80), httpStatus: z.number().int().min(400).max(599).optional(), submission: z.enum(['none', 'unknown', 'created']).optional(), recovery: z.enum(['rerun', 'resume-command', 'expired', 'ledger']).optional(), resumeDeadline: isoDate.optional() }).strict();
+export function isSafeJson(value, depth = 0) {
+    if (depth > 20)
+        return false;
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(v => isSafeJson(v, depth + 1));
+    return !!value && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype &&
+        Object.entries(value).every(([k, v]) => !['__proto__', 'constructor', 'prototype'].includes(k) && isSafeJson(v, depth + 1));
+}
+export const inputSchema = z.unknown().refine(v => isSafeJson(v) && !!v && typeof v === 'object' && !Array.isArray(v) && Buffer.byteLength(JSON.stringify(v)) <= 128 * 1024).pipe(z.record(z.unknown()));
+export const quoteSchema = z.object({ quoteId: uuid, modelId: z.string().min(1).max(200), credits: integer, expiresAt: isoDate }).strict();
+export const jobSchema = z.object({
+    jobId: uuid, status: z.enum(['accepted', 'policy_checking', 'queued', 'submitting', 'provider_running', 'output_checking', 'succeeded', 'rejected', 'failed', 'cancelled', 'expired']),
+    outputs: z.array(z.object({ url: z.string().max(8192), type: z.string().max(40).optional(), assetId: uuid.optional(), outputIndex: integer.optional() }).strict().refine(o => (o.assetId === undefined) === (o.outputIndex === undefined))).max(100),
+    identityReason: z.enum(['LEGACY_AWAITING_FRESH_GET', 'JOB_UNAVAILABLE', 'NO_VERIFIABLE_OUTPUTS', 'IDENTITY_CONFLICT']).optional(),
+    identityEvidence: z.array(z.object({ assetId: uuid, type: z.enum(['image', 'video', 'audio']) }).strict()).max(1000).refine(v => new Set(v.map(o => o.assetId.toLowerCase())).size === v.length).optional(),
+    error: z.object({ code: errorCode, message: z.string().max(200) }).strict().optional(),
+}).strict();
+export const runSchema = z.object({
+    runId: uuid, binding: z.string().regex(/^[a-f0-9]{64}$/), modelId: z.string().min(1).max(200), input: inputSchema,
+    projectId: uuid, idempotencyKey: uuid, quote: quoteSchema, requestedInput: inputSchema.optional(),
+    state: z.enum(['QUOTED', 'SUBMITTING', 'SUBMISSION_UNKNOWN', 'SUBMISSION_REJECTED', 'ACCEPTED', 'TERMINAL']),
+    job: jobSchema.optional(), lastErrorCode: errorCode.optional(), lastFailure: diagnosticSchema.optional(), createdAt: isoDate, updatedAt: isoDate,
+}).strict().refine(v => v.quote.modelId === v.modelId && (!['ACCEPTED', 'TERMINAL'].includes(v.state) || !!v.job));
+const journalSchema = z.object({ schemaVersion: z.literal(1), revision: integer, runs: z.array(runSchema).max(1000) }).strict()
+    .refine(v => new Set(v.runs.map(r => r.runId)).size === v.runs.length && new Set(v.runs.map(r => r.idempotencyKey)).size === v.runs.length);
+function validate(value) {
+    const parsed = journalSchema.safeParse(value);
+    if (!parsed.success || Buffer.byteLength(JSON.stringify(parsed.data)) > 8 * 1024 * 1024)
+        throw new StudioError('STUDIO_JOURNAL_INVALID', 409);
+    return parsed.data;
+}
+/** The owning asset store supplies its exclusive writer and lifecycle queue. */
+export function createRunJournal(root, serial) {
+    const file = path.join(root.managedDir, 'runs.json');
+    let current;
+    async function disk() {
+        await assertStudioRoot(root);
+        try {
+            await assertRegularFile(file);
+            const handle = await open(file, 'r');
+            try {
+                if ((await handle.stat()).size > 8 * 1024 * 1024)
+                    throw new Error();
+                return validate(JSON.parse(await handle.readFile('utf8')));
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch (e) {
+            if (hasFsCode(e, 'ENOENT'))
+                return undefined;
+            throw new StudioError('STUDIO_JOURNAL_INVALID', 409);
+        }
+    }
+    async function commit(next, initial = false) {
+        await assertStudioRoot(root);
+        const temp = path.join(root.managedDir, `runs.${randomUUID()}.tmp`);
+        const handle = await open(temp, 'wx', 0o600);
+        try {
+            await handle.writeFile(JSON.stringify(next));
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await assertStudioRoot(root);
+        if (initial) {
+            await link(temp, file);
+            await unlink(temp);
+        }
+        else {
+            await assertRegularFile(file);
+            await rename(temp, file);
+        }
+    }
+    async function authority() {
+        const loaded = await disk();
+        if (loaded)
+            await prepareDocumentAuthority(root, 'runs', true, 'STUDIO_JOURNAL_INVALID');
+        if (current) {
+            if (!loaded || JSON.stringify(loaded) !== JSON.stringify(current))
+                throw new StudioError('STUDIO_JOURNAL_INVALID', 409);
+        }
+        else if (loaded)
+            current = loaded;
+        else {
+            if ((await readdir(root.managedDir)).some(n => /^runs\..+\.tmp$/.test(n)))
+                throw new StudioError('STUDIO_JOURNAL_INVALID', 409);
+            await prepareDocumentAuthority(root, 'runs', false, 'STUDIO_JOURNAL_INVALID');
+            const empty = { schemaVersion: 1, revision: 0, runs: [] };
+            await commit(empty, true);
+            current = empty;
+        }
+        return current;
+    }
+    return {
+        read: () => serial(async () => structuredClone(await authority())),
+        write: next => serial(async () => {
+            const validated = validate(next);
+            const before = await authority();
+            if (validated.revision !== before.revision + 1)
+                throw new StudioError('STUDIO_JOURNAL_INVALID', 409);
+            await commit(validated);
+            current = validated;
+        }),
+    };
+}
+//# sourceMappingURL=run-journal.js.map

package/dist/studio/server.d.ts

@@ -0,0 +1,17 @@
+import { openStudioAssetStore } from './asset-store.js';
+import { createOutputSaveWorker } from './output-save-worker.js';
+import type { LumenKeyConfig } from '../core/types.js';
+export interface StudioServerHandle {
+    origin: string;
+    launchUrl: string;
+    close(): Promise<void>;
+}
+export declare function startStudioServer(options?: {
+    outputDir?: string;
+    maxBytes?: number;
+    integrity?: Parameters<typeof openStudioAssetStore>[0]['integrity'];
+    loadCloudConfig?: () => LumenKeyConfig | Promise<LumenKeyConfig>;
+    storageFaults?: Parameters<typeof openStudioAssetStore>[0]['faults'];
+    saveWorker?: Pick<Parameters<typeof createOutputSaveWorker>[0], 'fetchAsset' | 'hooks'>;
+}): Promise<StudioServerHandle>;
+//# sourceMappingURL=server.d.ts.map

package/dist/studio/server.js

@@ -0,0 +1,440 @@
+import { createServer } from 'node:http';
+import { once } from 'node:events';
+import { randomBytes } from 'node:crypto';
+import { readFile, readdir } from 'node:fs/promises';
+import { openStudioAssetStore } from './asset-store.js';
+import { storageError, StudioError } from './errors.js';
+import { createStudioSession } from './session.js';
+import { studioHtml, studioScript } from './shell.js';
+import { studioStyle } from './style.js';
+import { createStudioCloudService } from './cloud-service.js';
+import { cloudHttpError } from './cloud-contract.js';
+import { createOutputSaveService, saveHttpError } from './output-save-service.js';
+import { createOutputSaveWorker } from './output-save-worker.js';
+import { StudioCaptureError } from './director-captures.js';
+function json(response, status, value) {
+    response.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
+    response.end(JSON.stringify(value));
+}
+function waitForDrain(response) {
+    return new Promise((resolve, reject) => {
+        const cleanup = () => { response.off('drain', drained); response.off('close', failed); response.off('error', failed); };
+        const drained = () => { cleanup(); resolve(); };
+        const failed = () => { cleanup(); reject(new StudioError('STUDIO_STORAGE_FAILED', 500)); };
+        if (response.destroyed) {
+            failed();
+            return;
+        }
+        response.once('drain', drained);
+        response.once('close', failed);
+        response.once('error', failed);
+    });
+}
+async function smallJson(request, limit = 1024) {
+    if (request.headers['content-type'] !== 'application/json')
+        throw new StudioError('STUDIO_INPUT_INVALID');
+    if (request.headers['content-encoding'])
+        throw new StudioError('STUDIO_INPUT_INVALID');
+    const declaredLength = request.headers['content-length'];
+    if (declaredLength !== undefined && Number(declaredLength) > limit)
+        throw new StudioError('STUDIO_INPUT_INVALID', 413);
+    const chunks = [];
+    let size = 0;
+    // Keep the response writable when rejecting a chunked oversized request.
+    for await (const chunk of request.iterator({ destroyOnReturn: false })) {
+        size += chunk.length;
+        if (size > limit)
+            throw new StudioError('STUDIO_INPUT_INVALID', 413);
+        chunks.push(chunk);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new StudioError('STUDIO_INPUT_INVALID');
+    }
+}
+function byteRange(header, size) {
+    if (!header)
+        return { start: 0, end: size - 1, partial: false };
+    const match = header.length < 100 && /^bytes=(\d*)-(\d*)$/.exec(header);
+    if (!match || (!match[1] && !match[2]))
+        throw new StudioError('STUDIO_RANGE_INVALID', 416);
+    const start = match[1] ? Number(match[1]) : Math.max(0, size - Number(match[2]));
+    const end = match[1] && match[2] ? Math.min(size - 1, Number(match[2])) : size - 1;
+    if (![start, end].every(Number.isSafeInteger) || start < 0 || start >= size || end < start || (!match[1] && Number(match[2]) === 0))
+        throw new StudioError('STUDIO_RANGE_INVALID', 416);
+    return { start, end, partial: true };
+}
+export async function startStudioServer(options = {}) {
+    const browserModules = new Set((await readdir(new URL('./web/', import.meta.url), { withFileTypes: true })).filter(e => e.isFile() && /^[a-z][a-z0-9-]{0,40}\.js$/.test(e.name)).map(e => `/studio/web/${e.name}`));
+    const store = options.outputDir === undefined ? undefined : await openStudioAssetStore({ outputDir: options.outputDir, maxBytes: options.maxBytes, faults: options.storageFaults, integrity: options.integrity });
+    const loadConfig = options.loadCloudConfig ?? (async () => (await import('../core/config.js')).loadConfig());
+    let saveWorker;
+    let closing = false;
+    const cloud = createStudioCloudService({ store, loadConfig });
+    const saves = createOutputSaveService({ store, outputDir: options.outputDir, loadConfig, ...(store && options.outputDir ? { makeWorker: () => saveWorker ??= createOutputSaveWorker({ ...options.saveWorker, store, outputDir: options.outputDir, loadConfig }) } : {}) });
+    const session = createStudioSession();
+    const styleNonce = randomBytes(24).toString('base64');
+    let origin = '';
+    const active = new Set();
+    const server = createServer({ maxHeaderSize: 8192, requestTimeout: 30_000, headersTimeout: 10_000 }, (request, response) => {
+        response.setHeader('Cache-Control', 'no-store');
+        response.setHeader('X-Content-Type-Options', 'nosniff');
+        response.setHeader('Referrer-Policy', 'no-referrer');
+        response.setHeader('Content-Security-Policy', `default-src 'none'; script-src 'self'; style-src 'self'; style-src-elem 'self' 'nonce-${styleNonce}'; style-src-attr 'unsafe-inline'; connect-src 'self'; img-src 'self'; media-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'self'`);
+        const action = handle(request, response).catch(error => {
+            if (response.destroyed)
+                return;
+            if (response.headersSent) {
+                response.destroy();
+                return;
+            }
+            // Drain rejected input without retaining it. Closing mid-upload can reset
+            // the socket before clients receive the structured 413/400 response.
+            request.resume();
+            const requestPath = (request.url ?? '').split('?')[0];
+            if (requestPath.startsWith('/studio/api/saves/') || /^\/studio\/api\/runs\/[^/]+\/outputs(?:\/[^/]+\/save)?$/.test(requestPath) || /^\/studio\/api\/assets\/[^/]+$/.test(requestPath)) {
+                const safe = saveHttpError(error, requestPath.endsWith('/saves/bind'));
+                json(response, safe.status, safe.body);
+                return;
+            }
+            const safe = storageError(error);
+            json(response, safe.status, { error: { code: safe.code, message: safe.message }, ...(error instanceof StudioCaptureError ? { capture: error.capture } : {}) });
+        }).finally(() => active.delete(action));
+        active.add(action);
+    });
+    server.maxRequestsPerSocket = 100;
+    // Retire idle keep-alive sockets before header (10s) / request (30s) deadlines.
+    server.keepAliveTimeout = 2_000;
+    server.setTimeout(30_000, socket => socket.destroy());
+    server.on('clientError', (error, socket) => {
+        const code = error.code ?? '';
+        if (socket.bytesRead === 0 || /TIMEOUT|TIMEDOUT|ECONNRESET|EPIPE/.test(code) || socket.destroyed) {
+            socket.destroy();
+            return;
+        }
+        socket.end('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+    });
+    async function handle(request, response) {
+        if (closing)
+            throw new StudioError('STUDIO_STORAGE_CLOSED', 503);
+        const hostname = origin.slice('http://'.length);
+        const hostCount = request.rawHeaders.filter((_, i) => i % 2 === 0 && request.rawHeaders[i].toLowerCase() === 'host').length;
+        if (hostCount !== 1 || request.headers.host !== hostname || (request.headers.origin !== undefined && request.headers.origin !== origin))
+            throw new StudioError('STUDIO_REQUEST_FORBIDDEN', 403);
+        // Check the raw target before URL normalization can erase traversal segments.
+        if ((request.url ?? '').startsWith('/studio/web/')) {
+            const target = request.url;
+            if (request.method !== 'GET' || !/^\/studio\/web\/[a-z][a-z0-9-]{0,40}\.js$/.test(target) || !browserModules.has(target))
+                throw new StudioError('STUDIO_ROUTE_NOT_FOUND', 404);
+            const source = await readFile(new URL('./web/' + target.slice('/studio/web/'.length), import.meta.url), 'utf8');
+            response.writeHead(200, { 'Content-Type': 'text/javascript; charset=utf-8' });
+            response.end(source);
+            return;
+        }
+        const url = new URL(request.url ?? '/', origin);
+        const assetMetadata = /^\/studio\/api\/assets\/([^/]+)$/.exec(url.pathname);
+        const captureRoute = /^\/studio\/api\/canvases\/([^/]+)\/director-captures(?:\/([^/]+)(\/retry)?)?$/.exec(url.pathname);
+        const captureList = request.method === 'GET' && captureRoute && !captureRoute[2];
+        if (url.origin !== origin || (url.search && !captureList && !assetMetadata) || url.hash)
+            throw new StudioError('STUDIO_INPUT_INVALID');
+        if (request.method === 'GET' && ['/studio/', '/studio/app.js'].includes(url.pathname)) {
+            response.writeHead(200, { 'Content-Type': url.pathname.endsWith('.js') ? 'text/javascript; charset=utf-8' : 'text/html; charset=utf-8' });
+            response.end(url.pathname.endsWith('.js') ? studioScript : studioHtml.replace('__STUDIO_STYLE_NONCE__', styleNonce));
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/studio/style.css') {
+            response.writeHead(200, { 'Content-Type': 'text/css; charset=utf-8' });
+            response.end(studioStyle);
+            return;
+        }
+        if (request.method === 'GET' && ['/studio/canvas/editor.js', '/studio/canvas/editor.css'].includes(url.pathname)) {
+            const name = url.pathname.endsWith('.css') ? 'editor.css' : 'editor.js';
+            const source = await readFile(new URL('./canvas/' + name, import.meta.url));
+            response.writeHead(200, { 'Content-Type': name.endsWith('.css') ? 'text/css; charset=utf-8' : 'text/javascript; charset=utf-8' });
+            response.end(source);
+            return;
+        }
+        if (request.method !== 'GET' && request.headers.origin !== origin)
+            throw new StudioError('STUDIO_REQUEST_FORBIDDEN', 403);
+        if (request.method === 'POST' && url.pathname === '/studio/api/session/bootstrap') {
+            saves.invalidate();
+            const value = await smallJson(request);
+            if (!value || typeof value !== 'object' || !('launch' in value) || Object.keys(value).length !== 1)
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            response.setHeader('Set-Cookie', session.bootstrap(value.launch));
+            json(response, 200, { accepted: true });
+            return;
+        }
+        session.assert(request.headers.cookie);
+        if (request.method === 'GET' && assetMetadata) {
+            if (!store)
+                throw new StudioError('STUDIO_OUTPUT_ROOT_REQUIRED', 409);
+            if (url.search || url.hash || request.headers['transfer-encoding'] !== undefined || (request.headers['content-length'] !== undefined && request.headers['content-length'] !== '0'))
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            const asset = await store.metadata(assetMetadata[1]);
+            json(response, 200, { scope: saves.localScope(), asset });
+            return;
+        }
+        const outputList = /^\/studio\/api\/runs\/([^/]+)\/outputs$/.exec(url.pathname);
+        const outputSave = /^\/studio\/api\/runs\/([^/]+)\/outputs\/([^/]+)\/save$/.exec(url.pathname);
+        const saveOperation = /^\/studio\/api\/saves\/([^/]+)(\/retry)?$/.exec(url.pathname);
+        if (url.pathname === '/studio/api/saves/bind' || outputList || outputSave || saveOperation) {
+            if (request.method === 'POST')
+                await saves.preflight(url.pathname === '/studio/api/saves/bind');
+            const authorizedBody = async () => {
+                let body;
+                try {
+                    body = await smallJson(request);
+                }
+                catch (error) {
+                    // Reading the body yields: a changed binding/config takes precedence over parsing.
+                    await saves.preflight(url.pathname === '/studio/api/saves/bind');
+                    throw error;
+                }
+                await saves.preflight(url.pathname === '/studio/api/saves/bind');
+                return body;
+            };
+            if (request.method === 'GET' && (request.headers['transfer-encoding'] !== undefined || (request.headers['content-length'] !== undefined && request.headers['content-length'] !== '0')))
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            if (request.method === 'POST' && url.pathname === '/studio/api/saves/bind') {
+                const body = await authorizedBody();
+                if (!body || typeof body !== 'object' || Array.isArray(body) || Object.keys(body).length)
+                    throw new StudioError('STUDIO_INPUT_INVALID');
+                json(response, 200, await saves.bind());
+                return;
+            }
+            if (request.method === 'GET' && outputList) {
+                if (request.headers['transfer-encoding'] !== undefined || (request.headers['content-length'] !== undefined && request.headers['content-length'] !== '0'))
+                    throw new StudioError('STUDIO_INPUT_INVALID');
+                json(response, 200, await saves.outputs(outputList[1]));
+                return;
+            }
+            if (request.method === 'GET' && outputSave) {
+                json(response, 200, await saves.output(outputSave[1], outputSave[2]));
+                return;
+            }
+            if (request.method === 'GET' && saveOperation && !saveOperation[2]) {
+                json(response, 200, await saves.read(saveOperation[1]));
+                return;
+            }
+            if (request.method === 'POST' && (outputSave || saveOperation?.[2])) {
+                const body = await authorizedBody();
+                const { status, ...result } = outputSave ? await saves.accept(outputSave[1], outputSave[2], body) : await saves.retry(saveOperation[1], body);
+                json(response, status, result);
+                return;
+            }
+            throw new StudioError('STUDIO_ROUTE_NOT_FOUND', 404);
+        }
+        if (request.method === 'GET' && url.pathname === '/studio/api/session') {
+            json(response, 200, { apiVersion: 1, storage: { configured: !!store, ...(store ? { outputDir: options.outputDir } : {}) }, capabilities: { localAssets: !!store, cloudGeneration: !!store }, cloud: cloud.status() });
+            return;
+        }
+        if (url.pathname.startsWith('/studio/api/cloud/') || url.pathname === '/studio/api/quotes' || url.pathname === '/studio/api/runs' || url.pathname.startsWith('/studio/api/runs/')) {
+            try {
+                const route = url.pathname.slice('/studio/api/'.length);
+                if (request.method === 'GET') {
+                    if (route === 'cloud/models') {
+                        json(response, 200, { items: await cloud.models() });
+                        return;
+                    }
+                    if (route === 'cloud/balance') {
+                        json(response, 200, await cloud.balance());
+                        return;
+                    }
+                    if (route === 'runs') {
+                        json(response, 200, { items: await cloud.list() });
+                        return;
+                    }
+                }
+                if (request.method === 'POST') {
+                    const body = await smallJson(request, route === 'quotes' ? 192 * 1024 : 1024);
+                    if (route === 'quotes') {
+                        json(response, 201, await cloud.quote(body));
+                        return;
+                    }
+                    if (!body || typeof body !== 'object' || Array.isArray(body))
+                        throw new StudioError('STUDIO_INPUT_INVALID');
+                    const match = /^runs\/([^/]+)\/(confirm|refresh)$/.exec(route);
+                    if (match?.[2] === 'confirm') {
+                        if (Object.keys(body).length !== 1 || !('confirm' in body))
+                            throw new StudioError('STUDIO_INPUT_INVALID');
+                        json(response, 200, await cloud.confirm(match[1], body.confirm));
+                        return;
+                    }
+                    if (Object.keys(body).length)
+                        throw new StudioError('STUDIO_INPUT_INVALID');
+                    if (route === 'cloud/connect') {
+                        saves.invalidate();
+                        json(response, 200, await cloud.connect());
+                        return;
+                    }
+                    if (route === 'cloud/disconnect') {
+                        saves.invalidate();
+                        json(response, 200, await cloud.disconnect());
+                        return;
+                    }
+                    if (match?.[2] === 'refresh') {
+                        json(response, 200, await cloud.refresh(match[1]));
+                        return;
+                    }
+                }
+                throw new StudioError('STUDIO_ROUTE_NOT_FOUND', 404);
+            }
+            catch (error) {
+                const safe = cloudHttpError(error);
+                json(response, safe.status, safe.body);
+                return;
+            }
+        }
+        if (captureRoute) {
+            if (!store)
+                throw new StudioError('STUDIO_OUTPUT_ROOT_REQUIRED', 409);
+            const [, canvasId, captureId, retry] = captureRoute;
+            if (request.method === 'GET') {
+                if (retry)
+                    throw new StudioError('STUDIO_ROUTE_NOT_FOUND', 404);
+                if (captureId) {
+                    json(response, 200, await store.directorCaptures.read(canvasId, captureId));
+                    return;
+                }
+                const query = url.searchParams, keys = [...query.keys()];
+                if (keys.some(k => !['limit', 'cursor'].includes(k)) || new Set(keys).size !== keys.length)
+                    throw new StudioError('STUDIO_INPUT_INVALID');
+                const limit = query.get('limit');
+                if (limit !== null && !/^(?:[1-9]\d?|100)$/.test(limit))
+                    throw new StudioError('STUDIO_INPUT_INVALID');
+                json(response, 200, await store.directorCaptures.list(canvasId, { ...(limit === null ? {} : { limit: Number(limit) }), ...(query.has('cursor') ? { cursor: query.get('cursor') } : {}) }));
+                return;
+            }
+            if (request.method === 'POST') {
+                const body = await smallJson(request, captureId ? 1024 : 12 * 1024 * 1024);
+                if (captureId && !retry)
+                    throw new StudioError('STUDIO_ROUTE_NOT_FOUND', 404);
+                if (retry && (!body || typeof body !== 'object' || Array.isArray(body) || Object.keys(body).length !== 0))
+                    throw new StudioError('STUDIO_INPUT_INVALID');
+                const { status, ...receipt } = retry ? await store.directorCaptures.retry(canvasId, captureId) : await store.directorCaptures.create(canvasId, body);
+                json(response, status, receipt);
+                return;
+            }
+            throw new StudioError('STUDIO_ROUTE_NOT_FOUND', 404);
+        }
+        const canvasRoute = /^\/studio\/api\/canvases(?:\/([^/]+))?$/.exec(url.pathname);
+        if (canvasRoute) {
+            if (!store)
+                throw new StudioError('STUDIO_OUTPUT_ROOT_REQUIRED', 409);
+            const id = canvasRoute[1];
+            if (request.method === 'GET') {
+                json(response, 200, id ? await store.canvases.read(id) : await store.canvases.list());
+                return;
+            }
+            if (request.method === 'POST') {
+                const body = await smallJson(request, id ? 544 * 1024 : 1024);
+                json(response, id ? 200 : 201, id ? await store.canvases.save(id, body) : await store.canvases.create(body));
+                return;
+            }
+        }
+        if (url.pathname === '/studio/api/drafts') {
+            if (!store)
+                throw new StudioError('STUDIO_OUTPUT_ROOT_REQUIRED', 409);
+            if (request.method === 'GET') {
+                json(response, 200, await store.drafts.read());
+                return;
+            }
+            if (request.method === 'POST') {
+                json(response, 200, await store.drafts.save(await smallJson(request, 192 * 1024)));
+                return;
+            }
+        }
+        if (url.pathname === '/studio/api/assets') {
+            if (request.method === 'GET') {
+                json(response, 200, store ? await store.list() : { revision: 0, assets: [], recoveryIssues: [] });
+                return;
+            }
+            if (request.method === 'POST') {
+                if (!store)
+                    throw new StudioError('STUDIO_OUTPUT_ROOT_REQUIRED', 409);
+                const header = request.headers['x-studio-display-name'];
+                let displayName;
+                try {
+                    if (typeof header !== 'string' || header.length > 2400)
+                        throw new Error();
+                    displayName = decodeURIComponent(header);
+                }
+                catch {
+                    throw new StudioError('STUDIO_INPUT_INVALID');
+                }
+                if (request.headers['content-encoding'])
+                    throw new StudioError('STUDIO_INPUT_INVALID');
+                const length = request.headers['content-length'];
+                const asset = await store.save({ displayName, contentType: request.headers['content-type'] ?? '', ...(length === undefined ? {} : { expectedByteLength: Number(length) }), stream: request });
+                json(response, 201, asset);
+                return;
+            }
+        }
+        const content = /^\/studio\/api\/assets\/([^/]+)\/content$/.exec(url.pathname);
+        if (request.method === 'GET' && content) {
+            if (!store)
+                throw new StudioError('STUDIO_OUTPUT_ROOT_REQUIRED', 409);
+            const { asset, stream } = await store.read(content[1]);
+            const abort = () => stream.destroy();
+            response.on('close', abort);
+            try {
+                const range = byteRange(request.headers.range, asset.byteLength);
+                response.writeHead(range.partial ? 206 : 200, { 'Content-Type': asset.mediaType, 'Content-Length': range.end - range.start + 1, 'Accept-Ranges': 'bytes', ...(range.partial ? { 'Content-Range': `bytes ${range.start}-${range.end}/${asset.byteLength}` } : {}) });
+                let offset = 0;
+                for await (const chunk of stream) {
+                    const bytes = Buffer.from(chunk);
+                    const start = Math.max(0, range.start - offset);
+                    const end = Math.min(bytes.length, range.end + 1 - offset);
+                    offset += bytes.length;
+                    if (end > start && !response.write(bytes.subarray(start, end)))
+                        await waitForDrain(response);
+                    if (offset > range.end)
+                        break;
+                }
+                response.end();
+            }
+            finally {
+                response.off('close', abort);
+                stream.destroy();
+            }
+            return;
+        }
+        throw new StudioError('STUDIO_ROUTE_NOT_FOUND', 404);
+    }
+    try {
+        server.listen(0, '127.0.0.1');
+        await once(server, 'listening');
+    }
+    catch (error) {
+        await store?.close();
+        throw storageError(error);
+    }
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        server.close();
+        await store?.close();
+        throw new StudioError('STUDIO_STORAGE_FAILED', 500);
+    }
+    origin = `http://127.0.0.1:${address.port}`;
+    let closePromise;
+    return { origin, launchUrl: `${origin}/studio/#launch=${session.launch}`, close() {
+            return closePromise ??= (async () => {
+                closing = true;
+                saves.invalidate();
+                const stopped = new Promise(resolve => server.close(() => resolve()));
+                server.closeAllConnections();
+                await stopped;
+                await Promise.allSettled([...active]);
+                try {
+                    await saveWorker?.close();
+                }
+                finally {
+                    await store?.close();
+                }
+            })();
+        } };
+}
+//# sourceMappingURL=server.js.map

package/dist/studio/session.d.ts

@@ -0,0 +1,6 @@
+export declare function createStudioSession(): {
+    launch: string;
+    bootstrap(value: unknown): string;
+    assert(cookie: string | undefined): void;
+};
+//# sourceMappingURL=session.d.ts.map

package/dist/studio/session.js

@@ -0,0 +1,26 @@
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { StudioError } from './errors.js';
+function equal(a, b) {
+    return typeof a === 'string' && /^[0-9a-f]{64}$/.test(a) && timingSafeEqual(Buffer.from(a, 'ascii'), Buffer.from(b, 'ascii'));
+}
+export function createStudioSession() {
+    const launch = randomBytes(32).toString('hex');
+    const session = randomBytes(32).toString('hex');
+    const cookieName = `lkstudio_${randomBytes(8).toString('hex')}`;
+    let consumed = false;
+    return {
+        launch,
+        bootstrap(value) {
+            if (consumed || !equal(value, launch))
+                throw new StudioError('STUDIO_SESSION_REQUIRED', 401);
+            consumed = true;
+            return `${cookieName}=${session}; HttpOnly; SameSite=Strict; Path=/studio`;
+        },
+        assert(cookie) {
+            const values = (cookie ?? '').split(';').map(v => v.trim()).filter(v => v.startsWith(`${cookieName}=`));
+            if (!consumed || values.length !== 1 || !equal(values[0].slice(cookieName.length + 1), session))
+                throw new StudioError('STUDIO_SESSION_REQUIRED', 401);
+        },
+    };
+}
+//# sourceMappingURL=session.js.map

package/dist/studio/shell.d.ts

@@ -0,0 +1,3 @@
+export declare const studioHtml = "<!doctype html>\n<html lang=\"zh-CN\"><head><meta charset=\"utf-8\"><meta name=\"viewport\" content=\"width=device-width,initial-scale=1\"><meta name=\"studio-style-nonce\" content=\"__STUDIO_STYLE_NONCE__\"><title>LumenKey \u672C\u5730\u5DE5\u4F5C\u53F0</title><link rel=\"stylesheet\" href=\"/studio/style.css\"><link rel=\"stylesheet\" href=\"/studio/canvas/editor.css\"></head>\n<body><div class=\"app-shell\">\n<aside class=\"sidebar\"><div class=\"brand\"><b>\u5149\u94A5</b><small>LumenKey Studio \u00B7 \u672C\u5730</small></div>\n<nav aria-label=\"\u5DE5\u4F5C\u53F0\u5BFC\u822A\"><button data-view=\"create\" data-mode=\"image\" class=\"selected\">\u56FE\u50CF\u521B\u4F5C</button><button data-view=\"create\" data-mode=\"video\">\u89C6\u9891\u521B\u4F5C</button><button data-view=\"canvas\">\u753B\u5E03</button><button data-view=\"tasks\">\u751F\u6210\u4EFB\u52A1</button><button data-view=\"assets\">\u672C\u673A\u7D20\u6750</button></nav>\n<div class=\"sidebar-bottom\"><small>\u672C\u673A\u7F16\u8F91 \u00B7 \u4E91\u7AEF\u8BA1\u7B97</small><button id=\"theme\" class=\"quiet\">\u5207\u6362\u660E\u6697</button></div></aside>\n<main class=\"workspace\"><div class=\"runtime-header\"><header class=\"topbar\"><span>\u5DE5\u4F5C\u53F0 <span class=\"muted\">/</span> <b id=\"crumb\">\u56FE\u50CF\u521B\u4F5C</b></span><div class=\"top-actions\"><span id=\"balance\" class=\"muted\">\u7B97\u529B\u672A\u77E5</span><button id=\"connect\" class=\"quiet\">\u8FDE\u63A5\u4E91\u7AEF</button><button id=\"disconnect\" class=\"quiet\" hidden>\u65AD\u5F00</button></div></header>\n<div class=\"location runtime-status\" aria-label=\"\u5DE5\u4F5C\u533A\u72B6\u6001\"><div><small>\u4FDD\u5B58\u4F4D\u7F6E</small><details id=\"storage-location\" hidden><summary><span id=\"location-short\"></span><span class=\"hint\"> \u00B7 \u5C55\u5F00\u5B8C\u6574\u8DEF\u5F84</span></summary><code id=\"location\"></code></details><p id=\"storage-warning\">\u6B63\u5728\u8BFB\u53D6\u4FDD\u5B58\u4F4D\u7F6E\u2026</p></div><div><small>\u672C\u673A\u6388\u6743</small><b id=\"local-status\">\u6B63\u5728\u6838\u5BF9\u672C\u673A\u6388\u6743\u2026</b></div><div><small>\u4E91\u8FDE\u63A5</small><b id=\"gateway\">\u4E91\u7AEF\u672A\u8FDE\u63A5</b><span id=\"gateway-detail\" class=\"hint\">\u79BB\u7EBF\u53EF\u7F16\u8F91\uFF1B\u4E91\u7AEF\u751F\u6210\u9700\u8981\u8FDE\u63A5\u3002</span></div></div></div>\n<div class=\"runtime-note\">\u5148\u7F16\u8F91\u5185\u5BB9\uFF0C\u518D\u67E5\u770B\u62A5\u4EF7\u3002\u53EA\u6709\u786E\u8BA4\u63D0\u4EA4\u624D\u4F1A\u521B\u5EFA\u4E91\u7AEF\u4EFB\u52A1\u3002</div>\n<div class=\"view\"><div id=\"error\" class=\"error\" role=\"alert\" hidden></div><p id=\"notice\" role=\"status\" class=\"notice\" hidden></p>\n<section id=\"create-view\"><div class=\"heading\"><div><h1 id=\"title\">\u56FE\u50CF\u521B\u4F5C</h1><p>\u63CF\u8FF0\u4F60\u7684\u60F3\u6CD5\uFF0C\u5148\u67E5\u770B\u62A5\u4EF7\uFF0C\u518D\u51B3\u5B9A\u662F\u5426\u751F\u6210\u3002</p></div><button id=\"save-draft\" class=\"quiet\" disabled>\u4FDD\u5B58\u8349\u7A3F</button></div>\n<div class=\"create-panel\"><section class=\"composer\"><div class=\"section-title\"><h2>\u521B\u4F5C\u8F93\u5165</h2><span id=\"draft-status\" class=\"muted\">\u672A\u4FDD\u5B58</span></div><div id=\"prompt-fields\"></div><p class=\"hint\">\u7559\u7A7A\u9879\u6309\u5E73\u53F0\u76EE\u5F55\u89C4\u5219\u5904\u7406\uFF1B\u672C\u673A\u6587\u4EF6\u4E0D\u4F1A\u81EA\u52A8\u4E0A\u4F20\u3002</p><p id=\"draft-error\" class=\"error\" hidden></p><button id=\"reload-draft\" class=\"quiet\" hidden>\u8BFB\u53D6\u6700\u65B0\u8349\u7A3F\u7248\u672C\uFF08\u4FDD\u7559\u5F53\u524D\u7F16\u8F91\uFF09</button></section>\n<aside class=\"settings\"><h2>\u5E38\u7528\u504F\u597D</h2><label for=\"model\">\u6A21\u578B</label><select id=\"model\" disabled><option value=\"\">\u8FDE\u63A5\u4E91\u7AEF\u540E\u52A0\u8F7D\u76EE\u5F55</option></select><p id=\"catalog-status\" class=\"hint\">\u5C1A\u672A\u8FDE\u63A5</p><button id=\"reload-cloud\" class=\"quiet\" disabled>\u5237\u65B0\u76EE\u5F55\u4E0E\u4F59\u989D</button><div id=\"parameter-fields\"></div><details id=\"advanced-parameters\" hidden><summary>\u66F4\u591A\u53C2\u6570 <span class=\"hint\">JSON \u7B49\u590D\u6742\u8F93\u5165</span></summary><div id=\"advanced-fields\"></div></details><div class=\"quote-area\"><p id=\"quote-hint\" class=\"hint\">\u53EA\u62A5\u4EF7\uFF0C\u4E0D\u4F1A\u521B\u5EFA\u751F\u6210\u4EFB\u52A1\u3002</p><button id=\"quote\" class=\"primary\" disabled>\u67E5\u770B\u62A5\u4EF7</button></div></aside>\n<section class=\"output\"><div class=\"section-title\"><h2>\u672C\u6B21\u62A5\u4EF7\u4E0E\u7ED3\u679C</h2></div><div id=\"current-run\" class=\"empty\">\u586B\u5199\u8F93\u5165\u5E76\u9009\u62E9\u6A21\u578B\u540E\u67E5\u770B\u62A5\u4EF7\u3002</div><button id=\"review-quote\" class=\"primary\" hidden>\u6838\u5BF9\u5E76\u786E\u8BA4\u751F\u6210</button></section></div></section>\n<section id=\"canvas-view\" hidden aria-label=\"\u672C\u673A\u753B\u5E03\"></section>\n<section id=\"tasks-view\" hidden><div class=\"heading\"><div><h1>\u751F\u6210\u4EFB\u52A1</h1><p>\u5F53\u524D\u8FDE\u63A5\u7684\u672C\u5730\u4EFB\u52A1\u8BB0\u5F55\u3002\u5237\u65B0\u53EA\u67E5\u8BE2\u72B6\u6001\uFF0C\u4E0D\u4F1A\u91CD\u65B0\u4E0B\u5355\u3002</p></div><button id=\"refresh-tasks\" class=\"quiet\">\u5237\u65B0\u4EFB\u52A1\u5217\u8868</button></div><section class=\"save-binding\" aria-label=\"\u8F93\u51FA\u4FDD\u5B58\u8FDE\u63A5\"><p id=\"save-binding-status\" role=\"status\" class=\"hint\"></p><code id=\"save-binding-path\" hidden></code><button id=\"rebind-saves\" class=\"quiet\" disabled>\u91CD\u65B0\u6838\u5BF9\u4FDD\u5B58\u8FDE\u63A5</button></section><p id=\"tasks-status\" role=\"status\" class=\"hint\"></p><div id=\"tasks\"></div></section>\n<section id=\"assets-view\" hidden><div class=\"heading\"><div><h1>\u672C\u673A\u7D20\u6750</h1><p>\u8FD9\u91CC\u4EC5\u663E\u793A\u5DF2\u7ECF\u5199\u5165\u6240\u9009\u76EE\u5F55\u7684\u6587\u4EF6\u3002</p></div><button id=\"refresh-assets\" class=\"quiet\">\u5237\u65B0\u7D20\u6750</button></div><form id=\"save-asset\" class=\"import\"><label for=\"file\">\u5BFC\u5165\u5DF2\u6709\u56FE\u7247\u6216\u89C6\u9891</label><input id=\"file\" type=\"file\" accept=\"image/png,image/jpeg,image/webp,video/mp4,video/webm\"><button id=\"save-asset-button\" class=\"quiet\" disabled>\u4FDD\u5B58\u5230\u672C\u673A\u76EE\u5F55</button></form><p id=\"asset-message\" role=\"status\" class=\"hint\"></p><p id=\"assets-status\" role=\"status\" class=\"hint\"></p><div id=\"assets\" class=\"assets-grid\"></div><p id=\"issues\" class=\"error\" hidden></p></section>\n<footer>\u8349\u7A3F\u548C\u4EFB\u52A1\u8F93\u5165\u4FDD\u5B58\u5728\u672C\u673A\u76EE\u5F55\uFF0C\u672A\u52A0\u5BC6\u3002\u4E91\u7AEF\u5B8C\u6210\u4E0D\u7B49\u4E8E\u5DF2\u4FDD\u5B58\u5230\u672C\u673A\uFF1B\u672C\u5730\u72B6\u6001\u4E0D\u8BC1\u660E\u6263\u8D39\u6216\u9000\u6B3E\u3002</footer></div></main></div>\n<dialog id=\"confirm-dialog\" aria-labelledby=\"confirm-title\"><h2 id=\"confirm-title\">\u786E\u8BA4\u672C\u6B21\u751F\u6210</h2><p id=\"confirm-summary\"></p><p class=\"hint\">\u5C06\u4F7F\u7528\u5DF2\u62A5\u4EF7\u7684\u8F93\u5165\u3002\u5B9E\u9645\u6263\u8D39\u4E0E\u5931\u8D25\u91CA\u653E\u4EE5\u5E73\u53F0\u8D26\u672C\u4E3A\u51C6\u3002</p><div class=\"dialog-actions\"><button id=\"cancel-confirm\" class=\"quiet\">\u6682\u4E0D\u63D0\u4EA4</button><button id=\"confirm\" class=\"primary\">\u786E\u8BA4\u63D0\u4EA4</button></div></dialog>\n<script type=\"module\" src=\"/studio/app.js\"></script></body></html>";
+export declare const studioScript = "import './web/app.js';";
+//# sourceMappingURL=shell.d.ts.map