openworkgraph 0.2.12

package/dist/plugins.js

@@ -0,0 +1,239 @@
+import { ServiceError } from './errors.js';
+const forbidden = new Set(['__proto__', 'prototype', 'constructor']);
+const builtins = new Set(['text', 'image', 'document', 'video', 'file', 'preview', 'execution', 'group']);
+function invalid(message) { throw new ServiceError('INVALID_REQUEST', message); }
+/** Bounded pure JSON only: no getters, functions, cycles or exotic prototypes. */
+export function checkedJson(value, maxBytes = 16_777_216, maxDepth = 32) {
+    let bytes = 0;
+    const seen = new Set();
+    function visit(v, depth) {
+        if (depth > maxDepth)
+            invalid('JSON depth limit exceeded');
+        if (v === null || typeof v === 'boolean')
+            bytes += 5;
+        else if (typeof v === 'number' && Number.isFinite(v))
+            bytes += 24;
+        else if (typeof v === 'string')
+            bytes += Buffer.byteLength(JSON.stringify(v));
+        else if (typeof v === 'object' && v !== null) {
+            if (seen.has(v))
+                invalid('Cyclic JSON');
+            if (!Array.isArray(v) && Object.getPrototypeOf(v) !== Object.prototype && Object.getPrototypeOf(v) !== null)
+                invalid('Only plain JSON objects supported');
+            seen.add(v);
+            bytes += 2;
+            for (const key of Reflect.ownKeys(v)) {
+                if (Array.isArray(v) && key === 'length')
+                    continue;
+                if (typeof key !== 'string' || forbidden.has(key))
+                    invalid('Unsafe JSON key');
+                const descriptor = Object.getOwnPropertyDescriptor(v, key);
+                if (!('value' in descriptor) || !descriptor.enumerable)
+                    invalid('JSON accessors are not supported');
+                bytes += Buffer.byteLength(key) + 4;
+                visit(descriptor.value, depth + 1);
+                if (bytes > maxBytes)
+                    invalid('JSON size limit exceeded');
+            }
+            seen.delete(v);
+        }
+        else
+            invalid('Value is not JSON');
+        if (bytes > maxBytes)
+            invalid('JSON size limit exceeded');
+    }
+    // Clone the validated tree without constructing a single aggregate string.
+    // Strings are immutable and can be shared, including large resource payloads.
+    function clone(v) {
+        if (v === null || typeof v !== 'object')
+            return Object.is(v, -0) ? 0 : v;
+        if (Array.isArray(v))
+            return Array.from(v, item => item === undefined ? null : clone(item));
+        return Object.fromEntries(Object.entries(v).map(([key, item]) => [key, clone(item)]));
+    }
+    visit(value, 0);
+    return clone(value);
+}
+function object(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
+function path(field) {
+    if (typeof field !== 'string' || field.length > 256)
+        invalid('Invalid resource field path');
+    const parts = field.split('.');
+    if (parts.length > 8 || parts.some(p => !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(p) || forbidden.has(p)))
+        invalid('Invalid resource field path');
+    return parts;
+}
+export function readField(content, field) {
+    let value = content;
+    for (const key of path(field))
+        value = object(value) && Object.hasOwn(value, key) ? value[key] : undefined;
+    return value;
+}
+function validateSchema(schema) {
+    if (!object(schema) || !['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'].includes(schema.type))
+        invalid('Unsupported content schema');
+    for (const key of Object.keys(schema))
+        if (!['type', 'properties', 'required', 'items', 'additionalProperties'].includes(key))
+            invalid(`Unsupported schema keyword ${key}`);
+    if (schema.properties !== undefined) {
+        if (schema.type !== 'object' || !object(schema.properties))
+            invalid('Invalid schema properties');
+        for (const value of Object.values(schema.properties))
+            validateSchema(value);
+    }
+    if (schema.required !== undefined && (schema.type !== 'object' || !Array.isArray(schema.required) || schema.required.some(k => typeof k !== 'string' || forbidden.has(k))))
+        invalid('Invalid required fields');
+    if (schema.additionalProperties !== undefined && (schema.type !== 'object' || typeof schema.additionalProperties !== 'boolean'))
+        invalid('Invalid additionalProperties');
+    if (schema.items !== undefined) {
+        if (schema.type !== 'array')
+            invalid('Invalid array schema');
+        validateSchema(schema.items);
+    }
+}
+function matches(schema, value) {
+    if (schema.type === 'null')
+        return value === null;
+    if (schema.type === 'array')
+        return Array.isArray(value) && (!schema.items || value.every(v => matches(schema.items, v)));
+    if (schema.type === 'object')
+        return object(value) && (schema.required ?? []).every(k => Object.hasOwn(value, k)) && Object.entries(value).every(([k, v]) => schema.properties?.[k] ? matches(schema.properties[k], v) : schema.additionalProperties !== false);
+    if (schema.type === 'integer')
+        return typeof value === 'number' && Number.isSafeInteger(value);
+    return typeof value === schema.type;
+}
+function validateContract(input) {
+    const c = checkedJson(input, 65_536, 16);
+    if (!object(c) || !/^[a-z][a-z0-9._-]{0,127}$/.test(c.typeId) || typeof c.typeId !== 'string')
+        invalid('Invalid typeId');
+    if (Object.keys(c).some(k => !['typeId', 'pluginId', 'version', 'apiVersion', 'schemaVersion', 'contentSchema', 'resources', 'migrations'].includes(k)))
+        invalid('Unsupported contract field; executable entries are not resource contracts');
+    if (typeof c.pluginId !== 'string' || !/^[a-z][a-z0-9._-]{0,127}$/.test(c.pluginId) || typeof c.version !== 'string' || !/^[0-9]+[.][0-9]+[.][0-9]+$/.test(c.version))
+        invalid('Invalid plugin identity/version');
+    if (c.apiVersion !== '1.0' || !Number.isSafeInteger(c.schemaVersion) || c.schemaVersion < 1)
+        invalid('Unsupported API/schema version');
+    validateSchema(c.contentSchema);
+    if (!Array.isArray(c.resources) || c.resources.length > 32)
+        invalid('Invalid resource mappings');
+    for (const m of c.resources) {
+        if (!object(m) || !['text', 'image', 'document', 'video', 'file'].includes(m.kind))
+            invalid('Invalid resource kind');
+        if (Object.keys(m).some(k => !['kind', 'textField', 'resourceIdField', 'resourceVersionField'].includes(k)))
+            invalid('Unsupported resource mapping');
+        for (const field of [m.textField, m.resourceIdField, m.resourceVersionField])
+            if (field !== undefined)
+                path(field);
+        if (!!m.resourceIdField !== !!m.resourceVersionField || (!m.textField && !m.resourceIdField))
+            invalid('Incomplete resource mapping');
+        if (['image', 'video', 'file'].includes(m.kind) && !m.resourceIdField)
+            invalid('Media requires resource identity');
+    }
+    if (c.migrations !== undefined) {
+        if (!Array.isArray(c.migrations) || c.migrations.length > 16)
+            invalid('Invalid migrations');
+        const versions = new Set();
+        for (const m of c.migrations) {
+            if (!object(m) || !Number.isSafeInteger(m.fromSchemaVersion) || m.fromSchemaVersion < 1 || m.fromSchemaVersion >= c.schemaVersion || versions.has(m.fromSchemaVersion))
+                invalid('Invalid migration source');
+            versions.add(m.fromSchemaVersion);
+            if (Object.keys(m).some(k => !['fromSchemaVersion', 'rename', 'defaults'].includes(k)))
+                invalid('Unsupported migration operation');
+            if (m.rename !== undefined) {
+                if (!object(m.rename))
+                    invalid('Invalid rename');
+                const targets = new Set();
+                for (const [from, to] of Object.entries(m.rename)) {
+                    if (path(from).length !== 1 || path(to).length !== 1 || targets.has(to))
+                        invalid('Migration renames must be unique top-level fields');
+                    targets.add(to);
+                }
+            }
+            if (m.defaults !== undefined && !object(m.defaults))
+                invalid('Invalid migration defaults');
+        }
+    }
+    return c;
+}
+export class PluginRegistry {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Local control only; never call for untrusted graph import or from browser routes. */
+    registerTrusted(input) {
+        const c = validateContract(input);
+        if (builtins.has(c.typeId))
+            invalid('Built-in type cannot be replaced');
+        this.db.exec('SAVEPOINT plugin_registration');
+        try {
+            const existing = this.db.prepare('SELECT contract FROM plugin_contracts WHERE type=?').all(c.typeId);
+            if (existing.some(row => JSON.parse(String(row['contract'])).pluginId !== c.pluginId))
+                throw new ServiceError('CONFLICT', 'Type already owned by another plugin');
+            const previous = this.db.prepare('SELECT contract FROM plugin_contracts WHERE type=? AND schema_version=?').get(c.typeId, c.schemaVersion);
+            if (previous) {
+                if (String(previous['contract']) === JSON.stringify(c)) {
+                    this.db.exec('RELEASE plugin_registration');
+                    return c;
+                }
+                throw new ServiceError('CONFLICT', 'Registered schema versions are immutable; register a new schema version');
+            }
+            this.db.prepare('INSERT INTO plugin_contracts(type,schema_version,api_version,contract) VALUES (?,?,?,?)').run(c.typeId, c.schemaVersion, c.apiVersion, JSON.stringify(c));
+            this.db.exec('RELEASE plugin_registration');
+            return c;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK TO plugin_registration; RELEASE plugin_registration');
+            throw error;
+        }
+    }
+    get(type, schemaVersion) {
+        if (builtins.has(type)) {
+            if (schemaVersion !== 1)
+                return null;
+            if (type === 'group')
+                return { typeId: type, pluginId: 'core', version: '1.0.0', apiVersion: '1.0', schemaVersion: 1, contentSchema: { type: 'object', properties: { title: { type: 'string' } }, additionalProperties: false }, resources: [] };
+            const resources = ['execution', 'preview'].includes(type) ? [] : [{ kind: type, ...(type === 'text' ? { textField: 'text' } : type === 'file' ? { resourceIdField: 'resourceId', resourceVersionField: 'resourceVersion' } : { textField: 'text', resourceIdField: 'resourceId', resourceVersionField: 'resourceVersion' }) }];
+            return { typeId: type, pluginId: 'core', version: '1.0.0', apiVersion: '1.0', schemaVersion: 1, contentSchema: { type: 'object' }, resources };
+        }
+        const row = this.db.prepare('SELECT contract FROM plugin_contracts WHERE type=? AND schema_version=?').get(type, schemaVersion);
+        return row ? validateContract(JSON.parse(String(row['contract']))) : null;
+    }
+    inspect(type, schemaVersion, input) {
+        const content = checkedJson(input);
+        let contract;
+        try {
+            contract = this.get(type, schemaVersion);
+        }
+        catch {
+            return { state: 'incompatible', typeId: type, schemaVersion, content, reason: 'Stored contract is incompatible', contract: null };
+        }
+        if (!contract)
+            return { state: 'missing', typeId: type, schemaVersion, content, reason: 'Resource contract is unavailable', contract: null };
+        const valid = matches(contract.contentSchema, content);
+        return { state: valid ? 'available' : 'invalid', typeId: type, schemaVersion, content, reason: valid ? null : 'Content does not match schema', contract };
+    }
+    /** Pure copy-on-success migration. Caller persists new node version atomically; old version is never changed. */
+    migrate(type, fromSchema, toSchema, input) {
+        const original = checkedJson(input);
+        const target = this.get(type, toSchema);
+        const migration = target?.migrations?.find(m => m.fromSchemaVersion === fromSchema);
+        if (!target || !migration || !object(original))
+            throw new ServiceError('MIGRATION_FAILED', 'No explicit declarative migration');
+        const result = { ...original };
+        for (const [from, to] of Object.entries(migration.rename ?? {})) {
+            if (!Object.hasOwn(original, from) || from === to)
+                continue;
+            if (Object.hasOwn(result, to))
+                throw new ServiceError('MIGRATION_FAILED', `Migration would overwrite ${to}; original preserved`);
+            result[to] = original[from];
+            delete result[from];
+        }
+        for (const [key, value] of Object.entries(migration.defaults ?? {}))
+            if (!Object.hasOwn(result, key))
+                result[key] = value;
+        if (!matches(target.contentSchema, result))
+            throw new ServiceError('MIGRATION_FAILED', 'Migrated content is invalid; original preserved');
+        return checkedJson(result);
+    }
+}
+//# sourceMappingURL=plugins.js.map

package/dist/project-discovery.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectCandidates } from "./vendor/protocol/index.js";
+/** Best-effort private desktop format; not a public Codex RPC or a trusted registration. */
+export declare function discoverProjects(codexHome?: string): ProjectCandidates;

