macroclaw 0.9.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "macroclaw",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Telegram-to-Claude-Code bridge",
   "license": "MIT",
   "type": "module",
@@ -19,7 +19,8 @@
   "scripts": {
     "start": "bun run src/main.ts",
     "dev": "bun run --watch src/main.ts",
-    "check": "tsc --noEmit && biome check && bun test",
+    "check": "tsc --noEmit && biome check && bun test && bun run depcheck",
+    "depcheck": "depcruise src --config .dependency-cruiser.json --output-type err",
     "typecheck": "tsc --noEmit",
     "lint": "biome check",
     "lint:fix": "biome check --fix --unsafe",
@@ -41,6 +42,7 @@
   "devDependencies": {
     "@biomejs/biome": "^2.4.6",
     "bun-types": "^1.3.10",
+    "dependency-cruiser": "^17.3.8",
     "typescript": "^5.9.3"
   }
 }

package/src/app.ts

@@ -1,8 +1,7 @@
 import type { Bot } from "grammy";
-import type { Claude } from "./claude";
 import { CronScheduler } from "./cron";
 import { createLogger } from "./logger";
-import { Orchestrator, type OrchestratorResponse } from "./orchestrator";
+import { type Claude, Orchestrator, type OrchestratorResponse } from "./orchestrator";
 import { isAvailable as isSttAvailable, transcribe } from "./stt";
 import { createBot, downloadFile, sendFile, sendResponse } from "./telegram";
 

package/src/cli.test.ts

@@ -115,6 +115,8 @@ function mockService(overrides?: Partial<SystemService>): SystemService {
 		start: mock(() => ""),
 		stop: mock(() => {}),
 		update: mock(() => ""),
+		status: mock(() => ({ installed: false, running: false, platform: "systemd" as const })),
+		logs: mock(() => "journalctl -u macroclaw -n 50 --no-pager"),
 		...overrides,
 	};
 }
@@ -155,6 +157,27 @@ describe("Cli.service", () => {
 		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 }));
