macroclaw 0.12.0 → 0.14.0

package/src/settings.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { applyEnvOverrides, loadSettings, printSettings, type Settings, saveSettings } from "./settings";
+import { type Settings, SettingsManager } from "./settings";
 
 const tmpDir = "/tmp/macroclaw-settings-test";
 
@@ -17,9 +17,14 @@ afterEach(() => {
   if (existsSync(tmpDir)) rmSync(tmpDir, { recursive: true });
 });
 
-describe("loadSettings", () => {
-  it("returns null when file does not exist", () => {
-    expect(loadSettings(tmpDir)).toBeNull();
+describe("SettingsManager.load", () => {
+  it("exits when file does not exist", () => {
+    const mockExit = mock((_code?: number) => { throw new Error("exit"); });
+    const origExit = process.exit;
+    process.exit = mockExit as typeof process.exit;
+    expect(() => new SettingsManager(tmpDir).load()).toThrow("exit");
+    process.exit = origExit;
+    expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("reads and validates settings from file", () => {
@@ -28,7 +33,7 @@ describe("loadSettings", () => {
       botToken: "123:ABC",
       chatId: "12345678",
     }));
-    const settings = loadSettings(tmpDir);
+    const settings = new SettingsManager(tmpDir).load();
     expect(settings).toEqual({
       botToken: "123:ABC",
       chatId: "12345678",
@@ -49,7 +54,7 @@ describe("loadSettings", () => {
       logLevel: "info",
       pinoramaUrl: "http://localhost:6200",
     }));
-    const settings = loadSettings(tmpDir);
+    const settings = new SettingsManager(tmpDir).load();
     expect(settings).toEqual({
       botToken: "tok",
       chatId: "123",
@@ -70,7 +75,7 @@ describe("loadSettings", () => {
     process.exit = mockExit as any;
 
     try {
-      loadSettings(tmpDir);
+      new SettingsManager(tmpDir).load();
     } catch {
       // expected
     }
@@ -88,7 +93,7 @@ describe("loadSettings", () => {
     process.exit = mockExit as any;
 
     try {
-      loadSettings(tmpDir);
+      new SettingsManager(tmpDir).load();
     } catch {
       // expected
     }
@@ -110,7 +115,7 @@ describe("loadSettings", () => {
     process.exit = mockExit as any;
 
     try {
-      loadSettings(tmpDir);
+      new SettingsManager(tmpDir).load();
     } catch {
       // expected
     }
@@ -120,22 +125,48 @@ describe("loadSettings", () => {
   });
 });
 
-describe("saveSettings", () => {
+describe("SettingsManager.save", () => {
   it("creates directory and writes file", () => {
-    saveSettings(validSettings, tmpDir);
-    const saved = loadSettings(tmpDir);
+    const mgr = new SettingsManager(tmpDir);
+    mgr.save(validSettings);
+    const saved = mgr.load();
     expect(saved).toEqual(validSettings);
   });
 
   it("overwrites existing file", () => {
-    saveSettings(validSettings, tmpDir);
-    const updated = { ...validSettings, model: "opus" };
-    saveSettings(updated, tmpDir);
-    expect(loadSettings(tmpDir)).toEqual(updated);
+    const mgr = new SettingsManager(tmpDir);
+    mgr.save(validSettings);
+    const updated = { ...validSettings, model: "opus" as const };
+    mgr.save(updated);
+    expect(mgr.load()).toEqual(updated);
   });
 });
 
-describe("applyEnvOverrides", () => {
+describe("SettingsManager.loadRaw", () => {
+  it("returns null when file does not exist", () => {
+    expect(new SettingsManager("/nonexistent/path").loadRaw()).toBeNull();
+  });
+
+  it("reads and parses valid settings file", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(join(tmpDir, "settings.json"), JSON.stringify({ botToken: "tok", chatId: "123" }));
+    expect(new SettingsManager(tmpDir).loadRaw()).toEqual({ botToken: "tok", chatId: "123" });
+  });
+
+  it("returns null for invalid JSON", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(join(tmpDir, "settings.json"), "not json");
+    expect(new SettingsManager(tmpDir).loadRaw()).toBeNull();
+  });
+
+  it("returns null for non-object JSON", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(join(tmpDir, "settings.json"), '"just a string"');
+    expect(new SettingsManager(tmpDir).loadRaw()).toBeNull();
+  });
+});
+
+describe("SettingsManager.applyEnvOverrides", () => {
   const envVars = [
     "TELEGRAM_BOT_TOKEN", "AUTHORIZED_CHAT_ID", "MODEL",
     "WORKSPACE", "OPENAI_API_KEY", "LOG_LEVEL", "PINORAMA_URL",
@@ -157,14 +188,14 @@ describe("applyEnvOverrides", () => {
   });
 
   it("returns original settings when no env vars set", () => {
-    const { settings, overrides } = applyEnvOverrides(validSettings);
+    const { settings, overrides } = new SettingsManager(tmpDir).applyEnvOverrides(validSettings);
     expect(settings).toEqual(validSettings);
     expect(overrides.size).toBe(0);
   });
 
   it("overrides model from MODEL env var", () => {
     process.env.MODEL = "opus";
-    const { settings, overrides } = applyEnvOverrides(validSettings);
+    const { settings, overrides } = new SettingsManager(tmpDir).applyEnvOverrides(validSettings);
     expect(settings.model).toBe("opus");
     expect(overrides.has("model")).toBe(true);
   });
@@ -173,7 +204,7 @@ describe("applyEnvOverrides", () => {
     process.env.TELEGRAM_BOT_TOKEN = "override-token";
     process.env.AUTHORIZED_CHAT_ID = "99999";
     process.env.OPENAI_API_KEY = "sk-override";
-    const { settings, overrides } = applyEnvOverrides(validSettings);
+    const { settings, overrides } = new SettingsManager(tmpDir).applyEnvOverrides(validSettings);
     expect(settings.botToken).toBe("override-token");
     expect(settings.chatId).toBe("99999");
     expect(settings.openaiApiKey).toBe("sk-override");
@@ -184,7 +215,7 @@ describe("applyEnvOverrides", () => {
     process.env.WORKSPACE = "/override/path";
     process.env.LOG_LEVEL = "error";
     process.env.PINORAMA_URL = "http://override:6200";
-    const { settings, overrides } = applyEnvOverrides(validSettings);
+    const { settings, overrides } = new SettingsManager(tmpDir).applyEnvOverrides(validSettings);
     expect(settings.workspace).toBe("/override/path");
     expect(settings.logLevel).toBe("error");
     expect(settings.pinoramaUrl).toBe("http://override:6200");
@@ -194,13 +225,13 @@ describe("applyEnvOverrides", () => {
   });
 });
 
-describe("printSettings", () => {
+describe("SettingsManager.print", () => {
   it("does not throw", () => {
-    expect(() => printSettings(validSettings, new Set())).not.toThrow();
+    expect(() => new SettingsManager(tmpDir).print(validSettings, new Set())).not.toThrow();
   });
 
   it("does not throw with overrides", () => {
-    expect(() => printSettings(validSettings, new Set(["model"]))).not.toThrow();
+    expect(() => new SettingsManager(tmpDir).print(validSettings, new Set(["model"]))).not.toThrow();
   });
 
   it("does not throw with optional fields set", () => {
@@ -209,12 +240,18 @@ describe("printSettings", () => {
       openaiApiKey: "sk-1234567890",
       pinoramaUrl: "http://localhost:6200",
     };
-    expect(() => printSettings(full, new Set(["model", "openaiApiKey"]))).not.toThrow();
+    expect(() => new SettingsManager(tmpDir).print(full, new Set(["model", "openaiApiKey"]))).not.toThrow();
   });
 
   it("masks botToken showing only last 4 chars", () => {
-    // We test the masking indirectly — printSettings shouldn't throw
-    // and the function exists primarily for the startup log
-    expect(() => printSettings({ ...validSettings, botToken: "ab" }, new Set())).not.toThrow();
+    expect(() => new SettingsManager(tmpDir).print({ ...validSettings, botToken: "ab" }, new Set())).not.toThrow();
+  });
+});
+
+describe("SettingsManager.envMapping", () => {
+  it("is a static property with all settings keys", () => {
+    expect(SettingsManager.envMapping.botToken).toBe("TELEGRAM_BOT_TOKEN");
+    expect(SettingsManager.envMapping.chatId).toBe("AUTHORIZED_CHAT_ID");
+    expect(SettingsManager.envMapping.model).toBe("MODEL");
   });
 });

package/src/settings.ts

@@ -7,8 +7,8 @@ const log = createLogger("settings");
 
 export const settingsSchema = z.object({
   botToken: z.string(),
-  chatId: z.string(),
-  model: z.string().default("sonnet"),
+  chatId: z.string().regex(/^-?\d+$/, "Must be a numeric Telegram chat ID"),
+  model: z.enum(["haiku", "sonnet", "opus"]).default("sonnet"),
   workspace: z.string().default("~/.macroclaw-workspace"),
   openaiApiKey: z.string().optional(),
   logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
@@ -17,78 +17,99 @@ export const settingsSchema = z.object({
 
 export type Settings = z.infer<typeof settingsSchema>;
 
-const defaultDir = resolve(process.env.HOME || "~", ".macroclaw");
+export function maskValue(key: string, value: string | undefined): string {
+  if (value === undefined) return "(not set)";
+  if (key === "botToken" || key === "openaiApiKey") {
+    return value.length > 4 ? `****${value.slice(-4)}` : "****";
+  }
+  return value;
+}
 
-export function loadSettings(dir: string = defaultDir): Settings {
-  const path = join(dir, "settings.json");
-  if (!existsSync(path)) return null as unknown as Settings;
+const defaultDir = resolve(process.env.HOME || "~", ".macroclaw");
 
-  let raw: unknown;
-  try {
-    raw = JSON.parse(readFileSync(path, "utf-8"));
-  } catch (err) {
-    log.error({ err }, "settings.json is not valid JSON");
-    process.exit(1);
+export class SettingsManager {
+  readonly #dir: string;
+
+  static readonly envMapping: Record<keyof Settings, string> = {
+    botToken: "TELEGRAM_BOT_TOKEN",
+    chatId: "AUTHORIZED_CHAT_ID",
+    model: "MODEL",
+    workspace: "WORKSPACE",
+    openaiApiKey: "OPENAI_API_KEY",
+    logLevel: "LOG_LEVEL",
+    pinoramaUrl: "PINORAMA_URL",
+  };
+
+  constructor(dir: string = defaultDir) {
+    this.#dir = dir;
   }
 
-  const result = settingsSchema.safeParse(raw);
-  if (!result.success) {
-    log.error({ issues: result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`) }, "settings.json validation failed");
-    process.exit(1);
+  get dir(): string {
+    return this.#dir;
   }
 
-  return result.data;
-}
+  load(): Settings {
+    const path = join(this.#dir, "settings.json");
+    if (!existsSync(path)) {
+      log.error({ path }, "settings.json not found. Run `macroclaw setup` first.");
+      process.exit(1);
+    }
 
-export function saveSettings(settings: Settings, dir: string = defaultDir): void {
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "settings.json"), `${JSON.stringify(settings, null, 2)}\n`);
-}
+    let raw: unknown;
+    try {
+      raw = JSON.parse(readFileSync(path, "utf-8"));
+    } catch {
+      raw = null;
+    }
+
+    const result = settingsSchema.safeParse(raw);
+    if (!result.success) {
+      log.error({ issues: result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`) }, "settings.json validation failed");
+      process.exit(1);
+    }
+
+    return result.data;
+  }
 
-// --- Env var overrides ---
-
-const envMapping: Record<keyof Settings, string> = {
-  botToken: "TELEGRAM_BOT_TOKEN",
-  chatId: "AUTHORIZED_CHAT_ID",
-  model: "MODEL",
-  workspace: "WORKSPACE",
-  openaiApiKey: "OPENAI_API_KEY",
-  logLevel: "LOG_LEVEL",
-  pinoramaUrl: "PINORAMA_URL",
-};
-
-export function applyEnvOverrides(settings: Settings): { settings: Settings; overrides: Set<string> } {
-  const merged = { ...settings };
-  const overrides = new Set<string>();
-
-  for (const [key, envVar] of Object.entries(envMapping)) {
-    const value = process.env[envVar];
-    if (value !== undefined) {
-      (merged as Record<string, unknown>)[key] = value;
-      overrides.add(key);
+  loadRaw(): Record<string, unknown> | null {
+    const path = join(this.#dir, "settings.json");
+    if (!existsSync(path)) return null;
+    try {
+      const raw = JSON.parse(readFileSync(path, "utf-8"));
+      return typeof raw === "object" && raw !== null ? raw : null;
+    } catch {
+      return null;
     }
   }
 
-  return { settings: merged, overrides };
-}
+  save(settings: Settings): void {
+    mkdirSync(this.#dir, { recursive: true });
+    writeFileSync(join(this.#dir, "settings.json"), `${JSON.stringify(settings, null, 2)}\n`);
+  }
 
-// --- Startup log ---
+  applyEnvOverrides(settings: Settings): { settings: Settings; overrides: Set<string> } {
+    const merged = { ...settings };
+    const overrides = new Set<string>();
 
-export function maskValue(key: string, value: string | undefined): string {
-  if (value === undefined) return "(not set)";
-  if (key === "botToken" || key === "openaiApiKey") {
-    return value.length > 4 ? `****${value.slice(-4)}` : "****";
+    for (const [key, envVar] of Object.entries(SettingsManager.envMapping)) {
+      const value = process.env[envVar];
+      if (value !== undefined) {
+        (merged as Record<string, unknown>)[key] = value;
+        overrides.add(key);
+      }
+    }
+
+    return { settings: merged, overrides };
   }
-  return value;
-}
 
-export function printSettings(settings: Settings, overrides: Set<string>): void {
-  const lines = ["Settings:"];
-  for (const key of Object.keys(envMapping) as (keyof Settings)[]) {
-    const value = settings[key];
-    const masked = maskValue(key, value);
-    const suffix = overrides.has(key) ? " (env)" : "";
-    lines.push(`  ${key}: ${masked}${suffix}`);
+  print(settings: Settings, overrides: Set<string>): void {
+    const lines = ["Settings:"];
+    for (const key of Object.keys(SettingsManager.envMapping) as (keyof Settings)[]) {
+      const value = settings[key];
+      const masked = maskValue(key, value);
+      const suffix = overrides.has(key) ? " (env)" : "";
+      lines.push(`  ${key}: ${masked}${suffix}`);
+    }
+    log.info(lines.join("\n"));
   }
-  log.info(lines.join("\n"));
 }