@appchy/jarvis 0.1.13 → 0.1.15

package/dist/bin.js

@@ -1,15 +1,20 @@
+// src/bin.ts
+import dotenv from "dotenv";
+import fs9 from "fs";
+import path9 from "path";
+
 // src/cli.ts
 import { Command } from "commander";
-import { spawn as spawn2, execSync } from "child_process";
-import fs7 from "fs";
-import path7 from "path";
-import os4 from "os";
+import { spawn as spawn3, execSync as execSync2 } from "child_process";
+import fs8 from "fs";
+import path8 from "path";
+import os5 from "os";
 
 // src/config.ts
 import fs from "fs";
 import path from "path";
 import os from "os";
-var CONFIG_DIR = path.join(os.homedir(), ".jarvis");
+var CONFIG_DIR = process.env.JARVIS_CONFIG_DIR ?? path.join(os.homedir(), ".jarvis");
 var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
 function loadConfig() {
   try {
@@ -2556,7 +2561,7 @@ function createUpstreamClient(config) {
     if (!config.refreshToken) return null;
     return config.apiUrl.replace(/^wss:/, "https:").replace(/^ws:/, "http:") + "/refresh";
   }
-  function getTokenExpiry(token) {
+  function getTokenExpiry2(token) {
     try {
       const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
       return payload.exp ?? null;
@@ -2567,7 +2572,7 @@ function createUpstreamClient(config) {
   function scheduleRefresh() {
     if (refreshTimer) clearTimeout(refreshTimer);
     if (!config.refreshToken) return;
-    const exp = getTokenExpiry(currentToken);
+    const exp = getTokenExpiry2(currentToken);
     if (!exp) return;
     const msUntilExpiry = exp * 1e3 - Date.now();
     const refreshIn = Math.max(msUntilExpiry - REFRESH_BUFFER_MS, 0);
@@ -2627,6 +2632,7 @@ function createUpstreamClient(config) {
       }
     });
     ws.on("close", (code) => {
+      console.error("[Upstream] Connection closed, code:", code);
       if (closed) return;
       if (code === 4001 || code === 4003) {
         if (config.refreshToken) {
@@ -2678,6 +2684,7 @@ function createUpstreamClient(config) {
       reconnectTimer = setTimeout(connect, 3e3);
     });
     ws.on("error", (err) => {
+      console.error("[Upstream] Connection error:", err.message);
       logger.sys.error("[Upstream] Connection error", {
         error: err.message
       });
@@ -4796,26 +4803,453 @@ async function waitForAgent(port, maxAttempts = 30) {
   }
 }
 
+// src/service.ts
+import { execSync, spawn as spawn2 } from "child_process";
+import fs7 from "fs";
+import path7 from "path";
+import os4 from "os";
+function createServiceManager() {
+  if (process.platform === "darwin") return new MacOSService();
+  if (process.platform === "win32") return new WindowsService();
+  if (process.platform === "linux") return new LinuxService();
+  return new FallbackService();
+}
+var PLIST_LABEL = "com.appchy.jarvis";
+var PLIST_DIR = path7.join(os4.homedir(), "Library", "LaunchAgents");
+var PLIST_PATH = path7.join(PLIST_DIR, `${PLIST_LABEL}.plist`);
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+var MacOSService = class {
+  install(opts) {
+    const args = [
+      opts.nodePath,
+      opts.entryPath,
+      "start",
+      "--foreground",
+      "--port",
+      String(opts.port),
+      "--workspace",
+      opts.workspacePath
+    ];
+    if (!opts.upstream) {
+      args.push("--no-upstream");
+    }
+    const logFile = path7.join(os4.homedir(), ".jarvis", "agent.log");
+    const envPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+    const plist = `<?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>${PLIST_LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+${args.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n")}
+  </array>
+
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(opts.workspacePath)}</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${escapeXml(envPath)}</string>
+    <key>HOME</key>
+    <string>${escapeXml(os4.homedir())}</string>
+    <key>NODE_NO_WARNINGS</key>
+    <string>1</string>
+  </dict>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>KeepAlive</key>
+  <true/>
+
+  <key>ProcessType</key>
+  <string>Interactive</string>
+
+  <key>ThrottleInterval</key>
+  <integer>5</integer>
+
+  <key>StandardOutPath</key>
+  <string>${escapeXml(logFile)}</string>
+
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(logFile)}</string>
+</dict>
+</plist>
+`;
+    fs7.mkdirSync(PLIST_DIR, { recursive: true });
+    fs7.mkdirSync(path7.dirname(logFile), { recursive: true });
+    if (this.isInstalled()) {
+      try {
+        execSync(`launchctl unload -w "${PLIST_PATH}"`, { stdio: "ignore" });
+      } catch {
+      }
+    }
+    fs7.writeFileSync(PLIST_PATH, plist);
+    execSync(`launchctl load -w "${PLIST_PATH}"`);
+  }
+  uninstall() {
+    try {
+      execSync(`launchctl unload -w "${PLIST_PATH}"`, { stdio: "ignore" });
+    } catch {
+    }
+    try {
+      fs7.unlinkSync(PLIST_PATH);
+    } catch {
+    }
+  }
+  isInstalled() {
+    return fs7.existsSync(PLIST_PATH);
+  }
+  start() {
+    try {
+      execSync(`launchctl load -w "${PLIST_PATH}"`);
+    } catch {
+      execSync(`launchctl start ${PLIST_LABEL}`);
+    }
+  }
+  stop() {
+    try {
+      execSync(`launchctl unload -w "${PLIST_PATH}"`, { stdio: "ignore" });
+    } catch {
+    }
+  }
+  status() {
+    const installed = this.isInstalled();
+    if (!installed) return { installed: false, running: false };
+    try {
+      const output = execSync(`launchctl list ${PLIST_LABEL}`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"]
+      });
+      const pidMatch = output.match(/"PID"\s*=\s*(\d+)/);
+      const pid = pidMatch ? parseInt(pidMatch[1], 10) : void 0;
+      return { installed: true, running: pid !== void 0, pid, os: "macOS" };
+    } catch {
+      return { installed: true, running: false, os: "macOS" };
+    }
+  }
+};
+var TASK_NAME = "JarvisAgent";
+var WindowsService = class {
+  install(opts) {
+    const args = [
+      opts.entryPath,
+      "start",
+      "--foreground",
+      "--port",
+      String(opts.port),
+      "--workspace",
+      `"${opts.workspacePath}"`
+    ];
+    if (!opts.upstream) {
+      args.push("--no-upstream");
+    }
+    const xml = `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>Jarvis AI Agent \u2014 always-on background service</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Priority>7</Priority>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>999</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${escapeXml(opts.nodePath)}</Command>
+      <Arguments>${escapeXml(args.join(" "))}</Arguments>
+      <WorkingDirectory>${escapeXml(opts.workspacePath)}</WorkingDirectory>
+    </Exec>
+  </Actions>
+</Task>
+`;
+    const tmpDir = os4.tmpdir();
+    const tmpFile = path7.join(tmpDir, `jarvis-task-${Date.now()}.xml`);
+    fs7.writeFileSync(tmpFile, xml, { encoding: "utf-16le" });
+    try {
+      execSync(`schtasks /Create /TN "${TASK_NAME}" /XML "${tmpFile}" /F`, {
+        stdio: "ignore"
+      });
+    } finally {
+      try {
+        fs7.unlinkSync(tmpFile);
+      } catch {
+      }
+    }
+  }
+  uninstall() {
+    try {
+      execSync(`schtasks /Delete /TN "${TASK_NAME}" /F`, { stdio: "ignore" });
+    } catch {
+    }
+  }
+  isInstalled() {
+    try {
+      execSync(`schtasks /Query /TN "${TASK_NAME}"`, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  start() {
+    execSync(`schtasks /Run /TN "${TASK_NAME}"`, { stdio: "ignore" });
+  }
+  stop() {
+    execSync(`schtasks /End /TN "${TASK_NAME}"`, { stdio: "ignore" });
+  }
+  status() {
+    if (!this.isInstalled()) return { installed: false, running: false };
+    try {
+      const output = execSync(`schtasks /Query /TN "${TASK_NAME}" /FO CSV /NH`, {
+        encoding: "utf-8"
+      });
+      const running = output.includes("Running");
+      return { installed: true, running, os: "windows" };
+    } catch {
+      return { installed: true, running: false, os: "windows" };
+    }
+  }
+};
+var SYSTEMD_DIR = path7.join(os4.homedir(), ".config", "systemd", "user");
+var UNIT_NAME = "jarvis.service";
+var UNIT_PATH = path7.join(SYSTEMD_DIR, UNIT_NAME);
+var LinuxService = class {
+  install(opts) {
+    const args = [
+      opts.entryPath,
+      "start",
+      "--foreground",
+      "--port",
+      String(opts.port),
+      "--workspace",
+      opts.workspacePath
+    ];
+    if (!opts.upstream) {
+      args.push("--no-upstream");
+    }
+    const logFile = path7.join(os4.homedir(), ".jarvis", "agent.log");
+    const envPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+    const unit = `[Unit]
+Description=Jarvis AI Agent
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${opts.nodePath} ${args.join(" ")}
+WorkingDirectory=${opts.workspacePath}
+Environment=PATH=${envPath}
+Environment=HOME=${os4.homedir()}
+Environment=NODE_NO_WARNINGS=1
+Restart=always
+RestartSec=5
+StandardOutput=append:${logFile}
+StandardError=append:${logFile}
+
+[Install]
+WantedBy=default.target
+`;
+    fs7.mkdirSync(SYSTEMD_DIR, { recursive: true });
+    fs7.mkdirSync(path7.dirname(logFile), { recursive: true });
+    if (this.isInstalled()) {
+      try {
+        execSync("systemctl --user stop jarvis.service", { stdio: "ignore" });
+      } catch {
+      }
+    }
+    fs7.writeFileSync(UNIT_PATH, unit);
+    execSync("systemctl --user daemon-reload", { stdio: "ignore" });
+    execSync("systemctl --user enable jarvis.service", { stdio: "ignore" });
+    execSync("systemctl --user start jarvis.service", { stdio: "ignore" });
+    try {
+      execSync(`loginctl enable-linger ${os4.userInfo().username}`, { stdio: "ignore" });
+    } catch {
+    }
+  }
+  uninstall() {
+    try {
+      execSync("systemctl --user stop jarvis.service", { stdio: "ignore" });
+    } catch {
+    }
+    try {
+      execSync("systemctl --user disable jarvis.service", { stdio: "ignore" });
+    } catch {
+    }
+    try {
+      fs7.unlinkSync(UNIT_PATH);
+    } catch {
+    }
+    try {
+      execSync("systemctl --user daemon-reload", { stdio: "ignore" });
+    } catch {
+    }
+  }
+  isInstalled() {
+    return fs7.existsSync(UNIT_PATH);
+  }
+  start() {
+    execSync("systemctl --user start jarvis.service");
+  }
+  stop() {
+    execSync("systemctl --user stop jarvis.service", { stdio: "ignore" });
+  }
+  status() {
+    if (!this.isInstalled()) return { installed: false, running: false };
+    try {
+      const output = execSync("systemctl --user show jarvis.service --property=ActiveState,MainPID", {
+        encoding: "utf-8"
+      });
+      const active = output.includes("ActiveState=active");
+      const pidMatch = output.match(/MainPID=(\d+)/);
+      const pid = pidMatch ? parseInt(pidMatch[1], 10) : void 0;
+      return {
+        installed: true,
+        running: active && pid !== void 0 && pid > 0,
+        pid: pid && pid > 0 ? pid : void 0,
+        os: "linux"
+      };
+    } catch {
+      return { installed: true, running: false, os: "linux" };
+    }
+  }
+};
+var FallbackService = class {
+  constructor() {
+    this.pidFile = path7.join(os4.homedir(), ".jarvis", "agent.pid");
+    this.logFile = path7.join(os4.homedir(), ".jarvis", "agent.log");
+    this.markerFile = path7.join(os4.homedir(), ".jarvis", "service-installed");
+  }
+  install(opts) {
+    const jarvisDir = path7.join(os4.homedir(), ".jarvis");
+    fs7.mkdirSync(jarvisDir, { recursive: true });
+    this.stop();
+    const args = [
+      opts.entryPath,
+      "start",
+      "--foreground",
+      "--port",
+      String(opts.port),
+      "--workspace",
+      opts.workspacePath
+    ];
+    if (!opts.upstream) {
+      args.push("--no-upstream");
+    }
+    const logFd = fs7.openSync(this.logFile, "a");
+    const child = spawn2(opts.nodePath, args, {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      cwd: opts.workspacePath,
+      env: { ...process.env, NODE_NO_WARNINGS: "1" }
+    });
+    child.unref();
+    fs7.closeSync(logFd);
+    fs7.writeFileSync(this.pidFile, String(child.pid));
+    fs7.writeFileSync(this.markerFile, JSON.stringify({
+      nodePath: opts.nodePath,
+      entryPath: opts.entryPath,
+      port: opts.port,
+      workspacePath: opts.workspacePath,
+      upstream: opts.upstream
+    }));
+    console.log(
+      `\x1B[33mNote:\x1B[0m OS-level service not available on ${process.platform}.`
+    );
+    console.log("  Agent is running as a background process (PID: " + child.pid + ").");
+    console.log("  It will NOT auto-start on reboot or recover from crashes.");
+  }
+  uninstall() {
+    this.stop();
+    try {
+      fs7.unlinkSync(this.markerFile);
+    } catch {
+    }
+  }
+  isInstalled() {
+    return fs7.existsSync(this.markerFile);
+  }
+  start() {
+    if (!this.isInstalled()) {
+      throw new Error("Service not installed. Run 'jarvis install' first.");
+    }
+    const saved = JSON.parse(fs7.readFileSync(this.markerFile, "utf-8"));
+    this.install(saved);
+  }
+  stop() {
+    try {
+      const pid = parseInt(fs7.readFileSync(this.pidFile, "utf-8").trim(), 10);
+      if (!isNaN(pid)) {
+        process.kill(pid, "SIGTERM");
+      }
+    } catch {
+    }
+    try {
+      fs7.unlinkSync(this.pidFile);
+    } catch {
+    }
+  }
+  status() {
+    if (!this.isInstalled()) return { installed: false, running: false };
+    try {
+      const pid = parseInt(fs7.readFileSync(this.pidFile, "utf-8").trim(), 10);
+      if (isNaN(pid)) return { installed: true, running: false };
+      process.kill(pid, 0);
+      return { installed: true, running: true, pid };
+    } catch {
+      return { installed: true, running: false };
+    }
+  }
+};
+
 // src/cli.ts
 import { createRequire } from "module";
 var _require = createRequire(import.meta.url);
 var PKG_VERSION = _require("../package.json").version ?? "dev";
-var LOG_DIR = path7.join(os4.homedir(), ".jarvis");
-var LOG_FILE = path7.join(LOG_DIR, "agent.log");
-var PID_FILE = path7.join(LOG_DIR, "agent.pid");
+var LOG_DIR = path8.join(os5.homedir(), ".jarvis");
+var LOG_FILE = path8.join(LOG_DIR, "agent.log");
+var PID_FILE = path8.join(LOG_DIR, "agent.pid");
 function savePid(pid) {
-  fs7.mkdirSync(LOG_DIR, { recursive: true });
-  fs7.writeFileSync(PID_FILE, String(pid));
+  fs8.mkdirSync(LOG_DIR, { recursive: true });
+  fs8.writeFileSync(PID_FILE, String(pid));
 }
 function readPid() {
   try {
-    const pid = parseInt(fs7.readFileSync(PID_FILE, "utf-8").trim(), 10);
+    const pid = parseInt(fs8.readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (isNaN(pid)) return null;
     try {
       process.kill(pid, 0);
       return pid;
     } catch {
-      fs7.unlinkSync(PID_FILE);
+      fs8.unlinkSync(PID_FILE);
       return null;
     }
   } catch {
@@ -4824,7 +5258,7 @@ function readPid() {
 }
 function clearPid() {
   try {
-    fs7.unlinkSync(PID_FILE);
+    fs8.unlinkSync(PID_FILE);
   } catch {
   }
 }
@@ -4874,7 +5308,7 @@ async function findFreePort() {
 async function browserAuth(appUrl) {
   const config = loadConfig();
   const callbackPort = await findFreePort();
-  const loginUrl = `${appUrl}/login?callback=cli&port=${callbackPort}`;
+  const loginUrl = `${appUrl}/api/auth/cli?port=${callbackPort}`;
   console.log();
   console.log("Opening browser for sign in...");
   console.log(`  If it doesn't open, visit: ${loginUrl}`);
@@ -4904,34 +5338,61 @@ async function browserAuth(appUrl) {
     return false;
   }
 }
-var APP_URL = process.env.APP_URL ?? "https://jarvis.appchy.com" ?? "https://jarvis.appchy.com";
+function getAppUrl() {
+  return process.env.APP_URL ?? "https://jarvis.appchy.com" ?? "https://jarvis.appchy.com";
+}
+function getTokenExpiry(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+    return payload.exp ?? null;
+  } catch {
+    return null;
+  }
+}
+function isTokenExpired(token, bufferMs = 6e4) {
+  const exp = getTokenExpiry(token);
+  if (!exp) return true;
+  return exp * 1e3 - Date.now() < bufferMs;
+}
+async function tryRefreshToken(config) {
+  if (!config.apiUrl || !config.refreshToken) return null;
+  const refreshUrl = config.apiUrl.replace(/^wss:/, "https:").replace(/^ws:/, "http:") + "/refresh";
+  try {
+    const res = await fetch(refreshUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refreshToken: config.refreshToken })
+    });
+    if (!res.ok) return null;
+    const { token } = await res.json();
+    return token;
+  } catch {
+    return null;
+  }
+}
 async function ensureSetup() {
   const config = loadConfig();
-  if (config?.token || config?.anthropicApiKey || config?.useSubscription) {
+  if (!config?.token && !config?.anthropicApiKey && !config?.useSubscription) {
+    return browserAuth(getAppUrl());
+  }
+  if (config?.anthropicApiKey || config?.useSubscription) {
     return true;
   }
-  const ok = await browserAuth(APP_URL);
-  if (!ok) return false;
-  const pid = readPid();
-  if (pid) {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
+  if (config?.token && isTokenExpired(config.token)) {
+    console.log("Token expired, attempting refresh...");
+    const newToken = await tryRefreshToken(config);
+    if (newToken) {
+      saveConfig({ ...config, token: newToken, connectedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      console.log("Token refreshed successfully.");
+      return true;
     }
-    clearPid();
-    await new Promise((r) => setTimeout(r, 1e3));
+    console.log("Token refresh failed. Re-authenticating...");
+    return browserAuth(getAppUrl());
   }
   return true;
 }
 function createCli() {
   const program = new Command().name("jarvis").description("Jarvis local agent \u2014 runs Claude Code on your machine").version(PKG_VERSION);
-  program.argument("[message]", "Optional initial message to send").option("--model <id>", "Model (e.g., claude-opus-4-20250514)").option("--mode <mode>", "Permission mode: supervised|auto|plan|yolo").option("--thinking <config>", "Thinking: adaptive|enabled|disabled").option("--thinking-budget <n>", "Token budget when thinking=enabled").option("--max-turns <n>", "Max turns per task").option("-p, --port <port>", "Agent server port", "7862").option("-w, --workspace <path>", "Workspace root path").option("--no-server", "Connect to existing server, don't auto-start").action(async (message, opts) => {
-    if (message && program.commands.some((c) => c.name() === message)) {
-      return;
-    }
-    await ensureSetup();
-    await launchChat(opts);
-  });
   program.command("connect <token>").description("Connect to Jarvis cloud using a token from the web UI").option("-w, --workspace <path>", "Workspace root path for repo operations").action((token, opts) => {
     try {
       const parsed = parseConnectToken(token);
@@ -4958,86 +5419,133 @@ function createCli() {
       process.exit(1);
     }
   });
-  program.command("start").description("Start the local agent (runs as background daemon)").option("-p, --port <port>", "Local WS server port", "7862").option("-w, --workspace <path>", "Workspace root path").option("--api-key <key>", "Anthropic API key (for local-only use)").option("--no-upstream", "Don't connect to cloud (local-only mode)").option("--foreground", "Run in foreground (don't daemonize)").action(async (opts) => {
-    await ensureSetup();
-    const config = loadConfig();
-    const port = parseInt(opts.port, 10);
-    const alreadyRunning = await isPortInUse(port);
-    if (alreadyRunning) {
-      console.log(`Jarvis agent is already running on ws://127.0.0.1:${port}`);
-      console.log(`Use 'jarvis restart' to restart, or 'jarvis logs' to view logs.`);
-      return;
-    }
-    const workspacePath = opts.workspace ?? config?.workspacePath ?? process.cwd();
-    const userId = config?.userId ?? process.env.JARVIS_USER_ID ?? "local";
-    const explicitApiKey = opts.apiKey ?? config?.anthropicApiKey;
-    const useSubscription = !explicitApiKey;
-    const anthropicApiKey = explicitApiKey;
-    if (opts.foreground) {
-      await startAgent({
-        port,
-        workspacePath,
-        anthropicApiKey,
-        useSubscription,
-        userId,
-        upstream: (() => {
-          const apiUrl = process.env.JARVIS_UPSTREAM_URL ?? config?.apiUrl;
-          const token = process.env.JARVIS_UPSTREAM_TOKEN ?? config?.token;
-          if (opts.upstream && apiUrl && token) {
-            return { apiUrl, token, refreshToken: config?.refreshToken };
+  program.command("start").description("Start the local agent (authenticates, cleans up stale processes, starts fresh)").option("-p, --port <port>", "Local WS server port", "7862").option("-w, --workspace <path>", "Workspace root path").option("--api-key <key>", "Anthropic API key (for local-only use)").option("--no-upstream", "Don't connect to cloud (local-only mode)").option("--foreground", "Run in foreground (don't daemonize)").action(
+    async (opts) => {
+      if (!opts.foreground) {
+        const ok = await ensureSetup();
+        if (!ok) {
+          console.error("Setup failed. Cannot start agent.");
+          process.exit(1);
+        }
+      }
+      const config = loadConfig();
+      const port = parseInt(opts.port, 10);
+      const workspacePath = opts.workspace ?? config?.workspacePath ?? process.cwd();
+      const userId = config?.userId ?? process.env.JARVIS_USER_ID ?? "local";
+      const explicitApiKey = opts.apiKey ?? config?.anthropicApiKey;
+      const useSubscription = !explicitApiKey;
+      const anthropicApiKey = explicitApiKey;
+      if (opts.foreground) {
+        if (useSubscription && process.env.ANTHROPIC_API_KEY) {
+          delete process.env.ANTHROPIC_API_KEY;
+        }
+        await startAgent({
+          port,
+          workspacePath,
+          anthropicApiKey,
+          useSubscription,
+          userId,
+          upstream: (() => {
+            const apiUrl = process.env.JARVIS_UPSTREAM_URL ?? config?.apiUrl;
+            const token = process.env.JARVIS_UPSTREAM_TOKEN ?? config?.token;
+            if (opts.upstream && apiUrl && token) {
+              return { apiUrl, token, refreshToken: config?.refreshToken };
+            }
+            return void 0;
+          })()
+        });
+        return;
+      }
+      const service = createServiceManager();
+      if (service.isInstalled()) {
+        try {
+          service.stop();
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, 1e3));
+        service.start();
+        console.log("Jarvis agent started via OS service.");
+        return;
+      }
+      const stalePid = readPid();
+      if (stalePid) {
+        try {
+          process.kill(stalePid, "SIGTERM");
+        } catch {
+        }
+        clearPid();
+      }
+      if (await isPortInUse(port)) {
+        try {
+          const output = execSync2(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
+          if (output) {
+            for (const p of output.split("\n")) {
+              try {
+                process.kill(parseInt(p, 10), "SIGTERM");
+              } catch {
+              }
+            }
           }
-          return void 0;
-        })()
-      });
-      return;
-    }
-    fs7.mkdirSync(LOG_DIR, { recursive: true });
-    const logFd = fs7.openSync(LOG_FILE, "a");
-    const args = [
-      "start",
-      "--foreground",
-      "--port",
-      String(port),
-      "--workspace",
-      workspacePath
-    ];
-    if (!opts.upstream) {
-      args.push("--no-upstream");
-    }
-    if (anthropicApiKey) {
-      args.push("--api-key", anthropicApiKey);
-    }
-    const binPath = process.argv[1];
-    const cliRoot = path7.resolve(path7.dirname(binPath), "..");
-    const distEntry = path7.join(cliRoot, "dist", "bin.js");
-    const useDistEntry = fs7.existsSync(distEntry);
-    const child = spawn2(
-      process.execPath,
-      useDistEntry ? [distEntry, ...args] : [binPath, ...args],
-      {
-        detached: true,
-        stdio: ["ignore", logFd, logFd],
-        cwd: workspacePath,
-        env: { ...process.env, NODE_NO_WARNINGS: "1" }
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+      fs8.mkdirSync(LOG_DIR, { recursive: true });
+      const logFd = fs8.openSync(LOG_FILE, "a");
+      const args = [
+        "start",
+        "--foreground",
+        "--port",
+        String(port),
+        "--workspace",
+        workspacePath
+      ];
+      if (!opts.upstream) {
+        args.push("--no-upstream");
+      }
+      if (anthropicApiKey) {
+        args.push("--api-key", anthropicApiKey);
+      }
+      const binPath = process.argv[1];
+      const cliRoot = path8.resolve(path8.dirname(binPath), "..");
+      const distEntry = path8.join(cliRoot, "dist", "bin.js");
+      const useDistEntry = fs8.existsSync(distEntry);
+      const child = spawn3(
+        process.execPath,
+        useDistEntry ? [distEntry, ...args] : [binPath, ...args],
+        {
+          detached: true,
+          stdio: ["ignore", logFd, logFd],
+          cwd: workspacePath,
+          env: {
+            ...process.env,
+            NODE_NO_WARNINGS: "1",
+            // Strip API key when using subscription to prevent SDK from picking it up
+            ...useSubscription ? { ANTHROPIC_API_KEY: "" } : {}
+          }
+        }
+      );
+      child.unref();
+      fs8.closeSync(logFd);
+      savePid(child.pid);
+      console.log(`Jarvis agent started (PID: ${child.pid})`);
+      console.log(`  Local:     ws://127.0.0.1:${port}`);
+      console.log(`  Workspace: ${workspacePath}`);
+      console.log(`  Logs:      ${LOG_FILE}`);
+      if (config?.apiUrl) {
+        console.log(`  Cloud:     ${config.apiUrl}`);
       }
-    );
-    child.unref();
-    fs7.closeSync(logFd);
-    savePid(child.pid);
-    console.log(`Jarvis agent started (PID: ${child.pid})`);
-    console.log(`  Local:     ws://127.0.0.1:${port}`);
-    console.log(`  Workspace: ${workspacePath}`);
-    console.log(`  Logs:      ${LOG_FILE}`);
-    if (config?.apiUrl) {
-      console.log(`  Cloud:     ${config.apiUrl}`);
     }
-    console.log();
-    console.log(`Commands:`);
-    console.log(`  jarvis logs      \u2014 View agent logs`);
-    console.log(`  jarvis stop      \u2014 Stop the agent`);
-    console.log(`  jarvis restart   \u2014 Restart the agent`);
-  });
+  );
   program.command("stop").description("Stop the running agent").action(async () => {
+    const service = createServiceManager();
+    if (service.isInstalled()) {
+      service.stop();
+      clearPid();
+      console.log("Agent stopped via OS service.");
+      console.log("Use 'jarvis start' to re-enable, or 'jarvis uninstall' to remove auto-start.");
+      return;
+    }
     const pid = readPid();
     if (pid) {
       try {
@@ -5053,7 +5561,7 @@ function createCli() {
     const running = await isPortInUse(7862);
     if (running) {
       try {
-        const output = execSync("lsof -ti :7862", { encoding: "utf-8" }).trim();
+        const output = execSync2("lsof -ti :7862", { encoding: "utf-8" }).trim();
         if (output) {
           const pids = output.split("\n");
           for (const p of pids) {
@@ -5070,27 +5578,16 @@ function createCli() {
     }
     console.log("No agent is running.");
   });
-  program.command("restart").description("Restart the agent").action(async () => {
-    const pid = readPid();
-    if (pid) {
-      try {
-        process.kill(pid, "SIGTERM");
-      } catch {
-      }
-      clearPid();
-      console.log(`Stopped agent (PID: ${pid})`);
-      await new Promise((r) => setTimeout(r, 1e3));
-    }
-    console.log("Starting agent...");
+  program.command("restart").description("Restart the agent (alias for start \u2014 start always does a clean restart)").action(async () => {
     await program.parseAsync(["node", "jarvis", "start"]);
   });
   program.command("logs").description("View agent logs").option("-f, --follow", "Follow log output (like tail -f)", true).option("-n, --lines <n>", "Number of lines to show", "50").action((opts) => {
-    if (!fs7.existsSync(LOG_FILE)) {
+    if (!fs8.existsSync(LOG_FILE)) {
       console.log("No log file found. Start the agent first: jarvis start");
       return;
     }
     if (opts.follow) {
-      const tail = spawn2("tail", ["-f", "-n", opts.lines, LOG_FILE], {
+      const tail = spawn3("tail", ["-f", "-n", opts.lines, LOG_FILE], {
         stdio: "inherit"
       });
       process.on("SIGINT", () => {
@@ -5099,7 +5596,7 @@ function createCli() {
       });
       tail.on("exit", () => process.exit(0));
     } else {
-      const content = execSync(`tail -n ${opts.lines} "${LOG_FILE}"`, { encoding: "utf-8" });
+      const content = execSync2(`tail -n ${opts.lines} "${LOG_FILE}"`, { encoding: "utf-8" });
       process.stdout.write(content);
     }
   });
@@ -5109,7 +5606,9 @@ function createCli() {
     const port = config?.port ?? 7862;
     const running = await isPortInUse(port);
     console.log(`Jarvis Agent v${PKG_VERSION}:`);
-    console.log(`  Status:     ${running ? `\x1B[32mrunning\x1B[0m` : `\x1B[31mstopped\x1B[0m`}${pid ? ` (PID: ${pid})` : ""}`);
+    console.log(
+      `  Status:     ${running ? `\x1B[32mrunning\x1B[0m` : `\x1B[31mstopped\x1B[0m`}${pid ? ` (PID: ${pid})` : ""}`
+    );
     console.log(`  Port:       ${port}`);
     console.log(`  Config:     ${getConfigPath()}`);
     if (config) {
@@ -5123,15 +5622,105 @@ function createCli() {
     } else {
       console.log(`  Config:     Not set up. Run 'jarvis connect <token>'`);
     }
+    const svc = createServiceManager();
+    const svcStatus = svc.status();
+    if (svcStatus.installed) {
+      const label = svcStatus.os ?? "unknown";
+      const state2 = svcStatus.running ? `\x1B[32minstalled & running\x1B[0m (${label})` : `\x1B[33minstalled, stopped\x1B[0m (${label})`;
+      console.log(`  Service:    ${state2}`);
+    } else {
+      console.log(`  Service:    not installed (run 'jarvis install' for always-on)`);
+    }
     console.log(`  Logs:       ${LOG_FILE}`);
   });
+  program.command("install").description("Install as OS service for auto-start on login and crash recovery").option("-p, --port <port>", "Local WS server port", "7862").option("-w, --workspace <path>", "Workspace root path").option("--no-upstream", "Don't connect to cloud").action(async (opts) => {
+    await ensureSetup();
+    const config = loadConfig();
+    const port = parseInt(opts.port, 10);
+    const workspacePath = opts.workspace ?? config?.workspacePath ?? process.cwd();
+    const service = createServiceManager();
+    const binPath = process.argv[1];
+    const cliRoot = path8.resolve(path8.dirname(binPath), "..");
+    const distEntry = path8.join(cliRoot, "dist", "bin.js");
+    const entryPath = fs8.existsSync(distEntry) ? distEntry : binPath;
+    if (!fs8.existsSync(distEntry)) {
+      console.log("\x1B[33mWarning:\x1B[0m Using dev mode entry point (tsx).");
+      console.log("  For reliability, build first: pnpm build");
+      console.log();
+    }
+    const pid = readPid();
+    if (pid) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+      clearPid();
+    }
+    try {
+      service.install({
+        port,
+        workspacePath,
+        nodePath: process.execPath,
+        entryPath,
+        upstream: opts.upstream
+      });
+    } catch (err) {
+      console.error(`Failed to install service: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+    const status = service.status();
+    console.log(`Jarvis agent installed as OS service`);
+    console.log(`  Platform:  ${status.os}`);
+    console.log(`  Port:      ${port}`);
+    console.log(`  Workspace: ${workspacePath}`);
+    console.log(`  Auto-start on login: \x1B[32menabled\x1B[0m`);
+    console.log(`  Crash recovery:      \x1B[32menabled\x1B[0m`);
+    console.log();
+    console.log(`Commands:`);
+    console.log(`  jarvis status      \u2014 Check service status`);
+    console.log(`  jarvis uninstall   \u2014 Remove OS service`);
+  });
+  program.command("uninstall").description("Remove OS service (stops auto-start and crash recovery)").action(() => {
+    const service = createServiceManager();
+    if (!service.isInstalled()) {
+      console.log("No service is installed. Nothing to do.");
+      return;
+    }
+    try {
+      service.stop();
+    } catch {
+    }
+    service.uninstall();
+    clearPid();
+    console.log("Jarvis OS service removed.");
+    console.log("The agent will no longer auto-start on login or restart on crash.");
+  });
   program.command("logout").description("Clear saved configuration").action(() => {
     clearConfig();
     console.log("Configuration cleared.");
   });
+  program.command("chat", { isDefault: true, hidden: true }).description("Interactive TUI").option("--model <id>", "Model (e.g., claude-opus-4-20250514)").option("--mode <mode>", "Permission mode: supervised|auto|plan|yolo").option("--thinking <config>", "Thinking: adaptive|enabled|disabled").option("--thinking-budget <n>", "Token budget when thinking=enabled").option("--max-turns <n>", "Max turns per task").option("-p, --port <port>", "Agent server port", "7862").option("-w, --workspace <path>", "Workspace root path").option("--no-server", "Connect to existing server, don't auto-start").action(async (opts) => {
+    await ensureSetup();
+    await launchChat(opts);
+  });
   return program;
 }
 
 // src/bin.ts
+function findEnv() {
+  let dir = process.cwd();
+  while (dir !== path9.dirname(dir)) {
+    const envPath = path9.join(dir, ".env");
+    if (fs9.existsSync(envPath)) return envPath;
+    dir = path9.dirname(dir);
+  }
+  return void 0;
+}
+var envFile = findEnv();
+if (envFile) {
+  const prev = process.env.ANTHROPIC_API_KEY;
+  dotenv.config({ path: envFile });
+  if (prev === void 0) delete process.env.ANTHROPIC_API_KEY;
+}
 createCli().parse();
 //# sourceMappingURL=bin.js.map