openworkgraph 0.2.12

package/dist/project-lock.js

@@ -0,0 +1,35 @@
+import { createServer } from 'node:net';
+import { createHash } from 'node:crypto';
+import { userInfo } from 'node:os';
+import { isAbsolute, resolve } from 'node:path';
+import { ServiceError } from './errors.js';
+export function projectLockPort(canonicalPath) {
+    if (!isAbsolute(canonicalPath) || resolve(canonicalPath) !== canonicalPath || canonicalPath.includes('\0'))
+        throw new ServiceError('INVALID_REQUEST', 'Project lock requires the canonical absolute path');
+    const user = userInfo();
+    const hash = createHash('sha256').update(JSON.stringify(['openworkgraph-project-v1', user.uid, user.username, canonicalPath])).digest();
+    return 20000 + hash.readUInt32BE(0) % 40000;
+}
+/** Kernel lifetime lock shared by service roots. Port collision is contention,
+ * never evidence that a PID can be killed. Does not write into the source tree. */
+export async function acquireProjectLock(canonicalPath) {
+    const port = projectLockPort(canonicalPath);
+    const server = createServer(socket => { socket.on('error', () => { }); socket.destroy(); });
+    const acquired = await new Promise((resolve, reject) => {
+        const error = (cause) => {
+            if (cause.code === 'EADDRINUSE')
+                resolve(false);
+            else
+                reject(new ServiceError('PROJECT_UNAVAILABLE', 'Cannot acquire project lifetime lock', { cause }));
+        };
+        server.once('error', error);
+        server.listen({ host: '127.0.0.1', port, exclusive: true }, () => { server.off('error', error); resolve(true); });
+    });
+    if (!acquired)
+        return undefined;
+    // An unresolved writer keeps the process/lock alive even if the HTTP UI closes.
+    let released = false;
+    return () => { if (released)
+        return; released = true; server.close(); };
+}
+//# sourceMappingURL=project-lock.js.map

package/dist/project-probe-worker.d.ts

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

package/dist/project-probe-worker.js

@@ -0,0 +1,17 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { discoverProjects } from './project-discovery.js';
+import { inspectProjectDirectory } from './projects.js';
+import { ServiceError } from './errors.js';
+const job = workerData;
+if (job.kind === 'discover')
+    parentPort.postMessage(discoverProjects(job.codexHome));
+else
+    parentPort.postMessage((job.paths ?? []).map(path => {
+        try {
+            return { path, value: inspectProjectDirectory(path) };
+        }
+        catch (error) {
+            return { path, error: error instanceof ServiceError ? error.code : 'PROJECT_UNAVAILABLE' };
+        }
+    }));
+//# sourceMappingURL=project-probe-worker.js.map

package/dist/project-probe.d.ts

@@ -0,0 +1,22 @@
+import type { ProjectCandidates } from "./vendor/protocol/index.js";
+type Inspection = {
+    canonicalPath: string;
+    isGit: boolean;
+};
+/** Filesystem calls run outside the event loop and SQLite transactions.
+ * Timed-out workers retain their capacity slot until actual exit (bounded stuck mounts). */
+export declare class ProjectProbe {
+    private readonly options;
+    private readonly workers;
+    private closed;
+    constructor(options?: {
+        timeoutMs?: number;
+        maxWorkers?: number;
+        workerUrl?: URL;
+    });
+    private run;
+    inspect(paths: string[]): Promise<(path: string) => Inspection>;
+    discover(codexHome?: string): Promise<ProjectCandidates>;
+    close(): void;
+}
+export {};

package/dist/project-probe.js

