openworkgraph 0.2.12

package/dist/storage-api.js

@@ -0,0 +1,92 @@
+import { lstat, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { Auth } from './auth.js';
+import { ServiceError } from './errors.js';
+import { readJson } from './http.js';
+import { transaction } from './persistence/database.js';
+import { Resources } from './resources.js';
+const category = (name) => {
+    if (name === 'service.sqlite' || name.startsWith('service.sqlite-'))
+        return 'database';
+    if (name === 'blobs')
+        return 'resources';
+    if (name === 'runs')
+        return 'runs';
+    if (name === 'backups')
+        return 'backups';
+    if (name === 'config')
+        return 'config';
+    if (name === 'staging')
+        return 'staging';
+    return 'other';
+};
+/** Count managed files below the Runtime data root; never follow symlinks. */
+export async function measureStorage(directories) {
+    const categories = { database: 0, resources: 0, runs: 0, backups: 0, config: 0, staging: 0, other: 0 };
+    const pending = [{ path: directories.root, category: 'other' }];
+    while (pending.length) {
+        const directory = pending.pop();
+        let entries;
+        try {
+            entries = await readdir(directory.path, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' && directory.path !== directories.root)
+                continue;
+            throw error;
+        }
+        for (const entry of entries) {
+            const path = join(directory.path, entry.name);
+            const group = directory.path === directories.root ? category(entry.name) : directory.category;
+            let info;
+            try {
+                info = await lstat(path);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            if (info.isSymbolicLink())
+                continue;
+            if (info.isDirectory())
+                pending.push({ path, category: group });
+            else if (info.isFile())
+                categories[group] += info.size;
+        }
+    }
+    return { totalBytes: Object.values(categories).reduce((sum, bytes) => sum + bytes, 0), categories, measuredAt: new Date().toISOString() };
+}
+export class StorageApi {
+    db;
+    directories;
+    resources;
+    auth;
+    constructor(db, directories, resources, auth) {
+        this.db = db;
+        this.directories = directories;
+        this.resources = resources;
+        this.auth = auth;
+    }
+    async handle(request, path, token, origin) {
+        if (path !== '/v1/storage' && path !== '/v1/storage/cleanup')
+            return { handled: false };
+        this.auth.withSession(token, origin, () => undefined);
+        if (path === '/v1/storage' && request.method === 'GET') {
+            const usage = await measureStorage(this.directories);
+            return this.auth.withSession(token, origin, () => ({ handled: true, body: usage }));
+        }
+        if (path === '/v1/storage/cleanup' && request.method === 'POST') {
+            const body = await readJson(request, 1024);
+            if (Object.keys(body).length)
+                throw new ServiceError('INVALID_REQUEST', '缓存清理不接受额外参数。');
+            this.auth.withSession(token, origin, () => undefined);
+            const collected = transaction(this.db, () => this.resources.collectGarbage(undefined, true));
+            const deletion = await this.resources.drainFileDeletions();
+            const usage = await measureStorage(this.directories);
+            return this.auth.withSession(token, origin, () => ({ handled: true, body: { collectedResources: collected.canvas, collectedBlobs: collected.blobs, removedFiles: deletion.removed, failedFiles: deletion.failed, usage } }));
+        }
+        throw new ServiceError('NOT_FOUND', '存储数据接口不存在。');
+    }
+}
+//# sourceMappingURL=storage-api.js.map

package/dist/transfer-api.d.ts

@@ -0,0 +1,10 @@
+import type { IncomingMessage } from 'node:http';
+import type { ApiResult } from './api.js';
+import { Auth } from './auth.js';
+import { GraphTransfer } from './graph-transfer.js';
+export declare class TransferApi {
+    readonly transfer: GraphTransfer;
+    readonly auth: Auth;
+    constructor(transfer: GraphTransfer, auth: Auth);
+    handle(request: IncomingMessage, path: string, token: string, origin: string): Promise<ApiResult>;
+}

package/dist/transfer-api.js

@@ -0,0 +1,60 @@
+import { Auth } from './auth.js';
+import { GraphTransfer } from './graph-transfer.js';
+import { readJson } from './http.js';
+import { ServiceError } from './errors.js';
+import { GRAPH_BINARY_MIME, GRAPH_METADATA_MAX_BYTES, graphBinaryParts, readGraphBinary, jsonByteLength, WORKGRAPH_TRANSFER_TOTAL_BYTES } from "./vendor/protocol/index.js";
+export class TransferApi {
+    transfer;
+    auth;
+    constructor(transfer, auth) {
+        this.transfer = transfer;
+        this.auth = auth;
+    }
+    async handle(request, path, token, origin) {
+        const match = /^[/]v1[/]projects[/]([a-zA-Z0-9_-]+)[/]graphs[/](import|[a-zA-Z0-9_-]+[/](?:export|copied-provenance))$/.exec(path);
+        if (!match)
+            return { handled: false };
+        const principal = this.auth.withSession(token, origin, s => s.id), scope = { serviceId: this.transfer.graphs.serviceId, projectId: match[1] };
+        if (request.method === 'GET' && match[2] !== 'import') {
+            if (match[2].endsWith('/copied-provenance'))
+                return this.auth.withSession(token, origin, () => ({ handled: true, body: this.transfer.getCopiedProvenance({ ...scope, graphId: match[2].split('/')[0] }) }));
+            const value = await this.transfer.exportGraph({ ...scope, graphId: match[2].split('/')[0] });
+            if (request.headers.accept === GRAPH_BINARY_MIME) {
+                const binaryParts = graphBinaryParts(value);
+                return this.auth.withSession(token, origin, () => ({ handled: true, binaryParts, headers: { 'Content-Type': GRAPH_BINARY_MIME, 'Content-Length': String(binaryParts.reduce((sum, part) => sum + part.length, 0)) } }));
+            }
+            if (jsonByteLength(value) > GRAPH_METADATA_MAX_BYTES)
+                throw new ServiceError('PAYLOAD_TOO_LARGE', '大工作图需要二进制传输，请更新 Web 客户端后重试。');
+            return this.auth.withSession(token, origin, () => ({ handled: true, body: value }));
+        }
+        if (request.method === 'POST' && match[2] === 'import') {
+            let body;
+            if (request.headers['content-type'] === GRAPH_BINARY_MIME) {
+                if (request.headers['content-encoding'])
+                    throw new ServiceError('UNSUPPORTED_MEDIA_TYPE', '不支持压缩的工作图传输请求。');
+                if (Number(request.headers['content-length'] ?? 0) > WORKGRAPH_TRANSFER_TOTAL_BYTES + 8)
+                    throw new ServiceError('PAYLOAD_TOO_LARGE', '工作图导入不能超过 1 GB。');
+                try {
+                    body = await readGraphBinary(request);
+                }
+                catch {
+                    throw new ServiceError('INVALID_REQUEST', '工作图二进制资源不完整、格式无效或超过大小限制。');
+                }
+            }
+            else
+                body = await readJson(request, Math.min(this.transfer.limits.maxBundleBytes + 4096, GRAPH_METADATA_MAX_BYTES));
+            if (Object.keys(body).some(k => !['bundle', 'idempotencyKey'].includes(k)) || typeof body.idempotencyKey !== 'string' || !body.idempotencyKey || body.idempotencyKey.length > 256)
+                throw new ServiceError('INVALID_REQUEST', '导入需要图包和幂等键。');
+            this.auth.withSession(token, origin, () => undefined);
+            const prepared = await this.transfer.prepareImport(scope, body.bundle);
+            try {
+                return this.auth.withSession(token, origin, () => ({ handled: true, body: this.transfer.commitImport(scope, prepared, { idempotencyKey: body.idempotencyKey, principal }) }));
+            }
+            finally {
+                await this.transfer.disposePreparedImport(prepared);
+            }
+        }
+        throw new ServiceError('NOT_FOUND', '图传输接口不存在。');
+    }
+}
+//# sourceMappingURL=transfer-api.js.map

package/dist/vendor/protocol/contracts.typecheck.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vendor/protocol/contracts.typecheck.js

@@ -0,0 +1,35 @@
+function contracts(browser, local, graph, selection) {
+    void browser.setModelDefaults(selection, 0);
+    void browser.commandGraph(graph);
+    void browser.previewHistoryCleanup(['run']);
+    void browser.continueRestoredRun('run', 'request');
+    void local.previewRestore('/backup');
+    // @ts-expect-error Browser must not expose backup restoration.
+    void browser.restore('/backup', 'sha256');
+    // @ts-expect-error Restored runs require an idempotency key.
+    void browser.continueRestoredRun('run');
+    // @ts-expect-error Backend-private states must not leak into DTOs.
+    const state = 'backend_turn_finished';
+    void state;
+}
+void contracts;
+function resourceContracts(resources, envelope) {
+    // @ts-expect-error Canvas inputs must not bind directly to library AssetVersion.
+    void envelope.asset;
+    // @ts-expect-error Explicit update target and CAS version are required for library updates.
+    const update = { serviceId: 's', projectId: 'p', uploadId: 'u', name: 'file', idempotencyKey: 'k', mode: 'update' };
+    // @ts-expect-error Automatic propagation/accept-pending-version is not an API.
+    void resources.acceptAssetUpdate('node', 'asset');
+    void update;
+}
+void resourceContracts;
+const imageApiRun = { serviceId: 's', projectId: 'p', graphId: 'g', nodeId: 'n', kind: 'image_generation', idempotencyKey: 'k', expectedExecutionRevision: 0, imageRoute: { type: 'api', providerId: 'provider', modelId: 'image-model' } };
+// @ts-expect-error API image tasks cannot select a Codex model.
+const invalidApiRun = { ...imageApiRun, modelOverride: { model: 'codex', reasoningEffort: null } };
+// @ts-expect-error Text tasks cannot select an image provider.
+const invalidTextRoute = { ...imageApiRun, kind: 'text_generation' };
+void imageApiRun;
+void invalidApiRun;
+void invalidTextRoute;
+export {};
+//# sourceMappingURL=contracts.typecheck.js.map

package/dist/vendor/protocol/execution-chain.d.ts

@@ -0,0 +1,6 @@
+/** Kahn ordering for execution dependencies only. Reference feedback is unrelated. */
+export declare function executionOrder(edges: readonly {
+    sourceId: string;
+    targetId: string;
+    kind?: string;
+}[]): string[] | null;

package/dist/vendor/protocol/execution-chain.js

@@ -0,0 +1,26 @@
+/** Kahn ordering for execution dependencies only. Reference feedback is unrelated. */
+export function executionOrder(edges) {
+    const indegree = new Map();
+    const outgoing = new Map();
+    for (const edge of edges) {
+        if (edge.kind !== 'execution')
+            continue;
+        if (!indegree.has(edge.sourceId))
+            indegree.set(edge.sourceId, 0);
+        indegree.set(edge.targetId, (indegree.get(edge.targetId) ?? 0) + 1);
+        const next = outgoing.get(edge.sourceId) ?? [];
+        next.push(edge.targetId);
+        outgoing.set(edge.sourceId, next);
+    }
+    const ready = [...indegree].filter(([, count]) => count === 0).map(([id]) => id);
+    for (let index = 0; index < ready.length; index++) {
+        for (const id of outgoing.get(ready[index]) ?? []) {
+            const count = indegree.get(id) - 1;
+            indegree.set(id, count);
+            if (count === 0)
+                ready.push(id);
+        }
+    }
+    return ready.length === indegree.size ? ready : null;
+}
+//# sourceMappingURL=execution-chain.js.map

package/dist/vendor/protocol/graph-binary.d.ts

@@ -0,0 +1,15 @@
+import type { GraphBundle } from './index.js';
+/** HTTP representation: an 8-byte header, JSON metadata, then raw assets.
+ * The user-facing ZIP archive format remains separate and unchanged. */
+export declare const GRAPH_BINARY_MIME = "application/vnd.openworkgraph.bundle+octet-stream";
+export declare const GRAPH_METADATA_MAX_BYTES: number;
+export declare function base64Bytes(value: string): Uint8Array;
+export declare function bytesBase64(value: Uint8Array): string;
+export declare function graphBinaryParts(bundle: GraphBundle, idempotencyKey?: string): Uint8Array[];
+/** Bounded incremental reads avoid an aggregate JSON string or binary buffer. */
+export declare function readGraphBinary(source: AsyncIterable<Uint8Array>): Promise<{
+    bundle: GraphBundle;
+    idempotencyKey?: string;
+}>;
+/** Count JSON bytes without stringifying the aggregate bundle. */
+export declare function jsonByteLength(value: unknown): number;

package/dist/vendor/protocol/graph-binary.js

@@ -0,0 +1,121 @@
+import { WORKGRAPH_TRANSFER_TOTAL_BYTES, WORKGRAPH_UPLOAD_MAX_BYTES } from './index.js';
+/** HTTP representation: an 8-byte header, JSON metadata, then raw assets.
+ * The user-facing ZIP archive format remains separate and unchanged. */
+export const GRAPH_BINARY_MIME = 'application/vnd.openworkgraph.bundle+octet-stream';
+export const GRAPH_METADATA_MAX_BYTES = 128 * 1024 * 1024;
+const encoder = new TextEncoder();
+function invalid() { throw new Error('Invalid or oversized Work Graph binary bundle'); }
+export function base64Bytes(value) {
+    const raw = atob(value);
+    const result = new Uint8Array(raw.length);
+    for (let i = 0; i < raw.length; i++)
+        result[i] = raw.charCodeAt(i);
+    return result;
+}
+export function bytesBase64(value) {
+    const parts = [];
+    // Divisible by three: concatenation preserves base64 padding semantics.
+    for (let i = 0; i < value.length; i += 49152)
+        parts.push(btoa(String.fromCharCode(...value.subarray(i, i + 49152))));
+    return parts.join('');
+}
+export function graphBinaryParts(bundle, idempotencyKey) {
+    let total = 0;
+    if (!Array.isArray(bundle.resources) || bundle.resources.length > 256)
+        invalid();
+    const resources = bundle.resources.map(({ base64: _base64, ...resource }) => {
+        if (!Number.isSafeInteger(resource.bytes) || resource.bytes < 0 || resource.bytes > WORKGRAPH_UPLOAD_MAX_BYTES)
+            invalid();
+        total += resource.bytes;
+        if (total > WORKGRAPH_TRANSFER_TOTAL_BYTES)
+            invalid();
+        return resource;
+    });
+    const metadata = encoder.encode(JSON.stringify({ bundle: { ...bundle, resources }, ...(idempotencyKey === undefined ? {} : { idempotencyKey }) }));
+    if (metadata.length > GRAPH_METADATA_MAX_BYTES || total + metadata.length > WORKGRAPH_TRANSFER_TOTAL_BYTES)
+        invalid();
+    const header = new Uint8Array(8);
+    header.set([79, 87, 71, 66]); // OWGB
+    new DataView(header.buffer).setUint32(4, metadata.length);
+    return [header, metadata, ...bundle.resources.map(resource => {
+            if (resource.base64.length !== Math.ceil(resource.bytes / 3) * 4)
+                invalid();
+            const bytes = base64Bytes(resource.base64);
+            if (bytes.length !== resource.bytes)
+                invalid();
+            return bytes;
+        })];
+}
+/** Bounded incremental reads avoid an aggregate JSON string or binary buffer. */
+export async function readGraphBinary(source) {
+    const iterator = source[Symbol.asyncIterator]();
+    let chunk = new Uint8Array(0), offset = 0, received = 0;
+    async function next() {
+        const item = await iterator.next();
+        if (item.done)
+            return false;
+        chunk = item.value;
+        offset = 0;
+        received += chunk.length;
+        if (received > WORKGRAPH_TRANSFER_TOTAL_BYTES + 8)
+            invalid();
+        return true;
+    }
+    async function read(size) {
+        const result = new Uint8Array(size);
+        let filled = 0;
+        while (filled < size) {
+            if (offset === chunk.length) {
+                if (!await next())
+                    invalid();
+                continue;
+            }
+            const length = Math.min(size - filled, chunk.length - offset);
+            result.set(chunk.subarray(offset, offset + length), filled);
+            filled += length;
+            offset += length;
+        }
+        return result;
+    }
+    try {
+        const header = await read(8);
+        if (header[0] !== 79 || header[1] !== 87 || header[2] !== 71 || header[3] !== 66)
+            invalid();
+        const length = new DataView(header.buffer).getUint32(4);
+        if (!length || length > GRAPH_METADATA_MAX_BYTES)
+            invalid();
+        const envelope = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(await read(length)));
+        if (!envelope || Object.keys(envelope).some(key => !['bundle', 'idempotencyKey'].includes(key)) || !envelope.bundle || !Array.isArray(envelope.bundle.resources) || envelope.bundle.resources.length > 256)
+            invalid();
+        let total = length;
+        // Validate all lengths before allocating any asset buffers.
+        for (const resource of envelope.bundle.resources) {
+            if (!resource || Object.hasOwn(resource, 'base64') || !Number.isSafeInteger(resource.bytes) || resource.bytes < 0 || resource.bytes > WORKGRAPH_UPLOAD_MAX_BYTES)
+                invalid();
+            total += resource.bytes;
+            if (total > WORKGRAPH_TRANSFER_TOTAL_BYTES)
+                invalid();
+        }
+        for (const resource of envelope.bundle.resources)
+            resource.base64 = bytesBase64(await read(resource.bytes));
+        if (offset !== chunk.length)
+            invalid();
+        while (await next())
+            if (chunk.length)
+                invalid();
+        return envelope;
+    }
+    finally {
+        await iterator.return?.();
+    }
+}
+/** Count JSON bytes without stringifying the aggregate bundle. */
+export function jsonByteLength(value) {
+    if (value === null || typeof value !== 'object')
+        return encoder.encode(JSON.stringify(value)).length;
+    if (Array.isArray(value))
+        return 2 + Math.max(0, value.length - 1) + value.reduce((sum, item) => sum + jsonByteLength(item), 0);
+    const entries = Object.entries(value).filter(([, item]) => item !== undefined);
+    return 2 + Math.max(0, entries.length - 1) + entries.reduce((sum, [key, item]) => sum + encoder.encode(JSON.stringify(key)).length + 1 + jsonByteLength(item), 0);
+}
+//# sourceMappingURL=graph-binary.js.map

package/dist/vendor/protocol/graph-title.d.ts

@@ -0,0 +1,2 @@
+/** Resolve an imported graph title against every graph in the target project. */
+export declare function importedGraphTitle(title: string, existingTitles: Iterable<string>, maxLength?: number): string;

package/dist/vendor/protocol/graph-title.js

@@ -0,0 +1,23 @@
+const DEFAULT_GRAPH_TITLE_LIMIT = 1024;
+function truncateTitle(value, length) {
+    let result = value.slice(0, length);
+    const last = result.charCodeAt(result.length - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        result = result.slice(0, -1);
+    return result.replace(/\s+$/u, '');
+}
+/** Resolve an imported graph title against every graph in the target project. */
+export function importedGraphTitle(title, existingTitles, maxLength = DEFAULT_GRAPH_TITLE_LIMIT) {
+    const existing = new Set(existingTitles);
+    if (!existing.has(title))
+        return title;
+    for (let suffix = 1; suffix < Number.MAX_SAFE_INTEGER; suffix++) {
+        const marker = ` (${suffix})`;
+        const base = truncateTitle(title, Math.max(0, maxLength - marker.length));
+        const candidate = (base || title.slice(0, Math.max(0, maxLength - marker.length))) + marker;
+        if (!existing.has(candidate))
+            return candidate;
+    }
+    throw new Error('无法为导入的工作图生成唯一名称。');
+}
+//# sourceMappingURL=graph-title.js.map