openworkgraph 0.3.1 → 0.3.2

package/dist/skill-configs.js

@@ -96,7 +96,7 @@ export class SkillConfigs {
         if (await powershell(aclCheck, JSON.stringify({ path, sid })) !== 'ok')
             throw Error('Unsafe ACL');
     }
-    async directory(skillId) {
+    async directory(skillId, writable = true) {
         identifier(skillId);
         if (!['win32', 'darwin', 'linux'].includes(process.platform))
             throw new ServiceError('MODEL_UNAVAILABLE', '当前平台不支持受限技能配置存储。');
@@ -104,12 +104,36 @@ export class SkillConfigs {
         const workspace = join(root, hash(this.serviceId));
         const skill = join(workspace, hash(skillId));
         for (const path of [this.directories.config, root, workspace, skill]) {
-            ensureDirectory(path);
-            if (process.platform === 'win32')
-                await this.windowsAcl(path, true, true);
+            if (writable) {
+                ensureDirectory(path);
+                if (process.platform === 'win32')
+                    await this.windowsAcl(path, true, true);
+            }
+            else {
+                try {
+                    const stat = lstatSync(path);
+                    if (!stat.isDirectory() || stat.isSymbolicLink() || (process.getuid && stat.uid !== process.getuid()))
+                        throw Error('Unsafe storage');
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+            }
         }
         return skill;
     }
+    /** Immutable snapshots and an atomically published manifest need no read lock. */
+    async reading(skillId, action) {
+        try {
+            return await action(await this.directory(skillId, false));
+        }
+        catch (error) {
+            if (error instanceof ServiceError)
+                throw error;
+            throw new ServiceError('MODEL_UNAVAILABLE', '技能配置读取不可用。');
+        }
+    }
     async locked(skillId, action) {
         try {
             const path = await this.directory(skillId), lock = join(path, '.lock');
@@ -139,16 +163,52 @@ export class SkillConfigs {
             throw new ServiceError('MODEL_UNAVAILABLE', '受限技能配置存储不可用。');
         }
     }
-    async claim(lock) {
+    /** Coordinate revocation with final validation/dispatch, independently of write locks.
+     * Owner metadata contains no configuration values and needs no ACL subprocesses. */
+    async withDispatchLock(action) {
+        const lock = join(this.directories.config, '.skill-dispatch-' + hash(this.serviceId));
+        try {
+            ensureDirectory(this.directories.config);
+            const deadline = Date.now() + 5000;
+            for (;;) {
+                if (await this.claim(lock, false))
+                    break;
+                if (await this.recover(lock, 0, false))
+                    continue;
+                if (Date.now() >= deadline)
+                    throw new ServiceError('CONFLICT', '技能配置正在清除或派发，请稍后重试。', { retryable: true });
+                await delay(20);
+            }
+        }
+        catch (error) {
+            if (error instanceof ServiceError)
+                throw error;
+            throw new ServiceError('MODEL_UNAVAILABLE', '技能配置撤销协调不可用。');
+        }
+        try {
+            return await action();
+        }
+        finally {
+            try {
+                const released = join(this.directories.config, '.released-' + randomUUID());
+                await rename(lock, released);
+                await rm(released, { recursive: true, force: true });
+            }
+            catch {
+                throw new ServiceError('MODEL_UNAVAILABLE', '技能配置撤销协调不可用。');
+            }
+        }
+    }
+    async claim(lock, restrict = true) {
         const prepared = join(dirname(lock), '.owner-' + randomUUID());
         await mkdir(prepared, { mode: 0o700 });
         try {
-            if (process.platform === 'win32')
+            if (restrict && process.platform === 'win32')
                 await this.windowsAcl(prepared, true, true);
             const owner = { pid: process.pid, started: new Date(Date.now() - process.uptime() * 1000).toISOString(), hostname: hostname(), token: randomUUID() };
             // Publish a nonempty directory only after durable owner metadata exists.
             // rename cannot replace another nonempty lock directory, on either OS.
-            await this.atomic(prepared, 'owner-' + owner.token + '.json', owner);
+            await this.atomic(prepared, 'owner-' + owner.token + '.json', owner, restrict);
             try {
                 lstatSync(lock);
                 return undefined;
@@ -218,17 +278,17 @@ export class SkillConfigs {
             return error.code === 'ESRCH';
         }
     }
-    async recover(lock, depth = 0) {
+    async recover(lock, depth = 0, restrict = true) {
         const owner = await this.owner(lock);
         if (!owner || !this.dead(owner) || depth > 4)
             return false;
         const recovery = join(lock, '.recovery');
         let claim;
         try {
-            claim = await this.claim(recovery);
+            claim = await this.claim(recovery, restrict);
             if (!claim) {
                 // A recovery worker can itself crash. Its owner follows the same rule.
-                await this.recover(recovery, depth + 1);
+                await this.recover(recovery, depth + 1, restrict);
                 return false;
             }
         }
@@ -284,29 +344,34 @@ export class SkillConfigs {
             const stat = await file.stat();
             if (!stat.isFile() || stat.nlink !== 1 || (process.platform !== 'win32' && (stat.mode & 0o777) !== 0o600) || stat.size > storageBytes || (process.getuid && stat.uid !== process.getuid()))
                 throw Error('Unsafe storage');
-            if (process.platform === 'win32')
-                await this.windowsAcl(path, false, false);
             return JSON.parse(await file.readFile('utf8'));
         }
         finally {
             await file.close();
         }
     }
-    async manifest(path) {
+    async manifest(path, writable = true) {
         const raw = await this.load(join(path, 'current.json'));
         if (raw === undefined) {
             // Establish revision zero before a first write. A lost committed manifest
             // must not make old revision numbers eligible for reuse with new secrets.
-            if ((await readdir(path)).some(name => /^[0-9]+\.json$/.test(name)))
+            const names = await readdir(path).catch(error => { if (error.code === 'ENOENT')
+                return []; throw error; });
+            if (names.some(name => /^[0-9]+\.json$/.test(name))) {
+                // A first writer may have committed after our initial read.
+                if (!writable && await this.load(join(path, 'current.json')) !== undefined)
+                    return this.manifest(path, false);
                 throw Error('Missing revision manifest');
+            }
             const manifest = initial();
-            await this.atomic(path, 'current.json', manifest);
+            if (writable)
+                await this.atomic(path, 'current.json', manifest);
             return manifest;
         }
         const value = raw;
         if (!value || value.version !== 1 || !Number.isSafeInteger(value.revision) || value.revision < 0 || !Number.isSafeInteger(value.minimumRevision) || value.minimumRevision < 0 || value.minimumRevision > value.revision)
             throw Error('Invalid storage');
-        if (value.minimumRevision > 0)
+        if (writable && value.minimumRevision > 0)
             await this.removeRevoked(path, value.minimumRevision);
         return value;
     }
@@ -335,15 +400,17 @@ export class SkillConfigs {
         }
         return value;
     }
-    async atomic(path, name, value) {
+    async atomic(path, name, value, restrict = true) {
         const text = JSON.stringify(value);
         if (Buffer.byteLength(text) > storageBytes)
             invalid();
         const temporary = join(path, '.' + randomUUID() + '.tmp');
         const file = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
         try {
-            if (process.platform === 'win32')
-                await this.windowsAcl(temporary, false, true);
+            if (process.platform === 'win32') {
+                if (restrict)
+                    await this.windowsAcl(temporary, false, true);
+            }
             else
                 await file.chmod(0o600);
             await file.writeFile(text, 'utf8');
@@ -387,8 +454,8 @@ export class SkillConfigs {
     }
     async read(skillId, schema) {
         const checked = schemaCopy(schema);
-        return this.locked(skillId, async (path) => {
-            const manifest = await this.manifest(path);
+        return this.reading(skillId, async (path) => {
+            const manifest = await this.manifest(path, false);
             return this.view(skillId, checked, manifest, await this.snapshot(path, manifest, manifest.revision));
         });
     }
@@ -457,23 +524,23 @@ export class SkillConfigs {
             const snapshot = { revision, values: {} };
             const next = { ...manifest, revision, minimumRevision: revision };
             await this.atomic(path, String(revision) + '.json', snapshot);
-            await this.atomic(path, 'current.json', next);
+            await this.withDispatchLock(() => this.atomic(path, 'current.json', next));
             // Revocation commits before deletion. A crash midway is safe, and the
-            // next locked read resumes deleting the revoked private files.
+            // next write resumes deleting the revoked private files.
             await this.removeRevoked(path, revision);
             return this.view(skillId, emptySchema, next, snapshot);
         });
     }
-    async revision(skillId) { return this.locked(skillId, async (path) => (await this.manifest(path)).revision); }
+    async revision(skillId) { return this.reading(skillId, async (path) => (await this.manifest(path, false)).revision); }
     async hasRevision(skillId, revision) {
         revisionNumber(revision);
-        return this.locked(skillId, async (path) => {
-            const manifest = await this.manifest(path);
+        return this.reading(skillId, async (path) => {
+            const manifest = await this.manifest(path, false);
             if (revision < manifest.minimumRevision || revision > manifest.revision)
                 return false;
             try {
                 await this.snapshot(path, manifest, revision);
-                return true;
+                return revision >= (await this.manifest(path, false)).minimumRevision;
             }
             catch (error) {
                 if (error instanceof ServiceError && error.code === 'INVALID_REQUEST')
@@ -485,8 +552,10 @@ export class SkillConfigs {
     async environment(skillId, schema, revision) {
         const checked = schemaCopy(schema);
         revisionNumber(revision);
-        return this.locked(skillId, async (path) => {
-            const manifest = await this.manifest(path), snapshot = await this.snapshot(path, manifest, revision);
+        return this.reading(skillId, async (path) => {
+            const manifest = await this.manifest(path, false), snapshot = await this.snapshot(path, manifest, revision);
+            if (revision < (await this.manifest(path, false)).minimumRevision)
+                unavailable();
             return this.snapshotEnvironment(checked, snapshot);
         });
     }
@@ -501,9 +570,8 @@ export class SkillConfigs {
         }
         return environment;
     }
-    /** Deterministic multi-skill locking prevents clear between the final revision
-     * check, secret read, and synchronous spawn/request. No nested public store
-     * methods may be awaited inside dispatch. Never await a returned command. */
+    /** Read snapshots without write locks. Only final validation and synchronous
+     * dispatch exclude clear's commit, across instances and processes. */
     async withRevisions(requests, dispatch) {
         const unique = new Map();
         for (const request of requests) {
@@ -515,40 +583,30 @@ export class SkillConfigs {
         }
         const ids = [...unique.keys()].sort();
         const paths = new Map();
-        let dispatchFailed = false, dispatchError;
-        const acquire = (index) => {
-            const id = ids[index];
-            if (id !== undefined)
-                return this.locked(id, async (path) => { paths.set(id, path); return acquire(index + 1); });
-            return (async () => {
-                const environments = new Map();
-                for (const skillId of ids) {
-                    const request = unique.get(skillId), path = paths.get(skillId);
-                    const manifest = await this.manifest(path);
-                    const snapshot = await this.snapshot(path, manifest, request.revision);
-                    if (request.schema)
-                        environments.set(skillId, this.snapshotEnvironment(request.schema, snapshot));
-                }
-                // The envelope prevents Promise assimilation from holding locks for the
-                // lifetime of command/exec rather than only its synchronous dispatch.
-                try {
-                    return { value: dispatch(environments) };
-                }
-                catch (error) {
-                    dispatchFailed = true;
-                    dispatchError = error;
-                    throw error;
-                }
-            })();
+        const environments = new Map();
+        for (const skillId of ids) {
+            const request = unique.get(skillId);
+            await this.reading(skillId, async (path) => {
+                paths.set(skillId, path);
+                const manifest = await this.manifest(path, false);
+                const snapshot = await this.snapshot(path, manifest, request.revision);
+                if (request.schema)
+                    environments.set(skillId, this.snapshotEnvironment(request.schema, snapshot));
+            });
+        }
+        const dispatchChecked = async () => {
+            for (const skillId of ids) {
+                const request = unique.get(skillId);
+                await this.reading(skillId, async () => {
+                    const manifest = await this.manifest(paths.get(skillId), false);
+                    if (request.revision < manifest.minimumRevision || request.revision > manifest.revision)
+                        unavailable();
+                });
+            }
+            // Keep command promises inside the envelope so the lock ends at dispatch.
+            return { value: dispatch(environments) };
         };
-        try {
-            return await acquire(0);
-        }
-        catch (error) {
-            if (dispatchFailed)
-                throw dispatchError;
-            throw error;
-        }
+        return ids.length ? this.withDispatchLock(dispatchChecked) : dispatchChecked();
     }
 }
 //# sourceMappingURL=skill-configs.js.map

package/dist/skill-sessions.d.ts

@@ -11,8 +11,7 @@ export declare class SkillSessions {
     freeze(prompt: string, raw: unknown, cwd: string): Promise<FrozenSkill[]>;
     private references;
     environment(skills: readonly FrozenSkill[], explicitOnly?: boolean): Promise<Record<string, string>>;
-    /** Launch validates every frozen revision; activation resolves only its target.
-     * Automatic skills with missing required values remain available until used. */
+    /** Resolve only skills used at launch or by this activation. */
     withEnvironment<T>(skills: readonly FrozenSkill[], skillId: string | null, dispatch: (environment: Record<string, string>, secrets: Record<string, string>) => T): Promise<{
         value: T;
     }>;

package/dist/skill-sessions.js

@@ -82,8 +82,7 @@ export class SkillSessions {
     async environment(skills, explicitOnly = false) {
         return (await this.withSelectedEnvironment(skills, skill => !explicitOnly || skill.explicit, environment => environment)).value;
     }
-    /** Launch validates every frozen revision; activation resolves only its target.
-     * Automatic skills with missing required values remain available until used. */
+    /** Resolve only skills used at launch or by this activation. */
     async withEnvironment(skills, skillId, dispatch) {
         if (skillId !== null) {
             const skill = skills.find(item => item.skillId === skillId && item.source === 'openworkgraph');
@@ -98,15 +97,17 @@ export class SkillSessions {
         const frozen = structuredClone(skills);
         const requests = [];
         for (const skill of frozen) {
+            if (!selected(skill))
+                continue;
             if (skill.source === 'codex') {
-                if (selected(skill) && (!isAbsolute(skill.path) || basename(skill.path) !== 'SKILL.md' || (await fs.stat(skill.path)).size > 128 * 1024))
+                if (!isAbsolute(skill.path) || basename(skill.path) !== 'SKILL.md' || (await fs.stat(skill.path)).size > 128 * 1024)
                     throw new ServiceError('INPUT_BLOCKED', '冻结 Codex 技能路径不可用：' + skill.name);
                 continue;
             }
             const entry = await this.packages.packageEntry(skill.skillId, skill.packageVersion);
             if (entry.path !== skill.path || skill.configRevision === undefined)
                 throw new ServiceError('INPUT_BLOCKED', '冻结技能版本不可用：' + skill.name);
-            requests.push({ skillId: skill.skillId, revision: skill.configRevision, ...(selected(skill) ? { schema: entry.config } : {}) });
+            requests.push({ skillId: skill.skillId, revision: skill.configRevision, schema: entry.config });
         }
         return this.configs.withRevisions(requests, environments => {
             const environment = {};

package/dist/skills-management-api.js

@@ -11,7 +11,7 @@ export class SkillsManagementApi {
     async decorate(item) {
         if (!item.installed)
             return item;
-        const entry = await this.runtime.skills.packageEntry(item.skillId, item.packageVersion);
+        const entry = await this.runtime.skills.packageMetadata(item.skillId, item.packageVersion);
         if (!entry.config.environment.length)
             return { ...item, configuration: 'none' };
         const config = await this.runtime.skillConfigs.read(item.skillId, entry.config);
@@ -65,7 +65,11 @@ export class SkillsManagementApi {
             const query = (url.searchParams.get('query') ?? '').trim().toLocaleLowerCase();
             if (query.length > 1024)
                 throw new ServiceError('INVALID_REQUEST', '技能搜索内容过长。');
-            const catalog = await this.runtime.skills.catalog(url.searchParams.get('refresh') === '1');
+            // Installed browsing only reads the host's installation records and schemas.
+            // Remote source availability must never delay this view, including refresh.
+            const catalog = installed
+                ? await this.runtime.skills.installedCatalog()
+                : await this.runtime.skills.catalog(url.searchParams.get('refresh') === '1');
             const filtered = catalog.items.filter(item => (!installed || item.installed) && (item.name + ' ' + item.description).toLocaleLowerCase().includes(query));
             // Unpaged calls remain compatible with welcome setup and skill suggestions.
             const paged = !installed && (url.searchParams.has('offset') || url.searchParams.has('limit'));
@@ -104,7 +108,7 @@ export class SkillsManagementApi {
             }
             else {
                 if (request.method === 'GET') {
-                    const entry = await this.runtime.skills.packageEntry(id);
+                    const entry = await this.runtime.skills.packageMetadata(id);
                     result = { ...await this.runtime.skillConfigs.read(id, entry.config), packageVersion: entry.item.packageVersion };
                 }
                 else {

package/dist/vendor/protocol/index.d.ts

@@ -5,7 +5,7 @@ export * from './execution-chain.js';
 export * from './graph-title.js';
 export * from './graph-binary.js';
 export declare const PROTOCOL_VERSION: '1.0';
-export declare const SERVICE_VERSION: '0.3.1';
+export declare const SERVICE_VERSION: '0.3.2';
 /** Work Graph uploads use the UI's binary MB convention. */
 export declare const WORKGRAPH_UPLOAD_MAX_BYTES: number;
 export declare const WORKGRAPH_TRANSFER_TOTAL_BYTES: number;

package/dist/vendor/protocol/index.js

@@ -5,7 +5,7 @@ export * from './execution-chain.js';
 export * from './graph-title.js';
 export * from './graph-binary.js';
 export const PROTOCOL_VERSION = '1.0';
-export const SERVICE_VERSION = '0.3.1';
+export const SERVICE_VERSION = '0.3.2';
 /** Work Graph uploads use the UI's binary MB convention. */
 export const WORKGRAPH_UPLOAD_MAX_BYTES = 300 * 1024 * 1024;
 export const WORKGRAPH_TRANSFER_TOTAL_BYTES = 1024 * 1024 * 1024;

package/package.json

@@ -1,9 +1,9 @@
-{
-  "name": "openworkgraph", "version": "0.3.1", "type": "module",
-  "publishConfig": { "access": "public" },
-  "engines": { "node": ">=24.0.0" },
-  "bin": { "openworkgraph": "dist/cli.js" },
-  "files": ["dist/**/*.js", "dist/**/*.d.ts", "README.md"],
-  "scripts": { "prebuild": "node ../scripts/check-versions.mjs --quiet", "build": "tsc -p tsconfig.json && node scripts/vendor-protocol.mjs", "prepack": "node scripts/prepare-pack.mjs", "typecheck": "tsc -p tsconfig.json --noEmit", "start": "node dist/cli.js", "test": "node --test test/*.test.mjs" },
-  "dependencies": { "sharp": "^0.35.4", "yaml": "^2.9.1" }
-}
+{
+  "name": "openworkgraph", "version": "0.3.2", "type": "module",
+  "publishConfig": { "access": "public" },
+  "engines": { "node": ">=24.0.0" },
+  "bin": { "openworkgraph": "dist/cli.js" },
+  "files": ["dist/**/*.js", "dist/**/*.d.ts", "README.md"],
+  "scripts": { "prebuild": "node ../scripts/check-versions.mjs --quiet", "build": "tsc -p tsconfig.json && node scripts/vendor-protocol.mjs", "prepack": "node scripts/prepare-pack.mjs", "typecheck": "tsc -p tsconfig.json --noEmit", "start": "node dist/cli.js", "test": "node --test test/*.test.mjs" },
+  "dependencies": { "sharp": "^0.35.4", "yaml": "^2.9.1" }
+}