@rethinkingstudio/clawpilot 2.1.0-beta.3 → 2.1.0-beta.5

package/dist/relay/hermes-relay-manager.js

@@ -1,17 +1,30 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
 import { WebSocket } from "ws";
 import { handleLocalCommand } from "../commands/local-handlers.js";
 import { handleProviderCommand } from "../commands/provider-handlers.js";
 import { getServicePlatform } from "../platform/service-manager.js";
-import { checkHermesHealth, listHermesModels, streamHermesChat } from "../hermes/api-client.js";
+import { checkHermesHealth, createHermesJob, deleteHermesJob, listHermesJobs, listHermesModels, pauseHermesJob, resumeHermesJob, runHermesJob, streamHermesChat, updateHermesJob, } from "../hermes/api-client.js";
 import { HermesSessionStore } from "../hermes/session-store.js";
 const DEFAULT_HERMES_MODEL = "hermes-agent";
 const DEFAULT_CONTEXT_TOKENS = 200_000;
+const HERMES_CRON_OUTPUT_DIR = join(homedir(), ".hermes", "cron", "output");
+const HERMES_HOME_DIR = join(homedir(), ".hermes");
+const HERMES_SOUL_PATH = join(HERMES_HOME_DIR, "SOUL.md");
+const HERMES_HEALTHCHECK_FAST_INTERVAL_MS = 5_000;
+const HERMES_HEALTHCHECK_SLOW_INTERVAL_MS = 30_000;
+const HERMES_HEALTHCHECK_MAX_BACKOFF_MS = 30_000;
 export async function runHermesRelayManager(opts) {
     const wsUrl = buildRelayUrl(opts.relayServerUrl, opts.gatewayId, opts.relaySecret);
     const sessionStore = new HermesSessionStore();
     const activeRuns = new Map();
     const activeRunBySessionKey = new Map();
     const lastSessionState = new Map();
+    let runtimeOnline = false;
+    let healthTimer = null;
+    let healthProbeInFlight = false;
+    let currentHealthIntervalMs = HERMES_HEALTHCHECK_FAST_INTERVAL_MS;
     return new Promise((resolve) => {
         let relayWs;
         try {
@@ -27,6 +40,54 @@ export async function runHermesRelayManager(opts) {
                 relayWs.send(JSON.stringify(msg));
             }
         }
+        async function probeHermesHealth() {
+            if (healthProbeInFlight)
+                return;
+            healthProbeInFlight = true;
+            try {
+                await checkHermesHealth(opts.hermesApiBaseUrl, opts.hermesApiKey);
+                if (!runtimeOnline) {
+                    runtimeOnline = true;
+                    console.log("[runtime:hermes] api connected");
+                    send({ type: "gateway_connected" });
+                }
+                setHealthCheckInterval(HERMES_HEALTHCHECK_SLOW_INTERVAL_MS);
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                if (runtimeOnline) {
+                    runtimeOnline = false;
+                    console.log(`[runtime:hermes] api disconnected: ${reason}`);
+                    send({ type: "gateway_disconnected", reason });
+                }
+                setHealthCheckInterval(Math.min(currentHealthIntervalMs < HERMES_HEALTHCHECK_FAST_INTERVAL_MS
+                    ? HERMES_HEALTHCHECK_FAST_INTERVAL_MS
+                    : currentHealthIntervalMs * 2, HERMES_HEALTHCHECK_MAX_BACKOFF_MS));
+            }
+            finally {
+                healthProbeInFlight = false;
+            }
+        }
+        function startHealthChecks() {
+            currentHealthIntervalMs = HERMES_HEALTHCHECK_FAST_INTERVAL_MS;
+            setHealthCheckInterval(currentHealthIntervalMs);
+            void probeHermesHealth();
+        }
+        function setHealthCheckInterval(intervalMs) {
+            if (healthTimer && currentHealthIntervalMs === intervalMs)
+                return;
+            stopHealthChecks();
+            currentHealthIntervalMs = intervalMs;
+            healthTimer = setInterval(() => {
+                void probeHermesHealth();
+            }, currentHealthIntervalMs);
+        }
+        function stopHealthChecks() {
+            if (healthTimer) {
+                clearInterval(healthTimer);
+                healthTimer = null;
+            }
+        }
         function upsertSessionSnapshot(sessionKey, patch = {}) {
             const now = Date.now();
             const existing = lastSessionState.get(sessionKey);
@@ -48,7 +109,7 @@ export async function runHermesRelayManager(opts) {
             return next;
         }
         async function respondModels(requestId) {
-            const models = await listHermesModels(opts.hermesApiBaseUrl);
+            const models = await listHermesModels(opts.hermesApiBaseUrl, opts.hermesApiKey);
             send({
                 type: "res",
                 id: requestId,
@@ -119,6 +180,121 @@ export async function runHermesRelayManager(opts) {
                 },
             });
         }
+        async function respondTodayCronMessages(requestId) {
+            const now = new Date();
+            const jobs = await listHermesJobs(opts.hermesApiBaseUrl, opts.hermesApiKey);
+            const messages = jobs
+                .map((job) => toTodayCronMessage(job, now))
+                .filter((value) => value !== null)
+                .sort((lhs, rhs) => lhs.createdAt - rhs.createdAt);
+            send({
+                type: "res",
+                id: requestId,
+                ok: true,
+                payload: { messages },
+            });
+        }
+        async function respondCronList(requestId) {
+            const jobs = await listHermesJobs(opts.hermesApiBaseUrl, opts.hermesApiKey);
+            send({
+                type: "res",
+                id: requestId,
+                ok: true,
+                payload: {
+                    jobs: jobs.map(toCronJobPayload),
+                },
+            });
+        }
+        async function respondCronAdd(requestId, params) {
+            const payload = normalizeCronCreatePayload(params);
+            const job = await createHermesJob(payload, opts.hermesApiBaseUrl, opts.hermesApiKey);
+            send({ type: "res", id: requestId, ok: true, payload: { job: toCronJobPayload(job) } });
+        }
+        async function respondCronUpdate(requestId, params) {
+            const { id, patch } = normalizeCronUpdatePayload(params);
+            let job;
+            if (typeof patch.enabled === "boolean" && Object.keys(patch).length === 1) {
+                job = patch.enabled
+                    ? await resumeHermesJob(id, opts.hermesApiBaseUrl, opts.hermesApiKey)
+                    : await pauseHermesJob(id, opts.hermesApiBaseUrl, opts.hermesApiKey);
+            }
+            else {
+                job = await updateHermesJob(id, patch, opts.hermesApiBaseUrl, opts.hermesApiKey);
+            }
+            send({ type: "res", id: requestId, ok: true, payload: { job: toCronJobPayload(job) } });
+        }
+        async function respondCronRemove(requestId, params) {
+            const id = normalizeCronJobId(params);
+            await deleteHermesJob(id, opts.hermesApiBaseUrl, opts.hermesApiKey);
+            send({ type: "res", id: requestId, ok: true, payload: { ok: true } });
+        }
+        async function respondCronRun(requestId, params) {
+            const id = normalizeCronJobId(params);
+            const job = await runHermesJob(id, opts.hermesApiBaseUrl, opts.hermesApiKey);
+            send({ type: "res", id: requestId, ok: true, payload: { job: toCronJobPayload(job) } });
+        }
+        async function respondCronRuns(requestId, params) {
+            const id = normalizeCronJobId(params);
+            const jobs = await listHermesJobs(opts.hermesApiBaseUrl, opts.hermesApiKey);
+            const job = jobs.find((item) => item.id === id);
+            const entries = buildCronRunEntries(job);
+            send({
+                type: "res",
+                id: requestId,
+                ok: true,
+                payload: {
+                    entries,
+                    nextOffset: null,
+                },
+            });
+        }
+        async function respondCronMessageHistory(requestId, params) {
+            const id = normalizeCronJobId(params);
+            const limit = normalizeOptionalLimit(params);
+            send({
+                type: "res",
+                id: requestId,
+                ok: true,
+                payload: {
+                    jobId: id,
+                    sessionKey: `agent:main:cron:${id}`,
+                    messages: readHermesJobHistory(id, limit),
+                    hasMore: false,
+                },
+            });
+        }
+        function respondRuntimeFileGet(requestId, params) {
+            const fileName = normalizeRuntimeFileName(params);
+            const content = existsSync(HERMES_SOUL_PATH) ? readFileSync(HERMES_SOUL_PATH, "utf8") : "";
+            send({
+                type: "res",
+                id: requestId,
+                ok: true,
+                payload: {
+                    file: {
+                        name: fileName,
+                        content,
+                    },
+                },
+            });
+        }
+        function respondRuntimeFileSet(requestId, params) {
+            const { name, content } = normalizeRuntimeFileWrite(params);
+            mkdirSync(HERMES_HOME_DIR, { recursive: true });
+            writeFileSync(HERMES_SOUL_PATH, content, "utf8");
+            send({
+                type: "res",
+                id: requestId,
+                ok: true,
+                payload: {
+                    ok: true,
+                    file: {
+                        name,
+                        content,
+                    },
+                },
+            });
+        }
         function abortRun(runId, sessionKey) {
             const resolvedRunId = runId ?? (sessionKey ? activeRunBySessionKey.get(sessionKey) : undefined);
             if (!resolvedRunId)
@@ -161,6 +337,7 @@ export async function runHermesRelayManager(opts) {
             try {
                 const result = await streamHermesChat({
                     baseUrl: opts.hermesApiBaseUrl,
+                    apiKey: opts.hermesApiKey,
                     sessionId: existing?.hermesSessionId,
                     model: nextModel,
                     userMessage: message,
@@ -245,18 +422,7 @@ export async function runHermesRelayManager(opts) {
             console.log(`Connected to relay server for Hermes (gatewayId=${opts.gatewayId})`);
             send({ type: "relay_hello", platform: getServicePlatform() });
             opts.onConnected?.();
-            void checkHermesHealth(opts.hermesApiBaseUrl)
-                .then(() => {
-                console.log("[runtime:hermes] api connected");
-                send({ type: "gateway_connected" });
-            })
-                .catch((error) => {
-                console.log(`[runtime:hermes] api disconnected: ${error instanceof Error ? error.message : String(error)}`);
-                send({
-                    type: "gateway_disconnected",
-                    reason: error instanceof Error ? error.message : String(error),
-                });
-            });
+            startHealthChecks();
         });
         relayWs.on("message", async (raw) => {
             let msg;
@@ -309,6 +475,46 @@ export async function runHermesRelayManager(opts) {
                         if (requestId)
                             respondSessions(requestId);
                         return;
+                    case "cron.list":
+                        if (requestId)
+                            await respondCronList(requestId);
+                        return;
+                    case "cron.add":
+                        if (requestId)
+                            await respondCronAdd(requestId, msg.params ?? {});
+                        return;
+                    case "cron.update":
+                        if (requestId)
+                            await respondCronUpdate(requestId, msg.params ?? {});
+                        return;
+                    case "cron.remove":
+                        if (requestId)
+                            await respondCronRemove(requestId, msg.params ?? {});
+                        return;
+                    case "cron.run":
+                        if (requestId)
+                            await respondCronRun(requestId, msg.params ?? {});
+                        return;
+                    case "cron.runs":
+                        if (requestId)
+                            await respondCronRuns(requestId, msg.params ?? {});
+                        return;
+                    case "cron.messages.today":
+                        if (requestId)
+                            await respondTodayCronMessages(requestId);
+                        return;
+                    case "cron.messages.history":
+                        if (requestId)
+                            await respondCronMessageHistory(requestId, msg.params ?? {});
+                        return;
+                    case "runtime.files.get":
+                        if (requestId)
+                            respondRuntimeFileGet(requestId, msg.params ?? {});
+                        return;
+                    case "runtime.files.set":
+                        if (requestId)
+                            respondRuntimeFileSet(requestId, msg.params ?? {});
+                        return;
                     case "chat.send":
                         await handleChatSend((msg.params ?? {}));
                         return;
@@ -352,6 +558,7 @@ export async function runHermesRelayManager(opts) {
             }
         });
         relayWs.on("close", (code, reason) => {
+            stopHealthChecks();
             console.log(`Hermes relay connection closed: ${code} ${reason.toString()}`);
             opts.onDisconnected?.();
             resolve(code !== 4000);
@@ -361,6 +568,338 @@ export async function runHermesRelayManager(opts) {
         });
     });
 }
+function toTodayCronMessage(job, now) {
+    const runAt = parseHermesDate(job.lastRunAt ?? job.updatedAt ?? null);
+    if (!runAt || !isSameLocalDay(runAt, now))
+        return null;
+    const output = readLatestHermesJobOutput(job.id);
+    const createdAtMs = output?.timestampMs ?? runAt.getTime();
+    const createdAt = Math.floor(createdAtMs / 1000);
+    const content = (output?.content?.trim() || job.prompt?.trim() || "").trim();
+    return {
+        id: stableInt(`${job.id}:${createdAt}`),
+        jobId: job.name?.trim() || job.id,
+        sessionKey: `agent:main:cron:${job.id}`,
+        runId: `${job.id}:${createdAt}`,
+        role: "assistant",
+        content,
+        createdAt,
+        updatedAt: createdAt,
+    };
+}
+function toCronJobPayload(job) {
+    const schedule = toCronSchedulePayload(job);
+    const output = readLatestHermesJobOutput(job.id);
+    const lastRunAtMs = toUnixMs(job.lastRunAt) ?? (output ? Math.floor(output.timestampMs) : undefined);
+    const updatedAtMs = toUnixMs(job.updatedAt) ?? Date.now();
+    return {
+        id: job.id,
+        agentId: null,
+        name: job.name?.trim() || job.id,
+        description: null,
+        enabled: job.enabled ?? true,
+        deleteAfterRun: false,
+        createdAtMs: toUnixMs(job.createdAt) ?? updatedAtMs,
+        updatedAtMs,
+        schedule,
+        sessionTarget: "isolated",
+        wakeMode: "next-heartbeat",
+        payload: {
+            kind: "agentTurn",
+            message: job.prompt ?? "",
+        },
+        delivery: {
+            mode: "none",
+            channel: null,
+            to: null,
+            bestEffort: null,
+        },
+        state: {
+            nextRunAtMs: toUnixMs(job.nextRunAt),
+            runningAtMs: job.state === "running" ? Date.now() : null,
+            lastRunAtMs,
+            lastStatus: normalizeJobStatus(job.lastStatus, job.state),
+            lastError: job.lastError ?? null,
+            lastDurationMs: null,
+        },
+    };
+}
+function toCronSchedulePayload(job) {
+    const schedule = job.schedule ?? {};
+    const kind = typeof schedule.kind === "string" ? schedule.kind : null;
+    switch (kind) {
+        case "cron":
+            return {
+                kind: "cron",
+                expr: typeof schedule.expr === "string" ? schedule.expr : (job.scheduleDisplay ?? "* * * * *"),
+                tz: null,
+            };
+        case "interval": {
+            const minutes = typeof schedule.minutes === "number" ? schedule.minutes : 60;
+            return {
+                kind: "every",
+                everyMs: minutes * 60_000,
+                anchorMs: null,
+            };
+        }
+        case "once":
+            return {
+                kind: "at",
+                at: typeof schedule.run_at === "string" ? schedule.run_at : typeof schedule.runAt === "string" ? schedule.runAt : new Date().toISOString(),
+            };
+        default:
+            return {
+                kind: "cron",
+                expr: "0 9 * * *",
+                tz: null,
+            };
+    }
+}
+function normalizeJobStatus(lastStatus, state) {
+    if (lastStatus === "ok" || lastStatus === "error")
+        return lastStatus;
+    if (state === "completed")
+        return "ok";
+    return null;
+}
+function toUnixMs(value) {
+    const date = parseHermesDate(value ?? null);
+    return date ? date.getTime() : null;
+}
+function normalizeCronCreatePayload(params) {
+    const raw = asRecord(params);
+    const name = typeof raw.name === "string" ? raw.name.trim() : "";
+    const schedule = cronScheduleString(raw.schedule);
+    const payload = asRecord(raw.payload);
+    const prompt = typeof payload.message === "string" ? payload.message.trim() : "";
+    if (!name || !schedule || !prompt) {
+        throw new Error("invalid cron.add payload");
+    }
+    return {
+        name,
+        schedule,
+        prompt,
+        deliver: "local",
+    };
+}
+function normalizeCronUpdatePayload(params) {
+    const raw = asRecord(params);
+    const id = normalizeCronJobId(params);
+    const patchInput = asRecord(raw.patch);
+    const patch = {};
+    if (typeof patchInput.name === "string" && patchInput.name.trim()) {
+        patch.name = patchInput.name.trim();
+    }
+    if ("enabled" in patchInput && typeof patchInput.enabled === "boolean") {
+        patch.enabled = patchInput.enabled;
+    }
+    if ("schedule" in patchInput) {
+        patch.schedule = cronSchedulePayload(patchInput.schedule);
+    }
+    const payload = asRecord(patchInput.payload);
+    if (typeof payload.message === "string") {
+        patch.prompt = payload.message.trim();
+    }
+    if (Object.keys(patch).length === 0) {
+        throw new Error("invalid cron.update patch");
+    }
+    return { id, patch };
+}
+function normalizeCronJobId(params) {
+    const raw = asRecord(params);
+    const id = typeof raw.id === "string" ? raw.id.trim() : "";
+    if (!id)
+        throw new Error("missing cron job id");
+    return id;
+}
+function normalizeOptionalLimit(params) {
+    const raw = asRecord(params);
+    const value = typeof raw.limit === "number" ? raw.limit : Number.parseInt(String(raw.limit ?? "50"), 10);
+    return Number.isFinite(value) ? Math.max(1, Math.min(value, 200)) : 50;
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null ? value : {};
+}
+function cronScheduleString(rawSchedule) {
+    const schedule = asRecord(rawSchedule);
+    switch (schedule.kind) {
+        case "cron": {
+            const expr = typeof schedule.expr === "string" ? schedule.expr.trim() : "";
+            if (!expr)
+                throw new Error("missing cron expression");
+            return expr;
+        }
+        case "every": {
+            const everyMs = typeof schedule.everyMs === "number" ? schedule.everyMs : 0;
+            if (everyMs <= 0)
+                throw new Error("invalid interval");
+            return `every ${formatDurationMs(everyMs)}`;
+        }
+        case "at": {
+            const at = typeof schedule.at === "string" ? schedule.at.trim() : "";
+            if (!at)
+                throw new Error("missing schedule.at");
+            return at;
+        }
+        default:
+            throw new Error("unsupported cron schedule");
+    }
+}
+function cronSchedulePayload(rawSchedule) {
+    const schedule = asRecord(rawSchedule);
+    switch (schedule.kind) {
+        case "cron": {
+            const expr = typeof schedule.expr === "string" ? schedule.expr.trim() : "";
+            if (!expr)
+                throw new Error("missing cron expression");
+            return { kind: "cron", expr, display: expr };
+        }
+        case "every": {
+            const everyMs = typeof schedule.everyMs === "number" ? schedule.everyMs : 0;
+            if (everyMs <= 0)
+                throw new Error("invalid interval");
+            return {
+                kind: "interval",
+                minutes: Math.max(1, Math.round(everyMs / 60_000)),
+                display: `every ${formatDurationMs(everyMs)}`,
+            };
+        }
+        case "at": {
+            const at = typeof schedule.at === "string" ? schedule.at.trim() : "";
+            if (!at)
+                throw new Error("missing schedule.at");
+            return {
+                kind: "once",
+                run_at: at,
+                display: `once at ${at}`,
+            };
+        }
+        default:
+            throw new Error("unsupported cron schedule");
+    }
+}
+function formatDurationMs(ms) {
+    if (ms % 86_400_000 === 0)
+        return `${ms / 86_400_000}d`;
+    if (ms % 3_600_000 === 0)
+        return `${ms / 3_600_000}h`;
+    return `${Math.max(1, Math.round(ms / 60_000))}m`;
+}
+function buildCronRunEntries(job) {
+    if (!job)
+        return [];
+    const outputs = readHermesJobOutputs(job.id).map((entry) => ({
+        ts: entry.timestampMs,
+        jobId: job.id,
+        jobName: job.name ?? null,
+        action: "run",
+        status: "ok",
+        durationMs: null,
+        runAtMs: entry.timestampMs,
+        error: null,
+        summary: summarizeHermesOutput(entry.content),
+        deliveryStatus: null,
+        model: job.model ?? null,
+        usage: null,
+        sessionKey: `agent:main:cron:${job.id}`,
+    }));
+    if (outputs.length > 0)
+        return outputs.sort((lhs, rhs) => Number(rhs.ts) - Number(lhs.ts));
+    const lastRunAtMs = toUnixMs(job.lastRunAt);
+    if (!lastRunAtMs)
+        return [];
+    return [{
+            ts: lastRunAtMs,
+            jobId: job.id,
+            jobName: job.name ?? null,
+            action: "run",
+            status: normalizeJobStatus(job.lastStatus, job.state) ?? "ok",
+            durationMs: null,
+            runAtMs: lastRunAtMs,
+            error: job.lastError ?? null,
+            summary: summarizeHermesOutput(job.prompt ?? ""),
+            deliveryStatus: null,
+            model: job.model ?? null,
+            usage: null,
+            sessionKey: `agent:main:cron:${job.id}`,
+        }];
+}
+function readHermesJobHistory(jobId, limit) {
+    return readHermesJobOutputs(jobId)
+        .sort((lhs, rhs) => lhs.timestampMs - rhs.timestampMs)
+        .slice(-limit)
+        .map((entry, index) => ({
+        id: stableInt(`${jobId}:${entry.timestampMs}:${index}`),
+        role: "assistant",
+        content: entry.content,
+        runId: `${jobId}:${entry.timestampMs}`,
+        idempotencyKey: null,
+        createdAt: Math.floor(entry.timestampMs / 1000),
+        attachments: [],
+    }));
+}
+function readHermesJobOutputs(jobId) {
+    const jobDir = join(HERMES_CRON_OUTPUT_DIR, jobId);
+    if (!existsSync(jobDir))
+        return [];
+    return readdirSync(jobDir)
+        .filter((name) => name.endsWith(".md"))
+        .map((name) => {
+        const fullPath = join(jobDir, name);
+        const stats = statSync(fullPath);
+        return {
+            content: readFileSync(fullPath, "utf8"),
+            timestampMs: stats.mtimeMs,
+        };
+    })
+        .sort((lhs, rhs) => rhs.timestampMs - lhs.timestampMs);
+}
+function summarizeHermesOutput(content) {
+    const summary = content
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => line.trim())
+        .find(Boolean);
+    return summary ? summary.slice(0, 180) : null;
+}
+function normalizeRuntimeFileName(params) {
+    const raw = asRecord(params);
+    const name = typeof raw.name === "string" ? raw.name.trim() : "";
+    if (name !== "SOUL.md") {
+        throw new Error("unsupported runtime file");
+    }
+    return name;
+}
+function normalizeRuntimeFileWrite(params) {
+    const raw = asRecord(params);
+    const name = normalizeRuntimeFileName(params);
+    const content = typeof raw.content === "string" ? raw.content : "";
+    return { name, content };
+}
+function parseHermesDate(value) {
+    if (!value)
+        return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function isSameLocalDay(lhs, rhs) {
+    return lhs.getFullYear() === rhs.getFullYear()
+        && lhs.getMonth() === rhs.getMonth()
+        && lhs.getDate() === rhs.getDate();
+}
+function readLatestHermesJobOutput(jobId) {
+    const latest = readHermesJobOutputs(jobId)[0];
+    if (!latest)
+        return null;
+    return latest;
+}
+function stableInt(value) {
+    let hash = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = ((hash << 5) - hash + value.charCodeAt(index)) | 0;
+    }
+    return Math.abs(hash) || 1;
+}
 function deriveSessionLabel(sessionKey) {
     if (sessionKey === "agent:main:main")
         return "Main";