+		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 }));
+		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 }));
+		cli.service("logs", undefined, true);
+		expect(logs).toHaveBeenCalledWith(true);
+	});
+
 	it("throws for unknown action", () => {
 		const cli = new Cli(undefined, mockService());
 		expect(() => cli.service("bogus")).toThrow("Unknown service action: bogus");

package/src/cli.ts

@@ -83,7 +83,7 @@ export class Cli {
 		exec(args.join(" "), { cwd: settings.workspace, stdio: "inherit", env: { ...process.env, CLAUDECODE: "" } });
 	}
 
-	service(action: string, token?: string): void {
+	service(action: string, token?: string, follow?: boolean): void {
 		switch (action) {
 			case "install": {
 				const logCmd = this.#systemService.install(token);
@@ -108,6 +108,23 @@ export class Cli {
 				console.log(`Service updated. Check logs:\n  ${logCmd}`);
 				break;
 			}
+			case "status": {
+				const s = this.#systemService.status();
+				const lines = [
+					`Platform: ${s.platform}`,
+					`Installed: ${s.installed ? "yes" : "no"}`,
+					`Running: ${s.running ? "yes" : "no"}`,
+				];
+				if (s.pid) lines.push(`PID: ${s.pid}`);
+				if (s.uptime) lines.push(`Active since: ${s.uptime}`);
+				console.log(lines.join("\n"));
+				break;
+			}
+			case "logs": {
+				const cmd = this.#systemService.logs(follow);
+				console.log(cmd);
+				break;
+			}
 			default:
 				throw new Error(`Unknown service action: ${action}`);
 		}
@@ -169,6 +186,19 @@ const serviceUpdateCommand = defineCommand({
 	run: () => { try { defaultCli.service("update"); } catch (err) { handleError(err); } },
 });
 
+const serviceStatusCommand = defineCommand({
+	meta: { name: "status", description: "Show service installation and running status" },
+	run: () => { try { defaultCli.service("status"); } catch (err) { handleError(err); } },
+});
+
+const serviceLogsCommand = defineCommand({
+	meta: { name: "logs", description: "Print the command to view service logs" },
+	args: {
+		follow: { type: "boolean", alias: "f", description: "Follow log output in real-time" },
+	},
+	run: ({ args }) => { try { defaultCli.service("logs", undefined, args.follow); } catch (err) { handleError(err); } },
+});
+
 const serviceCommand = defineCommand({
 	meta: { name: "service", description: "Manage macroclaw system service" },
 	subCommands: {
@@ -177,6 +207,8 @@ const serviceCommand = defineCommand({
 		start: serviceStartCommand,
 		stop: serviceStopCommand,
 		update: serviceUpdateCommand,
+		status: serviceStatusCommand,
+		logs: serviceLogsCommand,
 	},
 });
 

package/src/orchestrator.ts

@@ -12,7 +12,8 @@ import { createLogger } from "./logger";
 import { CRON_TIMEOUT, MAIN_TIMEOUT, SYSTEM_PROMPT } from "./prompts";
 import { Queue } from "./queue";
 import { loadSessions, saveSessions } from "./sessions";
-import type { ButtonSpec } from "./telegram";
+
+type ButtonSpec = string | { text: string; data: string };
 
 const log = createLogger("orchestrator");
 
@@ -42,6 +43,7 @@ const textResultType = { type: "text" } as const;
 // --- Public response type ---
 
 export type { ButtonSpec };
+export type { Claude };
 
 export interface OrchestratorResponse {
   message: string;

package/src/service.test.ts

@@ -588,3 +588,115 @@ describe("update", () => {
 		}
 	});
 });
+
+describe("status", () => {
+	it("returns not installed, not running when service file missing", () => {
+		mockExistsSync.mockImplementation(() => false);
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd === "systemctl is-active macroclaw") throw new Error("not found");
+			return "";
+		});
+		const mgr = createManager();
+		const s = mgr.status();
+		expect(s.installed).toBe(false);
+		expect(s.running).toBe(false);
+		expect(s.platform).toBe("systemd");
+		expect(s.pid).toBeUndefined();
+		expect(s.uptime).toBeUndefined();
+	});
+
+	it("returns installed but not running for systemd", () => {
+		mockExistsSync.mockImplementation(() => true);
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd === "systemctl is-active macroclaw") return SYSTEMD_INACTIVE;
+			return "";
+		});
+		const mgr = createManager();
+		const s = mgr.status();
+		expect(s.installed).toBe(true);
+		expect(s.running).toBe(false);
+		expect(s.pid).toBeUndefined();
+	});
+
+	it("returns pid and uptime for running systemd service", () => {
+		mockExistsSync.mockImplementation(() => true);
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd === "systemctl is-active macroclaw") return SYSTEMD_ACTIVE;
+			if (cmd.startsWith("systemctl show macroclaw")) return "MainPID=42\nActiveEnterTimestamp=Thu 2026-03-12 10:00:00 UTC";
+			return "";
+		});
+		const mgr = createManager();
+		const s = mgr.status();
+		expect(s.installed).toBe(true);
+		expect(s.running).toBe(true);
+		expect(s.pid).toBe(42);
+		expect(s.uptime).toBe("Thu 2026-03-12 10:00:00 UTC");
+	});
+
+	it("returns pid for running launchd service", () => {
+		mockExistsSync.mockImplementation(() => true);
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd.startsWith("launchctl list ")) return LAUNCHD_RUNNING;
+			return "";
+		});
+		const mgr = createManager({ platform: "darwin" });
+		const s = mgr.status();
+		expect(s.installed).toBe(true);
+		expect(s.running).toBe(true);
+		expect(s.platform).toBe("launchd");
+		expect(s.pid).toBe(12345);
+	});
+
+	it("handles systemctl show failure gracefully", () => {
+		mockExistsSync.mockImplementation(() => true);
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd === "systemctl is-active macroclaw") return SYSTEMD_ACTIVE;
+			if (cmd.startsWith("systemctl show")) throw new Error("failed");
+			return "";
+		});
+		const mgr = createManager();
+		const s = mgr.status();
+		expect(s.running).toBe(true);
+		expect(s.pid).toBeUndefined();
+		expect(s.uptime).toBeUndefined();
+	});
+
+	it("handles launchctl list failure gracefully during status", () => {
+		mockExistsSync.mockImplementation(() => true);
+		let callCount = 0;
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd.startsWith("launchctl list ")) {
+				callCount++;
+				if (callCount === 1) return LAUNCHD_RUNNING;
+				throw new Error("failed");
+			}
+			return "";
+		});
+		const mgr = createManager({ platform: "darwin" });
+		const s = mgr.status();
+		expect(s.running).toBe(true);
+		expect(s.pid).toBeUndefined();
+	});
+});
+
+describe("logs", () => {
+	it("returns journalctl command for systemd", () => {
+		const mgr = createManager();
+		expect(mgr.logs()).toBe("journalctl -u macroclaw -n 50 --no-pager");
+	});
+
+	it("returns journalctl follow command for systemd", () => {
+		const mgr = createManager();
+		expect(mgr.logs(true)).toBe("journalctl -u macroclaw -f");
+	});
+
+	it("returns tail command for launchd", () => {
+		const mgr = createManager({ platform: "darwin" });
+		expect(mgr.logs()).toBe("tail -n 50 /home/testuser/.macroclaw/logs/stdout.log");
+	});
+
+	it("returns tail follow command for launchd", () => {
+		const mgr = createManager({ platform: "darwin" });
+		expect(mgr.logs(true)).toBe("tail -f /home/testuser/.macroclaw/logs/stdout.log /home/testuser/.macroclaw/logs/stderr.log");
+	});
+});

