macroclaw 0.11.0 → 0.13.0

package/README.md

@@ -1,9 +1,8 @@
 # Macroclaw
 
-Telegram-to-Claude-Code bridge. Bun + Grammy.
+Personal AI assistant, powered by Claude Code, delivered through Telegram.
 
-Uses the Claude Code CLI (`claude -p`) rather than the Agent SDK to avoid any possible
-ToS issues with using a Claude subscription programmatically.
+A lightweight bridge that turns a Telegram chat into a personal AI assistant — one that remembers context across conversations, runs background tasks, handles files and voice messages, and can also write and debug code. Built on the Claude Code CLI (`claude -p`) to stay **compliant with Anthropic's ToS**. The platform handles Telegram I/O, process orchestration, and scheduling; everything else — personality, skills, memory, behavior — lives in a customizable workspace.
 
 ## Security Model
 
@@ -48,6 +47,8 @@ Settings are stored in `~/.macroclaw/settings.json` and validated on startup.
 | `logLevel`     | `LOG_LEVEL`            | `debug`                    | No       |
 | `pinoramaUrl`  | `PINORAMA_URL`         | —                          | No       |
 
+**`openaiApiKey`** is used for voice message transcription via [OpenAI Whisper](https://platform.openai.com/docs/guides/speech-to-text). Without it, voice messages are ignored.
+
 Env vars take precedence over settings file values. On startup, a masked settings summary is printed showing which values were overridden by env vars.
 
 Session state (Claude session IDs) is stored separately in `~/.macroclaw/sessions.json`.

package/package.json

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

package/src/app.test.ts

@@ -3,18 +3,13 @@ import { existsSync, rmSync } from "node:fs";
 import { App, type AppConfig } from "./app";
 import { type Claude, QueryProcessError, type QueryResult, type RunningQuery } from "./claude";
 import { saveSessions } from "./sessions";
+import type { SpeechToText } from "./speech-to-text";
 
-const mockOpenAICreate = mock(async () => ({ text: "transcribed text" }));
+const mockTranscribe = mock(async (_filePath: string) => "transcribed text");
 
-mock.module("openai", () => ({
-  default: class MockOpenAI {
-    audio = {
-      transcriptions: {
-        create: mockOpenAICreate,
-      },
-    };
-  },
-}));
+function mockStt(): SpeechToText {
+  return { transcribe: mockTranscribe } as unknown as SpeechToText;
+}
 
 // Mock Grammy Bot
 mock.module("grammy", () => ({
@@ -59,17 +54,14 @@ mock.module("grammy", () => ({
 
 const tmpSettingsDir = "/tmp/macroclaw-test-settings";
 
-const savedOpenAIKey = process.env.OPENAI_API_KEY;
-
 beforeEach(() => {
-  process.env.OPENAI_API_KEY = "test-key";
+  mockTranscribe.mockReset();
+  mockTranscribe.mockImplementation(async () => "transcribed text");
   if (existsSync(tmpSettingsDir)) rmSync(tmpSettingsDir, { recursive: true });
   saveSessions({ mainSessionId: "test-session" }, tmpSettingsDir);
 });
 
 afterEach(() => {
-  if (savedOpenAIKey) process.env.OPENAI_API_KEY = savedOpenAIKey;
-  else delete process.env.OPENAI_API_KEY;
   if (existsSync(tmpSettingsDir)) rmSync(tmpSettingsDir, { recursive: true });
 });
 
@@ -128,6 +120,7 @@ function makeConfig(overrides?: Partial<AppConfig>): AppConfig {
     workspace: "/tmp/macroclaw-test-workspace",
     settingsDir: tmpSettingsDir,
     claude: defaultMockClaude(),
+    stt: mockStt(),
     ...overrides,
   };
 }
@@ -350,7 +343,7 @@ describe("App", () => {
       globalThis.fetch = mock(() =>
         Promise.resolve(new Response("fake-audio", { status: 200 })),
       ) as any;
-      mockOpenAICreate.mockImplementationOnce(async () => ({ text: "hello from voice" }));
+      mockTranscribe.mockImplementationOnce(async () => "hello from voice");
 
       const config = makeConfig();
       const app = new App(config);
@@ -380,7 +373,7 @@ describe("App", () => {
       globalThis.fetch = mock(() =>
         Promise.resolve(new Response("fake-audio", { status: 200 })),
       ) as any;
-      mockOpenAICreate.mockImplementationOnce(async () => { throw new Error("API error"); });
+      mockTranscribe.mockImplementationOnce(async () => { throw new Error("API error"); });
 
       const config = makeConfig();
       const app = new App(config);
@@ -406,7 +399,7 @@ describe("App", () => {
       globalThis.fetch = mock(() =>
         Promise.resolve(new Response("fake-audio", { status: 200 })),
       ) as any;
-      mockOpenAICreate.mockImplementationOnce(async () => ({ text: "  " }));
+      mockTranscribe.mockImplementationOnce(async () => "  ");
 
       const config = makeConfig();
       const app = new App(config);
@@ -442,9 +435,8 @@ describe("App", () => {
       expect((config.claude as Claude & { calls: CallInfo[] }).calls).toHaveLength(0);
     });
 
-    it("responds with unavailable message when OPENAI_API_KEY is not set", async () => {
-      delete process.env.OPENAI_API_KEY;
-      const config = makeConfig();
+    it("responds with unavailable message when stt is not configured", async () => {
+      const config = makeConfig({ stt: undefined });
       const app = new App(config);
       const bot = app.bot as any;
       const handler = bot.filterHandlers.get("message:voice")![0];
@@ -455,7 +447,7 @@ describe("App", () => {
       });
 
       const sendCalls = (bot.api.sendMessage as any).mock.calls;
-      const call = sendCalls.find((c: any) => c[1].includes("OPENAI_API_KEY"));
+      const call = sendCalls.find((c: any) => c[1].includes("openaiApiKey"));
       expect(call).toBeDefined();
       expect((config.claude as Claude & { calls: CallInfo[] }).calls).toHaveLength(0);
     });

package/src/app.ts

@@ -2,7 +2,7 @@ import type { Bot } from "grammy";
 import { CronScheduler } from "./cron";
 import { createLogger } from "./logger";
 import { type Claude, Orchestrator, type OrchestratorResponse } from "./orchestrator";
-import { isAvailable as isSttAvailable, transcribe } from "./stt";
+import type { SpeechToText } from "./speech-to-text";
 import { createBot, downloadFile, sendFile, sendResponse } from "./telegram";
 
 const log = createLogger("app");
@@ -14,6 +14,7 @@ export interface AppConfig {
   model?: string;
   settingsDir?: string;
   claude?: Claude;
+  stt?: SpeechToText;
 }
 
 export class App {
@@ -118,13 +119,13 @@ export class App {
 
     this.#bot.on("message:voice", async (ctx) => {
       if (ctx.chat.id.toString() !== this.#config.authorizedChatId) return;
-      if (!isSttAvailable()) {
-        await sendResponse(this.#bot, this.#config.authorizedChatId, "[Voice messages not available — set OPENAI_API_KEY to enable]");
+      if (!this.#config.stt) {
+        await sendResponse(this.#bot, this.#config.authorizedChatId, "[Voice messages not available — set openaiApiKey in settings to enable]");
         return;
       }
       try {
         const path = await downloadFile(this.#bot, ctx.message.voice.file_id, this.#config.botToken, "voice.ogg");
-        const text = await transcribe(path);
+        const text = await this.#config.stt.transcribe(path);
         if (!text.trim()) {
           await sendResponse(this.#bot, this.#config.authorizedChatId, "[Could not understand audio]");
           return;

package/src/cli.test.ts

@@ -1,34 +1,39 @@
 import { describe, expect, it, mock } from "bun:test";
 import { runCommand } from "citty";
-import { Cli, handleError, loadRawSettings, type SetupDeps } from "./cli";
+import { Cli, createReadlineIo, handleError } from "./cli";
 import type { SystemService } from "./service";
+import { SettingsManager } from "./settings";
+import type { SetupWizard } from "./setup";
 
 // Only mock ./index — safe since no other test imports it
 const mockStart = mock(async () => {});
 mock.module("./index", () => ({ start: mockStart }));
 
+// Mock child_process so cli.claude() doesn't spawn real processes
+const mockExecSync = mock((_cmd: string, _opts?: object) => "");
+mock.module("node:child_process", () => ({
+	execSync: mockExecSync,
+	execFileSync: () => "",
+}));
+
 const { main } = await import("./cli");
 
-function createMockSetupDeps(): SetupDeps & { saved: { settings: unknown; dir: string } | null } {
-	const result: SetupDeps & { saved: { settings: unknown; dir: string } | null } = {
-		saved: null,
-		initLogger: async () => {},
-		saveSettings: () => {},
-		loadRawSettings: () => null,
-		runSetupWizard: async (io) => {
-			await io.ask("test?");
-			io.write("done");
-			io.close?.();
-			return { botToken: "tok", chatId: "123" };
-		},
-		createReadlineInterface: () => ({
-			question: (_q: string, cb: (a: string) => void) => cb("answer"),
-			close: () => {},
-		}),
-		resolveDir: () => "/home/test/.macroclaw",
-	};
-	result.saveSettings = (settings: unknown, dir: string) => { result.saved = { settings, dir }; };
-	return result;
+function createMockWizard(overrides?: { collectSettings?: (defaults?: Record<string, unknown>) => Promise<unknown>; installService?: () => Promise<void> }) {
+	return {
+		collectSettings: overrides?.collectSettings ?? mock(async () => ({ botToken: "tok", chatId: "123" })),
+		installService: overrides?.installService ?? mock(async () => {}),
+	} as unknown as SetupWizard;
+}
+
+function createMockSettings(overrides?: Partial<SettingsManager>) {
+	return {
+		load: mock(() => ({ botToken: "tok", chatId: "123", model: "sonnet", workspace: "/tmp" })),
+		loadRaw: mock(() => null),
+		save: mock(() => {}),
+		applyEnvOverrides: mock((s: unknown) => ({ settings: s, overrides: new Set() })),
+		print: mock(() => {}),
+		...overrides,
+	} as unknown as SettingsManager;
 }
 
 describe("CLI routing", () => {
@@ -62,49 +67,45 @@ describe("CLI routing", () => {
 
 describe("Cli.setup", () => {
 	it("runs wizard and saves settings", async () => {
-		const deps = createMockSetupDeps();
-		const cli = new Cli(deps);
-		await cli.setup();
-		expect(deps.saved).toEqual({
-			settings: { botToken: "tok", chatId: "123" },
-			dir: "/home/test/.macroclaw",
-		});
-	});
-
-	it("calls initLogger", async () => {
-		const deps = createMockSetupDeps();
-		const mockInit = mock(async () => {});
-		deps.initLogger = mockInit;
-		const cli = new Cli(deps);
+		const wizard = createMockWizard();
+		const settings = createMockSettings();
+		const cli = new Cli({ wizard, settings });
 		await cli.setup();
-		expect(mockInit).toHaveBeenCalled();
+		expect((settings.save as ReturnType<typeof mock>)).toHaveBeenCalledWith({ botToken: "tok", chatId: "123" });
 	});
 
 	it("passes existing settings as defaults to wizard", async () => {
 		const existing = { botToken: "old-tok", chatId: "999" };
 		let receivedDefaults: unknown = null;
-		const deps = createMockSetupDeps();
-		deps.loadRawSettings = () => existing;
-		deps.runSetupWizard = async (io, opts) => {
-			receivedDefaults = opts?.defaults;
-			io.close?.();
-			return { botToken: "tok", chatId: "123" };
-		};
-		const cli = new Cli(deps);
+		const wizard = createMockWizard({
+			collectSettings: async (defaults) => { receivedDefaults = defaults; return { botToken: "tok", chatId: "123" }; },
+		});
+		const settings = createMockSettings({ loadRaw: () => existing } as unknown as Partial<SettingsManager>);
+		const cli = new Cli({ wizard, settings });
 		await cli.setup();
 		expect(receivedDefaults).toEqual(existing);
 	});
 
-	it("closes readline after wizard completes", async () => {
-		const deps = createMockSetupDeps();
-		const mockClose = mock(() => {});
-		deps.createReadlineInterface = () => ({
-			question: (_q: string, cb: (a: string) => void) => cb("answer"),
-			close: mockClose,
-		});
-		const cli = new Cli(deps);
+	it("wizard manages io lifecycle internally", async () => {
+		const wizard = createMockWizard();
+		const cli = new Cli({ wizard, settings: createMockSettings() });
 		await cli.setup();
-		expect(mockClose).toHaveBeenCalled();
+		expect((wizard.collectSettings as ReturnType<typeof mock>)).toHaveBeenCalled();
+		expect((wizard.installService as ReturnType<typeof mock>)).toHaveBeenCalled();
+	});
+
+	it("creates default wizard when none provided", () => {
+		const cli = new Cli({ settings: createMockSettings() });
+		expect(cli).toBeDefined();
+	});
+
+	it("createReadlineIo creates functional io", async () => {
+		const io = createReadlineIo();
+		io.open();
+		const answer = io.ask("test? ");
+		process.stdin.push("hello\n");
+		expect(await answer).toBe("hello");
+		io.close();
 	});
 });
 
@@ -124,67 +125,67 @@ function mockService(overrides?: Partial<SystemService>): SystemService {
 describe("Cli.service", () => {
 	it("runs install action", () => {
 		const install = mock(() => "tail -f /logs");
-		const cli = new Cli(undefined, mockService({ install }));
+		const cli = new Cli({ systemService: mockService({ install }) });
 		cli.service("install");
 		expect(install).toHaveBeenCalled();
 	});
 
 	it("runs uninstall action", () => {
 		const uninstall = mock(() => {});
-		const cli = new Cli(undefined, mockService({ uninstall }));
+		const cli = new Cli({ systemService: mockService({ uninstall }) });
 		cli.service("uninstall");
 		expect(uninstall).toHaveBeenCalled();
 	});
 
 	it("runs start action", () => {
 		const start = mock(() => "tail -f /logs");
-		const cli = new Cli(undefined, mockService({ start }));
+		const cli = new Cli({ systemService: mockService({ start }) });
 		cli.service("start");
 		expect(start).toHaveBeenCalled();
 	});
 
 	it("runs stop action", () => {
 		const stop = mock(() => {});
-		const cli = new Cli(undefined, mockService({ stop }));
+		const cli = new Cli({ systemService: mockService({ stop }) });
 		cli.service("stop");
 		expect(stop).toHaveBeenCalled();
 	});
 
 	it("runs update action", () => {
 		const update = mock(() => "tail -f /logs");
-		const cli = new Cli(undefined, mockService({ update }));
+		const cli = new Cli({ systemService: mockService({ update }) });
 		cli.service("update");
 		expect(update).toHaveBeenCalled();
 	});
 
 	it("runs status action", () => {
 		const status = mock(() => ({ installed: true, running: true, platform: "systemd" as const, pid: 42, uptime: "Thu 2026-03-12 10:00:00 UTC" }));
-		const cli = new Cli(undefined, mockService({ status }));
+		const cli = new Cli({ systemService: mockService({ status }) });
 		cli.service("status");
 		expect(status).toHaveBeenCalled();
 	});
 
 	it("runs logs action", () => {
 		const logs = mock(() => "journalctl -u macroclaw -n 50 --no-pager");
-		const cli = new Cli(undefined, mockService({ logs }));
+		const cli = new Cli({ systemService: mockService({ logs }) });
 		cli.service("logs");
 		expect(logs).toHaveBeenCalledWith(undefined);
 	});
 
 	it("passes follow flag to logs action", () => {
 		const logs = mock(() => "journalctl -u macroclaw -f");
-		const cli = new Cli(undefined, mockService({ logs }));
+		const cli = new Cli({ systemService: mockService({ logs }) });
 		cli.service("logs", undefined, true);
 		expect(logs).toHaveBeenCalledWith(true);
 	});
 
 	it("throws for unknown action", () => {
-		const cli = new Cli(undefined, mockService());
+		const cli = new Cli({ systemService: mockService() });
 		expect(() => cli.service("bogus")).toThrow("Unknown service action: bogus");
 	});
 
 	it("throws service errors", () => {
-		const cli = new Cli(undefined, mockService({ install: () => { throw new Error("Settings not found."); } }));
+		const cli = new Cli({ systemService: mockService({ install: () => { throw new Error("Settings not found."); } }) });
 		expect(() => cli.service("install")).toThrow("Settings not found.");
 	});
 });
@@ -197,21 +198,18 @@ describe("Cli.claude", () => {
 		fs.writeFileSync(`${dir}/settings.json`, JSON.stringify({ botToken: "tok", chatId: "123", model: "opus", workspace: "/tmp" }));
 		fs.writeFileSync(`${dir}/sessions.json`, JSON.stringify({ mainSessionId: "sess-123" }));
 
-		let capturedCmd = "";
-		let capturedOpts: any = {};
-		const exec = mock((cmd: string, opts: object) => { capturedCmd = cmd; capturedOpts = opts; });
-
-		const deps = createMockSetupDeps();
-		deps.resolveDir = () => dir;
-		const cli = new Cli(deps);
-		cli.claude(exec);
+		mockExecSync.mockClear();
+		const cli = new Cli({ settings: new SettingsManager(dir) });
+		cli.claude();
 
 		fs.rmSync(dir, { recursive: true });
 
-		expect(capturedCmd).toBe("claude --resume sess-123 --model opus");
-		expect(capturedOpts.cwd).toBe("/tmp");
-		expect(capturedOpts.stdio).toBe("inherit");
-		expect(capturedOpts.env.CLAUDECODE).toBe("");
+		expect(mockExecSync).toHaveBeenCalledWith(
+			"claude --resume sess-123 --model opus",
+			expect.objectContaining({ cwd: "/tmp", stdio: "inherit" }),
+		);
+		const opts = mockExecSync.mock.calls[0][1] as { env: Record<string, string> };
+		expect(opts.env.CLAUDECODE).toBe("");
 	});
 
 	it("omits --resume when no session exists", async () => {
@@ -221,64 +219,26 @@ describe("Cli.claude", () => {
 		fs.writeFileSync(`${dir}/settings.json`, JSON.stringify({ botToken: "tok", chatId: "123", model: "sonnet", workspace: "/tmp" }));
 		fs.writeFileSync(`${dir}/sessions.json`, JSON.stringify({}));
 
-		let capturedCmd = "";
-		const exec = mock((cmd: string, _opts: object) => { capturedCmd = cmd; });
-
-		const deps = createMockSetupDeps();
-		deps.resolveDir = () => dir;
-		const cli = new Cli(deps);
-		cli.claude(exec);
+		mockExecSync.mockClear();
+		const cli = new Cli({ settings: new SettingsManager(dir) });
+		cli.claude();
 
 		fs.rmSync(dir, { recursive: true });
 
-		expect(capturedCmd).toBe("claude --model sonnet");
-	});
-
-	it("throws when settings are missing", () => {
-		const deps = createMockSetupDeps();
-		deps.resolveDir = () => "/nonexistent/path";
-		const cli = new Cli(deps);
-		expect(() => cli.claude(mock())).toThrow("Settings not found");
-	});
-});
-
-describe("loadRawSettings", () => {
-	it("returns null when file does not exist", () => {
-		expect(loadRawSettings("/nonexistent/path")).toBeNull();
-	});
-
-	it("reads and parses valid settings file", async () => {
-		const dir = await import("node:fs").then(fs => {
-			const d = `/tmp/macroclaw-test-${Date.now()}`;
-			fs.mkdirSync(d, { recursive: true });
-			fs.writeFileSync(`${d}/settings.json`, JSON.stringify({ botToken: "tok", chatId: "123" }));
-			return d;
-		});
-		const result = loadRawSettings(dir);
-		expect(result).toEqual({ botToken: "tok", chatId: "123" });
-		await import("node:fs").then(fs => fs.rmSync(dir, { recursive: true }));
-	});
-
-	it("returns null for invalid JSON", async () => {
-		const dir = await import("node:fs").then(fs => {
-			const d = `/tmp/macroclaw-test-${Date.now()}`;
-			fs.mkdirSync(d, { recursive: true });
-			fs.writeFileSync(`${d}/settings.json`, "not json");
-			return d;
-		});
-		expect(loadRawSettings(dir)).toBeNull();
-		await import("node:fs").then(fs => fs.rmSync(dir, { recursive: true }));
+		expect(mockExecSync).toHaveBeenCalledWith(
+			"claude --model sonnet",
+			expect.objectContaining({ cwd: "/tmp", stdio: "inherit" }),
+		);
 	});
 
-	it("returns null for non-object JSON", async () => {
-		const dir = await import("node:fs").then(fs => {
-			const d = `/tmp/macroclaw-test-${Date.now()}`;
-			fs.mkdirSync(d, { recursive: true });
-			fs.writeFileSync(`${d}/settings.json`, '"just a string"');
-			return d;
-		});
-		expect(loadRawSettings(dir)).toBeNull();
-		await import("node:fs").then(fs => fs.rmSync(dir, { recursive: true }));
+	it("exits when settings are missing", () => {
+		const mockExit = mock((_code?: number) => { throw new Error("exit"); });
+		const origExit = process.exit;
+		process.exit = mockExit as typeof process.exit;
+		const cli = new Cli({ settings: new SettingsManager("/nonexistent/path") });
+		expect(() => cli.claude()).toThrow("exit");
+		process.exit = origExit;
+		expect(mockExit).toHaveBeenCalledWith(1);
 	});
 });
 

package/src/cli.ts

@@ -1,115 +1,66 @@
 import {execSync} from "node:child_process";
-import {existsSync, readFileSync} from "node:fs";
-import {join, resolve} from "node:path";
 import {createInterface} from "node:readline";
 import {defineCommand} from "citty";
-import pkg from "../package.json" with { type: "json" };
-import {initLogger} from "./logger";
+import pkg from "../package.json" with {type: "json"};
 import {ServiceManager, type SystemService} from "./service";
 import {loadSessions} from "./sessions";
-import {loadSettings, saveSettings} from "./settings";
-import {runSetupWizard} from "./setup";
-
-export interface SetupDeps {
-	initLogger: () => Promise<void>;
-	saveSettings: (settings: unknown, dir: string) => void;
-	loadRawSettings: (dir: string) => Record<string, unknown> | null;
-	runSetupWizard: (io: { ask: (q: string) => Promise<string>; write: (m: string) => void; close?: () => void }, opts?: { defaults?: Record<string, unknown>; onSettingsReady?: (settings: unknown) => void }) => Promise<unknown>;
-	createReadlineInterface: () => { question: (q: string, cb: (a: string) => void) => void; close: () => void };
-	resolveDir: () => string;
-}
-
-export function loadRawSettings(dir: string): Record<string, unknown> | null {
-	const path = join(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;
-	}
-}
-
-function defaultSetupDeps(): SetupDeps {
-	return {
-		initLogger,
-		saveSettings: saveSettings as (settings: unknown, dir: string) => void,
-		loadRawSettings,
-		runSetupWizard: runSetupWizard as SetupDeps["runSetupWizard"],
-		createReadlineInterface: () => createInterface({ input: process.stdin, output: process.stdout }),
-		resolveDir: () => resolve(process.env.HOME || "~", ".macroclaw"),
-	};
-}
-
-function defaultSystemService(): SystemService {
-	return new ServiceManager();
-}
+import {SettingsManager} from "./settings";
+import {type SetupIo, SetupWizard} from "./setup";
 
 export class Cli {
-	readonly #setupDeps: SetupDeps;
-	readonly #systemService: SystemService;
-
-	constructor(setupDeps?: Partial<SetupDeps>, systemService?: SystemService) {
-		this.#setupDeps = { ...defaultSetupDeps(), ...setupDeps };
-		this.#systemService = systemService ?? defaultSystemService();
+	readonly #settingsManager: SettingsManager;
+	readonly #setupWizard: SetupWizard;
+	readonly #serviceManager: SystemService;
+
+	constructor(opts?: { wizard?: SetupWizard; settings?: SettingsManager; systemService?: SystemService }) {
+		this.#settingsManager = opts?.settings ?? new SettingsManager();
+		this.#setupWizard = opts?.wizard ?? new SetupWizard(createReadlineIo());
+		this.#serviceManager = opts?.systemService ?? new ServiceManager();
 	}
 
 	async setup(): Promise<void> {
-		await this.#setupDeps.initLogger();
-		const rl = this.#setupDeps.createReadlineInterface();
-		const io = {
-			ask: (question: string): Promise<string> =>
-				new Promise((res) => rl.question(question, (answer: string) => res(answer.trim()))),
-			write: (msg: string) => process.stdout.write(msg),
-			close: () => rl.close(),
-		};
-		const dir = this.#setupDeps.resolveDir();
-		const defaults = this.#setupDeps.loadRawSettings(dir) ?? undefined;
-		const settings = await this.#setupDeps.runSetupWizard(io, {
-			defaults,
-			onSettingsReady: (s) => this.#setupDeps.saveSettings(s, dir),
-		});
-		this.#setupDeps.saveSettings(settings, dir);
+		const defaults = this.#settingsManager.loadRaw() ?? undefined;
+		const settings = await this.#setupWizard.collectSettings(defaults);
+		this.#settingsManager.save(settings);
+		await this.#setupWizard.installService();
 	}
 
-	claude(exec: (cmd: string, opts: object) => void = (cmd, opts) => execSync(cmd, opts)): void {
-		const dir = this.#setupDeps.resolveDir();
-		const settings = loadSettings(dir);
-		if (!settings) throw new Error("Settings not found. Run `macroclaw setup` first.");
-		const sessions = loadSessions(dir);
+	claude(): void {
+		const settings = this.#settingsManager.load();
+		const sessions = loadSessions(this.#settingsManager.dir);
 		const args = ["claude"];
 		if (sessions.mainSessionId) args.push("--resume", sessions.mainSessionId);
 		args.push("--model", settings.model);
-		exec(args.join(" "), { cwd: settings.workspace, stdio: "inherit", env: { ...process.env, CLAUDECODE: "" } });
+		execSync(args.join(" "), { cwd: settings.workspace, stdio: "inherit", env: { ...process.env, CLAUDECODE: "" } });
 	}
 
 	service(action: string, token?: string, follow?: boolean): void {
 		switch (action) {
 			case "install": {
-				const logCmd = this.#systemService.install(token);
+				const logCmd = this.#serviceManager.install(token);
 				console.log(`Service installed and started. Check logs:\n  ${logCmd}`);
 				break;
 			}
 			case "uninstall":
-				this.#systemService.uninstall();
+				this.#serviceManager.uninstall();
 				console.log("Service uninstalled.");
 				break;
 			case "start": {
-				const logCmd = this.#systemService.start();
+				const logCmd = this.#serviceManager.start();
 				console.log(`Service started. Check logs:\n  ${logCmd}`);
 				break;
 			}
 			case "stop":
-				this.#systemService.stop();
+				this.#serviceManager.stop();
 				console.log("Service stopped.");
 				break;
 			case "update": {
-				const logCmd = this.#systemService.update();
+				const logCmd = this.#serviceManager.update();
 				console.log(`Service updated. Check logs:\n  ${logCmd}`);
 				break;
 			}
 			case "status": {
-				const s = this.#systemService.status();
+				const s = this.#serviceManager.status();
 				const lines = [
 					`Platform: ${s.platform}`,
 					`Installed: ${s.installed ? "yes" : "no"}`,
@@ -121,7 +72,7 @@ export class Cli {
 				break;
 			}
 			case "logs": {
-				const cmd = this.#systemService.logs(follow);
+				const cmd = this.#serviceManager.logs(follow);
 				console.log(cmd);
 				break;
 			}
@@ -131,6 +82,17 @@ export class Cli {
 	}
 }
 
+export function createReadlineIo(): SetupIo {
+	let rl: ReturnType<typeof createInterface> | null = null;
+	return {
+		open: () => { rl = createInterface({ input: process.stdin, output: process.stdout }); },
+		close: () => { rl?.close(); rl = null; },
+		ask: (question: string): Promise<string> =>
+			new Promise((res) => rl?.question(question, (answer: string) => res(answer.trim()))),
+		write: (msg: string) => process.stdout.write(msg),
+	};
+}
+
 export function handleError(err: unknown): never {
 	console.error(err instanceof Error ? err.message : String(err));
 	process.exit(1);
@@ -216,4 +178,3 @@ export const main = defineCommand({
 	meta: { name: pkg.name, description: pkg.description, version: pkg.version },
 	subCommands: { start: startCommand, setup: setupCommand, claude: claudeCommand, service: serviceCommand },
 });
-