398 lines
19 KiB
TypeScript
398 lines
19 KiB
TypeScript
import { Agent, Model, Plugin, Provider } from "@opencode/plugin";
|
|
import type { RpcRegistration } from "@opencode/plugin/promise/rpc";
|
|
import type { ModelInfo } from "@opencode/client";
|
|
import { z } from "zod";
|
|
import { gptAgents, settings, workerNames } from "./config.js";
|
|
import { discover } from "./provider.js";
|
|
import { descriptions, routingGuide } from "./routing.js";
|
|
import { QuotaTracker } from "./quota.js";
|
|
import { QuotaRpc } from "./quota-rpc.js";
|
|
import { playwrightMcpCommand } from "./playwright.js";
|
|
import { Plugin as EffectPlugin } from "@opencode/plugin/effect";
|
|
import { fromPromise } from "@opencode/plugin/promise/adapter";
|
|
import { Effect } from "effect";
|
|
import { bindingKey, bindingSchema, installMultiWork } from "./multi-work.js";
|
|
|
|
// Permission actions use wildcards, not filesystem globs.
|
|
function matches(value: string, pattern: string) {
|
|
const escaped = pattern
|
|
.replace(/[.+^${}()|[\]\\]/g, "\\$&")
|
|
.replace(/\*/g, ".*")
|
|
.replace(/\?/g, ".");
|
|
return new RegExp(`^${escaped}$`, "s").test(value);
|
|
}
|
|
|
|
const reading = [
|
|
"read",
|
|
"glob",
|
|
"grep",
|
|
"list",
|
|
"todoread",
|
|
"todowrite",
|
|
"webfetch",
|
|
"websearch",
|
|
"question",
|
|
"external_directory",
|
|
"doom_loop",
|
|
];
|
|
const delegation = z.object({ agent: z.string() });
|
|
const todos = z.array(
|
|
z.object({
|
|
id: z.string(),
|
|
content: z.string(),
|
|
status: z.enum(["pending", "in_progress", "completed", "cancelled"]),
|
|
priority: z.enum(["high", "medium", "low"]),
|
|
}),
|
|
);
|
|
|
|
const makeBasePlugin = (permissionsChanged: (permissions: Agent.Info["permissions"]) => void) =>
|
|
Plugin.define({
|
|
id: "stanp-opencode",
|
|
async setup(context) {
|
|
const selected = settings.parse({ mode: "gpt", ...context.options });
|
|
let models = new Map<string, { model: ModelInfo; serviceTier: string | undefined }>();
|
|
let inherited: Agent.Info["permissions"] = Agent.Info.default(
|
|
Agent.ID.make("build"),
|
|
).permissions;
|
|
let permissionKey = JSON.stringify(inherited);
|
|
let hasCodegraph = false;
|
|
let codegraphTools: string[] = [];
|
|
let agentTransformReady = false;
|
|
const controller = new AbortController();
|
|
let quotaRegistration: RpcRegistration<typeof QuotaRpc> | undefined;
|
|
const quota = new QuotaTracker(context, async () => {
|
|
await quotaRegistration?.events.emit("updated", {});
|
|
});
|
|
quotaRegistration = await context.rpc.register(QuotaRpc, {
|
|
status: async () => quota.status() ?? null,
|
|
});
|
|
await quota.init();
|
|
// Subscribe before the first read: configuration can publish its models while
|
|
// asynchronous setup is running.
|
|
const updates = (async () => {
|
|
for await (const event of context.event.subscribe({ signal: controller.signal })) {
|
|
if (event.location) {
|
|
const workspaceID =
|
|
"workspaceID" in event.location
|
|
? event.location.workspaceID
|
|
: undefined;
|
|
if (
|
|
event.location.directory !== context.location.directory ||
|
|
workspaceID !== context.location.workspaceID
|
|
)
|
|
continue;
|
|
}
|
|
if (event.type === "model.updated") {
|
|
models = await discover(context, selected.provider);
|
|
await context.agent.reload();
|
|
} else if (event.type === "agent.updated") {
|
|
// The configured build transform may run after ours. Read the final
|
|
// registry, then replay only when its effective permissions change.
|
|
const { data } = await context.agent.list();
|
|
const permissions =
|
|
data.find((agent) => agent.id === "build")?.permissions ??
|
|
Agent.Info.default(Agent.ID.make("build")).permissions;
|
|
const key = JSON.stringify(permissions);
|
|
if (key === permissionKey) continue;
|
|
inherited = permissions;
|
|
permissionsChanged(inherited);
|
|
permissionKey = key;
|
|
await context.agent.reload();
|
|
} else if (
|
|
event.type === "session.execution.succeeded" ||
|
|
event.type === "session.execution.failed" ||
|
|
event.type === "session.execution.interrupted" ||
|
|
event.type === "session.idle"
|
|
) {
|
|
await quota.complete(event.data.sessionID);
|
|
} else if (event.type === "credential.updated") {
|
|
await quota.authChanged();
|
|
} else if (
|
|
event.type === "credential.switched" &&
|
|
String(event.data.integrationID) === "openai"
|
|
) {
|
|
await quota.authChanged(true);
|
|
}
|
|
}
|
|
})().catch((error) => {
|
|
if (!controller.signal.aborted)
|
|
console.error("stanp-opencode model update failed", error);
|
|
});
|
|
models = await discover(context, selected.provider);
|
|
const { data: initialAgents } = await context.agent.list();
|
|
inherited =
|
|
initialAgents.find((agent) => agent.id === "build")?.permissions ?? inherited;
|
|
permissionsChanged(inherited);
|
|
permissionKey = JSON.stringify(inherited);
|
|
const assignments = selected.mode === "gpt" ? gptAgents : selected.agents;
|
|
let workers: (typeof workerNames)[number][] = [];
|
|
const active = new Set<string>();
|
|
const playwrightCommand = selected.playwright
|
|
? await playwrightMcpCommand(context.location.directory)
|
|
: undefined;
|
|
|
|
await context.mcp.transform((editor) => {
|
|
if (playwrightCommand && !editor.get("playwright"))
|
|
editor.set("playwright", {
|
|
type: "local",
|
|
command: playwrightCommand,
|
|
timeout: { startup: 300_000 },
|
|
});
|
|
hasCodegraph = editor.get("codegraph") !== undefined;
|
|
if (hasCodegraph)
|
|
editor.update("codegraph", (server) => {
|
|
server.codemode = false;
|
|
});
|
|
});
|
|
await context.tool.transform((editor) => {
|
|
const next = editor
|
|
.list()
|
|
.map((tool) => tool.id)
|
|
.filter((id) => id.startsWith("codegraph_"))
|
|
.sort();
|
|
if (JSON.stringify(next) === JSON.stringify(codegraphTools)) return;
|
|
codegraphTools = next;
|
|
if (agentTransformReady)
|
|
queueMicrotask(() => {
|
|
void context.agent
|
|
.reload()
|
|
.catch((error) =>
|
|
console.error("stanp-opencode agent reload failed", error),
|
|
);
|
|
});
|
|
});
|
|
|
|
await context.agent.transform((editor) => {
|
|
const deep = models.has(assignments["deep-lo"].model);
|
|
const candidates = workerNames.filter((name) => deep || !name.startsWith("deep-"));
|
|
const coordinate = assignments[deep ? "deep-lo" : "good-lo"];
|
|
workers = [coordinate, ...candidates.map((name) => assignments[name])].every(
|
|
({ model }) => models.has(model),
|
|
)
|
|
? candidates
|
|
: [];
|
|
active.clear();
|
|
for (const name of workers) active.add(name);
|
|
if (workers.length === 0) return;
|
|
for (const name of workers) {
|
|
const assignment = assignments[name];
|
|
const available = models.get(assignment.model)!;
|
|
editor.update(name, (agent) => {
|
|
const hasVariant = available.model.variants.some(
|
|
({ id }) => id === assignment.effort,
|
|
);
|
|
agent.name = Agent.Name.make(name);
|
|
agent.mode = "subagent";
|
|
agent.hidden = false;
|
|
agent.description = descriptions[name];
|
|
agent.model = {
|
|
providerID: Provider.ID.make(available.model.providerID),
|
|
id: Model.ID.make(available.model.id),
|
|
};
|
|
if (hasVariant)
|
|
agent.model.variant = Model.VariantID.make(assignment.effort);
|
|
agent.request = {
|
|
settings: hasVariant ? {} : { reasoningEffort: assignment.effort },
|
|
headers: {},
|
|
body: {},
|
|
};
|
|
if (selected.lunaPriority && available.serviceTier)
|
|
agent.request.settings.serviceTier = available.serviceTier;
|
|
agent.permissions = [
|
|
...structuredClone(inherited),
|
|
{ action: "subagent", resource: "*", effect: "deny" },
|
|
];
|
|
});
|
|
}
|
|
editor.update("coordinate", (agent) => {
|
|
const available = models.get(coordinate.model)!;
|
|
const hasVariant = available.model.variants.some(
|
|
({ id }) => id === coordinate.effort,
|
|
);
|
|
agent.name = Agent.Name.make("coordinate");
|
|
agent.mode = "primary";
|
|
agent.hidden = false;
|
|
agent.description =
|
|
"Read, plan, and coordinate specialist workers; never implement directly.";
|
|
agent.model = {
|
|
providerID: Provider.ID.make(available.model.providerID),
|
|
id: Model.ID.make(available.model.id),
|
|
};
|
|
if (hasVariant) agent.model.variant = Model.VariantID.make(coordinate.effort);
|
|
agent.request = {
|
|
settings: hasVariant ? {} : { reasoningEffort: coordinate.effort },
|
|
headers: {},
|
|
body: {},
|
|
};
|
|
agent.system = routingGuide(deep);
|
|
agent.permissions = [
|
|
{ action: "*", resource: "*", effect: "deny" },
|
|
...reading.flatMap((action) =>
|
|
inherited
|
|
.filter((rule) => matches(action, rule.action))
|
|
.map((rule) => ({ ...rule, action })),
|
|
),
|
|
...(hasCodegraph
|
|
? codegraphTools.flatMap((action) =>
|
|
inherited
|
|
.filter((rule) => matches(action, rule.action))
|
|
.map((rule) => ({ ...rule, action })),
|
|
)
|
|
: []),
|
|
...workers.map((resource) => ({
|
|
action: "subagent",
|
|
resource,
|
|
effect: "allow" as const,
|
|
})),
|
|
];
|
|
});
|
|
});
|
|
agentTransformReady = true;
|
|
async function assertTodo(agentID: Agent.ID, action: string) {
|
|
const { data: agent } = await context.agent.get({ agentID });
|
|
const effect =
|
|
agent.permissions.findLast(
|
|
(rule) => matches(action, rule.action) && matches("*", rule.resource),
|
|
)?.effect ?? "ask";
|
|
if (effect !== "allow")
|
|
throw new Error(
|
|
`${action} requires an allow permission: OpenCode's public plugin API cannot request custom-tool permission approval (${effect}).`,
|
|
);
|
|
}
|
|
await context.tool.transform((editor) => {
|
|
if (!editor.get("todowrite"))
|
|
editor.add({
|
|
name: "todowrite",
|
|
description:
|
|
"Replace this session's todo list to track the work and its progress.",
|
|
input: z.object({ todos }),
|
|
options: { codemode: false },
|
|
async execute(input, tool) {
|
|
await assertTodo(tool.agent, "todowrite");
|
|
await context.storage.set(`todos:${tool.sessionID}`, input.todos);
|
|
return { content: JSON.stringify(input.todos) };
|
|
},
|
|
});
|
|
if (!editor.get("todoread"))
|
|
editor.add({
|
|
name: "todoread",
|
|
description: "Read this session's todo list.",
|
|
input: z.object({}),
|
|
options: { codemode: false },
|
|
async execute(_input, tool) {
|
|
await assertTodo(tool.agent, "todoread");
|
|
const stored = await context.storage.get(`todos:${tool.sessionID}`);
|
|
return {
|
|
content: JSON.stringify(
|
|
stored === undefined ? [] : todos.parse(stored),
|
|
),
|
|
};
|
|
},
|
|
});
|
|
});
|
|
await context.session.hook("context", (event) => {
|
|
if (workerNames.some((name) => name === event.agent)) {
|
|
delete event.tools.subagent;
|
|
return;
|
|
}
|
|
const tool = event.tools.subagent;
|
|
if (event.agent === "coordinate" && workers.length === 0) {
|
|
delete event.tools.subagent;
|
|
return;
|
|
}
|
|
if (event.agent !== "coordinate" || !tool) return;
|
|
tool.description = `Delegate a self-contained assignment to one of these workers:\n${workers.map((name) => `- ${name}: ${descriptions[name]}`).join("\n")}`;
|
|
// The executable definition remains native; constrain only this request's schema.
|
|
const properties = z
|
|
.record(z.string(), z.unknown())
|
|
.parse(tool.input.properties ?? {});
|
|
tool.input = {
|
|
...tool.input,
|
|
properties: { ...properties, agent: { type: "string", enum: workers } },
|
|
};
|
|
});
|
|
await context.session.hook("model.request", async (event) =>
|
|
quota.start(event.sessionID),
|
|
);
|
|
await context.tool.hook("execute.before", (event) => {
|
|
if (event.tool !== "subagent") return;
|
|
const { agent } = delegation.parse(event.input);
|
|
if (agent === "multi-work") throw new Error("multi-work is primary only");
|
|
if (agent === "coordinate" && event.agent !== "multi-work")
|
|
throw new Error(
|
|
"coordinate cannot run as a subagent without a ready worktree binding",
|
|
);
|
|
if (workerNames.some((name) => name === event.agent))
|
|
throw new Error("Workers cannot delegate tasks");
|
|
if (event.agent === "coordinate" && !active.has(agent))
|
|
throw new Error("coordinate may delegate only to its available workers");
|
|
});
|
|
// Commands can create child sessions without going through the subagent tool.
|
|
await context.session.hook("prompt", async (event) => {
|
|
const child = await context.session.get({ sessionID: event.sessionID });
|
|
if (!child.parentID) return;
|
|
if (child.agent === "multi-work") throw new Error("multi-work is primary only");
|
|
const parent = await context.session.get({ sessionID: child.parentID });
|
|
if (child.agent === "coordinate") {
|
|
const binding = bindingSchema.safeParse(
|
|
await context.storage.get(bindingKey(event.sessionID)),
|
|
);
|
|
if (
|
|
!binding.success ||
|
|
!binding.data.ready ||
|
|
binding.data.child !== event.sessionID ||
|
|
binding.data.owner !== child.parentID ||
|
|
binding.data.projectID !== child.projectID ||
|
|
binding.data.projectID !== parent.projectID ||
|
|
parent.agent !== "multi-work" ||
|
|
child.location.directory !== binding.data.directory ||
|
|
parent.location.directory !== binding.data.root.directory
|
|
)
|
|
throw new Error(
|
|
"coordinate cannot run as a subagent without a ready worktree binding",
|
|
);
|
|
}
|
|
if (
|
|
parent.agent === "multi-work" &&
|
|
child.agent !== "coordinate" &&
|
|
(child.agent !== "fast-lo" ||
|
|
child.location.directory !== parent.location.directory)
|
|
)
|
|
throw new Error(
|
|
"multi-work may delegate only to local fast-lo or a bound coordinate child",
|
|
);
|
|
if (workerNames.some((name) => name === parent.agent))
|
|
throw new Error("Workers cannot delegate tasks");
|
|
if (
|
|
parent.agent === "coordinate" &&
|
|
(child.agent === undefined || !active.has(child.agent))
|
|
)
|
|
throw new Error("coordinate may delegate only to its available workers");
|
|
});
|
|
return async () => {
|
|
controller.abort();
|
|
await updates;
|
|
await quota.dispose();
|
|
await quotaRegistration?.dispose();
|
|
};
|
|
},
|
|
});
|
|
|
|
export const basePlugin = makeBasePlugin(() => {});
|
|
|
|
export default EffectPlugin.define({
|
|
id: "stanp-opencode",
|
|
effect: (context) =>
|
|
Effect.gen(function* () {
|
|
let inherited: Agent.Info["permissions"] = Agent.Info.default(
|
|
Agent.ID.make("build"),
|
|
).permissions;
|
|
yield* fromPromise(
|
|
makeBasePlugin((permissions) => {
|
|
inherited = permissions;
|
|
}),
|
|
).effect(context);
|
|
yield* installMultiWork(context, () => inherited);
|
|
}),
|
|
});
|