macroclaw 0.14.0 → 0.15.0

package/package.json

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

package/src/cli.test.ts

@@ -115,7 +115,8 @@ function mockService(overrides?: Record<string, unknown>): SystemServiceManager
 		uninstall: mock(() => {}),
 		start: mock(() => ""),
 		stop: mock(() => {}),
-		update: mock(() => ""),
+		update: mock(() => ({ previousVersion: "0.6.0", currentVersion: "0.7.0" })),
+		isRunning: false,
 		status: mock(() => ({ installed: false, running: false, platform: "systemd" as const })),
 		logs: mock(() => "journalctl -u macroclaw -n 50 --no-pager"),
 		...overrides,
@@ -151,11 +152,26 @@ describe("Cli.service", () => {
 		expect(stop).toHaveBeenCalled();
 	});
 
-	it("runs update action", () => {
-		const update = mock(() => "tail -f /logs");
-		const cli = new Cli({ systemService: mockService({ update }) });
+	it("runs update action — stops and starts when running", () => {
+		const stop = mock(() => {});
+		const start = mock(() => "tail -f /logs");
+		const update = mock(() => ({ previousVersion: "0.6.0", currentVersion: "0.7.0" }));
+		const cli = new Cli({ systemService: mockService({ stop, start, update, isRunning: true }) });
 		cli.service("update");
+		expect(stop).toHaveBeenCalled();
 		expect(update).toHaveBeenCalled();
+		expect(start).toHaveBeenCalled();
+	});
+
+	it("runs update action — skips stop but still starts when not running", () => {
+		const stop = mock(() => {});
+		const start = mock(() => "tail -f /logs");
+		const update = mock(() => ({ previousVersion: "0.6.0", currentVersion: "0.7.0" }));
+		const cli = new Cli({ systemService: mockService({ stop, start, update, isRunning: false }) });
+		cli.service("update");
+		expect(stop).not.toHaveBeenCalled();
+		expect(update).toHaveBeenCalled();
+		expect(start).toHaveBeenCalled();
 	});
 
 	it("runs status action", () => {

package/src/cli.ts

@@ -55,8 +55,19 @@ export class Cli {
 				console.log("Service stopped.");
 				break;
 			case "update": {
-				const logCmd = this.#serviceManager.update();
-				console.log(`Service updated. Check logs:\n  ${logCmd}`);
+				if (this.#serviceManager.isRunning) {
+					this.#serviceManager.stop();
+					console.log("Service stopped.");
+				}
+				const result = this.#serviceManager.update();
+				if (result.previousVersion === result.currentVersion) {
+					console.log(`macroclaw v${result.currentVersion} (already up to date)`);
+				} else {
+					console.log(`Updated macroclaw v${result.previousVersion} → v${result.currentVersion}`);
+				}
+
+				const logCmd = this.#serviceManager.start();
+				console.log(`Service started. Check logs:\n  ${logCmd}`);
 				break;
 			}
 			case "status": {

package/src/system-service.test.ts

@@ -600,23 +600,58 @@ describe("update", () => {
 		);
 	});
 
-	it("updates launchd without sudo", () => {
+	it("runs bun install without stop/start", () => {
 		const tmpHome = `/tmp/macroclaw-test-updateld-${Date.now()}`;
 		mkdirSync(join(tmpHome, "Library/LaunchAgents"), { recursive: true });
 		writeFileSync(join(tmpHome, "Library/LaunchAgents/com.macroclaw.plist"), "test");
 
 		mockExecSync.mockImplementation((cmd: string) => {
-			if (cmd.startsWith("launchctl list ")) return LAUNCHD_RUNNING;
+			if (cmd === "bun pm ls -g") return "macroclaw@0.6.0\n";
 			return "";
 		});
 		const mgr = createManager({ platform: "darwin", home: tmpHome });
-		mgr.update();
-		expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining("launchctl unload"), expect.anything());
+		const result = mgr.update();
 		expect(mockExecSync).toHaveBeenCalledWith("bun install -g macroclaw@latest", expect.anything());
-		expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining("launchctl load"), expect.anything());
-		for (const call of mockExecSync.mock.calls) {
-			expect(call[0]).not.toMatch(/^sudo /);
-		}
+		expect(mockExecSync).not.toHaveBeenCalledWith(expect.stringContaining("launchctl"), expect.anything());
+		expect(mockExecSync).not.toHaveBeenCalledWith(expect.stringContaining("systemctl"), expect.anything());
+		expect(result.previousVersion).toBe("0.6.0");
+		expect(result.currentVersion).toBe("0.6.0");
+		rmSync(tmpHome, { recursive: true });
+	});
+
+	it("returns different versions when update changes version", () => {
+		const tmpHome = `/tmp/macroclaw-test-updatever-${Date.now()}`;
+		mkdirSync(join(tmpHome, "Library/LaunchAgents"), { recursive: true });
+		writeFileSync(join(tmpHome, "Library/LaunchAgents/com.macroclaw.plist"), "test");
+
+		let installCalled = false;
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd.startsWith("launchctl list ")) return LAUNCHD_STOPPED;
+			if (cmd === "bun install -g macroclaw@latest") { installCalled = true; return ""; }
+			if (cmd === "bun pm ls -g") return installCalled ? "macroclaw@0.7.0\n" : "macroclaw@0.6.0\n";
+			return "";
+		});
+		const mgr = createManager({ platform: "darwin", home: tmpHome });
+		const result = mgr.update();
+		expect(result.previousVersion).toBe("0.6.0");
+		expect(result.currentVersion).toBe("0.7.0");
+		rmSync(tmpHome, { recursive: true });
+	});
+
+	it("returns unknown when version query fails", () => {
+		const tmpHome = `/tmp/macroclaw-test-updateunk-${Date.now()}`;
+		mkdirSync(join(tmpHome, "Library/LaunchAgents"), { recursive: true });
+		writeFileSync(join(tmpHome, "Library/LaunchAgents/com.macroclaw.plist"), "test");
+
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd.startsWith("launchctl list ")) return LAUNCHD_STOPPED;
+			if (cmd === "bun pm ls -g") throw new Error("command not found");
+			return "";
+		});
+		const mgr = createManager({ platform: "darwin", home: tmpHome });
+		const result = mgr.update();
+		expect(result.previousVersion).toBe("unknown");
+		expect(result.currentVersion).toBe("unknown");
 		rmSync(tmpHome, { recursive: true });
 	});
 });

