macroclaw 0.12.0 → 0.14.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.12.0",
+  "version": "0.14.0",
   "description": "Telegram-to-Claude-Code bridge",
   "license": "MIT",
   "type": "module",

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 type { SystemService } from "./service";
+import { Cli, createReadlineIo, handleError } from "./cli";
+import { SettingsManager } from "./settings";
+import type { SetupWizard } from "./setup";
+import type { SystemServiceManager } from "./system-service";
 
 // 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,53 +67,49 @@ 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();
 	});
 });
 
-function mockService(overrides?: Partial<SystemService>): SystemService {
+function mockService(overrides?: Record<string, unknown>): SystemServiceManager {
 	return {
 		install: mock(() => ""),
 		uninstall: mock(() => {}),
@@ -118,73 +119,73 @@ function mockService(overrides?: Partial<SystemService>): SystemService {
 		status: mock(() => ({ installed: false, running: false, platform: "systemd" as const })),
 		logs: mock(() => "journalctl -u macroclaw -n 50 --no-pager"),
 		...overrides,
-	};
+	} as unknown as SystemServiceManager;
 }
 
 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");
+		expect(mockExecSync).toHaveBeenCalledWith(
+			"claude --model sonnet",
+			expect.objectContaining({ cwd: "/tmp", stdio: "inherit" }),
+		);
 	});
 
-	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 }));
-	});
-
-	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 {ServiceManager, type SystemService} from "./service";
+import pkg from "../package.json" with {type: "json"};
 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";
+import {SystemServiceManager} from "./system-service";
 
 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: SystemServiceManager;
+
+	constructor(opts?: { wizard?: SetupWizard; settings?: SettingsManager; systemService?: SystemServiceManager }) {
+		this.#settingsManager = opts?.settings ?? new SettingsManager();
+		this.#setupWizard = opts?.wizard ?? new SetupWizard(createReadlineIo());
+		this.#serviceManager = opts?.systemService ?? new SystemServiceManager();
 	}
 
 	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 },
 });
-

package/src/index.ts

@@ -1,26 +1,19 @@
 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";
-import { applyEnvOverrides, loadSettings, printSettings } from "./settings";
+import { configureLogger, createLogger } from "./logger";
+import { SettingsManager } from "./settings";
 import { SpeechToText } from "./speech-to-text";
 
 export async function start(): Promise<void> {
   const log = createLogger("index");
 
-  const defaultDir = resolve(process.env.HOME || "~", ".macroclaw");
+  const mgr = new SettingsManager();
+  const settings = mgr.load();
+  const { settings: resolved, overrides } = mgr.applyEnvOverrides(settings);
 
-  const settings = loadSettings(defaultDir);
-
-  if (!settings) {
-    log.error("No settings found. Run `macroclaw setup` first.");
-    process.exit(1);
-  }
-
-  const { settings: resolved, overrides } = applyEnvOverrides(settings);
-
-  await initLogger({ level: resolved.logLevel, pinoramaUrl: resolved.pinoramaUrl });
-  printSettings(resolved, overrides);
+  await configureLogger({ level: resolved.logLevel, pinoramaUrl: resolved.pinoramaUrl });
+  mgr.print(resolved, overrides);
 
   const workspace = resolve(resolved.workspace.replace(/^~/, process.env.HOME || "~"));
 

package/src/logger.test.ts

@@ -6,7 +6,7 @@ mock.module("pinorama-transport", () => ({
   default: mockPinoramaTransport,
 }));
 
-const { createLogger, initLogger } = await import("./logger");
+const { createLogger, configureLogger } = await import("./logger");
 
 describe("createLogger", () => {
   it("returns a pino child logger with module field", () => {
@@ -16,29 +16,29 @@ describe("createLogger", () => {
   });
 });
 
-describe("initLogger", () => {
+describe("configureLogger", () => {
   it("does nothing when called without opts", async () => {
     mockPinoramaTransport.mockClear();
-    await initLogger();
+    await configureLogger();
     expect(mockPinoramaTransport).not.toHaveBeenCalled();
   });
 
   it("sets log level from opts", async () => {
     const log = createLogger("opts-level");
-    await initLogger({ level: "warn" });
+    await configureLogger({ level: "warn" });
     expect(log.level).toBe("warn");
-    await initLogger({ level: "info" }); // restore
+    await configureLogger({ level: "info" }); // restore
   });
 
   it("adds pinorama transport from opts", async () => {
     mockPinoramaTransport.mockClear();
-    await initLogger({ pinoramaUrl: "http://example.com/pinorama" });
+    await configureLogger({ pinoramaUrl: "http://example.com/pinorama" });
     expect(mockPinoramaTransport).toHaveBeenCalledWith({ url: "http://example.com/pinorama" });
   });
 
   it("does not add duplicate pinorama transport on second call", async () => {
     mockPinoramaTransport.mockClear();
-    await initLogger({ pinoramaUrl: "http://example.com/pinorama" });
+    await configureLogger({ pinoramaUrl: "http://example.com/pinorama" });
     expect(mockPinoramaTransport).not.toHaveBeenCalled();
   });
 });

package/src/logger.ts

@@ -23,7 +23,7 @@ export interface LoggerOptions {
 
 let pinoramaAdded = false;
 
-export async function initLogger(opts?: LoggerOptions): Promise<void> {
+export async function configureLogger(opts?: LoggerOptions): Promise<void> {
 	if (opts?.level) logger.level = opts.level;
 
 	if (opts?.pinoramaUrl && !pinoramaAdded) {