openworkgraph 0.2.12

package/dist/history.d.ts

@@ -0,0 +1,20 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { HistoryCleanupPreview, Json } from "./vendor/protocol/index.js";
+import { Repositories } from './persistence/repositories.js';
+export declare class History {
+    readonly db: DatabaseSync;
+    readonly now: () => number;
+    readonly repo: Repositories;
+    constructor(db: DatabaseSync, now?: () => number);
+    preview(runIds: string[]): HistoryCleanupPreview;
+    clear(runIds: string[], idempotencyKey: string): HistoryCleanupPreview;
+    records(id: string): {
+        historyState: 'retained' | 'cleared';
+        records: {
+            id: number;
+            occurredAt: string;
+            kind: string;
+            payload: Json;
+        }[];
+    };
+}

package/dist/history.js

@@ -0,0 +1,61 @@
+import { isTerminalRunStatus } from "./vendor/protocol/index.js";
+import { randomUUID } from 'node:crypto';
+import { ServiceError } from './errors.js';
+import { atomic } from './persistence/database.js';
+import { Repositories } from './persistence/repositories.js';
+export class History {
+    db;
+    now;
+    repo;
+    constructor(db, now = Date.now) {
+        this.db = db;
+        this.now = now;
+        this.repo = new Repositories(db);
+    }
+    preview(runIds) {
+        return atomic(this.db, () => {
+            if (!Array.isArray(runIds) || !runIds.length || runIds.length > 1000 || runIds.some(id => typeof id !== 'string' || !id))
+                throw new ServiceError('INVALID_REQUEST', 'Select 1..1000 run IDs');
+            const unique = [...new Set(runIds)];
+            let count = 0;
+            for (const id of unique) {
+                const run = this.db.prepare('SELECT status FROM runs WHERE id=?').get(id);
+                if (!run)
+                    throw new ServiceError('NOT_FOUND', 'Run not found');
+                if (!isTerminalRunStatus(String(run.status)))
+                    throw new ServiceError('ACTIVE_RUN', 'Cannot clear unfinished run history');
+                count += Number(this.db.prepare('SELECT COUNT(*) AS n FROM run_process_records WHERE run_id=?').get(id).n);
+            }
+            return { runIds: unique, processRecordCount: count, preserves: ['runs', 'deliveries', 'assets', 'graphLinks'] };
+        });
+    }
+    clear(runIds, idempotencyKey) {
+        return this.repo.idempotent('history.clear', idempotencyKey, { runIds }, () => {
+            const preview = this.preview(runIds);
+            for (const id of preview.runIds) {
+                const run = this.db.prepare('SELECT * FROM runs WHERE id=?').get(id);
+                const graph = this.db.prepare('SELECT g.archived,g.trashed,p.state FROM graphs g JOIN projects p ON p.id=g.project_id WHERE g.id=?').get(String(run.graph_id));
+                if (graph.state !== 'active')
+                    throw new ServiceError('PROJECT_INACTIVE', 'Inactive project history is read-only');
+                if (graph.archived || graph.trashed)
+                    throw new ServiceError('CONFLICT', 'Archived or trashed graph history is read-only');
+                if (run.history_state === 'cleared')
+                    continue;
+                this.db.prepare('DELETE FROM run_process_records WHERE run_id=?').run(id);
+                this.db.prepare("UPDATE interactions SET payload='null',answer=NULL WHERE run_id=?").run(id);
+                this.db.prepare("UPDATE runs SET history_state='cleared' WHERE id=?").run(id);
+                this.db.prepare('UPDATE run_runtime SET revision=revision+1 WHERE run_id=?').run(id);
+                const runtime = this.db.prepare('SELECT revision FROM run_runtime WHERE run_id=?').get(id);
+                this.repo.appendEvent({ eventId: randomUUID(), type: 'run.changed', projectId: String(run.project_id), graphId: String(run.graph_id), entityId: id, revision: Number(runtime?.revision ?? 0), occurredAt: new Date(this.now()).toISOString(), payload: { id, historyState: 'cleared' } });
+            }
+            return preview;
+        });
+    }
+    records(id) {
+        const run = this.db.prepare('SELECT history_state FROM runs WHERE id=?').get(id);
+        if (!run)
+            throw new ServiceError('NOT_FOUND', 'Run not found');
+        return { historyState: run.history_state, records: this.db.prepare('SELECT * FROM run_process_records WHERE run_id=? ORDER BY id').all(id).map(row => ({ id: Number(row.id), occurredAt: String(row.occurred_at), kind: String(row.kind), payload: JSON.parse(String(row.payload)) })) };
+    }
+}
+//# sourceMappingURL=history.js.map

