@kortix/agent-tunnel 0.13.41 → 0.13.42

package/dist/agent-cli.js

@@ -2971,19 +2971,33 @@ if (typeof globalThis.WebSocket === "undefined") {
 }
 
 // src/agent/cli.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync9, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "fs";
 import { hostname as hostname4 } from "os";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 
 // src/agent/agent.ts
-import { hostname, platform, arch, release } from "os";
+import { spawn as spawn3 } from "child_process";
+import { hostname as hostname2, platform as platform2, arch, release } from "os";
 
 // src/agent/config.ts
-import { chmodSync, existsSync, lstatSync, readFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { chmodSync, existsSync, lstatSync, readFileSync as readFileSync2 } from "fs";
+import { basename, dirname, join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/shared/types.ts
+var TunnelErrorCode = {
+  PERMISSION_DENIED: -32000,
+  CAPABILITY_NOT_REGISTERED: -32001,
+  TIMEOUT: -32002,
+  LOCAL_ERROR: -32003,
+  NOT_CONNECTED: -32004,
+  EXPIRED: -32005,
+  RATE_LIMITED: -32006,
+  AUTH_FAILED: -32007,
+  ACCESS_PENDING: -32010,
+  ACCESS_DENIED: -32011,
+  ACCESS_OFF: -32012
+};
 var TunnelMethods = {
   "fs.read": "filesystem",
   "fs.write": "filesystem",
@@ -3273,14 +3287,77 @@ function desktopFeatureForMethod(method, args = {}) {
   return DESKTOP_METHOD_FEATURES[method];
 }
 
+// src/agent/service-paths.ts
+import { createHash } from "crypto";
+import { readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+var SERVICE_LABEL = "ai.kortix.agent-tunnel";
+function defaultAgentTunnelHome() {
+  return join(homedir(), ".agent-tunnel");
+}
+function agentTunnelHome(env = process.env) {
+  const override = env.AGENT_TUNNEL_HOME?.trim();
+  return override ? resolve(override) : defaultAgentTunnelHome();
+}
+function serviceLabelFor(home) {
+  const dir = resolve(home);
+  if (dir === defaultAgentTunnelHome())
+    return SERVICE_LABEL;
+  return `${SERVICE_LABEL}.${createHash("sha256").update(dir).digest("hex").slice(0, 8)}`;
+}
+function serviceHomeEnv(home = agentTunnelHome()) {
+  return resolve(home) === defaultAgentTunnelHome() ? {} : { AGENT_TUNNEL_HOME: resolve(home) };
+}
+var DEFAULT_INSTALL_BACKGROUND_SERVICE = true;
+var MAX_SERVICE_LOG_BYTES = 5 * 1024 * 1024;
+var RETAINED_LOG_LINES = 500;
+function getServicePaths(configDir = agentTunnelHome()) {
+  const home = homedir();
+  const label = serviceLabelFor(configDir);
+  const binDir = join(configDir, "bin");
+  return {
+    label,
+    configDir,
+    logDir: join(configDir, "logs"),
+    binDir,
+    vendoredRunner: join(binDir, "agent-cli.js"),
+    launchdPlist: join(home, "Library", "LaunchAgents", `${label}.plist`),
+    systemdUnit: join(home, ".config", "systemd", "user", `${label}.service`),
+    windowsScript: join(configDir, "agent-tunnel-service.ps1")
+  };
+}
+function serviceLogFiles(paths = getServicePaths()) {
+  return [
+    join(paths.logDir, "agent-tunnel.out.log"),
+    join(paths.logDir, "agent-tunnel.err.log")
+  ];
+}
+function rotateServiceLogs(paths = getServicePaths(), maxBytes = MAX_SERVICE_LOG_BYTES) {
+  const rotated = [];
+  for (const file of serviceLogFiles(paths)) {
+    try {
+      const contents = readFileSync(file, "utf8");
+      if (Buffer.byteLength(contents, "utf8") <= maxBytes)
+        continue;
+      const kept = contents.split(/\r?\n/).slice(-RETAINED_LOG_LINES).join(`
+`);
+      writeFileSync(file, `[agent-tunnel] earlier entries trimmed
+${kept}`, { mode: 384 });
+      rotated.push(file);
+    } catch {}
+  }
+  return rotated;
+}
+
 // src/agent/config.ts
-var CONFIG_DIR = join(homedir(), ".agent-tunnel");
-var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var CONFIG_DIR = agentTunnelHome();
+var CONFIG_FILE = join2(CONFIG_DIR, "config.json");
 var DEFAULTS = {
   apiUrl: "http://localhost:8080",
   wsPath: "/ws",
   maxFileSize: 10 * 1024 * 1024,
-  allowedPaths: [homedir()],
+  allowedPaths: [homedir2()],
   allowedCommands: [],
   blockedCommands: [],
   blockedPaths: [
@@ -3293,7 +3370,7 @@ var DEFAULTS = {
     "/sys",
     "/dev"
   ],
-  workingDir: homedir(),
+  workingDir: homedir2(),
   shellTimeout: 30000,
   shellMaxTimeout: 120000,
   shellMaxOutputSize: 1024 * 1024,
@@ -3420,6 +3497,12 @@ function buildTunnelWsUrl(config) {
   });
   return `${base}${wsPath}?${params.toString()}`;
 }
+function protectedAgentPaths(home = CONFIG_DIR) {
+  const paths = new Set([home, defaultAgentTunnelHome()]);
+  if (basename(dirname(home)) === "agent-tunnel")
+    paths.add(dirname(home));
+  return [...paths];
+}
 function loadConfig(overrides = {}) {
   let fileConfig = {};
   if (existsSync(CONFIG_FILE)) {
@@ -3428,7 +3511,7 @@ function loadConfig(overrides = {}) {
     assertPrivateOwnedPath(CONFIG_DIR, "directory", 448);
     assertPrivateOwnedPath(CONFIG_FILE, "file", 384);
     try {
-      const parsed = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+      const parsed = JSON.parse(readFileSync2(CONFIG_FILE, "utf-8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         throw new Error("root value must be an object");
       }
@@ -3457,19 +3540,327 @@ function loadConfig(overrides = {}) {
   merged.apiUrl = normalizeApiUrl(merged.apiUrl);
   merged.wsPath = absoluteWsPath(merged.wsPath);
   validateConfigValues(merged);
+  merged.blockedPaths = [...merged.blockedPaths, ...protectedAgentPaths()];
   return merged;
 }
 
+// src/agent/access.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { chmodSync as chmodSync2, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, renameSync, rmSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { isAbsolute, join as join3 } from "path";
+var ACCESS_HOLD_MS = 20000;
+var DESKTOP_APP_HEARTBEAT_MS = 30000;
+var MAX_GRANT_MS = 24 * 3600000;
+var MODES = ["ask", "always", "off"];
+var COMPAT = { mode: "always", grantedUntil: null, deniedUntil: null, keepAwake: false };
+var accessFilePath = (home = agentTunnelHome()) => join3(home, "access.json");
+var accessRequestPath = (home = agentTunnelHome()) => join3(home, "access-request.json");
+var desktopAppPath = (home = agentTunnelHome()) => join3(home, "desktop-app.json");
+var isoOrNull = (value) => typeof value === "string" && !Number.isNaN(Date.parse(value)) ? value : null;
+function readAccess(home = agentTunnelHome()) {
+  let raw;
+  try {
+    raw = readFileSync3(accessFilePath(home), "utf8");
+  } catch {
+    return { ...COMPAT };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      mode: MODES.includes(parsed.mode) ? parsed.mode : "ask",
+      grantedUntil: isoOrNull(parsed.grantedUntil),
+      deniedUntil: isoOrNull(parsed.deniedUntil),
+      keepAwake: parsed.keepAwake === true
+    };
+  } catch {
+    return { mode: "ask", grantedUntil: null, deniedUntil: null, keepAwake: false };
+  }
+}
+function writePrivateJson(file, home, value) {
+  mkdirSync(home, { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync2(tmp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  try {
+    chmodSync2(tmp, 384);
+  } catch {}
+  renameSync(tmp, file);
+}
+function writeAccess(state, home = agentTunnelHome()) {
+  writePrivateJson(accessFilePath(home), home, state);
+}
+function decideAccess(state, now = Date.now()) {
+  if (state.mode === "always")
+    return "run";
+  if (state.mode === "off")
+    return "off";
+  const denied = state.deniedUntil ? Date.parse(state.deniedUntil) : 0;
+  if (denied > now)
+    return "denied";
+  const granted = state.grantedUntil ? Date.parse(state.grantedUntil) : 0;
+  return granted > now && granted - now <= MAX_GRANT_MS ? "run" : "ask";
+}
+function writeAccessRequest(input, home = agentTunnelHome()) {
+  const request = { id: randomUUID(), requestedAt: new Date().toISOString(), ...input };
+  writePrivateJson(accessRequestPath(home), home, request);
+  return request;
+}
+function readAccessRequest(home = agentTunnelHome()) {
+  try {
+    const parsed = JSON.parse(readFileSync3(accessRequestPath(home), "utf8"));
+    return typeof parsed?.id === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function clearAccessRequest(id, home = agentTunnelHome()) {
+  if (readAccessRequest(home)?.id === id)
+    rmSync(accessRequestPath(home), { force: true });
+}
+function isAlive(pid) {
+  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function wakeDesktopApp(home = agentTunnelHome(), now = Date.now()) {
+  let app;
+  let touchedAt = 0;
+  try {
+    app = JSON.parse(readFileSync3(desktopAppPath(home), "utf8"));
+    touchedAt = statSync(desktopAppPath(home)).mtimeMs;
+  } catch {
+    return "no-app";
+  }
+  if (isAlive(app.pid) && now - touchedAt < DESKTOP_APP_HEARTBEAT_MS)
+    return "running";
+  if (typeof app.command !== "string" || !isAbsolute(app.command) || !existsSync2(app.command))
+    return "no-app";
+  const args = Array.isArray(app.args) ? app.args.filter((arg) => typeof arg === "string") : [];
+  const recorded = app.env && typeof app.env === "object" ? app.env : {};
+  const env = { ...process.env };
+  delete env.ELECTRON_RUN_AS_NODE;
+  delete env.AGENT_TUNNEL_HOME;
+  for (const [key, value] of Object.entries(recorded))
+    if (typeof value === "string")
+      env[key] = value;
+  try {
+    const child = spawn(app.command, args, { detached: true, stdio: "ignore", env });
+    child.on("error", () => {});
+    child.unref();
+    return "launched";
+  } catch {
+    return "no-app";
+  }
+}
+function keepAwakeCommand(platform, pid) {
+  if (platform === "darwin")
+    return { command: "caffeinate", args: ["-s", "-w", String(pid)] };
+  if (platform === "linux") {
+    return {
+      command: "systemd-inhibit",
+      args: ["--what=sleep", "--who=Kortix", "--why=Keep this computer reachable", "--mode=block", "tail", `--pid=${pid}`, "-f", "/dev/null"]
+    };
+  }
+  return null;
+}
+
+// src/agent/device-auth.ts
+import { execFileSync, spawn as spawn2 } from "child_process";
+import { hostname, platform } from "os";
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var TUNNEL_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var SETUP_TOKEN_PATTERN = /^kortix_tnl_[A-Za-z0-9_-]{32,64}$/;
+var DEVICE_CODE_PATTERN = /^[A-Z]{4}-[0-9]{4}$/;
+var DEVICE_SECRET_PATTERN = /^[A-Za-z0-9]{32}$/;
+var MAX_CHALLENGE_LIFETIME_MS = 10 * 60000;
+
+class InvalidDeviceAuthResponseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidDeviceAuthResponseError";
+  }
+}
+function invalid(what) {
+  throw new InvalidDeviceAuthResponseError(`Authorization server returned an invalid ${what}`);
+}
+function isJsonRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeBrowserUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" || url.protocol === "http:" ? url.toString() : null;
+  } catch {
+    return null;
+  }
+}
+function isLoopback(url) {
+  return ["localhost", "127.0.0.1", "[::1]", "::1"].includes(url.hostname);
+}
+function assertSafeVerificationUrl(value) {
+  if (value.length > 2048)
+    invalid("verification URL");
+  const browserUrl = normalizeBrowserUrl(value);
+  if (!browserUrl)
+    invalid("verification URL");
+  const url = new URL(browserUrl);
+  if (url.username || url.password || url.protocol !== "https:" && !isLoopback(url)) {
+    throw new InvalidDeviceAuthResponseError("Authorization server returned an unsafe verification URL");
+  }
+  return browserUrl;
+}
+function parseDeviceAuthChallenge(value) {
+  if (!isJsonRecord(value))
+    invalid("challenge");
+  const { deviceCode, deviceSecret, verificationUrl, expiresAt, pollIntervalMs } = value;
+  if (typeof deviceCode !== "string" || !DEVICE_CODE_PATTERN.test(deviceCode))
+    invalid("device code");
+  if (typeof deviceSecret !== "string" || !DEVICE_SECRET_PATTERN.test(deviceSecret)) {
+    invalid("device secret");
+  }
+  if (typeof verificationUrl !== "string")
+    invalid("verification URL");
+  if (typeof expiresAt !== "string")
+    invalid("expiration");
+  const expiresAtMs = Date.parse(expiresAt);
+  const now = Date.now();
+  if (!Number.isFinite(expiresAtMs) || expiresAtMs <= now || expiresAtMs > now + MAX_CHALLENGE_LIFETIME_MS) {
+    invalid("expiration");
+  }
+  if (!Number.isSafeInteger(pollIntervalMs) || pollIntervalMs < 250 || pollIntervalMs > 1e4) {
+    invalid("poll interval");
+  }
+  return {
+    deviceCode,
+    deviceSecret,
+    verificationUrl: assertSafeVerificationUrl(verificationUrl),
+    expiresAt,
+    pollIntervalMs
+  };
+}
+function parseApprovedCredentials(value) {
+  const { tunnelId, token } = value;
+  if (typeof tunnelId !== "string" || !TUNNEL_ID_PATTERN.test(tunnelId))
+    invalid("tunnel ID");
+  if (typeof token !== "string" || !SETUP_TOKEN_PATTERN.test(token))
+    invalid("setup token");
+  return { tunnelId, token };
+}
+function parseApprovedCapabilities(value) {
+  if (!Array.isArray(value))
+    return [];
+  return [...new Set(value)].filter((item) => isTunnelCapability(item));
+}
+function parseDeviceAuthStatus(value) {
+  if (!isJsonRecord(value) || typeof value.status !== "string")
+    invalid("status response");
+  switch (value.status) {
+    case "approved": {
+      if (!value.tunnelId || !value.token)
+        return { status: "approved-without-token" };
+      return {
+        status: "approved",
+        ...parseApprovedCredentials(value),
+        capabilities: parseApprovedCapabilities(value.capabilities)
+      };
+    }
+    case "denied":
+      return { status: "denied" };
+    case "expired":
+      return { status: "expired" };
+    default:
+      return null;
+  }
+}
+function machineDisplayName({
+  os = platform(),
+  host = hostname(),
+  env = process.env,
+  run = (command, args) => execFileSync(command, args, { encoding: "utf8", timeout: 1000, stdio: ["ignore", "pipe", "ignore"] })
+} = {}) {
+  const fallback = host.replace(/\.local$/i, "") || host;
+  try {
+    const name = os === "darwin" ? run("scutil", ["--get", "ComputerName"]) : os === "win32" ? env.COMPUTERNAME : "";
+    return name?.trim() || fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function requestDeviceAuthorization(apiUrl, options = {}) {
+  const response = await fetch(`${apiUrl}/device-auth`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      machineHostname: machineDisplayName(),
+      ...options.projectId ? { project_id: options.projectId } : {}
+    })
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new InvalidDeviceAuthResponseError(`Failed to create device auth request: ${response.status} ${body.slice(0, 200)}`);
+  }
+  return parseDeviceAuthChallenge(await response.json());
+}
+async function awaitDeviceAuthorization(apiUrl, challenge, options = {}) {
+  const wait = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const expiresAtMs = Date.parse(challenge.expiresAt);
+  for (;; ) {
+    const secondsRemaining = Math.max(0, Math.floor((expiresAtMs - Date.now()) / 1000));
+    if (secondsRemaining <= 0)
+      return { status: "expired" };
+    options.onWaiting?.(secondsRemaining);
+    let payload;
+    try {
+      const response = await fetch(`${apiUrl}/device-auth/${challenge.deviceCode}/status`, {
+        headers: { Authorization: `Bearer ${challenge.deviceSecret}` }
+      });
+      if (!response.ok) {
+        await wait(challenge.pollIntervalMs);
+        continue;
+      }
+      payload = await response.json();
+    } catch {
+      await wait(challenge.pollIntervalMs);
+      continue;
+    }
+    const outcome = parseDeviceAuthStatus(payload);
+    if (outcome)
+      return outcome;
+    await wait(challenge.pollIntervalMs);
+  }
+}
+function openBrowser(url) {
+  if (process.env.KORTIX_AGENT_TUNNEL_NO_BROWSER === "1")
+    return;
+  const safeUrl = normalizeBrowserUrl(url);
+  if (!safeUrl)
+    return;
+  const opener = {
+    darwin: ["open", [safeUrl]],
+    win32: ["rundll32.exe", ["url.dll,FileProtocolHandler", safeUrl]]
+  };
+  const [command, args] = opener[platform()] ?? ["xdg-open", [safeUrl]];
+  try {
+    spawn2(command, args, { detached: true, stdio: "ignore" }).unref();
+  } catch {}
+}
+
 // src/agent/version.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname, join as join2 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "@kortix/agent-tunnel";
 var MAX_LOOKUP_DEPTH = 8;
 var cached = null;
 function moduleDirectory() {
   try {
-    return dirname(fileURLToPath(import.meta.url));
+    return dirname2(fileURLToPath(import.meta.url));
   } catch {
     return process.cwd();
   }
@@ -3480,14 +3871,14 @@ function agentTunnelVersion() {
   let directory = moduleDirectory();
   for (let depth = 0;depth < MAX_LOOKUP_DEPTH; depth++) {
     try {
-      const manifest = JSON.parse(readFileSync2(join2(directory, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync4(join4(directory, "package.json"), "utf8"));
       if (manifest?.name === PACKAGE_NAME && typeof manifest.version === "string") {
         const version = manifest.version;
         cached = version;
         return version;
       }
     } catch {}
-    const parent = dirname(directory);
+    const parent = dirname2(directory);
     if (parent === directory)
       break;
     directory = parent;
@@ -3588,7 +3979,7 @@ class PermissionGuard {
 }
 
 // src/shared/crypto.ts
-import { createHash, createHmac, timingSafeEqual, randomInt } from "crypto";
+import { createHash as createHash2, createHmac, timingSafeEqual, randomInt } from "crypto";
 function signMessage(signingKey, payload, nonce) {
   return createHmac("sha256", signingKey).update(`${nonce}:${payload}`).digest("hex");
 }
@@ -3608,6 +3999,12 @@ function verifyMessageSignature(signingKey, payload, nonce, signature) {
 // src/agent/agent.ts
 var AGENT_VERSION = agentTunnelVersion();
 var AUTH_REJECTED_CLOSE_CODES = [4001, 4003];
+var RELAY_FAULT_4001_REASONS = new Set(["auth timeout", "authentication error", "authentication response failed"]);
+function isCredentialRejection(code, reason = "") {
+  if (!AUTH_REJECTED_CLOSE_CODES.includes(code))
+    return false;
+  return !(code === 4001 && RELAY_FAULT_4001_REASONS.has(reason));
+}
 var AGENT_REPLACED_CLOSE_CODE = 4004;
 var MAX_RPC_MESSAGE_SIZE = 5 * 1024 * 1024;
 function log(icon, msg) {
@@ -3616,36 +4013,84 @@ function log(icon, msg) {
   process.stdout.write(`  ${safeIcon} ${c.dim}${safeMsg}${c.reset}
 `);
 }
+var LIVENESS_TIMEOUT_MS = 75000;
+var WATCHDOG_INTERVAL_MS = 5000;
+var CLOCK_JUMP_MS = 30000;
+var REJECTED_RETRY_MS = 5 * 60000;
+var STANDBY_RETRY_MS = 60000;
+var MAX_STANDBY_RETRY_MS = 30 * 60000;
+var CONNECT_DEADLINE_MS = 20000;
+var KEEP_AWAKE_MIN_LIFETIME_MS = 5000;
+var REJECTED_LOG_EVERY_MS = 3600000;
+var BASE_RECONNECT_DELAY_MS = 1000;
+var MAX_RECONNECT_DELAY_MS = 30000;
+function reconnectDelay(attempt, random = Math.random()) {
+  const raw = Math.min(BASE_RECONNECT_DELAY_MS * 2 ** Math.min(attempt - 1, 30), MAX_RECONNECT_DELAY_MS);
+  return Math.round(Math.min(raw * (0.8 + 0.4 * random), MAX_RECONNECT_DELAY_MS));
+}
+var ACCESS_ERRORS = {
+  pending: {
+    code: TunnelErrorCode.ACCESS_PENDING,
+    message: "computer_access_pending: The owner has not allowed access yet. Ask them to approve the prompt on their computer, then try again."
+  },
+  denied: {
+    code: TunnelErrorCode.ACCESS_DENIED,
+    message: "computer_access_denied: The owner denied access on their computer. Try again later."
+  },
+  off: {
+    code: TunnelErrorCode.ACCESS_OFF,
+    message: "computer_access_off: The owner turned off access to this computer."
+  }
+};
 
 class TunnelAgent {
   hooks;
+  options;
+  home;
+  now;
   ws = null;
   registry;
   permissionGuard;
   config;
   reconnectAttempts = 0;
-  maxReconnectDelay = 30000;
-  baseReconnectDelay = 1000;
+  closeCurrentSocket = null;
+  watchdog = null;
+  lastTick = 0;
+  lastPingAt = 0;
+  connectStartedAt = 0;
+  standbyAttempts = 0;
+  lastRejectedLogAt = 0;
+  sentAccessKey = null;
+  keepAwake = null;
+  keepAwakeFailed = false;
   reconnectTimer = null;
   stableConnectionTimer = null;
   isShuttingDown = false;
+  status = null;
   uptime = 0;
+  displayName;
   uptimeInterval = null;
   signingKey = null;
   lastNonce = 0;
   responseNonce = 0;
-  constructor(config, registry, hooks = {}) {
+  constructor(config, registry, hooks = {}, options = {}) {
     this.config = config;
     this.registry = registry;
     this.permissionGuard = new PermissionGuard;
     this.hooks = hooks;
+    this.options = options;
+    this.home = options.home ?? agentTunnelHome();
+    this.now = options.now ?? Date.now;
   }
   connect() {
     if (this.ws) {
       this.ws.close();
     }
+    this.startWatchdog();
     const wsUrl = this.buildWsUrl();
     log(`${c.cyan}◆${c.reset}`, `Connecting…`);
+    this.connectStartedAt = this.now();
+    this.setStatus("connecting");
     try {
       this.ws = new WebSocket(new URL(wsUrl));
       this.setupWsHandlers();
@@ -3664,6 +4109,11 @@ class TunnelAgent {
       clearInterval(this.uptimeInterval);
       this.uptimeInterval = null;
     }
+    if (this.watchdog) {
+      clearInterval(this.watchdog);
+      this.watchdog = null;
+    }
+    this.syncKeepAwake(false);
     if (this.ws) {
       try {
         this.ws.close(1000, "client shutdown");
@@ -3672,6 +4122,15 @@ class TunnelAgent {
     }
     this.permissionGuard.clear();
     log(`${c.gray}○${c.reset}`, `Disconnected`);
+    this.setStatus("offline");
+  }
+  setStatus(status) {
+    if (this.status === status)
+      return;
+    this.status = status;
+    try {
+      this.hooks.onStatus?.(status, this.config);
+    } catch {}
   }
   isConnected() {
     return this.ws?.readyState === WebSocket.OPEN;
@@ -3691,13 +4150,19 @@ class TunnelAgent {
         type: "auth",
         token: trustedCredential(this.config.token, "token"),
         capabilities: this.registry.getCapabilityNames(),
-        agentVersion: AGENT_VERSION
+        agentVersion: AGENT_VERSION,
+        reportsAccess: true
       });
     });
     this.ws.addEventListener("message", (event) => {
       this.handleMessage(event.data);
     });
-    this.ws.addEventListener("close", (event) => {
+    let closeHandled = false;
+    const onClose = (event) => {
+      if (closeHandled)
+        return;
+      closeHandled = true;
+      this.setStatus("offline");
       if (this.uptimeInterval) {
         clearInterval(this.uptimeInterval);
         this.uptimeInterval = null;
@@ -3707,7 +4172,23 @@ class TunnelAgent {
         this.stableConnectionTimer = null;
       }
       if (!this.isShuttingDown) {
-        if (event.code === 4001) {
+        if (this.options.persistent && isCredentialRejection(event.code, event.reason)) {
+          this.setStatus("rejected");
+          if (this.now() - this.lastRejectedLogAt >= REJECTED_LOG_EVERY_MS) {
+            this.lastRejectedLogAt = this.now();
+            log(`${c.red}✗${c.reset}`, `Credential rejected — waiting for this computer to be paired again (retrying every 5 min)`);
+          }
+          this.retryAfter(this.options.rejectedRetryMs ?? REJECTED_RETRY_MS);
+          return;
+        }
+        if (this.options.persistent && event.code === AGENT_REPLACED_CLOSE_CODE) {
+          this.setStatus("standby");
+          const wait = Math.min((this.options.standbyRetryMs ?? STANDBY_RETRY_MS) * 2 ** this.standbyAttempts++, MAX_STANDBY_RETRY_MS);
+          log(`${c.yellow}○${c.reset}`, `Another Agent Tunnel process holds this computer — standing by, next try in ${Math.round(wait / 1000)}s`);
+          this.retryAfter(wait);
+          return;
+        }
+        if (event.code === 4001 && isCredentialRejection(event.code, event.reason)) {
           this.isShuttingDown = true;
           log(`${c.red}✗${c.reset}`, `Credential rejected — run \`agent-tunnel connect --reauth\` to pair again`);
           this.hooks.onTerminalClose?.({ code: event.code, reason: "credential-rejected" });
@@ -3728,9 +4209,12 @@ class TunnelAgent {
         log(`${c.yellow}○${c.reset}`, `Disconnected ${c.gray}(code: ${event.code})${c.reset}`);
         this.scheduleReconnect();
       }
-    });
+    };
+    this.ws.addEventListener("close", onClose);
+    this.closeCurrentSocket = onClose;
     this.ws.addEventListener("error", () => {
       log(`${c.red}✗${c.reset}`, `WebSocket error`);
+      setTimeout(() => onClose({ code: 1006 }), 1000);
     });
   }
   async handleMessage(raw) {
@@ -3756,6 +4240,11 @@ class TunnelAgent {
       } else {
         log(`${c.green}●${c.reset}`, `Connected ${c.reset}${c.gray}(${capabilityNames.join(", ")})${c.reset}`);
       }
+      this.lastPingAt = this.now();
+      this.sentAccessKey = null;
+      this.standbyAttempts = 0;
+      this.setStatus("online");
+      this.reportAccess();
       if (this.stableConnectionTimer)
         clearTimeout(this.stableConnectionTimer);
       this.stableConnectionTimer = setTimeout(() => {
@@ -3775,6 +4264,7 @@ class TunnelAgent {
       return;
     }
     if ("method" in msg && msg.method === "tunnel.ping") {
+      this.lastPingAt = this.now();
       this.sendPong();
       return;
     }
@@ -3842,6 +4332,11 @@ class TunnelAgent {
       this.sendSignedError(id, -32001, `Capability not registered for method: ${method}`);
       return;
     }
+    const refusal = await this.awaitAccess(method);
+    if (refusal) {
+      this.sendSignedError(id, refusal.code, refusal.message);
+      return;
+    }
     try {
       const result = await handler({
         ...params,
@@ -3900,22 +4395,166 @@ class TunnelAgent {
         uptime: this.uptime,
         capabilities: this.registry.getCapabilityNames(),
         machineInfo: {
-          hostname: hostname(),
-          platform: platform(),
+          hostname: hostname2(),
+          displayName: this.displayName ??= machineDisplayName(),
+          platform: platform2(),
           arch: arch(),
           osVersion: release(),
-          agentVersion: AGENT_VERSION
+          agentVersion: AGENT_VERSION,
+          homeDir: this.config.workingDir,
+          allowedPaths: this.config.allowedPaths
         }
       }
     });
   }
+  async awaitAccess(method) {
+    const first = decideAccess(readAccess(this.home));
+    if (first === "run")
+      return null;
+    if (first !== "ask")
+      return ACCESS_ERRORS[first];
+    const hold = this.options.accessHoldMs ?? ACCESS_HOLD_MS;
+    let requestId = null;
+    try {
+      const pending = readAccessRequest(this.home);
+      if (pending && Date.now() - Date.parse(pending.requestedAt) < hold) {
+        requestId = pending.id;
+      } else {
+        requestId = writeAccessRequest({ capability: capabilityForMethod(method) ?? method, method }, this.home).id;
+        wakeDesktopApp(this.home);
+      }
+    } catch {}
+    const deadline = Date.now() + hold;
+    while (Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, Math.min(100, hold / 4)));
+      const decision = decideAccess(readAccess(this.home));
+      if (decision === "ask")
+        continue;
+      if (requestId)
+        clearAccessRequest(requestId, this.home);
+      return decision === "run" ? null : ACCESS_ERRORS[decision];
+    }
+    return ACCESS_ERRORS.pending;
+  }
+  reportAccess() {
+    const access = readAccess(this.home);
+    const { mode } = access;
+    const grantedUntil = access.grantedUntil && Date.parse(access.grantedUntil) > this.now() ? access.grantedUntil : null;
+    const key = `${mode}|${grantedUntil}`;
+    if (key === this.sentAccessKey || this.status !== "online")
+      return;
+    this.sentAccessKey = key;
+    this.sendSigned({ jsonrpc: "2.0", method: "tunnel.access.state", params: { mode, grantedUntil } });
+  }
+  syncKeepAwake(want) {
+    if (!want) {
+      this.keepAwake?.kill();
+      this.keepAwake = null;
+      this.keepAwakeFailed = false;
+      return;
+    }
+    if (this.keepAwake || this.keepAwakeFailed)
+      return;
+    const blocker = keepAwakeCommand(platform2(), process.pid);
+    if (!blocker)
+      return;
+    const child = spawn3(blocker.command, blocker.args, { stdio: "ignore" });
+    child.on("error", () => {
+      this.keepAwakeFailed = true;
+      log(`${c.yellow}!${c.reset}`, `Keep awake is unavailable: ${blocker.command} could not start`);
+    });
+    const startedAt = this.now();
+    child.on("exit", (code) => {
+      if (this.keepAwake !== child)
+        return;
+      this.keepAwake = null;
+      if (code !== 0 || this.now() - startedAt < KEEP_AWAKE_MIN_LIFETIME_MS) {
+        this.keepAwakeFailed = true;
+        log(`${c.yellow}!${c.reset}`, `Keep awake is unavailable: ${blocker.command} exited (code ${code})`);
+      }
+    });
+    this.keepAwake = child;
+  }
+  startWatchdog() {
+    if (this.watchdog)
+      return;
+    const interval = this.options.watchdogIntervalMs ?? WATCHDOG_INTERVAL_MS;
+    this.lastTick = this.now();
+    this.watchdog = setInterval(() => {
+      const now = this.now();
+      const slept = now - this.lastTick > interval + CLOCK_JUMP_MS;
+      this.lastTick = now;
+      if (slept) {
+        this.reconnectAttempts = 0;
+        this.forceReconnect("clock jump");
+      } else if (this.status === "online" && now - this.lastPingAt > (this.options.livenessTimeoutMs ?? LIVENESS_TIMEOUT_MS)) {
+        this.forceReconnect("liveness timeout");
+      } else if (this.status === "connecting" && this.ws && now - this.connectStartedAt > (this.options.connectDeadlineMs ?? CONNECT_DEADLINE_MS)) {
+        this.forceReconnect("handshake timeout");
+      } else if (this.status === "rejected" && this.credentialChanged()) {
+        this.forceReconnect("new credential");
+      }
+      try {
+        const access = readAccess(this.home);
+        this.syncKeepAwake(access.keepAwake);
+        this.reportAccess();
+      } catch {}
+    }, interval);
+    this.watchdog.unref?.();
+  }
+  credentialChanged() {
+    try {
+      const next = this.options.reloadConfig?.();
+      if (!next || next.token === this.config.token && next.tunnelId === this.config.tunnelId)
+        return false;
+      this.config = next;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  forceReconnect(reason) {
+    if (this.isShuttingDown)
+      return;
+    if (!this.ws) {
+      if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        this.connect();
+      }
+      return;
+    }
+    log(`${c.yellow}○${c.reset}`, `Reconnecting (${reason})`);
+    try {
+      this.ws.close(4000, reason);
+    } catch {}
+    this.ws = null;
+    this.closeCurrentSocket?.({ code: 4000, reason });
+  }
+  retryAfter(ms) {
+    if (this.reconnectTimer)
+      clearTimeout(this.reconnectTimer);
+    this.ws = null;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      try {
+        if (this.options.reloadConfig)
+          this.config = this.options.reloadConfig();
+      } catch {}
+      this.connect();
+    }, ms);
+  }
   scheduleReconnect() {
     if (this.isShuttingDown)
       return;
     this.reconnectAttempts++;
-    const delay = Math.min(this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
+    const delay = reconnectDelay(this.reconnectAttempts);
+    this.ws = null;
     log(`${c.cyan}◆${c.reset}`, `Reconnecting in ${c.reset}${c.white}${(delay / 1000).toFixed(1)}s${c.dim} (attempt ${this.reconnectAttempts})`);
+    if (this.reconnectTimer)
+      clearTimeout(this.reconnectTimer);
     this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
       this.connect();
     }, delay);
   }
@@ -3925,7 +4564,7 @@ class TunnelAgent {
 }
 
 // src/agent/banner.ts
-import { arch as arch2, hostname as hostname2, platform as platform2 } from "os";
+import { arch as arch2, hostname as hostname3, platform as platform3 } from "os";
 var BOX_WIDTH = 60;
 var BAR_WIDTH = 50;
 var BAR_FRAMES = 14;
@@ -3975,7 +4614,7 @@ async function printStartupBanner({
   blank();
   row(`   ${c.dim}tunnel${c.reset}    ${c.white}${truncate(tunnelId, 40)}${c.reset}`);
   row(`   ${c.dim}relay${c.reset}     ${c.white}${truncate(apiUrl, 40)}${c.reset}`);
-  row(`   ${c.dim}machine${c.reset}   ${c.white}${truncate(hostname2(), 28)}${c.reset} ${c.dim}(${platform2()} ${arch2()})${c.reset}`);
+  row(`   ${c.dim}machine${c.reset}   ${c.white}${truncate(hostname3(), 28)}${c.reset} ${c.dim}(${platform3()} ${arch2()})${c.reset}`);
   row(`   ${c.dim}access${c.reset}    ${capabilityRow}`);
   blank();
   console.log(`  ${c.gray}╰${"─".repeat(BOX_WIDTH - brand.length - 3)} ${c.dim}created by ${c.cyan}kortix${c.reset} ${c.gray}─╯${c.reset}`);
@@ -4008,10 +4647,10 @@ class CapabilityRegistry {
 }
 
 // src/agent/capabilities/desktop/cua-driver.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync2, realpathSync, statSync } from "fs";
-import { homedir as homedir2, platform as platform3 } from "os";
-import { join as join3 } from "path";
+import { spawn as spawn4 } from "child_process";
+import { existsSync as existsSync3, realpathSync, statSync as statSync2 } from "fs";
+import { homedir as homedir3, platform as platform4 } from "os";
+import { join as join5 } from "path";
 var MAX_DRIVER_OUTPUT_BYTES = 5 * 1024 * 1024;
 var DRIVER_ENV_KEYS = [
   "PATH",
@@ -4030,7 +4669,7 @@ var DRIVER_ENV_KEYS = [
 function candidateBins() {
   const candidates = [
     process.env.CUA_DRIVER_BIN,
-    join3(homedir2(), ".local", "bin", process.platform === "win32" ? "cua-driver.exe" : "cua-driver"),
+    join5(homedir3(), ".local", "bin", process.platform === "win32" ? "cua-driver.exe" : "cua-driver"),
     "/usr/local/bin/cua-driver",
     "/opt/homebrew/bin/cua-driver"
   ];
@@ -4038,10 +4677,10 @@ function candidateBins() {
 }
 function findCuaDriverBinary() {
   for (const candidate of candidateBins()) {
-    if (!existsSync2(candidate))
+    if (!existsSync3(candidate))
       continue;
     const resolved = realpathSync(candidate);
-    const stats = statSync(resolved);
+    const stats = statSync2(resolved);
     if (!stats.isFile())
       throw new Error(`cua-driver is not a regular file: ${candidate}`);
     if (process.platform !== "win32") {
@@ -4070,7 +4709,7 @@ function driverEnvironment() {
 }
 function execFile(cmd, args, timeoutMs = 30000) {
   return new Promise((resolve, reject) => {
-    const proc = spawn(cmd, args, {
+    const proc = spawn4(cmd, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: driverEnvironment()
     });
@@ -4153,7 +4792,7 @@ class CuaDriver {
   binary = null;
   daemonReady = false;
   async ensureInstalled() {
-    if (this.binary && existsSync2(this.binary))
+    if (this.binary && existsSync3(this.binary))
       return this.binary;
     const found = findCuaDriverBinary();
     if (found) {
@@ -4211,15 +4850,15 @@ class CuaDriver {
   }
   async startDaemon() {
     const bin = await this.ensureInstalled();
-    if (platform3() === "darwin") {
-      const child = spawn("open", ["-n", "-g", "-a", "CuaDriver", "--args", "serve"], {
+    if (platform4() === "darwin") {
+      const child = spawn4("open", ["-n", "-g", "-a", "CuaDriver", "--args", "serve"], {
         detached: true,
         stdio: "ignore",
         env: driverEnvironment()
       });
       child.unref();
     } else {
-      const child = spawn(bin, ["serve"], {
+      const child = spawn4(bin, ["serve"], {
         detached: true,
         stdio: "ignore",
         env: driverEnvironment()
@@ -4366,7 +5005,7 @@ function createDesktopCapability() {
 
 // src/agent/capabilities/filesystem.ts
 import { open, writeFile, readdir, stat, unlink, mkdir } from "fs/promises";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 
 // src/shared/filesystem-validation.ts
 function validateFilesystemParams(method, params) {
@@ -4399,13 +5038,13 @@ function validateFilesystemParams(method, params) {
 }
 
 // src/agent/capabilities/filesystem.ts
-import { join as join5, dirname as dirname3 } from "path";
+import { join as join7, dirname as dirname4 } from "path";
 
 // src/agent/security/path-validator.ts
-import { dirname as dirname2, basename, join as join4, resolve, normalize, relative, isAbsolute } from "path";
+import { dirname as dirname3, basename as basename2, join as join6, resolve as resolve2, normalize, relative, isAbsolute as isAbsolute2 } from "path";
 import { realpathSync as realpathSync2 } from "fs";
 function resolveExistingRoot(path) {
-  const normalized = normalize(resolve(path));
+  const normalized = normalize(resolve2(path));
   try {
     return resolvePathForValidation(normalized);
   } catch {
@@ -4413,7 +5052,7 @@ function resolveExistingRoot(path) {
   }
 }
 function resolvePathForValidation(path) {
-  const normalized = normalize(resolve(path));
+  const normalized = normalize(resolve2(path));
   try {
     return realpathSync2(normalized);
   } catch (err) {
@@ -4421,10 +5060,10 @@ function resolvePathForValidation(path) {
     if (code !== "ENOENT") {
       throw new Error(`Access denied: cannot resolve path "${path}" (${code})`);
     }
-    const parent = dirname2(normalized);
+    const parent = dirname3(normalized);
     if (parent === normalized)
       return normalized;
-    return join4(resolvePathForValidation(parent), basename(normalized));
+    return join6(resolvePathForValidation(parent), basename2(normalized));
   }
 }
 function assertAllowedResolvedPath(originalPath, resolved, allowedPaths, blockedPaths = []) {
@@ -4440,13 +5079,13 @@ function assertAllowedResolvedPath(originalPath, resolved, allowedPaths, blocked
       return isPathInside(resolved, normalizedAllowed);
     });
     if (!withinAllowed) {
-      throw new Error(`Access denied: path "${originalPath}" is outside allowed directories`);
+      throw new Error(`Access denied: path "${originalPath}" is outside allowed directories (${allowedPaths.join(", ")})`);
     }
   }
 }
 function isPathInside(target, root) {
   const child = relative(root, target);
-  return child === "" || !child.startsWith("..") && !isAbsolute(child);
+  return child === "" || !child.startsWith("..") && !isAbsolute2(child);
 }
 function validatePath(path, allowedPaths, blockedPaths = []) {
   if (!path) {
@@ -4553,18 +5192,18 @@ function createFilesystemCapability(config) {
       throw new Error(`Content exceeds max size (${contentBytes} > ${maxFileSize})`);
     }
     const bytes = Buffer.from(content, encoding);
-    const expectedHash = createHash2("sha256").update(bytes).digest("hex");
+    const expectedHash = createHash3("sha256").update(bytes).digest("hex");
     if (params.sha256 !== undefined && params.sha256.toLowerCase() !== expectedHash) {
       throw new Error("SHA-256 mismatch: content differs from the source; destination was not modified");
     }
-    await mkdir(dirname3(path), { recursive: true });
+    await mkdir(dirname4(path), { recursive: true });
     validateFilesystemPath(path, config, params, true);
     await writeFile(path, bytes);
     validateFilesystemPath(path, config, params);
     const handle = await open(path, "r");
     try {
       const stats = await handle.stat();
-      const persistedHash = createHash2("sha256").update(await handle.readFile()).digest("hex");
+      const persistedHash = createHash3("sha256").update(await handle.readFile()).digest("hex");
       if (persistedHash !== expectedHash)
         throw new Error("SHA-256 mismatch after write; destination verification failed");
       return {
@@ -4584,7 +5223,7 @@ function createFilesystemCapability(config) {
     const entries = await readdir(path, { withFileTypes: true });
     const result = entries.map((entry) => ({
       name: entry.name,
-      path: join5(path, entry.name),
+      path: join7(path, entry.name),
       isDirectory: entry.isDirectory(),
       isFile: entry.isFile(),
       isSymlink: entry.isSymbolicLink()
@@ -4597,7 +5236,7 @@ function createFilesystemCapability(config) {
           for (const sub of subEntries) {
             result.push({
               name: sub.name,
-              path: join5(dir.path, sub.name),
+              path: join7(dir.path, sub.name),
               isDirectory: sub.isDirectory(),
               isFile: sub.isFile(),
               isSymlink: sub.isSymbolicLink()
@@ -4638,7 +5277,7 @@ function createFilesystemCapability(config) {
 }
 
 // src/agent/capabilities/shell.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 
 // src/agent/security/command-validator.ts
 var SHELL_METACHAR_REGEX = /[;&|`$(){}[\]<>!#~]/;
@@ -4703,7 +5342,7 @@ function createShellCapability(config) {
       }
     }
     return new Promise((resolve, reject) => {
-      const proc = spawn2(executable, args, {
+      const proc = spawn5(executable, args, {
         cwd,
         shell: false,
         timeout,
@@ -4777,33 +5416,32 @@ function createEnabledCapabilityRegistry(config, findDesktopDriver = findCuaDriv
 }
 
 // src/agent/credential-store.ts
-import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, renameSync, rmSync, writeFileSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
-var CONFIG_DIR2 = join6(homedir3(), ".agent-tunnel");
-var CONFIG_FILE2 = join6(CONFIG_DIR2, "config.json");
+import { chmodSync as chmodSync3, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join8 } from "path";
+var CONFIG_DIR2 = agentTunnelHome();
+var CONFIG_FILE2 = join8(CONFIG_DIR2, "config.json");
 var PAIRING_FIELDS = ["token", "tunnelId", "enabledCapabilities"];
 function readConfigFile() {
   try {
-    const parsed = JSON.parse(readFileSync3(CONFIG_FILE2, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(CONFIG_FILE2, "utf-8"));
     return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
   }
 }
 function writeConfigFileAtomic(next) {
-  mkdirSync(CONFIG_DIR2, { recursive: true, mode: 448 });
+  mkdirSync2(CONFIG_DIR2, { recursive: true, mode: 448 });
   try {
-    chmodSync2(CONFIG_DIR2, 448);
+    chmodSync3(CONFIG_DIR2, 448);
   } catch {}
-  const tmpFile = join6(CONFIG_DIR2, `config.${process.pid}.${Date.now()}.tmp`);
-  writeFileSync(tmpFile, JSON.stringify(next, null, 2), { mode: 384, flag: "wx" });
+  const tmpFile = join8(CONFIG_DIR2, `config.${process.pid}.${Date.now()}.tmp`);
+  writeFileSync3(tmpFile, JSON.stringify(next, null, 2), { mode: 384, flag: "wx" });
   try {
-    chmodSync2(tmpFile, 384);
+    chmodSync3(tmpFile, 384);
   } catch {}
-  renameSync(tmpFile, CONFIG_FILE2);
+  renameSync2(tmpFile, CONFIG_FILE2);
   try {
-    chmodSync2(CONFIG_FILE2, 384);
+    chmodSync3(CONFIG_FILE2, 384);
   } catch {}
 }
 function saveCredentials(tunnelId, token, apiUrl, enabledCapabilities) {
@@ -4816,13 +5454,13 @@ function saveCredentials(tunnelId, token, apiUrl, enabledCapabilities) {
   });
 }
 function clearSavedCredentials() {
-  if (!existsSync3(CONFIG_FILE2))
+  if (!existsSync4(CONFIG_FILE2))
     return false;
   let existing;
   try {
-    existing = JSON.parse(readFileSync3(CONFIG_FILE2, "utf-8"));
+    existing = JSON.parse(readFileSync5(CONFIG_FILE2, "utf-8"));
   } catch {
-    rmSync(CONFIG_FILE2, { force: true });
+    rmSync2(CONFIG_FILE2, { force: true });
     return true;
   }
   const hadCredentials = PAIRING_FIELDS.some((key) => (key in existing) && existing[key] != null);
@@ -4866,13 +5504,13 @@ function probeCredentials(config, options = {}) {
     socket.addEventListener("message", (event) => {
       try {
         const message = JSON.parse(String(event.data));
-        if (isJsonRecord(message) && message.type === "auth_ok")
+        if (isJsonRecord2(message) && message.type === "auth_ok")
           settle("valid");
       } catch {}
     });
     socket.addEventListener("close", (event) => {
-      const { code } = event;
-      if (AUTH_REJECTED_CLOSE_CODES.includes(code))
+      const { code, reason } = event;
+      if (isCredentialRejection(code, reason))
         return settle("rejected");
       if (code === AGENT_REPLACED_CLOSE_CODE)
         return settle("valid");
@@ -4881,172 +5519,9 @@ function probeCredentials(config, options = {}) {
     socket.addEventListener("error", () => settle("unreachable"));
   });
 }
-function isJsonRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-// src/agent/device-auth.ts
-import { spawn as spawn3 } from "child_process";
-import { hostname as hostname3, platform as platform4 } from "os";
-var TUNNEL_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-var SETUP_TOKEN_PATTERN = /^kortix_tnl_[A-Za-z0-9_-]{32,64}$/;
-var DEVICE_CODE_PATTERN = /^[A-Z]{4}-[0-9]{4}$/;
-var DEVICE_SECRET_PATTERN = /^[A-Za-z0-9]{32}$/;
-var MAX_CHALLENGE_LIFETIME_MS = 10 * 60000;
-
-class InvalidDeviceAuthResponseError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InvalidDeviceAuthResponseError";
-  }
-}
-function invalid(what) {
-  throw new InvalidDeviceAuthResponseError(`Authorization server returned an invalid ${what}`);
-}
 function isJsonRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function normalizeBrowserUrl(value) {
-  try {
-    const url = new URL(value);
-    return url.protocol === "https:" || url.protocol === "http:" ? url.toString() : null;
-  } catch {
-    return null;
-  }
-}
-function isLoopback(url) {
-  return ["localhost", "127.0.0.1", "[::1]", "::1"].includes(url.hostname);
-}
-function assertSafeVerificationUrl(value) {
-  if (value.length > 2048)
-    invalid("verification URL");
-  const browserUrl = normalizeBrowserUrl(value);
-  if (!browserUrl)
-    invalid("verification URL");
-  const url = new URL(browserUrl);
-  if (url.username || url.password || url.protocol !== "https:" && !isLoopback(url)) {
-    throw new InvalidDeviceAuthResponseError("Authorization server returned an unsafe verification URL");
-  }
-  return browserUrl;
-}
-function parseDeviceAuthChallenge(value) {
-  if (!isJsonRecord2(value))
-    invalid("challenge");
-  const { deviceCode, deviceSecret, verificationUrl, expiresAt, pollIntervalMs } = value;
-  if (typeof deviceCode !== "string" || !DEVICE_CODE_PATTERN.test(deviceCode))
-    invalid("device code");
-  if (typeof deviceSecret !== "string" || !DEVICE_SECRET_PATTERN.test(deviceSecret)) {
-    invalid("device secret");
-  }
-  if (typeof verificationUrl !== "string")
-    invalid("verification URL");
-  if (typeof expiresAt !== "string")
-    invalid("expiration");
-  const expiresAtMs = Date.parse(expiresAt);
-  const now = Date.now();
-  if (!Number.isFinite(expiresAtMs) || expiresAtMs <= now || expiresAtMs > now + MAX_CHALLENGE_LIFETIME_MS) {
-    invalid("expiration");
-  }
-  if (!Number.isSafeInteger(pollIntervalMs) || pollIntervalMs < 250 || pollIntervalMs > 1e4) {
-    invalid("poll interval");
-  }
-  return {
-    deviceCode,
-    deviceSecret,
-    verificationUrl: assertSafeVerificationUrl(verificationUrl),
-    expiresAt,
-    pollIntervalMs
-  };
-}
-function parseApprovedCredentials(value) {
-  const { tunnelId, token } = value;
-  if (typeof tunnelId !== "string" || !TUNNEL_ID_PATTERN.test(tunnelId))
-    invalid("tunnel ID");
-  if (typeof token !== "string" || !SETUP_TOKEN_PATTERN.test(token))
-    invalid("setup token");
-  return { tunnelId, token };
-}
-function parseApprovedCapabilities(value) {
-  if (!Array.isArray(value))
-    return [];
-  return [...new Set(value)].filter((item) => isTunnelCapability(item));
-}
-function parseDeviceAuthStatus(value) {
-  if (!isJsonRecord2(value) || typeof value.status !== "string")
-    invalid("status response");
-  switch (value.status) {
-    case "approved": {
-      if (!value.tunnelId || !value.token)
-        return { status: "approved-without-token" };
-      return {
-        status: "approved",
-        ...parseApprovedCredentials(value),
-        capabilities: parseApprovedCapabilities(value.capabilities)
-      };
-    }
-    case "denied":
-      return { status: "denied" };
-    case "expired":
-      return { status: "expired" };
-    default:
-      return null;
-  }
-}
-async function requestDeviceAuthorization(apiUrl) {
-  const response = await fetch(`${apiUrl}/device-auth`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ machineHostname: hostname3() })
-  });
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    throw new InvalidDeviceAuthResponseError(`Failed to create device auth request: ${response.status} ${body.slice(0, 200)}`);
-  }
-  return parseDeviceAuthChallenge(await response.json());
-}
-async function awaitDeviceAuthorization(apiUrl, challenge, options = {}) {
-  const wait = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-  const expiresAtMs = Date.parse(challenge.expiresAt);
-  for (;; ) {
-    const secondsRemaining = Math.max(0, Math.floor((expiresAtMs - Date.now()) / 1000));
-    if (secondsRemaining <= 0)
-      return { status: "expired" };
-    options.onWaiting?.(secondsRemaining);
-    let payload;
-    try {
-      const response = await fetch(`${apiUrl}/device-auth/${challenge.deviceCode}/status`, {
-        headers: { Authorization: `Bearer ${challenge.deviceSecret}` }
-      });
-      if (!response.ok) {
-        await wait(challenge.pollIntervalMs);
-        continue;
-      }
-      payload = await response.json();
-    } catch {
-      await wait(challenge.pollIntervalMs);
-      continue;
-    }
-    const outcome = parseDeviceAuthStatus(payload);
-    if (outcome)
-      return outcome;
-    await wait(challenge.pollIntervalMs);
-  }
-}
-function openBrowser(url) {
-  if (process.env.KORTIX_AGENT_TUNNEL_NO_BROWSER === "1")
-    return;
-  const safeUrl = normalizeBrowserUrl(url);
-  if (!safeUrl)
-    return;
-  const opener = {
-    darwin: ["open", [safeUrl]],
-    win32: ["rundll32.exe", ["url.dll,FileProtocolHandler", safeUrl]]
-  };
-  const [command, args] = opener[platform4()] ?? ["xdg-open", [safeUrl]];
-  try {
-    spawn3(command, args, { detached: true, stdio: "ignore" }).unref();
-  } catch {}
-}
 
 // src/agent/log-format.ts
 function collapseRepeatedLines(lines) {
@@ -5103,15 +5578,15 @@ async function promptYesNo(question, defaultValue) {
 }
 
 // src/agent/service.ts
-import { chmodSync as chmodSync3, copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync3, realpathSync as realpathSync3, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
+import { chmodSync as chmodSync4, copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7, realpathSync as realpathSync3, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
 import { platform as platform6 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/agent/service-drivers.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir5, platform as platform5, userInfo } from "os";
-import { dirname as dirname4, join as join8 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir4, platform as platform5, userInfo } from "os";
+import { dirname as dirname5, join as join9 } from "path";
 
 // src/agent/service-quoting.ts
 function shellQuote(value) {
@@ -5124,66 +5599,28 @@ function xmlEscape(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 
-// src/agent/service-paths.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join7 } from "path";
-var SERVICE_LABEL = "ai.kortix.agent-tunnel";
-var DEFAULT_INSTALL_BACKGROUND_SERVICE = true;
-var TERMINAL_SERVICE_EXIT_CODE = 0;
-var MAX_SERVICE_LOG_BYTES = 5 * 1024 * 1024;
-var RETAINED_LOG_LINES = 500;
-function getServicePaths() {
-  const home = homedir4();
-  const configDir = join7(home, ".agent-tunnel");
-  const binDir = join7(configDir, "bin");
-  return {
-    configDir,
-    logDir: join7(configDir, "logs"),
-    binDir,
-    vendoredRunner: join7(binDir, "agent-cli.js"),
-    launchdPlist: join7(home, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`),
-    systemdUnit: join7(home, ".config", "systemd", "user", `${SERVICE_LABEL}.service`),
-    windowsScript: join7(configDir, "agent-tunnel-service.ps1")
-  };
-}
-function serviceLogFiles(paths = getServicePaths()) {
-  return [
-    join7(paths.logDir, "agent-tunnel.out.log"),
-    join7(paths.logDir, "agent-tunnel.err.log")
-  ];
-}
-function rotateServiceLogs(paths = getServicePaths(), maxBytes = MAX_SERVICE_LOG_BYTES) {
-  const rotated = [];
-  for (const file of serviceLogFiles(paths)) {
-    try {
-      const contents = readFileSync4(file, "utf8");
-      if (Buffer.byteLength(contents, "utf8") <= maxBytes)
-        continue;
-      const kept = contents.split(/\r?\n/).slice(-RETAINED_LOG_LINES).join(`
-`);
-      writeFileSync2(file, `[agent-tunnel] earlier entries trimmed
-${kept}`, { mode: 384 });
-      rotated.push(file);
-    } catch {}
-  }
-  return rotated;
-}
-
 // src/agent/service-drivers.ts
 function posixShellCommand(runner) {
   const interpreter = `"$(command -v ${shellQuote(runner.command)} 2>/dev/null || command -v node)"`;
-  return `exec ${interpreter} ${runner.args.map(shellQuote).join(" ")}`;
+  const env = Object.entries(runner.env ?? {});
+  const exports = env.length ? `export ${env.map(([key, value]) => `${key}=${shellQuote(value)}`).join(" ")}; ` : "";
+  return `${exports}exec ${interpreter} ${runner.args.map(shellQuote).join(" ")}`;
 }
-function run(command, args) {
-  const result = spawnSync(command, args, { encoding: "utf8" });
-  return {
-    ok: result.status === 0,
-    detail: [result.stdout, result.stderr].filter(Boolean).join(`
+var supervisor = {
+  run(command, args) {
+    const result = spawnSync(command, args, { encoding: "utf8" });
+    return {
+      ok: result.status === 0,
+      detail: [result.stdout, result.stderr].filter(Boolean).join(`
 `).trim()
-  };
-}
+    };
+  }
+};
+var run = (command, args) => supervisor.run(command, args);
 var notInstalled = (what) => ({ ok: false, detail: `${what} is not installed.` });
+var pause = { ms(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+} };
 function joinDetails(...results) {
   return results.map((result) => result.detail).filter(Boolean).join(`
 `);
@@ -5194,8 +5631,8 @@ function launchdTarget() {
 }
 function logPaths(paths) {
   return {
-    stdout: join8(paths.logDir, "agent-tunnel.out.log"),
-    stderr: join8(paths.logDir, "agent-tunnel.err.log")
+    stdout: join9(paths.logDir, "agent-tunnel.out.log"),
+    stderr: join9(paths.logDir, "agent-tunnel.err.log")
   };
 }
 function renderLaunchdPlist(command, paths = getServicePaths()) {
@@ -5205,7 +5642,7 @@ function renderLaunchdPlist(command, paths = getServicePaths()) {
 <plist version="1.0">
 <dict>
   <key>Label</key>
-  <string>${xmlEscape(SERVICE_LABEL)}</string>
+  <string>${xmlEscape(paths.label)}</string>
   <key>ProgramArguments</key>
   <array>
     <string>/bin/sh</string>
@@ -5215,10 +5652,9 @@ function renderLaunchdPlist(command, paths = getServicePaths()) {
   <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
-  <dict>
-    <key>SuccessfulExit</key>
-    <false/>
-  </dict>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
   <key>Umask</key>
   <integer>63</integer>
   <key>StandardOutPath</key>
@@ -5226,7 +5662,7 @@ function renderLaunchdPlist(command, paths = getServicePaths()) {
   <key>StandardErrorPath</key>
   <string>${xmlEscape(stderr)}</string>
   <key>WorkingDirectory</key>
-  <string>${xmlEscape(homedir5())}</string>
+  <string>${xmlEscape(homedir4())}</string>
   <key>EnvironmentVariables</key>
   <dict>
     <key>PATH</key>
@@ -5247,9 +5683,9 @@ Wants=network-online.target
 Type=simple
 UMask=0077
 ExecStart=/bin/sh -lc ${shellQuote(command)}
-Restart=on-failure
+Restart=always
 RestartSec=5
-WorkingDirectory=${homedir5()}
+WorkingDirectory=${homedir4()}
 Environment=PATH=/usr/local/bin:/usr/bin:/bin
 StandardOutput=append:${stdout}
 StandardError=append:${stderr}
@@ -5261,119 +5697,206 @@ WantedBy=default.target
 function renderWindowsPowerShellScript(runner) {
   const command = powershellQuote(runner.command);
   const args = runner.args.map(powershellQuote).join(" ");
+  const env = Object.entries(runner.env ?? {}).map(([key, value]) => `$env:${key} = ${powershellQuote(value)}
+`).join("");
   return `$ErrorActionPreference = 'Continue'
-while ($true) {
-  & ${command}${args ? ` ${args}` : ""}
-  # A clean exit means the agent stopped for a reason restarting cannot fix,
-  # such as a missing or revoked credential. Anything else is a crash worth retrying.
-  if ($LASTEXITCODE -eq ${TERMINAL_SERVICE_EXIT_CODE}) { break }
+${env}while ($true) {
+  # The pipe makes PowerShell wait for a GUI-subsystem binary (the desktop
+  # app's Kortix.exe) and set $LASTEXITCODE; a bare call returns at once.
+  & ${command}${args ? ` ${args}` : ""} | Out-Null
+  # The agent never exits on its own (R2), so every exit is restarted.
   Start-Sleep -Seconds 5
 }
 `;
 }
 var launchd = {
   unitPath: (paths) => paths.launchdPlist,
+  render: (paths, runner) => renderLaunchdPlist(posixShellCommand(runner), paths),
   install(paths, runner) {
-    mkdirSync2(dirname4(paths.launchdPlist), { recursive: true });
-    writeFileSync3(paths.launchdPlist, renderLaunchdPlist(posixShellCommand(runner), paths), { mode: 384 });
+    mkdirSync3(dirname5(paths.launchdPlist), { recursive: true });
+    writeFileSync4(paths.launchdPlist, launchd.render(paths, runner), { mode: 384 });
     run("launchctl", ["bootout", launchdTarget(), paths.launchdPlist]);
-    const boot = run("launchctl", ["bootstrap", launchdTarget(), paths.launchdPlist]);
-    const kick = run("launchctl", ["kickstart", "-k", `${launchdTarget()}/${SERVICE_LABEL}`]);
-    return { installed: true, active: boot.ok || kick.ok ? true : null, detail: joinDetails(boot, kick) };
+    run("launchctl", ["enable", `${launchdTarget()}/${paths.label}`]);
+    let boot = { ok: false, detail: "" };
+    let kick = { ok: false, detail: "" };
+    for (let attempt = 0;attempt < 3; attempt++) {
+      if (attempt > 0)
+        pause.ms(1000);
+      boot = run("launchctl", ["bootstrap", launchdTarget(), paths.launchdPlist]);
+      kick = run("launchctl", ["kickstart", "-k", `${launchdTarget()}/${paths.label}`]);
+      if (run("launchctl", ["print", `${launchdTarget()}/${paths.label}`]).ok) {
+        return { installed: true, active: true, detail: joinDetails(boot, kick) };
+      }
+    }
+    return { installed: true, active: null, detail: joinDetails(boot, kick) };
   },
   uninstall(paths) {
-    const existed = existsSync4(paths.launchdPlist);
+    const existed = existsSync5(paths.launchdPlist);
     const stop = run("launchctl", ["bootout", launchdTarget(), paths.launchdPlist]);
     if (existed)
-      rmSync2(paths.launchdPlist, { force: true });
+      rmSync3(paths.launchdPlist, { force: true });
     return { detail: stop.detail };
   },
   start(paths, installed) {
     const boot = installed ? run("launchctl", ["bootstrap", launchdTarget(), paths.launchdPlist]) : notInstalled("LaunchAgent");
-    const kick = run("launchctl", ["kickstart", "-k", `${launchdTarget()}/${SERVICE_LABEL}`]);
+    const kick = run("launchctl", ["kickstart", "-k", `${launchdTarget()}/${paths.label}`]);
     return { active: boot.ok || kick.ok ? true : null, detail: joinDetails(boot, kick) };
   },
   stop(paths, installed) {
     const stop = installed ? run("launchctl", ["bootout", launchdTarget(), paths.launchdPlist]) : notInstalled("LaunchAgent");
     return { detail: stop.detail };
   },
+  pause(paths) {
+    const disable = run("launchctl", ["disable", `${launchdTarget()}/${paths.label}`]);
+    const stop = run("launchctl", ["bootout", launchdTarget(), paths.launchdPlist]);
+    return { enabled: disable.ok ? false : undefined, detail: joinDetails(disable, stop) };
+  },
+  resume(paths, installed) {
+    const enable = run("launchctl", ["enable", `${launchdTarget()}/${paths.label}`]);
+    const boot = installed ? run("launchctl", ["bootstrap", launchdTarget(), paths.launchdPlist]) : notInstalled("LaunchAgent");
+    const kick = run("launchctl", ["kickstart", `${launchdTarget()}/${paths.label}`]);
+    return { enabled: enable.ok, active: boot.ok || kick.ok ? true : null, detail: joinDetails(enable, boot, kick) };
+  },
   status(paths, installed) {
-    const status = run("launchctl", ["print", `${launchdTarget()}/${SERVICE_LABEL}`]);
+    const disabled = run("launchctl", ["print-disabled", launchdTarget()]);
+    const enabled = !new RegExp(`"${paths.label.replace(/\./g, "\\.")}" => (disabled|true)`).test(disabled.detail);
+    const status = run("launchctl", ["print", `${launchdTarget()}/${paths.label}`]);
     return {
       active: status.ok,
-      detail: status.detail || (installed ? readFileSync5(paths.launchdPlist, "utf8") : undefined)
+      enabled,
+      detail: status.detail || (installed ? readFileSync6(paths.launchdPlist, "utf8") : undefined)
     };
   }
 };
 var systemd = {
   unitPath: (paths) => paths.systemdUnit,
+  render: (paths, runner) => renderSystemdUnit(posixShellCommand(runner), paths),
   install(paths, runner) {
-    mkdirSync2(dirname4(paths.systemdUnit), { recursive: true });
-    writeFileSync3(paths.systemdUnit, renderSystemdUnit(posixShellCommand(runner), paths), { mode: 384 });
+    mkdirSync3(dirname5(paths.systemdUnit), { recursive: true });
+    writeFileSync4(paths.systemdUnit, systemd.render(paths, runner), { mode: 384 });
     const reload = run("systemctl", ["--user", "daemon-reload"]);
-    const enable = run("systemctl", ["--user", "enable", "--now", `${SERVICE_LABEL}.service`]);
-    return { installed: true, active: enable.ok ? true : null, detail: joinDetails(reload, enable) };
+    const enable = run("systemctl", ["--user", "enable", `${paths.label}.service`]);
+    const restart = run("systemctl", ["--user", "restart", `${paths.label}.service`]);
+    return {
+      installed: true,
+      active: restart.ok ? true : null,
+      detail: joinDetails(reload, enable, restart, ensureLinger())
+    };
   },
   uninstall(paths) {
-    const existed = existsSync4(paths.systemdUnit);
-    const disable = run("systemctl", ["--user", "disable", "--now", `${SERVICE_LABEL}.service`]);
+    const existed = existsSync5(paths.systemdUnit);
+    const disable = run("systemctl", ["--user", "disable", "--now", `${paths.label}.service`]);
     if (existed)
-      rmSync2(paths.systemdUnit, { force: true });
+      rmSync3(paths.systemdUnit, { force: true });
     run("systemctl", ["--user", "daemon-reload"]);
     return { detail: disable.detail };
   },
-  start(_paths, installed) {
-    const start = installed ? run("systemctl", ["--user", "start", `${SERVICE_LABEL}.service`]) : notInstalled("systemd unit");
+  start(paths, installed) {
+    const start = installed ? run("systemctl", ["--user", "start", `${paths.label}.service`]) : notInstalled("systemd unit");
     return { active: start.ok ? true : null, detail: start.detail };
   },
-  stop(_paths, installed) {
-    const stop = installed ? run("systemctl", ["--user", "stop", `${SERVICE_LABEL}.service`]) : notInstalled("systemd unit");
+  stop(paths, installed) {
+    const stop = installed ? run("systemctl", ["--user", "stop", `${paths.label}.service`]) : notInstalled("systemd unit");
     return { detail: stop.detail };
   },
-  status() {
-    const status = run("systemctl", ["--user", "is-active", `${SERVICE_LABEL}.service`]);
-    return { active: status.ok, detail: status.detail };
+  pause(paths) {
+    const disable = run("systemctl", ["--user", "disable", "--now", `${paths.label}.service`]);
+    return { enabled: disable.ok ? false : undefined, active: false, detail: disable.detail };
+  },
+  resume(paths) {
+    const enable = run("systemctl", ["--user", "enable", "--now", `${paths.label}.service`]);
+    return { enabled: enable.ok, active: enable.ok ? true : null, detail: enable.detail };
+  },
+  status(paths) {
+    const status = run("systemctl", ["--user", "is-active", `${paths.label}.service`]);
+    const enabled = run("systemctl", ["--user", "is-enabled", `${paths.label}.service`]);
+    return { active: status.ok, enabled: enabled.ok, detail: status.detail };
   }
 };
+function ensureLinger() {
+  const user = userInfo().username;
+  const linger = run("loginctl", ["show-user", user, "-p", "Linger"]);
+  if (/Linger=yes/.test(linger.detail))
+    return { ok: true, detail: "" };
+  if (run("loginctl", ["enable-linger", user]).ok)
+    return { ok: true, detail: "Enabled lingering: the service keeps running after logout and starts at boot." };
+  return {
+    ok: false,
+    detail: `Warning: the service stops when you log out and starts only at your next login. Run \`loginctl enable-linger ${user}\` (may need sudo) to keep it running.`
+  };
+}
+function renderWindowsTaskXml(paths, user) {
+  return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo><Description>Kortix Agent Tunnel</Description></RegistrationInfo>
+  <Triggers><LogonTrigger><Enabled>true</Enabled><UserId>${xmlEscape(user)}</UserId></LogonTrigger></Triggers>
+  <Principals><Principal id="Author"><UserId>${xmlEscape(user)}</UserId><LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal></Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <Enabled>true</Enabled>
+  </Settings>
+  <Actions Context="Author"><Exec><Command>powershell.exe</Command><Arguments>${xmlEscape(`-NoProfile -NonInteractive -WindowStyle Hidden -ExecutionPolicy Bypass -File "${paths.windowsScript}"`)}</Arguments></Exec></Actions>
+</Task>
+`;
+}
+var windowsUser = () => process.env.USERDOMAIN ? `${process.env.USERDOMAIN}\\${userInfo().username}` : userInfo().username;
+var windowsTaskXmlPath = (paths) => paths.windowsScript.replace(/\.ps1$/, ".xml");
 var scheduledTask = {
   unitPath: (paths) => paths.windowsScript,
+  render: (_paths, runner) => renderWindowsPowerShellScript(runner),
   install(paths, runner) {
-    writeFileSync3(paths.windowsScript, renderWindowsPowerShellScript(runner), { mode: 384 });
-    const create = run("schtasks.exe", [
-      "/Create",
-      "/TN",
-      SERVICE_LABEL,
-      "/TR",
-      `powershell.exe -NoProfile -ExecutionPolicy Bypass -File "${paths.windowsScript}"`,
-      "/SC",
-      "ONLOGON",
-      "/F",
-      "/RL",
-      "LIMITED"
-    ]);
-    const start = run("schtasks.exe", ["/Run", "/TN", SERVICE_LABEL]);
+    writeFileSync4(paths.windowsScript, renderWindowsPowerShellScript(runner), { mode: 384 });
+    const xml = windowsTaskXmlPath(paths);
+    writeFileSync4(xml, Buffer.from(`\uFEFF${renderWindowsTaskXml(paths, windowsUser())}`, "utf16le"), { mode: 384 });
+    const create = run("schtasks.exe", ["/Create", "/TN", paths.label, "/XML", xml, "/F"]);
+    run("schtasks.exe", ["/End", "/TN", paths.label]);
+    const start = run("schtasks.exe", ["/Run", "/TN", paths.label]);
     return { installed: create.ok, active: start.ok ? true : null, detail: joinDetails(create, start) };
   },
   uninstall(paths) {
-    const existed = existsSync4(paths.windowsScript);
-    const stop = run("schtasks.exe", ["/End", "/TN", SERVICE_LABEL]);
-    const del = run("schtasks.exe", ["/Delete", "/TN", SERVICE_LABEL, "/F"]);
+    const existed = existsSync5(paths.windowsScript);
+    const stop = run("schtasks.exe", ["/End", "/TN", paths.label]);
+    const del = run("schtasks.exe", ["/Delete", "/TN", paths.label, "/F"]);
     if (existed)
-      rmSync2(paths.windowsScript, { force: true });
+      rmSync3(paths.windowsScript, { force: true });
+    rmSync3(windowsTaskXmlPath(paths), { force: true });
     return { detail: joinDetails(stop, del) };
   },
-  start(_paths, installed) {
-    const start = installed ? run("schtasks.exe", ["/Run", "/TN", SERVICE_LABEL]) : notInstalled("Scheduled Task");
+  start(paths, installed) {
+    const start = installed ? run("schtasks.exe", ["/Run", "/TN", paths.label]) : notInstalled("Scheduled Task");
     return { active: start.ok ? true : null, detail: start.detail };
   },
-  stop(_paths, installed) {
-    const stop = installed ? run("schtasks.exe", ["/End", "/TN", SERVICE_LABEL]) : notInstalled("Scheduled Task");
+  stop(paths, installed) {
+    const stop = installed ? run("schtasks.exe", ["/End", "/TN", paths.label]) : notInstalled("Scheduled Task");
     return { detail: stop.detail };
   },
+  pause(paths) {
+    const disable = run("schtasks.exe", ["/Change", "/TN", paths.label, "/DISABLE"]);
+    const stop = run("schtasks.exe", ["/End", "/TN", paths.label]);
+    return { enabled: disable.ok ? false : undefined, active: false, detail: joinDetails(disable, stop) };
+  },
+  resume(paths) {
+    const enable = run("schtasks.exe", ["/Change", "/TN", paths.label, "/ENABLE"]);
+    const start = run("schtasks.exe", ["/Run", "/TN", paths.label]);
+    return { enabled: enable.ok, active: start.ok ? true : null, detail: joinDetails(enable, start) };
+  },
   status(paths, installed) {
-    const status = run("schtasks.exe", ["/Query", "/TN", SERVICE_LABEL, "/FO", "LIST", "/V"]);
-    const detail = status.detail || (installed ? readFileSync5(paths.windowsScript, "utf8") : undefined);
-    return { active: status.ok ? /Status:\s*Running/i.test(detail ?? "") : false, detail };
+    const status = run("powershell.exe", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      `(Get-ScheduledTask -TaskName ${powershellQuote(paths.label)} -ErrorAction Stop).State`
+    ]);
+    const state = status.ok ? status.detail.trim() : "";
+    return {
+      active: state === "Running",
+      enabled: state !== "Disabled",
+      detail: state || (installed ? readFileSync6(paths.windowsScript, "utf8") : undefined)
+    };
   }
 };
 var DRIVERS = {
@@ -5382,32 +5905,51 @@ var DRIVERS = {
   win32: scheduledTask
 };
 var SUPPORTED_PLATFORMS_MESSAGE = "Background services are supported on macOS launchd, Linux systemd user services, and Windows Scheduled Tasks.";
+function serviceDriverFor(os) {
+  return DRIVERS[os];
+}
 function serviceDriver() {
-  return DRIVERS[platform5()];
+  return serviceDriverFor(platform5());
 }
 
 // src/agent/service.ts
 function isEphemeralRunnerPath(path) {
   const normalized = path.replace(/\\/g, "/");
-  return normalized.includes("/_npx/") || normalized.includes("/_cacache/") || normalized.includes("/.pnpm-store/") || normalized.includes("/.yarn/$$virtual/");
+  return normalized.includes("/_npx/") || normalized.includes("/_cacache/") || normalized.includes("/.pnpm-store/") || normalized.includes("/.yarn/$$virtual/") || normalized.includes("/.mount_");
 }
 function vendorRunner(scriptPath, paths = getServicePaths()) {
   if (!isEphemeralRunnerPath(scriptPath))
     return scriptPath;
-  mkdirSync3(paths.binDir, { recursive: true, mode: 448 });
+  mkdirSync4(paths.binDir, { recursive: true, mode: 448 });
   const source = realpathSync3(scriptPath);
   copyFileSync(source, paths.vendoredRunner);
   try {
-    chmodSync3(paths.vendoredRunner, 448);
+    chmodSync4(paths.vendoredRunner, 448);
   } catch {}
-  writeFileSync4(join9(paths.binDir, "agent-cli.source.json"), JSON.stringify({ source, vendoredFrom: scriptPath }, null, 2), { mode: 384 });
+  writeFileSync5(join10(paths.binDir, "package.json"), JSON.stringify({ name: "@kortix/agent-tunnel", version: agentTunnelVersion(), private: true }), { mode: 384 });
+  writeFileSync5(join10(paths.binDir, "agent-cli.source.json"), JSON.stringify({ source, vendoredFrom: scriptPath }, null, 2), { mode: 384 });
   return paths.vendoredRunner;
 }
-function currentRunnerParts() {
-  const script = process.argv[1];
-  if (script && existsSync5(script)) {
-    return { command: process.execPath, args: [vendorRunner(script), "run", "--service"] };
+function runnerPartsFor(script, runtime = {
+  execPath: process.execPath,
+  electron: process.versions.electron,
+  appImage: process.env.APPIMAGE
+}, paths = getServicePaths(), vendor = vendorRunner) {
+  const env = serviceHomeEnv(paths.configDir);
+  if (runtime.electron) {
+    return {
+      command: runtime.appImage || runtime.execPath,
+      args: [runtime.appImage ? vendor(script, paths) : script, "run", "--service"],
+      env: { ...env, ELECTRON_RUN_AS_NODE: "1" }
+    };
   }
+  return { command: runtime.execPath, args: [vendor(script, paths), "run", "--service"], env };
+}
+var plannedRunner = (script, paths) => isEphemeralRunnerPath(script) ? paths.vendoredRunner : script;
+function currentRunnerParts(vendor = vendorRunner) {
+  const script = process.argv[1];
+  if (script && existsSync6(script))
+    return runnerPartsFor(script, undefined, getServicePaths(), vendor);
   throw new Error("Cannot install the background service because the current Agent Tunnel executable was not found");
 }
 function withDriver(operate, fallback) {
@@ -5416,26 +5958,28 @@ function withDriver(operate, fallback) {
   if (!driver)
     throw new Error(SUPPORTED_PLATFORMS_MESSAGE);
   const path = driver.unitPath(paths);
-  const installed = existsSync5(path);
+  const installed = existsSync6(path);
   const outcome = operate(driver, paths, installed);
   return {
     platform: platform6(),
     installed: outcome.installed ?? installed,
     active: outcome.active ?? fallback.active,
+    ...outcome.enabled !== undefined ? { enabled: outcome.enabled } : {},
+    ...outcome.upToDate !== undefined ? { upToDate: outcome.upToDate } : {},
     path,
     detail: outcome.detail
   };
 }
 function installService() {
   const paths = getServicePaths();
-  mkdirSync3(paths.configDir, { recursive: true, mode: 448 });
-  mkdirSync3(paths.logDir, { recursive: true, mode: 448 });
+  mkdirSync4(paths.configDir, { recursive: true, mode: 448 });
+  mkdirSync4(paths.logDir, { recursive: true, mode: 448 });
   rotateServiceLogs(paths);
   const runner = currentRunnerParts();
   return withDriver((driver, servicePaths) => driver.install(servicePaths, runner), { installed: false, active: null });
 }
 function uninstallService() {
-  rmSync3(getServicePaths().binDir, { recursive: true, force: true });
+  rmSync4(getServicePaths().binDir, { recursive: true, force: true });
   return withDriver((driver, paths) => ({ ...driver.uninstall(paths), installed: false, active: false }), { installed: false, active: false });
 }
 function startService() {
@@ -5444,6 +5988,18 @@ function startService() {
 function stopService() {
   return withDriver((driver, paths, installed) => ({ ...driver.stop(paths, installed), active: false }), { installed: false, active: false });
 }
+function pauseService() {
+  return withDriver((driver, paths, installed) => ({ ...driver.pause(paths, installed), active: false }), { installed: false, active: false });
+}
+function resumeService() {
+  const current = getServiceStatus();
+  if (current.installed && current.upToDate === false)
+    return installService();
+  return resumeUnit();
+}
+function resumeUnit() {
+  return withDriver((driver, paths, installed) => driver.resume(paths, installed), { installed: false, active: null });
+}
 function restartService() {
   stopService();
   return startService();
@@ -5457,7 +6013,13 @@ function getServiceStatus() {
       detail: SUPPORTED_PLATFORMS_MESSAGE
     };
   }
-  return withDriver((driver, paths, installed) => driver.status(paths, installed), { installed: false, active: null });
+  return withDriver((driver, paths, installed) => {
+    let upToDate = false;
+    try {
+      upToDate = installed && readFileSync7(driver.unitPath(paths), "utf8") === driver.render(paths, currentRunnerParts(plannedRunner));
+    } catch {}
+    return { ...driver.status(paths, installed), upToDate };
+  }, { installed: false, active: null });
 }
 
 // src/agent/service-control.ts
@@ -5477,8 +6039,8 @@ function acquireTunnelLease() {
   };
 }
 var SERVICE_ACTIONS = {
-  start: { run: startService, label: "started" },
-  stop: { run: stopService, label: "stopped" },
+  start: { run: resumeService, label: "started" },
+  stop: { run: pauseService, label: "paused until `agent-tunnel start`" },
   restart: { run: restartService, label: "restarted" },
   uninstall: { run: uninstallService, label: "removed" },
   install: { run: installService, label: "installed" }
@@ -5486,6 +6048,8 @@ var SERVICE_ACTIONS = {
 function describeService(status) {
   if (!status.installed)
     return `${glyph.off} not installed`;
+  if (status.enabled === false)
+    return `${c.yellow}○${c.reset} paused ${c.dim}· stays stopped until \`agent-tunnel start\`${c.reset}`;
   if (status.active)
     return `${glyph.on} running ${c.dim}· starts at login${c.reset}`;
   return `${c.yellow}○${c.reset} installed ${c.dim}· stopped${c.reset}`;
@@ -5500,6 +6064,41 @@ function renderServiceAction(action, status) {
   blankLine();
 }
 
+// src/agent/state-file.ts
+import { chmodSync as chmodSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync8, renameSync as renameSync3, writeFileSync as writeFileSync6 } from "fs";
+import { join as join11 } from "path";
+function stateFilePath(home = agentTunnelHome()) {
+  return join11(home, "state.json");
+}
+function writeAgentState(status, tunnel, home = agentTunnelHome()) {
+  const state = {
+    tunnelId: tunnel.tunnelId,
+    apiUrl: tunnel.apiUrl,
+    status,
+    since: new Date().toISOString(),
+    agentVersion: agentTunnelVersion(),
+    pid: process.pid
+  };
+  try {
+    mkdirSync5(home, { recursive: true, mode: 448 });
+    const tmp = join11(home, `state.${process.pid}.${Date.now()}.tmp`);
+    writeFileSync6(tmp, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+    try {
+      chmodSync5(tmp, 384);
+    } catch {}
+    renameSync3(tmp, stateFilePath(home));
+  } catch {}
+}
+function readAgentState(home = agentTunnelHome()) {
+  try {
+    const parsed = JSON.parse(readFileSync8(stateFilePath(home), "utf8"));
+    return parsed && typeof parsed === "object" && typeof parsed.status === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
 // src/agent/cli.ts
 var ALL_CAPABILITIES = ["filesystem", "shell", "desktop"];
 var BACKGROUND_FLAGS = ["daemon", "service", "background", "always-online"];
@@ -5516,8 +6115,17 @@ function parseArgs(argv) {
   }
   return { command: argv[2] || "help", flags };
 }
+var jsonMode = false;
+var writeStdout = process.stdout.write.bind(process.stdout);
+function emit(event, fields = {}) {
+  writeStdout(`${JSON.stringify({ event, ...fields })}
+`);
+}
 function fail(message) {
-  console.error(`  ${glyph.bad} ${message}`);
+  if (jsonMode)
+    emit("error", { message });
+  else
+    console.error(`  ${glyph.bad} ${message}`);
   process.exit(1);
 }
 function shortenHomePath(path) {
@@ -5525,12 +6133,17 @@ function shortenHomePath(path) {
   return home && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
 }
 function startAgent(config, options = {}) {
+  if (jsonMode) {
+    process.stdout.write = process.stderr.write.bind(process.stderr);
+    options = { ...options, service: true };
+  }
   const registry = createEnabledCapabilityRegistry(config);
   if (config.enabledCapabilities?.includes("desktop") && !registry.has("desktop")) {
     console.error("[agent-tunnel] Computer Use is approved but unavailable: install the trusted cua-driver locally, then restart Agent Tunnel.");
   }
   if (options.service) {
-    console.log(`[agent-tunnel] service starting: ${config.tunnelId} -> ${config.apiUrl}`);
+    process.stdout.write(`[agent-tunnel] service starting: ${config.tunnelId} -> ${config.apiUrl}
+`);
   } else {
     clearScreen();
     printStartupBanner({
@@ -5540,13 +6153,9 @@ function startAgent(config, options = {}) {
       version: agentTunnelVersion()
     });
   }
-  const agent = new TunnelAgent(config, registry, {
-    onTerminalClose: ({ reason }) => {
-      if (!options.service)
-        return;
-      console.log(`[agent-tunnel] stopping service: ${reason}`);
-      process.exit(TERMINAL_SERVICE_EXIT_CODE);
-    }
+  const agent = new TunnelAgent(config, registry, { onStatus: (status, current) => writeAgentState(status, current) }, {
+    persistent: options.service === true,
+    reloadConfig: () => loadConfig({ apiUrl: config.apiUrl })
   });
   agent.connect();
   const shutdown = () => {
@@ -5564,7 +6173,7 @@ async function chooseBackgroundMode(flags) {
     return true;
   if (anyFlag(flags, FOREGROUND_FLAGS))
     return false;
-  if (!isInteractiveTerminal())
+  if (jsonMode || !isInteractiveTerminal())
     return false;
   blankLine();
   console.log(`  ${glyph.warn} ${c.bold}Security note${c.reset}`);
@@ -5576,45 +6185,72 @@ async function chooseBackgroundMode(flags) {
 async function launch(config, flags, lease) {
   if (await chooseBackgroundMode(flags)) {
     saveCredentials(config.tunnelId, config.token, config.apiUrl);
-    renderServiceAction("install", SERVICE_ACTIONS.install.run());
+    if (!jsonMode) {
+      renderServiceAction("install", SERVICE_ACTIONS.install.run());
+      return;
+    }
+    try {
+      const status = SERVICE_ACTIONS.install.run();
+      const ok = status.installed && status.active === true;
+      emit("service", { action: "install", ok, active: status.active, detail: status.detail ?? "" });
+      if (!ok)
+        process.exitCode = 1;
+    } catch (error) {
+      emit("service", { action: "install", ok: false, detail: error instanceof Error ? error.message : String(error) });
+      process.exitCode = 1;
+    }
     return;
   }
-  if (lease?.serviceWasActive) {
+  if (lease?.serviceWasActive && !jsonMode) {
     console.log(`  ${c.dim}Background service stays paused while this terminal holds the tunnel.${c.reset}`);
     console.log(`  ${c.dim}Resume it with${c.reset} ${c.white}agent-tunnel start${c.reset}${c.dim}, or leave it — it starts again at login.${c.reset}`);
   }
   startAgent(config);
 }
-async function pairThisMachine(apiUrl, flags) {
-  blankLine();
-  console.log(`  ${glyph.mark} ${c.bold}Device Authorization${c.reset}`);
-  blankLine();
+async function pairThisMachine(apiUrl, flags, lease) {
+  if (!jsonMode) {
+    blankLine();
+    console.log(`  ${glyph.mark} ${c.bold}Device Authorization${c.reset}`);
+    blankLine();
+  }
   let challenge;
   try {
-    challenge = await requestDeviceAuthorization(apiUrl);
+    challenge = await requestDeviceAuthorization(apiUrl, { projectId: flags["project-id"] });
   } catch (error) {
     fail(error instanceof InvalidDeviceAuthResponseError ? error.message : "Failed to start device authorization");
   }
-  console.log(`  ${c.dim}Code:${c.reset}  ${c.bold}${c.white}${challenge.deviceCode}${c.reset}`);
-  blankLine();
-  console.log(`  ${c.dim}Open this URL on any device to approve:${c.reset}`);
-  console.log(`  ${c.cyan}${challenge.verificationUrl}${c.reset}`);
-  blankLine();
-  openBrowser(challenge.verificationUrl);
+  if (jsonMode) {
+    emit("challenge", {
+      deviceCode: challenge.deviceCode,
+      verificationUrl: challenge.verificationUrl,
+      expiresAt: challenge.expiresAt
+    });
+  } else {
+    console.log(`  ${c.dim}Code:${c.reset}  ${c.bold}${c.white}${challenge.deviceCode}${c.reset}`);
+    blankLine();
+    console.log(`  ${c.dim}Open this URL on any device to approve:${c.reset}`);
+    console.log(`  ${c.cyan}${challenge.verificationUrl}${c.reset}`);
+    blankLine();
+    openBrowser(challenge.verificationUrl);
+  }
+  const clearWaiting = () => {
+    if (!jsonMode)
+      process.stdout.write(`\r${" ".repeat(60)}\r`);
+  };
   let outcome;
   try {
     outcome = await awaitDeviceAuthorization(apiUrl, challenge, {
-      onWaiting: (secondsRemaining) => {
+      onWaiting: jsonMode ? undefined : (secondsRemaining) => {
         const minutes = Math.floor(secondsRemaining / 60);
         const seconds = String(secondsRemaining % 60).padStart(2, "0");
         process.stdout.write(`\r  ${c.dim}Waiting for approval... ${c.white}${minutes}:${seconds}${c.reset}  `);
       }
     });
   } catch (error) {
-    process.stdout.write(`\r${" ".repeat(60)}\r`);
+    clearWaiting();
     fail(error instanceof Error ? error.message : "Device authorization failed");
   }
-  process.stdout.write(`\r${" ".repeat(60)}\r`);
+  clearWaiting();
   if (outcome.status === "denied")
     fail("Authorization denied.");
   if (outcome.status === "expired")
@@ -5623,6 +6259,8 @@ async function pairThisMachine(apiUrl, flags) {
     fail("Authorization was approved, but the setup token was not available. Run connect again.");
   }
   if (outcome.capabilities.length === 0) {
+    if (jsonMode)
+      fail("No capabilities were approved. Nothing was saved. Pair again and approve at least one capability.");
     console.log(`  ${glyph.bad} ${c.bold}No capabilities were approved${c.reset}`);
     blankLine();
     console.log(`  ${c.dim}A tunnel with no capabilities connects but cannot act, and the${c.reset}`);
@@ -5632,12 +6270,22 @@ async function pairThisMachine(apiUrl, flags) {
     blankLine();
     process.exit(1);
   }
-  console.log(`  ${glyph.on} ${c.bold}Authorized${c.reset}`);
   saveCredentials(outcome.tunnelId, outcome.token, apiUrl, outcome.capabilities);
-  console.log(`  ${c.dim}Saved to ${CONFIG_FILE2}${c.reset}`);
-  console.log(`  ${c.dim}Access: ${outcome.capabilities.join(", ")}${c.reset}`);
-  blankLine();
-  await launch(loadConfig({ apiUrl }), flags);
+  writeAccess({
+    mode: existsSync7(desktopAppPath()) ? "ask" : "always",
+    grantedUntil: null,
+    deniedUntil: null,
+    keepAwake: readAccess().keepAwake
+  });
+  if (jsonMode) {
+    emit("approved", { tunnelId: outcome.tunnelId, capabilities: outcome.capabilities });
+  } else {
+    console.log(`  ${glyph.on} ${c.bold}Authorized${c.reset}`);
+    console.log(`  ${c.dim}Saved to ${CONFIG_FILE2}${c.reset}`);
+    console.log(`  ${c.dim}Access: ${outcome.capabilities.join(", ")}${c.reset}`);
+    blankLine();
+  }
+  await launch(loadConfig({ apiUrl }), flags, lease);
 }
 async function commandConnect(flags) {
   const config = loadConfig({
@@ -5649,18 +6297,24 @@ async function commandConnect(flags) {
   if (Boolean(config.token) !== Boolean(config.tunnelId)) {
     fail("Provide both --token and --tunnel-id, or neither (for device auth)");
   }
-  if (!config.token) {
-    await pairThisMachine(config.apiUrl, flags);
+  if (flags["project-id"] !== undefined && !UUID_PATTERN.test(flags["project-id"])) {
+    fail("--project-id must be a project UUID");
+  }
+  const savedForOtherBackend = Boolean(config.token) && !explicitCredentials && Boolean(flags["api-url"]) && new URL(loadConfig().apiUrl).origin !== new URL(config.apiUrl).origin;
+  const lease = acquireTunnelLease();
+  if (!config.token || savedForOtherBackend) {
+    await pairThisMachine(config.apiUrl, flags, lease);
     return;
   }
   if (isTruthyFlag(flags.reauth) && !explicitCredentials) {
     clearSavedCredentials();
-    await pairThisMachine(config.apiUrl, flags);
+    await pairThisMachine(config.apiUrl, flags, lease);
     return;
   }
-  const lease = acquireTunnelLease();
-  blankLine();
-  console.log(`  ${glyph.mark} ${c.dim}Checking saved credentials…${c.reset}`);
+  if (!jsonMode) {
+    blankLine();
+    console.log(`  ${glyph.mark} ${c.dim}Checking saved credentials…${c.reset}`);
+  }
   let probe;
   try {
     probe = await probeCredentials(config, {
@@ -5677,11 +6331,15 @@ async function commandConnect(flags) {
   if (probe === "rejected") {
     if (explicitCredentials)
       fail("The supplied --token was rejected for this tunnel.");
-    console.log(`  ${glyph.warn} ${c.dim}Saved token rejected — re-authorizing${c.reset}`);
+    if (!jsonMode)
+      console.log(`  ${glyph.warn} ${c.dim}Saved token rejected — re-authorizing${c.reset}`);
     clearSavedCredentials();
-    await pairThisMachine(config.apiUrl, flags);
+    await pairThisMachine(config.apiUrl, flags, lease);
     return;
   }
+  if (jsonMode) {
+    emit("approved", { tunnelId: config.tunnelId, capabilities: config.enabledCapabilities ?? [], existing: true });
+  }
   await launch(config, flags, lease);
 }
 function commandRun(flags) {
@@ -5692,8 +6350,21 @@ function commandRun(flags) {
   });
   const asService = flags.service === "true";
   if (!config.token || !config.tunnelId) {
-    console.error(`  ${glyph.bad} No saved tunnel credentials found. Run \`agent-tunnel connect\` first.`);
-    process.exit(asService ? TERMINAL_SERVICE_EXIT_CODE : 1);
+    if (!asService) {
+      console.error(`  ${glyph.bad} No saved tunnel credentials found. Run \`agent-tunnel connect\` first.`);
+      process.exit(1);
+    }
+    process.stdout.write(`[agent-tunnel] no saved credential — waiting for a credential (pair this computer to start)
+`);
+    const wait = setInterval(() => {
+      const next = loadConfig({ apiUrl: flags["api-url"] });
+      if (!next.token || !next.tunnelId)
+        return;
+      clearInterval(wait);
+      rotateServiceLogs();
+      startAgent(next, { service: true });
+    }, 60000);
+    return;
   }
   if (asService)
     rotateServiceLogs();
@@ -5701,7 +6372,7 @@ function commandRun(flags) {
 }
 function lastServiceActivity() {
   try {
-    const lines = readFileSync6(join10(getServicePaths().logDir, "agent-tunnel.out.log"), "utf8").split(/\r?\n/).map((line) => stripAnsi(line).trim()).filter((line) => line.length > 0);
+    const lines = readFileSync9(join12(getServicePaths().logDir, "agent-tunnel.out.log"), "utf8").split(/\r?\n/).map((line) => stripAnsi(line).trim()).filter((line) => line.length > 0);
     return lines.at(-1) ?? null;
   } catch {
     return null;
@@ -5719,7 +6390,11 @@ function commandStatus(flags) {
       apiUrl: config.apiUrl,
       capabilities: [...approved],
       version: agentTunnelVersion(),
+      home: agentTunnelHome(),
+      serviceLabel: getServicePaths().label,
       service,
+      state: readAgentState(),
+      access: readAccess(),
       lastActivity: lastServiceActivity()
     }, null, 2));
     return;
@@ -5753,12 +6428,40 @@ function commandStatus(flags) {
   console.log(`  ${c.dim}Recent logs:${c.reset} ${c.white}agent-tunnel logs${c.reset}`);
   blankLine();
 }
-function commandLogout(flags) {
+async function unpairOnServer() {
+  let config;
+  try {
+    config = loadConfig();
+  } catch {
+    return false;
+  }
+  if (!config.token || !config.tunnelId)
+    return false;
+  try {
+    const response = await fetch(`${config.apiUrl}/self`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${config.token}`, "X-Tunnel-Id": config.tunnelId },
+      signal: AbortSignal.timeout(1e4)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function commandLogout(flags) {
+  const serverUnpaired = await unpairOnServer();
   const removed = clearSavedCredentials();
+  rmSync5(accessFilePath(), { force: true });
+  rmSync5(accessRequestPath(), { force: true });
   const keepService = isTruthyFlag(flags["keep-service"]);
   if (!keepService)
     SERVICE_ACTIONS.uninstall.run();
+  if (isTruthyFlag(flags.json)) {
+    console.log(JSON.stringify({ ok: true, serverUnpaired, credentialsCleared: removed, serviceRemoved: !keepService }));
+    return;
+  }
   blankLine();
+  console.log(serverUnpaired ? `  ${glyph.on} ${c.dim}Removed this computer from Kortix${c.reset}` : `  ${glyph.warn} ${c.dim}Could not reach Kortix — remove this computer from its settings${c.reset}`);
   console.log(removed ? `  ${glyph.on} ${c.bold}Signed out${c.reset} ${c.dim}(credentials cleared from ${CONFIG_FILE2})${c.reset}` : `  ${glyph.off} ${c.dim}No saved credentials to clear${c.reset}`);
   console.log(keepService ? `  ${glyph.warn} ${c.dim}Background service kept — it cannot authenticate until you connect again${c.reset}` : `  ${c.dim}Background service removed${c.reset}`);
   blankLine();
@@ -5770,7 +6473,7 @@ function commandLogs(flags) {
   if (isTruthyFlag(flags.clear)) {
     for (const file of serviceLogFiles(paths)) {
       try {
-        writeFileSync5(file, "", { mode: 384 });
+        writeFileSync7(file, "", { mode: 384 });
       } catch {}
     }
     blankLine();
@@ -5782,16 +6485,16 @@ function commandLogs(flags) {
   const limit = Number.isSafeInteger(requested) && requested > 0 ? requested : DEFAULT_LOG_LINES;
   const showAll = isTruthyFlag(flags.all);
   for (const [label, file] of [
-    ["output", join10(paths.logDir, "agent-tunnel.out.log")],
-    ["errors", join10(paths.logDir, "agent-tunnel.err.log")]
+    ["output", join12(paths.logDir, "agent-tunnel.out.log")],
+    ["errors", join12(paths.logDir, "agent-tunnel.err.log")]
   ]) {
     blankLine();
     console.log(`  ${c.bold}${c.white}${label}${c.reset}  ${c.dim}${shortenHomePath(file)}${c.reset}`);
-    if (!existsSync6(file)) {
+    if (!existsSync7(file)) {
       console.log(`  ${c.dim}not created yet${c.reset}`);
       continue;
     }
-    const kept = readFileSync6(file, "utf8").split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line.trim().length > 0).filter((line) => showAll || !isShellStartupNoise(line));
+    const kept = readFileSync9(file, "utf8").split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line.trim().length > 0).filter((line) => showAll || !isShellStartupNoise(line));
     const lines = collapseRepeatedLines(kept).slice(-limit);
     if (lines.length === 0) {
       console.log(`  ${c.dim}empty${c.reset}`);
@@ -5827,11 +6530,15 @@ var COMMANDS = {
   },
   status: { summary: "Show pairing, capabilities, and service state (--json)", run: commandStatus },
   logs: { summary: "Show recent service logs (--lines <n>, --all, --clear)", run: commandLogs },
-  start: { summary: "Start the background service", run: (f) => commandServiceAction("start", f) },
+  start: {
+    summary: "Start the background service (resumes a paused one)",
+    run: (f) => commandServiceAction("start", f),
+    aliases: ["resume"]
+  },
   stop: {
-    summary: "Stop the background service (keeps it installed)",
+    summary: "Pause the background service; it stays stopped after restart until `start`",
     run: (f) => commandServiceAction("stop", f),
-    aliases: ["disable"]
+    aliases: ["disable", "pause"]
   },
   restart: { summary: "Restart the background service", run: (f) => commandServiceAction("restart", f) },
   "install-service": {
@@ -5843,10 +6550,10 @@ var COMMANDS = {
     run: (f) => commandServiceAction("uninstall", f)
   },
   "service-status": {
-    summary: "Show the background service state (same view as status)",
+    summary: "Show the background service state (same view as status, --json)",
     run: commandStatus
   },
-  logout: { summary: "Clear saved credentials and remove the service", run: commandLogout },
+  logout: { summary: "Remove this computer from Kortix, clear credentials, remove the service", run: commandLogout },
   run: { summary: "Run using saved credentials (used by the service)", run: commandRun },
   "start-service": { summary: "", run: (f) => commandServiceAction("start", f), hidden: true },
   "stop-service": { summary: "", run: (f) => commandServiceAction("stop", f), hidden: true },
@@ -5859,7 +6566,8 @@ var OPTIONS = [
   ["--token <token> --tunnel-id <id>", "Skip device auth and use an explicit credential"],
   ["--reauth", "With connect: discard the saved credential and pair again"],
   ["--daemon / --foreground", "With connect: skip the prompt and choose the mode"],
-  ["--json", "With status: machine-readable output"],
+  ["--project-id <uuid>", 'With connect: offer "Also share with <project>" on the approval page; the computer is yours in every project either way'],
+  ["--json", "With connect: NDJSON events, no prompts. With status and logout: machine-readable output"],
   ["--keep-service", "With logout: keep the background service installed"]
 ];
 function showHelp() {
@@ -5885,10 +6593,12 @@ function showHelp() {
   }
   blankLine();
   console.log(`  ${c.dim}Config: ${CONFIG_FILE2}${c.reset}`);
+  console.log(`  ${c.dim}Set AGENT_TUNNEL_HOME to use another config directory and service.${c.reset}`);
   console.log(`  ${c.dim}powered by ${c.cyan}kortix${c.reset}`);
   blankLine();
 }
 var { command, flags } = parseArgs(process.argv);
+jsonMode = command === "connect" && isTruthyFlag(flags.json);
 if (Object.prototype.hasOwnProperty.call(flags, "keep-awake")) {
   console.error(`  ${glyph.bad} --keep-awake is not supported. Configure sleep behavior in the operating system.`);
   process.exit(2);
@@ -5898,7 +6608,6 @@ if (!resolved) {
   showHelp();
 } else {
   Promise.resolve(resolved.run(flags)).catch((error) => {
-    console.error(`  ${glyph.bad} ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
+    fail(error instanceof Error ? error.message : String(error));
   });
 }