macroclaw 0.40.0 → 0.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "macroclaw",
-  "version": "0.40.0",
+  "version": "0.42.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,14 @@ 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) => "");
+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 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 +50,11 @@ beforeEach(() => {
 	mockExecSync.mockClear();
 	mockUserInfo.mockClear();
 	mockExistsSync.mockClear();
-	mockExecSync.mockImplementation((_cmd: string, _opts?: object) => "");
+	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 +178,7 @@ describe("install", () => {
 		expect(() => mgr.install()).toThrow("Settings not found. Run `macroclaw setup` first.");
 	});
 
-	it("runs global install without resolving binary paths on 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"), "{}");
@@ -183,13 +194,36 @@ describe("install", () => {
 		rmSync(tmpHome, { recursive: true });
 
 		expect(mockExecSync).toHaveBeenCalledWith("bun install -g macroclaw", expect.anything());
-		// systemd no longer resolves paths — bash -lc handles PATH at runtime
-		expect(mockExecSync).not.toHaveBeenCalledWith("which bun", expect.anything());
-		expect(mockExecSync).not.toHaveBeenCalledWith("which claude", expect.anything());
-		expect(mockExecSync).not.toHaveBeenCalledWith("bun pm bin -g", 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("installs launchd service with bash -lc and OAuth token", () => {
+	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"), "{}");
+
+		mockUserInfo.mockImplementation(() => ({ username: "testuser", homedir: tmpHome, uid: 1000, gid: 1000, shell: "/bin/bash" }));
+		mockExistsSync.mockImplementation((path: string) => {
+			if (path === "/var/lib/systemd/linger/testuser") return true;
+			return realExistsSync(path);
+		});
+		mockExecSync.mockImplementation((cmd: string) => {
+			if (cmd === "/bin/bash -lc 'printf %s \"$PATH\"'") throw new Error("not found");
+			return "";
+		});
+
+		const mgr = createManager({ home: tmpHome });
+		expect(() => mgr.install()).toThrow(
+			"not found",
+		);
+		expect(existsSync(join(tmpHome, ".config/systemd/user/macroclaw.service"))).toBe(false);
+		expect(mockExecSync).not.toHaveBeenCalledWith("systemctl --user daemon-reload", expect.anything());
+		rmSync(tmpHome, { recursive: true });
+	});
+
+	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"), "{}");
@@ -202,23 +236,57 @@ 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 bun macroclaw start</string>");
+		expect(writtenContent).toContain("<string>macroclaw</string>");
+		expect(writtenContent).toContain("<string>start</string>");
 		expect(writtenContent).toContain("<key>KeepAlive</key>");
 		expect(writtenContent).toContain(".macroclaw/logs/stdout.log");
-		// No PATH/HOME env vars — login shell provides them
-		expect(writtenContent).not.toContain("<key>PATH</key>");
+		expect(writtenContent).toContain("<key>EnvironmentVariables</key>");
+		expect(writtenContent).toContain("<key>PATH</key>");
+		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>");
 		expect(writtenContent).toContain("<string>sk-test-token</string>");
 		expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining("launchctl load"), expect.anything());
-		// No path resolution calls
-		expect(mockExecSync).not.toHaveBeenCalledWith("which bun", expect.anything());
-		expect(mockExecSync).not.toHaveBeenCalledWith("which claude", expect.anything());
-		expect(mockExecSync).not.toHaveBeenCalledWith("bun pm bin -g", expect.anything());
+		expect(mockExecSync).not.toHaveBeenCalledWith("which macroclaw", expect.anything());
+		rmSync(tmpHome, { recursive: true });
+	});
+
+	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 === "/bin/bash -lc 'printf %s \"$PATH\"'") throw new Error("not found");
+			return "";
+		});
+
+		const mgr = createManager({ platform: "darwin", home: tmpHome });
+		expect(() => mgr.install("sk-test-token")).toThrow(
+			"not found",
+		);
+		expect(existsSync(join(tmpHome, "Library/LaunchAgents/com.macroclaw.plist"))).toBe(false);
+		expect(mockExecSync).not.toHaveBeenCalledWith(expect.stringContaining("launchctl load"), expect.anything());
+		rmSync(tmpHome, { recursive: true });
+	});
+
+	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 === "/bin/bash -lc 'printf %s \"$PATH\"'") throw new Error("permission denied");
+			return "";
+		});
+
+		const mgr = createManager({ platform: "darwin", home: tmpHome });
+		expect(() => mgr.install("sk-test-token")).toThrow(
+			"permission denied",
+		);
 		rmSync(tmpHome, { recursive: true });
 	});
 
