601 lines
18 KiB
TypeScript
601 lines
18 KiB
TypeScript
import fs from "node:fs/promises";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
|
|
import type { CliDeps } from "../cli/deps.js";
|
|
import type { ClawdbotConfig } from "../config/config.js";
|
|
import type { CronJob } from "./types.js";
|
|
|
|
vi.mock("../agents/pi-embedded.js", () => ({
|
|
abortEmbeddedPiRun: vi.fn().mockReturnValue(false),
|
|
runEmbeddedPiAgent: vi.fn(),
|
|
resolveEmbeddedSessionLane: (key: string) =>
|
|
`session:${key.trim() || "main"}`,
|
|
}));
|
|
vi.mock("../agents/model-catalog.js", () => ({
|
|
loadModelCatalog: vi.fn(),
|
|
}));
|
|
|
|
import { loadModelCatalog } from "../agents/model-catalog.js";
|
|
import { runEmbeddedPiAgent } from "../agents/pi-embedded.js";
|
|
import { runCronIsolatedAgentTurn } from "./isolated-agent.js";
|
|
|
|
async function withTempHome<T>(fn: (home: string) => Promise<T>): Promise<T> {
|
|
const base = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-cron-"));
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = base;
|
|
try {
|
|
return await fn(base);
|
|
} finally {
|
|
process.env.HOME = previousHome;
|
|
await fs.rm(base, { recursive: true, force: true });
|
|
}
|
|
}
|
|
|
|
async function writeSessionStore(home: string) {
|
|
const dir = path.join(home, ".clawdbot", "sessions");
|
|
await fs.mkdir(dir, { recursive: true });
|
|
const storePath = path.join(dir, "sessions.json");
|
|
await fs.writeFile(
|
|
storePath,
|
|
JSON.stringify(
|
|
{
|
|
"agent:main:main": {
|
|
sessionId: "main-session",
|
|
updatedAt: Date.now(),
|
|
lastProvider: "webchat",
|
|
lastTo: "",
|
|
},
|
|
},
|
|
null,
|
|
2,
|
|
),
|
|
"utf-8",
|
|
);
|
|
return storePath;
|
|
}
|
|
|
|
function makeCfg(
|
|
home: string,
|
|
storePath: string,
|
|
overrides: Partial<ClawdbotConfig> = {},
|
|
): ClawdbotConfig {
|
|
const base: ClawdbotConfig = {
|
|
agent: {
|
|
model: "anthropic/claude-opus-4-5",
|
|
workspace: path.join(home, "clawd"),
|
|
},
|
|
session: { store: storePath, mainKey: "main" },
|
|
} as ClawdbotConfig;
|
|
return { ...base, ...overrides };
|
|
}
|
|
|
|
function makeJob(payload: CronJob["payload"]): CronJob {
|
|
const now = Date.now();
|
|
return {
|
|
id: "job-1",
|
|
enabled: true,
|
|
createdAtMs: now,
|
|
updatedAtMs: now,
|
|
schedule: { kind: "every", everyMs: 60_000 },
|
|
sessionTarget: "isolated",
|
|
wakeMode: "now",
|
|
payload,
|
|
state: {},
|
|
isolation: { postToMainPrefix: "Cron" },
|
|
};
|
|
}
|
|
|
|
describe("runCronIsolatedAgentTurn", () => {
|
|
beforeEach(() => {
|
|
vi.mocked(runEmbeddedPiAgent).mockReset();
|
|
vi.mocked(loadModelCatalog).mockResolvedValue([]);
|
|
});
|
|
|
|
it("uses last non-empty agent text as summary", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn(),
|
|
sendMessageTelegram: vi.fn(),
|
|
sendMessageDiscord: vi.fn(),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: "first" }, { text: " " }, { text: " last " }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const res = await runCronIsolatedAgentTurn({
|
|
cfg: makeCfg(home, storePath),
|
|
deps,
|
|
job: makeJob({ kind: "agentTurn", message: "do it", deliver: false }),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
expect(res.status).toBe("ok");
|
|
expect(res.summary).toBe("last");
|
|
});
|
|
});
|
|
|
|
it("defaults thinking to low for reasoning-capable models", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn(),
|
|
sendMessageTelegram: vi.fn(),
|
|
sendMessageDiscord: vi.fn(),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: "done" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
vi.mocked(loadModelCatalog).mockResolvedValueOnce([
|
|
{
|
|
id: "claude-opus-4-5",
|
|
name: "Opus 4.5",
|
|
provider: "anthropic",
|
|
reasoning: true,
|
|
},
|
|
]);
|
|
|
|
await runCronIsolatedAgentTurn({
|
|
cfg: makeCfg(home, storePath),
|
|
deps,
|
|
job: makeJob({ kind: "agentTurn", message: "do it", deliver: false }),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
const callArgs = vi.mocked(runEmbeddedPiAgent).mock.calls.at(-1)?.[0];
|
|
expect(callArgs?.thinkLevel).toBe("low");
|
|
});
|
|
});
|
|
|
|
it("truncates long summaries", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn(),
|
|
sendMessageTelegram: vi.fn(),
|
|
sendMessageDiscord: vi.fn(),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
const long = "a".repeat(2001);
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: long }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const res = await runCronIsolatedAgentTurn({
|
|
cfg: makeCfg(home, storePath),
|
|
deps,
|
|
job: makeJob({ kind: "agentTurn", message: "do it", deliver: false }),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
expect(res.status).toBe("ok");
|
|
expect(String(res.summary ?? "")).toMatch(/…$/);
|
|
});
|
|
});
|
|
|
|
it("fails delivery without a WhatsApp recipient when bestEffortDeliver=false", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn(),
|
|
sendMessageTelegram: vi.fn(),
|
|
sendMessageDiscord: vi.fn(),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: "hello" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const res = await runCronIsolatedAgentTurn({
|
|
cfg: makeCfg(home, storePath),
|
|
deps,
|
|
job: makeJob({
|
|
kind: "agentTurn",
|
|
message: "do it",
|
|
deliver: true,
|
|
provider: "whatsapp",
|
|
bestEffortDeliver: false,
|
|
}),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
expect(res.status).toBe("error");
|
|
expect(res.summary).toBe("hello");
|
|
expect(String(res.error ?? "")).toMatch(/requires a recipient/i);
|
|
expect(deps.sendMessageWhatsApp).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it("skips delivery without a WhatsApp recipient when bestEffortDeliver=true", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn(),
|
|
sendMessageTelegram: vi.fn(),
|
|
sendMessageDiscord: vi.fn(),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: "hello" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const res = await runCronIsolatedAgentTurn({
|
|
cfg: makeCfg(home, storePath),
|
|
deps,
|
|
job: makeJob({
|
|
kind: "agentTurn",
|
|
message: "do it",
|
|
deliver: true,
|
|
provider: "whatsapp",
|
|
bestEffortDeliver: true,
|
|
}),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
expect(res.status).toBe("skipped");
|
|
expect(String(res.summary ?? "")).toMatch(/delivery skipped/i);
|
|
expect(deps.sendMessageWhatsApp).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it("passes telegram token from config for delivery", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn(),
|
|
sendMessageTelegram: vi.fn().mockResolvedValue({
|
|
messageId: "t1",
|
|
chatId: "123",
|
|
}),
|
|
sendMessageDiscord: vi.fn(),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: "hello from cron" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const prevTelegramToken = process.env.TELEGRAM_BOT_TOKEN;
|
|
process.env.TELEGRAM_BOT_TOKEN = "";
|
|
try {
|
|
const res = await runCronIsolatedAgentTurn({
|
|
cfg: makeCfg(home, storePath, { telegram: { botToken: "t-1" } }),
|
|
deps,
|
|
job: makeJob({
|
|
kind: "agentTurn",
|
|
message: "do it",
|
|
deliver: true,
|
|
provider: "telegram",
|
|
to: "123",
|
|
}),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
expect(res.status).toBe("ok");
|
|
expect(deps.sendMessageTelegram).toHaveBeenCalledWith(
|
|
"123",
|
|
"hello from cron",
|
|
expect.objectContaining({ token: "t-1" }),
|
|
);
|
|
} finally {
|
|
if (prevTelegramToken === undefined) {
|
|
delete process.env.TELEGRAM_BOT_TOKEN;
|
|
} else {
|
|
process.env.TELEGRAM_BOT_TOKEN = prevTelegramToken;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
it("delivers via discord when configured", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn(),
|
|
sendMessageTelegram: vi.fn(),
|
|
sendMessageDiscord: vi.fn().mockResolvedValue({
|
|
messageId: "d1",
|
|
channelId: "chan",
|
|
}),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: "hello from cron" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const res = await runCronIsolatedAgentTurn({
|
|
cfg: makeCfg(home, storePath),
|
|
deps,
|
|
job: makeJob({
|
|
kind: "agentTurn",
|
|
message: "do it",
|
|
deliver: true,
|
|
provider: "discord",
|
|
to: "channel:1122",
|
|
}),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
expect(res.status).toBe("ok");
|
|
expect(deps.sendMessageDiscord).toHaveBeenCalledWith(
|
|
"channel:1122",
|
|
"hello from cron",
|
|
expect.objectContaining({ token: process.env.DISCORD_BOT_TOKEN }),
|
|
);
|
|
});
|
|
});
|
|
|
|
it("skips delivery when response is exactly HEARTBEAT_OK", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn(),
|
|
sendMessageTelegram: vi.fn().mockResolvedValue({
|
|
messageId: "t1",
|
|
chatId: "123",
|
|
}),
|
|
sendMessageDiscord: vi.fn(),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: "HEARTBEAT_OK" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const res = await runCronIsolatedAgentTurn({
|
|
cfg: makeCfg(home, storePath),
|
|
deps,
|
|
job: makeJob({
|
|
kind: "agentTurn",
|
|
message: "do it",
|
|
deliver: true,
|
|
provider: "telegram",
|
|
to: "123",
|
|
}),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
// Job still succeeds, but no delivery happens.
|
|
expect(res.status).toBe("ok");
|
|
expect(res.summary).toBe("HEARTBEAT_OK");
|
|
expect(deps.sendMessageTelegram).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it("skips delivery when response has HEARTBEAT_OK with short padding", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn().mockResolvedValue({
|
|
messageId: "w1",
|
|
chatId: "+1234",
|
|
}),
|
|
sendMessageTelegram: vi.fn(),
|
|
sendMessageDiscord: vi.fn(),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
// Short junk around HEARTBEAT_OK (<=30 chars) should still skip delivery.
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: "HEARTBEAT_OK 🦞" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const res = await runCronIsolatedAgentTurn({
|
|
cfg: makeCfg(home, storePath, { whatsapp: { allowFrom: ["+1234"] } }),
|
|
deps,
|
|
job: makeJob({
|
|
kind: "agentTurn",
|
|
message: "do it",
|
|
deliver: true,
|
|
provider: "whatsapp",
|
|
to: "+1234",
|
|
}),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
expect(res.status).toBe("ok");
|
|
expect(deps.sendMessageWhatsApp).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it("delivers when response has HEARTBEAT_OK but also substantial content", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn(),
|
|
sendMessageTelegram: vi.fn().mockResolvedValue({
|
|
messageId: "t1",
|
|
chatId: "123",
|
|
}),
|
|
sendMessageDiscord: vi.fn(),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
// Long content after HEARTBEAT_OK should still be delivered.
|
|
const longContent = `Important alert: ${"a".repeat(50)}`;
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: `HEARTBEAT_OK ${longContent}` }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const res = await runCronIsolatedAgentTurn({
|
|
cfg: makeCfg(home, storePath),
|
|
deps,
|
|
job: makeJob({
|
|
kind: "agentTurn",
|
|
message: "do it",
|
|
deliver: true,
|
|
provider: "telegram",
|
|
to: "123",
|
|
}),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
expect(res.status).toBe("ok");
|
|
expect(deps.sendMessageTelegram).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it("delivers when response has HEARTBEAT_OK but includes media", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn(),
|
|
sendMessageTelegram: vi.fn().mockResolvedValue({
|
|
messageId: "t1",
|
|
chatId: "123",
|
|
}),
|
|
sendMessageDiscord: vi.fn(),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
// Media should still be delivered even if text is just HEARTBEAT_OK.
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [
|
|
{ text: "HEARTBEAT_OK", mediaUrl: "https://example.com/img.png" },
|
|
],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const res = await runCronIsolatedAgentTurn({
|
|
cfg: makeCfg(home, storePath),
|
|
deps,
|
|
job: makeJob({
|
|
kind: "agentTurn",
|
|
message: "do it",
|
|
deliver: true,
|
|
provider: "telegram",
|
|
to: "123",
|
|
}),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
expect(res.status).toBe("ok");
|
|
expect(deps.sendMessageTelegram).toHaveBeenCalledWith(
|
|
"123",
|
|
"HEARTBEAT_OK",
|
|
expect.objectContaining({ mediaUrl: "https://example.com/img.png" }),
|
|
);
|
|
});
|
|
});
|
|
|
|
it("delivers when heartbeat ack padding exceeds configured limit", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = await writeSessionStore(home);
|
|
const deps: CliDeps = {
|
|
sendMessageWhatsApp: vi.fn(),
|
|
sendMessageTelegram: vi.fn().mockResolvedValue({
|
|
messageId: "t1",
|
|
chatId: "123",
|
|
}),
|
|
sendMessageDiscord: vi.fn(),
|
|
sendMessageSignal: vi.fn(),
|
|
sendMessageIMessage: vi.fn(),
|
|
};
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: "HEARTBEAT_OK 🦞" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const cfg = makeCfg(home, storePath);
|
|
cfg.agent = { ...cfg.agent, heartbeat: { ackMaxChars: 0 } };
|
|
|
|
const res = await runCronIsolatedAgentTurn({
|
|
cfg,
|
|
deps,
|
|
job: makeJob({
|
|
kind: "agentTurn",
|
|
message: "do it",
|
|
deliver: true,
|
|
provider: "telegram",
|
|
to: "123",
|
|
}),
|
|
message: "do it",
|
|
sessionKey: "cron:job-1",
|
|
lane: "cron",
|
|
});
|
|
|
|
expect(res.status).toBe("ok");
|
|
expect(deps.sendMessageTelegram).toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|