package/dist/http.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingMessage } from 'node:http';
+export declare function readJson(request: IncomingMessage, limit?: number): Promise<Record<string, unknown>>;

package/dist/http.js

@@ -0,0 +1,42 @@
+import { ServiceError } from './errors.js';
+export function readJson(request, limit = 16 * 1024) {
+    if (!/^application[/]json(?:\s*;\s*charset=utf-8)?$/i.test(request.headers['content-type'] ?? ''))
+        throw new ServiceError('UNSUPPORTED_MEDIA_TYPE', '请求须使用 application/json。');
+    if (request.headers['content-encoding'])
+        throw new ServiceError('UNSUPPORTED_MEDIA_TYPE', '暂不接受压缩的 JSON 请求。');
+    if (Number(request.headers['content-length'] ?? 0) > limit)
+        throw new ServiceError('PAYLOAD_TOO_LARGE', `请求不能超过 ${limit} 字节。`);
+    return new Promise((resolve, reject) => {
+        let bytes = 0;
+        let exceeded = false;
+        const chunks = [];
+        request.on('data', (chunk) => {
+            bytes += chunk.length;
+            if (bytes > limit) {
+                if (!exceeded) {
+                    exceeded = true;
+                    chunks.length = 0;
+                    reject(new ServiceError('PAYLOAD_TOO_LARGE', `请求不能超过 ${limit} 字节。`));
+                }
+                return;
+            }
+            chunks.push(chunk);
+        });
+        request.once('end', () => {
+            if (exceeded)
+                return;
+            try {
+                const value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
+                if (!value || typeof value !== 'object' || Array.isArray(value))
+                    throw new Error();
+                resolve(value);
+            }
+            catch {
+                reject(new ServiceError('INVALID_REQUEST', '请求正文必须是有效的 JSON 对象。'));
+            }
+        });
+        request.once('error', reject);
+        request.once('aborted', () => reject(new ServiceError('INVALID_REQUEST', '请求已中断。')));
+    });
+}
+//# sourceMappingURL=http.js.map

package/dist/image-credentials.d.ts

@@ -0,0 +1,11 @@
+import type { DataDirectories } from './directories.js';
+export declare class ImageCredentials {
+    private readonly dirs;
+    private readonly serviceId;
+    private readonly credentialDir;
+    constructor(dirs: DataDirectories, serviceId: string);
+    private file;
+    store(id: string, revision: number, value: string): Promise<void>;
+    read(id: string, revision: number): Promise<string | null>;
+    revoke(id: string, revision: number): Promise<void>;
+}

package/dist/image-credentials.js

