439 lines
12 KiB
TypeScript
439 lines
12 KiB
TypeScript
import crypto from "node:crypto";
|
|
import { runCommandReply } from "../auto-reply/command-reply.js";
|
|
import {
|
|
applyTemplate,
|
|
type MsgContext,
|
|
type TemplateContext,
|
|
} from "../auto-reply/templating.js";
|
|
import {
|
|
normalizeThinkLevel,
|
|
normalizeVerboseLevel,
|
|
type ThinkLevel,
|
|
type VerboseLevel,
|
|
} from "../auto-reply/thinking.js";
|
|
import { type CliDeps, createDefaultDeps } from "../cli/deps.js";
|
|
import { loadConfig, type WarelayConfig } from "../config/config.js";
|
|
import {
|
|
DEFAULT_IDLE_MINUTES,
|
|
loadSessionStore,
|
|
resolveSessionKey,
|
|
resolveStorePath,
|
|
type SessionEntry,
|
|
saveSessionStore,
|
|
} from "../config/sessions.js";
|
|
import { emitAgentEvent } from "../infra/agent-events.js";
|
|
import { runCommandWithTimeout } from "../process/exec.js";
|
|
import { defaultRuntime, type RuntimeEnv } from "../runtime.js";
|
|
import { normalizeE164 } from "../utils.js";
|
|
|
|
type AgentCommandOpts = {
|
|
message: string;
|
|
to?: string;
|
|
sessionId?: string;
|
|
thinking?: string;
|
|
thinkingOnce?: string;
|
|
verbose?: string;
|
|
json?: boolean;
|
|
timeout?: string;
|
|
deliver?: boolean;
|
|
surface?: string;
|
|
};
|
|
|
|
type SessionResolution = {
|
|
sessionId: string;
|
|
sessionKey?: string;
|
|
sessionEntry?: SessionEntry;
|
|
sessionStore?: Record<string, SessionEntry>;
|
|
storePath?: string;
|
|
isNewSession: boolean;
|
|
systemSent: boolean;
|
|
persistedThinking?: ThinkLevel;
|
|
persistedVerbose?: VerboseLevel;
|
|
};
|
|
|
|
function assertCommandConfig(cfg: WarelayConfig) {
|
|
const reply = cfg.inbound?.reply;
|
|
if (!reply || reply.mode !== "command" || !reply.command?.length) {
|
|
throw new Error(
|
|
"Configure inbound.reply.mode=command with reply.command before using `clawdis agent`.",
|
|
);
|
|
}
|
|
return reply as NonNullable<
|
|
NonNullable<WarelayConfig["inbound"]>["reply"]
|
|
> & { mode: "command"; command: string[] };
|
|
}
|
|
|
|
function resolveSession(opts: {
|
|
to?: string;
|
|
sessionId?: string;
|
|
replyCfg: NonNullable<NonNullable<WarelayConfig["inbound"]>["reply"]>;
|
|
}): SessionResolution {
|
|
const sessionCfg = opts.replyCfg?.session;
|
|
const scope = sessionCfg?.scope ?? "per-sender";
|
|
const mainKey = sessionCfg?.mainKey ?? "main";
|
|
const idleMinutes = Math.max(
|
|
sessionCfg?.idleMinutes ?? DEFAULT_IDLE_MINUTES,
|
|
1,
|
|
);
|
|
const idleMs = idleMinutes * 60_000;
|
|
const storePath = sessionCfg ? resolveStorePath(sessionCfg.store) : undefined;
|
|
const sessionStore = storePath ? loadSessionStore(storePath) : undefined;
|
|
const now = Date.now();
|
|
|
|
let sessionKey: string | undefined =
|
|
sessionStore && opts.to
|
|
? resolveSessionKey(scope, { From: opts.to } as MsgContext, mainKey)
|
|
: undefined;
|
|
let sessionEntry =
|
|
sessionKey && sessionStore ? sessionStore[sessionKey] : undefined;
|
|
|
|
// If a session id was provided, prefer to re-use its entry (by id) even when no key was derived.
|
|
if (
|
|
sessionStore &&
|
|
opts.sessionId &&
|
|
(!sessionEntry || sessionEntry.sessionId !== opts.sessionId)
|
|
) {
|
|
const foundKey = Object.keys(sessionStore).find(
|
|
(key) => sessionStore[key]?.sessionId === opts.sessionId,
|
|
);
|
|
if (foundKey) {
|
|
sessionKey = sessionKey ?? foundKey;
|
|
sessionEntry = sessionStore[foundKey];
|
|
}
|
|
}
|
|
|
|
let sessionId = opts.sessionId?.trim() || sessionEntry?.sessionId;
|
|
let isNewSession = false;
|
|
let systemSent = sessionEntry?.systemSent ?? false;
|
|
|
|
if (!opts.sessionId) {
|
|
const fresh = sessionEntry && sessionEntry.updatedAt >= now - idleMs;
|
|
if (!sessionEntry || !fresh) {
|
|
sessionId = sessionId ?? crypto.randomUUID();
|
|
isNewSession = true;
|
|
systemSent = false;
|
|
if (sessionCfg && sessionStore && sessionKey) {
|
|
sessionEntry = {
|
|
sessionId,
|
|
updatedAt: now,
|
|
abortedLastRun: sessionEntry?.abortedLastRun,
|
|
};
|
|
}
|
|
}
|
|
} else {
|
|
sessionId = sessionId ?? crypto.randomUUID();
|
|
isNewSession = false;
|
|
if (!sessionEntry && sessionCfg && sessionStore && sessionKey) {
|
|
sessionEntry = {
|
|
sessionId,
|
|
updatedAt: now,
|
|
};
|
|
}
|
|
}
|
|
|
|
const persistedThinking =
|
|
!isNewSession && sessionEntry
|
|
? normalizeThinkLevel(sessionEntry.thinkingLevel)
|
|
: undefined;
|
|
const persistedVerbose =
|
|
!isNewSession && sessionEntry
|
|
? normalizeVerboseLevel(sessionEntry.verboseLevel)
|
|
: undefined;
|
|
|
|
return {
|
|
sessionId: sessionId ?? crypto.randomUUID(),
|
|
sessionKey,
|
|
sessionEntry,
|
|
sessionStore,
|
|
storePath,
|
|
isNewSession,
|
|
systemSent,
|
|
persistedThinking,
|
|
persistedVerbose,
|
|
};
|
|
}
|
|
|
|
export async function agentCommand(
|
|
opts: AgentCommandOpts,
|
|
runtime: RuntimeEnv = defaultRuntime,
|
|
deps: CliDeps = createDefaultDeps(),
|
|
) {
|
|
const body = (opts.message ?? "").trim();
|
|
if (!body) {
|
|
throw new Error("Message (--message) is required");
|
|
}
|
|
if (!opts.to && !opts.sessionId) {
|
|
throw new Error("Pass --to <E.164> or --session-id to choose a session");
|
|
}
|
|
|
|
const cfg = loadConfig();
|
|
const replyCfg = assertCommandConfig(cfg);
|
|
const sessionCfg = replyCfg.session;
|
|
const allowFrom = (cfg.inbound?.allowFrom ?? [])
|
|
.map((val) => normalizeE164(val))
|
|
.filter((val) => val.length > 1);
|
|
|
|
const thinkOverride = normalizeThinkLevel(opts.thinking);
|
|
const thinkOnce = normalizeThinkLevel(opts.thinkingOnce);
|
|
if (opts.thinking && !thinkOverride) {
|
|
throw new Error(
|
|
"Invalid thinking level. Use one of: off, minimal, low, medium, high.",
|
|
);
|
|
}
|
|
if (opts.thinkingOnce && !thinkOnce) {
|
|
throw new Error(
|
|
"Invalid one-shot thinking level. Use one of: off, minimal, low, medium, high.",
|
|
);
|
|
}
|
|
const verboseOverride = normalizeVerboseLevel(opts.verbose);
|
|
if (opts.verbose && !verboseOverride) {
|
|
throw new Error('Invalid verbose level. Use "on" or "off".');
|
|
}
|
|
|
|
const timeoutSecondsRaw =
|
|
opts.timeout !== undefined
|
|
? Number.parseInt(String(opts.timeout), 10)
|
|
: (replyCfg.timeoutSeconds ?? 600);
|
|
const timeoutSeconds = Math.max(timeoutSecondsRaw, 1);
|
|
if (Number.isNaN(timeoutSecondsRaw) || timeoutSecondsRaw <= 0) {
|
|
throw new Error("--timeout must be a positive integer (seconds)");
|
|
}
|
|
const timeoutMs = timeoutSeconds * 1000;
|
|
|
|
const sessionResolution = resolveSession({
|
|
to: opts.to,
|
|
sessionId: opts.sessionId,
|
|
replyCfg,
|
|
});
|
|
const {
|
|
sessionId,
|
|
sessionKey,
|
|
sessionEntry,
|
|
sessionStore,
|
|
storePath,
|
|
isNewSession,
|
|
systemSent: initialSystemSent,
|
|
persistedThinking,
|
|
persistedVerbose,
|
|
} = sessionResolution;
|
|
|
|
let systemSent = initialSystemSent;
|
|
const sendSystemOnce = sessionCfg?.sendSystemOnce === true;
|
|
const isFirstTurnInSession = isNewSession || !systemSent;
|
|
|
|
// Merge thinking/verbose levels: one-shot override > flag override > persisted > defaults.
|
|
const resolvedThinkLevel: ThinkLevel | undefined =
|
|
thinkOnce ??
|
|
thinkOverride ??
|
|
persistedThinking ??
|
|
(replyCfg.thinkingDefault as ThinkLevel | undefined);
|
|
const resolvedVerboseLevel: VerboseLevel | undefined =
|
|
verboseOverride ??
|
|
persistedVerbose ??
|
|
(replyCfg.verboseDefault as VerboseLevel | undefined);
|
|
|
|
// Persist overrides into the session store (mirrors directive-only flow).
|
|
if (sessionStore && sessionEntry && sessionKey && storePath) {
|
|
sessionEntry.updatedAt = Date.now();
|
|
if (thinkOverride) {
|
|
if (thinkOverride === "off") {
|
|
delete sessionEntry.thinkingLevel;
|
|
} else {
|
|
sessionEntry.thinkingLevel = thinkOverride;
|
|
}
|
|
} else if (isNewSession) {
|
|
delete sessionEntry.thinkingLevel;
|
|
}
|
|
|
|
if (verboseOverride) {
|
|
if (verboseOverride === "off") {
|
|
delete sessionEntry.verboseLevel;
|
|
} else {
|
|
sessionEntry.verboseLevel = verboseOverride;
|
|
}
|
|
} else if (isNewSession) {
|
|
delete sessionEntry.verboseLevel;
|
|
}
|
|
|
|
if (sendSystemOnce && isFirstTurnInSession) {
|
|
sessionEntry.systemSent = true;
|
|
systemSent = true;
|
|
}
|
|
|
|
sessionStore[sessionKey] = sessionEntry;
|
|
await saveSessionStore(storePath, sessionStore);
|
|
}
|
|
|
|
const baseCtx: TemplateContext = {
|
|
Body: body,
|
|
BodyStripped: body,
|
|
From: opts.to,
|
|
SessionId: sessionId,
|
|
IsNewSession: isNewSession ? "true" : "false",
|
|
Surface: opts.surface,
|
|
};
|
|
|
|
const sessionIntro =
|
|
isFirstTurnInSession && sessionCfg?.sessionIntro
|
|
? applyTemplate(sessionCfg.sessionIntro, baseCtx)
|
|
: "";
|
|
const bodyPrefix = replyCfg.bodyPrefix
|
|
? applyTemplate(replyCfg.bodyPrefix, baseCtx)
|
|
: "";
|
|
|
|
let commandBody = body;
|
|
if (!sendSystemOnce || isFirstTurnInSession) {
|
|
commandBody = bodyPrefix ? `${bodyPrefix}${commandBody}` : commandBody;
|
|
}
|
|
if (sessionIntro) {
|
|
commandBody = `${sessionIntro}\n\n${commandBody}`;
|
|
}
|
|
|
|
const templatingCtx: TemplateContext = {
|
|
...baseCtx,
|
|
Body: commandBody,
|
|
BodyStripped: commandBody,
|
|
};
|
|
|
|
const startedAt = Date.now();
|
|
emitAgentEvent({
|
|
runId: sessionId,
|
|
stream: "job",
|
|
data: {
|
|
state: "started",
|
|
startedAt,
|
|
to: opts.to,
|
|
sessionId,
|
|
isNewSession,
|
|
},
|
|
});
|
|
|
|
let result: Awaited<ReturnType<typeof runCommandReply>>;
|
|
try {
|
|
result = await runCommandReply({
|
|
reply: { ...replyCfg, mode: "command" },
|
|
templatingCtx,
|
|
sendSystemOnce,
|
|
isNewSession,
|
|
isFirstTurnInSession,
|
|
systemSent,
|
|
timeoutMs,
|
|
timeoutSeconds,
|
|
commandRunner: runCommandWithTimeout,
|
|
thinkLevel: resolvedThinkLevel,
|
|
verboseLevel: resolvedVerboseLevel,
|
|
runId: sessionId,
|
|
});
|
|
emitAgentEvent({
|
|
runId: sessionId,
|
|
stream: "job",
|
|
data: {
|
|
state: "done",
|
|
startedAt,
|
|
endedAt: Date.now(),
|
|
to: opts.to,
|
|
sessionId,
|
|
durationMs: Date.now() - startedAt,
|
|
},
|
|
});
|
|
} catch (err) {
|
|
emitAgentEvent({
|
|
runId: sessionId,
|
|
stream: "job",
|
|
data: {
|
|
state: "error",
|
|
startedAt,
|
|
endedAt: Date.now(),
|
|
to: opts.to,
|
|
sessionId,
|
|
durationMs: Date.now() - startedAt,
|
|
error: String(err),
|
|
},
|
|
});
|
|
throw err;
|
|
}
|
|
|
|
// If the agent returned a new session id, persist it.
|
|
const returnedSessionId = result.meta.agentMeta?.sessionId;
|
|
if (
|
|
returnedSessionId &&
|
|
returnedSessionId !== sessionId &&
|
|
sessionStore &&
|
|
sessionEntry &&
|
|
sessionKey &&
|
|
storePath
|
|
) {
|
|
sessionEntry.sessionId = returnedSessionId;
|
|
sessionEntry.updatedAt = Date.now();
|
|
sessionStore[sessionKey] = sessionEntry;
|
|
await saveSessionStore(storePath, sessionStore);
|
|
}
|
|
|
|
const payloads = result.payloads ?? [];
|
|
const deliver = opts.deliver === true;
|
|
const targetTo = opts.to ? normalizeE164(opts.to) : allowFrom[0];
|
|
if (deliver && !targetTo) {
|
|
throw new Error(
|
|
"Delivering to WhatsApp requires --to <E.164> or inbound.allowFrom[0]",
|
|
);
|
|
}
|
|
|
|
if (opts.json) {
|
|
const normalizedPayloads = payloads.map((p) => ({
|
|
text: p.text ?? "",
|
|
mediaUrl: p.mediaUrl ?? null,
|
|
mediaUrls: p.mediaUrls ?? (p.mediaUrl ? [p.mediaUrl] : undefined),
|
|
}));
|
|
runtime.log(
|
|
JSON.stringify(
|
|
{
|
|
payloads: normalizedPayloads,
|
|
meta: result.meta,
|
|
},
|
|
null,
|
|
2,
|
|
),
|
|
);
|
|
// If JSON output was requested, suppress additional human-readable logs unless we're
|
|
// also delivering, in which case we still proceed to send below.
|
|
if (!deliver) return;
|
|
}
|
|
|
|
if (payloads.length === 0) {
|
|
runtime.log("No reply from agent.");
|
|
return;
|
|
}
|
|
|
|
for (const payload of payloads) {
|
|
const mediaList =
|
|
payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
|
|
if (!opts.json) {
|
|
const lines: string[] = [];
|
|
if (payload.text) lines.push(payload.text.trimEnd());
|
|
for (const url of mediaList) {
|
|
lines.push(`MEDIA:${url}`);
|
|
}
|
|
runtime.log(lines.join("\n"));
|
|
}
|
|
|
|
if (deliver && targetTo) {
|
|
const text = payload.text ?? "";
|
|
const media = mediaList;
|
|
if (!text && media.length === 0) continue;
|
|
|
|
const primaryMedia = media[0];
|
|
await deps.sendMessageWhatsApp(targetTo, text, {
|
|
verbose: false,
|
|
mediaUrl: primaryMedia,
|
|
});
|
|
|
|
for (const extra of media.slice(1)) {
|
|
await deps.sendMessageWhatsApp(targetTo, "", {
|
|
verbose: false,
|
|
mediaUrl: extra,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|