package/src/service.ts

@@ -50,12 +50,22 @@ interface LinuxUser {
 	home: string;
 }
 
+export interface ServiceStatus {
+	installed: boolean;
+	running: boolean;
+	platform: Platform;
+	pid?: number;
+	uptime?: string;
+}
+
 export interface SystemService {
 	install: (oauthToken?: string) => string;
 	uninstall: () => void;
 	start: () => string;
 	stop: () => void;
 	update: () => string;
+	status: () => ServiceStatus;
+	logs: (follow?: boolean) => string;
 }
 
 export class ServiceManager implements SystemService {
@@ -229,6 +239,46 @@ export class ServiceManager implements SystemService {
 		return this.#logTailCommand();
 	}
 
+	status(): ServiceStatus {
+		const result: ServiceStatus = {
+			installed: this.isInstalled,
+			running: this.isRunning,
+			platform: this.#platform,
+		};
+
+		if (result.running) {
+			if (this.#platform === "launchd") {
+				try {
+					const out = this.#deps.execSync(`launchctl list ${LAUNCHD_LABEL}`);
+					const pidMatch = /"PID"\s*=\s*(\d+)/.exec(out);
+					if (pidMatch) result.pid = Number(pidMatch[1]);
+				} catch { /* best effort */ }
+			} else {
+				try {
+					const out = this.#deps.execSync("systemctl show macroclaw --property=MainPID,ActiveEnterTimestamp --no-pager");
+					const pidMatch = /MainPID=(\d+)/.exec(out);
+					if (pidMatch && pidMatch[1] !== "0") result.pid = Number(pidMatch[1]);
+					const tsMatch = /ActiveEnterTimestamp=(.+)/.exec(out);
+					if (tsMatch?.[1].trim()) result.uptime = tsMatch[1].trim();
+				} catch { /* best effort */ }
+			}
+		}
+
+		return result;
+	}
+
+	logs(follow = false): string {
+		if (this.#platform === "launchd") {
+			const logDir = resolve(this.#deps.home, ".macroclaw/logs");
+			return follow
+				? `tail -f ${logDir}/stdout.log ${logDir}/stderr.log`
+				: `tail -n 50 ${logDir}/stdout.log`;
+		}
+		return follow
+			? "journalctl -u macroclaw -f"
+			: "journalctl -u macroclaw -n 50 --no-pager";
+	}
+
 	#resolvePath(binary: string): string {
 		try {
 			return this.#deps.execSync(`which ${binary}`).trim();