@appchy/jarvis 0.1.18 → 0.1.20

package/dist/bin.js

@@ -1,27 +1,28 @@
-// src/bin.ts
-import dotenv from "dotenv";
-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 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";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function isDev() {
+  try {
+    const envFile = path.join(__dirname, "..", "env.json");
+    const data = JSON.parse(fs.readFileSync(envFile, "utf-8"));
+    return data.env === "development";
+  } catch {
+    return false;
+  }
+}
+var PROD_APP_URL = "https://jarvis.appchy.com";
+var DEV_APP_URL = "http://localhost:3000";
+function getDefaultAppUrl() {
+  return isDev() ? process.env.APP_URL || DEV_APP_URL : PROD_APP_URL;
+}
 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;
+  return isDev() ? path.join(base, "dev") : base;
 }
 var CONFIG_DIR = resolveConfigDir();
 var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
@@ -62,6 +63,13 @@ function getConfigPath() {
   return CONFIG_FILE;
 }
 
+// src/cli.ts
+import { Command } from "commander";
+import { spawn as spawn3, execSync as execSync2 } from "child_process";
+import fs10 from "fs";
+import path10 from "path";
+import os6 from "os";
+
 // ../../packages/logger/src/logger.ts
 function resolveError(meta) {
   if (!meta) return {};
@@ -1982,42 +1990,58 @@ function formatToolDescription(toolName, input) {
 // ../../packages/agent/src/worktree.ts
 import { exec as execCb } from "child_process";
 import fs2 from "fs/promises";
+import os2 from "os";
 import path2 from "path";
 import { promisify } from "util";
 var exec = promisify(execCb);
-var WORKTREE_DIR = ".jarvis/worktrees";
-async function createWorktree(repoPath, taskId, baseBranch) {
-  const branchName = `jarvis/task-${taskId}`;
-  const worktreeDir = path2.join(repoPath, WORKTREE_DIR, `task-${taskId}`);
-  await fs2.mkdir(path2.dirname(worktreeDir), { recursive: true });
-  await ensureGitignore(repoPath);
-  if (await worktreeExists(repoPath, taskId)) {
-    return worktreeDir;
-  }
-  const startPoint = baseBranch ?? "HEAD";
-  await exec(`git worktree add -b "${branchName}" "${worktreeDir}" "${startPoint}"`, {
-    cwd: repoPath
+var DEFAULT_WORKTREE_DIR = path2.join(os2.homedir(), ".jarvis", "worktrees");
+function resolveDir(worktreeDir) {
+  if (!worktreeDir) return DEFAULT_WORKTREE_DIR;
+  return worktreeDir.replace(/^~/, os2.homedir());
+}
+async function createWorktree(req) {
+  const branchName = `jarvis/task-${req.taskId}`;
+  const baseDir = resolveDir(req.worktreeDir);
+  const worktreePath = path2.join(baseDir, `task-${req.taskId}`);
+  await fs2.mkdir(path2.dirname(worktreePath), { recursive: true });
+  if (await worktreeExists({ taskId: req.taskId, worktreeDir: req.worktreeDir })) {
+    return { worktreePath, branchName };
+  }
+  const startPoint = req.branch ?? "HEAD";
+  await exec(`git worktree add -b "${branchName}" "${worktreePath}" "${startPoint}"`, {
+    cwd: req.repoPath
   });
-  return worktreeDir;
+  return { worktreePath, branchName };
 }
-async function worktreeExists(repoPath, taskId) {
-  const worktreeDir = path2.join(repoPath, WORKTREE_DIR, `task-${taskId}`);
-  try {
-    await fs2.access(worktreeDir);
-    return true;
-  } catch {
-    return false;
+async function listWorktrees(req) {
+  const { stdout } = await exec("git worktree list --porcelain", { cwd: req.repoPath });
+  const worktrees = [];
+  let currentPath = "";
+  let currentBranch = "";
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      currentPath = line.slice(9);
+    } else if (line.startsWith("branch refs/heads/")) {
+      currentBranch = line.slice(18);
+      if (currentBranch.startsWith("jarvis/task-")) {
+        worktrees.push({
+          taskId: currentBranch.replace("jarvis/task-", ""),
+          path: currentPath,
+          branch: currentBranch
+        });
+      }
+    }
   }
+  return worktrees;
 }
-async function ensureGitignore(repoPath) {
-  const gitignorePath = path2.join(repoPath, ".gitignore");
+async function worktreeExists(req) {
+  const baseDir = resolveDir(req.worktreeDir);
+  const worktreePath = path2.join(baseDir, `task-${req.taskId}`);
   try {
-    const content = await fs2.readFile(gitignorePath, "utf-8");
-    if (!content.includes(".jarvis/")) {
-      await fs2.appendFile(gitignorePath, "\n.jarvis/\n");
-    }
+    await fs2.access(worktreePath);
+    return true;
   } catch {
-    await fs2.writeFile(gitignorePath, ".jarvis/\n");
+    return false;
   }
 }
 
@@ -2257,7 +2281,7 @@ function isImageFile(mimeType) {
 }
 function resolveUrl(url, baseUrl) {
   if (url.startsWith("http://") || url.startsWith("https://")) return url;
-  const origin = baseUrl || process.env.APP_URL || "http://localhost:3000";
+  const origin = baseUrl || getDefaultAppUrl();
   return `${origin}${url}`;
 }
 async function resolveAttachments(attachments, workspacePath, baseUrl) {
@@ -2338,7 +2362,7 @@ function createAgent(deps) {
       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);
+        const attachmentContext = await resolveAttachments(msg.attachments, wsPath, getDefaultAppUrl());
         if (attachmentContext) {
           let lastUserIdx = -1;
           for (let i = nonSystemMessages.length - 1; i >= 0; i--) {
@@ -2576,6 +2600,12 @@ function createGitHandler(workspacePath, broadcast) {
       case "git:diffStats":
         await handleDiffStats(msg);
         return true;
+      case "git:listWorktrees":
+        await handleListWorktrees(msg);
+        return true;
+      case "git:browseDir":
+        await handleBrowseDir(msg);
+        return true;
       default:
         return false;
     }
@@ -2583,34 +2613,55 @@ function createGitHandler(workspacePath, broadcast) {
   function respond(requestId, result, error) {
     broadcast({ type: "git:response", requestId, result, error });
   }
+  async function hasGitDir(dir) {
+    return fs5.access(path5.join(dir, ".git")).then(() => true).catch(() => false);
+  }
+  async function fetchAndCheckout(repoDir, branch) {
+    await exec2("git fetch origin", { cwd: repoDir, timeout: 12e4 });
+    try {
+      await exec2(`git checkout "${branch}"`, { cwd: repoDir });
+    } catch {
+      await exec2(`git checkout -b "${branch}" "origin/${branch}"`, { cwd: repoDir });
+    }
+    await exec2("git pull --ff-only", { cwd: repoDir }).catch(() => {
+    });
+  }
   async function handleResolveRepo(msg) {
     try {
-      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 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 });
+      if (msg.repoPath && await hasGitDir(msg.repoPath)) {
+        logger.sys.info("[Git] Using explicit repo path", { repoPath: msg.repoPath });
+        await fetchAndCheckout(msg.repoPath, msg.branch);
+        respond(msg.requestId, { repoPath: msg.repoPath });
+        return;
       }
-      await exec2("git fetch origin", { cwd: repoDir, timeout: 12e4 });
-      try {
-        await exec2(`git checkout "${msg.branch}"`, { cwd: repoDir });
-      } catch {
-        await exec2(`git checkout -b "${msg.branch}" "origin/${msg.branch}"`, { cwd: repoDir });
+      const byName = path5.join(workspacePath, msg.name);
+      if (await hasGitDir(byName)) {
+        logger.sys.info("[Git] Found repo by name", { repoPath: byName });
+        await fetchAndCheckout(byName, msg.branch);
+        respond(msg.requestId, { repoPath: byName });
+        return;
       }
-      await exec2("git pull --ff-only", { cwd: repoDir }).catch(() => {
-      });
-      logger.sys.info("[Git] Repo resolved", { repoDir, branch: msg.branch });
-      respond(msg.requestId, { repoPath: repoDir });
+      const byOwnerName = path5.join(workspacePath, msg.owner, msg.name);
+      if (await hasGitDir(byOwnerName)) {
+        logger.sys.info("[Git] Found repo by owner/name", { repoPath: byOwnerName });
+        await fetchAndCheckout(byOwnerName, msg.branch);
+        respond(msg.requestId, { repoPath: byOwnerName });
+        return;
+      }
+      logger.sys.info("[Git] Cloning repo...", { repoDir: byOwnerName });
+      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}" "${byOwnerName}"`, { timeout: 3e5 });
+      await fetchAndCheckout(byOwnerName, msg.branch);
+      respond(msg.requestId, { repoPath: byOwnerName });
     } catch (err) {
       respond(msg.requestId, null, err instanceof Error ? err.message : String(err));
     }
   }
   async function handleCreateWorktree(msg) {
     try {
-      const worktreePath = await createWorktree(msg.repoPath, msg.taskId, msg.branch);
-      respond(msg.requestId, { worktreePath, branchName: `jarvis/task-${msg.taskId}` });
+      const result = await createWorktree({ repoPath: msg.repoPath, taskId: msg.taskId, branch: msg.branch });
+      respond(msg.requestId, result);
     } catch (err) {
       respond(msg.requestId, null, err instanceof Error ? err.message : String(err));
     }
@@ -2652,6 +2703,26 @@ function createGitHandler(workspacePath, broadcast) {
       respond(msg.requestId, { files: [], additions: 0, deletions: 0 });
     }
   }
+  async function handleListWorktrees(msg) {
+    try {
+      const worktrees = await listWorktrees({ repoPath: msg.repoPath });
+      respond(msg.requestId, worktrees);
+    } catch (err) {
+      respond(msg.requestId, null, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleBrowseDir(msg) {
+    try {
+      const { stdout } = await exec2(
+        `osascript -e 'set theFolder to POSIX path of (choose folder with prompt "Select worktree directory")' -e 'return theFolder'`,
+        { timeout: 6e4 }
+      );
+      const selectedPath = stdout.trim();
+      respond(msg.requestId, { path: selectedPath });
+    } catch (err) {
+      respond(msg.requestId, null, err instanceof Error ? err.message : String(err));
+    }
+  }
   return { handle };
 }
 
@@ -2754,7 +2825,11 @@ function createUpstreamClient(config) {
   }
   function getTokenExpiry(token) {
     try {
-      const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+      const parts = token.split(".");
+      if (parts.length === 5) {
+        return Math.floor(Date.now() / 1e3) + 3600;
+      }
+      const payload = JSON.parse(Buffer.from(parts[1], "base64").toString());
       return payload.exp ?? null;
     } catch {
       return null;
@@ -2800,6 +2875,29 @@ function createUpstreamClient(config) {
       return false;
     }
   }
+  function attemptReauth() {
+    if (!config.onAuthExhausted) {
+      logger.sys.error("[Upstream] Auth failed after max retries, giving up");
+      return;
+    }
+    logger.sys.info("[Upstream] Auth exhausted, attempting re-authentication...");
+    config.onAuthExhausted().then((result) => {
+      if (!result) {
+        logger.sys.error("[Upstream] Re-authentication failed, giving up");
+        return;
+      }
+      currentToken = result.token;
+      if (result.refreshToken) config.refreshToken = result.refreshToken;
+      authFailures = 0;
+      retries = 0;
+      logger.sys.info("[Upstream] Re-authenticated, reconnecting...");
+      reconnectTimer = setTimeout(connect, 1e3);
+    }).catch((err) => {
+      logger.sys.error("[Upstream] Re-authentication error", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+  }
   function connect() {
     if (closed) return;
     ws = new WebSocket2(config.apiUrl, {
@@ -2833,10 +2931,7 @@ function createUpstreamClient(config) {
             } else {
               authFailures++;
               if (authFailures >= MAX_AUTH_RETRIES) {
-                logger.sys.error("[Upstream] Auth failed after max retries, giving up", {
-                  code,
-                  attempts: authFailures
-                });
+                attemptReauth();
                 return;
               }
               reconnectTimer = setTimeout(connect, 3e3);
@@ -2846,10 +2941,7 @@ function createUpstreamClient(config) {
         }
         authFailures++;
         if (authFailures >= MAX_AUTH_RETRIES) {
-          logger.sys.error("[Upstream] Auth failed after max retries, giving up", {
-            code,
-            attempts: authFailures
-          });
+          attemptReauth();
           return;
         }
         logger.sys.warn("[Upstream] Auth failed, retrying...", {
@@ -2994,16 +3086,16 @@ async function startAgent(options) {
 import React6 from "react";
 import { render as render2 } from "ink";
 import { spawn } from "child_process";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import path8 from "path";
 import fs8 from "fs";
-import os3 from "os";
+import os4 from "os";
 import WebSocket4 from "ws";
 
 // src/tui/settings.ts
 import fs6 from "fs";
 import path6 from "path";
-import os2 from "os";
+import os3 from "os";
 var DEFAULT_SETTINGS = {
   model: "claude-sonnet-4-20250514",
   thinking: { type: "adaptive" },
@@ -3012,7 +3104,7 @@ var DEFAULT_SETTINGS = {
   theme: "dark",
   disallowedTools: []
 };
-var SETTINGS_DIR = path6.join(os2.homedir(), ".jarvis");
+var SETTINGS_DIR = path6.join(os3.homedir(), ".jarvis");
 var SETTINGS_FILE = path6.join(SETTINGS_DIR, "settings.json");
 function loadSettings() {
   try {
@@ -4950,12 +5042,12 @@ async function launchChat(opts) {
 }
 function spawnAgentProcess(port, workspacePath) {
   const config = loadConfig();
-  const logDir = path8.join(os3.homedir(), ".jarvis");
+  const logDir = path8.join(os4.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 = path8.resolve(path8.dirname(__filename), "../..");
+  const __filename2 = fileURLToPath2(import.meta.url);
+  const cliRoot = path8.resolve(path8.dirname(__filename2), "../..");
   const binPath = path8.join(cliRoot, "bin", "jarvis.mjs");
   const args = ["start", "--port", String(port), "--workspace", workspacePath];
   if (config?.apiUrl && config?.token) {
@@ -5010,7 +5102,7 @@ async function waitForAgent(port, maxAttempts = 30) {
 import { execSync, spawn as spawn2 } from "child_process";
 import fs9 from "fs";
 import path9 from "path";
-import os4 from "os";
+import os5 from "os";
 function createServiceManager() {
   if (process.platform === "darwin") return new MacOSService();
   if (process.platform === "win32") return new WindowsService();
@@ -5018,7 +5110,7 @@ function createServiceManager() {
   return new FallbackService();
 }
 var PLIST_LABEL = "com.appchy.jarvis";
-var PLIST_DIR = path9.join(os4.homedir(), "Library", "LaunchAgents");
+var PLIST_DIR = path9.join(os5.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;");
@@ -5038,7 +5130,7 @@ var MacOSService = class {
     if (!opts.upstream) {
       args.push("--no-upstream");
     }
-    const logFile = path9.join(os4.homedir(), ".jarvis", "agent.log");
+    const logFile = path9.join(os5.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">
@@ -5060,7 +5152,7 @@ ${args.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n")}
     <key>PATH</key>
     <string>${escapeXml(envPath)}</string>
     <key>HOME</key>
-    <string>${escapeXml(os4.homedir())}</string>
+    <string>${escapeXml(os5.homedir())}</string>
     <key>NODE_NO_WARNINGS</key>
     <string>1</string>
 ${Object.entries(opts.env ?? {}).map(([k, v]) => `    <key>${escapeXml(k)}</key>
@@ -5198,7 +5290,7 @@ var WindowsService = class {
   </Actions>
 </Task>
 `;
-    const tmpDir = os4.tmpdir();
+    const tmpDir = os5.tmpdir();
     const tmpFile = path9.join(tmpDir, `jarvis-task-${Date.now()}.xml`);
     fs9.writeFileSync(tmpFile, xml, { encoding: "utf-16le" });
     try {
@@ -5245,7 +5337,7 @@ var WindowsService = class {
     }
   }
 };
-var SYSTEMD_DIR = path9.join(os4.homedir(), ".config", "systemd", "user");
+var SYSTEMD_DIR = path9.join(os5.homedir(), ".config", "systemd", "user");
 var UNIT_NAME = "jarvis.service";
 var UNIT_PATH = path9.join(SYSTEMD_DIR, UNIT_NAME);
 var LinuxService = class {
@@ -5262,7 +5354,7 @@ var LinuxService = class {
     if (!opts.upstream) {
       args.push("--no-upstream");
     }
-    const logFile = path9.join(os4.homedir(), ".jarvis", "agent.log");
+    const logFile = path9.join(os5.homedir(), ".jarvis", "agent.log");
     const envPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
     const unit = `[Unit]
 Description=Jarvis AI Agent
@@ -5273,7 +5365,7 @@ Type=simple
 ExecStart=${opts.nodePath} ${args.join(" ")}
 WorkingDirectory=${opts.workspacePath}
 Environment=PATH=${envPath}
-Environment=HOME=${os4.homedir()}
+Environment=HOME=${os5.homedir()}
 Environment=NODE_NO_WARNINGS=1
 Restart=always
 RestartSec=5
@@ -5296,7 +5388,7 @@ WantedBy=default.target
     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" });
+      execSync(`loginctl enable-linger ${os5.userInfo().username}`, { stdio: "ignore" });
     } catch {
     }
   }
@@ -5349,12 +5441,12 @@ WantedBy=default.target
 };
 var FallbackService = class {
   constructor() {
-    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");
+    this.pidFile = path9.join(os5.homedir(), ".jarvis", "agent.pid");
+    this.logFile = path9.join(os5.homedir(), ".jarvis", "agent.log");
+    this.markerFile = path9.join(os5.homedir(), ".jarvis", "service-installed");
   }
   install(opts) {
-    const jarvisDir = path9.join(os4.homedir(), ".jarvis");
+    const jarvisDir = path9.join(os5.homedir(), ".jarvis");
     fs9.mkdirSync(jarvisDir, { recursive: true });
     this.stop();
     const args = [
@@ -5439,7 +5531,7 @@ var FallbackService = class {
 import { createRequire } from "module";
 var _require = createRequire(import.meta.url);
 var PKG_VERSION = _require("../package.json").version ?? "dev";
-var LOG_DIR = path10.join(os5.homedir(), ".jarvis");
+var LOG_DIR = path10.join(os6.homedir(), ".jarvis");
 var LOG_FILE = path10.join(LOG_DIR, "agent.log");
 var PID_FILE = path10.join(LOG_DIR, "agent.pid");
 function readPid() {
@@ -5540,9 +5632,8 @@ async function browserAuth(appUrl) {
   }
 }
 function getAppUrl() {
-  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";
+  const config = loadConfig();
+  return config?.appUrl ?? getDefaultAppUrl();
 }
 async function ensureSetup() {
   const config = loadConfig();
@@ -5552,6 +5643,45 @@ async function ensureSetup() {
   clearConfig();
   return browserAuth(getAppUrl());
 }
+function parseGitRemote(url) {
+  const sshMatch = url.match(/[:\/]([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (sshMatch) return { owner: sshMatch[1], name: sshMatch[2] };
+  return null;
+}
+async function autoRegisterRepo(workspacePath, config) {
+  try {
+    const remoteUrl = execSync2("git config --get remote.origin.url", {
+      cwd: workspacePath,
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    if (!remoteUrl) return;
+    const parsed = parseGitRemote(remoteUrl);
+    if (!parsed) return;
+    const slug = `${parsed.owner}/${parsed.name}`;
+    const appUrl = config?.appUrl ?? getDefaultAppUrl();
+    const token = config?.token;
+    if (!token) return;
+    console.log(`Registering repo ${slug} \u2192 ${workspacePath}`);
+    const envId = config?.envId ?? "local";
+    const res = await fetch(`${appUrl}/api/v1/settings/preferences/repos?envId=${envId}`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({ [slug]: workspacePath })
+    });
+    if (res.ok) {
+      console.log(`  Repo registered`);
+    } else {
+      const body = await res.text().catch(() => "");
+      console.error(`  Failed to register repo (${res.status}): ${body}`);
+    }
+  } catch (err) {
+    console.error(`  Failed to register repo: ${err instanceof Error ? err.message : err}`);
+  }
+}
 function createCli() {
   const program = new Command().name("jarvis").description("Jarvis local agent \u2014 runs Claude Code on your machine").version(PKG_VERSION);
   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) => {
@@ -5593,6 +5723,9 @@ function createCli() {
       const port = parseInt(opts.port, 10);
       const workspacePath = opts.workspace ?? config?.workspacePath ?? process.cwd();
       const userId = config?.userId ?? process.env.JARVIS_USER_ID ?? "local";
+      if (!opts.foreground) {
+        await autoRegisterRepo(workspacePath, config);
+      }
       const explicitApiKey = opts.apiKey ?? config?.anthropicApiKey;
       const useSubscription = !explicitApiKey;
       const anthropicApiKey = explicitApiKey;
@@ -5610,7 +5743,20 @@ function createCli() {
             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 };
+              const appUrl = getAppUrl();
+              return {
+                apiUrl,
+                token,
+                refreshToken: config?.refreshToken,
+                onAuthExhausted: async () => {
+                  console.log("\n[Auth] Token expired \u2014 re-authenticating...");
+                  const ok = await browserAuth(appUrl);
+                  if (!ok) return null;
+                  const fresh = loadConfig();
+                  if (!fresh?.token) return null;
+                  return { token: fresh.token, refreshToken: fresh.refreshToken };
+                }
+              };
             }
             return void 0;
           })()
@@ -5666,17 +5812,19 @@ function createCli() {
       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 srcEntry = path10.join(cliRoot, "src", "bin.ts");
+      const useSrc = isDev() && fs10.existsSync(srcEntry);
+      const entryPath = useSrc ? srcEntry : fs10.existsSync(distEntry) ? distEntry : binPath;
+      const tsxBin = path10.join(cliRoot, "node_modules", ".bin", "tsx");
+      const nodePath = useSrc && fs10.existsSync(tsxBin) ? tsxBin : process.execPath;
       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,
+        nodePath,
         entryPath,
         upstream: opts.upstream,
         ...Object.keys(serviceEnv).length > 0 ? { env: serviceEnv } : {}
@@ -5813,12 +5961,11 @@ function createCli() {
     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;
-    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();
-    }
+    const srcEntry = path10.join(cliRoot, "src", "bin.ts");
+    const useSrc = isDev() && fs10.existsSync(srcEntry);
+    const entryPath = useSrc ? srcEntry : fs10.existsSync(distEntry) ? distEntry : binPath;
+    const tsxBin = path10.join(cliRoot, "node_modules", ".bin", "tsx");
+    const nodePath = useSrc && fs10.existsSync(tsxBin) ? tsxBin : process.execPath;
     const pid = readPid();
     if (pid) {
       try {
@@ -5828,8 +5975,6 @@ 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;
@@ -5837,7 +5982,7 @@ function createCli() {
       service.install({
         port,
         workspacePath,
-        nodePath: process.execPath,
+        nodePath,
         entryPath,
         upstream: opts.upstream,
         ...Object.keys(installEnv).length > 0 ? { env: installEnv } : {}
@@ -5885,22 +6030,19 @@ function createCli() {
 }
 
 // src/bin.ts
-function findEnv() {
+if (isDev()) {
+  const dotenv = await import("dotenv");
+  const fs11 = await import("fs");
+  const path11 = await import("path");
   let dir = process.cwd();
   while (dir !== path11.dirname(dir)) {
     const envPath = path11.join(dir, ".env");
-    if (fs11.existsSync(envPath)) return envPath;
+    if (fs11.existsSync(envPath)) {
+      dotenv.config({ path: envPath });
+      break;
+    }
     dir = path11.dirname(dir);
   }
-  return void 0;
-}
-var envFile = findEnv();
-if (envFile) {
-  const prevApiKey = process.env.ANTHROPIC_API_KEY;
-  const prevAppUrl = process.env.APP_URL;
-  dotenv.config({ path: envFile });
-  if (prevApiKey === void 0) delete process.env.ANTHROPIC_API_KEY;
-  if (prevAppUrl === void 0) delete process.env.APP_URL;
 }
 createCli().parse();
 //# sourceMappingURL=bin.js.map