YeonGyu-Kim
518 lines
17 KiB
TypeScript
518 lines
17 KiB
TypeScript
/// <reference types="bun-types" />
|
|
|
|
import { afterEach, beforeEach, describe, expect, it, mock, afterAll, spyOn } from "bun:test"
|
|
import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
|
|
import { tmpdir } from "node:os"
|
|
import { join } from "node:path"
|
|
import type { PluginInput } from "@opencode-ai/plugin"
|
|
import type { Project } from "@opencode-ai/sdk"
|
|
import { readBoulderState, writeBoulderState } from "../../features/boulder-state"
|
|
import { createToolExecuteBeforeHandler } from "./tool-execute-before"
|
|
|
|
const isCallerOrchestratorMock = mock(async () => true)
|
|
const collectGitDiffStatsMock = mock(() => ({
|
|
filesChanged: 0,
|
|
insertions: 0,
|
|
deletions: 0,
|
|
}))
|
|
|
|
mock.module("../../shared/session-utils", () => ({
|
|
isCallerOrchestrator: isCallerOrchestratorMock,
|
|
}))
|
|
|
|
mock.module("../../shared/git-worktree", () => ({
|
|
collectGitDiffStats: collectGitDiffStatsMock,
|
|
formatFileChanges: mock(() => "No file changes"),
|
|
}))
|
|
|
|
afterAll(() => { mock.restore() })
|
|
|
|
const { createToolExecuteAfterHandler } = await import("./tool-execute-after")
|
|
|
|
type SessionGetInput = { path: { id: string } }
|
|
type SessionGetResult = {
|
|
data: { parentID: string | undefined }
|
|
error?: undefined
|
|
request: Request
|
|
response: Response
|
|
}
|
|
|
|
describe("createToolExecuteAfterHandler background launch detection", () => {
|
|
let testDirectory = ""
|
|
|
|
beforeEach(() => {
|
|
testDirectory = join(tmpdir(), `atlas-background-launch-${crypto.randomUUID()}`)
|
|
|
|
if (!existsSync(testDirectory)) {
|
|
mkdirSync(testDirectory, { recursive: true })
|
|
}
|
|
|
|
isCallerOrchestratorMock.mockClear()
|
|
collectGitDiffStatsMock.mockClear()
|
|
})
|
|
|
|
afterEach(() => {
|
|
if (testDirectory && existsSync(testDirectory)) {
|
|
rmSync(testDirectory, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
function createProject(): Project {
|
|
return {
|
|
id: "project-1",
|
|
worktree: testDirectory,
|
|
time: {
|
|
created: Date.now(),
|
|
},
|
|
}
|
|
}
|
|
|
|
function createSessionGetResult(parentID: string | undefined): SessionGetResult {
|
|
return {
|
|
data: {
|
|
parentID,
|
|
},
|
|
error: undefined,
|
|
request: new Request("https://example.com/session"),
|
|
response: new Response(null, { status: 200 }),
|
|
} as SessionGetResult
|
|
}
|
|
|
|
function createHandler(parentSessionIDs?: Record<string, string | undefined>) {
|
|
const project = createProject()
|
|
const client = {
|
|
session: {
|
|
get: async (input: SessionGetInput) => createSessionGetResult(parentSessionIDs?.[input.path.id]),
|
|
},
|
|
} as unknown as PluginInput["client"]
|
|
|
|
if (parentSessionIDs) {
|
|
spyOn(client.session, "get").mockImplementation((input) => Promise.resolve(
|
|
createSessionGetResult(parentSessionIDs[input?.path?.id ?? ""]),
|
|
) as never)
|
|
}
|
|
|
|
const ctx = {
|
|
client,
|
|
project,
|
|
directory: testDirectory,
|
|
worktree: testDirectory,
|
|
serverUrl: new URL("https://example.com"),
|
|
$: Bun.$,
|
|
} satisfies PluginInput
|
|
|
|
return createToolExecuteAfterHandler({
|
|
ctx,
|
|
pendingFilePaths: new Map(),
|
|
pendingTaskRefs: new Map(),
|
|
autoCommit: true,
|
|
getState: () => ({ promptFailureCount: 0 }),
|
|
})
|
|
}
|
|
|
|
describe("#given a call_omo_agent background launch result", () => {
|
|
describe("#when tool.execute.after handles it", () => {
|
|
it("#then it should treat the launch as still running", async () => {
|
|
const handler = createHandler()
|
|
const output = {
|
|
title: "call_omo_agent",
|
|
output: "Background agent task launched successfully.",
|
|
metadata: {
|
|
sessionId: "ses_child123",
|
|
},
|
|
}
|
|
|
|
await handler(
|
|
{
|
|
tool: "call_omo_agent",
|
|
sessionID: "ses_parent",
|
|
},
|
|
output,
|
|
)
|
|
|
|
expect(output.output).toBe("Background agent task launched successfully.")
|
|
expect(collectGitDiffStatsMock).not.toHaveBeenCalled()
|
|
})
|
|
})
|
|
|
|
describe("#when a background task launch belongs to the active boulder task", () => {
|
|
it("#then it should persist the delegated session without transforming the launch output", async () => {
|
|
const sessionID = "ses_parent"
|
|
const childSessionID = "ses_child123"
|
|
const planPath = join(testDirectory, "background-launch-plan.md")
|
|
const project = createProject()
|
|
const client = {
|
|
session: {
|
|
get: async () => createSessionGetResult(undefined),
|
|
},
|
|
} as unknown as PluginInput["client"]
|
|
|
|
spyOn(client.session, "get").mockImplementation((input) => Promise.resolve(
|
|
createSessionGetResult(input?.path?.id === childSessionID ? sessionID : undefined),
|
|
) as never)
|
|
|
|
writeFileSync(planPath, `# Plan
|
|
|
|
## TODOs
|
|
- [ ] 1. Implement auth flow
|
|
`)
|
|
|
|
writeBoulderState(testDirectory, {
|
|
active_plan: planPath,
|
|
started_at: "2026-01-02T10:00:00Z",
|
|
session_ids: [sessionID],
|
|
plan_name: "background-launch-plan",
|
|
})
|
|
|
|
const pendingFilePaths = new Map<string, string>()
|
|
const pendingTaskRefs = new Map()
|
|
const ctx = {
|
|
client,
|
|
project,
|
|
directory: testDirectory,
|
|
worktree: testDirectory,
|
|
serverUrl: new URL("https://example.com"),
|
|
$: Bun.$,
|
|
} satisfies PluginInput
|
|
const beforeHandler = createToolExecuteBeforeHandler({ ctx, pendingFilePaths, pendingTaskRefs })
|
|
const afterHandler = createToolExecuteAfterHandler({
|
|
ctx,
|
|
pendingFilePaths,
|
|
pendingTaskRefs,
|
|
autoCommit: true,
|
|
getState: () => ({ promptFailureCount: 0 }),
|
|
})
|
|
|
|
await beforeHandler(
|
|
{ tool: "task", sessionID, callID: "call-bg-task" },
|
|
{ args: { prompt: "Implement auth flow" } },
|
|
)
|
|
|
|
const output = {
|
|
title: "Sisyphus Task",
|
|
output: "Background task launched.\n\nBackground Task ID: bg_123\n\n<task_metadata>\nsession_id: ses_child123\n</task_metadata>",
|
|
metadata: {
|
|
sessionId: childSessionID,
|
|
agent: "sisyphus-junior",
|
|
category: "deep",
|
|
},
|
|
}
|
|
|
|
await afterHandler(
|
|
{ tool: "task", sessionID, callID: "call-bg-task" },
|
|
output,
|
|
)
|
|
|
|
expect(output.output).toContain("Background task launched.")
|
|
expect(collectGitDiffStatsMock).not.toHaveBeenCalled()
|
|
expect(readBoulderState(testDirectory)?.session_ids).toContain(childSessionID)
|
|
expect(readBoulderState(testDirectory)?.session_origins?.[childSessionID]).toBe("appended")
|
|
expect(readBoulderState(testDirectory)?.task_sessions?.["todo:1"]?.session_id).toBe(childSessionID)
|
|
})
|
|
|
|
it("#then it should not track spawned child when child lookup fails", async () => {
|
|
const sessionID = "ses_parent"
|
|
const childSessionID = "ses_child_lookup_failure"
|
|
const planPath = join(testDirectory, "background-launch-plan.md")
|
|
const project = createProject()
|
|
const client = {
|
|
session: {
|
|
get: async () => createSessionGetResult(undefined),
|
|
},
|
|
} as unknown as PluginInput["client"]
|
|
|
|
spyOn(client.session, "get").mockImplementation((input) => {
|
|
if (input?.path?.id === childSessionID) {
|
|
return Promise.reject(new Error("lookup failed")) as never
|
|
}
|
|
return Promise.resolve(createSessionGetResult(undefined)) as never
|
|
})
|
|
|
|
writeFileSync(planPath, `# Plan
|
|
|
|
## TODOs
|
|
- [ ] 1. Implement auth flow
|
|
`)
|
|
|
|
writeBoulderState(testDirectory, {
|
|
active_plan: planPath,
|
|
started_at: "2026-01-02T10:00:00Z",
|
|
session_ids: [sessionID],
|
|
plan_name: "background-launch-plan",
|
|
})
|
|
|
|
const pendingFilePaths = new Map<string, string>()
|
|
const pendingTaskRefs = new Map()
|
|
const ctx = {
|
|
client,
|
|
project,
|
|
directory: testDirectory,
|
|
worktree: testDirectory,
|
|
serverUrl: new URL("https://example.com"),
|
|
$: Bun.$,
|
|
} satisfies PluginInput
|
|
const beforeHandler = createToolExecuteBeforeHandler({ ctx, pendingFilePaths, pendingTaskRefs })
|
|
const afterHandler = createToolExecuteAfterHandler({
|
|
ctx,
|
|
pendingFilePaths,
|
|
pendingTaskRefs,
|
|
autoCommit: true,
|
|
getState: () => ({ promptFailureCount: 0 }),
|
|
})
|
|
|
|
await beforeHandler(
|
|
{ tool: "task", sessionID, callID: "call-bg-task-lookup-failure" },
|
|
{ args: { prompt: "Implement auth flow" } },
|
|
)
|
|
|
|
const output = {
|
|
title: "Sisyphus Task",
|
|
output: "Background task launched.\n\nBackground Task ID: bg_456\n\n<task_metadata>\nsession_id: ses_child_lookup_failure\n</task_metadata>",
|
|
metadata: {
|
|
sessionId: childSessionID,
|
|
agent: "sisyphus-junior",
|
|
category: "deep",
|
|
},
|
|
}
|
|
|
|
await afterHandler(
|
|
{ tool: "task", sessionID, callID: "call-bg-task-lookup-failure" },
|
|
output,
|
|
)
|
|
|
|
expect(readBoulderState(testDirectory)?.session_ids).not.toContain(childSessionID)
|
|
})
|
|
|
|
it("#then it should not track an extracted child session outside active lineage", async () => {
|
|
const sessionID = "ses_parent"
|
|
const childSessionID = "ses_outside_lineage"
|
|
const planPath = join(testDirectory, "background-launch-plan.md")
|
|
const project = createProject()
|
|
const client = {
|
|
session: {
|
|
get: async () => createSessionGetResult(undefined),
|
|
},
|
|
} as unknown as PluginInput["client"]
|
|
|
|
spyOn(client.session, "get").mockImplementation((input) => Promise.resolve(
|
|
createSessionGetResult(input?.path?.id === childSessionID ? "ses_unrelated_parent" : undefined),
|
|
) as never)
|
|
|
|
writeFileSync(planPath, `# Plan
|
|
|
|
## TODOs
|
|
- [ ] 1. Implement auth flow
|
|
`)
|
|
|
|
writeBoulderState(testDirectory, {
|
|
active_plan: planPath,
|
|
started_at: "2026-01-02T10:00:00Z",
|
|
session_ids: [sessionID],
|
|
plan_name: "background-launch-plan",
|
|
})
|
|
|
|
const pendingFilePaths = new Map<string, string>()
|
|
const pendingTaskRefs = new Map()
|
|
const ctx = {
|
|
client,
|
|
project,
|
|
directory: testDirectory,
|
|
worktree: testDirectory,
|
|
serverUrl: new URL("https://example.com"),
|
|
$: Bun.$,
|
|
} satisfies PluginInput
|
|
const beforeHandler = createToolExecuteBeforeHandler({ ctx, pendingFilePaths, pendingTaskRefs })
|
|
const afterHandler = createToolExecuteAfterHandler({
|
|
ctx,
|
|
pendingFilePaths,
|
|
pendingTaskRefs,
|
|
autoCommit: true,
|
|
getState: () => ({ promptFailureCount: 0 }),
|
|
})
|
|
|
|
await beforeHandler(
|
|
{ tool: "task", sessionID, callID: "call-bg-task-outside-lineage" },
|
|
{ args: { prompt: "Implement auth flow" } },
|
|
)
|
|
|
|
const output = {
|
|
title: "Sisyphus Task",
|
|
output: "Background task launched.\n\nBackground Task ID: bg_789\n\n<task_metadata>\nsession_id: ses_outside_lineage\n</task_metadata>",
|
|
metadata: {
|
|
sessionId: childSessionID,
|
|
agent: "sisyphus-junior",
|
|
category: "deep",
|
|
},
|
|
}
|
|
|
|
await afterHandler(
|
|
{ tool: "task", sessionID, callID: "call-bg-task-outside-lineage" },
|
|
output,
|
|
)
|
|
|
|
expect(readBoulderState(testDirectory)?.session_ids).not.toContain(childSessionID)
|
|
})
|
|
|
|
it("#then it should not append an unrelated launcher session into active boulder", async () => {
|
|
const sessionID = "ses_unrelated_parent"
|
|
const childSessionID = "ses_unrelated_child"
|
|
const planPath = join(testDirectory, "background-launch-plan.md")
|
|
const project = createProject()
|
|
const client = {
|
|
session: {
|
|
get: async () => createSessionGetResult(undefined),
|
|
},
|
|
} as unknown as PluginInput["client"]
|
|
|
|
spyOn(client.session, "get").mockImplementation((input) => Promise.resolve(
|
|
createSessionGetResult(input?.path?.id === childSessionID ? sessionID : undefined),
|
|
) as never)
|
|
|
|
writeFileSync(planPath, `# Plan
|
|
|
|
## TODOs
|
|
- [ ] 1. Implement auth flow
|
|
`)
|
|
|
|
writeBoulderState(testDirectory, {
|
|
active_plan: planPath,
|
|
started_at: "2026-01-02T10:00:00Z",
|
|
session_ids: ["ses_boulder_root"],
|
|
session_origins: { "ses_boulder_root": "direct" },
|
|
plan_name: "background-launch-plan",
|
|
})
|
|
|
|
const pendingFilePaths = new Map<string, string>()
|
|
const pendingTaskRefs = new Map()
|
|
const ctx = {
|
|
client,
|
|
project,
|
|
directory: testDirectory,
|
|
worktree: testDirectory,
|
|
serverUrl: new URL("https://example.com"),
|
|
$: Bun.$,
|
|
} satisfies PluginInput
|
|
const beforeHandler = createToolExecuteBeforeHandler({ ctx, pendingFilePaths, pendingTaskRefs })
|
|
const afterHandler = createToolExecuteAfterHandler({
|
|
ctx,
|
|
pendingFilePaths,
|
|
pendingTaskRefs,
|
|
autoCommit: true,
|
|
getState: () => ({ promptFailureCount: 0 }),
|
|
})
|
|
|
|
await beforeHandler(
|
|
{ tool: "task", sessionID, callID: "call-bg-task-unrelated-launcher" },
|
|
{ args: { prompt: "Implement auth flow" } },
|
|
)
|
|
|
|
const output = {
|
|
title: "Sisyphus Task",
|
|
output: "Background task launched.\n\nBackground Task ID: bg_999\n\n<task_metadata>\nsession_id: ses_unrelated_child\n</task_metadata>",
|
|
metadata: {
|
|
sessionId: childSessionID,
|
|
agent: "sisyphus-junior",
|
|
category: "deep",
|
|
},
|
|
}
|
|
|
|
await afterHandler(
|
|
{ tool: "task", sessionID, callID: "call-bg-task-unrelated-launcher" },
|
|
output,
|
|
)
|
|
|
|
expect(readBoulderState(testDirectory)?.session_ids).not.toContain(sessionID)
|
|
expect(readBoulderState(testDirectory)?.session_ids).not.toContain(childSessionID)
|
|
})
|
|
|
|
it("#then it should append launched child to the session-resolved work", async () => {
|
|
const parentSessionID = "ses_parent_for_work"
|
|
const childSessionID = "ses_child_for_work"
|
|
const planPathA = join(testDirectory, "background-launch-work-a.md")
|
|
const planPathB = join(testDirectory, "background-launch-work-b.md")
|
|
const project = createProject()
|
|
const client = {
|
|
session: {
|
|
get: async () => createSessionGetResult(undefined),
|
|
},
|
|
} as unknown as PluginInput["client"]
|
|
|
|
spyOn(client.session, "get").mockImplementation((input) => Promise.resolve(
|
|
createSessionGetResult(input?.path?.id === childSessionID ? parentSessionID : undefined),
|
|
) as never)
|
|
|
|
writeFileSync(planPathA, "# Plan\n\n## TODOs\n- [ ] 1. Work A\n")
|
|
writeFileSync(planPathB, "# Plan\n\n## TODOs\n- [ ] 1. Work B\n")
|
|
|
|
writeBoulderState(testDirectory, {
|
|
schema_version: 2,
|
|
active_work_id: "work-a",
|
|
active_plan: planPathA,
|
|
started_at: "2026-01-02T10:00:00Z",
|
|
session_ids: ["ses_unrelated_active"],
|
|
plan_name: "background-launch-work-a",
|
|
works: {
|
|
"work-a": {
|
|
work_id: "work-a",
|
|
active_plan: planPathA,
|
|
plan_name: "background-launch-work-a",
|
|
started_at: "2026-01-02T10:00:00Z",
|
|
session_ids: ["ses_unrelated_active"],
|
|
status: "active",
|
|
},
|
|
"work-b": {
|
|
work_id: "work-b",
|
|
active_plan: planPathB,
|
|
plan_name: "background-launch-work-b",
|
|
started_at: "2026-01-02T10:05:00Z",
|
|
session_ids: [parentSessionID],
|
|
status: "active",
|
|
},
|
|
},
|
|
})
|
|
|
|
const pendingFilePaths = new Map<string, string>()
|
|
const pendingTaskRefs = new Map()
|
|
const ctx = {
|
|
client,
|
|
project,
|
|
directory: testDirectory,
|
|
worktree: testDirectory,
|
|
serverUrl: new URL("https://example.com"),
|
|
$: Bun.$,
|
|
} satisfies PluginInput
|
|
const beforeHandler = createToolExecuteBeforeHandler({ ctx, pendingFilePaths, pendingTaskRefs })
|
|
const afterHandler = createToolExecuteAfterHandler({
|
|
ctx,
|
|
pendingFilePaths,
|
|
pendingTaskRefs,
|
|
autoCommit: true,
|
|
getState: () => ({ promptFailureCount: 0 }),
|
|
})
|
|
|
|
await beforeHandler(
|
|
{ tool: "task", sessionID: parentSessionID, callID: "call-bg-work" },
|
|
{ args: { prompt: "Work B" } },
|
|
)
|
|
|
|
await afterHandler(
|
|
{ tool: "task", sessionID: parentSessionID, callID: "call-bg-work" },
|
|
{
|
|
title: "Sisyphus Task",
|
|
output: "Background task launched.\n\nBackground Task ID: bg_work\n\n<task_metadata>\nsession_id: ses_child_for_work\n</task_metadata>",
|
|
metadata: {
|
|
sessionId: childSessionID,
|
|
agent: "sisyphus-junior",
|
|
category: "deep",
|
|
},
|
|
},
|
|
)
|
|
|
|
const boulderState = readBoulderState(testDirectory)
|
|
expect(boulderState?.works?.["work-b"]?.session_ids).toContain(childSessionID)
|
|
expect(boulderState?.works?.["work-a"]?.session_ids).not.toContain(childSessionID)
|
|
})
|
|
})
|
|
})
|
|
})
|