@@ -0,0 +1,130 @@
+import { spawn } from 'node:child_process';
+import { chmodSync, closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ServiceError } from './errors.js';
+const identifier = (value) => {
+    if (!/^[a-zA-Z0-9_-]{1,100}$/.test(value))
+        throw new ServiceError('INVALID_REQUEST', '凭据标识无效。');
+    return value;
+};
+const scope = (serviceId, providerId, revision) => [identifier(serviceId), identifier(providerId), revision].join(':');
+/** Fixed commands only. Secret input travels on stdin; platform diagnostics stay private. */
+function invoke(command, args, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+        const timer = setTimeout(() => child.kill(), 30000);
+        timer.unref();
+        const output = [];
+        let length = 0;
+        child.stdout.on('data', (chunk) => {
+            length += chunk.length;
+            if (length > 64 * 1024)
+                child.kill();
+            else
+                output.push(chunk);
+        });
+        child.stderr.resume();
+        child.stdin.on('error', () => { });
+        child.on('error', () => { clearTimeout(timer); reject(new ServiceError('MODEL_UNAVAILABLE', '本机凭据存储不可用。')); });
+        child.on('close', code => { clearTimeout(timer); code === 0 && length <= 64 * 1024 ? resolve(Buffer.concat(output).toString('utf8').trimEnd()) : reject(new ServiceError('MODEL_UNAVAILABLE', '本机凭据存储操作失败。')); });
+        child.stdin.end(input === undefined ? '' : input + String.fromCharCode(10));
+    });
+}
+const encrypt = '$v=[Console]::In.ReadToEnd().TrimEnd([char]10,[char]13); ConvertFrom-SecureString (ConvertTo-SecureString -String $v -AsPlainText -Force)';
+const decrypt = '$v=[Console]::In.ReadToEnd().TrimEnd([char]10,[char]13); $s=ConvertTo-SecureString $v; $p=[Runtime.InteropServices.Marshal]::SecureStringToBSTR($s); try {[Runtime.InteropServices.Marshal]::PtrToStringBSTR($p)} finally {[Runtime.InteropServices.Marshal]::ZeroFreeBSTR($p)}';
+export class ImageCredentials {
+    dirs;
+    serviceId;
+    credentialDir;
+    constructor(dirs, serviceId) {
+        this.dirs = dirs;
+        this.serviceId = serviceId;
+        this.credentialDir = join(dirs.config, 'image-credentials');
+        if (process.platform === 'win32' || process.platform === 'darwin') {
+            mkdirSync(this.credentialDir, { recursive: true, mode: 0o700 });
+            const stat = lstatSync(this.credentialDir);
+            if (!stat.isDirectory() || stat.isSymbolicLink())
+                throw new ServiceError('INVALID_REQUEST', '凭据目录不能是符号链接。');
+            if (process.platform === 'darwin')
+                chmodSync(this.credentialDir, 0o700);
+        }
+    }
+    file(id, revision) { return join(this.credentialDir, identifier(this.serviceId) + '.' + Buffer.from(identifier(id)).toString('hex') + '.' + revision + (process.platform === 'darwin' ? '.key' : '.dpapi')); }
+    async store(id, revision, value) {
+        const key = scope(this.serviceId, id, revision);
+        if (typeof value !== 'string' || !value.trim() || value.length > 16 * 1024 || value.includes(String.fromCharCode(10)) || value.includes(String.fromCharCode(13)))
+            throw new ServiceError('INVALID_REQUEST', '凭据格式无效。');
+        if (process.platform === 'darwin') {
+            const path = this.file(id, revision);
+            const fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+            try {
+                writeFileSync(fd, value, 'utf8');
+            }
+            catch (error) {
+                closeSync(fd);
+                unlinkSync(path);
+                throw error;
+            }
+            closeSync(fd);
+        }
+        else if (process.platform === 'linux') {
+            await invoke('secret-tool', ['store', '--label=OpenWorkgraph image provider', 'service', 'OpenWorkgraph-image-provider', 'account', key], value);
+        }
+        else if (process.platform === 'win32') {
+            const ciphertext = await invoke('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', encrypt], value);
+            if (!ciphertext)
+                throw new ServiceError('MODEL_UNAVAILABLE', '本机凭据保护失败。');
+            writeFileSync(this.file(id, revision), ciphertext, { flag: 'wx', mode: 0o600 });
+        }
+        else
+            throw new ServiceError('MODEL_UNAVAILABLE', '此平台没有受保护的凭据存储。');
+        if (await this.read(id, revision) !== value) {
+            await this.revoke(id, revision).catch(() => { });
+            throw new ServiceError('MODEL_UNAVAILABLE', 'API Key 写入后无法从本机凭据存储读取。');
+        }
+    }
+    async read(id, revision) {
+        const key = scope(this.serviceId, id, revision);
+        try {
+            let value;
+            if (process.platform === 'darwin') {
+                const fd = openSync(this.file(id, revision), constants.O_RDONLY | constants.O_NOFOLLOW);
+                try {
+                    const stat = fstatSync(fd);
+                    if (!stat.isFile() || stat.mode & 0o077 || stat.size > 16 * 1024)
+                        return null;
+                    value = readFileSync(fd, 'utf8');
+                }
+                finally {
+                    closeSync(fd);
+                }
+            }
+            else if (process.platform === 'linux')
+                value = await invoke('secret-tool', ['lookup', 'service', 'OpenWorkgraph-image-provider', 'account', key]);
+            else if (process.platform === 'win32') {
+                const path = this.file(id, revision), stat = lstatSync(path);
+                if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 64 * 1024)
+                    throw Error('Invalid credential file');
+                value = await invoke('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', decrypt], readFileSync(path, 'utf8'));
+            }
+            else
+                return null;
+            return value || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async revoke(id, revision) {
+        const key = scope(this.serviceId, id, revision);
+        if (process.platform === 'darwin')
+            unlinkSync(this.file(id, revision));
+        else if (process.platform === 'linux')
+            await invoke('secret-tool', ['clear', 'service', 'OpenWorkgraph-image-provider', 'account', key]);
+        else if (process.platform === 'win32')
+            unlinkSync(this.file(id, revision));
+        else
+            throw new ServiceError('MODEL_UNAVAILABLE', '本机凭据存储不可用。');
+    }
+}
+//# sourceMappingURL=image-credentials.js.map

