macroclaw 0.3.0 → 0.4.0

package/src/service.ts

@@ -0,0 +1,346 @@
+import { execSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { userInfo as osUserInfo, tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { createLogger } from "./logger";
+
+const log = createLogger("service");
+const LAUNCHD_LABEL = "com.macroclaw";
+
+export type Platform = "launchd" | "systemd";
+
+export interface ServiceDeps {
+	existsSync: (path: string) => boolean;
+	writeFileSync: (path: string, data: string) => void;
+	mkdirSync: (path: string, opts?: { recursive: boolean }) => void;
+	rmSync: (path: string) => void;
+	execSync: (cmd: string, opts?: object) => string;
+	tmpdir: () => string;
+	randomUUID: () => string;
+	userInfo: () => { username: string; homedir: string };
+	platform: string;
+	home: string;
+}
+
+function defaultDeps(): ServiceDeps {
+	return {
+		existsSync,
+		writeFileSync,
+		mkdirSync: (path, opts) => mkdirSync(path, opts),
+		rmSync,
+		execSync: (cmd, opts) => execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], ...opts }).toString(),
+		tmpdir,
+		randomUUID,
+		userInfo: () => ({ username: osUserInfo().username, homedir: osUserInfo().homedir }),
+		platform: process.platform,
+		home: process.env.HOME || "~",
+	};
+}
+
+function detectPlatform(platform: string): Platform {
+	if (platform === "darwin") return "launchd";
+	if (platform === "linux") return "systemd";
+	throw new Error("Unsupported platform. Only macOS (launchd) and Linux (systemd) are supported.");
+}
+
+interface LinuxUser {
+	user: string;
+	group: string;
+	home: string;
+}
+
+export interface SystemService {
+	install: (oauthToken?: string) => string;
+	uninstall: () => void;
+	start: () => string;
+	stop: () => void;
+	update: () => string;
+}
+
+export class ServiceManager implements SystemService {
+	readonly #deps: ServiceDeps;
+	readonly #platform: Platform;
+
+	constructor(deps?: Partial<ServiceDeps>) {
+		this.#deps = { ...defaultDeps(), ...deps };
+		this.#platform = detectPlatform(this.#deps.platform);
+	}
+
+	get platform(): Platform {
+		return this.#platform;
+	}
+
+	get serviceFilePath(): string {
+		return this.#platform === "launchd"
+			? resolve(this.#deps.home, "Library/LaunchAgents/com.macroclaw.plist")
+			: "/etc/systemd/system/macroclaw.service";
+	}
+
+	get isInstalled(): boolean {
+		return this.#deps.existsSync(this.serviceFilePath);
+	}
+
+	get isRunning(): boolean {
+		if (this.#platform === "launchd") {
+			try {
+				const out = this.#deps.execSync(`launchctl list ${LAUNCHD_LABEL}`);
+				// If the PID line shows a number (not "-"), the service is running
+				return /"PID"\s*=\s*\d+/.test(out);
+			} catch {
+				return false;
+			}
+		}
+		try {
+			const out = this.#deps.execSync("systemctl is-active macroclaw");
+			return out.trim() === "active";
+		} catch {
+			return false;
+		}
+	}
+
+	install(oauthToken?: string): string {
+		if (this.#platform === "launchd") {
+			this.#installLaunchd(oauthToken);
+		} else {
+			this.#installSystemd();
+		}
+		log.debug("Service installed and started");
+		return this.#logTailCommand();
+	}
+
+	#installLaunchd(oauthToken?: string): void {
+		const settingsPath = resolve(this.#deps.home, ".macroclaw/settings.json");
+		if (!this.#deps.existsSync(settingsPath)) {
+			throw new Error("Settings not found. Run `macroclaw setup` first.");
+		}
+
+		this.#deps.execSync("bun install -g macroclaw");
+		const bunPath = this.#resolvePath("bun");
+		const claudePath = this.#resolvePath("claude");
+		const macroclawPath = this.#resolveGlobalBinPath("macroclaw");
+
+		const pathDirs = [...new Set([dirname(bunPath), dirname(claudePath), dirname(macroclawPath)])];
+
+		const logDir = resolve(this.#deps.home, ".macroclaw/logs");
+		this.#deps.mkdirSync(logDir, { recursive: true });
+		if (this.isRunning) {
+			this.#deps.execSync(`launchctl unload ${this.serviceFilePath}`);
+		}
+
+		this.#deps.writeFileSync(this.serviceFilePath, this.#generateLaunchdPlist(bunPath, macroclawPath, pathDirs, oauthToken));
+		log.debug({ filePath: this.serviceFilePath }, "Wrote launchd plist");
+		this.#deps.execSync(`launchctl load ${this.serviceFilePath}`);
+	}
+
+	#installSystemd(): void {
+		const target = this.#resolveLinuxUser();
+
+		if (this.isRunning) {
+			this.#sudo("systemctl stop macroclaw");
+		}
+
+		this.#deps.execSync("bun install -g macroclaw");
+		const bunPath = this.#resolvePath("bun");
+		const claudePath = this.#resolvePath("claude");
+		const macroclawPath = this.#resolveGlobalBinPath("macroclaw");
+
+		const pathDirs = [...new Set([dirname(bunPath), dirname(claudePath), dirname(macroclawPath)])];
+
+		const unitContent = this.#generateSystemdUnit(bunPath, macroclawPath, target, pathDirs);
+		this.#writeSystemdUnit(unitContent);
+		log.debug({ filePath: this.serviceFilePath, user: target.user }, "Wrote systemd unit");
+		this.#sudo("systemctl daemon-reload");
+		this.#sudo("systemctl enable macroclaw");
+		this.#sudo("systemctl start macroclaw");
+	}
+
+	uninstall(): void {
+		this.#requireInstalled();
+
+		if (this.#platform === "launchd") {
+			if (this.isRunning) {
+				this.#deps.execSync(`launchctl unload ${this.serviceFilePath}`);
+			}
+			this.#deps.rmSync(this.serviceFilePath);
+		} else {
+			if (this.isRunning) {
+				this.#sudo("systemctl stop macroclaw");
+			}
+			try { this.#sudo("systemctl disable macroclaw"); } catch { /* already disabled */ }
+			this.#sudo(`rm ${this.serviceFilePath}`);
+			this.#sudo("systemctl daemon-reload");
+		}
+
+		log.debug("Service uninstalled");
+	}
+
+	start(): string {
+		this.#requireInstalled();
+
+		if (this.isRunning) {
+			throw new Error("Service is already running.");
+		}
+
+		if (this.#platform === "launchd") {
+			this.#deps.execSync(`launchctl load ${this.serviceFilePath}`);
+		} else {
+			this.#sudo("systemctl start macroclaw");
+		}
+
+		log.debug("Service started");
+		return this.#logTailCommand();
+	}
+
+	stop(): void {
+		this.#requireInstalled();
+
+		if (!this.isRunning) {
+			throw new Error("Service is not running.");
+		}
+
+		if (this.#platform === "launchd") {
+			this.#deps.execSync(`launchctl unload ${this.serviceFilePath}`);
+		} else {
+			this.#sudo("systemctl stop macroclaw");
+		}
+
+		log.debug("Service stopped");
+	}
+
+	update(): string {
+		this.#requireInstalled();
+
+		if (this.#platform === "launchd") {
+			if (this.isRunning) {
+				this.#deps.execSync(`launchctl unload ${this.serviceFilePath}`);
+			}
+			this.#deps.execSync("bun install -g macroclaw@latest");
+			this.#deps.execSync(`launchctl load ${this.serviceFilePath}`);
+		} else {
+			if (this.isRunning) {
+				this.#sudo("systemctl stop macroclaw");
+			}
+			this.#deps.execSync("bun install -g macroclaw@latest");
+			this.#sudo("systemctl start macroclaw");
+		}
+
+		log.debug("Service updated (reinstalled, restarted)");
+		return this.#logTailCommand();
+	}
+
+	#resolvePath(binary: string): string {
+		try {
+			return this.#deps.execSync(`which ${binary}`).trim();
+		} catch {
+			throw new Error(`Could not resolve ${binary} path. Is it installed?`);
+		}
+	}
+
+	#resolveGlobalBinPath(binary: string): string {
+		const binDir = this.#deps.execSync("bun pm bin -g").trim();
+		const binPath = join(binDir, binary);
+		if (!this.#deps.existsSync(binPath)) {
+			throw new Error(`Could not find ${binary} in ${binDir}. Is it installed?`);
+		}
+		return binPath;
+	}
+
+
+	#requireInstalled(): void {
+		if (!this.isInstalled) {
+			throw new Error("Service not installed. Run `macroclaw service install` first.");
+		}
+	}
+
+	#logTailCommand(): string {
+		if (this.#platform === "launchd") {
+			const logDir = resolve(this.#deps.home, ".macroclaw/logs");
+			return `tail -f ${logDir}/*.log`;
+		}
+		return "journalctl -u macroclaw -f";
+	}
+
+	#sudo(cmd: string): void {
+		this.#deps.execSync(`sudo ${cmd}`);
+	}
+
+	/** Write unit content to a temp file, then sudo-copy it into /etc/systemd/system/. */
+	#writeSystemdUnit(content: string): void {
+		const tmpPath = join(this.#deps.tmpdir(), `macroclaw-${this.#deps.randomUUID()}.service`);
+		this.#deps.writeFileSync(tmpPath, content);
+		try {
+			this.#sudo(`cp ${tmpPath} ${this.serviceFilePath}`);
+		} finally {
+			try { this.#deps.rmSync(tmpPath); } catch { /* best-effort cleanup */ }
+		}
+	}
+
+	#resolveLinuxUser(): LinuxUser {
+		const info = this.#deps.userInfo();
+		const user = info.username;
+		const home = info.homedir;
+		const group = this.#deps.execSync(`id -gn ${user}`).trim();
+
+		const settingsPath = resolve(home, ".macroclaw/settings.json");
+		if (!this.#deps.existsSync(settingsPath)) {
+			throw new Error(`Settings not found. Run \`macroclaw setup\` first.`);
+		}
+
+		return { user, group, home };
+	}
+
+	#generateLaunchdPlist(bunPath: string, macroclawPath: string, pathDirs: string[], oauthToken?: string): string {
+		const logDir = resolve(this.#deps.home, ".macroclaw/logs");
+		const tokenEnv = oauthToken ? `\n\t\t<key>CLAUDE_CODE_OAUTH_TOKEN</key>\n\t\t<string>${oauthToken}</string>` : "";
+		return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>Label</key>
+	<string>com.macroclaw</string>
+	<key>ProgramArguments</key>
+	<array>
+		<string>${bunPath}</string>
+		<string>${macroclawPath}</string>
+		<string>start</string>
+	</array>
+	<key>KeepAlive</key>
+	<true/>
+	<key>StandardOutPath</key>
+	<string>${logDir}/stdout.log</string>
+	<key>StandardErrorPath</key>
+	<string>${logDir}/stderr.log</string>
+	<key>EnvironmentVariables</key>
+	<dict>
+		<key>HOME</key>
+		<string>${this.#deps.home}</string>
+		<key>PATH</key>
+		<string>${pathDirs.join(":")}</string>${tokenEnv}
+	</dict>
+</dict>
+</plist>
+`;
+	}
+
+	#generateSystemdUnit(bunPath: string, macroclawPath: string, target: LinuxUser, pathDirs: string[]): string {
+		return `[Unit]
+Description=Macroclaw - Telegram-to-Claude-Code bridge
+After=network.target
+
+[Service]
+Type=simple
+User=${target.user}
+Group=${target.group}
+Environment=HOME=${target.home}
+Environment=PATH=${pathDirs.join(":")}
+WorkingDirectory=${target.home}
+ExecStart=${bunPath} ${macroclawPath} start
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+`;
+	}
+}

package/src/setup.test.ts

@@ -1,6 +1,11 @@
 import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
 import type { SetupIO } from "./setup";
 
+// Mock child_process so resolveClaudePath doesn't hit real `which`
+mock.module("node:child_process", () => ({
+  execSync: (_cmd: string) => "/mock/bin/claude\n",
+}));
+
 // Mock Grammy Bot
 const mockBotInit = mock(async () => {});
 const mockBotStart = mock(() => {});
@@ -42,15 +47,27 @@ mock.module("grammy", () => ({
   },
 }));
 
-const { runSetupWizard } = await import("./setup");
+const mockInstall = mock(() => "tail -f /mock/logs");
+
+function createMockServiceInstaller() {
+  return {
+    install: mockInstall,
+  };
+}
+
+const { resolveClaudePath, runSetupWizard } = await import("./setup");
 
-function createMockIO(inputs: string[]): SetupIO {
+function createMockIO(inputs: string[]): SetupIO & { written: string[]; closed: boolean } {
   let index = 0;
   const written: string[] = [];
-  return {
+  const io = {
     ask: async () => inputs[index++] ?? "",
     write: (msg: string) => { written.push(msg); },
+    close: () => { io.closed = true; },
+    written,
+    closed: false,
   };
+  return io;
 }
 
 // Save/restore env vars
@@ -68,6 +85,7 @@ beforeEach(() => {
   mockSetMyCommands.mockClear();
   mockBotCatchHandler = null;
   mockBotCommandHandler = null;
+  mockInstall.mockImplementation(() => "tail -f /mock/logs");
 });
 
 afterEach(() => {
@@ -85,6 +103,7 @@ describe("runSetupWizard", () => {
       "opus",      // model
       "/my/ws",    // workspace
       "sk-test",   // openai key
+      "",          // no service install
     ]);
 
     const settings = await runSetupWizard(io);
@@ -110,6 +129,7 @@ describe("runSetupWizard", () => {
       "",  // accept default model
       "",  // accept default workspace
       "",  // accept default openai key
+      "",  // no service install
     ]);
 
     const settings = await runSetupWizard(io);
@@ -128,6 +148,7 @@ describe("runSetupWizard", () => {
       "",       // press enter for default model
       "",       // press enter for default workspace
       "",       // press enter for no openai key
+      "",       // no service install
     ]);
 
     const settings = await runSetupWizard(io);
@@ -144,6 +165,7 @@ describe("runSetupWizard", () => {
       "",
       "",
       "",
+      "",  // no service install
     ]);
 
     await runSetupWizard(io);
@@ -167,6 +189,7 @@ describe("runSetupWizard", () => {
       "",
       "",
       "",
+      "",  // no service install
     ]);
 
     const settings = await runSetupWizard(io);
@@ -183,6 +206,7 @@ describe("runSetupWizard", () => {
       "",
       "",
       "",
+      "",  // no service install
     ]);
 
     const settings = await runSetupWizard(io);
@@ -198,6 +222,7 @@ describe("runSetupWizard", () => {
       "",
       "",
       "",
+      "",  // no service install
     ]);
 
     const settings = await runSetupWizard(io);
@@ -212,6 +237,7 @@ describe("runSetupWizard", () => {
       "",
       "",
       "",
+      "",  // no service install
     ]);
 
     await runSetupWizard(io);
@@ -229,6 +255,7 @@ describe("runSetupWizard", () => {
       "",
       "",
       "",
+      "",  // no service install
     ]);
 
     await runSetupWizard(io);
@@ -238,4 +265,134 @@ describe("runSetupWizard", () => {
     mockBotCommandHandler!({ chat: { id: 12345 }, reply: mockReply });
     expect(mockReply).toHaveBeenCalledWith("12345");
   });
+
+  it("calls onSettingsReady before service install prompt", async () => {
+    const order: string[] = [];
+    const installer = { install: () => { order.push("install"); return ""; } };
+    const onSettingsReady = () => { order.push("save"); };
+    const io = createMockIO([
+      "tok",
+      "123",
+      "",
+      "",
+      "",
+      "y",
+      "sk-test-token",  // oauth token (macOS)
+    ]);
+
+    await runSetupWizard(io, { serviceInstaller: installer, onSettingsReady, platform: "darwin" });
+
+    expect(order).toEqual(["save", "install"]);
+  });
+
+  it("closes io before running service install", async () => {
+    let closedBeforeInstall = false;
+    const io = createMockIO([
+      "tok",
+      "123",
+      "",
+      "",
+      "",
+      "y",
+      "sk-test-token",  // oauth token (macOS)
+    ]);
+    const installer = { install: () => { closedBeforeInstall = io.closed; return ""; } };
+
+    await runSetupWizard(io, { serviceInstaller: installer, platform: "darwin" });
+
+    expect(closedBeforeInstall).toBe(true);
+  });
+
+  it("installs service when user answers yes", async () => {
+    mockInstall.mockClear();
+    const installer = createMockServiceInstaller();
+    const io = createMockIO([
+      "tok",
+      "123",
+      "",
+      "",
+      "",
+      "y",
+      "sk-test-token",  // oauth token (macOS)
+    ]);
+
+    await runSetupWizard(io, { serviceInstaller: installer, platform: "darwin" });
+
+    expect(mockInstall).toHaveBeenCalled();
+    expect(io.written).toContainEqual(expect.stringContaining("Service installed and started."));
+  });
+
+  it("skips service install when user answers no", async () => {
+    mockInstall.mockClear();
+    const installer = createMockServiceInstaller();
+    const io = createMockIO([
+      "tok",
+      "123",
+      "",
+      "",
+      "",
+      "n",  // no to service install
+    ]);
+
+    await runSetupWizard(io, { serviceInstaller: installer });
+
+    expect(mockInstall).not.toHaveBeenCalled();
+    expect(io.closed).toBe(true);
+  });
+
+  it("skips service install when oauth token is empty on macOS", async () => {
+    mockInstall.mockClear();
+    const installer = createMockServiceInstaller();
+    const io = createMockIO([
+      "tok",
+      "123",
+      "",
+      "",
+      "",
+      "y",
+      "",  // empty oauth token
+    ]);
+
+    const settings = await runSetupWizard(io, { serviceInstaller: installer, platform: "darwin" });
+
+    expect(mockInstall).not.toHaveBeenCalled();
+    expect(io.written).toContainEqual(expect.stringContaining("No token provided"));
+    expect(settings.botToken).toBe("tok");
+  });
+
+  it("handles service install failure gracefully", async () => {
+    mockInstall.mockImplementation(() => { throw new Error("Permission denied"); });
+    const installer = createMockServiceInstaller();
+    const io = createMockIO([
+      "tok",
+      "123",
+      "",
+      "",
+      "",
+      "yes",
+      "sk-test-token",  // oauth token (macOS)
+    ]);
+
+    await runSetupWizard(io, { serviceInstaller: installer, platform: "darwin" });
+
+    expect(io.written).toContainEqual(expect.stringContaining("Service installation failed: Permission denied"));
+  });
+
+  it("fails fast when claude CLI is not found", async () => {
+    const io = createMockIO([]);
+    await expect(
+      runSetupWizard(io, { resolveClaude: () => { throw new Error("Claude Code CLI not found."); } }),
+    ).rejects.toThrow("Claude Code CLI not found.");
+  });
+
+  it("resolveClaudePath returns trimmed path on success", () => {
+    const result = resolveClaudePath(() => "/usr/local/bin/claude\n");
+    expect(result).toBe("/usr/local/bin/claude");
+  });
+
+  it("resolveClaudePath throws when claude is not found", () => {
+    expect(() => resolveClaudePath(() => { throw new Error("not found"); })).toThrow(
+      "Claude Code CLI not found.",
+    );
+  });
 });