@appchy/jarvis 0.1.15 → 0.1.17

package/dist/bin.js

@@ -1,20 +1,29 @@
 // src/bin.ts
 import dotenv from "dotenv";
-import fs9 from "fs";
-import path9 from "path";
+import fs11 from "fs";
+import path11 from "path";
 
 // src/cli.ts
 import { Command } from "commander";
 import { spawn as spawn3, execSync as execSync2 } from "child_process";
-import fs8 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path10 from "path";
 import os5 from "os";
 
 // src/config.ts
 import fs from "fs";
 import path from "path";
 import os from "os";
-var CONFIG_DIR = process.env.JARVIS_CONFIG_DIR ?? path.join(os.homedir(), ".jarvis");
+function resolveConfigDir() {
+  if (process.env.JARVIS_CONFIG_DIR) return process.env.JARVIS_CONFIG_DIR;
+  const base = path.join(os.homedir(), ".jarvis");
+  const appUrl = process.env.APP_URL ?? "";
+  if (appUrl && !appUrl.includes("appchy.com") && appUrl !== "") {
+    return path.join(base, "dev");
+  }
+  return base;
+}
+var CONFIG_DIR = resolveConfigDir();
 var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
 function loadConfig() {
   try {
@@ -53,30 +62,6 @@ function getConfigPath() {
   return CONFIG_FILE;
 }
 
-// ../../providers/anthropic/src/anthropic.provider.ts
-import Anthropic from "@anthropic-ai/sdk";
-
-// ../../providers/anthropic/src/anthropic.models.ts
-var claudeCodeSonnet = {
-  id: "claude-sonnet-4-5-20250929",
-  name: "Claude Code (Sonnet)",
-  provider: "claude-code",
-  maxTokens: { input: 2e5, output: 16384 },
-  cost: { multiplier: 20, inputTokens: 3, outputTokens: 15 }
-};
-var claudeCodeOpus = {
-  id: "claude-opus-4-6-20250515",
-  name: "Claude Code (Opus)",
-  provider: "claude-code",
-  maxTokens: { input: 2e5, output: 16384 },
-  cost: { multiplier: 50, inputTokens: 5, outputTokens: 25 }
-};
-var claudeCodeModels = {
-  claudeCodeSonnet,
-  claudeCodeOpus,
-  list: () => [claudeCodeSonnet, claudeCodeOpus]
-};
-
 // ../../packages/logger/src/logger.ts
 function resolveError(meta) {
   if (!meta) return {};
@@ -168,6 +153,30 @@ var logger = {
   }
 };
 
+// ../../providers/anthropic/src/anthropic.provider.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// ../../providers/anthropic/src/anthropic.models.ts
+var claudeCodeSonnet = {
+  id: "claude-sonnet-4-5-20250929",
+  name: "Claude Code (Sonnet)",
+  provider: "claude-code",
+  maxTokens: { input: 2e5, output: 16384 },
+  cost: { multiplier: 20, inputTokens: 3, outputTokens: 15 }
+};
+var claudeCodeOpus = {
+  id: "claude-opus-4-6-20250515",
+  name: "Claude Code (Opus)",
+  provider: "claude-code",
+  maxTokens: { input: 2e5, output: 16384 },
+  cost: { multiplier: 50, inputTokens: 5, outputTokens: 25 }
+};
+var claudeCodeModels = {
+  claudeCodeSonnet,
+  claudeCodeOpus,
+  list: () => [claudeCodeSonnet, claudeCodeOpus]
+};
+
 // ../../packages/types/src/agents/llm.types.ts
 function hasOutputFormat(output, format) {
   return output?.formats?.includes(format) ?? false;
@@ -2235,6 +2244,81 @@ function createWsProgressHandlers(deps) {
   return { onMessage, completeTools, waitForInput, handleUserInput, handleProgress };
 }
 
+// src/attachments.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+var TEXT_MIME_PREFIXES = ["text/", "application/json", "application/xml", "application/javascript"];
+var IMAGE_MIME_PREFIXES = ["image/"];
+function isTextFile(mimeType) {
+  return TEXT_MIME_PREFIXES.some((p) => mimeType.startsWith(p));
+}
+function isImageFile(mimeType) {
+  return IMAGE_MIME_PREFIXES.some((p) => mimeType.startsWith(p));
+}
+function resolveUrl(url, baseUrl) {
+  if (url.startsWith("http://") || url.startsWith("https://")) return url;
+  const origin = baseUrl || process.env.APP_URL || "http://localhost:3000";
+  return `${origin}${url}`;
+}
+async function resolveAttachments(attachments, workspacePath, baseUrl) {
+  if (!attachments.length) return "";
+  const parts = [];
+  const uploadDir = path3.join(workspacePath, ".jarvis-uploads");
+  for (const att of attachments) {
+    try {
+      const fullUrl = resolveUrl(att.url, baseUrl);
+      if (isTextFile(att.mimeType)) {
+        const res = await fetch(fullUrl);
+        if (!res.ok) {
+          logger.sys.warn("[Attachments] Failed to fetch text file", {
+            fileName: att.fileName,
+            status: res.status
+          });
+          continue;
+        }
+        const text = await res.text();
+        parts.push(`<file name="${att.fileName}">
+${text}
+</file>`);
+      } else if (isImageFile(att.mimeType)) {
+        await fs3.mkdir(uploadDir, { recursive: true });
+        const localPath = path3.join(uploadDir, att.fileName);
+        const res = await fetch(fullUrl);
+        if (!res.ok) {
+          logger.sys.warn("[Attachments] Failed to fetch image", {
+            fileName: att.fileName,
+            status: res.status
+          });
+          continue;
+        }
+        const buffer = Buffer.from(await res.arrayBuffer());
+        await fs3.writeFile(localPath, buffer);
+        parts.push(`[Image attached: ${localPath}]`);
+      } else {
+        await fs3.mkdir(uploadDir, { recursive: true });
+        const localPath = path3.join(uploadDir, att.fileName);
+        const res = await fetch(fullUrl);
+        if (!res.ok) {
+          logger.sys.warn("[Attachments] Failed to fetch file", {
+            fileName: att.fileName,
+            status: res.status
+          });
+          continue;
+        }
+        const buffer = Buffer.from(await res.arrayBuffer());
+        await fs3.writeFile(localPath, buffer);
+        parts.push(`[File attached: ${localPath}]`);
+      }
+    } catch (err) {
+      logger.sys.warn("[Attachments] Error processing attachment", {
+        fileName: att.fileName,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return parts.length ? parts.join("\n\n") : "";
+}
+
 // src/agent.ts
 function createAgent(deps) {
   const activeTasks = /* @__PURE__ */ new Map();
@@ -2253,6 +2337,27 @@ function createAgent(deps) {
       const wsPath = msg.worktreePath || deps.workspacePath;
       const systemMsg = msg.messages.find((m) => m.role === "system");
       const nonSystemMessages = msg.messages.filter((m) => m.role !== "system");
+      if (msg.attachments?.length) {
+        const attachmentContext = await resolveAttachments(msg.attachments, wsPath);
+        if (attachmentContext) {
+          let lastUserIdx = -1;
+          for (let i = nonSystemMessages.length - 1; i >= 0; i--) {
+            if (nonSystemMessages[i].role === "user") {
+              lastUserIdx = i;
+              break;
+            }
+          }
+          if (lastUserIdx >= 0) {
+            const orig = nonSystemMessages[lastUserIdx];
+            nonSystemMessages[lastUserIdx] = {
+              ...orig,
+              content: `${attachmentContext}
+
+${orig.content}`
+            };
+          }
+        }
+      }
       logger.sys.info("[Agent] Running task", {
         taskId,
         model: msg.model,
@@ -2328,11 +2433,17 @@ function createAgent(deps) {
       });
     } catch (err) {
       if (abortController.signal.aborted) {
-        logger.sys.info("[Agent] Task aborted", { taskId });
+        logger.sys.info("[Agent] Task interrupted", { taskId });
         deps.broadcast({
           type: "agent:output",
           taskId,
-          output: { success: false, content: "", error: "Aborted", sessionId: msg.session?.resume }
+          output: {
+            success: false,
+            content: "",
+            error: "Interrupted",
+            interrupted: true,
+            sessionId: msg.session?.resume
+          }
         });
       } else {
         const error = err instanceof Error ? err.message : String(err);
@@ -2364,12 +2475,92 @@ function createAgent(deps) {
   return { runTask, cancelTask, isRunning, activeTaskCount };
 }
 
+// src/files.ts
+import { execFile } from "child_process";
+import { promisify as promisify2 } from "util";
+import path4 from "path";
+import fs4 from "fs/promises";
+var execFileAsync = promisify2(execFile);
+var MAX_RESULTS = 50;
+async function searchFiles(workspacePath, query) {
+  try {
+    const { stdout } = await execFileAsync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+      cwd: workspacePath,
+      maxBuffer: 1024 * 1024
+    });
+    const allFiles = stdout.split("\n").filter(Boolean);
+    const dirSet = /* @__PURE__ */ new Set();
+    for (const f of allFiles) {
+      const parts = f.split("/");
+      for (let i = 1; i < parts.length; i++) {
+        dirSet.add(parts.slice(0, i).join("/"));
+      }
+    }
+    const allEntries = [
+      ...[...dirSet].map((d) => ({ path: d, name: path4.basename(d), type: "directory" })),
+      ...allFiles.map((f) => ({ path: f, name: path4.basename(f), type: "file" }))
+    ];
+    if (!query.trim()) {
+      const sorted = [...allEntries].sort((a, b) => {
+        const depthA = a.path.split("/").length;
+        const depthB = b.path.split("/").length;
+        if (depthA !== depthB) return depthA - depthB;
+        if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+        return a.path.localeCompare(b.path);
+      });
+      return sorted.slice(0, MAX_RESULTS);
+    }
+    const lowerQuery = query.toLowerCase();
+    const matched = allEntries.filter((e) => e.path.toLowerCase().includes(lowerQuery)).sort((a, b) => {
+      const aExact = a.name.toLowerCase() === lowerQuery ? 0 : 1;
+      const bExact = b.name.toLowerCase() === lowerQuery ? 0 : 1;
+      if (aExact !== bExact) return aExact - bExact;
+      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+      return a.path.localeCompare(b.path);
+    }).slice(0, MAX_RESULTS);
+    return matched;
+  } catch (err) {
+    logger.sys.warn("[Files] git ls-files failed, falling back to fs scan", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return fallbackSearch(workspacePath, query);
+  }
+}
+async function fallbackSearch(workspacePath, query) {
+  const results = [];
+  const lowerQuery = query.toLowerCase();
+  async function walk(dir, depth) {
+    if (depth > 4 || results.length >= MAX_RESULTS) return;
+    try {
+      const entries = await fs4.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (results.length >= MAX_RESULTS) break;
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        const relPath = path4.relative(workspacePath, path4.join(dir, entry.name));
+        if (relPath.toLowerCase().includes(lowerQuery)) {
+          results.push({
+            path: relPath,
+            name: entry.name,
+            type: entry.isDirectory() ? "directory" : "file"
+          });
+        }
+        if (entry.isDirectory()) {
+          await walk(path4.join(dir, entry.name), depth + 1);
+        }
+      }
+    } catch {
+    }
+  }
+  await walk(workspacePath, 0);
+  return results;
+}
+
 // src/git.ts
 import { exec as execCb2 } from "child_process";
-import fs3 from "fs/promises";
-import path3 from "path";
-import { promisify as promisify2 } from "util";
-var exec2 = promisify2(execCb2);
+import fs5 from "fs/promises";
+import path5 from "path";
+import { promisify as promisify3 } from "util";
+var exec2 = promisify3(execCb2);
 function createGitHandler(workspacePath, broadcast) {
   async function handle(msg) {
     switch (msg.type) {
@@ -2394,11 +2585,11 @@ function createGitHandler(workspacePath, broadcast) {
   }
   async function handleResolveRepo(msg) {
     try {
-      const repoDir = path3.join(workspacePath, msg.owner, msg.name);
-      const isCloned = await fs3.access(path3.join(repoDir, ".git")).then(() => true).catch(() => false);
+      const repoDir = path5.join(workspacePath, msg.owner, msg.name);
+      const isCloned = await fs5.access(path5.join(repoDir, ".git")).then(() => true).catch(() => false);
       if (!isCloned) {
         logger.sys.info("[Git] Cloning repo...", { repoDir });
-        await fs3.mkdir(path3.join(workspacePath, msg.owner), { recursive: true });
+        await fs5.mkdir(path5.join(workspacePath, msg.owner), { recursive: true });
         const cloneUrl = `git@github.com:${msg.owner}/${msg.name}.git`;
         await exec2(`git clone "${cloneUrl}" "${repoDir}"`, { timeout: 3e5 });
       }
@@ -2561,7 +2752,7 @@ function createUpstreamClient(config) {
     if (!config.refreshToken) return null;
     return config.apiUrl.replace(/^wss:/, "https:").replace(/^ws:/, "http:") + "/refresh";
   }
-  function getTokenExpiry2(token) {
+  function getTokenExpiry(token) {
     try {
       const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
       return payload.exp ?? null;
@@ -2572,7 +2763,7 @@ function createUpstreamClient(config) {
   function scheduleRefresh() {
     if (refreshTimer) clearTimeout(refreshTimer);
     if (!config.refreshToken) return;
-    const exp = getTokenExpiry2(currentToken);
+    const exp = getTokenExpiry(currentToken);
     if (!exp) return;
     const msUntilExpiry = exp * 1e3 - Date.now();
     const refreshIn = Math.max(msUntilExpiry - REFRESH_BUFFER_MS, 0);
@@ -2759,6 +2950,18 @@ async function startAgent(options) {
         }
         break;
       }
+      case "files:search": {
+        const filesMsg = msg;
+        searchFiles(options.workspacePath, filesMsg.query).then((files) => {
+          broadcast({ type: "files:response", requestId: filesMsg.requestId, files });
+        }).catch((err) => {
+          logger.sys.error("[Agent] File search failed", {
+            error: err instanceof Error ? err.message : String(err)
+          });
+          broadcast({ type: "files:response", requestId: filesMsg.requestId, files: [] });
+        });
+        break;
+      }
       case "ping":
         break;
     }
@@ -2792,14 +2995,14 @@ import React6 from "react";
 import { render as render2 } from "ink";
 import { spawn } from "child_process";
 import { fileURLToPath } from "url";
-import path6 from "path";
-import fs6 from "fs";
+import path8 from "path";
+import fs8 from "fs";
 import os3 from "os";
 import WebSocket4 from "ws";
 
 // src/tui/settings.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import os2 from "os";
 var DEFAULT_SETTINGS = {
   model: "claude-sonnet-4-20250514",
@@ -2809,11 +3012,11 @@ var DEFAULT_SETTINGS = {
   theme: "dark",
   disallowedTools: []
 };
-var SETTINGS_DIR = path4.join(os2.homedir(), ".jarvis");
-var SETTINGS_FILE = path4.join(SETTINGS_DIR, "settings.json");
+var SETTINGS_DIR = path6.join(os2.homedir(), ".jarvis");
+var SETTINGS_FILE = path6.join(SETTINGS_DIR, "settings.json");
 function loadSettings() {
   try {
-    const raw = fs4.readFileSync(SETTINGS_FILE, "utf-8");
+    const raw = fs6.readFileSync(SETTINGS_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     return { ...DEFAULT_SETTINGS, ...parsed };
   } catch {
@@ -2821,8 +3024,8 @@ function loadSettings() {
   }
 }
 function saveSettings(settings) {
-  fs4.mkdirSync(SETTINGS_DIR, { recursive: true });
-  fs4.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2) + "\n");
+  fs6.mkdirSync(SETTINGS_DIR, { recursive: true });
+  fs6.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2) + "\n");
 }
 function mergeCliFlags(settings, flags) {
   const merged = { ...settings };
@@ -3532,8 +3735,8 @@ function Suggestions({
 
 // src/tui/components/file-picker.tsx
 import { Box as Box6, Text as Text6 } from "ink";
-import path5 from "path";
-import fs5 from "fs";
+import path7 from "path";
+import fs7 from "fs";
 import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 var cachedFiles = null;
 function scanFiles(workspacePath) {
@@ -3554,11 +3757,11 @@ function scanFiles(workspacePath) {
   function walk(dir, depth) {
     if (depth > 4) return;
     try {
-      const entries = fs5.readdirSync(dir, { withFileTypes: true });
+      const entries = fs7.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (ignoreSet.has(entry.name) || entry.name.startsWith(".")) continue;
-        const full = path5.join(dir, entry.name);
-        const rel = path5.relative(workspacePath, full);
+        const full = path7.join(dir, entry.name);
+        const rel = path7.relative(workspacePath, full);
         if (entry.isDirectory()) {
           results.push(rel + "/");
           walk(full, depth + 1);
@@ -4747,13 +4950,13 @@ async function launchChat(opts) {
 }
 function spawnAgentProcess(port, workspacePath) {
   const config = loadConfig();
-  const logDir = path6.join(os3.homedir(), ".jarvis");
-  fs6.mkdirSync(logDir, { recursive: true });
-  const logFile = path6.join(logDir, "agent.log");
-  const logFd = fs6.openSync(logFile, "a");
+  const logDir = path8.join(os3.homedir(), ".jarvis");
+  fs8.mkdirSync(logDir, { recursive: true });
+  const logFile = path8.join(logDir, "agent.log");
+  const logFd = fs8.openSync(logFile, "a");
   const __filename = fileURLToPath(import.meta.url);
-  const cliRoot = path6.resolve(path6.dirname(__filename), "../..");
-  const binPath = path6.join(cliRoot, "bin", "jarvis.mjs");
+  const cliRoot = path8.resolve(path8.dirname(__filename), "../..");
+  const binPath = path8.join(cliRoot, "bin", "jarvis.mjs");
   const args = ["start", "--port", String(port), "--workspace", workspacePath];
   if (config?.apiUrl && config?.token) {
   } else {
@@ -4768,7 +4971,7 @@ function spawnAgentProcess(port, workspacePath) {
     cwd: workspacePath,
     env: { ...process.env }
   });
-  fs6.closeSync(logFd);
+  fs8.closeSync(logFd);
 }
 async function checkAgentRunning(port) {
   return new Promise((resolve) => {
@@ -4805,8 +5008,8 @@ 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 fs9 from "fs";
+import path9 from "path";
 import os4 from "os";
 function createServiceManager() {
   if (process.platform === "darwin") return new MacOSService();
@@ -4815,8 +5018,8 @@ function createServiceManager() {
   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`);
+var PLIST_DIR = path9.join(os4.homedir(), "Library", "LaunchAgents");
+var PLIST_PATH = path9.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;");
 }
@@ -4835,7 +5038,7 @@ var MacOSService = class {
     if (!opts.upstream) {
       args.push("--no-upstream");
     }
-    const logFile = path7.join(os4.homedir(), ".jarvis", "agent.log");
+    const logFile = path9.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">
@@ -4860,6 +5063,8 @@ ${args.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n")}
     <string>${escapeXml(os4.homedir())}</string>
     <key>NODE_NO_WARNINGS</key>
     <string>1</string>
+${Object.entries(opts.env ?? {}).map(([k, v]) => `    <key>${escapeXml(k)}</key>
+    <string>${escapeXml(v)}</string>`).join("\n")}
   </dict>
 
   <key>RunAtLoad</key>
@@ -4882,15 +5087,15 @@ ${args.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n")}
 </dict>
 </plist>
 `;
-    fs7.mkdirSync(PLIST_DIR, { recursive: true });
-    fs7.mkdirSync(path7.dirname(logFile), { recursive: true });
+    fs9.mkdirSync(PLIST_DIR, { recursive: true });
+    fs9.mkdirSync(path9.dirname(logFile), { recursive: true });
     if (this.isInstalled()) {
       try {
         execSync(`launchctl unload -w "${PLIST_PATH}"`, { stdio: "ignore" });
       } catch {
       }
     }
-    fs7.writeFileSync(PLIST_PATH, plist);
+    fs9.writeFileSync(PLIST_PATH, plist);
     execSync(`launchctl load -w "${PLIST_PATH}"`);
   }
   uninstall() {
@@ -4899,12 +5104,12 @@ ${args.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n")}
     } catch {
     }
     try {
-      fs7.unlinkSync(PLIST_PATH);
+      fs9.unlinkSync(PLIST_PATH);
     } catch {
     }
   }
   isInstalled() {
-    return fs7.existsSync(PLIST_PATH);
+    return fs9.existsSync(PLIST_PATH);
   }
   start() {
     try {
@@ -4994,15 +5199,15 @@ var WindowsService = class {
 </Task>
 `;
     const tmpDir = os4.tmpdir();
-    const tmpFile = path7.join(tmpDir, `jarvis-task-${Date.now()}.xml`);
-    fs7.writeFileSync(tmpFile, xml, { encoding: "utf-16le" });
+    const tmpFile = path9.join(tmpDir, `jarvis-task-${Date.now()}.xml`);
+    fs9.writeFileSync(tmpFile, xml, { encoding: "utf-16le" });
     try {
       execSync(`schtasks /Create /TN "${TASK_NAME}" /XML "${tmpFile}" /F`, {
         stdio: "ignore"
       });
     } finally {
       try {
-        fs7.unlinkSync(tmpFile);
+        fs9.unlinkSync(tmpFile);
       } catch {
       }
     }
@@ -5040,9 +5245,9 @@ var WindowsService = class {
     }
   }
 };
-var SYSTEMD_DIR = path7.join(os4.homedir(), ".config", "systemd", "user");
+var SYSTEMD_DIR = path9.join(os4.homedir(), ".config", "systemd", "user");
 var UNIT_NAME = "jarvis.service";
-var UNIT_PATH = path7.join(SYSTEMD_DIR, UNIT_NAME);
+var UNIT_PATH = path9.join(SYSTEMD_DIR, UNIT_NAME);
 var LinuxService = class {
   install(opts) {
     const args = [
@@ -5057,7 +5262,7 @@ var LinuxService = class {
     if (!opts.upstream) {
       args.push("--no-upstream");
     }
-    const logFile = path7.join(os4.homedir(), ".jarvis", "agent.log");
+    const logFile = path9.join(os4.homedir(), ".jarvis", "agent.log");
     const envPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
     const unit = `[Unit]
 Description=Jarvis AI Agent
@@ -5078,15 +5283,15 @@ StandardError=append:${logFile}
 [Install]
 WantedBy=default.target
 `;
-    fs7.mkdirSync(SYSTEMD_DIR, { recursive: true });
-    fs7.mkdirSync(path7.dirname(logFile), { recursive: true });
+    fs9.mkdirSync(SYSTEMD_DIR, { recursive: true });
+    fs9.mkdirSync(path9.dirname(logFile), { recursive: true });
     if (this.isInstalled()) {
       try {
         execSync("systemctl --user stop jarvis.service", { stdio: "ignore" });
       } catch {
       }
     }
-    fs7.writeFileSync(UNIT_PATH, unit);
+    fs9.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" });
@@ -5105,7 +5310,7 @@ WantedBy=default.target
     } catch {
     }
     try {
-      fs7.unlinkSync(UNIT_PATH);
+      fs9.unlinkSync(UNIT_PATH);
     } catch {
     }
     try {
@@ -5114,7 +5319,7 @@ WantedBy=default.target
     }
   }
   isInstalled() {
-    return fs7.existsSync(UNIT_PATH);
+    return fs9.existsSync(UNIT_PATH);
   }
   start() {
     execSync("systemctl --user start jarvis.service");
@@ -5144,13 +5349,13 @@ WantedBy=default.target
 };
 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");
+    this.pidFile = path9.join(os4.homedir(), ".jarvis", "agent.pid");
+    this.logFile = path9.join(os4.homedir(), ".jarvis", "agent.log");
+    this.markerFile = path9.join(os4.homedir(), ".jarvis", "service-installed");
   }
   install(opts) {
-    const jarvisDir = path7.join(os4.homedir(), ".jarvis");
-    fs7.mkdirSync(jarvisDir, { recursive: true });
+    const jarvisDir = path9.join(os4.homedir(), ".jarvis");
+    fs9.mkdirSync(jarvisDir, { recursive: true });
     this.stop();
     const args = [
       opts.entryPath,
@@ -5164,7 +5369,7 @@ var FallbackService = class {
     if (!opts.upstream) {
       args.push("--no-upstream");
     }
-    const logFd = fs7.openSync(this.logFile, "a");
+    const logFd = fs9.openSync(this.logFile, "a");
     const child = spawn2(opts.nodePath, args, {
       detached: true,
       stdio: ["ignore", logFd, logFd],
@@ -5172,9 +5377,9 @@ var FallbackService = class {
       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({
+    fs9.closeSync(logFd);
+    fs9.writeFileSync(this.pidFile, String(child.pid));
+    fs9.writeFileSync(this.markerFile, JSON.stringify({
       nodePath: opts.nodePath,
       entryPath: opts.entryPath,
       port: opts.port,
@@ -5190,37 +5395,37 @@ var FallbackService = class {
   uninstall() {
     this.stop();
     try {
-      fs7.unlinkSync(this.markerFile);
+      fs9.unlinkSync(this.markerFile);
     } catch {
     }
   }
   isInstalled() {
-    return fs7.existsSync(this.markerFile);
+    return fs9.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"));
+    const saved = JSON.parse(fs9.readFileSync(this.markerFile, "utf-8"));
     this.install(saved);
   }
   stop() {
     try {
-      const pid = parseInt(fs7.readFileSync(this.pidFile, "utf-8").trim(), 10);
+      const pid = parseInt(fs9.readFileSync(this.pidFile, "utf-8").trim(), 10);
       if (!isNaN(pid)) {
         process.kill(pid, "SIGTERM");
       }
     } catch {
     }
     try {
-      fs7.unlinkSync(this.pidFile);
+      fs9.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);
+      const pid = parseInt(fs9.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 };
@@ -5234,22 +5439,18 @@ var FallbackService = class {
 import { createRequire } from "module";
 var _require = createRequire(import.meta.url);
 var PKG_VERSION = _require("../package.json").version ?? "dev";
-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) {
-  fs8.mkdirSync(LOG_DIR, { recursive: true });
-  fs8.writeFileSync(PID_FILE, String(pid));
-}
+var LOG_DIR = path10.join(os5.homedir(), ".jarvis");
+var LOG_FILE = path10.join(LOG_DIR, "agent.log");
+var PID_FILE = path10.join(LOG_DIR, "agent.pid");
 function readPid() {
   try {
-    const pid = parseInt(fs8.readFileSync(PID_FILE, "utf-8").trim(), 10);
+    const pid = parseInt(fs10.readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (isNaN(pid)) return null;
     try {
       process.kill(pid, 0);
       return pid;
     } catch {
-      fs8.unlinkSync(PID_FILE);
+      fs10.unlinkSync(PID_FILE);
       return null;
     }
   } catch {
@@ -5258,7 +5459,7 @@ function readPid() {
 }
 function clearPid() {
   try {
-    fs8.unlinkSync(PID_FILE);
+    fs10.unlinkSync(PID_FILE);
   } catch {
   }
 }
@@ -5308,7 +5509,7 @@ async function findFreePort() {
 async function browserAuth(appUrl) {
   const config = loadConfig();
   const callbackPort = await findFreePort();
-  const loginUrl = `${appUrl}/api/auth/cli?port=${callbackPort}`;
+  const loginUrl = `${appUrl}/auth/cli?port=${callbackPort}`;
   console.log();
   console.log("Opening browser for sign in...");
   console.log(`  If it doesn't open, visit: ${loginUrl}`);
@@ -5339,57 +5540,17 @@ async function browserAuth(appUrl) {
   }
 }
 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;
-  }
+  if ("https://jarvis.appchy.com") return "https://jarvis.appchy.com";
+  if (process.env.APP_URL) return process.env.APP_URL;
+  return "https://jarvis.appchy.com";
 }
 async function ensureSetup() {
   const config = loadConfig();
-  if (!config?.token && !config?.anthropicApiKey && !config?.useSubscription) {
-    return browserAuth(getAppUrl());
-  }
   if (config?.anthropicApiKey || config?.useSubscription) {
     return true;
   }
-  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;
-    }
-    console.log("Token refresh failed. Re-authenticating...");
-    return browserAuth(getAppUrl());
-  }
-  return true;
+  clearConfig();
+  return browserAuth(getAppUrl());
 }
 function createCli() {
   const program = new Command().name("jarvis").description("Jarvis local agent \u2014 runs Claude Code on your machine").version(PKG_VERSION);
@@ -5459,13 +5620,9 @@ function createCli() {
       const service = createServiceManager();
       if (service.isInstalled()) {
         try {
-          service.stop();
+          service.uninstall();
         } catch {
         }
-        await new Promise((r) => setTimeout(r, 1e3));
-        service.start();
-        console.log("Jarvis agent started via OS service.");
-        return;
       }
       const stalePid = readPid();
       if (stalePid) {
@@ -5475,13 +5632,13 @@ function createCli() {
         }
         clearPid();
       }
-      if (await isPortInUse(port)) {
+      const killPort = async (p) => {
         try {
-          const output = execSync2(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
+          const output = execSync2(`lsof -ti :${p}`, { encoding: "utf-8" }).trim();
           if (output) {
-            for (const p of output.split("\n")) {
+            for (const pid of output.split("\n")) {
               try {
-                process.kill(parseInt(p, 10), "SIGTERM");
+                process.kill(parseInt(pid, 10), "SIGTERM");
               } catch {
               }
             }
@@ -5489,52 +5646,66 @@ function createCli() {
         } 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: "" } : {}
+        if (await isPortInUse(p)) {
+          try {
+            const output = execSync2(`lsof -ti :${p}`, { encoding: "utf-8" }).trim();
+            if (output) {
+              for (const pid of output.split("\n")) {
+                try {
+                  process.kill(parseInt(pid, 10), "SIGKILL");
+                } catch {
+                }
+              }
+            }
+          } catch {
           }
+          await new Promise((r) => setTimeout(r, 1e3));
         }
-      );
-      child.unref();
-      fs8.closeSync(logFd);
-      savePid(child.pid);
-      console.log(`Jarvis agent started (PID: ${child.pid})`);
+      };
+      await killPort(port);
+      const binPath = process.argv[1];
+      const cliRoot = path10.resolve(path10.dirname(binPath), "..");
+      const distEntry = path10.join(cliRoot, "dist", "bin.js");
+      const entryPath = fs10.existsSync(distEntry) ? distEntry : binPath;
+      const serviceEnv = {};
+      if (process.env.APP_URL) serviceEnv.APP_URL = process.env.APP_URL;
+      if ("https://jarvis.appchy.com") serviceEnv.JARVIS_APP_URL = "https://jarvis.appchy.com";
+      if (process.env.JARVIS_CONFIG_DIR) serviceEnv.JARVIS_CONFIG_DIR = process.env.JARVIS_CONFIG_DIR;
+      if (process.env.JARVIS_USER_ID) serviceEnv.JARVIS_USER_ID = process.env.JARVIS_USER_ID;
+      if (process.env.JARVIS_ENV_ID) serviceEnv.JARVIS_ENV_ID = process.env.JARVIS_ENV_ID;
+      service.install({
+        port,
+        workspacePath,
+        nodePath: process.execPath,
+        entryPath,
+        upstream: opts.upstream,
+        ...Object.keys(serviceEnv).length > 0 ? { env: serviceEnv } : {}
+      });
+      const startTime = Date.now();
+      let agentReady = false;
+      while (Date.now() - startTime < 15e3) {
+        if (await isPortInUse(port)) {
+          agentReady = true;
+          break;
+        }
+        await new Promise((r) => setTimeout(r, 500));
+      }
+      if (!agentReady) {
+        console.error("Agent failed to start. Check logs:");
+        console.error(`  ${LOG_FILE}`);
+        process.exit(1);
+      }
+      const status = service.status();
+      console.log(`Jarvis agent started`);
       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}`);
       }
+      if (status.os) {
+        console.log(`  Service:   ${status.os} (auto-start on login, crash recovery)`);
+      }
     }
   );
   program.command("stop").description("Stop the running agent").action(async () => {
@@ -5582,7 +5753,7 @@ function createCli() {
     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 (!fs8.existsSync(LOG_FILE)) {
+    if (!fs10.existsSync(LOG_FILE)) {
       console.log("No log file found. Start the agent first: jarvis start");
       return;
     }
@@ -5640,10 +5811,10 @@ function createCli() {
     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)) {
+    const cliRoot = path10.resolve(path10.dirname(binPath), "..");
+    const distEntry = path10.join(cliRoot, "dist", "bin.js");
+    const entryPath = fs10.existsSync(distEntry) ? distEntry : binPath;
+    if (!fs10.existsSync(distEntry)) {
       console.log("\x1B[33mWarning:\x1B[0m Using dev mode entry point (tsx).");
       console.log("  For reliability, build first: pnpm build");
       console.log();
@@ -5656,13 +5827,20 @@ function createCli() {
       }
       clearPid();
     }
+    const installEnv = {};
+    if (process.env.APP_URL) installEnv.APP_URL = process.env.APP_URL;
+    if ("https://jarvis.appchy.com") installEnv.JARVIS_APP_URL = "https://jarvis.appchy.com";
+    if (process.env.JARVIS_CONFIG_DIR) installEnv.JARVIS_CONFIG_DIR = process.env.JARVIS_CONFIG_DIR;
+    if (process.env.JARVIS_USER_ID) installEnv.JARVIS_USER_ID = process.env.JARVIS_USER_ID;
+    if (process.env.JARVIS_ENV_ID) installEnv.JARVIS_ENV_ID = process.env.JARVIS_ENV_ID;
     try {
       service.install({
         port,
         workspacePath,
         nodePath: process.execPath,
         entryPath,
-        upstream: opts.upstream
+        upstream: opts.upstream,
+        ...Object.keys(installEnv).length > 0 ? { env: installEnv } : {}
       });
     } catch (err) {
       console.error(`Failed to install service: ${err instanceof Error ? err.message : err}`);
@@ -5709,10 +5887,10 @@ function createCli() {
 // 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);
+  while (dir !== path11.dirname(dir)) {
+    const envPath = path11.join(dir, ".env");
+    if (fs11.existsSync(envPath)) return envPath;
+    dir = path11.dirname(dir);
   }
   return void 0;
 }