mirror of
https://github.com/openclaw/openclaw.git
synced 2026-05-06 23:51:38 +00:00
489 lines
16 KiB
TypeScript
489 lines
16 KiB
TypeScript
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import {
|
|
addSubagentRunForTests,
|
|
resetSubagentRegistryForTests,
|
|
} from "../../agents/subagent-registry.js";
|
|
import type { OpenClawConfig } from "../../config/config.js";
|
|
import type { SessionBindingRecord } from "../../infra/outbound/session-binding-service.js";
|
|
import { installSubagentsCommandCoreMocks } from "./commands-subagents.test-mocks.js";
|
|
|
|
const hoisted = vi.hoisted(() => {
|
|
const callGatewayMock = vi.fn();
|
|
const getThreadBindingManagerMock = vi.fn();
|
|
const resolveThreadBindingThreadNameMock = vi.fn(() => "🤖 codex");
|
|
const readAcpSessionEntryMock = vi.fn();
|
|
const sessionBindingCapabilitiesMock = vi.fn();
|
|
const sessionBindingBindMock = vi.fn();
|
|
const sessionBindingResolveByConversationMock = vi.fn();
|
|
const sessionBindingListBySessionMock = vi.fn();
|
|
const sessionBindingUnbindMock = vi.fn();
|
|
return {
|
|
callGatewayMock,
|
|
getThreadBindingManagerMock,
|
|
resolveThreadBindingThreadNameMock,
|
|
readAcpSessionEntryMock,
|
|
sessionBindingCapabilitiesMock,
|
|
sessionBindingBindMock,
|
|
sessionBindingResolveByConversationMock,
|
|
sessionBindingListBySessionMock,
|
|
sessionBindingUnbindMock,
|
|
};
|
|
});
|
|
|
|
function buildFocusSessionBindingService() {
|
|
const service = {
|
|
touch: vi.fn(),
|
|
listBySession(targetSessionKey: string) {
|
|
return hoisted.sessionBindingListBySessionMock(targetSessionKey);
|
|
},
|
|
resolveByConversation(ref: unknown) {
|
|
return hoisted.sessionBindingResolveByConversationMock(ref);
|
|
},
|
|
getCapabilities(params: unknown) {
|
|
return hoisted.sessionBindingCapabilitiesMock(params);
|
|
},
|
|
bind(input: unknown) {
|
|
return hoisted.sessionBindingBindMock(input);
|
|
},
|
|
unbind(input: unknown) {
|
|
return hoisted.sessionBindingUnbindMock(input);
|
|
},
|
|
};
|
|
return service;
|
|
}
|
|
|
|
vi.mock("../../gateway/call.js", () => ({
|
|
callGateway: hoisted.callGatewayMock,
|
|
}));
|
|
|
|
vi.mock("../../acp/runtime/session-meta.js", async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import("../../acp/runtime/session-meta.js")>();
|
|
return {
|
|
...actual,
|
|
readAcpSessionEntry: (params: unknown) => hoisted.readAcpSessionEntryMock(params),
|
|
};
|
|
});
|
|
|
|
vi.mock("../../discord/monitor/thread-bindings.js", async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import("../../discord/monitor/thread-bindings.js")>();
|
|
return {
|
|
...actual,
|
|
getThreadBindingManager: hoisted.getThreadBindingManagerMock,
|
|
resolveThreadBindingThreadName: hoisted.resolveThreadBindingThreadNameMock,
|
|
};
|
|
});
|
|
|
|
vi.mock("../../infra/outbound/session-binding-service.js", async (importOriginal) => {
|
|
const actual =
|
|
await importOriginal<typeof import("../../infra/outbound/session-binding-service.js")>();
|
|
return {
|
|
...actual,
|
|
getSessionBindingService: () => buildFocusSessionBindingService(),
|
|
};
|
|
});
|
|
|
|
installSubagentsCommandCoreMocks();
|
|
|
|
const { handleSubagentsCommand } = await import("./commands-subagents.js");
|
|
const { buildCommandTestParams } = await import("./commands-spawn.test-harness.js");
|
|
|
|
type FakeBinding = {
|
|
accountId: string;
|
|
channelId: string;
|
|
threadId: string;
|
|
targetKind: "subagent" | "acp";
|
|
targetSessionKey: string;
|
|
agentId: string;
|
|
label?: string;
|
|
webhookId?: string;
|
|
webhookToken?: string;
|
|
boundBy: string;
|
|
boundAt: number;
|
|
};
|
|
|
|
function createFakeBinding(
|
|
overrides: Pick<FakeBinding, "threadId" | "targetKind" | "targetSessionKey" | "agentId"> &
|
|
Partial<FakeBinding>,
|
|
): FakeBinding {
|
|
return {
|
|
accountId: "default",
|
|
channelId: "parent-1",
|
|
boundBy: "user-1",
|
|
boundAt: Date.now(),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function expectAgentListContainsThreadBinding(text: string, label: string, threadId: string): void {
|
|
expect(text).toContain("agents:");
|
|
expect(text).toContain(label);
|
|
expect(text).toContain(`thread:${threadId}`);
|
|
}
|
|
|
|
function createFakeThreadBindingManager(initialBindings: FakeBinding[] = []) {
|
|
const byThread = new Map<string, FakeBinding>(
|
|
initialBindings.map((binding) => [binding.threadId, binding]),
|
|
);
|
|
|
|
const manager = {
|
|
getIdleTimeoutMs: vi.fn(() => 24 * 60 * 60 * 1000),
|
|
getMaxAgeMs: vi.fn(() => 0),
|
|
getByThreadId: vi.fn((threadId: string) => byThread.get(threadId)),
|
|
listBySessionKey: vi.fn((targetSessionKey: string) =>
|
|
[...byThread.values()].filter((binding) => binding.targetSessionKey === targetSessionKey),
|
|
),
|
|
listBindings: vi.fn(() => [...byThread.values()]),
|
|
bindTarget: vi.fn(async (params: Record<string, unknown>) => {
|
|
const threadId =
|
|
typeof params.threadId === "string" && params.threadId.trim()
|
|
? params.threadId.trim()
|
|
: "thread-created";
|
|
const targetSessionKey =
|
|
typeof params.targetSessionKey === "string" ? params.targetSessionKey.trim() : "";
|
|
const agentId =
|
|
typeof params.agentId === "string" && params.agentId.trim()
|
|
? params.agentId.trim()
|
|
: "main";
|
|
const binding: FakeBinding = {
|
|
accountId: "default",
|
|
channelId:
|
|
typeof params.channelId === "string" && params.channelId.trim()
|
|
? params.channelId.trim()
|
|
: "parent-1",
|
|
threadId,
|
|
targetKind:
|
|
params.targetKind === "subagent" || params.targetKind === "acp"
|
|
? params.targetKind
|
|
: "acp",
|
|
targetSessionKey,
|
|
agentId,
|
|
label: typeof params.label === "string" ? params.label : undefined,
|
|
boundBy: typeof params.boundBy === "string" ? params.boundBy : "system",
|
|
boundAt: Date.now(),
|
|
};
|
|
byThread.set(threadId, binding);
|
|
return binding;
|
|
}),
|
|
unbindThread: vi.fn((params: { threadId: string }) => {
|
|
const binding = byThread.get(params.threadId) ?? null;
|
|
if (binding) {
|
|
byThread.delete(params.threadId);
|
|
}
|
|
return binding;
|
|
}),
|
|
};
|
|
|
|
return { manager, byThread };
|
|
}
|
|
|
|
const baseCfg = {
|
|
session: { mainKey: "main", scope: "per-sender" },
|
|
} satisfies OpenClawConfig;
|
|
|
|
function createDiscordCommandParams(commandBody: string) {
|
|
const params = buildCommandTestParams(commandBody, baseCfg, {
|
|
Provider: "discord",
|
|
Surface: "discord",
|
|
OriginatingChannel: "discord",
|
|
OriginatingTo: "channel:parent-1",
|
|
AccountId: "default",
|
|
MessageThreadId: "thread-1",
|
|
});
|
|
params.command.senderId = "user-1";
|
|
return params;
|
|
}
|
|
|
|
function createStoredBinding(overrides?: Partial<FakeBinding>): FakeBinding {
|
|
return {
|
|
accountId: "default",
|
|
channelId: "parent-1",
|
|
threadId: "thread-1",
|
|
targetKind: "subagent",
|
|
targetSessionKey: "agent:main:subagent:child",
|
|
agentId: "main",
|
|
label: "child",
|
|
boundBy: "user-1",
|
|
boundAt: Date.now(),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function createSessionBindingRecord(
|
|
overrides?: Partial<SessionBindingRecord>,
|
|
): SessionBindingRecord {
|
|
return {
|
|
bindingId: "default:thread-1",
|
|
targetSessionKey: "agent:codex-acp:session-1",
|
|
targetKind: "session",
|
|
conversation: {
|
|
channel: "discord",
|
|
accountId: "default",
|
|
conversationId: "thread-1",
|
|
parentConversationId: "parent-1",
|
|
},
|
|
status: "active",
|
|
boundAt: Date.now(),
|
|
metadata: {
|
|
boundBy: "user-1",
|
|
agentId: "codex-acp",
|
|
},
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function createSessionBindingCapabilities() {
|
|
return {
|
|
adapterAvailable: true,
|
|
bindSupported: true,
|
|
unbindSupported: true,
|
|
placements: ["current", "child"] as const,
|
|
};
|
|
}
|
|
|
|
async function runUnfocusAndExpectManualUnbind(initialBindings: FakeBinding[]) {
|
|
const fake = createFakeThreadBindingManager(initialBindings);
|
|
hoisted.getThreadBindingManagerMock.mockReturnValue(fake.manager);
|
|
|
|
const params = createDiscordCommandParams("/unfocus");
|
|
const result = await handleSubagentsCommand(params, true);
|
|
|
|
expect(result?.reply?.text).toContain("Thread unfocused");
|
|
expect(fake.manager.unbindThread).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
threadId: "thread-1",
|
|
reason: "manual",
|
|
}),
|
|
);
|
|
}
|
|
|
|
async function focusCodexAcpInThread(options?: { existingBinding?: SessionBindingRecord | null }) {
|
|
hoisted.sessionBindingCapabilitiesMock.mockReturnValue(createSessionBindingCapabilities());
|
|
hoisted.sessionBindingResolveByConversationMock.mockReturnValue(options?.existingBinding ?? null);
|
|
hoisted.sessionBindingBindMock.mockImplementation(
|
|
async (input: {
|
|
targetSessionKey: string;
|
|
conversation: { accountId: string; conversationId: string };
|
|
metadata?: Record<string, unknown>;
|
|
}) =>
|
|
createSessionBindingRecord({
|
|
targetSessionKey: input.targetSessionKey,
|
|
conversation: {
|
|
channel: "discord",
|
|
accountId: input.conversation.accountId,
|
|
conversationId: input.conversation.conversationId,
|
|
parentConversationId: "parent-1",
|
|
},
|
|
metadata: {
|
|
boundBy: typeof input.metadata?.boundBy === "string" ? input.metadata.boundBy : "user-1",
|
|
},
|
|
}),
|
|
);
|
|
hoisted.callGatewayMock.mockImplementation(async (request: unknown) => {
|
|
const method = (request as { method?: string }).method;
|
|
if (method === "sessions.resolve") {
|
|
return { key: "agent:codex-acp:session-1" };
|
|
}
|
|
return {};
|
|
});
|
|
const params = createDiscordCommandParams("/focus codex-acp");
|
|
const result = await handleSubagentsCommand(params, true);
|
|
return { result };
|
|
}
|
|
|
|
async function runAgentsCommandAndText(): Promise<string> {
|
|
const params = createDiscordCommandParams("/agents");
|
|
const result = await handleSubagentsCommand(params, true);
|
|
return result?.reply?.text ?? "";
|
|
}
|
|
|
|
describe("/focus, /unfocus, /agents", () => {
|
|
beforeEach(() => {
|
|
resetSubagentRegistryForTests();
|
|
hoisted.callGatewayMock.mockClear();
|
|
hoisted.getThreadBindingManagerMock.mockClear().mockReturnValue(null);
|
|
hoisted.resolveThreadBindingThreadNameMock.mockClear().mockReturnValue("🤖 codex");
|
|
hoisted.readAcpSessionEntryMock.mockReset().mockReturnValue(null);
|
|
hoisted.sessionBindingCapabilitiesMock
|
|
.mockReset()
|
|
.mockReturnValue(createSessionBindingCapabilities());
|
|
hoisted.sessionBindingResolveByConversationMock.mockReset().mockReturnValue(null);
|
|
hoisted.sessionBindingListBySessionMock.mockReset().mockReturnValue([]);
|
|
hoisted.sessionBindingUnbindMock.mockReset().mockResolvedValue([]);
|
|
hoisted.sessionBindingBindMock.mockReset();
|
|
});
|
|
|
|
it("/focus resolves ACP sessions and binds the current Discord thread", async () => {
|
|
const { result } = await focusCodexAcpInThread();
|
|
|
|
expect(result?.reply?.text).toContain("bound this thread");
|
|
expect(result?.reply?.text).toContain("(acp)");
|
|
expect(hoisted.sessionBindingBindMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
placement: "current",
|
|
targetKind: "session",
|
|
targetSessionKey: "agent:codex-acp:session-1",
|
|
metadata: expect.objectContaining({
|
|
introText:
|
|
"⚙️ codex-acp session active (idle auto-unfocus after 24h inactivity). Messages here go directly to this session.",
|
|
}),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("/focus includes ACP session identifiers in intro text when available", async () => {
|
|
hoisted.readAcpSessionEntryMock.mockReturnValue({
|
|
sessionKey: "agent:codex-acp:session-1",
|
|
storeSessionKey: "agent:codex-acp:session-1",
|
|
acp: {
|
|
backend: "acpx",
|
|
agent: "codex",
|
|
runtimeSessionName: "runtime-1",
|
|
identity: {
|
|
state: "resolved",
|
|
source: "status",
|
|
acpxSessionId: "acpx-456",
|
|
agentSessionId: "codex-123",
|
|
lastUpdatedAt: Date.now(),
|
|
},
|
|
mode: "persistent",
|
|
state: "idle",
|
|
lastActivityAt: Date.now(),
|
|
},
|
|
});
|
|
const { result } = await focusCodexAcpInThread();
|
|
|
|
expect(result?.reply?.text).toContain("bound this thread");
|
|
expect(hoisted.sessionBindingBindMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
metadata: expect.objectContaining({
|
|
introText: expect.stringContaining("agent session id: codex-123"),
|
|
}),
|
|
}),
|
|
);
|
|
expect(hoisted.sessionBindingBindMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
metadata: expect.objectContaining({
|
|
introText: expect.stringContaining("acpx session id: acpx-456"),
|
|
}),
|
|
}),
|
|
);
|
|
expect(hoisted.sessionBindingBindMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
metadata: expect.objectContaining({
|
|
introText: expect.stringContaining("codex resume codex-123"),
|
|
}),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("/unfocus removes an active thread binding for the binding owner", async () => {
|
|
await runUnfocusAndExpectManualUnbind([createStoredBinding()]);
|
|
});
|
|
|
|
it("/unfocus also unbinds ACP-focused thread bindings", async () => {
|
|
await runUnfocusAndExpectManualUnbind([
|
|
createStoredBinding({
|
|
targetKind: "acp",
|
|
targetSessionKey: "agent:codex:acp:session-1",
|
|
agentId: "codex",
|
|
label: "codex-session",
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it("/focus rejects rebinding when the thread is focused by another user", async () => {
|
|
const { result } = await focusCodexAcpInThread({
|
|
existingBinding: createSessionBindingRecord({
|
|
metadata: {
|
|
boundBy: "user-2",
|
|
},
|
|
}),
|
|
});
|
|
|
|
expect(result?.reply?.text).toContain("Only user-2 can refocus this thread.");
|
|
expect(hoisted.sessionBindingBindMock).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("/agents includes bound persistent sessions and requester-scoped ACP bindings", async () => {
|
|
addSubagentRunForTests({
|
|
runId: "run-1",
|
|
childSessionKey: "agent:main:subagent:child-1",
|
|
requesterSessionKey: "agent:main:main",
|
|
requesterDisplayKey: "main",
|
|
task: "test task",
|
|
cleanup: "keep",
|
|
label: "child-1",
|
|
createdAt: Date.now(),
|
|
});
|
|
|
|
const fake = createFakeThreadBindingManager([
|
|
createFakeBinding({
|
|
threadId: "thread-1",
|
|
targetKind: "subagent",
|
|
targetSessionKey: "agent:main:subagent:child-1",
|
|
agentId: "main",
|
|
label: "child-1",
|
|
}),
|
|
createFakeBinding({
|
|
threadId: "thread-2",
|
|
targetKind: "acp",
|
|
targetSessionKey: "agent:main:main",
|
|
agentId: "codex-acp",
|
|
label: "main-session",
|
|
}),
|
|
createFakeBinding({
|
|
threadId: "thread-3",
|
|
targetKind: "acp",
|
|
targetSessionKey: "agent:codex-acp:session-2",
|
|
agentId: "codex-acp",
|
|
label: "codex-acp",
|
|
}),
|
|
]);
|
|
hoisted.getThreadBindingManagerMock.mockReturnValue(fake.manager);
|
|
|
|
const text = await runAgentsCommandAndText();
|
|
|
|
expect(text).toContain("agents:");
|
|
expect(text).toContain("thread:thread-1");
|
|
expect(text).toContain("acp/session bindings:");
|
|
expect(text).toContain("session:agent:main:main");
|
|
expect(text).not.toContain("session:agent:codex-acp:session-2");
|
|
});
|
|
|
|
it("/agents keeps finished session-mode runs visible while their thread binding remains", async () => {
|
|
addSubagentRunForTests({
|
|
runId: "run-session-1",
|
|
childSessionKey: "agent:main:subagent:persistent-1",
|
|
requesterSessionKey: "agent:main:main",
|
|
requesterDisplayKey: "main",
|
|
task: "persistent task",
|
|
cleanup: "keep",
|
|
label: "persistent-1",
|
|
spawnMode: "session",
|
|
createdAt: Date.now(),
|
|
endedAt: Date.now(),
|
|
});
|
|
|
|
const fake = createFakeThreadBindingManager([
|
|
createFakeBinding({
|
|
threadId: "thread-persistent-1",
|
|
targetKind: "subagent",
|
|
targetSessionKey: "agent:main:subagent:persistent-1",
|
|
agentId: "main",
|
|
label: "persistent-1",
|
|
}),
|
|
]);
|
|
hoisted.getThreadBindingManagerMock.mockReturnValue(fake.manager);
|
|
|
|
const text = await runAgentsCommandAndText();
|
|
|
|
expectAgentListContainsThreadBinding(text, "persistent-1", "thread-persistent-1");
|
|
});
|
|
|
|
it("/focus is discord-only", async () => {
|
|
const params = buildCommandTestParams("/focus codex-acp", baseCfg);
|
|
const result = await handleSubagentsCommand(params, true);
|
|
expect(result?.reply?.text).toContain("only available on Discord");
|
|
});
|
|
});
|