package/dist/image-providers.d.ts

@@ -0,0 +1,51 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { ImageProvider, ImageProviderModel } from "./vendor/protocol/index.js";
+import { ImageCredentials } from './image-credentials.js';
+export interface ProviderConfig {
+    id: string;
+    name: string;
+    driver: 'openai';
+    endpoint: string;
+    enabled: boolean;
+}
+export interface ModelConfig {
+    id: string;
+    name: string;
+    modes: ImageProviderModel['modes'];
+    formats: ImageProviderModel['formats'];
+    sizes: string[];
+    qualities: string[];
+    isDefault: boolean;
+}
+export interface DiscoveredModel {
+    id: string;
+    name: string;
+}
+export interface FrozenProviderConfig {
+    endpoint: string;
+    driver: 'openai';
+    model: ImageProviderModel;
+}
+/** Public directory only: no credential value and no inferred model availability. */
+export declare class ImageProviders {
+    private readonly db;
+    readonly credentials?: ImageCredentials | undefined;
+    private readonly configured;
+    private readonly writes;
+    constructor(db: DatabaseSync, credentials?: ImageCredentials | undefined);
+    refreshCredentials(): Promise<void>;
+    credentialAvailable(providerId: string, revision: number): boolean;
+    private serialize;
+    setCredential(providerId: string, value: string, expected: unknown): Promise<ImageProvider>;
+    revokeCredential(providerId: string, expected: unknown): Promise<ImageProvider>;
+    /** Public config only. Previous accepted Runs can resolve this even after an edit or disable. */
+    frozen(providerId: string, configRevision: number, modelId: string): FrozenProviderConfig;
+    private saveVersion;
+    list(): ImageProvider[];
+    private get;
+    setProvider(raw: ProviderConfig, expected: unknown): ImageProvider;
+    deleteProvider(providerId: string, expected: unknown): void;
+    setModel(providerId: string, raw: ModelConfig, expected: unknown): ImageProvider;
+    syncDiscoveredModels(providerId: string, discovered: DiscoveredModel[], expected: unknown): ImageProvider;
+    deleteModel(providerId: string, modelId: string, expected: unknown): ImageProvider;
+}

package/dist/image-providers.js