package/dist/project-discovery.js

@@ -0,0 +1,57 @@
+import { closeSync, constants, fstatSync, openSync, readSync, realpathSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+const MAX_BYTES = 2 * 1024 * 1024;
+/** Best-effort private desktop format; not a public Codex RPC or a trusted registration. */
+export function discoverProjects(codexHome = process.env['CODEX_HOME'] || join(homedir(), '.codex')) {
+    const unavailable = (reason) => ({ source: 'codex-desktop-saved-roots', status: 'unavailable', reason, candidates: [] });
+    let fd;
+    let data;
+    try {
+        fd = openSync(join(codexHome, '.codex-global-state.json'), constants.O_RDONLY | constants.O_NONBLOCK | (constants.O_NOFOLLOW ?? 0));
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.size > MAX_BYTES)
+            return unavailable('Codex 桌面目录来源不是常规文件或超过读取上限；请手动输入路径。');
+        const raw = Buffer.alloc(MAX_BYTES + 1);
+        let length = 0;
+        while (length < raw.length) {
+            const bytes = readSync(fd, raw, length, raw.length - length, null);
+            if (!bytes)
+                break;
+            length += bytes;
+        }
+        if (length > MAX_BYTES)
+            return unavailable('Codex 桌面目录来源超过读取上限；请手动输入路径。');
+        data = JSON.parse(raw.subarray(0, length).toString('utf8'));
+    }
+    catch {
+        return unavailable('Codex 桌面已保存目录来源不存在、不可读或格式无效；请手动输入路径。');
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return unavailable('Codex 桌面目录来源格式不受支持；请手动输入路径。');
+    const roots = data['electron-saved-workspace-roots'];
+    if (!Array.isArray(roots) || roots.length > 1000 || roots.some(value => typeof value !== 'string' || !isAbsolute(value) || value.includes('\0') || value.length > 32768))
+        return unavailable('Codex 桌面已保存目录字段缺失或格式不受支持；请手动输入路径。');
+    const seen = new Set();
+    const candidates = [];
+    for (const root of roots) {
+        let path = root;
+        let availability = 'unavailable';
+        try {
+            path = realpathSync.native(root);
+            if (statSync(path).isDirectory())
+                availability = 'available';
+        }
+        catch { /* Keep stale paths visible without inventing availability. */ }
+        if (!seen.has(path)) {
+            seen.add(path);
+            candidates.push({ path, availability });
+        }
+    }
+    return { source: 'codex-desktop-saved-roots', status: 'available', reason: '已读取本机 Codex 桌面私有格式的已保存目录；候选仅供选择，注册时仍须验证。', candidates };
+}
+//# sourceMappingURL=project-discovery.js.map

package/dist/project-files-api.d.ts

@@ -0,0 +1,16 @@
+import type { IncomingMessage } from 'node:http';
+import type { DatabaseSync } from 'node:sqlite';
+import { Auth } from './auth.js';
+import type { ApiResult } from './api.js';
+import { Graphs } from './graphs.js';
+import type { Resources } from './resources.js';
+export declare class ProjectFilesApi {
+    private readonly db;
+    private readonly auth;
+    private readonly graphs;
+    private readonly resources;
+    private readonly runsDirectory;
+    private readonly files;
+    constructor(db: DatabaseSync, auth: Auth, graphs: Graphs, resources: Resources, runsDirectory: string);
+    handle(request: IncomingMessage, rawPath: string, token: string, origin: string): Promise<ApiResult>;
+}

package/dist/project-files-api.js

@@ -0,0 +1,243 @@
+import { Auth } from './auth.js';
+import { readJson } from './http.js';
+import { ServiceError } from './errors.js';
+import { ProjectFiles, classifyProjectFile, normalizeProjectPath, PROJECT_IMAGE_THUMBNAIL_LEVELS } from './project-files.js';
+import { Graphs } from './graphs.js';
+import { randomUUID } from 'node:crypto';
+import { Repositories } from './persistence/repositories.js';
+import { atomic } from './persistence/database.js';
+export class ProjectFilesApi {
+    db;
+    auth;
+    graphs;
+    resources;
+    runsDirectory;
+    files;
+    constructor(db, auth, graphs, resources, runsDirectory) {
+        this.db = db;
+        this.auth = auth;
+        this.graphs = graphs;
+        this.resources = resources;
+        this.runsDirectory = runsDirectory;
+        this.files = new ProjectFiles(db);
+    }
+    async handle(request, rawPath, token, origin) {
+        const url = new URL(rawPath, 'http://localhost');
+        const detach = /^[/]v1[/]projects[/]([a-zA-Z0-9_-]+)[/]graphs[/]([a-zA-Z0-9_-]+)[/]nodes[/]([a-zA-Z0-9_-]+)[/]detach$/.exec(url.pathname);
+        if (detach && request.method === 'POST') {
+            const body = await readJson(request, 2 * 1024 * 1024);
+            if (Object.keys(body).some(key => !['expectedContentVersion', 'expectedExecutionRevision', 'expectedLayoutRevision', 'expectedObservationToken', 'content', 'idempotencyKey'].includes(key))
+                || !Number.isSafeInteger(body['expectedContentVersion']) || !Number.isSafeInteger(body['expectedExecutionRevision']) || !Number.isSafeInteger(body['expectedLayoutRevision'])
+                || typeof body['expectedObservationToken'] !== 'string' || typeof body['idempotencyKey'] !== 'string' || !body['content'] || typeof body['content'] !== 'object' || Array.isArray(body['content']))
+                throw new ServiceError('INVALID_REQUEST', '解除引用需要正文、节点版本、观察标记和幂等键。');
+            const content = body['content'];
+            if (typeof content.text !== 'string')
+                throw new ServiceError('INVALID_REQUEST', '首版仅支持文本引用在编辑时解除引用。');
+            const principal = this.auth.withSession(token, origin, current => current.id);
+            const scope = { serviceId: this.graphs.serviceId, projectId: detach[1], graphId: detach[2] };
+            const replayScope = principal + ':project-file.detach:' + scope.graphId;
+            const replay = new Repositories(this.db).replay(replayScope, body['idempotencyKey'], body);
+            if (replay !== undefined)
+                return { handled: true, body: replay };
+            const snapshot = this.graphs.snapshot(scope);
+            const node = snapshot.nodes.find(item => item.id === detach[3]);
+            if (!node || node.type !== 'text' || node.contentVersion !== body['expectedContentVersion'] || !node.content || typeof node.content !== 'object' || Array.isArray(node.content))
+                throw new ServiceError('REVISION_CONFLICT', '引用文本节点已变化。');
+            const old = node.content, source = old.source;
+            if (!source || typeof source !== 'object' || Array.isArray(source) || source.kind !== 'project-file' || source.projectId !== scope.projectId || typeof source.relativePath !== 'string')
+                throw new ServiceError('INVALID_REQUEST', '目标节点不是当前项目的文本引用。');
+            const observation = (await this.files.stat(scope.projectId, [source.relativePath]))[0];
+            if (observation.state !== 'available')
+                throw new ServiceError(observation.state === 'missing' ? 'NOT_FOUND' : 'PROJECT_UNAVAILABLE', observation.state === 'missing' ? '项目文件已不存在，不能基于旧内容解除引用。' : '项目文件当前不可用。');
+            if (observation.changeToken !== body['expectedObservationToken'])
+                throw new ServiceError('CONFLICT', '项目文件自预览后已变化，请重新打开后再编辑。');
+            const mime = typeof old.mime === 'string' ? old.mime : observation.mime ?? 'text/plain';
+            const title = typeof content.title === 'string' && content.title.trim() ? content.title : typeof old.title === 'string' ? old.title : observation.name;
+            const prepared = await this.resources.prepareBytes(Buffer.from(content.text, 'utf8'), mime);
+            let consumed = false;
+            try {
+                const result = new Repositories(this.db).idempotent(replayScope, body['idempotencyKey'], body, () => atomic(this.db, () => {
+                    const latest = this.graphs.snapshot(scope).nodes.find(item => item.id === detach[3]);
+                    if (!latest || latest.contentVersion !== body['expectedContentVersion'] || !latest.content || typeof latest.content !== 'object' || Array.isArray(latest.content))
+                        throw new ServiceError('REVISION_CONFLICT', '引用文本节点已变化。');
+                    const latestSource = latest.content.source;
+                    const latestObservation = latest.content.observation;
+                    if (!latestSource || typeof latestSource !== 'object' || Array.isArray(latestSource) || latestSource.kind !== 'project-file' || latestSource.relativePath !== source.relativePath
+                        || !latestObservation || typeof latestObservation !== 'object' || Array.isArray(latestObservation) || latestObservation.changeToken !== body['expectedObservationToken'])
+                        throw new ServiceError('CONFLICT', '引用来源或观察标记已变化。');
+                    const created = this.resources.createCanvasFromPrepared(scope, prepared, title);
+                    consumed = true;
+                    const independent = { ...old, ...content, title, resourceId: created.resource.id, resourceVersion: created.resource.current.version, mime: created.resource.current.mime, bytes: created.resource.current.bytes };
+                    delete independent.source;
+                    delete independent.observation;
+                    return this.graphs.command({ ...scope, idempotencyKey: 'detach-' + body['idempotencyKey'], expectedExecutionRevision: Number(body['expectedExecutionRevision']), expectedLayoutRevision: Number(body['expectedLayoutRevision']), operations: [{ type: 'node.content', nodeId: detach[3], expectedContentVersion: Number(body['expectedContentVersion']), content: independent }] }, principal);
+                }));
+                if (!consumed)
+                    atomic(this.db, () => { this.resources.discardPrepared(prepared); });
+                return { handled: true, body: result };
+            }
+            catch (error) {
+                if (!consumed)
+                    atomic(this.db, () => { this.resources.discardPrepared(prepared); });
+                throw error;
+            }
+        }
+        const associate = /^[/]v1[/]projects[/]([a-zA-Z0-9_-]+)[/]graphs[/]([a-zA-Z0-9_-]+)[/]project-files[/]associate$/.exec(url.pathname);
+        if (associate && request.method === 'POST') {
+            this.auth.withSession(token, origin, () => undefined);
+            const body = await readJson(request, 16 * 1024);
+            if (Object.keys(body).some(key => !['path', 'nodeId', 'expectedContentVersion', 'expectedExecutionRevision', 'expectedLayoutRevision', 'idempotencyKey'].includes(key)) || typeof body['path'] !== 'string' || typeof body['nodeId'] !== 'string' || typeof body['idempotencyKey'] !== 'string' || !Number.isSafeInteger(body['expectedContentVersion']) || !Number.isSafeInteger(body['expectedExecutionRevision']) || !Number.isSafeInteger(body['expectedLayoutRevision']))
+                throw new ServiceError('INVALID_REQUEST', '关联空引用需要路径、节点和版本。');
+            const scope = { serviceId: this.graphs.serviceId, projectId: associate[1], graphId: associate[2] };
+            const snapshot = this.graphs.snapshot(scope);
+            const node = snapshot.nodes.find(item => item.id === body['nodeId']);
+            if (!node || node.contentVersion !== body['expectedContentVersion'] || !node.content || typeof node.content !== 'object' || Array.isArray(node.content))
+                throw new ServiceError('REVISION_CONFLICT', '空引用节点已变化。');
+            const source = node.content.source;
+            if (!source || typeof source !== 'object' || Array.isArray(source) || source.kind !== 'project-file-empty')
+                throw new ServiceError('INVALID_REQUEST', '目标节点不是空引用节点。');
+            const file = await this.files.resolve(associate[1], body['path'], 'file');
+            const observation = (await this.files.stat(associate[1], [file.relativePath]))[0];
+            if (observation.state !== 'available')
+                throw new ServiceError('PROJECT_UNAVAILABLE', '项目文件当前不可读。');
+            const name = file.relativePath.split('/').at(-1);
+            const classified = classifyProjectFile(name);
+            const content = { title: name, text: '', prompt: '', mime: classified.mime, bytes: observation.bytes, source: { kind: 'project-file', serviceId: this.graphs.serviceId, projectId: associate[1], relativePath: file.relativePath }, observation: { state: 'available', name, mime: classified.mime, bytes: observation.bytes, changeToken: observation.changeToken } };
+            const result = this.auth.withSession(token, origin, current => this.graphs.command({ ...scope, idempotencyKey: body['idempotencyKey'], expectedExecutionRevision: Number(body['expectedExecutionRevision']), expectedLayoutRevision: Number(body['expectedLayoutRevision']), operations: [{ type: 'node.project-file.associate', nodeId: node.id, expectedContentVersion: node.contentVersion, nodeType: classified.type, content }] }, current.id));
+            return { handled: true, body: result };
+        }
+        const create = /^[/]v1[/]projects[/]([a-zA-Z0-9_-]+)[/]graphs[/]([a-zA-Z0-9_-]+)[/]project-files$/.exec(url.pathname);
+        if (create && request.method === 'POST') {
+            this.auth.withSession(token, origin, () => undefined);
+            const body = await readJson(request, 16 * 1024);
+            if (Object.keys(body).some(key => !['path', 'x', 'y', 'expectedExecutionRevision', 'expectedLayoutRevision', 'idempotencyKey'].includes(key)) || typeof body['path'] !== 'string' || typeof body['x'] !== 'number' || typeof body['y'] !== 'number' || typeof body['idempotencyKey'] !== 'string' || !Number.isSafeInteger(body['expectedExecutionRevision']) || !Number.isSafeInteger(body['expectedLayoutRevision']))
+                throw new ServiceError('INVALID_REQUEST', '创建项目文件引用需要路径、落点、版本和幂等键。');
+            const file = await this.files.resolve(create[1], body['path'], 'file');
+            const observation = (await this.files.stat(create[1], [file.relativePath]))[0];
+            if (observation.state !== 'available')
+                throw new ServiceError('PROJECT_UNAVAILABLE', '项目文件当前不可读。');
+            const name = file.relativePath.split('/').at(-1);
+            const classified = classifyProjectFile(name);
+            const result = this.auth.withSession(token, origin, current => this.graphs.command({ serviceId: this.graphs.serviceId, projectId: create[1], graphId: create[2], idempotencyKey: body['idempotencyKey'], expectedExecutionRevision: Number(body['expectedExecutionRevision']), expectedLayoutRevision: Number(body['expectedLayoutRevision']), operations: [{ type: 'node.create', node: { id: randomUUID(), type: classified.type, schemaVersion: 1, contentVersion: 1, content: { title: name, text: '', prompt: '', mime: classified.mime, bytes: observation.bytes, source: { kind: 'project-file', serviceId: this.graphs.serviceId, projectId: create[1], relativePath: file.relativePath }, observation: { state: 'available', name, mime: classified.mime, bytes: observation.bytes, changeToken: observation.changeToken } }, x: Number(body['x']), y: Number(body['y']), width: 300, height: 220, readOnly: false } }] }, current.id));
+            return { handled: true, body: result };
+        }
+        const match = /^[/]v1[/]projects[/]([a-zA-Z0-9_-]+)[/]files(?:[/](search|stat|content|media|thumbnail|link-preview|link-content))?$/.exec(url.pathname);
+        if (!match)
+            return { handled: false };
+        this.auth.withSession(token, origin, () => undefined);
+        const projectId = match[1], action = match[2] ?? 'list';
+        if (action === 'link-preview' && request.method === 'POST') {
+            const body = await readJson(request, 16 * 1024);
+            if (typeof body['path'] !== 'string' || (body['streamVideo'] !== undefined && typeof body['streamVideo'] !== 'boolean') || Object.keys(body).some(key => !['path', 'thumbnailSize', 'streamVideo'].includes(key)) || (body['thumbnailSize'] !== undefined && ![640, 1280].includes(body['thumbnailSize'])))
+                throw new ServiceError('INVALID_REQUEST', '需要有效的文件路径和缩略图尺寸。');
+            if (body['streamVideo'] === true && body['thumbnailSize'] === undefined) {
+                const metadata = await this.files.readLinkedFile(projectId, body['path'], this.runsDirectory, { metadataOnly: true });
+                this.auth.withSession(token, origin, () => undefined);
+                if (metadata.mime.startsWith('video/'))
+                    return { handled: true, body: { name: metadata.name, mime: metadata.mime, bytes: metadata.total, scope: metadata.scope, contentPath: '/v1/projects/' + projectId + '/files/link-content?' + new URLSearchParams({ path: body['path'] }).toString() } };
+            }
+            const result = body['thumbnailSize'] === undefined
+                ? await this.files.readLinkedFile(projectId, body['path'], this.runsDirectory)
+                : await this.files.readLinkedImageThumbnail(projectId, body['path'], this.runsDirectory, body['thumbnailSize']);
+            this.auth.withSession(token, origin, () => undefined);
+            return { handled: true, body: { name: result.name, mime: result.mime, bytes: result.bytes.length, base64: result.bytes.toString('base64'), scope: result.scope, ...(result.relativePath ? { relativePath: result.relativePath } : {}) } };
+        }
+        if (action === 'link-content' && request.method === 'GET') {
+            if ([...url.searchParams.keys()].some(key => key !== 'path') || url.searchParams.getAll('path').length !== 1)
+                throw new ServiceError('INVALID_REQUEST', '需要有效的文件路径。');
+            const range = /^bytes=([0-9]+)-([0-9]+)$/.exec(request.headers.range ?? '');
+            if (!range)
+                throw new ServiceError('INVALID_REQUEST', '链接文件须使用明确的字节范围。');
+            const result = await this.files.readLinkedFile(projectId, url.searchParams.get('path'), this.runsDirectory, { range: { start: Number(range[1]), end: Number(range[2]) } });
+            this.auth.withSession(token, origin, () => undefined);
+            return { handled: true, binary: result.bytes, status: 206, headers: { 'Content-Type': result.mime, 'Content-Length': String(result.bytes.length), 'Accept-Ranges': 'bytes', 'Content-Range': 'bytes ' + result.start + '-' + result.end + '/' + result.total, 'X-Content-Type-Options': 'nosniff' } };
+        }
+        if (action === 'stat' && request.method === 'POST') {
+            const body = await readJson(request, 16 * 1024);
+            if (Object.keys(body).length !== 1 || !Array.isArray(body['paths']))
+                throw new ServiceError('INVALID_REQUEST', '需要 paths 数组。');
+            const result = await this.files.stat(projectId, body['paths']);
+            this.auth.withSession(token, origin, () => undefined);
+            return { handled: true, body: result };
+        }
+        if (request.method !== 'GET')
+            throw new ServiceError('NOT_FOUND', '项目文件接口不存在。');
+        const allowed = action === 'search' ? ['query', 'showHidden', 'cursor', 'limit'] : ['content', 'media', 'thumbnail'].includes(action) ? ['path', 'cacheKey', ...(action === 'thumbnail' ? ['size'] : [])] : ['path', 'showHidden', 'cursor', 'limit'];
+        if ([...url.searchParams.keys()].some(key => !allowed.includes(key)) || allowed.some(key => url.searchParams.getAll(key).length > 1))
+            throw new ServiceError('INVALID_REQUEST', '项目文件查询参数无效。');
+        const showHidden = url.searchParams.get('showHidden') === 'true';
+        if (url.searchParams.has('showHidden') && !['true', 'false'].includes(url.searchParams.get('showHidden')))
+            throw new ServiceError('INVALID_REQUEST', 'showHidden 必须是布尔值。');
+        const limit = url.searchParams.has('limit') ? Number(url.searchParams.get('limit')) : action === 'search' ? 50 : 200;
+        const cursor = url.searchParams.get('cursor');
+        if (action === 'list') {
+            const result = await this.files.list(projectId, url.searchParams.get('path') ?? '', showHidden, limit, cursor);
+            this.auth.withSession(token, origin, () => undefined);
+            return { handled: true, body: result };
+        }
+        if (action === 'content') {
+            const path = normalizeProjectPath(url.searchParams.get('path'));
+            if (!path)
+                throw new ServiceError('INVALID_REQUEST', '需要文件路径。');
+            const header = request.headers.range;
+            let range;
+            if (header) {
+                const match = /^bytes=([0-9]+)-([0-9]*)$/.exec(header);
+                if (!match)
+                    throw new ServiceError('INVALID_REQUEST', '仅支持单个明确起点的字节范围。');
+                range = { start: Number(match[1]), ...(match[2] ? { end: Number(match[2]) } : {}) };
+            }
+            const content = await this.files.readRange(projectId, path, range);
+            this.auth.withSession(token, origin, () => undefined);
+            if (range)
+                return { handled: true, binary: content.bytes, status: 206, headers: { 'Content-Type': classifyProjectFile(path).mime, 'Content-Length': String(content.bytes.length), 'Accept-Ranges': 'bytes', 'Content-Range': 'bytes ' + content.start + '-' + content.end + '/' + content.total, 'X-Content-Type-Options': 'nosniff' } };
+            return { handled: true, body: { path, bytes: content.bytes.length, base64: content.bytes.toString('base64') } };
+        }
+        if (action === 'media') {
+            if (request.headers.range)
+                throw new ServiceError('INVALID_REQUEST', '图片原图不接受 Range。');
+            const path = normalizeProjectPath(url.searchParams.get('path'));
+            if (!path)
+                throw new ServiceError('INVALID_REQUEST', '需要文件路径。');
+            const classified = classifyProjectFile(path);
+            if (!classified.mime.startsWith('image/'))
+                throw new ServiceError('INVALID_REQUEST', '仅支持图片项目文件原图。');
+            const content = await this.files.readRange(projectId, path);
+            this.auth.withSession(token, origin, () => undefined);
+            return { handled: true, binary: content.bytes, status: 200, headers: { 'Content-Type': classified.mime, 'Content-Length': String(content.bytes.length), 'Cache-Control': 'private, max-age=31536000, immutable', 'Content-Disposition': 'inline', 'X-Content-Type-Options': 'nosniff' } };
+        }
+        if (action === 'thumbnail') {
+            if (request.headers.range)
+                throw new ServiceError('INVALID_REQUEST', '缩略图不接受 Range。');
+            const path = normalizeProjectPath(url.searchParams.get('path'));
+            if (!path)
+                throw new ServiceError('INVALID_REQUEST', '需要文件路径。');
+            const requestedSize = url.searchParams.get('size');
+            const size = requestedSize === null ? 320 : Number(requestedSize);
+            if (!PROJECT_IMAGE_THUMBNAIL_LEVELS.includes(size))
+                throw new ServiceError('INVALID_REQUEST', '无效的缩略图尺寸。');
+            const thumbnail = await this.files.thumbnail(projectId, path, size);
+            this.auth.withSession(token, origin, () => undefined);
+            // Video covers may be replaced independently of the video's change token.
+            const video = /[.](mp4|m4v|mov|webm|mkv|avi|mpg|mpeg|ogv)$/i.test(path);
+            return { handled: true, binary: thumbnail.bytes, status: 200, headers: { 'Content-Type': thumbnail.mime, 'Content-Length': String(thumbnail.bytes.length), 'Cache-Control': video ? 'private, no-cache' : 'private, max-age=31536000, immutable', 'X-Content-Type-Options': 'nosniff' } };
+        }
+        if (action === 'search') {
+            const query = url.searchParams.get('query')?.trim() ?? '';
+            const controller = new AbortController();
+            const cancel = () => controller.abort();
+            request.once('aborted', cancel);
+            let result;
+            try {
+                result = await this.files.search(projectId, query, showHidden, limit, cursor, controller.signal);
+            }
+            finally {
+                request.off('aborted', cancel);
+            }
+            this.auth.withSession(token, origin, () => undefined);
+            return { handled: true, body: result };
+        }
+        return { handled: false };
+    }
+}
+//# sourceMappingURL=project-files-api.js.map