mirror of
https://github.com/waybarrios/opencode-power-pack.git
synced 2026-11-18 18:03:43 +00:00
317 lines
13 KiB
JavaScript
317 lines
13 KiB
JavaScript
import { test } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { readdirSync } from "node:fs";
|
|
import path from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
import plugin from "../.opencode/plugins/opencode-power-pack.js";
|
|
import { agents as agentPolicies, loadSkills } from "../.opencode/lib/agent-config.js";
|
|
|
|
const REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
|
|
const SKILLS_DIR = path.join(REPO, "skills");
|
|
const SKILL_NAMES = readdirSync(SKILLS_DIR, { withFileTypes: true })
|
|
.filter((entry) => entry.isDirectory())
|
|
.map((entry) => entry.name)
|
|
.sort();
|
|
|
|
function fakeEditor(entries = new Map()) {
|
|
return {
|
|
entries,
|
|
list: () => [...entries.values()],
|
|
get: (id) => entries.get(id),
|
|
add: (entry) => entries.set(entry.id, entry),
|
|
update: (id, update) => {
|
|
const draft = entries.get(id) ?? { id, permissions: [{ action: "*", resource: "*", effect: "allow" }] };
|
|
update(draft);
|
|
entries.set(id, draft);
|
|
},
|
|
remove: (id) => entries.delete(id),
|
|
};
|
|
}
|
|
|
|
test("V2 permission enforcement survives global allows and preserves later custom agents", async () => {
|
|
const skills = fakeEditor();
|
|
const agents = fakeEditor();
|
|
let evaluate;
|
|
await plugin.setup({
|
|
skill: { transform: async (callback) => callback(skills) },
|
|
agent: {
|
|
transform: async (callback) => callback(agents),
|
|
get: async ({ agentID }) => ({ data: agents.get(agentID) }),
|
|
},
|
|
session: { get: async () => ({ data: { agent: "code-explorer" } }) },
|
|
permission: { hook: async (name, callback) => {
|
|
assert.equal(name, "evaluate");
|
|
evaluate = callback;
|
|
} },
|
|
});
|
|
assert.equal(typeof evaluate, "function");
|
|
for (const name of ["code-explorer", "code-architect", "code-reviewer"]) {
|
|
// The real host applies global/configured agents after plugin transforms.
|
|
const agent = agents.get(name);
|
|
assert.equal(agent.permissions.some(({ effect }) => effect === "deny"), false,
|
|
"bundled defaults do not constrain a later user-defined agent");
|
|
agent.permissions.push({ action: "*", resource: "*", effect: "allow" });
|
|
for (const [action, resources] of [["edit", ["file.js"]], ["read", [".env"]],
|
|
["shell", ["rm -rf build"]], ["subagent", ["build"]]]) {
|
|
const event = { agent: name, action, resources, effect: "allow", sessionID: "ses_test" };
|
|
await evaluate(event);
|
|
assert.equal(event.effect, "deny", `${name} denies ${action} after global allow`);
|
|
}
|
|
}
|
|
const implicit = { action: "edit", resources: ["file.js"], effect: "allow", sessionID: "ses_test" };
|
|
await evaluate(implicit);
|
|
assert.equal(implicit.effect, "deny", "session agent is resolved when omitted");
|
|
for (const resource of ["git status; touch unexpected-file", "git status && touch unexpected-file",
|
|
"git log | sh", "git show $(touch unexpected-file)", "git status\ntouch unexpected-file"]) {
|
|
const event = { agent: "code-reviewer", action: "shell", resources: [resource], effect: "allow" };
|
|
await evaluate(event);
|
|
assert.equal(event.effect, "deny", "Git prefixes cannot authorize compound shell commands");
|
|
}
|
|
const unrelated = { agent: "toString", action: "edit", resources: ["file.js"], effect: "allow" };
|
|
await evaluate(unrelated);
|
|
assert.equal(unrelated.effect, "allow", "unrelated agent IDs cannot select inherited object properties");
|
|
for (const effect of ["ask", "deny"]) {
|
|
const event = { agent: "code-explorer", action: "read", resources: ["README.md"], effect };
|
|
await evaluate(event);
|
|
assert.equal(event.effect, effect, "the hook never grants additional access");
|
|
}
|
|
Object.assign(agents.get("code-reviewer"), { mode: "primary", system: "My custom assistant" });
|
|
const custom = { agent: "code-reviewer", action: "edit", resources: ["file.js"], effect: "allow" };
|
|
await evaluate(custom);
|
|
assert.equal(custom.effect, "allow", "a configured replacement keeps host permissions");
|
|
});
|
|
|
|
async function register() {
|
|
const skills = fakeEditor();
|
|
const agents = fakeEditor();
|
|
const context = contextFor(skills, agents);
|
|
await plugin.setup(context);
|
|
return { skills, agents };
|
|
}
|
|
|
|
function contextFor(skills, agents) {
|
|
return {
|
|
skill: { transform: async (callback) => callback(skills) },
|
|
agent: {
|
|
transform: async (callback) => callback(agents),
|
|
get: async ({ agentID }) => ({ data: agents.get(agentID) }),
|
|
},
|
|
permission: { hook: async () => {} },
|
|
};
|
|
}
|
|
|
|
test("plugin registers every bundled skill with the V2 Skill.Info shape", async () => {
|
|
const { skills } = await register();
|
|
|
|
assert.equal(plugin.id, "opencode-power-pack");
|
|
assert.equal(skills.list().length, SKILL_NAMES.length);
|
|
|
|
for (const name of SKILL_NAMES) {
|
|
const skill = skills.get(name);
|
|
assert.ok(skill, `${name} is registered`);
|
|
assert.equal(skill.id, name);
|
|
assert.match(skill.name, /\S/);
|
|
assert.match(skill.description, /\S/);
|
|
assert.equal(skill.path, path.join(SKILLS_DIR, name, "SKILL.md"));
|
|
assert.match(skill.content, /\S/);
|
|
assert.doesNotMatch(skill.content, /^---/, `${name} registers its body without frontmatter`);
|
|
}
|
|
|
|
assert.match(
|
|
skills.get("feature-dev").content,
|
|
/# Feature Development/,
|
|
"skill content keeps the workflow body",
|
|
);
|
|
});
|
|
|
|
test("a skill rejected by the host does not block the other skills or agents", async (t) => {
|
|
const skills = fakeEditor();
|
|
const agents = fakeEditor();
|
|
const add = skills.add;
|
|
skills.add = (skill) => {
|
|
if (skill.id === "code-reviewer") throw new Error("rejected by host");
|
|
add(skill);
|
|
};
|
|
const logged = t.mock.method(console, "error", () => {});
|
|
|
|
await assert.doesNotReject(() => plugin.setup(contextFor(skills, agents)));
|
|
|
|
assert.equal(skills.list().length, SKILL_NAMES.length - 1);
|
|
assert.equal(skills.get("code-reviewer"), undefined);
|
|
assert.ok(agents.get("code-reviewer"), "agents still register after a rejected skill");
|
|
assert.equal(logged.mock.callCount(), 1);
|
|
assert.match(String(logged.mock.calls[0].arguments[0]), /code-reviewer/);
|
|
});
|
|
|
|
test("plugin registers the feature workflow roles as read-only subagents", async () => {
|
|
const { agents } = await register();
|
|
|
|
for (const name of ["code-explorer", "code-architect", "code-reviewer"]) {
|
|
const agent = agents.get(name);
|
|
assert.ok(agent, `${name} is registered`);
|
|
assert.equal(agent.mode, "subagent");
|
|
assert.equal(agent.hidden, false);
|
|
assert.match(agent.description, /\S/);
|
|
assert.match(agent.system, /\S/);
|
|
assert.doesNotMatch(agent.system, /^---/);
|
|
|
|
const rule = (action, resource) => agentPolicies(loadSkills(SKILLS_DIR))[name].permissions
|
|
.filter((entry) => entry.action === action && entry.resource === resource)
|
|
.at(-1)?.effect;
|
|
assert.equal(rule("*", "*"), "deny", `${name} denies unlisted actions`);
|
|
assert.equal(rule("read", "*"), "allow");
|
|
assert.equal(rule("read", "*.env"), "deny");
|
|
assert.equal(rule("read", "*.env.*"), "deny");
|
|
assert.equal(rule("read", "*.env.example"), "allow");
|
|
assert.equal(rule("glob", "*"), "allow");
|
|
assert.equal(rule("grep", "*"), "allow");
|
|
assert.equal(rule("edit", "*"), "deny");
|
|
assert.equal(rule("subagent", "*"), "deny");
|
|
assert.equal(rule("webfetch", "*"), "deny");
|
|
assert.equal(rule("websearch", "*"), "deny");
|
|
assert.equal(rule("external_directory", "*"), "deny");
|
|
assert.equal(rule("shell", "*"), "deny");
|
|
}
|
|
|
|
assert.match(
|
|
agents.get("code-reviewer").system,
|
|
/Dispatched handoff/i,
|
|
"registered reviewer inherits the handoff contract",
|
|
);
|
|
|
|
const reviewer = agentPolicies(loadSkills(SKILLS_DIR))["code-reviewer"].permissions;
|
|
assert.deepEqual(
|
|
reviewer.filter(({ action }) => action === "shell"),
|
|
[
|
|
{ action: "shell", resource: "*", effect: "deny" },
|
|
{ action: "shell", resource: "git status*", effect: "allow" },
|
|
{ action: "shell", resource: "git diff*", effect: "allow" },
|
|
{ action: "shell", resource: "git show*", effect: "allow" },
|
|
{ action: "shell", resource: "git log*", effect: "allow" },
|
|
{ action: "shell", resource: "git blame*", effect: "allow" },
|
|
{ action: "shell", resource: "git rev-parse*", effect: "allow" },
|
|
{ action: "shell", resource: "git merge-base*", effect: "allow" },
|
|
{ action: "shell", resource: "git ls-files*", effect: "allow" },
|
|
{ action: "shell", resource: "git *--output*", effect: "deny" },
|
|
{ action: "shell", resource: "git *--ext-diff*", effect: "deny" },
|
|
{ action: "shell", resource: "git *>*", effect: "deny" },
|
|
],
|
|
"code-reviewer keeps the read-only Git allowlist and write-through denials",
|
|
);
|
|
});
|
|
|
|
test("plugin preserves agents registered before it", async () => {
|
|
const customReviewer = { id: "code-reviewer", name: "Custom", mode: "subagent" };
|
|
const skills = fakeEditor();
|
|
const agents = fakeEditor(new Map([["code-reviewer", customReviewer]]));
|
|
|
|
await plugin.setup(contextFor(skills, agents));
|
|
|
|
assert.equal(agents.get("code-reviewer"), customReviewer);
|
|
assert.ok(agents.get("code-explorer"), "other roles are still registered");
|
|
assert.ok(agents.get("code-architect"), "other roles are still registered");
|
|
});
|
|
|
|
test("plugin exposes the OpenCode 1 config hook for skills and agents", async () => {
|
|
const { config } = await plugin.server();
|
|
const target = {};
|
|
await config(target);
|
|
|
|
assert.deepEqual(target.skills.paths, [SKILLS_DIR]);
|
|
await config(target);
|
|
assert.deepEqual(target.skills.paths, [SKILLS_DIR], "skill path is registered once");
|
|
|
|
for (const name of ["code-explorer", "code-architect", "code-reviewer"]) {
|
|
const agent = target.agent[name];
|
|
assert.ok(agent, `${name} is registered`);
|
|
assert.equal(agent.mode, "subagent");
|
|
assert.equal(agent.permission.edit, "deny");
|
|
assert.equal(agent.permission.task, "deny");
|
|
assert.equal(agent.permission.webfetch, "deny");
|
|
if (name !== "code-reviewer") assert.equal(agent.permission.bash, "deny");
|
|
assert.deepEqual(agent.permission.read, {
|
|
"*": "allow",
|
|
"*.env": "deny",
|
|
"*.env.*": "deny",
|
|
"*.env.example": "allow",
|
|
});
|
|
assert.match(agent.description, /\S/);
|
|
assert.match(agent.prompt, /\S/);
|
|
assert.doesNotMatch(agent.prompt, /^---/);
|
|
}
|
|
|
|
assert.match(
|
|
target.agent["code-reviewer"].prompt,
|
|
/Dispatched handoff/i,
|
|
"registered reviewer inherits the handoff contract",
|
|
);
|
|
|
|
assert.deepEqual(target.agent["code-reviewer"].permission.bash, {
|
|
"*": "deny",
|
|
"git status*": "allow",
|
|
"git diff*": "allow",
|
|
"git show*": "allow",
|
|
"git log*": "allow",
|
|
"git blame*": "allow",
|
|
"git rev-parse*": "allow",
|
|
"git merge-base*": "allow",
|
|
"git ls-files*": "allow",
|
|
"git *--output*": "deny",
|
|
"git *--ext-diff*": "deny",
|
|
"git *>*": "deny",
|
|
});
|
|
});
|
|
|
|
test("OpenCode 1 config hook preserves user-defined agents", async () => {
|
|
const customReviewer = { description: "My reviewer", mode: "subagent" };
|
|
const target = { agent: { "code-reviewer": customReviewer } };
|
|
const { config } = await plugin.server();
|
|
|
|
await config(target);
|
|
|
|
assert.equal(target.agent["code-reviewer"], customReviewer);
|
|
assert.ok(target.agent["code-explorer"], "other roles are still registered");
|
|
assert.ok(target.agent["code-architect"], "other roles are still registered");
|
|
});
|
|
|
|
test("both hosts derive the same read-only rules from one permission source", async () => {
|
|
const { agents } = await register();
|
|
const target = {};
|
|
await (await plugin.server()).config(target);
|
|
|
|
assert.deepEqual(agentPolicies(loadSkills(SKILLS_DIR))["code-explorer"].permissions, [
|
|
{ action: "*", resource: "*", effect: "deny" },
|
|
{ action: "read", resource: "*", effect: "allow" },
|
|
{ action: "read", resource: "*.env", effect: "deny" },
|
|
{ action: "read", resource: "*.env.*", effect: "deny" },
|
|
{ action: "read", resource: "*.env.example", effect: "allow" },
|
|
{ action: "glob", resource: "*", effect: "allow" },
|
|
{ action: "grep", resource: "*", effect: "allow" },
|
|
{ action: "edit", resource: "*", effect: "deny" },
|
|
{ action: "subagent", resource: "*", effect: "deny" },
|
|
{ action: "webfetch", resource: "*", effect: "deny" },
|
|
{ action: "websearch", resource: "*", effect: "deny" },
|
|
{ action: "external_directory", resource: "*", effect: "deny" },
|
|
{ action: "shell", resource: "*", effect: "deny" },
|
|
]);
|
|
assert.equal(target.agent["code-explorer"].permission.list, "allow", "OpenCode 1 keeps its list tool");
|
|
});
|
|
|
|
test("host edits to one registered agent do not leak into others or later registrations", async () => {
|
|
// OpenCode 2 mutates host permission arrays after our registration.
|
|
const first = await register();
|
|
first.agents.get("code-explorer").permissions.push({ action: "edit", resource: "*", effect: "allow" });
|
|
assert.equal(first.agents.get("code-architect").permissions.at(-1).action, "*");
|
|
const second = await register();
|
|
assert.equal(second.agents.get("code-explorer").permissions.at(-1).action, "*");
|
|
|
|
const { config } = await plugin.server();
|
|
const legacy = {};
|
|
await config(legacy);
|
|
legacy.agent["code-explorer"].permission.read["*.env"] = "allow";
|
|
assert.equal(legacy.agent["code-architect"].permission.read["*.env"], "deny");
|
|
const fresh = {};
|
|
await config(fresh);
|
|
assert.equal(fresh.agent["code-explorer"].permission.read["*.env"], "deny");
|
|
});
|