@@ -0,0 +1,271 @@
+import { atomic } from './persistence/database.js';
+import { ServiceError } from './errors.js';
+import { ImageCredentials } from './image-credentials.js';
+import { isPrivateNetworkHost } from './network.js';
+const identity = (value) => {
+    if (typeof value !== 'string' || !/^[a-zA-Z0-9_-]{1,100}$/.test(value))
+        throw new ServiceError('INVALID_REQUEST', '服务商或模型 ID 无效。');
+    return value;
+};
+const modelIdentity = (value) => {
+    if (typeof value !== 'string' || !/^[a-zA-Z0-9_.:/-]{1,100}$/.test(value) || value === '.' || value === '..' || value.startsWith('/') || value.endsWith('/') || value.includes('//'))
+        throw new ServiceError('INVALID_REQUEST', '图片模型 ID 无效。');
+    return value;
+};
+const label = (value) => {
+    if (typeof value !== 'string' || !value.trim() || value.length > 150)
+        throw new ServiceError('INVALID_REQUEST', '显示名称无效。');
+    return value.trim();
+};
+const revision = (value) => {
+    if (!Number.isSafeInteger(value) || value < 0 || value >= Number.MAX_SAFE_INTEGER)
+        throw new ServiceError('INVALID_REQUEST', '配置修订号无效。');
+    return value;
+};
+function endpoint(value) {
+    if (typeof value !== 'string')
+        throw new ServiceError('INVALID_REQUEST', '服务商地址无效。');
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new ServiceError('INVALID_REQUEST', '服务商地址无效。');
+    }
+    if (!(url.protocol === 'https:' || (url.protocol === 'http:' && isPrivateNetworkHost(url.hostname))) || url.username || url.password || url.search || url.hash || url.port === '0')
+        throw new ServiceError('INVALID_REQUEST', '服务商地址必须是 HTTPS；局域网或回环 IP 地址可使用 HTTP，且不得含凭据、查询或片段。');
+    const path = url.pathname.replace(/\/+$/, '');
+    return url.origin + (path && path !== '/' ? path : '');
+}
+function choices(value, allowed, field) {
+    if (!Array.isArray(value) || !value.length || value.length > 30 || value.some(item => typeof item !== 'string' || !allowed.includes(item)) || new Set(value).size !== value.length)
+        throw new ServiceError('INVALID_REQUEST', field + ' 能力列表无效。');
+    return value;
+}
+function inferredModel(model, isDefault) {
+    const id = modelIdentity(model.id), name = label(model.name);
+    if (id === 'dall-e-2')
+        return { id, name, modes: ['text', 'image'], formats: ['png'], sizes: ['256x256', '512x512', '1024x1024'], qualities: ['auto'], isDefault };
+    if (id === 'dall-e-3')
+        return { id, name, modes: ['text'], formats: ['png'], sizes: ['1024x1024', '1792x1024', '1024x1792'], qualities: ['auto', 'high'], isDefault };
+    return { id, name, modes: ['text', 'text_image'], formats: ['png', 'jpeg', 'webp'], sizes: ['auto', '1024x1024', '1536x1024', '1024x1536'], qualities: ['auto', 'high', 'medium', 'low'], isDefault };
+}
+/** Public directory only: no credential value and no inferred model availability. */
+export class ImageProviders {
+    db;
+    credentials;
+    configured = new Set();
+    writes = new Map();
+    constructor(db, credentials) {
+        this.db = db;
+        this.credentials = credentials;
+    }
+    async refreshCredentials() {
+        this.configured.clear();
+        for (const row of this.db.prepare('SELECT id,credential_revision FROM image_providers WHERE deleted=0 AND credential_revision IS NOT NULL').all()) {
+            if (await this.credentials?.read(String(row.id), Number(row.credential_revision)))
+                this.configured.add(String(row.id));
+        }
+    }
+    credentialAvailable(providerId, revision) {
+        const row = this.db.prepare('SELECT 1 FROM image_provider_revoked_credentials WHERE provider_id=? AND revision=?').get(identity(providerId), revision);
+        return !row && this.configured.has(providerId);
+    }
+    serialize(id, work) {
+        const previous = this.writes.get(id) ?? Promise.resolve();
+        const next = previous.catch(() => { }).then(work);
+        this.writes.set(id, next);
+        void next.finally(() => { if (this.writes.get(id) === next)
+            this.writes.delete(id); }).catch(() => { });
+        return next;
+    }
+    async setCredential(providerId, value, expected) {
+        const id = identity(providerId), prev = revision(expected);
+        if (typeof value !== 'string' || !value.trim() || value.length > 16 * 1024 || value.includes(String.fromCharCode(10)) || value.includes(String.fromCharCode(13)))
+            throw new ServiceError('INVALID_REQUEST', '凭据格式无效。');
+        if (!this.credentials)
+            throw new ServiceError('MODEL_UNAVAILABLE', '本机凭据存储不可用。');
+        return this.serialize(id, async () => {
+            const before = this.db.prepare('SELECT revision,credential_counter,deleted FROM image_providers WHERE id=?').get(id);
+            if (!before || before.deleted)
+                throw new ServiceError('NOT_FOUND', '服务商不存在。');
+            if (Number(before.revision) !== prev)
+                throw new ServiceError('REVISION_CONFLICT', '服务商配置已变化，请刷新后重试。');
+            const next = Number(before.credential_counter) + 1;
+            await this.credentials.store(id, next, value);
+            try {
+                const provider = atomic(this.db, () => {
+                    const changed = this.db.prepare('UPDATE image_providers SET credential_revision=?,credential_counter=?,revision=revision+1 WHERE id=? AND revision=? AND deleted=0').run(next, next, id, prev);
+                    if (!changed.changes)
+                        throw new ServiceError('REVISION_CONFLICT', '服务商配置已变化，请刷新后重试。');
+                    this.db.prepare('UPDATE image_provider_models SET verified_at=NULL WHERE provider_id=?').run(id);
+                    this.saveVersion(id);
+                    return this.get(id);
+                });
+                this.configured.add(id);
+                return { ...provider, credentialConfigured: true };
+            }
+            catch (error) {
+                await this.credentials.revoke(id, next).catch(() => { });
+                throw error;
+            }
+        });
+    }
+    async revokeCredential(providerId, expected) {
+        const id = identity(providerId), prev = revision(expected);
+        return this.serialize(id, async () => {
+            const before = this.db.prepare('SELECT revision,credential_counter,deleted FROM image_providers WHERE id=?').get(id);
+            if (!before || before.deleted)
+                throw new ServiceError('NOT_FOUND', '服务商不存在。');
+            if (Number(before.revision) !== prev)
+                throw new ServiceError('REVISION_CONFLICT', '服务商配置已变化，请刷新后重试。');
+            const count = Number(before.credential_counter);
+            const provider = atomic(this.db, () => {
+                for (let rev = 1; rev <= count; rev++)
+                    this.db.prepare('INSERT OR IGNORE INTO image_provider_revoked_credentials(provider_id,revision) VALUES(?,?)').run(id, rev);
+                this.db.prepare('UPDATE image_providers SET credential_revision=NULL,revision=revision+1 WHERE id=? AND revision=?').run(id, prev);
+                this.db.prepare('UPDATE image_provider_models SET verified_at=NULL WHERE provider_id=?').run(id);
+                this.saveVersion(id);
+                return this.get(id);
+            });
+            this.configured.delete(id);
+            for (let rev = 1; rev <= count; rev++)
+                await this.credentials?.revoke(id, rev).catch(() => { });
+            return { ...provider, credentialConfigured: false };
+        });
+    }
+    /** Public config only. Previous accepted Runs can resolve this even after an edit or disable. */
+    frozen(providerId, configRevision, modelId) {
+        const row = this.db.prepare('SELECT payload FROM image_provider_config_versions WHERE provider_id=? AND revision=?').get(identity(providerId), configRevision);
+        if (!row)
+            throw new ServiceError('MODEL_UNAVAILABLE', '冻结服务商配置版本不存在。');
+        const payload = JSON.parse(String(row.payload));
+        const model = payload.models.find(item => item.id === modelIdentity(modelId));
+        if (!model)
+            throw new ServiceError('MODEL_UNAVAILABLE', '冻结配置中没有所选模型。');
+        return { endpoint: payload.endpoint, driver: payload.driver, model: { ...model, verifiedAt: null } };
+    }
+    saveVersion(id) {
+        const provider = this.get(id);
+        this.db.prepare('INSERT INTO image_provider_config_versions(provider_id,revision,payload) VALUES(?,?,?)').run(id, provider.revision, JSON.stringify({ endpoint: provider.endpoint, driver: provider.driver, models: provider.models.map(({ verifiedAt: _verifiedAt, ...model }) => model) }));
+    }
+    list() {
+        const providers = this.db.prepare('SELECT * FROM image_providers WHERE deleted=0 ORDER BY id').all();
+        return providers.map(row => {
+            const models = this.db.prepare('SELECT * FROM image_provider_models WHERE provider_id=? ORDER BY id').all(String(row.id)).map(model => ({
+                id: String(model.id), name: String(model.name), modes: JSON.parse(String(model.modes)), formats: JSON.parse(String(model.formats)), sizes: JSON.parse(String(model.sizes)), qualities: JSON.parse(String(model.qualities)), isDefault: Boolean(model.is_default), verifiedAt: model.verified_at === null ? null : String(model.verified_at),
+            }));
+            return { id: String(row.id), name: String(row.name), driver: 'openai', endpoint: String(row.endpoint), enabled: Boolean(row.enabled), revision: Number(row.revision), credentialConfigured: this.configured.has(String(row.id)), credentialRevision: row.credential_revision === null ? null : Number(row.credential_revision), models };
+        });
+    }
+    get(id) {
+        const provider = this.list().find(item => item.id === id);
+        if (!provider)
+            throw new ServiceError('NOT_FOUND', '生图服务商不存在。');
+        return provider;
+    }
+    setProvider(raw, expected) {
+        const id = identity(raw?.id), name = label(raw.name), target = endpoint(raw.endpoint), prev = revision(expected);
+        if (raw.driver !== 'openai' || typeof raw.enabled !== 'boolean')
+            throw new ServiceError('INVALID_REQUEST', '服务商配置无效。');
+        return atomic(this.db, () => {
+            const current = this.db.prepare('SELECT revision,deleted,endpoint FROM image_providers WHERE id=?').get(id);
+            if (current?.deleted)
+                throw new ServiceError('CONFLICT', '已删除服务商不能重新使用原 ID。');
+            if (current ? Number(current.revision) !== prev : prev !== 0)
+                throw new ServiceError('REVISION_CONFLICT', '服务商配置已变化，请刷新后重试。');
+            if (current)
+                this.db.prepare('UPDATE image_providers SET name=?,endpoint=?,enabled=?,revision=revision+1 WHERE id=? AND revision=?').run(name, target, Number(raw.enabled), id, prev);
+            else
+                this.db.prepare('INSERT INTO image_providers(id,name,driver,endpoint,enabled,revision) VALUES(?,?,?,?,?,1)').run(id, name, raw.driver, target, Number(raw.enabled));
+            if (current && current.endpoint !== target)
+                this.db.prepare('UPDATE image_provider_models SET verified_at=NULL WHERE provider_id=?').run(id);
+            this.saveVersion(id);
+            return this.get(id);
+        });
+    }
+    deleteProvider(providerId, expected) {
+        const id = identity(providerId), prev = revision(expected);
+        atomic(this.db, () => {
+            const row = this.db.prepare('SELECT revision,deleted FROM image_providers WHERE id=?').get(id);
+            if (!row || row.deleted)
+                throw new ServiceError('NOT_FOUND', '生图服务商不存在。');
+            if (Number(row.revision) !== prev)
+                throw new ServiceError('REVISION_CONFLICT', '服务商配置已变化，请刷新后重试。');
+            this.db.prepare('UPDATE image_providers SET deleted=1,enabled=0,revision=revision+1 WHERE id=? AND revision=?').run(id, prev);
+            this.db.prepare('UPDATE image_provider_models SET verified_at=NULL WHERE provider_id=?').run(id);
+        });
+    }
+    setModel(providerId, raw, expected) {
+        const id = identity(providerId), modelId = modelIdentity(raw?.id), name = label(raw.name), prev = revision(expected);
+        const modes = choices(raw.modes, ['text', 'image', 'text_image'], '输入模式');
+        const formats = choices(raw.formats, ['png', 'jpeg', 'webp'], '格式');
+        const sizes = choices(raw.sizes, raw.sizes ?? [], '尺寸');
+        const qualities = choices(raw.qualities, raw.qualities ?? [], '质量');
+        if (sizes.some(item => item.length > 60) || qualities.some(item => item.length > 60) || typeof raw.isDefault !== 'boolean')
+            throw new ServiceError('INVALID_REQUEST', '模型参数无效。');
+        return atomic(this.db, () => {
+            const current = this.db.prepare('SELECT revision,deleted FROM image_providers WHERE id=?').get(id);
+            if (!current || current.deleted)
+                throw new ServiceError('NOT_FOUND', '生图服务商不存在。');
+            if (Number(current.revision) !== prev)
+                throw new ServiceError('REVISION_CONFLICT', '服务商配置已变化，请刷新后重试。');
+            if (raw.isDefault)
+                this.db.prepare('UPDATE image_provider_models SET is_default=0 WHERE provider_id=?').run(id);
+            // An edited capability or model identity loses any prior real verification.
+            this.db.prepare('INSERT INTO image_provider_models(provider_id,id,name,modes,formats,sizes,qualities,is_default) VALUES(?,?,?,?,?,?,?,?) ON CONFLICT(provider_id,id) DO UPDATE SET name=excluded.name,modes=excluded.modes,formats=excluded.formats,sizes=excluded.sizes,qualities=excluded.qualities,is_default=excluded.is_default,verified_at=NULL').run(id, modelId, name, JSON.stringify(modes), JSON.stringify(formats), JSON.stringify(sizes), JSON.stringify(qualities), Number(raw.isDefault));
+            this.db.prepare('UPDATE image_providers SET revision=revision+1 WHERE id=? AND revision=?').run(id, prev);
+            this.saveVersion(id);
+            return this.get(id);
+        });
+    }
+    syncDiscoveredModels(providerId, discovered, expected) {
+        const id = identity(providerId), prev = revision(expected);
+        if (!Array.isArray(discovered) || discovered.length > 1000)
+            throw new ServiceError('INVALID_REQUEST', '模型选择无效。');
+        const unique = new Map();
+        for (const item of discovered) {
+            const modelId = modelIdentity(item?.id), name = label(item?.name);
+            if (unique.has(modelId))
+                throw new ServiceError('INVALID_REQUEST', '模型选择包含重复项。');
+            unique.set(modelId, { id: modelId, name });
+        }
+        return atomic(this.db, () => {
+            const provider = this.db.prepare('SELECT revision,deleted FROM image_providers WHERE id=?').get(id);
+            if (!provider || provider.deleted)
+                throw new ServiceError('NOT_FOUND', '生图服务商不存在。');
+            if (Number(provider.revision) !== prev)
+                throw new ServiceError('REVISION_CONFLICT', '服务商配置已变化，请刷新后重试。');
+            const existing = this.db.prepare('SELECT * FROM image_provider_models WHERE provider_id=?').all(id);
+            const currentDefault = existing.find(row => Boolean(row.is_default) && unique.has(String(row.id)));
+            const defaultId = currentDefault ? String(currentDefault.id) : unique.keys().next().value;
+            this.db.prepare('DELETE FROM image_provider_models WHERE provider_id=?').run(id);
+            for (const item of unique.values()) {
+                const config = inferredModel(item, item.id === defaultId);
+                const old = existing.find(row => String(row.id) === config.id);
+                const same = old && String(old.name) === config.name && String(old.modes) === JSON.stringify(config.modes) && String(old.formats) === JSON.stringify(config.formats) && String(old.sizes) === JSON.stringify(config.sizes) && String(old.qualities) === JSON.stringify(config.qualities);
+                this.db.prepare('INSERT INTO image_provider_models(provider_id,id,name,modes,formats,sizes,qualities,is_default,verified_at) VALUES(@provider,@id,@name,@modes,@formats,@sizes,@qualities,@isDefault,@verifiedAt)').run({ provider: id, id: config.id, name: config.name, modes: JSON.stringify(config.modes), formats: JSON.stringify(config.formats), sizes: JSON.stringify(config.sizes), qualities: JSON.stringify(config.qualities), isDefault: Number(config.isDefault), verifiedAt: same ? (old.verified_at ?? null) : null });
+            }
+            this.db.prepare('UPDATE image_providers SET revision=revision+1 WHERE id=? AND revision=?').run(id, prev);
+            this.saveVersion(id);
+            return this.get(id);
+        });
+    }
+    deleteModel(providerId, modelId, expected) {
+        const id = identity(providerId), model = modelIdentity(modelId), prev = revision(expected);
+        return atomic(this.db, () => {
+            const provider = this.db.prepare('SELECT revision,deleted FROM image_providers WHERE id=?').get(id);
+            if (!provider || provider.deleted)
+                throw new ServiceError('NOT_FOUND', '服务商不存在。');
+            if (Number(provider.revision) !== prev)
+                throw new ServiceError('REVISION_CONFLICT', '服务商配置已变化，请刷新后重试。');
+            const removed = this.db.prepare('DELETE FROM image_provider_models WHERE provider_id=? AND id=?').run(id, model);
+            if (!removed.changes)
+                throw new ServiceError('NOT_FOUND', '图片模型不存在。');
+            this.db.prepare('UPDATE image_providers SET revision=revision+1 WHERE id=? AND revision=?').run(id, prev);
+            this.saveVersion(id);
+            return this.get(id);
+        });
+    }
+}
+//# sourceMappingURL=image-providers.js.map

package/dist/input-materialization.d.ts

@@ -0,0 +1,17 @@
+import type { InputSnapshot } from "./vendor/protocol/index.js";
+export interface MaterializedInputs {
+    directory: string;
+    files: {
+        resourceId: string;
+        version: number;
+        path: string;
+        sha256: string;
+    }[];
+}
+export interface MaterializeInputOptions {
+    inputDirectory: string;
+    blobDirectory: string;
+    resolveBlobPath?: (sha256: string) => string;
+}
+/** Async preparation outside SQLite transactions; only the newly created private directory is written. */
+export declare function materializeInputs(snapshot: InputSnapshot, options: MaterializeInputOptions): Promise<MaterializedInputs>;