@@ -231,8 +299,10 @@ describe("install", () => {
 		const mgr = createManager({ platform: "darwin", home: tmpHome });
 		mgr.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>${DEFAULT_SERVICE_PATH}</string>`);
 		expect(writtenContent).not.toContain("CLAUDE_CODE_OAUTH_TOKEN");
-		expect(writtenContent).not.toContain("<key>EnvironmentVariables</key>");
 		rmSync(tmpHome, { recursive: true });
 	});
 
@@ -273,7 +343,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"), "{}");
@@ -294,11 +364,11 @@ describe("install", () => {
 		expect(unitContent).toContain("WantedBy=default.target");
 		expect(unitContent).not.toContain("User=");
 		expect(unitContent).not.toContain("Group=");
-		// bash -lc sources login profile for PATH — no hardcoded Environment lines
+		// systemd snapshots the login shell PATH and ensures Bun's global bin is included
 		expect(unitContent).not.toContain("Environment=HOME=");
-		expect(unitContent).not.toContain("Environment=PATH=");
+		expect(unitContent).toContain(`Environment=PATH=${DEFAULT_SERVICE_PATH}`);
 		expect(unitContent).toContain("WorkingDirectory=%h");
-		expect(unitContent).toContain("ExecStart=/bin/bash -lc 'exec bun macroclaw start'");
+		expect(unitContent).toContain("ExecStart=macroclaw start");
 
 		// Lingering enabled via sudo
 		expect(mockExecSync).toHaveBeenCalledWith("sudo loginctl enable-linger testuser", expect.anything());
@@ -608,22 +678,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 });
 	});
 
@@ -636,6 +728,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 "";
 		});
@@ -643,6 +737,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 });
 	});
 
@@ -653,6 +748,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 "";
 		});
@@ -660,6 +757,96 @@ 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("<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");
+		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=/usr/local/bin:/home/testuser/.bun/bin:/usr/bin:/bin");
+		expect(unitContent).not.toContain("Environment=PATH=/home/testuser/.bun/bin:/usr/local/bin:/home/testuser/.bun/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,6 +86,7 @@ export class SystemServiceManager {
 		}
 
 		this.#exec("bun install -g macroclaw");
+		const servicePath = this.#getServicePath();
 
 		const logDir = resolve(this.#home, ".macroclaw/logs");
 		mkdirSync(logDir, { recursive: true });
@@ -92,7 +94,7 @@ export class SystemServiceManager {
 			this.#exec(`launchctl unload ${this.serviceFilePath}`);
 		}
 
-		writeFileSync(this.serviceFilePath, this.#generateLaunchdPlist(oauthToken));
+		writeFileSync(this.serviceFilePath, this.#generateLaunchdPlist(servicePath, oauthToken));
 		log.debug({ filePath: this.serviceFilePath }, "Wrote launchd plist");
 		this.#exec(`launchctl load ${this.serviceFilePath}`);
 	}
@@ -108,6 +110,7 @@ export class SystemServiceManager {
 		}
 
 		this.#exec("bun install -g macroclaw");
+		const servicePath = this.#getServicePath();
 
 		// Enable lingering so user services run without an active login session
 		const username = osUserInfo().username;
@@ -115,7 +118,7 @@ export class SystemServiceManager {
 			this.#sudo(`loginctl enable-linger ${username}`);
 		}
 
-		const unitContent = this.#generateSystemdUnit();
+		const unitContent = this.#generateSystemdUnit(servicePath);
 		mkdirSync(dirname(this.serviceFilePath), { recursive: true });
 		writeFileSync(this.serviceFilePath, unitContent);
 		log.debug({ filePath: this.serviceFilePath }, "Wrote systemd unit");
@@ -190,12 +193,31 @@ 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();
+		if (this.#platform === "systemd") {
+			writeFileSync(this.serviceFilePath, this.#generateSystemdUnit(servicePath));
+			this.#exec("systemctl --user daemon-reload");
+			return;
+		}
+		const oauthToken = this.#getLaunchdOauthToken();
+		writeFileSync(this.serviceFilePath, this.#generateLaunchdPlist(servicePath, oauthToken));
 	}
 
 	status(): ServiceStatus {
@@ -242,6 +264,24 @@ export class SystemServiceManager {
 		return execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).toString();
 	}
 
+	#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 = shellPath.split(":").filter(Boolean);
+		if (entries.includes(bunGlobalBin)) return shellPath;
+		return [bunGlobalBin, ...entries].join(":");
+	}
+
+	#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 {
 		try {
@@ -271,11 +311,13 @@ export class SystemServiceManager {
 		this.#exec(`sudo ${cmd}`);
 	}
 
-	#generateLaunchdPlist(oauthToken?: string): string {
+	#generateLaunchdPlist(servicePath: string, oauthToken?: string): string {
 		const logDir = resolve(this.#home, ".macroclaw/logs");
-		const tokenEnvBlock = oauthToken
-			? `\n\t<key>EnvironmentVariables</key>\n\t<dict>\n\t\t<key>CLAUDE_CODE_OAUTH_TOKEN</key>\n\t\t<string>${oauthToken}</string>\n\t</dict>`
-			: "";
+		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>`);
+		}
+		const envBlock = `\n\t<key>EnvironmentVariables</key>\n\t<dict>${envVars.join("")}\n\t</dict>`;
 		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">
@@ -284,22 +326,21 @@ export class SystemServiceManager {
 	<string>com.macroclaw</string>
 	<key>ProgramArguments</key>
 	<array>
-		<string>/bin/bash</string>
-		<string>-lc</string>
-		<string>exec bun macroclaw start</string>
+		<string>macroclaw</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>${tokenEnvBlock}
+	<string>${logDir}/stderr.log</string>${envBlock}
 </dict>
 </plist>
 `;
 	}
 
-	#generateSystemdUnit(): string {
+	#generateSystemdUnit(servicePath: string): string {
 		return `[Unit]
 Description=Macroclaw - Telegram-to-Claude-Code bridge
 After=network.target
@@ -307,7 +348,8 @@ After=network.target
 [Service]
 Type=simple
 WorkingDirectory=%h
-ExecStart=/bin/bash -lc 'exec bun macroclaw start'
+Environment=PATH=${servicePath}
+ExecStart=macroclaw start
 Restart=on-failure
 RestartSec=5