Skip to content

armgit / Orkas

Public Imported from GitHub
0

Orkas is an open-source (MIT), local-first AI team for your desktop: a Commander turns your goal into to-dos and coordinates 16 built-in specialist agents plus Claude Code, Codex, OpenCode, OpenClaw and Hermes, with projects, scheduled automations and connectors. Free app for macOS & Windows; built-in models or your own keys.

Fix operator policy validation at Skill write boundaries

wyt195ac65a8cd2
diff --git a/.github/workflows/native-dependencies.yml b/.github/workflows/native-dependencies.yml
index c922bb9f..f3fed249 100644
--- a/.github/workflows/native-dependencies.yml
+++ b/.github/workflows/native-dependencies.yml
@@ -62,3 +62,9 @@ jobs:
test/main/util/ensure-deps.test.ts
test/main/util/ensure-dev-dependencies.test.ts
test/main/util/linux-source-dependencies.test.ts
+ - name: Verify operator policy Worker, ASAR runtime and write boundaries
+ run: >-
+ npm run test:js -- --maxWorkers=1
+ test/main/quality/operator-policy.test.ts
+ test/main/quality/operator-policy-asar.test.ts
+ test/main/features/skills.test.ts
diff --git a/src/main/features/skills.ts b/src/main/features/skills.ts
index 89e790c2..ea7d7a23 100644
--- a/src/main/features/skills.ts
+++ b/src/main/features/skills.ts
@@ -428,8 +428,7 @@ function readSkillOrkasMetaSync(dir: string): SkillOrkasMeta {
}
}
-function writeSkillOrkasMetaSync(dir: string, patch: SkillOrkasMeta): void {
- const current = readSkillOrkasMetaSync(dir);
+function mergeSkillOrkasMeta(current: SkillOrkasMeta, patch: SkillOrkasMeta): SkillOrkasMeta {
const next: SkillOrkasMeta = { ...current };
if (Object.prototype.hasOwnProperty.call(patch, 'category')) {
const raw = typeof patch.category === 'string' ? patch.category.trim() : '';
@@ -469,7 +468,11 @@ function writeSkillOrkasMetaSync(dir: string, patch: SkillOrkasMeta): void {
if (clean) next.state = clean;
else delete next.state;
}
- writeJsonSync(skillMetaFile(dir), next);
+ return next;
+}
+
+function writeSkillOrkasMetaSync(dir: string, patch: SkillOrkasMeta): void {
+ writeJsonSync(skillMetaFile(dir), mergeSkillOrkasMeta(readSkillOrkasMetaSync(dir), patch));
}
function _stripSkillSidecarDescriptions(meta: SkillOrkasMeta): SkillOrkasMeta {
@@ -1162,7 +1165,7 @@ export async function createCustomSkill(
const uid = getActiveUserId();
const reports = await validateWithOperatorPolicy(uid, { kind: 'files', files: [
{ relpath: 'SKILL.md', content: skillMdContent(name, description, '', category, 'approved') },
- { relpath: '_meta.json', content: JSON.stringify({ category, status: 'approved' }) },
+ { relpath: '_meta.json', content: JSON.stringify(mergeSkillOrkasMeta({}, { category, status: 'approved' }), null, 2) },
] });
if (uid !== getActiveUserId() || reports.some(hasBlockingOperatorPolicy)) throw new Error(t('quality.operator.incomplete'));
return _createCustomSkillSync(name, description, category);
@@ -1216,7 +1219,7 @@ export async function updateCustomSkill(
description_en?: string;
category?: string;
},
- options: { skipRename?: boolean } = {},
+ options: { skipRename?: boolean; isCancelled?: () => boolean } = {},
): Promise<CustomSkill | null> {
const userId = getActiveUserId();
let d = customSkillDir(skillId, userId);
@@ -1248,11 +1251,17 @@ export async function updateCustomSkill(
? String(updates.category || '')
: ((meta.category as string) || '');
+ const sidecar = readSkillOrkasMetaSync(d);
+ const proposedSidecar = _stripSkillSidecarDescriptions(mergeSkillOrkasMeta(sidecar, {
+ category: newCategory,
+ status: String(meta.status || meta.state || sidecar.status || 'approved'),
+ }));
+ delete proposedSidecar._import;
const policyReports = await validateWithOperatorPolicy(userId, { kind: 'files', files: [
{ relpath: 'SKILL.md', content: skillMdContent(newName, { zh: newZh, en: newEn }, body) },
- { relpath: '_meta.json', content: JSON.stringify({ ...readSkillOrkasMetaSync(d), category: newCategory }) },
+ { relpath: '_meta.json', content: JSON.stringify(proposedSidecar, null, 2) },
] });
- if (userId !== getActiveUserId() || policyReports.some(hasBlockingOperatorPolicy)) throw new Error(t('quality.operator.incomplete'));
+ if (userId !== getActiveUserId() || options.isCancelled?.() || policyReports.some(hasBlockingOperatorPolicy)) throw new Error(t('quality.operator.incomplete'));
let currentId = skillId;
// `skipRename` is the in-progress-edit hook used by the skill detail name
// editor: while the user is typing, write the new `name:` into SKILL.md
@@ -1305,12 +1314,7 @@ export async function updateCustomSkill(
}
writeTextAtomicSync(md, skillMdContent(newName, { zh: newZh, en: newEn }, body));
- writeSkillOrkasMetaSync(d, {
- ...(newCategory ? { category: newCategory } : { category: '' }),
- status: String(meta.status || meta.state || readSkillOrkasMetaSync(d).status || 'approved'),
- });
- removeSkillSidecarDescriptionsSync(d);
- clearSkillImportDraftMarkerSync(currentId);
+ writeJsonSync(skillMetaFile(d), proposedSidecar);
log.info(`updated name=${currentId} category=${newCategory || '(none)'}`);
_invalidateSkillListCache({ userId });
invalidateCoreAgentSkills().catch(() => { /* runner may not be loaded yet */ });
@@ -2190,7 +2194,8 @@ export async function importSkillPackageFromPath(sourcePath: string): Promise<Im
*
* Returns the new id if renamed, null otherwise.
*/
-async function _renameSkillByFrontmatterIfNeeded(currentId: string): Promise<string | null> {
+async function _renameSkillByFrontmatterIfNeeded(currentId: string, isCancelled?: () => boolean): Promise<string | null> {
+ if (isCancelled?.()) return null;
const md = path.join(customSkillDir(currentId), 'SKILL.md');
if (!fs.existsSync(md)) return null;
let meta: SkillFrontmatter;
@@ -2203,7 +2208,7 @@ async function _renameSkillByFrontmatterIfNeeded(currentId: string): Promise<str
if (fs.existsSync(customSkillDir(intended))) return null;
if (fs.existsSync(path.join(userMarketplaceSkillsDir(getActiveUserId()), intended))) return null;
try {
- const updated = await updateCustomSkill(currentId, { name: intended });
+ const updated = await updateCustomSkill(currentId, { name: intended }, { isCancelled });
if (updated) {
log.info(`auto-renamed skill ${currentId} -> ${intended} (from SKILL.md frontmatter)`);
return intended;
@@ -2248,17 +2253,32 @@ export async function writeCustomSkillFileChecked(
if (!fs.existsSync(d) || !fs.statSync(d).isDirectory()) {
return { ok: false, reason: 'missing_dir' };
}
+ const canonicalPath = normalizeSkillWritePath(relpath);
+ if (!canonicalPath) return { ok: false, reason: 'invalid_path' };
+ relpath = canonicalPath;
const isSkillMdWrite = relpath.toUpperCase() === 'SKILL.MD';
let sidecarPatch: SkillOrkasMeta = {};
if (isSkillMdWrite) {
sidecarPatch = _skillSidecarPatchFromFrontmatter(splitSkillMd(content).meta);
}
- const contentForWrite = relpath.toUpperCase() === 'SKILL.MD'
- ? normalizeSkillMdForWrite(content, skillId)
- : content;
+ let contentForWrite = isSkillMdWrite ? normalizeSkillMdForWrite(content, skillId) : content;
+ const currentSidecar = readSkillOrkasMetaSync(d);
+ let proposedSidecar: SkillOrkasMeta | undefined;
+ if (relpath === '_meta.json') {
+ try {
+ const parsed = JSON.parse(contentForWrite);
+ if (parsed && typeof parsed === 'object' && !Array.isArray(parsed) && parsed._import) {
+ delete parsed._import;
+ contentForWrite = JSON.stringify(parsed, null, 2);
+ }
+ } catch { /* The validator below reports malformed JSON. */ }
+ } else if ((isSkillMdWrite && _hasSkillSidecarPatch(sidecarPatch)) || currentSidecar._import) {
+ proposedSidecar = mergeSkillOrkasMeta(currentSidecar, sidecarPatch);
+ delete proposedSidecar._import;
+ }
const files = [{ relpath, content: contentForWrite }];
- if (isSkillMdWrite && _hasSkillSidecarPatch(sidecarPatch)) {
- files.push({ relpath: '_meta.json', content: JSON.stringify({ ...readSkillOrkasMetaSync(d), ...sidecarPatch }) });
+ if (proposedSidecar) {
+ files.push({ relpath: '_meta.json', content: JSON.stringify(proposedSidecar, null, 2) });
}
const reports = await validateWithOperatorPolicy(uid, { kind: 'files', files });
const violations = reports.flatMap((r, index) => index === 0 ? r.violations : r.violations.filter(v => v.source === 'operator-policy'));
@@ -2274,10 +2294,7 @@ export async function writeCustomSkillFileChecked(
}
const written = _writeSkillFileAt(d, relpath, contentForWrite, /* invalidateOnSkillMd */ true);
if (!written) return { ok: false, report, reason: 'invalid_path' };
- if (isSkillMdWrite && _hasSkillSidecarPatch(sidecarPatch)) {
- writeSkillOrkasMetaSync(d, sidecarPatch);
- }
- clearSkillImportDraftMarkerSync(skillId);
+ if (proposedSidecar) writeJsonSync(skillMetaFile(d), proposedSidecar);
return { ok: true, report };
}
@@ -2293,6 +2310,19 @@ export async function writeCustomSkillFile(
return (await writeCustomSkillFileChecked(skillId, relpath, content)).ok;
}
+/** Use the writer's accepted path spelling for validation too. On Windows,
+ * separators must be canonical before checking components and file kinds. */
+function normalizeSkillWritePath(relpath: string): string | null {
+ const rel = relpath.trim().split(path.sep).join('/').replace(/^\/+/, '');
+ if (!rel || rel.startsWith('..')) return null;
+ if (rel.split('/').some(part => part === '' || part === '.' || part === '..')) return null;
+ // Win32 removes trailing dots/spaces and treats colons as alternate streams.
+ if (process.platform === 'win32' && rel.split('/').some(part => /[. ]$|:/.test(part))) return null;
+ if (rel.toLowerCase() === '_meta.json') return '_meta.json';
+ if (rel.toUpperCase() === 'SKILL.MD') return 'SKILL.md';
+ return rel;
+}
+
/** Path-validated write into a resolved skill directory. Returns false on
* any path-escape attempt or missing dir. SKILL.md writes also bust the
* shared list cache + core-agent skill registry cache when requested. */
@@ -2302,11 +2332,8 @@ export function _writeSkillFileAt(
content: string,
invalidateOnSkillMd = true,
): boolean {
- if (!relpath) return false;
- const rel = relpath.trim().replace(/^\/+/, '');
- if (!rel || rel.startsWith('..')) return false;
- const parts = rel.split('/');
- if (parts.some((p) => p === '' || p === '.' || p === '..')) return false;
+ const rel = normalizeSkillWritePath(relpath);
+ if (!rel) return false;
const target = path.resolve(resolvedDir, rel);
try {
const relative = path.relative(resolvedDir, target);
@@ -2357,8 +2384,9 @@ export async function writeSkillFileForEdit(
skillId: string,
relpath: string,
content: string,
+ isCancelled?: () => boolean,
): Promise<boolean> {
- return (await writeSkillFileForEditChecked(skillId, relpath, content)).ok;
+ return (await writeSkillFileForEditChecked(skillId, relpath, content, isCancelled)).ok;
}
interface SkillMetadataApplyResult {
@@ -2375,55 +2403,50 @@ export async function applySkillMetadataForEdit(
updates: SkillMetadataUpdate,
opts: { replaceSidecar?: boolean; isCancelled?: () => boolean } = {},
): Promise<SkillMetadataApplyResult> {
+ const uid = getActiveUserId();
const skill = await getSkillForEdit(skillId);
- if (!skill) return { ok: false, skillId, written: false, reason: 'missing_dir' };
+ if (!skill || uid !== getActiveUserId() || opts.isCancelled?.()) {
+ return { ok: false, skillId, written: false, reason: 'missing_dir' };
+ }
const mdPath = path.join(skill.dir, 'SKILL.md');
const current = fs.existsSync(mdPath) ? fs.readFileSync(mdPath, 'utf8') : '';
const next = _applyMetadataToSkillMdContent(current, updates, skill.id, skill.source);
- const uid = getActiveUserId();
- const proposedSidecar = opts.replaceSidecar
- ? _skillSidecarReplacementFromMetadataUpdate(updates, readSkillOrkasMetaSync(skill.dir))
- : { ...readSkillOrkasMetaSync(skill.dir), ..._skillSidecarPatchFromMetadataUpdate(updates) };
- const policyReports = await validateWithOperatorPolicy(uid, { kind: 'files', files: [
- { relpath: 'SKILL.md', content: next }, { relpath: '_meta.json', content: JSON.stringify(proposedSidecar) },
- ] });
- const blocked = policyReports.find(hasBlockingOperatorPolicy);
- if (blocked || uid !== getActiveUserId() || opts.isCancelled?.()) return { ok: false, skillId, written: false, report: blocked };
- let report: QualityReport | undefined;
- let wrote = false;
-
- if (next !== current) {
- const res = await writeSkillFileForEditChecked(skillId, 'SKILL.md', next, opts.isCancelled);
- if (!res.ok) {
- return { ok: false, skillId, written: false, report: res.report, reason: res.reason };
- }
- report = res.report;
- wrote = true;
- }
-
const rawSidecarPatch = _skillSidecarPatchFromMetadataUpdate(updates);
const sidecarPatch = skill.source === 'marketplace'
? _stripSkillSidecarDescriptions(rawSidecarPatch)
: rawSidecarPatch;
- if (_hasSkillSidecarPatch(sidecarPatch)) {
- if (opts.replaceSidecar) {
- writeSkillOrkasMetaFullSync(
- skill.dir,
- _skillSidecarReplacementFromMetadataUpdate(updates, readSkillOrkasMetaSync(skill.dir)),
- );
- } else {
- writeSkillOrkasMetaSync(skill.dir, sidecarPatch);
- }
- wrote = true;
+ const writesMarkdown = next !== current;
+ if (writesMarkdown && skill.source !== 'custom') return { ok: false, skillId, written: false };
+ const wrote = writesMarkdown || _hasSkillSidecarPatch(sidecarPatch);
+ const currentSidecar = readSkillOrkasMetaSync(skill.dir);
+ const proposedSidecar = opts.replaceSidecar && _hasSkillSidecarPatch(sidecarPatch)
+ ? _stripSkillSidecarDescriptions(_skillSidecarReplacementFromMetadataUpdate(updates, currentSidecar))
+ : mergeSkillOrkasMeta(currentSidecar, sidecarPatch);
+ if (wrote && skill.source === 'custom') delete proposedSidecar._import;
+ const policyReports = await validateWithOperatorPolicy(uid, { kind: 'files', files: [
+ { relpath: 'SKILL.md', content: next }, { relpath: '_meta.json', content: JSON.stringify(proposedSidecar, null, 2) },
+ ] });
+ const blocked = policyReports.find(hasBlockingOperatorPolicy)
+ || (writesMarkdown && !policyReports[0].ok ? policyReports[0] : undefined);
+ if (blocked || uid !== getActiveUserId() || opts.isCancelled?.() || !fs.existsSync(skill.dir)) {
+ return { ok: false, skillId, written: false, report: blocked };
+ }
+ const report = writesMarkdown ? policyReports[0] : undefined;
+ // No asynchronous yield between the final gate and these exact writes.
+ if (writesMarkdown && !_writeSkillFileAt(skill.dir, 'SKILL.md', next)) {
+ return { ok: false, skillId, written: false, report, reason: 'invalid_path' };
+ }
+ if (_hasSkillSidecarPatch(sidecarPatch) || (wrote && currentSidecar._import)) {
+ writeJsonSync(skillMetaFile(skill.dir), proposedSidecar);
_invalidateSkillListCache();
invalidateCoreAgentSkills().catch(() => { /* runner may not be loaded yet */ });
}
+ if (report) void persistQualityReport({ uid, kind: 'skill', id: skillId, report });
let resolvedId = skillId;
if (skill.source === 'custom') {
- const newId = await _renameSkillByFrontmatterIfNeeded(skillId);
+ const newId = await _renameSkillByFrontmatterIfNeeded(skillId, opts.isCancelled);
if (newId && newId !== skillId) resolvedId = newId;
- if (wrote) clearSkillImportDraftMarkerSync(resolvedId);
}
const post = await getSkillForEdit(resolvedId);
log.info(`skill=${skillId}${resolvedId !== skillId ? ` -> ${resolvedId}` : ''} metadata updated`);
@@ -3054,6 +3077,7 @@ async function _applySkillContainerCreate(
metadata?: SkillMetadataUpdate,
opts: { isCancelled?: () => boolean } = {},
): Promise<SkillContainerResult> {
+ files = files.map(f => ({ ...f, path: normalizeSkillWritePath(f.path) || f.path }));
files = files.map((f) => (
f.path.toUpperCase() === 'SKILL.MD'
? {
@@ -3087,8 +3111,20 @@ async function _applySkillContainerCreate(
// half-created skill. Pre-validation moves the EXTREME gate to a single
// decision point: any EXTREME → abort the whole create, no dir touched.
const uid = getActiveUserId();
+ const metadataSidecar = metadata ? _skillSidecarPatchFromMetadataUpdate(metadata) : {};
+ const fileSidecar = _skillSidecarPatchFromFrontmatter(meta);
+ const seedCategory = String(metadataSidecar.category || fileSidecar.category || '');
+ let proposedSidecar = mergeSkillOrkasMeta({}, { category: seedCategory, status: 'approved' });
+ for (const file of files) {
+ if (file.path !== '_meta.json') continue;
+ try {
+ const parsed = JSON.parse(file.content);
+ if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) proposedSidecar = parsed;
+ } catch { /* File validation below rejects malformed metadata. */ }
+ }
+ proposedSidecar = mergeSkillOrkasMeta(proposedSidecar, { ...fileSidecar, ...metadataSidecar });
const policyFiles = files.map(f => ({ relpath: f.path, content: f.path.toUpperCase() === 'SKILL.MD' ? normalizeSkillMdForWrite(f.content, name) : f.content }));
- policyFiles.push({ relpath: '_meta.json', content: JSON.stringify({ ..._skillSidecarPatchFromFrontmatter(meta), ...(metadata ? _skillSidecarPatchFromMetadataUpdate(metadata) : {}), status: 'approved' }) });
+ policyFiles.push({ relpath: '_meta.json', content: JSON.stringify(proposedSidecar, null, 2) });
const reports = await validateWithOperatorPolicy(uid, { kind: 'files', files: policyFiles });
if (uid !== getActiveUserId() || opts.isCancelled?.()) return { ok: false, error: t('skills.errors.validation_blocked') };
const validationFailed: { path: string; report: QualityReport }[] = [];
@@ -3121,9 +3157,6 @@ async function _applySkillContainerCreate(
// All files passed EXTREME — proceed with the actual create.
const desc = migrateDescriptionPair(meta as any);
const seedDescription = desc.description_zh || desc.description_en || '';
- const metadataSidecar = metadata ? _skillSidecarPatchFromMetadataUpdate(metadata) : {};
- const fileSidecar = _skillSidecarPatchFromFrontmatter(meta);
- const seedCategory = String(metadataSidecar.category || fileSidecar.category || '');
const created = _createCustomSkillSync(name, seedDescription, seedCategory);
if (!created) return { ok: false, error: t('skills.errors.create_failed') };
@@ -3149,9 +3182,7 @@ async function _applySkillContainerCreate(
try { fs.utimesSync(path.join(customSkillDir(name), w), stampNow, stampNow); }
catch { /* best effort */ }
}
- if (_hasSkillSidecarPatch({ ...fileSidecar, ...metadataSidecar })) {
- writeSkillOrkasMetaSync(customSkillDir(name), { ...fileSidecar, ...metadataSidecar });
- }
+ writeJsonSync(skillMetaFile(customSkillDir(name)), proposedSidecar);
const violations = reports.flatMap(report => report.violations);
void persistQualityReport({ uid, kind: 'skill', id: name,
report: { ...reports[0], violations, ok: !violations.some(v => v.level === 'EXTREME') } });
@@ -3228,7 +3259,7 @@ async function _applySkillContainerEdit(
// same hook as the per-skill edit chat (`streamSendToSkillChat`).
let resolvedId = skillId;
if (touchedSkillMd) {
- const newId = await _renameSkillByFrontmatterIfNeeded(skillId);
+ const newId = await _renameSkillByFrontmatterIfNeeded(skillId, opts.isCancelled);
if (newId && newId !== skillId) resolvedId = newId;
}
@@ -3639,7 +3670,7 @@ export async function* streamSendToSkillChat(
let updatedMetadata = false;
let usedImportDraftAsSkill = false;
for (const fb of fileBlocks) {
- if (await writeSkillFileForEdit(skillId, fb.path, fb.content)) {
+ if (await writeSkillFileForEdit(skillId, fb.path, fb.content, () => !!opts.abortSignal?.aborted || getActiveUserId() !== userId)) {
written.push(fb.path);
synthesizedProgress.push(t('process.skill.file_written', { path: fb.path }));
if (fb.path.toUpperCase() === 'SKILL.MD') {
@@ -3662,8 +3693,8 @@ export async function* streamSendToSkillChat(
&& container.files.some((f) => f.path.toUpperCase() === 'SKILL.MD');
const targetBefore = currentSkillId;
const res = useCurrentDraft
- ? await _applySkillContainerEdit(currentSkillId, container.files, container.metadata, { isCancelled: () => !!opts.abortSignal?.aborted })
- : await applySkillContainerFromCommander(container, { isCancelled: () => !!opts.abortSignal?.aborted });
+ ? await _applySkillContainerEdit(currentSkillId, container.files, container.metadata, { isCancelled: () => !!opts.abortSignal?.aborted || getActiveUserId() !== userId })
+ : await applySkillContainerFromCommander(container, { isCancelled: () => !!opts.abortSignal?.aborted || getActiveUserId() !== userId });
if (res.ok && res.skillId) {
if (useCurrentDraft) {
usedImportDraftAsSkill = true;
@@ -3709,7 +3740,7 @@ export async function* streamSendToSkillChat(
container.skillId,
[],
metadataOnly,
- { replaceSidecar: true, isCancelled: () => !!opts.abortSignal?.aborted },
+ { replaceSidecar: true, isCancelled: () => !!opts.abortSignal?.aborted || getActiveUserId() !== userId },
);
if (res.ok && res.skillId) {
createdSkills.push({
@@ -3738,7 +3769,7 @@ export async function* streamSendToSkillChat(
// also need to rename src and data trees plus migrate user chat dirs.
if (skill.source === 'custom') {
for (const sid of skillsTouchingMd) {
- const newId = await _renameSkillByFrontmatterIfNeeded(sid);
+ const newId = await _renameSkillByFrontmatterIfNeeded(sid, () => !!opts.abortSignal?.aborted || getActiveUserId() !== userId);
if (newId && newId !== sid) {
if (sid === currentSkillId) currentSkillId = newId;
const evt = {
@@ -3754,7 +3785,7 @@ export async function* streamSendToSkillChat(
const metaRes = await applySkillMetadataForEdit(
currentSkillId,
metadataUpdate,
- { replaceSidecar: directImportMetadataOnly },
+ { replaceSidecar: directImportMetadataOnly, isCancelled: () => !!opts.abortSignal?.aborted || getActiveUserId() !== userId },
);
if (metaRes.ok) {
updatedMetadata = true;
diff --git a/test/main/features/skills.test.ts b/test/main/features/skills.test.ts
index 379b6c82..4952ff26 100644
--- a/test/main/features/skills.test.ts
+++ b/test/main/features/skills.test.ts
@@ -2869,3 +2869,78 @@ describe('skills › operator policy write gates', () => {
expect(fs.existsSync(path.join(customSkillsDir(), 'policy-meta', '_meta.json'))).toBe(false);
});
});
+
+function enableCommitBoundaryPolicy(rules: unknown[]) {
+ const config = path.join(tmpDir, TEST_UID, 'local', 'config');
+ fs.mkdirSync(config, { recursive: true });
+ fs.writeFileSync(path.join(config, 'operator-policy-enabled.json'), '{"enabled":true}');
+ fs.writeFileSync(path.join(config, 'operator-policy.json'), JSON.stringify({version: 1, rules}));
+}
+describe('skills › operator policy commit boundary', () => {
+ it('applies the same policy to the canonical Skill path and its accepted write alias', async () => {
+ writeCustomSkill('alias');
+ enableCommitBoundaryPolicy([{id:'private',level:'EXTREME',pattern:'private-resource',appliesTo:['skill_md']}]);
+ const s = await loadSkills();
+ const payload = '---\nname: alias\ndescription: test\n---\n```bash\necho private-resource\n```';
+ expect((await s.writeCustomSkillFileChecked('alias', 'SKILL.md', payload)).ok).toBe(false);
+ for (const alias of ['/SKILL.md', ' skill.md ']) {
+ expect((await s.writeCustomSkillFileChecked('alias', alias, payload)).ok).toBe(false);
+ }
+ const persisted = fs.readFileSync(path.join(customSkillsDir(),'alias','SKILL.md'),'utf8');
+ expect(persisted).not.toContain('private-resource');
+ });
+ it('checks metadata aliases before replacing the canonical sidecar', async () => {
+ writeCustomSkill('meta-alias');
+ enableCommitBoundaryPolicy([{ id: 'private', level: 'EXTREME', pattern: 'private-resource', appliesTo: ['skill_meta'] }]);
+ const s = await loadSkills();
+ for (const alias of ['/_meta.json', '_META.JSON']) {
+ expect((await s.writeCustomSkillFileChecked('meta-alias', alias, '{"category":"private-resource"}')).ok).toBe(false);
+ }
+ expect(fs.existsSync(path.join(customSkillsDir(), 'meta-alias', '_meta.json'))).toBe(false);
+ });
+ it('checks normalized metadata bytes that will be persisted', async () => {
+ writeCustomSkill('category');
+ enableCommitBoundaryPolicy([{id:'no_creation',level:'EXTREME',pattern:'creation',appliesTo:['skill_meta']}]);
+ const s = await loadSkills();
+ const result = await s.applySkillMetadataForEdit('category', {category:'writing'});
+ const file=path.join(customSkillsDir(),'category','_meta.json');
+ const persisted=fs.existsSync(file) ? fs.readFileSync(file,'utf8') : '';
+ expect(result.ok).toBe(false);
+ expect(persisted).not.toContain('creation');
+ });
+ it('checks the final creation status from legacy frontmatter', async () => {
+ enableCommitBoundaryPolicy([{id:'no_draft',level:'EXTREME',pattern:'draft',appliesTo:['skill_meta']}]);
+ const s=await loadSkills();
+ const result=await s.applySkillContainerFromCommander({raw:'',files:[{path:'SKILL.md',content:'---\nname: status-case\ndescription: Test\nstatus: draft\n---\nBody'}]});
+ const file=path.join(customSkillsDir(),'status-case','_meta.json');
+ const persisted=fs.existsSync(file) ? fs.readFileSync(file,'utf8') : '';
+ expect(result.ok).toBe(false);
+ expect(persisted).not.toContain('draft');
+ });
+ for (const kind of ['file','metadata']) {
+ it(`does not persist inline ${kind} after Stop during policy validation`, async () => {
+ writeCustomSkill('cancelled');
+ enableCommitBoundaryPolicy([]);
+ const controller = new AbortController();
+ const policy = await import('../../../src/main/features/operator-policy');
+ const original = policy.validateWithOperatorPolicy;
+ const spy = vi.spyOn(policy, 'validateWithOperatorPolicy').mockImplementation(async (...args) => {
+ const result = await original(...args);
+ controller.abort();
+ return result;
+ });
+ streamImpl.current = async function* () {
+ yield {type:'final',text: kind === 'file'
+ ? '<<<skill-file path=notes.md\nchanged after stop\n>>>'
+ : '<skill-meta><category>data</category></skill-meta>'};
+ };
+ try {
+ const s = await loadSkills();
+ for await (const event of s.streamSendToSkillChat(TEST_UID,'cancelled','edit',{abortSignal:controller.signal})) {}
+ const target=path.join(customSkillsDir(),'cancelled',kind==='file'?'notes.md':'_meta.json');
+ expect(controller.signal.aborted).toBe(true);
+ expect(fs.existsSync(target)).toBe(false);
+ } finally { spy.mockRestore(); }
+ });
+ }
+});
diff --git a/test/main/quality/operator-policy-asar.test.ts b/test/main/quality/operator-policy-asar.test.ts
new file mode 100644
index 00000000..a3bd87fb
--- /dev/null
+++ b/test/main/quality/operator-policy-asar.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const { createPackageWithOptions, statFile } = require('@electron/asar');
+
+describe('operator policy packaged runtime', () => {
+ it('loads the real Worker from ASAR, enforces rules, terminates slow regex and recovers', async () => {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'orkas-policy-asar-'));
+ try {
+ const stage = path.join(root, 'stage');
+ const archive = path.join(root, 'app.asar');
+ const copy = (relative: string) => {
+ const target = path.join(stage, relative);
+ fs.mkdirSync(path.dirname(target), { recursive: true });
+ fs.cpSync(path.join(process.cwd(), relative), target, { recursive: true });
+ };
+ copy('src/main/quality');
+ copy('src/main/util/token-estimate.ts');
+ copy('src/main/util/skill-description-policy.ts');
+ const build = require('../../../package.json').build;
+ for (const dep of ['tsx', 'get-tsconfig', 'resolve-pkg-maps', 'esbuild', '@esbuild']) {
+ expect(build.asarUnpack).toContain(`node_modules/${dep}/**/*`);
+ copy(`node_modules/${dep}`);
+ }
+ const unpack = build.asarUnpack.map((pattern: string) => path.join(stage, pattern).replaceAll('\\', '/'));
+ await createPackageWithOptions(stage, archive, { unpack: `{${unpack.join(',')}}` });
+ expect(statFile(archive, 'src/main/quality/operator-worker.js').unpacked).not.toBe(true);
+ const launcher = path.join(root, 'launch.cjs');
+ fs.writeFileSync(launcher, `
+ require('node:module').createRequire(require('node:path').join(__dirname, 'app.asar', 'entry.cjs'))('tsx/cjs');
+ const { runOperatorPolicy } = require('./app.asar/src/main/quality');
+ const assert = require('node:assert/strict');
+ const policy = pattern => JSON.stringify({ version: 1, rules: [{ id: 'blocked', level: 'EXTREME', pattern }] });
+ const request = content => ({ kind: 'files', files: [{ relpath: 'run.sh', content }] });
+ (async () => {
+ const hit = await runOperatorPolicy(policy('private-resource'), request('echo private-resource'));
+ assert.equal(hit.reports?.[0].ok, false, JSON.stringify(hit));
+ assert.ok(hit.reports[0].violations.some(v => v.rule === 'operator:blocked'));
+ let ticks = 0;
+ const timer = setInterval(() => ticks++, 10);
+ const slow = await runOperatorPolicy(policy('^(a+)+$'), request('a'.repeat(31) + '!'));
+ clearInterval(timer);
+ assert.equal(slow.error, 'timeout');
+ assert.ok(ticks > 10);
+ const next = await runOperatorPolicy(policy('private-resource'), request('echo safe'));
+ assert.equal(next.reports?.[0].ok, true, JSON.stringify(next));
+ process.stdout.write('POLICY_ASAR_OK');
+ })().catch(e => { console.error(e); process.exitCode = 1; });
+ `);
+ // Match bootstrap.cjs: esbuild's executable must use its real unpacked path.
+ const env = { ...process.env, ELECTRON_RUN_AS_NODE: '1', ESBUILD_BINARY_PATH: path.join(
+ `${archive}.unpacked`, 'node_modules', '@esbuild', `${process.platform}-${process.arch}`,
+ ...(process.platform === 'win32' ? ['esbuild.exe'] : ['bin', 'esbuild']),
+ ) };
+ expect(fs.existsSync(env.ESBUILD_BINARY_PATH)).toBe(true);
+ delete env.NODE_OPTIONS;
+ delete env.NODE_PATH;
+ const result = spawnSync(process.execPath, [launcher], { cwd: root, env, encoding: 'utf8', timeout: 20000 });
+ expect(result.status, result.stderr || result.stdout || String(result.error)).toBe(0);
+ expect(result.stdout).toContain('POLICY_ASAR_OK');
+ } finally { fs.rmSync(root, { recursive: true, force: true }); }
+ }, 30000);
+});