mirror of
https://github.com/waybarrios/opencode-power-pack.git
synced 2026-11-18 18:03:43 +00:00
Introduce a shared advisory sandbox policy contract for Codex, OpenCode, Claude Code, and Pi
Define versioned capability profiles for every bundled skill, add policy resolution and diagnostic commands, preserve sandbox metadata during selective installation, and cover the contract and packaged artifacts with tests.
This commit is contained in:
@@ -28,6 +28,7 @@
|
||||
<a href="#codex-quick-install"><b>Codex Quick Install</b></a> ·
|
||||
<a href="#pi-quick-install"><b>Pi Quick Install</b></a> ·
|
||||
<a href="#whats-inside"><b>Skills</b></a> ·
|
||||
<a href="#sandbox-capability-contract"><b>Sandbox Contract</b></a> ·
|
||||
<a href="#invocation"><b>Invocation</b></a> ·
|
||||
<a href="#how-it-works"><b>Architecture</b></a> ·
|
||||
<a href="#acknowledgments"><b>Credits</b></a>
|
||||
@@ -146,6 +147,27 @@ Profiles automatically include required companion skills and can be combined wit
|
||||
|
||||
The npm installer and the full Claude Code/Codex/OpenCode plugins are alternative activation paths. Claude Code users should prefer the namespaced plugin because the selective installer currently targets the portable `.agents/skills` location used by Codex, OpenCode, and Pi. If a full plugin is already active, selectively copying the same skills does not reduce that plugin's loaded catalog.
|
||||
|
||||
## Sandbox Capability Contract
|
||||
|
||||
The package assigns every bundled skill a default least-capability profile and an explicit set of allowed escalations. Inspect the complete contract or resolve one skill from the CLI:
|
||||
|
||||
```bash
|
||||
opencode-power-pack sandbox doctor
|
||||
opencode-power-pack sandbox resolve --skill code-review
|
||||
opencode-power-pack sandbox resolve --sandbox-profile publish --json
|
||||
```
|
||||
|
||||
| Sandbox profile | Workspace | Network and credentials | External side effects |
|
||||
|---|---|---|---|
|
||||
| `observe` | Read | Denied | Denied |
|
||||
| `develop` | Write | Denied | Denied |
|
||||
| `network-read` | Write | Explicitly approved | Denied |
|
||||
| `publish` | Write | Explicitly approved | Explicit confirmation required |
|
||||
|
||||
This first contract version reports `advisory` enforcement. It describes the capability boundary that host adapters must enforce, but it does not isolate commands or replace the permissions configured by Codex, Claude Code, OpenCode, or Pi. `sandbox doctor` therefore reports `Backend: not-configured` and `Strict ready: no` instead of implying a stronger guarantee.
|
||||
|
||||
Selective installations include a generated `SANDBOX_POLICY.json` beside each copied `SKILL.md`. The file is self-describing and preserves the skill's default profile even when the central package is not present. It remains advisory until an enforcement backend and host adapter are active.
|
||||
|
||||
## Why This Exists
|
||||
|
||||
Claude Code, Codex, OpenCode, and Pi read `SKILL.md` workflows, but many valuable workflows originated as Claude-specific commands and agents. Copying those artifacts directly does not preserve their orchestration, permissions, or subagent behavior.
|
||||
@@ -453,6 +475,13 @@ opencode-power-pack
|
||||
+-- package.json
|
||||
| +-- declares skills/ as a Pi package for pi install
|
||||
|
|
||||
+-- sandbox/contract.json
|
||||
| +-- maps all fifty-four skills to versioned capability profiles
|
||||
| +-- records allowed escalation paths without claiming enforcement
|
||||
|
|
||||
+-- bin/sandbox/policy.mjs
|
||||
| +-- validates, resolves, and reports the shared capability contract
|
||||
|
|
||||
+-- .opencode/plugins/opencode-power-pack.js
|
||||
| +-- registers skills/ in config.skills.paths
|
||||
| +-- registers code-explorer as a read-only subagent
|
||||
@@ -480,6 +509,7 @@ The packaged agents deny edits, external network access, and nested tasks. `code
|
||||
| Portable and host-native subagent orchestration | Proprietary or non-redistributable plugins |
|
||||
| Licensed adaptations with immutable provenance | Automatic trust of third-party skill catalogs |
|
||||
| Explicit permission boundaries and regression tests | Supporting OpenCode versions older than 1.18.7 or obsolete Codex plugin formats |
|
||||
| Versioned sandbox capability contracts and honest enforcement reporting | Treating advisory metadata as an OS security boundary |
|
||||
|
||||
## Contributing
|
||||
|
||||
@@ -494,6 +524,7 @@ Before opening a PR:
|
||||
|
||||
```bash
|
||||
npm test
|
||||
npm run test:sandbox
|
||||
npm run smoke:opencode
|
||||
npm pack --dry-run
|
||||
```
|
||||
|
||||
+116
-6
@@ -11,10 +11,17 @@ import {
|
||||
readdir,
|
||||
rename,
|
||||
rm,
|
||||
writeFile,
|
||||
} from "node:fs/promises";
|
||||
import os from "node:os";
|
||||
import path from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import {
|
||||
loadSandboxContract,
|
||||
portableSkillPolicy,
|
||||
resolveSandboxProfile,
|
||||
sandboxDoctorReport,
|
||||
} from "./sandbox/policy.mjs";
|
||||
|
||||
const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
|
||||
const USAGE = `OpenCode Power Pack selective skill installer
|
||||
@@ -24,6 +31,9 @@ Usage:
|
||||
npx @waybarrios/opencode-power-pack install <skill...> [options]
|
||||
npx @waybarrios/opencode-power-pack install --profile <name> [options]
|
||||
npx @waybarrios/opencode-power-pack install --all [options]
|
||||
npx @waybarrios/opencode-power-pack sandbox doctor [--json]
|
||||
npx @waybarrios/opencode-power-pack sandbox resolve --skill <name> [--json]
|
||||
npx @waybarrios/opencode-power-pack sandbox resolve --sandbox-profile <name> [--json]
|
||||
|
||||
Options:
|
||||
--profile <name> Install a curated profile. Repeatable.
|
||||
@@ -119,7 +129,13 @@ export function resolveSelection({ skillNames = [], profileNames = [], all = fal
|
||||
return [...selected].sort((left, right) => left.localeCompare(right));
|
||||
}
|
||||
|
||||
async function replaceDirectoryWithRollback(source, destination, force, packageRoot) {
|
||||
async function replaceDirectoryWithRollback(
|
||||
source,
|
||||
destination,
|
||||
force,
|
||||
packageRoot,
|
||||
sandboxContract,
|
||||
) {
|
||||
const parent = path.dirname(destination);
|
||||
const name = path.basename(destination);
|
||||
const lock = `${destination}.opp-lock`;
|
||||
@@ -150,6 +166,11 @@ async function replaceDirectoryWithRollback(source, destination, force, packageR
|
||||
path.join(staged, "THIRD_PARTY_NOTICES.md"),
|
||||
);
|
||||
await cp(path.join(packageRoot, "LICENSES"), path.join(staged, "LICENSES"), { recursive: true });
|
||||
await writeFile(
|
||||
path.join(staged, "SANDBOX_POLICY.json"),
|
||||
`${JSON.stringify(portableSkillPolicy(sandboxContract, name), null, 2)}\n`,
|
||||
"utf8",
|
||||
);
|
||||
if (force && await pathExists(destination)) {
|
||||
backup = path.join(parent, `.opp-backup-${name}-${randomUUID()}`);
|
||||
await rename(destination, backup);
|
||||
@@ -227,6 +248,7 @@ export async function installSkills({
|
||||
packageRoot = PACKAGE_ROOT,
|
||||
}) {
|
||||
if (!dryRun) await mkdir(destination, { recursive: true });
|
||||
const sandboxContract = await loadSandboxContract(packageRoot);
|
||||
const results = [];
|
||||
|
||||
for (const skillName of skillNames) {
|
||||
@@ -243,7 +265,13 @@ export async function installSkills({
|
||||
continue;
|
||||
}
|
||||
|
||||
const warnings = await replaceDirectoryWithRollback(source, target, force, packageRoot);
|
||||
const warnings = await replaceDirectoryWithRollback(
|
||||
source,
|
||||
target,
|
||||
force,
|
||||
packageRoot,
|
||||
sandboxContract,
|
||||
);
|
||||
results.push({
|
||||
name: skillName,
|
||||
status: exists ? "updated" : "installed",
|
||||
@@ -310,6 +338,82 @@ function printCatalog(catalog, skills, write) {
|
||||
}
|
||||
}
|
||||
|
||||
export function parseSandboxArgs(args) {
|
||||
const [command, ...rest] = args;
|
||||
if (!command) throw new Error("Choose a sandbox command: doctor or resolve.");
|
||||
if (!["doctor", "resolve"].includes(command)) {
|
||||
throw new Error(`Unknown sandbox command: ${command}`);
|
||||
}
|
||||
|
||||
const options = { command, json: false };
|
||||
for (let index = 0; index < rest.length; index += 1) {
|
||||
const value = rest[index];
|
||||
if (value === "--json") {
|
||||
options.json = true;
|
||||
} else if (value === "--skill" || value === "--sandbox-profile") {
|
||||
if (command !== "resolve") throw new Error(`${value} is only valid with sandbox resolve.`);
|
||||
const target = rest[index + 1];
|
||||
if (!target || target.startsWith("-")) throw new Error(`${value} requires a value.`);
|
||||
const key = value === "--skill" ? "skillName" : "profileName";
|
||||
if (options[key]) throw new Error(`${value} may be provided only once.`);
|
||||
options[key] = target;
|
||||
index += 1;
|
||||
} else {
|
||||
throw new Error(`Unknown sandbox option: ${value}`);
|
||||
}
|
||||
}
|
||||
if (command === "resolve" && !options.skillName && !options.profileName) {
|
||||
throw new Error("sandbox resolve requires --skill or --sandbox-profile.");
|
||||
}
|
||||
if (command === "resolve" && options.skillName && options.profileName) {
|
||||
throw new Error("Choose exactly one of --skill or --sandbox-profile.");
|
||||
}
|
||||
return options;
|
||||
}
|
||||
|
||||
function printSandboxResolution(resolution, write) {
|
||||
if (resolution.skill) write(`Skill: ${resolution.skill}\n`);
|
||||
write(`Profile: ${resolution.profile.name}\n`);
|
||||
write(`Description: ${resolution.profile.description}\n`);
|
||||
write(`Risk level: ${resolution.profile.riskLevel}\n`);
|
||||
write(`Enforcement: ${resolution.profile.enforcementLevel}\n`);
|
||||
write("Capabilities:\n");
|
||||
for (const [name, value] of Object.entries(resolution.profile.capabilities)) {
|
||||
write(` ${name.padEnd(20)} ${value}\n`);
|
||||
}
|
||||
if (resolution.allowedEscalations) {
|
||||
const names = resolution.allowedEscalations.map((profile) => profile.name);
|
||||
write(`Allowed escalations: ${names.length > 0 ? names.join(", ") : "none"}\n`);
|
||||
}
|
||||
write("Warning: advisory metadata does not isolate commands or tools.\n");
|
||||
}
|
||||
|
||||
function printSandboxDoctor(report, write) {
|
||||
write(`Sandbox contract: ${report.ok ? "valid" : "invalid"}\n`);
|
||||
write(`Schema version: ${report.schemaVersion}\n`);
|
||||
write(`Profiles: ${report.profiles}\n`);
|
||||
write(`Assigned skills: ${report.assignedSkills}/${report.packagedSkills}\n`);
|
||||
write(`Enforcement: ${report.enforcementLevel}\n`);
|
||||
write(`Backend: ${report.backend}\n`);
|
||||
write(`Strict ready: ${report.strictReady ? "yes" : "no"}\n`);
|
||||
for (const warning of report.warnings) write(`Warning: ${warning}\n`);
|
||||
}
|
||||
|
||||
export async function runSandboxCommand(args, context) {
|
||||
const options = parseSandboxArgs(args);
|
||||
const skills = await discoverSkills(context.packageRoot);
|
||||
const availableSkillNames = skills.map((skill) => skill.name);
|
||||
const contract = await loadSandboxContract(context.packageRoot, availableSkillNames);
|
||||
const result = options.command === "doctor"
|
||||
? sandboxDoctorReport(contract, availableSkillNames)
|
||||
: resolveSandboxProfile(contract, options);
|
||||
|
||||
if (options.json) context.write(`${JSON.stringify(result, null, 2)}\n`);
|
||||
else if (options.command === "doctor") printSandboxDoctor(result, context.write);
|
||||
else printSandboxResolution(result, context.write);
|
||||
return 0;
|
||||
}
|
||||
|
||||
export async function main(args = process.argv.slice(2), context = {}) {
|
||||
const write = context.write || ((text) => process.stdout.write(text));
|
||||
const cwd = context.cwd || process.cwd();
|
||||
@@ -322,6 +426,10 @@ export async function main(args = process.argv.slice(2), context = {}) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (command === "sandbox") {
|
||||
return runSandboxCommand(rest, { packageRoot, write });
|
||||
}
|
||||
|
||||
const catalog = await loadCatalog(packageRoot);
|
||||
const skills = await discoverSkills(packageRoot);
|
||||
|
||||
@@ -372,8 +480,10 @@ export function isDirectInvocation(argvEntry, moduleUrl = import.meta.url) {
|
||||
const invokedDirectly = isDirectInvocation(process.argv[1]);
|
||||
|
||||
if (invokedDirectly) {
|
||||
main().catch((error) => {
|
||||
process.stderr.write(`Error: ${error.message}\n`);
|
||||
process.exitCode = 1;
|
||||
});
|
||||
main()
|
||||
.then((exitCode) => { process.exitCode = exitCode; })
|
||||
.catch((error) => {
|
||||
process.stderr.write(`Error: ${error.message}\n`);
|
||||
process.exitCode = 1;
|
||||
});
|
||||
}
|
||||
|
||||
@@ -0,0 +1,205 @@
|
||||
import { readFile } from "node:fs/promises";
|
||||
import path from "node:path";
|
||||
|
||||
const TOP_LEVEL_KEYS = new Set([
|
||||
"$schema",
|
||||
"schemaVersion",
|
||||
"enforcementLevel",
|
||||
"profiles",
|
||||
"skills",
|
||||
]);
|
||||
const PROFILE_KEYS = new Set(["description", "riskLevel", "capabilities"]);
|
||||
const CAPABILITY_KEYS = new Set([
|
||||
"workspace",
|
||||
"temporaryFiles",
|
||||
"network",
|
||||
"credentials",
|
||||
"externalSideEffects",
|
||||
]);
|
||||
const ASSIGNMENT_KEYS = new Set(["defaultProfile", "allowedEscalations"]);
|
||||
|
||||
function isObject(value) {
|
||||
return value !== null && typeof value === "object" && !Array.isArray(value);
|
||||
}
|
||||
|
||||
function assertObject(value, label) {
|
||||
if (!isObject(value)) throw new TypeError(`${label} must be an object.`);
|
||||
}
|
||||
|
||||
function assertExactKeys(value, expected, label) {
|
||||
for (const key of Object.keys(value)) {
|
||||
if (!expected.has(key)) throw new TypeError(`${label} has unknown field: ${key}`);
|
||||
}
|
||||
for (const key of expected) {
|
||||
if (!Object.hasOwn(value, key)) throw new TypeError(`${label} is missing field: ${key}`);
|
||||
}
|
||||
}
|
||||
|
||||
function assertChoice(value, choices, label) {
|
||||
if (!choices.includes(value)) {
|
||||
throw new TypeError(`${label} must be one of: ${choices.join(", ")}.`);
|
||||
}
|
||||
}
|
||||
|
||||
function ownEntry(object, key) {
|
||||
return Object.hasOwn(object, key) ? object[key] : undefined;
|
||||
}
|
||||
|
||||
export function validateSandboxContract(contract, availableSkillNames) {
|
||||
assertObject(contract, "Sandbox contract");
|
||||
assertExactKeys(contract, TOP_LEVEL_KEYS, "Sandbox contract");
|
||||
if (contract.$schema !== "./contract.schema.json") {
|
||||
throw new TypeError("Sandbox contract must reference ./contract.schema.json.");
|
||||
}
|
||||
if (contract.schemaVersion !== 1) {
|
||||
throw new TypeError(`Unsupported sandbox contract schema version: ${contract.schemaVersion}`);
|
||||
}
|
||||
if (contract.enforcementLevel !== "advisory") {
|
||||
throw new TypeError("PR 1 sandbox contracts must report advisory enforcement.");
|
||||
}
|
||||
|
||||
assertObject(contract.profiles, "Sandbox profiles");
|
||||
const profileEntries = Object.entries(contract.profiles);
|
||||
if (profileEntries.length === 0) throw new TypeError("Sandbox contract must define profiles.");
|
||||
for (const [name, profile] of profileEntries) {
|
||||
if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name)) {
|
||||
throw new TypeError(`Invalid sandbox profile name: ${name}`);
|
||||
}
|
||||
assertObject(profile, `Sandbox profile ${name}`);
|
||||
assertExactKeys(profile, PROFILE_KEYS, `Sandbox profile ${name}`);
|
||||
if (typeof profile.description !== "string" || profile.description.trim() === "") {
|
||||
throw new TypeError(`Sandbox profile ${name} requires a description.`);
|
||||
}
|
||||
if (!Number.isInteger(profile.riskLevel) || profile.riskLevel < 0) {
|
||||
throw new TypeError(`Sandbox profile ${name} requires a non-negative integer riskLevel.`);
|
||||
}
|
||||
assertObject(profile.capabilities, `Sandbox profile ${name} capabilities`);
|
||||
assertExactKeys(profile.capabilities, CAPABILITY_KEYS, `Sandbox profile ${name} capabilities`);
|
||||
assertChoice(profile.capabilities.workspace, ["read", "write"], `${name}.workspace`);
|
||||
assertChoice(profile.capabilities.temporaryFiles, ["deny", "write"], `${name}.temporaryFiles`);
|
||||
assertChoice(profile.capabilities.network, ["deny", "explicit"], `${name}.network`);
|
||||
assertChoice(profile.capabilities.credentials, ["deny", "explicit"], `${name}.credentials`);
|
||||
assertChoice(
|
||||
profile.capabilities.externalSideEffects,
|
||||
["deny", "confirm"],
|
||||
`${name}.externalSideEffects`,
|
||||
);
|
||||
}
|
||||
|
||||
assertObject(contract.skills, "Sandbox skill assignments");
|
||||
const assignmentEntries = Object.entries(contract.skills);
|
||||
if (assignmentEntries.length === 0) {
|
||||
throw new TypeError("Sandbox contract must assign skills.");
|
||||
}
|
||||
for (const [skillName, assignment] of assignmentEntries) {
|
||||
if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(skillName)) {
|
||||
throw new TypeError(`Invalid sandbox skill name: ${skillName}`);
|
||||
}
|
||||
assertObject(assignment, `Sandbox assignment ${skillName}`);
|
||||
assertExactKeys(assignment, ASSIGNMENT_KEYS, `Sandbox assignment ${skillName}`);
|
||||
const defaultProfile = ownEntry(contract.profiles, assignment.defaultProfile);
|
||||
if (!defaultProfile) {
|
||||
throw new TypeError(`${skillName} references unknown profile: ${assignment.defaultProfile}`);
|
||||
}
|
||||
if (!Array.isArray(assignment.allowedEscalations)) {
|
||||
throw new TypeError(`${skillName}.allowedEscalations must be an array.`);
|
||||
}
|
||||
const seen = new Set();
|
||||
for (const escalationName of assignment.allowedEscalations) {
|
||||
if (typeof escalationName !== "string" || escalationName.trim() === "") {
|
||||
throw new TypeError(`${skillName} has an invalid escalation profile.`);
|
||||
}
|
||||
if (seen.has(escalationName)) {
|
||||
throw new TypeError(`${skillName} repeats escalation profile: ${escalationName}`);
|
||||
}
|
||||
seen.add(escalationName);
|
||||
const escalation = ownEntry(contract.profiles, escalationName);
|
||||
if (!escalation) {
|
||||
throw new TypeError(`${skillName} references unknown escalation: ${escalationName}`);
|
||||
}
|
||||
if (escalationName === assignment.defaultProfile) {
|
||||
throw new TypeError(`${skillName} repeats its default profile as an escalation.`);
|
||||
}
|
||||
if (escalation.riskLevel <= defaultProfile.riskLevel) {
|
||||
throw new TypeError(`${skillName} escalation ${escalationName} must increase riskLevel.`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (availableSkillNames) {
|
||||
const available = new Set(availableSkillNames);
|
||||
const assigned = new Set(Object.keys(contract.skills));
|
||||
const missing = [...available].filter((name) => !assigned.has(name)).sort();
|
||||
const unknown = [...assigned].filter((name) => !available.has(name)).sort();
|
||||
if (missing.length > 0) {
|
||||
throw new TypeError(`Sandbox assignments missing packaged skills: ${missing.join(", ")}`);
|
||||
}
|
||||
if (unknown.length > 0) {
|
||||
throw new TypeError(`Sandbox assignments reference unknown skills: ${unknown.join(", ")}`);
|
||||
}
|
||||
}
|
||||
|
||||
return contract;
|
||||
}
|
||||
|
||||
export async function loadSandboxContract(packageRoot, availableSkillNames) {
|
||||
const source = await readFile(path.join(packageRoot, "sandbox", "contract.json"), "utf8");
|
||||
return validateSandboxContract(JSON.parse(source), availableSkillNames);
|
||||
}
|
||||
|
||||
function resolvedProfile(contract, profileName) {
|
||||
const profile = ownEntry(contract.profiles, profileName);
|
||||
if (!profile) throw new Error(`Unknown sandbox profile: ${profileName}`);
|
||||
return {
|
||||
name: profileName,
|
||||
description: profile.description,
|
||||
riskLevel: profile.riskLevel,
|
||||
capabilities: { ...profile.capabilities },
|
||||
enforcementLevel: contract.enforcementLevel,
|
||||
};
|
||||
}
|
||||
|
||||
export function resolveSandboxProfile(contract, { skillName, profileName }) {
|
||||
if ((skillName ? 1 : 0) + (profileName ? 1 : 0) !== 1) {
|
||||
throw new Error("Choose exactly one of --skill or --sandbox-profile.");
|
||||
}
|
||||
if (profileName) return { profile: resolvedProfile(contract, profileName) };
|
||||
|
||||
const assignment = ownEntry(contract.skills, skillName);
|
||||
if (!assignment) throw new Error(`Unknown sandbox skill: ${skillName}`);
|
||||
return {
|
||||
skill: skillName,
|
||||
profile: resolvedProfile(contract, assignment.defaultProfile),
|
||||
allowedEscalations: assignment.allowedEscalations.map((name) => resolvedProfile(contract, name)),
|
||||
};
|
||||
}
|
||||
|
||||
export function portableSkillPolicy(contract, skillName) {
|
||||
const resolution = resolveSandboxProfile(contract, { skillName });
|
||||
return {
|
||||
schemaVersion: contract.schemaVersion,
|
||||
source: "@waybarrios/opencode-power-pack",
|
||||
enforcementLevel: contract.enforcementLevel,
|
||||
warning: "This capability policy is advisory until an enforcement backend and host adapter are active.",
|
||||
skill: resolution.skill,
|
||||
profile: resolution.profile,
|
||||
allowedEscalations: resolution.allowedEscalations,
|
||||
};
|
||||
}
|
||||
|
||||
export function sandboxDoctorReport(contract, availableSkillNames) {
|
||||
validateSandboxContract(contract, availableSkillNames);
|
||||
return {
|
||||
ok: true,
|
||||
schemaVersion: contract.schemaVersion,
|
||||
enforcementLevel: contract.enforcementLevel,
|
||||
backend: "not-configured",
|
||||
strictReady: false,
|
||||
profiles: Object.keys(contract.profiles).length,
|
||||
assignedSkills: Object.keys(contract.skills).length,
|
||||
packagedSkills: availableSkillNames.length,
|
||||
warnings: [
|
||||
"Capability profiles are advisory until an enforcement backend and host adapter are active.",
|
||||
],
|
||||
};
|
||||
}
|
||||
@@ -21,6 +21,7 @@
|
||||
".codex-plugin",
|
||||
".opencode",
|
||||
"bin",
|
||||
"sandbox",
|
||||
"assets",
|
||||
"skillsets.json",
|
||||
"UPSTREAMS.json",
|
||||
@@ -29,6 +30,7 @@
|
||||
],
|
||||
"scripts": {
|
||||
"test": "node --test",
|
||||
"test:sandbox": "node --test tests/sandbox-policy.test.mjs",
|
||||
"prepublishOnly": "npm test",
|
||||
"eval:behavioral": "node scripts/behavioral-evals.mjs run",
|
||||
"eval:behavioral:accept": "node scripts/behavioral-evals.mjs accept",
|
||||
|
||||
@@ -0,0 +1,269 @@
|
||||
{
|
||||
"$schema": "./contract.schema.json",
|
||||
"schemaVersion": 1,
|
||||
"enforcementLevel": "advisory",
|
||||
"profiles": {
|
||||
"observe": {
|
||||
"description": "Inspect and analyze the workspace without modifying it or using the network.",
|
||||
"riskLevel": 0,
|
||||
"capabilities": {
|
||||
"workspace": "read",
|
||||
"temporaryFiles": "write",
|
||||
"network": "deny",
|
||||
"credentials": "deny",
|
||||
"externalSideEffects": "deny"
|
||||
}
|
||||
},
|
||||
"develop": {
|
||||
"description": "Modify the workspace and temporary files without network access or external side effects.",
|
||||
"riskLevel": 1,
|
||||
"capabilities": {
|
||||
"workspace": "write",
|
||||
"temporaryFiles": "write",
|
||||
"network": "deny",
|
||||
"credentials": "deny",
|
||||
"externalSideEffects": "deny"
|
||||
}
|
||||
},
|
||||
"network-read": {
|
||||
"description": "Use explicitly approved network destinations and credentials for retrieval without external mutations.",
|
||||
"riskLevel": 2,
|
||||
"capabilities": {
|
||||
"workspace": "write",
|
||||
"temporaryFiles": "write",
|
||||
"network": "explicit",
|
||||
"credentials": "explicit",
|
||||
"externalSideEffects": "deny"
|
||||
}
|
||||
},
|
||||
"publish": {
|
||||
"description": "Perform explicitly confirmed external mutations using narrowly scoped network and credential access.",
|
||||
"riskLevel": 3,
|
||||
"capabilities": {
|
||||
"workspace": "write",
|
||||
"temporaryFiles": "write",
|
||||
"network": "explicit",
|
||||
"credentials": "explicit",
|
||||
"externalSideEffects": "confirm"
|
||||
}
|
||||
}
|
||||
},
|
||||
"skills": {
|
||||
"agentic-actions-auditor": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"agents-md-improver": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"agents-md-revise": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"ai-slop": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"code-architect": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"code-explorer": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"code-quality": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"code-review": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": ["network-read", "publish"]
|
||||
},
|
||||
"code-reviewer": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"codeql": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"design-patterns": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"differential-review": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"feature-dev": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"fp-check": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"frontend-design": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"hf-cli": {
|
||||
"defaultProfile": "network-read",
|
||||
"allowedEscalations": ["publish"]
|
||||
},
|
||||
"hf-cloud-aws-context-discovery": {
|
||||
"defaultProfile": "network-read",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"hf-cloud-python-env-setup": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"hf-cloud-sagemaker-deployment-planner": {
|
||||
"defaultProfile": "network-read",
|
||||
"allowedEscalations": ["publish"]
|
||||
},
|
||||
"hf-cloud-sagemaker-iam-preflight": {
|
||||
"defaultProfile": "network-read",
|
||||
"allowedEscalations": ["publish"]
|
||||
},
|
||||
"hf-cloud-sagemaker-production-defaults": {
|
||||
"defaultProfile": "publish",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"hf-cloud-serving-image-selection": {
|
||||
"defaultProfile": "network-read",
|
||||
"allowedEscalations": ["publish"]
|
||||
},
|
||||
"hf-mem": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"huggingface-best": {
|
||||
"defaultProfile": "network-read",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"huggingface-community-evals": {
|
||||
"defaultProfile": "network-read",
|
||||
"allowedEscalations": ["publish"]
|
||||
},
|
||||
"huggingface-datasets": {
|
||||
"defaultProfile": "network-read",
|
||||
"allowedEscalations": ["publish"]
|
||||
},
|
||||
"huggingface-gradio": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read", "publish"]
|
||||
},
|
||||
"huggingface-llm-trainer": {
|
||||
"defaultProfile": "publish",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"huggingface-local-models": {
|
||||
"defaultProfile": "network-read",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"huggingface-lora-space-builder": {
|
||||
"defaultProfile": "publish",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"huggingface-paper-publisher": {
|
||||
"defaultProfile": "publish",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"huggingface-papers": {
|
||||
"defaultProfile": "network-read",
|
||||
"allowedEscalations": ["publish"]
|
||||
},
|
||||
"huggingface-spaces": {
|
||||
"defaultProfile": "publish",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"huggingface-tool-builder": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read", "publish"]
|
||||
},
|
||||
"huggingface-trackio": {
|
||||
"defaultProfile": "publish",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"huggingface-vision-trainer": {
|
||||
"defaultProfile": "publish",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"huggingface-zerogpu": {
|
||||
"defaultProfile": "publish",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"insecure-defaults": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"mcp-builder": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"paper-summarizer": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"sarif-parsing": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"security-review": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": ["network-read", "publish"]
|
||||
},
|
||||
"security-threat-model": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"semgrep": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"semgrep-rule-creator": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"semgrep-rule-variant-creator": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"sharp-edges": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"skill-creator": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"supply-chain-risk-auditor": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"train-sentence-transformers": {
|
||||
"defaultProfile": "publish",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"transformers-js": {
|
||||
"defaultProfile": "develop",
|
||||
"allowedEscalations": ["network-read"]
|
||||
},
|
||||
"trl-training": {
|
||||
"defaultProfile": "publish",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"variant-analysis": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": []
|
||||
},
|
||||
"vuln-report": {
|
||||
"defaultProfile": "observe",
|
||||
"allowedEscalations": ["develop"]
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,109 @@
|
||||
{
|
||||
"$schema": "https://json-schema.org/draft/2020-12/schema",
|
||||
"$id": "https://github.com/waybarrios/opencode-power-pack/sandbox/contract.schema.json",
|
||||
"title": "OpenCode Power Pack sandbox capability contract",
|
||||
"type": "object",
|
||||
"additionalProperties": false,
|
||||
"required": [
|
||||
"$schema",
|
||||
"schemaVersion",
|
||||
"enforcementLevel",
|
||||
"profiles",
|
||||
"skills"
|
||||
],
|
||||
"properties": {
|
||||
"$schema": {
|
||||
"const": "./contract.schema.json"
|
||||
},
|
||||
"schemaVersion": {
|
||||
"const": 1
|
||||
},
|
||||
"enforcementLevel": {
|
||||
"const": "advisory"
|
||||
},
|
||||
"profiles": {
|
||||
"type": "object",
|
||||
"minProperties": 1,
|
||||
"propertyNames": {
|
||||
"pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$"
|
||||
},
|
||||
"additionalProperties": {
|
||||
"$ref": "#/$defs/profile"
|
||||
}
|
||||
},
|
||||
"skills": {
|
||||
"type": "object",
|
||||
"minProperties": 1,
|
||||
"propertyNames": {
|
||||
"pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$"
|
||||
},
|
||||
"additionalProperties": {
|
||||
"$ref": "#/$defs/skillAssignment"
|
||||
}
|
||||
}
|
||||
},
|
||||
"$defs": {
|
||||
"profile": {
|
||||
"type": "object",
|
||||
"additionalProperties": false,
|
||||
"required": ["description", "riskLevel", "capabilities"],
|
||||
"properties": {
|
||||
"description": {
|
||||
"type": "string",
|
||||
"minLength": 1
|
||||
},
|
||||
"riskLevel": {
|
||||
"type": "integer",
|
||||
"minimum": 0
|
||||
},
|
||||
"capabilities": {
|
||||
"type": "object",
|
||||
"additionalProperties": false,
|
||||
"required": [
|
||||
"workspace",
|
||||
"temporaryFiles",
|
||||
"network",
|
||||
"credentials",
|
||||
"externalSideEffects"
|
||||
],
|
||||
"properties": {
|
||||
"workspace": {
|
||||
"enum": ["read", "write"]
|
||||
},
|
||||
"temporaryFiles": {
|
||||
"enum": ["deny", "write"]
|
||||
},
|
||||
"network": {
|
||||
"enum": ["deny", "explicit"]
|
||||
},
|
||||
"credentials": {
|
||||
"enum": ["deny", "explicit"]
|
||||
},
|
||||
"externalSideEffects": {
|
||||
"enum": ["deny", "confirm"]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"skillAssignment": {
|
||||
"type": "object",
|
||||
"additionalProperties": false,
|
||||
"required": ["defaultProfile", "allowedEscalations"],
|
||||
"properties": {
|
||||
"defaultProfile": {
|
||||
"type": "string",
|
||||
"minLength": 1
|
||||
},
|
||||
"allowedEscalations": {
|
||||
"type": "array",
|
||||
"uniqueItems": true,
|
||||
"items": {
|
||||
"type": "string",
|
||||
"minLength": 1
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@ import {
|
||||
existsSync,
|
||||
mkdirSync,
|
||||
mkdtempSync,
|
||||
readFileSync,
|
||||
readdirSync,
|
||||
rmSync,
|
||||
writeFileSync,
|
||||
@@ -52,6 +53,9 @@ test("published package relies on native commands and ships every skill", () =>
|
||||
"focused review metadata is published",
|
||||
);
|
||||
assert.ok(packaged.has("bin/opencode-power-pack.mjs"), "selective installer is published");
|
||||
assert.ok(packaged.has("bin/sandbox/policy.mjs"), "sandbox policy resolver is published");
|
||||
assert.ok(packaged.has("sandbox/contract.json"), "sandbox contract is published");
|
||||
assert.ok(packaged.has("sandbox/contract.schema.json"), "sandbox schema is published");
|
||||
assert.ok(packaged.has("skillsets.json"), "selective profiles are published");
|
||||
for (const prefix of ["evals/", "scripts/", "tests/", "docs/superpowers/"]) {
|
||||
assert.equal(
|
||||
@@ -121,6 +125,27 @@ test("packed npm artifact exposes a working selective-installer executable", ()
|
||||
assert.match(output, /Profiles:/);
|
||||
assert.match(output, /recommended/);
|
||||
assert.match(output, /code-review/);
|
||||
const sandboxOutput = execFileSync(executable, ["sandbox", "doctor"], {
|
||||
cwd: installRoot,
|
||||
encoding: "utf8",
|
||||
});
|
||||
assert.match(sandboxOutput, /Sandbox contract: valid/);
|
||||
assert.match(sandboxOutput, /Assigned skills: 54\/54/);
|
||||
assert.match(sandboxOutput, /Strict ready: no/);
|
||||
mkdirSync(join(installRoot, ".git"));
|
||||
execFileSync(executable, ["install", "code-review", "--project"], {
|
||||
cwd: installRoot,
|
||||
encoding: "utf8",
|
||||
});
|
||||
const installedPolicy = JSON.parse(
|
||||
readFileSync(
|
||||
join(installRoot, ".agents", "skills", "code-review", "SANDBOX_POLICY.json"),
|
||||
"utf8",
|
||||
),
|
||||
);
|
||||
assert.equal(installedPolicy.skill, "code-review");
|
||||
assert.equal(installedPolicy.profile.name, "observe");
|
||||
assert.equal(installedPolicy.enforcementLevel, "advisory");
|
||||
} finally {
|
||||
rmSync(packedRoot, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
@@ -0,0 +1,202 @@
|
||||
import { test } from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
import { readFile } from "node:fs/promises";
|
||||
import path from "node:path";
|
||||
import {
|
||||
discoverSkills,
|
||||
main,
|
||||
parseSandboxArgs,
|
||||
} from "../bin/opencode-power-pack.mjs";
|
||||
import {
|
||||
loadSandboxContract,
|
||||
portableSkillPolicy,
|
||||
resolveSandboxProfile,
|
||||
sandboxDoctorReport,
|
||||
validateSandboxContract,
|
||||
} from "../bin/sandbox/policy.mjs";
|
||||
|
||||
const REPO = process.env.REPO || process.cwd();
|
||||
|
||||
function clone(value) {
|
||||
return structuredClone(value);
|
||||
}
|
||||
|
||||
test("sandbox contract covers every packaged skill with four ordered profiles", async () => {
|
||||
const skills = await discoverSkills(REPO);
|
||||
const names = skills.map((skill) => skill.name);
|
||||
const contract = await loadSandboxContract(REPO, names);
|
||||
|
||||
assert.equal(contract.schemaVersion, 1);
|
||||
assert.equal(contract.enforcementLevel, "advisory");
|
||||
assert.deepEqual(Object.keys(contract.profiles), [
|
||||
"observe",
|
||||
"develop",
|
||||
"network-read",
|
||||
"publish",
|
||||
]);
|
||||
assert.equal(Object.keys(contract.skills).length, names.length);
|
||||
assert.deepEqual(Object.keys(contract.skills).sort(), names);
|
||||
assert.deepEqual(
|
||||
Object.values(contract.profiles).map((profile) => profile.riskLevel),
|
||||
[0, 1, 2, 3],
|
||||
);
|
||||
});
|
||||
|
||||
test("sandbox assignments preserve required writes and documented external modes", async () => {
|
||||
const contract = await loadSandboxContract(REPO);
|
||||
const expected = {
|
||||
"differential-review": ["develop", ["network-read"]],
|
||||
"security-threat-model": ["develop", []],
|
||||
"supply-chain-risk-auditor": ["develop", ["network-read"]],
|
||||
"security-review": ["observe", ["network-read", "publish"]],
|
||||
"huggingface-community-evals": ["network-read", ["publish"]],
|
||||
"huggingface-datasets": ["network-read", ["publish"]],
|
||||
"huggingface-papers": ["network-read", ["publish"]],
|
||||
"huggingface-tool-builder": ["develop", ["network-read", "publish"]],
|
||||
};
|
||||
|
||||
for (const [skillName, [defaultProfile, allowedEscalations]] of Object.entries(expected)) {
|
||||
assert.deepEqual(contract.skills[skillName], { defaultProfile, allowedEscalations }, skillName);
|
||||
}
|
||||
});
|
||||
|
||||
test("sandbox JSON schema mirrors the closed top-level contract", async () => {
|
||||
const schema = JSON.parse(
|
||||
await readFile(path.join(REPO, "sandbox", "contract.schema.json"), "utf8"),
|
||||
);
|
||||
|
||||
assert.equal(schema.additionalProperties, false);
|
||||
assert.deepEqual(schema.required, [
|
||||
"$schema",
|
||||
"schemaVersion",
|
||||
"enforcementLevel",
|
||||
"profiles",
|
||||
"skills",
|
||||
]);
|
||||
assert.equal(schema.properties.schemaVersion.const, 1);
|
||||
assert.equal(schema.properties.enforcementLevel.const, "advisory");
|
||||
assert.equal(schema.$defs.profile.additionalProperties, false);
|
||||
assert.equal(schema.$defs.skillAssignment.additionalProperties, false);
|
||||
});
|
||||
|
||||
test("sandbox validation rejects unknown fields, incomplete coverage, and unsafe escalations", async () => {
|
||||
const skills = await discoverSkills(REPO);
|
||||
const names = skills.map((skill) => skill.name);
|
||||
const contract = await loadSandboxContract(REPO, names);
|
||||
|
||||
const unknownField = clone(contract);
|
||||
unknownField.unexpected = true;
|
||||
assert.throws(() => validateSandboxContract(unknownField, names), /unknown field: unexpected/);
|
||||
|
||||
const incomplete = clone(contract);
|
||||
delete incomplete.skills[names[0]];
|
||||
assert.throws(() => validateSandboxContract(incomplete, names), /missing packaged skills/);
|
||||
|
||||
const downwardEscalation = clone(contract);
|
||||
downwardEscalation.skills["frontend-design"] = {
|
||||
defaultProfile: "develop",
|
||||
allowedEscalations: ["observe"],
|
||||
};
|
||||
assert.throws(() => validateSandboxContract(downwardEscalation, names), /must increase riskLevel/);
|
||||
|
||||
assert.throws(
|
||||
() => resolveSandboxProfile(contract, { skillName: "__proto__" }),
|
||||
/Unknown sandbox skill/,
|
||||
);
|
||||
assert.throws(
|
||||
() => resolveSandboxProfile(contract, { profileName: "toString" }),
|
||||
/Unknown sandbox profile/,
|
||||
);
|
||||
});
|
||||
|
||||
test("skill and direct-profile resolution report advisory capabilities explicitly", async () => {
|
||||
const contract = await loadSandboxContract(REPO);
|
||||
const skill = resolveSandboxProfile(contract, { skillName: "code-review" });
|
||||
|
||||
assert.equal(skill.skill, "code-review");
|
||||
assert.equal(skill.profile.name, "observe");
|
||||
assert.equal(skill.profile.enforcementLevel, "advisory");
|
||||
assert.deepEqual(
|
||||
skill.allowedEscalations.map((profile) => profile.name),
|
||||
["network-read", "publish"],
|
||||
);
|
||||
|
||||
const direct = resolveSandboxProfile(contract, { profileName: "publish" });
|
||||
assert.equal(direct.profile.capabilities.externalSideEffects, "confirm");
|
||||
assert.throws(
|
||||
() => resolveSandboxProfile(contract, { skillName: "code-review", profileName: "observe" }),
|
||||
/exactly one/,
|
||||
);
|
||||
});
|
||||
|
||||
test("portable policies remain self-describing and never claim enforcement", async () => {
|
||||
const contract = await loadSandboxContract(REPO);
|
||||
const policy = portableSkillPolicy(contract, "huggingface-spaces");
|
||||
|
||||
assert.equal(policy.schemaVersion, 1);
|
||||
assert.equal(policy.skill, "huggingface-spaces");
|
||||
assert.equal(policy.profile.name, "publish");
|
||||
assert.equal(policy.enforcementLevel, "advisory");
|
||||
assert.match(policy.warning, /advisory/i);
|
||||
});
|
||||
|
||||
test("sandbox doctor reports complete coverage and no configured backend", async () => {
|
||||
const skills = await discoverSkills(REPO);
|
||||
const names = skills.map((skill) => skill.name);
|
||||
const contract = await loadSandboxContract(REPO, names);
|
||||
const report = sandboxDoctorReport(contract, names);
|
||||
|
||||
assert.deepEqual(report, {
|
||||
ok: true,
|
||||
schemaVersion: 1,
|
||||
enforcementLevel: "advisory",
|
||||
backend: "not-configured",
|
||||
strictReady: false,
|
||||
profiles: 4,
|
||||
assignedSkills: 54,
|
||||
packagedSkills: 54,
|
||||
warnings: [
|
||||
"Capability profiles are advisory until an enforcement backend and host adapter are active.",
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
test("sandbox CLI supports deterministic text and JSON output", async () => {
|
||||
let output = "";
|
||||
const context = {
|
||||
cwd: REPO,
|
||||
home: REPO,
|
||||
packageRoot: REPO,
|
||||
write: (text) => { output += text; },
|
||||
};
|
||||
|
||||
assert.equal(await main(["sandbox", "doctor"], context), 0);
|
||||
assert.match(output, /Assigned skills: 54\/54/);
|
||||
assert.match(output, /Enforcement: advisory/);
|
||||
assert.match(output, /Strict ready: no/);
|
||||
|
||||
output = "";
|
||||
assert.equal(
|
||||
await main(["sandbox", "resolve", "--skill", "code-review", "--json"], context),
|
||||
0,
|
||||
);
|
||||
const resolution = JSON.parse(output);
|
||||
assert.equal(resolution.skill, "code-review");
|
||||
assert.equal(resolution.profile.name, "observe");
|
||||
assert.equal(resolution.profile.enforcementLevel, "advisory");
|
||||
});
|
||||
|
||||
test("sandbox CLI parser fails closed on ambiguous and malformed selectors", () => {
|
||||
assert.deepEqual(parseSandboxArgs(["doctor", "--json"]), {
|
||||
command: "doctor",
|
||||
json: true,
|
||||
});
|
||||
assert.throws(() => parseSandboxArgs([]), /doctor or resolve/);
|
||||
assert.throws(() => parseSandboxArgs(["missing"]), /Unknown sandbox command/);
|
||||
assert.throws(() => parseSandboxArgs(["resolve"]), /requires --skill or --sandbox-profile/);
|
||||
assert.throws(
|
||||
() => parseSandboxArgs(["resolve", "--skill", "code-review", "--sandbox-profile", "observe"]),
|
||||
/exactly one/,
|
||||
);
|
||||
assert.throws(() => parseSandboxArgs(["doctor", "--skill", "code-review"]), /only valid/);
|
||||
});
|
||||
@@ -118,6 +118,13 @@ test("installer copies only selected skills, skips existing skills, and replaces
|
||||
/Third-Party Notices/,
|
||||
);
|
||||
assert.ok((await readdir(path.join(destination, "code-review", "LICENSES"))).length > 0);
|
||||
const sandboxPolicy = JSON.parse(
|
||||
await readFile(path.join(destination, "code-review", "SANDBOX_POLICY.json"), "utf8"),
|
||||
);
|
||||
assert.equal(sandboxPolicy.skill, "code-review");
|
||||
assert.equal(sandboxPolicy.profile.name, "observe");
|
||||
assert.equal(sandboxPolicy.enforcementLevel, "advisory");
|
||||
assert.match(sandboxPolicy.warning, /advisory/i);
|
||||
|
||||
const sentinel = path.join(destination, "code-review", "stale.txt");
|
||||
await writeFile(sentinel, "stale", "utf8");
|
||||
|
||||
Reference in New Issue
Block a user