package/src/system-service.ts

@@ -24,6 +24,11 @@ export interface ServiceStatus {
 	uptime?: string;
 }
 
+export interface UpdateResult {
+	previousVersion: string;
+	currentVersion: string;
+}
+
 export class SystemServiceManager {
 	readonly #platform: Platform;
 	readonly #home: string;
@@ -179,25 +184,15 @@ export class SystemServiceManager {
 		log.debug("Service stopped");
 	}
 
-	update(): string {
+	update(): UpdateResult {
 		this.#requireInstalled();
 
-		if (this.#platform === "launchd") {
-			if (this.isRunning) {
-				this.#exec(`launchctl unload ${this.serviceFilePath}`);
-			}
-			this.#exec("bun install -g macroclaw@latest");
-			this.#exec(`launchctl load ${this.serviceFilePath}`);
-		} else {
-			if (this.isRunning) {
-				this.#sudo("systemctl stop macroclaw");
-			}
-			this.#exec("bun install -g macroclaw@latest");
-			this.#sudo("systemctl start macroclaw");
-		}
+		const previousVersion = this.#getInstalledVersion();
+		this.#exec("bun install -g macroclaw@latest");
+		const currentVersion = this.#getInstalledVersion();
 
-		log.debug("Service updated (reinstalled, restarted)");
-		return this.#logTailCommand();
+		log.debug({ previousVersion, currentVersion }, "Service updated");
+		return { previousVersion, currentVersion };
 	}
 
 	status(): ServiceStatus {
@@ -261,6 +256,17 @@ export class SystemServiceManager {
 		return binPath;
 	}
 
+
+	#getInstalledVersion(): string {
+		try {
+			const output = this.#exec("bun pm ls -g");
+			const match = /macroclaw@(\S+)/.exec(output);
+			return match?.[1] ?? "unknown";
+		} catch {
+			return "unknown";
+		}
+	}
+
 	#requireInstalled(): void {
 		if (!this.isInstalled) {
 			throw new Error("Service not installed. Run `macroclaw service install` first.");