@@ -0,0 +1,67 @@
+import { Worker } from 'node:worker_threads';
+import { ServiceError } from './errors.js';
+/** Filesystem calls run outside the event loop and SQLite transactions.
+ * Timed-out workers retain their capacity slot until actual exit (bounded stuck mounts). */
+export class ProjectProbe {
+    options;
+    workers = new Map();
+    closed = false;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    run(job) {
+        if (this.closed || this.workers.size >= (this.options.maxWorkers ?? 4))
+            return Promise.reject(new ServiceError('PROJECT_UNAVAILABLE', '目录探测繁忙，请稍后重试。'));
+        return new Promise((resolve, reject) => {
+            const worker = new Worker(this.options.workerUrl ?? new URL('./project-probe-worker.js', import.meta.url), { workerData: job });
+            let settled = false;
+            const finish = (error, value) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                if (error)
+                    reject(error);
+                else
+                    resolve(value);
+            };
+            const timer = setTimeout(() => {
+                finish(new ServiceError('PROJECT_UNAVAILABLE', '目录探测超时，未修改项目；请检查挂载设备后重试。'));
+                void worker.terminate();
+            }, this.options.timeoutMs ?? 5000);
+            this.workers.set(worker, () => finish(new ServiceError('PROJECT_UNAVAILABLE', '服务停止，目录探测已取消。')));
+            worker.on('message', (value) => finish(null, value));
+            worker.on('error', () => finish(new ServiceError('PROJECT_UNAVAILABLE', '目录探测失败；请检查本机目录。')));
+            worker.on('exit', () => { this.workers.delete(worker); finish(new ServiceError('PROJECT_UNAVAILABLE', '目录探测未完成。')); });
+            worker.unref();
+        });
+    }
+    async inspect(paths) {
+        const results = await this.run({ kind: 'inspect', paths: [...new Set(paths)] });
+        const byPath = new Map(results.map(result => [result.path, result]));
+        for (const result of results)
+            if (result.value && !byPath.has(result.value.canonicalPath))
+                byPath.set(result.value.canonicalPath, result);
+        return path => {
+            const result = byPath.get(path);
+            if (!result)
+                throw new ServiceError('CONFLICT', '项目路径在探测期间变化；请刷新后重试。');
+            if (!result.value)
+                throw new ServiceError(result.error ?? 'PROJECT_UNAVAILABLE', '目录不可用；请检查路径。');
+            return result.value;
+        };
+    }
+    async discover(codexHome) {
+        try {
+            return await this.run({ kind: 'discover', codexHome });
+        }
+        catch {
+            return { source: 'codex-desktop-saved-roots', status: 'unavailable', reason: '目录候选探测超时、繁忙或不可用；可手动注册路径。', candidates: [] };
+        }
+    }
+    close() { this.closed = true; for (const [worker, cancel] of this.workers) {
+        cancel();
+        void worker.terminate();
+    } }
+}
+//# sourceMappingURL=project-probe.js.map

package/dist/projects.d.ts

@@ -0,0 +1,29 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { Project } from "./vendor/protocol/index.js";
+export declare function inspectProjectDirectory(path: string): {
+    canonicalPath: string;
+    isGit: boolean;
+};
+export declare class Projects {
+    readonly db: DatabaseSync;
+    readonly serviceId: string;
+    readonly inspectDirectory: typeof inspectProjectDirectory;
+    constructor(db: DatabaseSync, serviceId: string, inspectDirectory?: typeof inspectProjectDirectory);
+    /** Join auth.withSession; a failed operation remains atomic even if its caller catches it. */
+    private atomic;
+    private row;
+    private project;
+    list(state?: Project['state'] | 'all'): Project[];
+    get(id: string): Project;
+    private unique;
+    private noUnfinishedRuns;
+    private changed;
+    register(path: string): Project;
+    setState(id: string, state: Project['state']): Project;
+    repairPath(id: string, path: string): Project;
+    /** Guard metadata writes; source availability is required separately for execution. */
+    assertWritable(id: string): Project;
+    /** Future run submission must call this within its own acceptance transaction.
+     * Returning a path does not lock the filesystem against subsequent external moves. */
+    resolveCwd(id: string): string;
+}

package/dist/projects.js

