macroclaw 0.41.0 → 0.43.0

package/package.json

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

package/src/cli.test.ts

@@ -134,7 +134,8 @@ function mockService(overrides?: Record<string, unknown>): SystemServiceManager
 		start: mock(() => ""),
 		stop: mock(() => {}),
 		restart: mock(() => ""),
-		update: mock(() => ({ previousVersion: "0.6.0", currentVersion: "0.7.0" })),
+		refresh: mock(() => {}),
+		update: mock(() => ({ previousVersion: "0.6.0", currentVersion: "0.7.0", logTailCommand: "tail -f /logs" })),
 		isRunning: false,
 		status: mock(() => ({ installed: false, running: false, platform: "systemd" as const })),
 		logs: mock(() => "journalctl -u macroclaw -n 50 --no-pager"),
@@ -171,6 +172,13 @@ describe("Cli.service", () => {
 		expect(stop).toHaveBeenCalled();
 	});
 
+	it("runs refresh action", () => {
+		const refresh = mock(() => {});
+		const cli = new Cli({ systemService: mockService({ refresh }) });
+		cli.service("refresh");
+		expect(refresh).toHaveBeenCalled();
+	});
+
 	it("runs restart action", () => {
 		const restart = mock(() => "tail -f /logs");
 		const cli = new Cli({ systemService: mockService({ restart }) });
@@ -178,26 +186,17 @@ describe("Cli.service", () => {
 		expect(restart).toHaveBeenCalled();
 	});
 
-	it("runs update action — stops and starts when running", () => {
+	it("runs update action", () => {
 		const stop = mock(() => {});
 		const start = mock(() => "tail -f /logs");
-		const update = mock(() => ({ previousVersion: "0.6.0", currentVersion: "0.7.0" }));
+		const update = mock(() => ({ previousVersion: "0.6.0", currentVersion: "0.7.0", logTailCommand: "tail -f /logs" }));
+		mockExecSync.mockClear();
 		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();
+		expect(start).not.toHaveBeenCalled();
+		expect(mockExecSync).not.toHaveBeenCalledWith("macroclaw service refresh", expect.anything());
 	});
 
 	it("runs status action", () => {

package/src/cli.ts

@@ -59,20 +59,18 @@ export class Cli {
 				this.#serviceManager.stop();
 				console.log("Service stopped.");
 				break;
+			case "refresh":
+				this.#serviceManager.refresh();
+				console.log("Service refreshed.");
+				break;
 			case "update": {
-				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}`);
+				console.log(`Service started. Check logs:\n  ${result.logTailCommand}`);
 				break;
 			}
 			case "restart": {
@@ -173,6 +171,11 @@ const serviceUpdateCommand = defineCommand({
 	run: () => { try { defaultCli.service("update"); } catch (err) { handleError(err); } },
 });
 
+const serviceRefreshCommand = defineCommand({
+	meta: { name: "refresh", description: "Regenerate service files from current configuration" },
+	run: () => { try { defaultCli.service("refresh"); } 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); } },
@@ -200,6 +203,7 @@ const serviceCommand = defineCommand({
 		stop: serviceStopCommand,
 		restart: serviceRestartCommand,
 		update: serviceUpdateCommand,
+		refresh: serviceRefreshCommand,
 		status: serviceStatusCommand,
 		logs: serviceLogsCommand,
 	},

package/src/system-service.test.ts

@@ -7,7 +7,15 @@ const { existsSync: realExistsSync, mkdirSync, readFileSync, rmSync, writeFileSy
 const existsSync = realExistsSync;
 
 // Mock child_process and os — safe since no other tests depend on real execSync or userInfo
-const mockExecSync = mock((cmd: string, _opts?: object): string => cmd === "bun pm bin -g" ? "/home/testuser/.bun/bin\n" : "");
+const DEFAULT_LOGIN_PATH = "/usr/local/bin:/usr/bin:/bin";
+const DEFAULT_BUN_GLOBAL_BIN = "/home/testuser/.bun/bin";
+const DEFAULT_SERVICE_PATH = `${DEFAULT_BUN_GLOBAL_BIN}:${DEFAULT_LOGIN_PATH}`;
+const DEFAULT_EXECUTABLE_PATH = `${DEFAULT_BUN_GLOBAL_BIN}/macroclaw`;
+const mockExecSync = mock((cmd: string, _opts?: object): string => {
+	if (cmd === "/bin/bash -lc 'printf %s \"$PATH\"'") return `${DEFAULT_LOGIN_PATH}\n`;
+	if (cmd === "bun pm bin -g") return `${DEFAULT_BUN_GLOBAL_BIN}\n`;
+	return "";
+});
 const mockUserInfo = mock(() => ({ username: "testuser", homedir: "/home/testuser", uid: 1000, gid: 1000, shell: "/bin/bash" }));
 const mockExistsSync = mock((path: string) => realExistsSync(path));
 
@@ -43,7 +51,11 @@ beforeEach(() => {
 	mockExecSync.mockClear();
 	mockUserInfo.mockClear();
 	mockExistsSync.mockClear();
-	mockExecSync.mockImplementation((cmd: string, _opts?: object): string => cmd === "bun pm bin -g" ? "/home/testuser/.bun/bin\n" : "");
+	mockExecSync.mockImplementation((cmd: string, _opts?: object): string => {
+		if (cmd === "/bin/bash -lc 'printf %s \"$PATH\"'") return `${DEFAULT_LOGIN_PATH}\n`;
+		if (cmd === "bun pm bin -g") return `${DEFAULT_BUN_GLOBAL_BIN}\n`;
+		return "";
+	});
 	mockUserInfo.mockImplementation(() => ({ username: "testuser", homedir: "/home/testuser", uid: 1000, gid: 1000, shell: "/bin/bash" }));
 	mockExistsSync.mockImplementation((path: string) => realExistsSync(path));
 });
@@ -167,7 +179,7 @@ describe("install", () => {
 		expect(() => mgr.install()).toThrow("Settings not found. Run `macroclaw setup` first.");
 	});
 
-	it("runs global install and resolves bun global bin for systemd", () => {
+	it("runs global install and resolves login shell PATH for systemd", () => {
 		const tmpHome = `/tmp/macroclaw-test-install-${Date.now()}`;
 		mkdirSync(join(tmpHome, ".macroclaw"), { recursive: true });
 		writeFileSync(join(tmpHome, ".macroclaw/settings.json"), "{}");
@@ -178,20 +190,17 @@ describe("install", () => {
 			if (path === "/var/lib/systemd/linger/testuser") return true; // already lingering
 			return realExistsSync(path);
 		});
-		mockExecSync.mockImplementation((cmd: string) => {
-			if (cmd === "bun pm bin -g") return "/home/testuser/.bun/bin\n";
-			return "";
-		});
 		const mgr = createManager({ home: tmpHome });
 		mgr.install();
 		rmSync(tmpHome, { recursive: true });
 
 		expect(mockExecSync).toHaveBeenCalledWith("bun install -g macroclaw", expect.anything());
+		expect(mockExecSync).toHaveBeenCalledWith("/bin/bash -lc 'printf %s \"$PATH\"'", expect.anything());
 		expect(mockExecSync).toHaveBeenCalledWith("bun pm bin -g", expect.anything());
 		expect(mockExecSync).not.toHaveBeenCalledWith("which macroclaw", expect.anything());
 	});
 
-	it("surfaces bun global bin resolution failures for systemd", () => {
+	it("surfaces login shell PATH resolution failures for systemd", () => {
 		const tmpHome = `/tmp/macroclaw-test-install-missing-path-${Date.now()}`;
 		mkdirSync(join(tmpHome, ".macroclaw"), { recursive: true });
 		writeFileSync(join(tmpHome, ".macroclaw/settings.json"), "{}");
@@ -202,7 +211,7 @@ describe("install", () => {
 			return realExistsSync(path);
 		});
 		mockExecSync.mockImplementation((cmd: string) => {
-			if (cmd === "bun pm bin -g") throw new Error("not found");
+			if (cmd === "/bin/bash -lc 'printf %s \"$PATH\"'") throw new Error("not found");
 			return "";
 		});
 
@@ -215,7 +224,7 @@ describe("install", () => {
 		rmSync(tmpHome, { recursive: true });
 	});
 
-	it("installs launchd service with bash -lc and OAuth token", () => {
+	it("installs launchd service with direct macroclaw invocation and OAuth token", () => {
 		const tmpHome = `/tmp/macroclaw-test-launchd-${Date.now()}`;
 		mkdirSync(join(tmpHome, ".macroclaw"), { recursive: true });
 		writeFileSync(join(tmpHome, ".macroclaw/settings.json"), "{}");
@@ -228,15 +237,13 @@ describe("install", () => {
 		const plistPath = join(plistDir, "com.macroclaw.plist");
 		expect(existsSync(plistPath)).toBe(true);
 		const writtenContent = readFileSync(plistPath, "utf-8");
-		// bash -lc pattern — no hardcoded binary paths
-		expect(writtenContent).toContain("<string>/bin/bash</string>");
-		expect(writtenContent).toContain("<string>-lc</string>");
-		expect(writtenContent).toContain("<string>exec macroclaw start</string>");
+		expect(writtenContent).toContain(`<string>${DEFAULT_EXECUTABLE_PATH}</string>`);
+		expect(writtenContent).toContain("<string>start</string>");
 		expect(writtenContent).toContain("<key>KeepAlive</key>");
 		expect(writtenContent).toContain(".macroclaw/logs/stdout.log");
 		expect(writtenContent).toContain("<key>EnvironmentVariables</key>");
 		expect(writtenContent).toContain("<key>PATH</key>");
-		expect(writtenContent).toContain("<string>/home/testuser/.bun/bin</string>");
+		expect(writtenContent).toContain(`<string>${DEFAULT_SERVICE_PATH}</string>`);
 		expect(writtenContent).not.toContain("<key>HOME</key>");
 		// OAuth token is preserved
 		expect(writtenContent).toContain("<key>CLAUDE_CODE_OAUTH_TOKEN</key>");
@@ -246,14 +253,14 @@ describe("install", () => {
 		rmSync(tmpHome, { recursive: true });
 	});
 
-	it("surfaces bun global bin resolution failures for launchd", () => {
+	it("surfaces login shell PATH resolution failures for launchd", () => {
 		const tmpHome = `/tmp/macroclaw-test-launchd-missing-path-${Date.now()}`;
 		mkdirSync(join(tmpHome, ".macroclaw"), { recursive: true });
 		writeFileSync(join(tmpHome, ".macroclaw/settings.json"), "{}");
 		mkdirSync(join(tmpHome, "Library/LaunchAgents"), { recursive: true });
 
 		mockExecSync.mockImplementation((cmd: string) => {
-			if (cmd === "bun pm bin -g") throw new Error("not found");
+			if (cmd === "/bin/bash -lc 'printf %s \"$PATH\"'") throw new Error("not found");
 			return "";
 		});
 
@@ -266,14 +273,14 @@ describe("install", () => {
 		rmSync(tmpHome, { recursive: true });
 	});
 
-	it("surfaces bun global bin permission failures for launchd", () => {
+	it("surfaces login shell PATH permission failures for launchd", () => {
 		const tmpHome = `/tmp/macroclaw-test-launchd-missing-bin-dir-${Date.now()}`;
 		mkdirSync(join(tmpHome, ".macroclaw"), { recursive: true });
 		writeFileSync(join(tmpHome, ".macroclaw/settings.json"), "{}");
 		mkdirSync(join(tmpHome, "Library/LaunchAgents"), { recursive: true });
 
 		mockExecSync.mockImplementation((cmd: string) => {
-			if (cmd === "bun pm bin -g") throw new Error("permission denied");
+			if (cmd === "/bin/bash -lc 'printf %s \"$PATH\"'") throw new Error("permission denied");
 			return "";
 		});
 
@@ -295,7 +302,7 @@ describe("install", () => {
 		const writtenContent = readFileSync(join(tmpHome, "Library/LaunchAgents/com.macroclaw.plist"), "utf-8");
 		expect(writtenContent).toContain("<key>EnvironmentVariables</key>");
 		expect(writtenContent).toContain("<key>PATH</key>");
-		expect(writtenContent).toContain("<string>/home/testuser/.bun/bin</string>");
+		expect(writtenContent).toContain(`<string>${DEFAULT_SERVICE_PATH}</string>`);
 		expect(writtenContent).not.toContain("CLAUDE_CODE_OAUTH_TOKEN");
 		rmSync(tmpHome, { recursive: true });
 	});
@@ -337,7 +344,7 @@ describe("install", () => {
 		rmSync(tmpHome, { recursive: true });
 	});
 
-	it("installs systemd user service with bash -lc and no hardcoded paths", () => {
+	it("installs systemd user service with direct macroclaw invocation and no hardcoded paths", () => {
 		const tmpHome = `/tmp/macroclaw-test-systemd-${Date.now()}`;
 		mkdirSync(join(tmpHome, ".macroclaw"), { recursive: true });
 		writeFileSync(join(tmpHome, ".macroclaw/settings.json"), "{}");
@@ -358,11 +365,11 @@ describe("install", () => {
 		expect(unitContent).toContain("WantedBy=default.target");
 		expect(unitContent).not.toContain("User=");
 		expect(unitContent).not.toContain("Group=");
-		// systemd seeds PATH with Bun's global bin; login shell can extend it via profile files
+		// systemd snapshots the login shell PATH and ensures Bun's global bin is included
 		expect(unitContent).not.toContain("Environment=HOME=");
-		expect(unitContent).toContain("Environment=PATH=/home/testuser/.bun/bin");
+		expect(unitContent).toContain(`Environment=PATH=${DEFAULT_SERVICE_PATH}`);
 		expect(unitContent).toContain("WorkingDirectory=%h");
-		expect(unitContent).toContain("ExecStart=/bin/bash -lc 'exec macroclaw start'");
+		expect(unitContent).toContain(`ExecStart=${DEFAULT_EXECUTABLE_PATH} start`);
 
 		// Lingering enabled via sudo
 		expect(mockExecSync).toHaveBeenCalledWith("sudo loginctl enable-linger testuser", expect.anything());
@@ -672,22 +679,44 @@ describe("update", () => {
 		);
 	});
 
-	it("runs bun install without stop/start", () => {
+	it("stops, refreshes, and starts the service when updating launchd", () => {
 		const tmpHome = `/tmp/macroclaw-test-updateld-${Date.now()}`;
 		mkdirSync(join(tmpHome, "Library/LaunchAgents"), { recursive: true });
 		writeFileSync(join(tmpHome, "Library/LaunchAgents/com.macroclaw.plist"), "test");
 
+		const calls: string[] = [];
+		let running = true;
 		mockExecSync.mockImplementation((cmd: string) => {
+			calls.push(cmd);
+			if (cmd.startsWith("launchctl list ")) return running ? LAUNCHD_RUNNING : LAUNCHD_STOPPED;
 			if (cmd === "bun pm ls -g") return "macroclaw@0.6.0\n";
+			if (cmd.includes("launchctl unload")) {
+				running = false;
+				return "";
+			}
+			if (cmd === "macroclaw service refresh") return "";
+			if (cmd.includes("launchctl load")) {
+				running = true;
+				return "";
+			}
 			return "";
 		});
 		const mgr = createManager({ platform: "darwin", home: tmpHome });
 		const result = mgr.update();
+
 		expect(mockExecSync).toHaveBeenCalledWith("bun install -g macroclaw@latest", expect.anything());
-		expect(mockExecSync).not.toHaveBeenCalledWith(expect.stringContaining("launchctl"), expect.anything());
-		expect(mockExecSync).not.toHaveBeenCalledWith(expect.stringContaining("systemctl"), expect.anything());
+		expect(mockExecSync).toHaveBeenCalledWith("macroclaw service refresh", expect.anything());
+		const unloadIdx = calls.findIndex((call) => call.includes("launchctl unload"));
+		const installIdx = calls.indexOf("bun install -g macroclaw@latest");
+		const refreshIdx = calls.indexOf("macroclaw service refresh");
+		const loadIdx = calls.findIndex((call) => call.includes("launchctl load"));
+		expect(unloadIdx).toBeGreaterThan(-1);
+		expect(installIdx).toBeGreaterThan(unloadIdx);
+		expect(refreshIdx).toBeGreaterThan(installIdx);
+		expect(loadIdx).toBeGreaterThan(refreshIdx);
 		expect(result.previousVersion).toBe("0.6.0");
 		expect(result.currentVersion).toBe("0.6.0");
+		expect(result.logTailCommand).toBe(`tail -f ${tmpHome}/.macroclaw/logs/*.log`);
 		rmSync(tmpHome, { recursive: true });
 	});
 
@@ -700,6 +729,8 @@ describe("update", () => {
 		mockExecSync.mockImplementation((cmd: string) => {
 			if (cmd.startsWith("launchctl list ")) return LAUNCHD_STOPPED;
 			if (cmd === "bun install -g macroclaw@latest") { installCalled = true; return ""; }
+			if (cmd === "macroclaw service refresh") return "";
+			if (cmd.includes("launchctl load")) return "";
 			if (cmd === "bun pm ls -g") return installCalled ? "macroclaw@0.7.0\n" : "macroclaw@0.6.0\n";
 			return "";
 		});
@@ -707,6 +738,7 @@ describe("update", () => {
 		const result = mgr.update();
 		expect(result.previousVersion).toBe("0.6.0");
 		expect(result.currentVersion).toBe("0.7.0");
+		expect(result.logTailCommand).toBe(`tail -f ${tmpHome}/.macroclaw/logs/*.log`);
 		rmSync(tmpHome, { recursive: true });
 	});
 
@@ -717,6 +749,8 @@ describe("update", () => {
 
 		mockExecSync.mockImplementation((cmd: string) => {
 			if (cmd.startsWith("launchctl list ")) return LAUNCHD_STOPPED;
+			if (cmd === "macroclaw service refresh") return "";
+			if (cmd.includes("launchctl load")) return "";
 			if (cmd === "bun pm ls -g") throw new Error("command not found");
 			return "";
 		});
@@ -724,6 +758,120 @@ describe("update", () => {
 		const result = mgr.update();
 		expect(result.previousVersion).toBe("unknown");
 		expect(result.currentVersion).toBe("unknown");
+		expect(result.logTailCommand).toBe(`tail -f ${tmpHome}/.macroclaw/logs/*.log`);
+		rmSync(tmpHome, { recursive: true });
+	});
+});
+
+describe("refresh", () => {
+	it("throws when service is not installed", () => {
+		const mgr = createManager({ platform: "darwin", home: "/nonexistent" });
+		expect(() => mgr.refresh()).toThrow(
+			"Service not installed. Run `macroclaw service install` first.",
+		);
+	});
+
+	it("refreshes launchd PATH snapshot and preserves oauth token", () => {
+		const tmpHome = `/tmp/macroclaw-test-refresh-launchd-${Date.now()}`;
+		const plistDir = join(tmpHome, "Library/LaunchAgents");
+		mkdirSync(plistDir, { recursive: true });
+		writeFileSync(join(plistDir, "com.macroclaw.plist"), `<?xml version="1.0" encoding="UTF-8"?>
+<plist version="1.0">
+<dict>
+	<key>EnvironmentVariables</key>
+	<dict>
+		<key>PATH</key>
+		<string>/old/path</string>
+		<key>CLAUDE_CODE_OAUTH_TOKEN</key>
+		<string>sk-test-token</string>
+	</dict>
+</dict>
+</plist>
+`);
+
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd === "/bin/bash -lc 'printf %s \"$PATH\"'") return "/custom/bin:/usr/bin:/bin\n";
+			if (cmd === "bun pm bin -g") return "/home/testuser/.bun/bin\n";
+			return "";
+		});
+
+		const mgr = createManager({ platform: "darwin", home: tmpHome });
+		mgr.refresh();
+		const plist = readFileSync(join(plistDir, "com.macroclaw.plist"), "utf-8");
+
+		expect(mockExecSync).toHaveBeenCalledWith("/bin/bash -lc 'printf %s \"$PATH\"'", expect.anything());
+		expect(mockExecSync).toHaveBeenCalledWith("bun pm bin -g", expect.anything());
+		expect(plist).toContain("<string>/home/testuser/.bun/bin:/custom/bin:/usr/bin:/bin</string>");
+		expect(plist).toContain("<string>/home/testuser/.bun/bin/macroclaw</string>");
+		expect(plist).toContain("<key>CLAUDE_CODE_OAUTH_TOKEN</key>");
+		expect(plist).toContain("<string>sk-test-token</string>");
+		rmSync(tmpHome, { recursive: true });
+	});
+
+	it("refreshes systemd PATH snapshot and reloads daemon", () => {
+		const tmpHome = `/tmp/macroclaw-test-refresh-systemd-${Date.now()}`;
+		const unitDir = join(tmpHome, ".config/systemd/user");
+		mkdirSync(unitDir, { recursive: true });
+		writeFileSync(join(unitDir, "macroclaw.service"), "test");
+
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd === "/bin/bash -lc 'printf %s \"$PATH\"'") return "/custom/bin:/usr/bin:/bin\n";
+			if (cmd === "bun pm bin -g") return "/home/testuser/.bun/bin\n";
+			return "";
+		});
+
+		const mgr = createManager({ platform: "linux", home: tmpHome });
+		mgr.refresh();
+		const unitContent = readFileSync(join(unitDir, "macroclaw.service"), "utf-8");
+
+		expect(mockExecSync).toHaveBeenCalledWith("/bin/bash -lc 'printf %s \"$PATH\"'", expect.anything());
+		expect(mockExecSync).toHaveBeenCalledWith("bun pm bin -g", expect.anything());
+		expect(mockExecSync).toHaveBeenCalledWith("systemctl --user daemon-reload", expect.anything());
+		expect(unitContent).toContain("Environment=PATH=/home/testuser/.bun/bin:/custom/bin:/usr/bin:/bin");
+		expect(unitContent).toContain("ExecStart=/home/testuser/.bun/bin/macroclaw start");
+		rmSync(tmpHome, { recursive: true });
+	});
+
+	it("does not duplicate bun global bin when it is already in login shell PATH", () => {
+		const tmpHome = `/tmp/macroclaw-test-refresh-systemd-path-present-${Date.now()}`;
+		const unitDir = join(tmpHome, ".config/systemd/user");
+		mkdirSync(unitDir, { recursive: true });
+		writeFileSync(join(unitDir, "macroclaw.service"), "test");
+
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd === "/bin/bash -lc 'printf %s \"$PATH\"'") return "/usr/local/bin:/home/testuser/.bun/bin:/usr/bin:/bin\n";
+			if (cmd === "bun pm bin -g") return "/home/testuser/.bun/bin\n";
+			return "";
+		});
+
+		const mgr = createManager({ platform: "linux", home: tmpHome });
+		mgr.refresh();
+		const unitContent = readFileSync(join(unitDir, "macroclaw.service"), "utf-8");
+
+		expect(unitContent).toContain("Environment=PATH=/home/testuser/.bun/bin:/usr/local/bin:/usr/bin:/bin");
+		expect(unitContent).not.toContain("Environment=PATH=/usr/local/bin:/home/testuser/.bun/bin:/usr/local/bin:/usr/bin:/bin");
+		rmSync(tmpHome, { recursive: true });
+	});
+
+	it("dedupes repeated PATH entries while keeping bun global bin first", () => {
+		const tmpHome = `/tmp/macroclaw-test-refresh-systemd-path-dedup-${Date.now()}`;
+		const unitDir = join(tmpHome, ".config/systemd/user");
+		mkdirSync(unitDir, { recursive: true });
+		writeFileSync(join(unitDir, "macroclaw.service"), "test");
+
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd === "/bin/bash -lc 'printf %s \"$PATH\"'") {
+				return "/home/testuser/.bun/bin:/usr/local/bin:/usr/bin:/usr/local/bin:/usr/bin:/bin:/home/testuser/.bun/bin\n";
+			}
+			if (cmd === "bun pm bin -g") return "/home/testuser/.bun/bin\n";
+			return "";
+		});
+
+		const mgr = createManager({ platform: "linux", home: tmpHome });
+		mgr.refresh();
+		const unitContent = readFileSync(join(unitDir, "macroclaw.service"), "utf-8");
+
+		expect(unitContent).toContain("Environment=PATH=/home/testuser/.bun/bin:/usr/local/bin:/usr/bin:/bin");
 		rmSync(tmpHome, { recursive: true });
 	});
 });

package/src/system-service.ts

@@ -1,5 +1,5 @@
 import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { userInfo as osUserInfo } from "node:os";
 import { dirname, resolve } from "node:path";
 import { createLogger } from "./logger";
@@ -20,6 +20,7 @@ export interface ServiceStatus {
 export interface UpdateResult {
 	previousVersion: string;
 	currentVersion: string;
+	logTailCommand: string;
 }
 
 export class SystemServiceManager {
@@ -85,7 +86,8 @@ export class SystemServiceManager {
 		}
 
 		this.#exec("bun install -g macroclaw");
-		const bunGlobalBin = this.#getBunGlobalBinDir();
+		const servicePath = this.#getServicePath();
+		const executablePath = this.#getMacroclawExecutablePath();
 
 		const logDir = resolve(this.#home, ".macroclaw/logs");
 		mkdirSync(logDir, { recursive: true });
@@ -93,7 +95,7 @@ export class SystemServiceManager {
 			this.#exec(`launchctl unload ${this.serviceFilePath}`);
 		}
 
-		writeFileSync(this.serviceFilePath, this.#generateLaunchdPlist(bunGlobalBin, oauthToken));
+		writeFileSync(this.serviceFilePath, this.#generateLaunchdPlist(servicePath, executablePath, oauthToken));
 		log.debug({ filePath: this.serviceFilePath }, "Wrote launchd plist");
 		this.#exec(`launchctl load ${this.serviceFilePath}`);
 	}
@@ -109,7 +111,8 @@ export class SystemServiceManager {
 		}
 
 		this.#exec("bun install -g macroclaw");
-		const bunGlobalBin = this.#getBunGlobalBinDir();
+		const servicePath = this.#getServicePath();
+		const executablePath = this.#getMacroclawExecutablePath();
 
 		// Enable lingering so user services run without an active login session
 		const username = osUserInfo().username;
@@ -117,7 +120,7 @@ export class SystemServiceManager {
 			this.#sudo(`loginctl enable-linger ${username}`);
 		}
 
-		const unitContent = this.#generateSystemdUnit(bunGlobalBin);
+		const unitContent = this.#generateSystemdUnit(servicePath, executablePath);
 		mkdirSync(dirname(this.serviceFilePath), { recursive: true });
 		writeFileSync(this.serviceFilePath, unitContent);
 		log.debug({ filePath: this.serviceFilePath }, "Wrote systemd unit");
@@ -192,12 +195,32 @@ export class SystemServiceManager {
 	update(): UpdateResult {
 		this.#requireInstalled();
 
+		const wasRunning = this.isRunning;
+		if (wasRunning) {
+			this.stop();
+		}
+
 		const previousVersion = this.#getInstalledVersion();
 		this.#exec("bun install -g macroclaw@latest");
+		this.#exec("macroclaw service refresh");
+		const logTailCommand = this.start();
 		const currentVersion = this.#getInstalledVersion();
 
-		log.debug({ previousVersion, currentVersion }, "Service updated");
-		return { previousVersion, currentVersion };
+		log.debug({ previousVersion, currentVersion, wasRunning }, "Service updated");
+		return { previousVersion, currentVersion, logTailCommand };
+	}
+
+	refresh(): void {
+		this.#requireInstalled();
+		const servicePath = this.#getServicePath();
+		const executablePath = this.#getMacroclawExecutablePath();
+		if (this.#platform === "systemd") {
+			writeFileSync(this.serviceFilePath, this.#generateSystemdUnit(servicePath, executablePath));
+			this.#exec("systemctl --user daemon-reload");
+			return;
+		}
+		const oauthToken = this.#getLaunchdOauthToken();
+		writeFileSync(this.serviceFilePath, this.#generateLaunchdPlist(servicePath, executablePath, oauthToken));
 	}
 
 	status(): ServiceStatus {
@@ -244,8 +267,26 @@ export class SystemServiceManager {
 		return execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).toString();
 	}
 
-	#getBunGlobalBinDir(): string {
-		return this.#exec("bun pm bin -g").trim();
+	#getLoginShellPath(): string {
+		return this.#exec("/bin/bash -lc 'printf %s \"$PATH\"'").trim();
+	}
+
+	#getServicePath(): string {
+		const shellPath = this.#getLoginShellPath();
+		const bunGlobalBin = this.#exec("bun pm bin -g").trim();
+		const entries = [bunGlobalBin, ...shellPath.split(":").filter(Boolean)];
+		return [...new Set(entries)].join(":");
+	}
+
+	#getMacroclawExecutablePath(): string {
+		return resolve(this.#exec("bun pm bin -g").trim(), "macroclaw");
+	}
+
+	#getLaunchdOauthToken(): string | undefined {
+		if (this.#platform !== "launchd" || !existsSync(this.serviceFilePath)) return undefined;
+		const plist = readFileSync(this.serviceFilePath, "utf-8");
+		const match = /<key>CLAUDE_CODE_OAUTH_TOKEN<\/key>\s*<string>([^<]+)<\/string>/.exec(plist);
+		return match?.[1];
 	}
 
 	#getInstalledVersion(): string {
@@ -276,9 +317,9 @@ export class SystemServiceManager {
 		this.#exec(`sudo ${cmd}`);
 	}
 
-	#generateLaunchdPlist(bunGlobalBin: string, oauthToken?: string): string {
+	#generateLaunchdPlist(servicePath: string, executablePath: string, oauthToken?: string): string {
 		const logDir = resolve(this.#home, ".macroclaw/logs");
-		const envVars = [`\n\t<key>PATH</key>\n\t\t<string>${bunGlobalBin}</string>`];
+		const envVars = [`\n\t<key>PATH</key>\n\t\t<string>${servicePath}</string>`];
 		if (oauthToken) {
 			envVars.push(`\n\t<key>CLAUDE_CODE_OAUTH_TOKEN</key>\n\t\t<string>${oauthToken}</string>`);
 		}
@@ -291,9 +332,8 @@ export class SystemServiceManager {
 	<string>com.macroclaw</string>
 	<key>ProgramArguments</key>
 	<array>
-		<string>/bin/bash</string>
-		<string>-lc</string>
-		<string>exec macroclaw start</string>
+		<string>${executablePath}</string>
+		<string>start</string>
 	</array>
 	<key>KeepAlive</key>
 	<true/>
@@ -306,7 +346,7 @@ export class SystemServiceManager {
 `;
 	}
 
-	#generateSystemdUnit(bunGlobalBin: string): string {
+	#generateSystemdUnit(servicePath: string, executablePath: string): string {
 		return `[Unit]
 Description=Macroclaw - Telegram-to-Claude-Code bridge
 After=network.target
@@ -314,8 +354,8 @@ After=network.target
 [Service]
 Type=simple
 WorkingDirectory=%h
-Environment=PATH=${bunGlobalBin}
-ExecStart=/bin/bash -lc 'exec macroclaw start'
+Environment=PATH=${servicePath}
+ExecStart=${executablePath} start
 Restart=on-failure
 RestartSec=5