489 lines
18 KiB
TypeScript
489 lines
18 KiB
TypeScript
import { expect, test } from "bun:test";
|
|
import { Effect } from "effect";
|
|
import { Agent } from "@opencode/schema/agent";
|
|
import { Session } from "@opencode/schema/session";
|
|
import { SessionMessage } from "@opencode/schema/session-message";
|
|
import { Tool } from "@opencode/schema/tool";
|
|
import type { Context } from "@opencode/plugin/effect/plugin";
|
|
import type { ToolEditor, ToolHooks } from "@opencode/plugin/effect/tool";
|
|
import type { AgentEditor } from "@opencode/plugin/effect/agent";
|
|
import type { SessionContext } from "@opencode/plugin/effect/session";
|
|
import { z } from "zod";
|
|
import { Herdr, type HerdrRoot } from "../src/multi-work/herdr.js";
|
|
import { bindingKey, bindingSchema, installMultiWork } from "../src/multi-work/multi-work.js";
|
|
|
|
class FixtureHerdr extends Herdr {
|
|
eligible = true;
|
|
rootWorkspaceID = "w1";
|
|
rootRepo = "/root/.git";
|
|
creations = 0;
|
|
verified = 0;
|
|
delayCreation = false;
|
|
creationAborted = false;
|
|
createdBase: string | undefined;
|
|
createdBranch: string | undefined;
|
|
createdLabel: string | undefined;
|
|
creationStarted = Promise.withResolvers<void>();
|
|
override async root(directory: string) {
|
|
return this.eligible && directory === "/root"
|
|
? { directory, workspaceID: this.rootWorkspaceID, repo: this.rootRepo }
|
|
: undefined;
|
|
}
|
|
override async create(
|
|
_root: HerdrRoot,
|
|
base: string,
|
|
branch: string,
|
|
signal: AbortSignal,
|
|
label?: string,
|
|
) {
|
|
this.creations++;
|
|
this.createdBase = base;
|
|
this.createdBranch = branch;
|
|
this.createdLabel = label;
|
|
if (!this.eligible) throw new Error("root closed");
|
|
if (this.delayCreation) {
|
|
this.creationStarted.resolve();
|
|
await new Promise<void>((_resolve, reject) => {
|
|
signal.addEventListener(
|
|
"abort",
|
|
() => {
|
|
this.creationAborted = true;
|
|
reject(new Error("creation interrupted"));
|
|
},
|
|
{ once: true },
|
|
);
|
|
});
|
|
}
|
|
return { directory: "/worktree", workspaceID: "w2", branch };
|
|
}
|
|
override async verify() {
|
|
this.verified++;
|
|
}
|
|
}
|
|
|
|
interface FixtureSession {
|
|
id: Session.ID;
|
|
projectID: string;
|
|
agent: string;
|
|
parentID: string | undefined;
|
|
location: { directory: string };
|
|
permissions: Agent.Info["permissions"];
|
|
}
|
|
|
|
const defaultInput = {
|
|
agent: "coordinate",
|
|
description: "test",
|
|
prompt: "work",
|
|
worktree: { base: "main" },
|
|
};
|
|
|
|
function required<T>(map: Map<string, T>, key: string) {
|
|
const value = map.get(key);
|
|
if (value === undefined) throw new Error(`Missing fixture entry ${key}`);
|
|
return value;
|
|
}
|
|
|
|
function fixture() {
|
|
const herdr = new FixtureHerdr();
|
|
const storage = new Map<string, Parameters<Context["storage"]["set"]>[1]>();
|
|
const agents = new Map<string, NonNullable<ReturnType<AgentEditor["get"]>>>();
|
|
for (const name of ["coordinate", "fast-lo", "fast-hi", "good-lo", "good-hi"])
|
|
agents.set(name, { ...Agent.Info.default(Agent.ID.make(name)), permissions: [] });
|
|
const parent: FixtureSession = {
|
|
id: Session.ID.make("ses_parent"),
|
|
projectID: "project-fixture",
|
|
agent: "multi-work",
|
|
parentID: undefined,
|
|
location: { directory: "/root" },
|
|
permissions: [],
|
|
};
|
|
const sessions = new Map([[String(parent.id), parent]]);
|
|
const order: string[] = [];
|
|
let cancelled = false;
|
|
let hold = false;
|
|
let delayMove = false;
|
|
let crossProject = false;
|
|
let destinationAvailable = true;
|
|
let warming = false;
|
|
let agentReads = 0;
|
|
let prompts = 0;
|
|
let serial = 0;
|
|
const entered = Promise.withResolvers<void>();
|
|
const progress: Tool.Metadata[] = [];
|
|
const native: Tool.Info = {
|
|
name: "subagent",
|
|
description: "native",
|
|
input: z.object({}),
|
|
options: { codemode: false },
|
|
execute: (raw, call) =>
|
|
Effect.gen(function* () {
|
|
const input = z
|
|
.object({
|
|
agent: z.string(),
|
|
sessionID: z.string().optional(),
|
|
background: z.boolean().optional(),
|
|
})
|
|
.parse(raw);
|
|
const id = Session.ID.make(input.sessionID ?? `ses_child${++serial}`);
|
|
if (input.sessionID === undefined || input.sessionID === "")
|
|
sessions.set(id, {
|
|
...parent,
|
|
id,
|
|
parentID: call.sessionID,
|
|
agent: input.agent,
|
|
location: { directory: "/root" },
|
|
});
|
|
order.push("create");
|
|
yield* call.progress({ sessionID: id, status: "running" });
|
|
order.push(`prompt:${required(sessions, id).location.directory}`);
|
|
prompts++;
|
|
entered.resolve();
|
|
if (hold)
|
|
yield* Effect.never.pipe(
|
|
Effect.onInterrupt(() =>
|
|
Effect.sync(() => {
|
|
cancelled = true;
|
|
}),
|
|
),
|
|
);
|
|
return {
|
|
content: "native result",
|
|
metadata: {
|
|
sessionID: id,
|
|
status: input.background === true ? "running" : "completed",
|
|
},
|
|
};
|
|
}),
|
|
};
|
|
let tool = native;
|
|
const toolHooks: ((event: ToolHooks["execute.before"]) => Effect.Effect<void, Tool.Error>)[] =
|
|
[];
|
|
const hooks: ((event: SessionContext) => Effect.Effect<void>)[] = [];
|
|
let prompt!: (event: Pick<SessionContext, "sessionID">) => Effect.Effect<void>;
|
|
let transform: ((editor: AgentEditor) => void) | undefined;
|
|
const registration = Effect.succeed({ dispose: Effect.void });
|
|
const editAgents = (): AgentEditor => ({
|
|
get: (id) => agents.get(id),
|
|
list: () => [...agents.values()],
|
|
default() {},
|
|
remove(id) {
|
|
agents.delete(id);
|
|
},
|
|
update(id, update) {
|
|
// SAFETY: Agent.Info.default returns a fresh draft that the fixture exclusively owns.
|
|
const agent = (agents.get(id) ?? Agent.Info.default(Agent.ID.make(id))) as NonNullable<
|
|
ReturnType<AgentEditor["get"]>
|
|
>;
|
|
update(agent);
|
|
agents.set(id, agent);
|
|
},
|
|
});
|
|
const editTools: ToolEditor = {
|
|
list: () => [{ ...tool, id: tool.name }],
|
|
get: () => ({ ...tool, id: tool.name }),
|
|
add() {},
|
|
namespace() {},
|
|
remove() {},
|
|
update(_id, update) {
|
|
const draft = { ...tool };
|
|
update(draft);
|
|
tool = draft;
|
|
},
|
|
};
|
|
const host = {
|
|
options: {},
|
|
location: { directory: "/root" },
|
|
storage: {
|
|
get: (key: string) => Effect.sync(() => storage.get(key)),
|
|
set: (key: string, value: Parameters<Context["storage"]["set"]>[1]) =>
|
|
Effect.sync(() => {
|
|
storage.set(key, value);
|
|
}),
|
|
},
|
|
agent: {
|
|
transform: (callback: (editor: AgentEditor) => void) =>
|
|
Effect.sync(() => {
|
|
transform = callback;
|
|
callback(editAgents());
|
|
}).pipe(Effect.andThen(registration)),
|
|
reload: () =>
|
|
Effect.sync(() => {
|
|
transform?.(editAgents());
|
|
}),
|
|
get: () => Effect.succeed({ data: required(agents, "multi-work") }),
|
|
list: () =>
|
|
Effect.sync(() => {
|
|
agentReads++;
|
|
if (!destinationAvailable) throw new Error("Destination location unavailable");
|
|
return { data: warming && agentReads === 1 ? [] : [...agents.values()] };
|
|
}),
|
|
},
|
|
session: {
|
|
get: ({ sessionID }: { sessionID: string }) =>
|
|
Effect.sync(() => required(sessions, sessionID)),
|
|
move: ({ sessionID, directory }: { sessionID: string; directory: string }) =>
|
|
Effect.sync(() => {
|
|
order.push("move-request");
|
|
if (!delayMove) {
|
|
required(sessions, sessionID).location.directory = directory;
|
|
order.push("moved");
|
|
if (crossProject)
|
|
required(sessions, sessionID).projectID = "another-project";
|
|
}
|
|
entered.resolve();
|
|
}),
|
|
hook: (name: string, callback: (event: SessionContext) => Effect.Effect<void>) =>
|
|
Effect.sync(() => {
|
|
if (name === "context") hooks.push(callback);
|
|
if (name === "prompt") {
|
|
// SAFETY: The prompt admission hook reads only the native session ID.
|
|
prompt = callback as typeof prompt;
|
|
}
|
|
}).pipe(Effect.andThen(registration)),
|
|
},
|
|
tool: {
|
|
transform: (callback: (editor: ToolEditor) => void) =>
|
|
Effect.sync(() => callback(editTools)).pipe(Effect.andThen(registration)),
|
|
hook: (
|
|
_name: string,
|
|
callback: (event: ToolHooks["execute.before"]) => Effect.Effect<void, Tool.Error>,
|
|
) =>
|
|
Effect.sync(() => {
|
|
toolHooks.push(callback);
|
|
}).pipe(Effect.andThen(registration)),
|
|
},
|
|
};
|
|
// SAFETY: The test setup only receives its exercised services; unexpected host dependencies fail loudly.
|
|
const install = installMultiWork as (
|
|
context: Pick<Context, "options">,
|
|
buildPermissions: () => Agent.Info["permissions"],
|
|
herdr: Herdr,
|
|
) => ReturnType<typeof installMultiWork>;
|
|
const call: Tool.Context = {
|
|
sessionID: parent.id,
|
|
agent: Agent.ID.make("multi-work"),
|
|
messageID: SessionMessage.ID.make("msg_test"),
|
|
id: Tool.CallID.make("call_test"),
|
|
progress: (value) =>
|
|
Effect.sync(() => {
|
|
progress.push(value);
|
|
}),
|
|
};
|
|
return {
|
|
herdr,
|
|
agents,
|
|
sessions,
|
|
parent,
|
|
storage,
|
|
order,
|
|
entered,
|
|
hooks,
|
|
prompt: (event: Pick<SessionContext, "sessionID">) => prompt(event),
|
|
toolHooks,
|
|
call,
|
|
progress,
|
|
install: install(
|
|
host,
|
|
() =>
|
|
agents.get("build")?.permissions ??
|
|
Agent.Info.default(Agent.ID.make("build")).permissions,
|
|
herdr,
|
|
),
|
|
invoke: (input = defaultInput, caller = call) => tool.execute(input, caller),
|
|
execute: (input: z.infer<typeof request>, caller = call) => tool.execute(input, caller),
|
|
hold() {
|
|
hold = true;
|
|
},
|
|
delayMove() {
|
|
delayMove = true;
|
|
},
|
|
missingDestination() {
|
|
destinationAvailable = false;
|
|
},
|
|
crossProject() {
|
|
crossProject = true;
|
|
},
|
|
warmDestination() {
|
|
warming = true;
|
|
},
|
|
get agentReads() {
|
|
return agentReads;
|
|
},
|
|
get cancelled() {
|
|
return cancelled;
|
|
},
|
|
get prompts() {
|
|
return prompts;
|
|
},
|
|
get tool() {
|
|
return tool;
|
|
},
|
|
};
|
|
}
|
|
const request = z.object({
|
|
agent: z.string(),
|
|
description: z.string(),
|
|
prompt: z.string(),
|
|
worktree: z
|
|
.object({
|
|
base: z.string(),
|
|
branch: z.string().optional(),
|
|
label: z.string().optional(),
|
|
})
|
|
.optional(),
|
|
sessionID: z.string().optional(),
|
|
background: z.boolean().optional(),
|
|
});
|
|
|
|
test("coordinate can create and resume a root-local background child without Herdr creation or movement", async () => {
|
|
const f = fixture();
|
|
f.parent.permissions = [{ action: "herdr_worktree", resource: "*", effect: "deny" }];
|
|
await Effect.runPromise(
|
|
Effect.scoped(
|
|
Effect.gen(function* () {
|
|
yield* f.install;
|
|
const created = yield* f.execute({
|
|
agent: "coordinate",
|
|
description: "local edit",
|
|
prompt: "edit assigned files",
|
|
background: true,
|
|
});
|
|
expect(created.metadata).toMatchObject({
|
|
sessionID: "ses_child1",
|
|
status: "running",
|
|
directory: "/root",
|
|
workspaceID: "w1",
|
|
branch: "root",
|
|
});
|
|
expect(f.herdr.creations).toBe(0);
|
|
expect(f.order).toEqual(["create", "prompt:/root"]);
|
|
expect(bindingSchema.parse(f.storage.get(bindingKey("ses_child1")))).toMatchObject({
|
|
owner: "ses_parent",
|
|
directory: "/root",
|
|
workspaceID: "w1",
|
|
branch: "root",
|
|
ready: true,
|
|
});
|
|
yield* f.execute({
|
|
agent: "coordinate",
|
|
description: "resume local",
|
|
prompt: "continue",
|
|
sessionID: "ses_child1",
|
|
});
|
|
expect(f.herdr.creations).toBe(0);
|
|
expect(f.herdr.verified).toBe(0);
|
|
}),
|
|
),
|
|
);
|
|
});
|
|
|
|
test("root-local resume rejects location, binding, and live-root changes", async () => {
|
|
for (const tamper of ["session", "workspace", "root", "branch", "live-root"] as const) {
|
|
const f = fixture();
|
|
await Effect.runPromise(
|
|
Effect.scoped(
|
|
Effect.gen(function* () {
|
|
yield* f.install;
|
|
yield* f.execute({
|
|
agent: "coordinate",
|
|
description: "local edit",
|
|
prompt: "work",
|
|
});
|
|
if (tamper === "session")
|
|
required(f.sessions, "ses_child1").location.directory = "/other";
|
|
else if (tamper === "live-root") f.herdr.rootWorkspaceID = "foreign";
|
|
else {
|
|
const binding = bindingSchema.parse(
|
|
f.storage.get(bindingKey("ses_child1")),
|
|
);
|
|
const changed = { ...binding };
|
|
if (tamper === "workspace") changed.workspaceID = "foreign";
|
|
if (tamper === "root") {
|
|
changed.root = { ...binding.root, workspaceID: "foreign" };
|
|
changed.workspaceID = "foreign";
|
|
}
|
|
if (tamper === "branch") changed.branch = "main";
|
|
f.storage.set(bindingKey("ses_child1"), changed);
|
|
}
|
|
expect(
|
|
(yield* Effect.exit(
|
|
f.execute({
|
|
agent: "coordinate",
|
|
description: "resume",
|
|
prompt: "continue",
|
|
sessionID: "ses_child1",
|
|
}),
|
|
))._tag,
|
|
).toBe("Failure");
|
|
expect(f.prompts).toBe(1);
|
|
}),
|
|
),
|
|
);
|
|
}
|
|
});
|
|
|
|
test("interrupted root-local creation retains its binding and cannot be blindly replayed", async () => {
|
|
const f = fixture();
|
|
f.hold();
|
|
const controller = new AbortController();
|
|
const running = Effect.runPromise(
|
|
Effect.scoped(
|
|
Effect.gen(function* () {
|
|
yield* f.install;
|
|
return yield* f.execute({
|
|
agent: "coordinate",
|
|
description: "local edit",
|
|
prompt: "work",
|
|
});
|
|
}),
|
|
),
|
|
{ signal: controller.signal },
|
|
);
|
|
await f.entered.promise;
|
|
controller.abort();
|
|
await expect(running).rejects.toBeDefined();
|
|
expect(bindingSchema.parse(f.storage.get(bindingKey("ses_child1"))).ready).toBe(true);
|
|
expect(f.storage.has(`multi-work-call:${f.call.sessionID}:${f.call.id}`)).toBe(true);
|
|
const replay = await Effect.runPromise(
|
|
Effect.exit(
|
|
f.execute({
|
|
agent: "coordinate",
|
|
description: "local edit",
|
|
prompt: "work",
|
|
}),
|
|
),
|
|
);
|
|
expect(replay._tag).toBe("Failure");
|
|
expect(f.prompts).toBe(1);
|
|
});
|
|
|
|
test("root loss, session permission denial and missing destination fail before prompting", async () => {
|
|
for (const failure of ["root", "permission", "ask", "destination", "project"] as const) {
|
|
const f = fixture();
|
|
await Effect.runPromise(
|
|
Effect.scoped(
|
|
Effect.gen(function* () {
|
|
yield* f.install;
|
|
if (failure === "root") f.herdr.eligible = false;
|
|
if (failure === "permission")
|
|
f.parent.permissions = [
|
|
{ action: "herdr_worktree", resource: "*", effect: "deny" },
|
|
];
|
|
if (failure === "destination") f.missingDestination();
|
|
if (failure === "project") f.crossProject();
|
|
if (failure === "ask")
|
|
f.parent.permissions = [
|
|
{ action: "herdr_worktree", resource: "*", effect: "ask" },
|
|
];
|
|
const result = yield* Effect.exit(f.invoke());
|
|
expect(result._tag).toBe("Failure");
|
|
expect(f.prompts).toBe(0);
|
|
expect(f.herdr.creations).toBe(
|
|
failure === "destination" || failure === "project" ? 1 : 0,
|
|
);
|
|
}),
|
|
),
|
|
);
|
|
}
|
|
});
|