macroclaw 0.22.0 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "macroclaw",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Telegram-to-Claude-Code bridge",
   "license": "MIT",
   "type": "module",

package/src/cron.test.ts

@@ -39,6 +39,12 @@ function minutesAgoCron(minutesAgo: number): string {
   return `${past.getMinutes()} ${past.getHours()} ${past.getDate()} ${past.getMonth() + 1} *`;
 }
 
+// Build a cron expression that matched N days ago
+function daysAgoCron(daysAgo: number): string {
+  const past = new Date(Date.now() - daysAgo * 24 * 60 * 60_000);
+  return `${past.getMinutes()} ${past.getHours()} ${past.getDate()} ${past.getMonth() + 1} *`;
+}
+
 beforeEach(() => {
   mkdirSync(SCHEDULE_DIR, { recursive: true });
 });
@@ -337,4 +343,41 @@ describe("missed non-recurring events", () => {
     const updated = readScheduleConfig();
     expect(updated.jobs).toHaveLength(0);
   });
+
+  it("discards non-recurring job missed by more than a week without firing", () => {
+    writeScheduleConfig({
+      jobs: [
+        { name: "stale", cron: daysAgoCron(10), prompt: "too old", recurring: false },
+        { name: "keeper", cron: nonMatchingCron(), prompt: "stay" },
+      ],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).not.toHaveBeenCalled();
+
+    const updated = readScheduleConfig();
+    expect(updated.jobs).toHaveLength(1);
+    expect(updated.jobs[0].name).toBe("keeper");
+  });
+
+  it("fires non-recurring job missed by 6 days (within week window)", () => {
+    writeScheduleConfig({
+      jobs: [{ name: "recent", cron: daysAgoCron(6), prompt: "still valid", recurring: false }],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).toHaveBeenCalledTimes(1);
+    const call = onJob.mock.calls[0];
+    expect(call[0]).toBe("recent");
+    expect(call[1]).toContain("[missed event, should have fired");
+    expect(call[1]).toContain("still valid");
+  });
 });

package/src/cron.ts

@@ -25,6 +25,7 @@ export interface CronSchedulerConfig {
 }
 
 const TICK_INTERVAL = 10_000; // 10 seconds
+const MAX_MISSED_MS = 7 * 24 * 60 * 60 * 1000; // 1 week
 
 export class CronScheduler {
   #lastMinute = -1;
@@ -87,14 +88,18 @@ export class CronScheduler {
           if (job.recurring === false) {
             firedNonRecurring.push(i);
           }
-        } else if (job.recurring === false && diff >= 60_000) {
-          // Non-recurring job in the past — fire regardless of how late
+        } else if (job.recurring === false && diff >= 60_000 && diff <= MAX_MISSED_MS) {
+          // Non-recurring job in the past — fire if missed within the last week
           const missedMinutes = Math.round(diff / 60_000);
           const firedAt = prev.toISOString();
           const missedPrompt = `[missed event, should have fired ${missedMinutes} min ago at ${firedAt}] ${job.prompt}`;
           log.info({ name: job.name, missedMinutes, firedAt }, "Firing missed non-recurring job");
           this.#config.onJob(job.name, missedPrompt, job.model);
           firedNonRecurring.push(i);
+        } else if (job.recurring === false && diff > MAX_MISSED_MS) {
+          // Non-recurring job missed by more than a week — discard without firing
+          log.warn({ name: job.name, missedMinutes: Math.round(diff / 60_000) }, "Discarding stale non-recurring job");
+          firedNonRecurring.push(i);
         }
       } catch (err) {
         log.warn({ cron: job.cron, err: err instanceof Error ? err.message : err }, "Invalid cron expression");

package/src/system-service.test.ts

@@ -1,10 +1,15 @@
 import { beforeEach, describe, expect, it, mock } from "bun:test";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
+// Capture real fs functions before mocking
+const realFs = await import("node:fs");
+const { existsSync: realExistsSync, mkdirSync, readFileSync, rmSync, writeFileSync } = realFs;
+const existsSync = realExistsSync;
+
 // Mock child_process and os — safe since no other tests depend on real execSync or userInfo
 const mockExecSync = mock((_cmd: string, _opts?: object) => "");
 const mockUserInfo = mock(() => ({ username: "testuser", homedir: "/home/testuser", uid: 1000, gid: 1000, shell: "/bin/bash" }));
+const mockExistsSync = mock((path: string) => realExistsSync(path));
 
 mock.module("node:child_process", () => ({
 	execSync: (...args: unknown[]) => mockExecSync(args[0] as string, args[1] as object),
@@ -15,6 +20,14 @@ mock.module("node:os", () => ({
 	tmpdir: () => "/tmp",
 }));
 
+mock.module("node:fs", () => {
+	const result: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(realFs)) {
+		result[key] = key === "existsSync" ? (path: string) => mockExistsSync(path) : value;
+	}
+	return result;
+});
+
 const { SystemServiceManager } = await import("./system-service");
 
 function createManager(opts?: { platform?: string; home?: string }): InstanceType<typeof SystemServiceManager> {
@@ -29,8 +42,10 @@ const SYSTEMD_INACTIVE = "inactive";
 beforeEach(() => {
 	mockExecSync.mockClear();
 	mockUserInfo.mockClear();
+	mockExistsSync.mockClear();
 	mockExecSync.mockImplementation((_cmd: string, _opts?: object) => "");
 	mockUserInfo.mockImplementation(() => ({ username: "testuser", homedir: "/home/testuser", uid: 1000, gid: 1000, shell: "/bin/bash" }));
+	mockExistsSync.mockImplementation((path: string) => realExistsSync(path));
 });
 
 describe("constructor", () => {
@@ -662,6 +677,7 @@ describe("status", () => {
 			if (cmd === "systemctl is-active macroclaw") throw new Error("not found");
 			return "";
 		});
+		mockExistsSync.mockReturnValue(false);
 		const mgr = createManager({ home: "/nonexistent" });
 		const s = mgr.status();
 		expect(s.installed).toBe(false);