@@ -0,0 +1,219 @@
+import { randomUUID } from 'node:crypto';
+import { accessSync, closeSync, constants, fstatSync, openSync, readSync, realpathSync, statSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { TERMINAL_RUN_STATUSES } from "./vendor/protocol/index.js";
+import { ServiceError } from './errors.js';
+import { transaction } from './persistence/database.js';
+import { Repositories } from './persistence/repositories.js';
+function canonicalDirectory(path) {
+    if (typeof path !== 'string' || path.length > 32768 || !isAbsolute(path) || path.includes('\0'))
+        throw new ServiceError('INVALID_REQUEST', '项目路径必须是绝对目录路径。');
+    try {
+        const canonical = realpathSync.native(path);
+        if (!statSync(canonical).isDirectory())
+            throw new Error('Not a directory');
+        accessSync(canonical, constants.R_OK | constants.X_OK);
+        return canonical;
+    }
+    catch (cause) {
+        throw new ServiceError('PROJECT_UNAVAILABLE', '项目目录不存在或不可访问；请修复路径，不会自动创建目录。', { cause });
+    }
+}
+function readGitFile(path) {
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK | (constants.O_NOFOLLOW ?? 0));
+    try {
+        const info = fstatSync(fd);
+        if (!info.isFile() || info.size > 4096)
+            throw new Error('Invalid Git metadata file');
+        const buffer = Buffer.alloc(4097);
+        let length = 0;
+        while (length < buffer.length) {
+            const count = readSync(fd, buffer, length, buffer.length - length, null);
+            if (!count)
+                break;
+            length += count;
+        }
+        if (length > 4096)
+            throw new Error('Git metadata file too large');
+        return buffer.subarray(0, length).toString('utf8');
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Inspect Git metadata only: no processes, hooks, config execution or filesystem writes. */
+function isGitDirectory(path) {
+    for (let current = path;; current = dirname(current)) {
+        try {
+            const marker = join(current, '.git');
+            const info = statSync(marker);
+            let gitDir = marker;
+            if (info.isFile()) {
+                if (info.size > 4096)
+                    return false;
+                const match = /^gitdir: (.+)\r?\n?$/.exec(readGitFile(marker));
+                if (!match)
+                    return false;
+                gitDir = resolve(current, match[1].trim());
+            }
+            else if (!info.isDirectory())
+                return false;
+            let commonDir = gitDir;
+            try {
+                const common = join(gitDir, 'commondir');
+                const value = readGitFile(common).trim();
+                if (!value)
+                    return false;
+                commonDir = resolve(gitDir, value);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    return false;
+            }
+            return statSync(join(gitDir, 'HEAD')).isFile() && statSync(join(commonDir, 'objects')).isDirectory() && statSync(join(commonDir, 'refs')).isDirectory();
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                return false;
+        }
+        if (dirname(current) === current)
+            return false;
+    }
+}
+export function inspectProjectDirectory(path) {
+    const canonicalPath = canonicalDirectory(path);
+    return { canonicalPath, isGit: isGitDirectory(canonicalPath) };
+}
+export class Projects {
+    db;
+    serviceId;
+    inspectDirectory;
+    constructor(db, serviceId, inspectDirectory = inspectProjectDirectory) {
+        this.db = db;
+        this.serviceId = serviceId;
+        this.inspectDirectory = inspectDirectory;
+    }
+    /** Join auth.withSession; a failed operation remains atomic even if its caller catches it. */
+    atomic(work) {
+        if (!this.db.isTransaction)
+            return transaction(this.db, work);
+        const savepoint = 'projects_' + randomUUID().replaceAll('-', '');
+        this.db.exec(`SAVEPOINT ${savepoint}`);
+        try {
+            const result = work();
+            this.db.exec(`RELEASE ${savepoint}`);
+            return result;
+        }
+        catch (error) {
+            this.db.exec(`ROLLBACK TO ${savepoint}; RELEASE ${savepoint}`);
+            throw error;
+        }
+    }
+    row(id) {
+        if (typeof id !== 'string' || !id)
+            throw new ServiceError('INVALID_REQUEST', '需要 projectId。');
+        const row = this.db.prepare('SELECT * FROM projects WHERE id=?').get(id);
+        if (!row)
+            throw new ServiceError('NOT_FOUND', '项目不存在。');
+        return row;
+    }
+    project(row) {
+        let availability = 'unavailable';
+        try {
+            if (this.inspectDirectory(row.canonical_path).canonicalPath === row.canonical_path)
+                availability = 'available';
+        }
+        catch (error) {
+            if (error instanceof ServiceError && error.code === 'CONFLICT')
+                throw error;
+            if (!(error instanceof ServiceError) || error.code !== 'PROJECT_UNAVAILABLE')
+                availability = 'unknown';
+        }
+        return { serviceId: this.serviceId, projectId: row.id, name: row.name, canonicalPath: row.canonical_path, state: row.state, availability, isGit: row.is_git === 1 };
+    }
+    list(state = 'active') {
+        if (!['active', 'inactive', 'all'].includes(state))
+            throw new ServiceError('INVALID_REQUEST', '无效的项目状态筛选。');
+        return this.atomic(() => {
+            const rows = this.db.prepare("SELECT * FROM projects WHERE ?='all' OR state=? ORDER BY name,id").all(state, state);
+            return rows.map(row => this.project(row));
+        });
+    }
+    get(id) { return this.atomic(() => this.project(this.row(id))); }
+    unique(path, exceptId = null) {
+        const row = this.db.prepare('SELECT id FROM projects WHERE canonical_path=?').get(path);
+        if (row && row['id'] !== exceptId)
+            throw new ServiceError('CONFLICT', '此目录已注册为另一个项目；请使用已有项目。');
+    }
+    noUnfinishedRuns(id) {
+        const placeholders = TERMINAL_RUN_STATUSES.map(() => '?').join(',');
+        if (this.db.prepare(`SELECT 1 FROM runs WHERE project_id=? AND status NOT IN (${placeholders}) LIMIT 1`).get(id, ...TERMINAL_RUN_STATUSES)) {
+            throw new ServiceError('ACTIVE_RUN', '项目有未结束的执行或生成任务，不能停用或修改路径。');
+        }
+    }
+    changed(row) {
+        const project = this.project(row);
+        const revision = Number(this.db.prepare("SELECT COALESCE(MAX(revision),0)+1 AS revision FROM events WHERE type='project.changed' AND entity_id=?").get(row.id)['revision']);
+        new Repositories(this.db).appendEvent({ eventId: randomUUID(), type: 'project.changed', projectId: row.id, graphId: null, entityId: row.id, revision, occurredAt: new Date().toISOString(), payload: { ...project } });
+        return project;
+    }
+    register(path) {
+        return this.atomic(() => {
+            const inspected = this.inspectDirectory(path);
+            const canonical = inspected.canonicalPath;
+            this.unique(canonical);
+            const row = { id: randomUUID(), canonical_path: canonical, name: basename(canonical) || canonical, state: 'active', is_git: Number(inspected.isGit) };
+            this.db.prepare('INSERT INTO projects(id,canonical_path,name,state,is_git) VALUES(?,?,?,?,?)').run(row.id, row.canonical_path, row.name, row.state, row.is_git);
+            return this.changed(row);
+        });
+    }
+    setState(id, state) {
+        if (state !== 'active' && state !== 'inactive')
+            throw new ServiceError('INVALID_REQUEST', '项目状态必须是 active 或 inactive。');
+        return this.atomic(() => {
+            const row = this.row(id);
+            if (row.state === state)
+                return this.project(row);
+            if (state === 'inactive')
+                this.noUnfinishedRuns(id);
+            this.db.prepare('UPDATE projects SET state=? WHERE id=?').run(state, id);
+            return this.changed({ ...row, state });
+        });
+    }
+    repairPath(id, path) {
+        return this.atomic(() => {
+            const row = this.row(id);
+            if (row.state !== 'active')
+                throw new ServiceError('PROJECT_INACTIVE', '停用项目只读；请先启用再修复路径。');
+            this.noUnfinishedRuns(id);
+            const inspected = this.inspectDirectory(path);
+            const canonical = inspected.canonicalPath;
+            this.unique(canonical, id);
+            const isGit = Number(inspected.isGit);
+            if (canonical === row.canonical_path && isGit === row.is_git)
+                return this.project(row);
+            this.db.prepare('UPDATE projects SET canonical_path=?,is_git=? WHERE id=?').run(canonical, isGit, id);
+            return this.changed({ ...row, canonical_path: canonical, is_git: isGit });
+        });
+    }
+    /** Guard metadata writes; source availability is required separately for execution. */
+    assertWritable(id) {
+        return this.atomic(() => {
+            const project = this.project(this.row(id));
+            if (project.state !== 'active')
+                throw new ServiceError('PROJECT_INACTIVE', '停用项目只读，不能提交新任务。');
+            return project;
+        });
+    }
+    /** Future run submission must call this within its own acceptance transaction.
+     * Returning a path does not lock the filesystem against subsequent external moves. */
+    resolveCwd(id) {
+        return this.atomic(() => {
+            const project = this.assertWritable(id);
+            if (project.availability !== 'available')
+                throw new ServiceError('PROJECT_UNAVAILABLE', '项目目录不可用或符号链接目标已变化；请修复项目路径。');
+            return project.canonicalPath;
+        });
+    }
+}
+//# sourceMappingURL=projects.js.map

package/dist/publication.d.ts

@@ -0,0 +1,31 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { GraphScope, Run } from "./vendor/protocol/index.js";
+import { type DataDirectories } from './directories.js';
+import { Graphs } from './graphs.js';
+import { Resources } from './resources.js';
+import { Runs, type RunToken } from './runs.js';
+export interface CandidateDecision extends GraphScope {
+    runId: string;
+    expectedContentVersion: number;
+    decision: 'accept' | 'discard';
+}
+/** Validate API image bytes with the same structural checks used at publication. */
+export declare function validateImageOutput(bytes: Buffer): 'image/png' | 'image/jpeg' | 'image/webp';
+/** File preparation never runs inside a transaction. Only this publisher may
+ * interpret bridge result.answer; natural-language completion is not parsed. */
+export declare class Publication {
+    readonly db: DatabaseSync;
+    readonly dirs: DataDirectories;
+    readonly resources: Resources;
+    readonly graphs: Graphs;
+    readonly runs: Runs;
+    constructor(db: DatabaseSync, dirs: DataDirectories, resources: Resources, graphs: Graphs, runs: Runs);
+    private check;
+    publish(run: Run, token: RunToken): Promise<void>;
+    private append;
+    /** Main's authenticated route must supply full scope. No implicit acceptance. */
+    decide(request: CandidateDecision): {
+        state: 'accepted' | 'discarded';
+        contentVersion: number;
+    };
+}