macroclaw 0.0.0-dev

package/src/cron.test.ts

@@ -0,0 +1,265 @@
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { CronScheduler } from "./cron";
+
+const TEST_DIR = join(import.meta.dir, "..", ".test-workspace-cron");
+const CRON_DIR = join(TEST_DIR, ".macroclaw");
+const CRON_FILE = join(CRON_DIR, "cron.json");
+
+function writeCronConfig(config: any) {
+  mkdirSync(CRON_DIR, { recursive: true });
+  writeFileSync(CRON_FILE, JSON.stringify(config));
+}
+
+function readCronConfig() {
+  return JSON.parse(readFileSync(CRON_FILE, "utf-8"));
+}
+
+function makeOnJob() {
+  return mock((_name: string, _prompt: string, _model?: string) => {});
+}
+
+// Build a cron expression that matches the current minute
+function currentMinuteCron(): string {
+  const now = new Date();
+  return `${now.getMinutes()} ${now.getHours()} * * *`;
+}
+
+// Build a cron expression that never matches now
+function nonMatchingCron(): string {
+  const now = new Date();
+  const otherMinute = (now.getMinutes() + 30) % 60;
+  return `${otherMinute} ${(now.getHours() + 12) % 24} * * *`;
+}
+
+beforeEach(() => {
+  mkdirSync(CRON_DIR, { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(TEST_DIR, { recursive: true, force: true });
+});
+
+describe("CronScheduler", () => {
+  it("calls onJob for matching cron job", () => {
+    writeCronConfig({
+      jobs: [{ name: "test-job", cron: currentMinuteCron(), prompt: "do something" }],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).toHaveBeenCalledWith("test-job", "do something", undefined);
+  });
+
+  it("does not call onJob for non-matching jobs", () => {
+    writeCronConfig({
+      jobs: [{ name: "later", cron: nonMatchingCron(), prompt: "not now" }],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).not.toHaveBeenCalled();
+  });
+
+  it("silently skips when cron.json does not exist", () => {
+    rmSync(CRON_FILE, { force: true });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).not.toHaveBeenCalled();
+  });
+
+  it("does not call onJob on malformed JSON", () => {
+    writeFileSync(CRON_FILE, "not json{{{");
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).not.toHaveBeenCalled();
+  });
+
+  it("does not call onJob when jobs is not an array", () => {
+    writeCronConfig({ jobs: "not-array" });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).not.toHaveBeenCalled();
+  });
+
+  it("skips invalid cron expression and processes valid jobs", () => {
+    writeCronConfig({
+      jobs: [
+        { name: "bad", cron: "invalid cron", prompt: "bad" },
+        { name: "good", cron: currentMinuteCron(), prompt: "good" },
+      ],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).toHaveBeenCalledTimes(1);
+    expect(onJob).toHaveBeenCalledWith("good", "good", undefined);
+  });
+
+  it("stop clears the interval", () => {
+    writeCronConfig({ jobs: [] });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop(); // should not throw
+  });
+
+  it("only evaluates once per minute", () => {
+    writeCronConfig({
+      jobs: [{ name: "once", cron: currentMinuteCron(), prompt: "once" }],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).toHaveBeenCalledTimes(1);
+
+    // Start again with a new instance — the lastMinute tracker is per-instance
+    const onJob2 = makeOnJob();
+    const cron2 = new CronScheduler(TEST_DIR, { onJob: onJob2 });
+    cron2.start();
+    cron2.stop();
+
+    expect(onJob2).toHaveBeenCalledTimes(1);
+  });
+
+  it("handles multiple matching jobs", () => {
+    writeCronConfig({
+      jobs: [
+        { name: "first", cron: currentMinuteCron(), prompt: "first" },
+        { name: "second", cron: currentMinuteCron(), prompt: "second" },
+      ],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).toHaveBeenCalledTimes(2);
+    expect(onJob).toHaveBeenCalledWith("first", "first", undefined);
+    expect(onJob).toHaveBeenCalledWith("second", "second", undefined);
+  });
+
+  it("passes model override to onJob", () => {
+    writeCronConfig({
+      jobs: [{ name: "smart", cron: currentMinuteCron(), prompt: "think hard", model: "opus" }],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).toHaveBeenCalledWith("smart", "think hard", "opus");
+  });
+
+  it("removes non-recurring job after it fires", () => {
+    writeCronConfig({
+      jobs: [
+        { name: "once", cron: currentMinuteCron(), prompt: "one-time", recurring: false },
+        { name: "always", cron: currentMinuteCron(), prompt: "forever" },
+      ],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    expect(onJob).toHaveBeenCalledTimes(2);
+
+    const updated = readCronConfig();
+    expect(updated.jobs).toHaveLength(1);
+    expect(updated.jobs[0].name).toBe("always");
+  });
+
+  it("keeps recurring jobs (default behavior)", () => {
+    writeCronConfig({
+      jobs: [{ name: "keeper", cron: currentMinuteCron(), prompt: "stay" }],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    const updated = readCronConfig();
+    expect(updated.jobs).toHaveLength(1);
+    expect(updated.jobs[0].name).toBe("keeper");
+  });
+
+  it("keeps jobs with recurring: true", () => {
+    writeCronConfig({
+      jobs: [{ name: "explicit", cron: currentMinuteCron(), prompt: "stay", recurring: true }],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    const updated = readCronConfig();
+    expect(updated.jobs).toHaveLength(1);
+  });
+
+  it("still fires job when write-back of cron.json fails", () => {
+    // Write config to a path that will be read successfully
+    writeCronConfig({
+      jobs: [{ name: "once", cron: currentMinuteCron(), prompt: "fire", recurring: false }],
+    });
+
+    // Make cron.json read-only so writeFileSync fails
+    const { chmodSync } = require("node:fs");
+    chmodSync(CRON_FILE, 0o444);
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    chmodSync(CRON_FILE, 0o644);
+
+    expect(onJob).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not write file when no non-recurring jobs fired", () => {
+    writeCronConfig({
+      jobs: [{ name: "recurring", cron: nonMatchingCron(), prompt: "nope", recurring: false }],
+    });
+
+    const onJob = makeOnJob();
+    const cron = new CronScheduler(TEST_DIR, { onJob });
+    cron.start();
+    cron.stop();
+
+    // File should remain unchanged (job still present since it didn't fire)
+    const updated = readCronConfig();
+    expect(updated.jobs).toHaveLength(1);
+  });
+});

package/src/cron.ts

@@ -0,0 +1,108 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { CronExpressionParser } from "cron-parser";
+import { z } from "zod/v4";
+import { createLogger } from "./logger";
+
+const log = createLogger("cron");
+
+const cronJobSchema = z.object({
+  name: z.string(),
+  cron: z.string(),
+  prompt: z.string(),
+  recurring: z.boolean().optional(),
+  model: z.string().optional(),
+});
+
+const cronConfigSchema = z.object({
+  jobs: z.array(cronJobSchema),
+});
+
+type CronConfig = z.infer<typeof cronConfigSchema>;
+
+export interface CronSchedulerConfig {
+  onJob: (name: string, prompt: string, model?: string) => void;
+}
+
+const TICK_INTERVAL = 10_000; // 10 seconds
+
+export class CronScheduler {
+  #lastMinute = -1;
+  #cronPath: string;
+  #config: CronSchedulerConfig;
+  #timer: Timer | null = null;
+
+  constructor(workspace: string, config: CronSchedulerConfig) {
+    this.#cronPath = join(workspace, ".macroclaw", "cron.json");
+    this.#config = config;
+  }
+
+  start(): void {
+    this.#tick();
+    this.#timer = setInterval(() => this.#tick(), TICK_INTERVAL);
+  }
+
+  stop(): void {
+    if (this.#timer) {
+      clearInterval(this.#timer);
+      this.#timer = null;
+    }
+  }
+
+  #tick(): void {
+    const now = new Date();
+    const currentMinute = now.getMinutes() + now.getHours() * 60 + now.getDate() * 1440 + now.getMonth() * 43200;
+
+    // Only evaluate once per minute
+    if (currentMinute === this.#lastMinute) return;
+    this.#lastMinute = currentMinute;
+
+    let config: CronConfig;
+    try {
+      const raw = readFileSync(this.#cronPath, "utf-8");
+      const parsed = cronConfigSchema.safeParse(JSON.parse(raw));
+      if (!parsed.success) {
+        log.warn("cron.json: 'jobs' is not an array");
+        return;
+      }
+      config = parsed.data;
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") return;
+      log.warn({ err: err instanceof Error ? err.message : err }, "Failed to read cron.json");
+      return;
+    }
+
+    const firedNonRecurring: number[] = [];
+
+    for (let i = 0; i < config.jobs.length; i++) {
+      const job = config.jobs[i];
+      try {
+        const interval = CronExpressionParser.parse(job.cron);
+        const prev = interval.prev();
+        const diff = Math.abs(now.getTime() - prev.getTime());
+        // Match if the previous occurrence is within the current minute
+        if (diff < 60_000) {
+          log.debug({ name: job.name, cron: job.cron }, "Cron job triggered");
+          this.#config.onJob(job.name, job.prompt, job.model);
+          if (job.recurring === false) {
+            firedNonRecurring.push(i);
+          }
+        }
+      } catch (err) {
+        log.warn({ cron: job.cron, err: err instanceof Error ? err.message : err }, "Invalid cron expression");
+      }
+    }
+
+    // Remove fired non-recurring jobs (iterate in reverse to preserve indices)
+    if (firedNonRecurring.length > 0) {
+      for (let i = firedNonRecurring.length - 1; i >= 0; i--) {
+        config.jobs.splice(firedNonRecurring[i], 1);
+      }
+      try {
+        writeFileSync(this.#cronPath, `${JSON.stringify(config, null, 2)}\n`);
+      } catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : err }, "Failed to write cron.json");
+      }
+    }
+  }
+}

package/src/history.test.ts

@@ -0,0 +1,92 @@
+import { afterAll, beforeEach, describe, expect, it, spyOn } from "bun:test";
+import * as fs from "node:fs/promises";
+import { logPrompt, logResult } from "./history";
+
+const mockMkdir = spyOn(fs, "mkdir").mockResolvedValue(undefined);
+const mockAppendFile = spyOn(fs, "appendFile").mockResolvedValue(undefined);
+
+beforeEach(() => {
+  mockMkdir.mockClear();
+  mockAppendFile.mockClear();
+});
+
+afterAll(() => {
+  mockMkdir.mockRestore();
+  mockAppendFile.mockRestore();
+});
+
+describe("logPrompt", () => {
+  it("writes a prompt entry as JSONL", async () => {
+    const request = { type: "user", message: "hello" };
+    await logPrompt(request);
+
+    expect(mockMkdir).toHaveBeenCalledTimes(1);
+    expect(mockMkdir.mock.calls[0][1]).toEqual({ recursive: true });
+
+    expect(mockAppendFile).toHaveBeenCalledTimes(1);
+    const written = mockAppendFile.mock.calls[0][1] as string;
+    const parsed = JSON.parse(written);
+    expect(parsed.type).toBe("prompt");
+    expect(parsed.request).toEqual(request);
+    expect(parsed.ts).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+  });
+
+  it("writes cron request", async () => {
+    const request = { type: "cron", name: "daily", prompt: "check" };
+    await logPrompt(request);
+
+    const parsed = JSON.parse(mockAppendFile.mock.calls[0][1] as string);
+    expect(parsed.request).toEqual(request);
+  });
+});
+
+describe("logResult", () => {
+  it("writes a result entry as JSONL", async () => {
+    const response = { action: "send", message: "hi", actionReason: "ok" };
+    await logResult(response);
+
+    expect(mockAppendFile).toHaveBeenCalledTimes(1);
+    const written = mockAppendFile.mock.calls[0][1] as string;
+    const parsed = JSON.parse(written);
+    expect(parsed.type).toBe("result");
+    expect(parsed.response).toEqual(response);
+    expect(parsed.ts).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+  });
+
+  it("writes silent response", async () => {
+    const response = { action: "silent", actionReason: "nothing new" };
+    await logResult(response);
+
+    const parsed = JSON.parse(mockAppendFile.mock.calls[0][1] as string);
+    expect(parsed.response).toEqual(response);
+  });
+});
+
+describe("file path", () => {
+  it("uses today's date in YYYY-MM-DD.jsonl format", async () => {
+    await logPrompt({ type: "user", message: "test" });
+
+    const filePath = mockAppendFile.mock.calls[0][0] as string;
+    const today = new Date().toISOString().slice(0, 10);
+    expect(filePath).toContain(`${today}.jsonl`);
+    expect(filePath).toContain(".macroclaw/history/");
+  });
+});
+
+describe("mkdir", () => {
+  it("creates history directory recursively", async () => {
+    await logPrompt({ type: "user", message: "test" });
+
+    const dirPath = mockMkdir.mock.calls[0][0] as string;
+    expect(dirPath).toContain(".macroclaw/history");
+  });
+});
+
+describe("error handling", () => {
+  it("logs errors but does not throw", async () => {
+    mockAppendFile.mockRejectedValueOnce(new Error("disk full"));
+
+    // Should not throw
+    await logPrompt({ type: "user", message: "test" });
+  });
+});

package/src/history.ts

@@ -0,0 +1,37 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { createLogger } from "./logger";
+
+const log = createLogger("history");
+
+// Minimal types for history logging — intentionally kept broad to avoid coupling
+type HistoryRequest = { type: string; [key: string]: unknown };
+type HistoryResponse = { action: string; actionReason: string; [key: string]: unknown };
+
+type HistoryEntry =
+  | { ts: string; type: "prompt"; request: HistoryRequest }
+  | { ts: string; type: "result"; response: HistoryResponse };
+
+const historyDir = resolve(process.env.HOME || "~", ".macroclaw", "history");
+
+function todayFile(): string {
+  const date = new Date().toISOString().slice(0, 10);
+  return join(historyDir, `${date}.jsonl`);
+}
+
+async function append(entry: HistoryEntry): Promise<void> {
+  try {
+    await mkdir(historyDir, { recursive: true });
+    await appendFile(todayFile(), `${JSON.stringify(entry)}\n`);
+  } catch (err) {
+    log.error({ err }, "Failed to write history entry");
+  }
+}
+
+export async function logPrompt(request: HistoryRequest): Promise<void> {
+  await append({ ts: new Date().toISOString(), type: "prompt", request });
+}
+
+export async function logResult(response: HistoryResponse): Promise<void> {
+  await append({ ts: new Date().toISOString(), type: "result", response });
+}

package/src/index.ts

@@ -0,0 +1,42 @@
+import { cpSync, existsSync, readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { App, type AppConfig } from "./app";
+import { createLogger, initLogger } from "./logger";
+
+await initLogger();
+const log = createLogger("index");
+
+function requireEnv(name: string): string {
+  const value = process.env[name];
+  if (!value) {
+    log.error({ name }, "Missing environment variable");
+    process.exit(1);
+  }
+  return value;
+}
+
+const defaultWorkspace = resolve(process.env.HOME || "~", ".macroclaw-workspace");
+const workspace = process.env.WORKSPACE || defaultWorkspace;
+
+function initWorkspace(workspace: string) {
+  const templateDir = join(dirname(import.meta.dir), "workspace-template");
+  const exists = existsSync(workspace);
+  const empty = exists && readdirSync(workspace).length === 0;
+
+  if (!exists || empty) {
+    log.info({ workspace }, "Initializing workspace from template");
+    cpSync(templateDir, workspace, { recursive: true });
+    log.info("Workspace initialized");
+  }
+}
+
+initWorkspace(workspace);
+
+const config: AppConfig = {
+  botToken: requireEnv("TELEGRAM_BOT_TOKEN"),
+  authorizedChatId: requireEnv("AUTHORIZED_CHAT_ID"),
+  workspace,
+  model: process.env.MODEL,
+};
+
+new App(config).start();

package/src/logger.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it, mock } from "bun:test";
+
+const mockPinoramaTransport = mock(() => ({ write: () => {} }));
+
+mock.module("pinorama-transport", () => ({
+  default: mockPinoramaTransport,
+}));
+
+const { createLogger, initLogger } = await import("./logger");
+
+describe("createLogger", () => {
+  it("returns a pino child logger with module field", () => {
+    const log = createLogger("test-module");
+    expect(log).toBeDefined();
+    expect(log.bindings().module).toBe("test-module");
+  });
+});
+
+describe("initLogger", () => {
+  it("adds pinorama transport when PINORAMA_URL is set", async () => {
+    process.env.PINORAMA_URL = "http://localhost:6200/pinorama";
+    await initLogger();
+    expect(mockPinoramaTransport).toHaveBeenCalledWith({ url: "http://localhost:6200/pinorama" });
+    delete process.env.PINORAMA_URL;
+  });
+
+  it("does nothing when PINORAMA_URL is not set", async () => {
+    delete process.env.PINORAMA_URL;
+    mockPinoramaTransport.mockClear();
+    await initLogger();
+    expect(mockPinoramaTransport).not.toHaveBeenCalled();
+  });
+});

package/src/logger.ts

@@ -0,0 +1,28 @@
+import pino from "pino";
+import pretty from "pino-pretty";
+
+const prettyStream = pretty({
+	ignore: "pid,hostname",
+	messageFormat: "[{module}] {msg}",
+});
+
+const level = (process.env.LOG_LEVEL || "debug") as pino.Level;
+
+const streams: pino.StreamEntry[] = [{ level, stream: prettyStream }];
+
+const logger = pino(
+	{ level: process.env.LOG_LEVEL || "debug" },
+	pino.multistream(streams),
+);
+
+export async function initLogger(): Promise<void> {
+	const pinoramaUrl = process.env.PINORAMA_URL;
+	if (pinoramaUrl) {
+		const { default: pinoramaTransport } = await import("pinorama-transport");
+		streams.push({ level, stream: pinoramaTransport({ url: pinoramaUrl }) });
+	}
+}
+
+export function createLogger(module: string) {
+	return logger.child({ module });
+}