@beeuni/agent-tunnel 0.1.0 → 0.1.2

package/dist/agent-cli.js

@@ -2966,13 +2966,13 @@ if (typeof globalThis.WebSocket === "undefined") {
 }
 
 // src/agent/cli.ts
-import { existsSync as existsSync7, readFileSync as readFileSync11, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync11, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
 import { hostname as hostname4 } from "os";
 import { join as join12 } from "path";
 
 // src/agent/agent.ts
 import { spawn as spawn3 } from "child_process";
-import { hostname as hostname2, platform as platform2, arch, release } from "os";
+import { hostname as hostname2, platform as platform3, arch, release } from "os";
 
 // src/agent/config.ts
 import { chmodSync, existsSync, lstatSync, readFileSync as readFileSync2 } from "fs";
@@ -2991,7 +2991,9 @@ var TunnelErrorCode = {
   AUTH_FAILED: -32007,
   ACCESS_PENDING: -32010,
   ACCESS_DENIED: -32011,
-  ACCESS_OFF: -32012
+  ACCESS_OFF: -32012,
+  DESKTOP_PERMISSION_MISSING: -32013,
+  ACCESS_UNCONFIRMED: -32014
 };
 var TunnelMethods = {
   "fs.read": "filesystem",
@@ -3007,47 +3009,12 @@ var TunnelMethods = {
   "desktop.cua.list_tools": "desktop",
   "desktop.cua.describe": "desktop",
   "desktop.cua.call": "desktop",
-  "desktop.cua.bring_to_front": "desktop",
-  "desktop.cua.check_for_update": "desktop",
-  "desktop.cua.check_permissions": "desktop",
-  "desktop.cua.click": "desktop",
-  "desktop.cua.double_click": "desktop",
-  "desktop.cua.drag": "desktop",
-  "desktop.cua.end_session": "desktop",
-  "desktop.cua.get_accessibility_tree": "desktop",
-  "desktop.cua.get_agent_cursor_state": "desktop",
-  "desktop.cua.get_config": "desktop",
-  "desktop.cua.get_cursor_position": "desktop",
-  "desktop.cua.get_recording_state": "desktop",
-  "desktop.cua.get_screen_size": "desktop",
-  "desktop.cua.get_window_state": "desktop",
-  "desktop.cua.hotkey": "desktop",
-  "desktop.cua.kill_app": "desktop",
-  "desktop.cua.launch_app": "desktop",
-  "desktop.cua.list_apps": "desktop",
-  "desktop.cua.list_windows": "desktop",
-  "desktop.cua.move_cursor": "desktop",
-  "desktop.cua.page": "desktop",
-  "desktop.cua.press_key": "desktop",
-  "desktop.cua.replay_trajectory": "desktop",
-  "desktop.cua.right_click": "desktop",
-  "desktop.cua.scroll": "desktop",
-  "desktop.cua.set_agent_cursor_enabled": "desktop",
-  "desktop.cua.set_agent_cursor_motion": "desktop",
-  "desktop.cua.set_agent_cursor_style": "desktop",
-  "desktop.cua.set_config": "desktop",
-  "desktop.cua.set_value": "desktop",
-  "desktop.cua.start_recording": "desktop",
-  "desktop.cua.install_ffmpeg": "desktop",
-  "desktop.cua.start_session": "desktop",
-  "desktop.cua.stop_recording": "desktop",
-  "desktop.cua.type_text": "desktop",
-  "desktop.cua.zoom": "desktop",
   "tunnel.ping": null,
   "tunnel.pong": null,
   "tunnel.permission.revoked": null,
   "tunnel.permissions.sync": null,
-  "tunnel.token.rotated": null
+  "tunnel.token.rotated": null,
+  "tunnel.access.set": null
 };
 
 // src/shared/permissions.ts
@@ -3063,53 +3030,25 @@ var VALID_DESKTOP_FEATURES = new Set([
   "accessibility",
   "computer_use"
 ]);
-var DESKTOP_METHOD_FEATURES = {
-  "desktop.cua.ensure": "computer_use",
-  "desktop.cua.start_daemon": "computer_use",
-  "desktop.cua.status": "computer_use",
-  "desktop.cua.version": "computer_use",
-  "desktop.cua.list_tools": "computer_use",
-  "desktop.cua.describe": "computer_use",
-  "desktop.cua.bring_to_front": "windows",
-  "desktop.cua.check_for_update": "computer_use",
-  "desktop.cua.check_permissions": "computer_use",
-  "desktop.cua.click": "mouse",
-  "desktop.cua.double_click": "mouse",
-  "desktop.cua.drag": "mouse",
-  "desktop.cua.end_session": "computer_use",
-  "desktop.cua.get_accessibility_tree": "accessibility",
-  "desktop.cua.get_agent_cursor_state": "mouse",
-  "desktop.cua.get_config": "computer_use",
-  "desktop.cua.get_cursor_position": "mouse",
-  "desktop.cua.get_recording_state": "computer_use",
-  "desktop.cua.get_screen_size": "screenshot",
-  "desktop.cua.get_window_state": "accessibility",
-  "desktop.cua.hotkey": "keyboard",
-  "desktop.cua.kill_app": "apps",
-  "desktop.cua.launch_app": "apps",
-  "desktop.cua.list_apps": "apps",
-  "desktop.cua.list_windows": "windows",
-  "desktop.cua.move_cursor": "mouse",
-  "desktop.cua.page": "accessibility",
-  "desktop.cua.press_key": "keyboard",
-  "desktop.cua.replay_trajectory": "computer_use",
-  "desktop.cua.right_click": "mouse",
-  "desktop.cua.scroll": "keyboard",
-  "desktop.cua.set_agent_cursor_enabled": "mouse",
-  "desktop.cua.set_agent_cursor_motion": "mouse",
-  "desktop.cua.set_agent_cursor_style": "mouse",
-  "desktop.cua.set_config": "computer_use",
-  "desktop.cua.set_value": "accessibility",
-  "desktop.cua.start_recording": "screenshot",
-  "desktop.cua.install_ffmpeg": "computer_use",
-  "desktop.cua.start_session": "computer_use",
-  "desktop.cua.stop_recording": "screenshot",
-  "desktop.cua.type_text": "keyboard",
-  "desktop.cua.zoom": "screenshot"
-};
+var CUA_PREFIX = "desktop.cua.";
 function capabilityForMethod(method) {
   const capability = TunnelMethods[method];
-  return capability ?? null;
+  if (capability !== undefined)
+    return capability;
+  return method.startsWith(CUA_PREFIX) && method.length > CUA_PREFIX.length ? "desktop" : null;
+}
+function normalizeDesktopCall(method, params) {
+  if (!method.startsWith(CUA_PREFIX) || method in TunnelMethods)
+    return { method, params };
+  const { permissionId, ...args } = params;
+  return {
+    method: "desktop.cua.call",
+    params: {
+      tool: method.slice(CUA_PREFIX.length),
+      args,
+      ...permissionId === undefined ? {} : { permissionId }
+    }
+  };
 }
 function isTunnelCapability(value) {
   return VALID_CAPABILITIES.has(value);
@@ -3271,16 +3210,6 @@ function operationForMethod(method) {
   const separator = method.indexOf(".");
   return separator === -1 ? method : method.slice(separator + 1);
 }
-function desktopFeatureForMethod(method, args = {}) {
-  if (method === "desktop.cua.call") {
-    const tool = args.tool;
-    if (typeof tool !== "string" || tool.length === 0)
-      return;
-    const toolMethod = tool.startsWith("desktop.cua.") ? tool : `desktop.cua.${tool}`;
-    return DESKTOP_METHOD_FEATURES[toolMethod];
-  }
-  return DESKTOP_METHOD_FEATURES[method];
-}
 
 // src/agent/service-paths.ts
 import { createHash } from "crypto";
@@ -3288,7 +3217,6 @@ import { readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join, resolve } from "path";
 var SERVICE_LABEL = "ai.beeuni.agent-tunnel";
-var DEFAULT_INSTALL_BACKGROUND_SERVICE = true;
 function defaultAgentTunnelHome() {
   return join(homedir(), ".agent-tunnel");
 }
@@ -3543,10 +3471,13 @@ function loadConfig(overrides = {}) {
 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 { platform } from "os";
 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 DENY_MS = 10 * 60000;
+var REQUEST_FRESH_MS = 60000;
 var MODES = ["ask", "always", "off"];
 var COMPAT = { mode: "always", grantedUntil: null, deniedUntil: null, keepAwake: false };
 var accessFilePath = (home = agentTunnelHome()) => join3(home, "access.json");
@@ -3596,6 +3527,99 @@ function decideAccess(state, now = Date.now()) {
   const granted = state.grantedUntil ? Date.parse(state.grantedUntil) : 0;
   return granted > now && granted - now <= MAX_GRANT_MS ? "run" : "ask";
 }
+var keepAwakeSupported = (os) => os === "darwin" || os === "linux";
+function parseAccessChange(params) {
+  const raw = params && typeof params === "object" ? params : {};
+  const change = {};
+  if (raw.mode !== undefined) {
+    if (!MODES.includes(raw.mode))
+      throw new Error(`mode must be one of ${MODES.join(", ")}`);
+    change.mode = raw.mode;
+  }
+  if (raw.grantMinutes !== undefined) {
+    if (typeof raw.grantMinutes !== "number" || !(raw.grantMinutes > 0))
+      throw new Error("grantMinutes must be a positive number");
+    change.grantMinutes = raw.grantMinutes;
+  }
+  for (const key of ["revoke", "deny", "keepAwake"]) {
+    if (raw[key] === undefined)
+      continue;
+    if (typeof raw[key] !== "boolean")
+      throw new Error(`${key} must be true or false`);
+    change[key] = raw[key];
+  }
+  if (Object.keys(change).length === 0)
+    throw new Error("No access change given");
+  return change;
+}
+function accessCommand(change) {
+  const npx = "npx @beeuni/agent-tunnel@latest";
+  if (change.keepAwake !== undefined && Object.keys(change).length === 1)
+    return `${npx} keep-awake ${change.keepAwake ? "on" : "off"}`;
+  const args = [change.mode, change.grantMinutes !== undefined ? `--allow-for ${change.grantMinutes}` : undefined];
+  return [`${npx} access`, ...args.filter(Boolean)].join(" ");
+}
+function nextAccess(current, change, now = Date.now()) {
+  const next = { ...current };
+  if (change.mode !== undefined) {
+    if (!MODES.includes(change.mode))
+      throw new Error(`mode must be one of ${MODES.join(", ")}`);
+    if (change.mode !== current.mode) {
+      next.grantedUntil = null;
+      next.deniedUntil = null;
+    }
+    next.mode = change.mode;
+  }
+  if (change.grantMinutes !== undefined) {
+    const minutes = Number(change.grantMinutes);
+    if (!Number.isFinite(minutes) || minutes <= 0)
+      throw new Error("grantMinutes must be a positive number");
+    next.grantedUntil = new Date(now + Math.min(minutes * 60000, MAX_GRANT_MS)).toISOString();
+    next.deniedUntil = null;
+  }
+  if (change.revoke === true)
+    next.grantedUntil = null;
+  if (change.deny === true) {
+    next.grantedUntil = null;
+    next.deniedUntil = new Date(now + DENY_MS).toISOString();
+  }
+  if (change.keepAwake !== undefined)
+    next.keepAwake = change.keepAwake === true;
+  return next;
+}
+function accessWidens(current, next, now = Date.now()) {
+  if (next.mode === "always")
+    return current.mode !== "always";
+  if (next.mode !== "ask")
+    return false;
+  const reach = (state) => state.mode === "ask" && decideAccess(state, now) === "run" ? Date.parse(state.grantedUntil) : 0;
+  return reach(next) > reach(current);
+}
+function pendingAccessRequest(home = agentTunnelHome(), now = Date.now()) {
+  const request = readAccessRequest(home);
+  return request && now - Date.parse(request.requestedAt) < REQUEST_FRESH_MS ? request : null;
+}
+function accessView(home = agentTunnelHome(), os = platform(), now = Date.now()) {
+  const state = readAccess(home);
+  const request = pendingAccessRequest(home, now);
+  return {
+    ...state,
+    grantedUntil: state.grantedUntil && Date.parse(state.grantedUntil) > now ? state.grantedUntil : null,
+    deniedUntil: state.deniedUntil && Date.parse(state.deniedUntil) > now ? state.deniedUntil : null,
+    keepAwakeSupported: keepAwakeSupported(os),
+    pendingRequest: request ? { id: request.id, capability: request.capability, requestedAt: request.requestedAt, ...request.change ? { change: request.change } : {} } : null
+  };
+}
+function applyAccess(change, home = agentTunnelHome(), now = Date.now()) {
+  const request = readAccessRequest(home);
+  const declinesChange = change.deny === true && Boolean(request?.change);
+  const own = declinesChange ? { ...change, deny: undefined } : change;
+  writeAccess(nextAccess(readAccess(home), own, now), home);
+  const answers = own.mode !== undefined || own.grantMinutes !== undefined || change.deny === true;
+  if (request && answers && !(Date.parse(request.requestedAt) > now))
+    rmSync(accessRequestPath(home), { force: true });
+  return accessView(home, platform(), now);
+}
 function writeAccessRequest(input, home = agentTunnelHome()) {
   const request = { id: randomUUID(), requestedAt: new Date().toISOString(), ...input };
   writePrivateJson(accessRequestPath(home), home, request);
@@ -3653,10 +3677,10 @@ function wakeDesktopApp(home = agentTunnelHome(), now = Date.now()) {
     return "no-app";
   }
 }
-function keepAwakeCommand(platform, pid) {
-  if (platform === "darwin")
+function keepAwakeCommand(platform2, pid) {
+  if (platform2 === "darwin")
     return { command: "caffeinate", args: ["-s", "-w", String(pid)] };
-  if (platform === "linux") {
+  if (platform2 === "linux") {
     return {
       command: "systemd-inhibit",
       args: ["--what=sleep", "--who=Beeuni", "--why=Keep this computer reachable", "--mode=block", "tail", `--pid=${pid}`, "-f", "/dev/null"]
@@ -3669,7 +3693,7 @@ function keepAwakeCommand(platform, pid) {
 import { execFileSync, spawn as spawn2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
 import { readFileSync as readFileSync4 } from "fs";
-import { hostname, platform } from "os";
+import { hostname, platform as platform2 } 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 = /^beeuni_tnl_[A-Za-z0-9_-]{32,64}$/;
@@ -3776,7 +3800,7 @@ function parseDeviceAuthStatus(value) {
   }
 }
 function machineDisplayName({
-  os = platform(),
+  os = platform2(),
   host = hostname(),
   env = process.env,
   run = (command, args) => execFileSync(command, args, { encoding: "utf8", timeout: 1000, stdio: ["ignore", "pipe", "ignore"] })
@@ -3790,7 +3814,7 @@ function machineDisplayName({
   }
 }
 function machineId({
-  os = platform(),
+  os = platform2(),
   run = (command, args) => execFileSync(command, args, { encoding: "utf8", timeout: 2000, stdio: ["ignore", "pipe", "ignore"] }),
   read = (path) => readFileSync4(path, "utf8")
 } = {}) {
@@ -3859,7 +3883,7 @@ function openBrowser(url) {
     darwin: ["open", [safeUrl]],
     win32: ["rundll32.exe", ["url.dll,FileProtocolHandler", safeUrl]]
   };
-  const [command, args] = opener[platform()] ?? ["xdg-open", [safeUrl]];
+  const [command, args] = opener[platform2()] ?? ["xdg-open", [safeUrl]];
   try {
     spawn2(command, args, { detached: true, stdio: "ignore" }).unref();
   } catch {}
@@ -4012,6 +4036,10 @@ function verifyMessageSignature(signingKey, payload, nonce, signature) {
 
 // src/agent/agent.ts
 var AGENT_VERSION = agentTunnelVersion();
+function openRelaySocket(url) {
+  const RelaySocket = WebSocket;
+  return new RelaySocket(url, { headers: { "User-Agent": `beeuni-agent-tunnel/${AGENT_VERSION}` } });
+}
 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 = "") {
@@ -4029,6 +4057,7 @@ function log(icon, msg) {
 }
 var LIVENESS_TIMEOUT_MS = 75000;
 var WATCHDOG_INTERVAL_MS = 5000;
+var DESKTOP_PROBE_EVERY_TICKS = 12;
 var CLOCK_JUMP_MS = 30000;
 var REJECTED_RETRY_MS = 5 * 60000;
 var PAIR_AGAIN_COMMAND = "npx @beeuni/agent-tunnel@latest connect --reauth";
@@ -4077,6 +4106,9 @@ class TunnelAgent {
   standbyAttempts = 0;
   lastRejectedLogAt = 0;
   sentAccessKey = null;
+  desktopPermissions = null;
+  probingDesktop = false;
+  watchdogTicks = 0;
   keepAwake = null;
   keepAwakeFailed = false;
   reconnectTimer = null;
@@ -4109,7 +4141,7 @@ class TunnelAgent {
     this.connectStartedAt = this.now();
     this.setStatus("connecting");
     try {
-      this.ws = new WebSocket(new URL(wsUrl));
+      this.ws = openRelaySocket(new URL(wsUrl).href);
       this.setupWsHandlers();
     } catch (err) {
       log(`${c.red}✗${c.reset}`, `Connection failed`);
@@ -4168,7 +4200,8 @@ class TunnelAgent {
         token: trustedCredential(this.config.token, "token"),
         capabilities: this.registry.getCapabilityNames(),
         agentVersion: AGENT_VERSION,
-        reportsAccess: true
+        reportsAccess: true,
+        controlsAccess: true
       });
     });
     this.ws.addEventListener("message", (event) => {
@@ -4262,6 +4295,7 @@ class TunnelAgent {
       this.standbyAttempts = 0;
       this.setStatus("online");
       this.reportAccess();
+      this.probeDesktopPermissions();
       if (this.stableConnectionTimer)
         clearTimeout(this.stableConnectionTimer);
       this.stableConnectionTimer = setTimeout(() => {
@@ -4311,6 +4345,10 @@ class TunnelAgent {
       log(`${c.yellow}!${c.reset}`, `Token rotated — reconnecting with new token`);
       return;
     }
+    if ("id" in msg && msg.id && msg.method === "tunnel.access.set") {
+      await this.handleAccessChange(msg);
+      return;
+    }
     if ("id" in msg && msg.id) {
       await this.handleRpcRequest(msg);
       return;
@@ -4337,7 +4375,8 @@ class TunnelAgent {
     return true;
   }
   async handleRpcRequest(request) {
-    const { id, method, params = {} } = request;
+    const { method, params } = normalizeDesktopCall(request.method, request.params ?? {});
+    const { id } = request;
     const permissionId = params.permissionId;
     const permission = this.permissionGuard.getPermissionForMethod(permissionId, method);
     if (!permission) {
@@ -4362,7 +4401,8 @@ class TunnelAgent {
       this.sendSignedResult(id, result);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      this.sendSignedError(id, -32003, message);
+      const code = err?.code;
+      this.sendSignedError(id, typeof code === "number" && code <= -32000 && code >= -32099 ? code : -32003, message);
     }
   }
   sendSignedResult(id, result) {
@@ -4415,7 +4455,7 @@ class TunnelAgent {
           hostname: hostname2(),
           displayName: this.displayName ??= machineDisplayName(),
           ...this.hardwareId ? { machineId: this.hardwareId } : {},
-          platform: platform2(),
+          platform: platform3(),
           arch: arch(),
           osVersion: release(),
           agentVersion: AGENT_VERSION,
@@ -4436,10 +4476,11 @@ class TunnelAgent {
     try {
       const pending = readAccessRequest(this.home);
       if (pending && Date.now() - Date.parse(pending.requestedAt) < hold) {
-        requestId = pending.id;
+        requestId = pending.change ? null : pending.id;
       } else {
         requestId = writeAccessRequest({ capability: capabilityForMethod(method) ?? method, method }, this.home).id;
         wakeDesktopApp(this.home);
+        this.reportAccess();
       }
     } catch {}
     const deadline = Date.now() + hold;
@@ -4454,15 +4495,83 @@ class TunnelAgent {
     }
     return ACCESS_ERRORS.pending;
   }
+  async handleAccessChange(request) {
+    let change;
+    try {
+      change = parseAccessChange(request.params);
+    } catch (err) {
+      this.sendSignedError(request.id, TunnelErrorCode.LOCAL_ERROR, err instanceof Error ? err.message : String(err));
+      return;
+    }
+    try {
+      const view = await this.changeAccess(change);
+      this.reportAccess();
+      this.sendSignedResult(request.id, view);
+    } catch (err) {
+      this.reportAccess();
+      this.sendSignedError(request.id, TunnelErrorCode.ACCESS_UNCONFIRMED, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async changeAccess(change) {
+    const current = readAccess(this.home);
+    const target = nextAccess(current, change, this.now());
+    if (!accessWidens(current, target, this.now()))
+      return applyAccess(change, this.home, this.now());
+    const unconfirmed = (why) => new Error(`computer_access_unconfirmed: ${why}`);
+    const asked = writeAccessRequest({ capability: "access", method: "tunnel.access.set", change }, this.home);
+    this.reportAccess();
+    if (wakeDesktopApp(this.home) === "no-app") {
+      clearAccessRequest(asked.id, this.home);
+      throw unconfirmed(`Only the owner can allow more access, on the computer itself. Run ${accessCommand(change)} there.`);
+    }
+    const hold = this.options.accessHoldMs ?? ACCESS_HOLD_MS;
+    const deadline = Date.now() + hold;
+    while (Date.now() < deadline) {
+      await new Promise((resolve2) => setTimeout(resolve2, Math.min(100, hold / 4)));
+      if (!accessWidens(readAccess(this.home), target, this.now())) {
+        clearAccessRequest(asked.id, this.home);
+        return accessView(this.home, platform3(), this.now());
+      }
+      if (readAccessRequest(this.home)?.id !== asked.id)
+        throw unconfirmed("The owner declined on the computer.");
+    }
+    clearAccessRequest(asked.id, this.home);
+    throw unconfirmed(`Nobody confirmed on the computer within ${Math.round(hold / 1000)} seconds.`);
+  }
   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")
+    if (this.status !== "online")
+      return;
+    const view = accessView(this.home, platform3(), this.now());
+    const params = {
+      mode: view.mode,
+      grantedUntil: view.grantedUntil,
+      deniedUntil: view.deniedUntil,
+      keepAwake: view.keepAwake,
+      keepAwakeSupported: view.keepAwakeSupported,
+      pendingRequest: view.pendingRequest ? { capability: view.pendingRequest.capability, requestedAt: view.pendingRequest.requestedAt, ...view.pendingRequest.change ? { change: view.pendingRequest.change } : {} } : null,
+      desktopPermissions: this.desktopPermissions
+    };
+    const key = JSON.stringify(params);
+    if (key === this.sentAccessKey)
       return;
     this.sentAccessKey = key;
-    this.sendSigned({ jsonrpc: "2.0", method: "tunnel.access.state", params: { mode, grantedUntil } });
+    this.sendSigned({ jsonrpc: "2.0", method: "tunnel.access.state", params });
+  }
+  async probeDesktopPermissions() {
+    const call = this.registry.getHandler("desktop.cua.call");
+    if (!call || this.probingDesktop)
+      return;
+    this.probingDesktop = true;
+    try {
+      const report = await call({ tool: "check_permissions", args: {}, __permission: { capability: "desktop" } });
+      this.desktopPermissions = {
+        accessibility: report?.accessibility === true,
+        screenRecording: report?.screen_recording === true
+      };
+    } catch {} finally {
+      this.probingDesktop = false;
+    }
+    this.reportAccess();
   }
   syncKeepAwake(want) {
     if (!want) {
@@ -4473,7 +4582,7 @@ class TunnelAgent {
     }
     if (this.keepAwake || this.keepAwakeFailed)
       return;
-    const blocker = keepAwakeCommand(platform2(), process.pid);
+    const blocker = keepAwakeCommand(platform3(), process.pid);
     if (!blocker)
       return;
     const child = spawn3(blocker.command, blocker.args, { stdio: "ignore" });
@@ -4517,6 +4626,8 @@ class TunnelAgent {
         this.syncKeepAwake(access.keepAwake);
         this.reportAccess();
       } catch {}
+      if (++this.watchdogTicks % DESKTOP_PROBE_EVERY_TICKS === 0 && this.status === "online")
+        this.probeDesktopPermissions();
     }, interval);
     this.watchdog.unref?.();
   }
@@ -4582,7 +4693,7 @@ class TunnelAgent {
 }
 
 // src/agent/banner.ts
-import { arch as arch2, hostname as hostname3, platform as platform3 } from "os";
+import { arch as arch2, hostname as hostname3, platform as platform4 } from "os";
 var BOX_WIDTH = 60;
 var BAR_WIDTH = 50;
 var BAR_FRAMES = 14;
@@ -4632,7 +4743,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(hostname3(), 28)}${c.reset} ${c.dim}(${platform3()} ${arch2()})${c.reset}`);
+  row(`   ${c.dim}machine${c.reset}   ${c.white}${truncate(hostname3(), 28)}${c.reset} ${c.dim}(${platform4()} ${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}beeuni${c.reset} ${c.gray}─╯${c.reset}`);
@@ -4666,8 +4777,8 @@ class CapabilityRegistry {
 
 // src/agent/capabilities/desktop/cua-driver.ts
 import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync6, realpathSync, statSync as statSync2 } from "fs";
-import { homedir as homedir3, platform as platform4, tmpdir } from "os";
+import { existsSync as existsSync3, readFileSync as readFileSync6, realpathSync, rmSync as rmSync2, statSync as statSync2 } from "fs";
+import { homedir as homedir3, platform as platform5, tmpdir } from "os";
 import { basename as basename2, dirname as dirname3, join as join5 } from "path";
 var MAX_DRIVER_OUTPUT_BYTES = 5 * 1024 * 1024;
 var DRIVER_ENV_KEYS = [
@@ -4785,7 +4896,7 @@ function execFile(cmd, args, timeoutMs = 30000, env = driverEnvironment()) {
       clearTimeout(timer);
       if (code !== 0) {
         const detail = stderr.trim() || stdout.trim();
-        reject(new Error(`${cmd} failed (${code})${detail ? `: ${detail}` : ""}`));
+        reject(new Error(`${basename2(cmd)} failed (${code})${detail ? `: ${detail}` : ""}`));
       } else {
         resolve2({ stdout, stderr });
       }
@@ -4833,7 +4944,8 @@ class CuaDriver {
     this.binary = options.binary ?? null;
     this.embedded = options.embedded;
     const uid = typeof process.getuid === "function" ? process.getuid() : "user";
-    this.socketPath = options.socketPath ?? join5(tmpdir(), `beeuni-cua-${uid}.sock`);
+    const home = serviceLabelFor(agentTunnelHome()).slice(SERVICE_LABEL.length);
+    this.socketPath = options.socketPath ?? join5(tmpdir(), `beeuni-cua-${uid}${home}.sock`);
     this.hostBundleId = options.hostBundleId;
   }
   isEmbedded(binary) {
@@ -4913,7 +5025,9 @@ class CuaDriver {
     const bin = await this.ensureInstalled();
     if (this.isEmbedded(bin)) {
       await this.startEmbeddedDaemon(bin);
-    } else if (platform4() === "darwin") {
+      this.daemonReady = true;
+      return { ok: true };
+    } else if (platform5() === "darwin") {
       const child = spawn4("open", ["-n", "-g", "-a", "CuaDriver", "--args", "serve"], {
         detached: true,
         stdio: "ignore",
@@ -4942,6 +5056,12 @@ class CuaDriver {
     if (this.daemon && this.daemon.exitCode === null)
       return;
     const { env, socket } = this.mode(bin);
+    if (existsSync3(this.socketPath)) {
+      await execFile(bin, ["stop", ...socket], 1e4, env).catch(() => {
+        return;
+      });
+      rmSync2(this.socketPath, { force: true });
+    }
     const child = spawn4(bin, ["serve", "--embedded", "--no-permissions-gate", ...socket], {
       stdio: "ignore",
       env
@@ -4965,12 +5085,32 @@ class CuaDriver {
       throw new Error("cua-driver did not start (no socket after 10 s)");
     }
   }
+  async permissionOwner() {
+    return this.isEmbedded(await this.ensureInstalled()) ? "Beeuni" : "CuaDriver";
+  }
+  async missingPermissions() {
+    const report = await this.call("check_permissions", {});
+    const missing = [];
+    if (report?.accessibility === false)
+      missing.push("Accessibility");
+    if (report?.screen_recording === false)
+      missing.push("Screen Recording");
+    return missing;
+  }
   stop() {
     this.daemon?.kill();
     this.daemon = null;
     this.daemonReady = false;
   }
   async ensureDaemonReady() {
+    const bin = await this.ensureInstalled();
+    if (this.isEmbedded(bin)) {
+      if (this.daemon?.exitCode === null && existsSync3(this.socketPath))
+        return;
+      this.stop();
+      await this.startDaemon();
+      return;
+    }
     if (this.daemonReady)
       return;
     try {
@@ -4987,44 +5127,6 @@ class CuaDriver {
 }
 
 // src/agent/capabilities/desktop.ts
-var CUA_TOOLS = [
-  "bring_to_front",
-  "check_for_update",
-  "check_permissions",
-  "click",
-  "double_click",
-  "drag",
-  "end_session",
-  "get_accessibility_tree",
-  "get_agent_cursor_state",
-  "get_config",
-  "get_cursor_position",
-  "get_recording_state",
-  "get_screen_size",
-  "get_window_state",
-  "hotkey",
-  "kill_app",
-  "launch_app",
-  "list_apps",
-  "list_windows",
-  "move_cursor",
-  "page",
-  "press_key",
-  "replay_trajectory",
-  "right_click",
-  "scroll",
-  "set_agent_cursor_enabled",
-  "set_agent_cursor_motion",
-  "set_agent_cursor_style",
-  "set_config",
-  "set_value",
-  "start_recording",
-  "install_ffmpeg",
-  "start_session",
-  "stop_recording",
-  "type_text",
-  "zoom"
-];
 var LOCAL_ONLY_CUA_TOOLS = new Set(["check_for_update", "install_ffmpeg"]);
 function assertRemotelyCallableTool(tool) {
   if (typeof tool !== "string" || tool.length === 0) {
@@ -5034,24 +5136,30 @@ function assertRemotelyCallableTool(tool) {
     throw new Error(`CUA tool "${tool}" is local-only and cannot run through Agent Tunnel`);
   }
 }
-function createDesktopCapability() {
+
+class DesktopPermissionMissingError extends Error {
+  code = TunnelErrorCode.DESKTOP_PERMISSION_MISSING;
+}
+async function explainFailure(cua, err, onMissing) {
+  const missing = await cua.missingPermissions().catch(() => []);
+  if (missing.length > 0) {
+    onMissing();
+    throw new DesktopPermissionMissingError(`computer_desktop_permission_missing: macOS has not given ${await cua.permissionOwner()} ${missing.join(" and ")} on this computer.`);
+  }
+  throw err;
+}
+function createDesktopCapability(options = {}) {
   const cua = new CuaDriver;
   const methods = new Map;
-  const assertDesktopPermission = (params, method) => {
+  const onMissing = options.onPermissionMissing ?? (() => {});
+  const assertDesktopPermission = (params) => {
     const permission = params.__permission;
     if (permission?.capability !== "desktop") {
       throw new Error("Permission denied: desktop permission required");
     }
-    const features = Array.isArray(permission.scope?.features) ? permission.scope.features.filter((value) => typeof value === "string") : [];
-    if (features.length === 0)
-      return;
-    const feature = desktopFeatureForMethod(method, params);
-    if (!feature || !features.includes(feature)) {
-      throw new Error(`Permission denied: desktop feature "${feature ?? "unknown"}" is not allowed`);
-    }
   };
   methods.set("desktop.cua.ensure", async (params) => {
-    assertDesktopPermission(params, "desktop.cua.ensure");
+    assertDesktopPermission(params);
     const binary = await cua.ensureInstalled();
     const version = await cua.version().catch(() => {
       return;
@@ -5059,40 +5167,36 @@ function createDesktopCapability() {
     return { ok: true, binary, version };
   });
   methods.set("desktop.cua.start_daemon", async (params) => {
-    assertDesktopPermission(params, "desktop.cua.start_daemon");
+    assertDesktopPermission(params);
     return cua.startDaemon();
   });
   methods.set("desktop.cua.status", async (params) => {
-    assertDesktopPermission(params, "desktop.cua.status");
+    assertDesktopPermission(params);
     return { status: await cua.status() };
   });
   methods.set("desktop.cua.version", async (params) => {
-    assertDesktopPermission(params, "desktop.cua.version");
+    assertDesktopPermission(params);
     return { version: await cua.version() };
   });
   methods.set("desktop.cua.list_tools", async (params) => {
-    assertDesktopPermission(params, "desktop.cua.list_tools");
+    assertDesktopPermission(params);
     return { tools: await cua.listTools() };
   });
   methods.set("desktop.cua.describe", async (params) => {
-    assertDesktopPermission(params, "desktop.cua.describe");
+    assertDesktopPermission(params);
     return { description: await cua.describe(params.tool) };
   });
   methods.set("desktop.cua.call", async (params) => {
-    assertDesktopPermission(params, "desktop.cua.call");
+    assertDesktopPermission(params);
     const tool = params.tool;
     assertRemotelyCallableTool(tool);
     const args = params.args || {};
-    return cua.call(tool, args);
+    try {
+      return await cua.call(tool, args);
+    } catch (err) {
+      return explainFailure(cua, err, onMissing);
+    }
   });
-  for (const tool of CUA_TOOLS) {
-    if (LOCAL_ONLY_CUA_TOOLS.has(tool))
-      continue;
-    methods.set(`desktop.cua.${tool}`, async (params) => {
-      assertDesktopPermission(params, `desktop.cua.${tool}`);
-      return cua.call(tool, params);
-    });
-  }
   return {
     name: "desktop",
     methods
@@ -5503,7 +5607,7 @@ function createShellCapability(config) {
 }
 
 // src/agent/capabilities/enabled-registry.ts
-function createEnabledCapabilityRegistry(config, findDesktopDriver = findCuaDriverBinary) {
+function createEnabledCapabilityRegistry(config, findDesktopDriver = findCuaDriverBinary, desktop = {}) {
   const registry = new CapabilityRegistry;
   const enabled = new Set(config.enabledCapabilities ?? ["filesystem", "shell", "desktop"]);
   if (enabled.has("filesystem"))
@@ -5511,13 +5615,13 @@ function createEnabledCapabilityRegistry(config, findDesktopDriver = findCuaDriv
   if (enabled.has("shell"))
     registry.register(createShellCapability(config));
   if (enabled.has("desktop") && findDesktopDriver()) {
-    registry.register(createDesktopCapability());
+    registry.register(createDesktopCapability(desktop));
   }
   return registry;
 }
 
 // src/agent/credential-store.ts
-import { chmodSync as chmodSync3, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync7, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { chmodSync as chmodSync3, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync7, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
 import { join as join8 } from "path";
 var CONFIG_DIR2 = agentTunnelHome();
 var CONFIG_FILE2 = join8(CONFIG_DIR2, "config.json");
@@ -5561,7 +5665,7 @@ function clearSavedCredentials() {
   try {
     existing = JSON.parse(readFileSync7(CONFIG_FILE2, "utf-8"));
   } catch {
-    rmSync2(CONFIG_FILE2, { force: true });
+    rmSync3(CONFIG_FILE2, { force: true });
     return true;
   }
   const hadCredentials = PAIRING_FIELDS.some((key) => (key in existing) && existing[key] != null);
@@ -5577,17 +5681,17 @@ function probeCredentials(config, options = {}) {
   return new Promise((resolve3) => {
     let socket;
     try {
-      socket = new WebSocket(new URL(buildTunnelWsUrl(config)));
+      socket = openRelaySocket(new URL(buildTunnelWsUrl(config)).href);
     } catch {
       resolve3("unreachable");
       return;
     }
     const settle = (result) => {
       clearTimeout(timer);
+      resolve3(result);
       try {
         socket.close(1000, "probe complete");
       } catch {}
-      resolve3(result);
     };
     const timer = setTimeout(() => settle("unreachable"), options.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS);
     socket.addEventListener("open", () => {
@@ -5642,7 +5746,6 @@ function isShellStartupNoise(line) {
 }
 
 // src/agent/prompts.ts
-import { createInterface } from "readline/promises";
 function isInteractiveTerminal() {
   return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
@@ -5652,41 +5755,16 @@ function isTruthyFlag(value) {
 function anyFlag(flags, names) {
   return names.some((name) => isTruthyFlag(flags[name]));
 }
-async function promptYesNo(question, defaultValue) {
-  const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    for (;; ) {
-      const answer = (await rl.question(`${question}${suffix}`)).trim().toLowerCase();
-      if (!answer)
-        return defaultValue;
-      if (["y", "yes"].includes(answer))
-        return true;
-      if (["n", "no"].includes(answer))
-        return false;
-      console.log(`  ${c.yellow}!${c.reset} Please answer yes or no.`);
-    }
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      process.stdout.write(`
-`);
-      process.exit(130);
-    }
-    throw error;
-  } finally {
-    rl.close();
-  }
-}
 
 // src/agent/service.ts
-import { chmodSync as chmodSync4, copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync9, realpathSync as realpathSync3, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
-import { platform as platform6 } from "os";
+import { chmodSync as chmodSync4, copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync9, realpathSync as realpathSync3, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir5, platform as platform7 } from "os";
 import { join as join10 } from "path";
 
 // src/agent/service-drivers.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync8, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir4, platform as platform5, userInfo } from "os";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync8, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir4, platform as platform6, userInfo } from "os";
 import { dirname as dirname6, join as join9 } from "path";
 
 // src/agent/service-quoting.ts
@@ -5835,7 +5913,7 @@ var launchd = {
     const existed = existsSync5(paths.launchdPlist);
     const stop = run("launchctl", ["bootout", launchdTarget(), paths.launchdPlist]);
     if (existed)
-      rmSync3(paths.launchdPlist, { force: true });
+      rmSync4(paths.launchdPlist, { force: true });
     return { detail: stop.detail };
   },
   start(paths, installed) {
@@ -5888,7 +5966,7 @@ var systemd = {
     const existed = existsSync5(paths.systemdUnit);
     const disable = run("systemctl", ["--user", "disable", "--now", `${paths.label}.service`]);
     if (existed)
-      rmSync3(paths.systemdUnit, { force: true });
+      rmSync4(paths.systemdUnit, { force: true });
     run("systemctl", ["--user", "daemon-reload"]);
     return { detail: disable.detail };
   },
@@ -5963,8 +6041,8 @@ var scheduledTask = {
     const stop = run("schtasks.exe", ["/End", "/TN", paths.label]);
     const del = run("schtasks.exe", ["/Delete", "/TN", paths.label, "/F"]);
     if (existed)
-      rmSync3(paths.windowsScript, { force: true });
-    rmSync3(windowsTaskXmlPath(paths), { force: true });
+      rmSync4(paths.windowsScript, { force: true });
+    rmSync4(windowsTaskXmlPath(paths), { force: true });
     return { detail: joinDetails(stop, del) };
   },
   start(paths, installed) {
@@ -6010,7 +6088,7 @@ function serviceDriverFor(os) {
   return DRIVERS[os];
 }
 function serviceDriver() {
-  return serviceDriverFor(platform5());
+  return serviceDriverFor(platform6());
 }
 
 // src/agent/service.ts
@@ -6046,8 +6124,22 @@ function runnerPartsFor(script, runtime = {
   }
   return { command: runtime.execPath, args: [vendor(script, paths), "run", "--service"], env };
 }
+function installedAppRunner(apps = ["/Applications/Beeuni.app", join10(homedir5(), "Applications", "Beeuni.app")], os = process.platform) {
+  if (os !== "darwin")
+    return null;
+  for (const app of apps) {
+    const execPath = join10(app, "Contents", "MacOS", "Beeuni");
+    const script = join10(app, "Contents", "Resources", "agent-tunnel", "agent-cli.js");
+    if (existsSync6(execPath) && existsSync6(script))
+      return { execPath, script };
+  }
+  return null;
+}
 var plannedRunner = (script, paths) => isEphemeralRunnerPath(script) ? paths.vendoredRunner : script;
 function currentRunnerParts(vendor = vendorRunner) {
+  const app = process.versions.electron ? null : installedAppRunner();
+  if (app)
+    return runnerPartsFor(app.script, { execPath: app.execPath, electron: "installed-app" }, getServicePaths(), vendor);
   const script = process.argv[1];
   if (script && existsSync6(script))
     return runnerPartsFor(script, undefined, getServicePaths(), vendor);
@@ -6062,7 +6154,7 @@ function withDriver(operate, fallback) {
   const installed = existsSync6(path);
   const outcome = operate(driver, paths, installed);
   return {
-    platform: platform6(),
+    platform: platform7(),
     installed: outcome.installed ?? installed,
     active: outcome.active ?? fallback.active,
     ...outcome.enabled !== undefined ? { enabled: outcome.enabled } : {},
@@ -6080,7 +6172,7 @@ function installService() {
   return withDriver((driver, servicePaths) => driver.install(servicePaths, runner), { installed: false, active: null });
 }
 function uninstallService() {
-  rmSync4(getServicePaths().binDir, { recursive: true, force: true });
+  rmSync5(getServicePaths().binDir, { recursive: true, force: true });
   return withDriver((driver, paths) => ({ ...driver.uninstall(paths), installed: false, active: false }), { installed: false, active: false });
 }
 function startService() {
@@ -6108,7 +6200,7 @@ function restartService() {
 function getServiceStatus() {
   if (!serviceDriver()) {
     return {
-      platform: platform6(),
+      platform: platform7(),
       installed: false,
       active: null,
       detail: SUPPORTED_PLATFORMS_MESSAGE
@@ -6165,6 +6257,35 @@ function renderServiceAction(action, status) {
   blankLine();
 }
 
+// src/agent/self-restart.ts
+import { statSync as statSync3 } from "fs";
+function runtimeFingerprint(files) {
+  return files.map((file) => {
+    try {
+      const stat2 = statSync3(file);
+      return `${stat2.ino}:${stat2.mtimeMs}:${stat2.size}`;
+    } catch {
+      return "missing";
+    }
+  }).join("|");
+}
+var PERMISSION_RESTART_MIN_UPTIME_S = 5 * 60;
+function watchForRestart(exit, intervalMs = 60000) {
+  const files = [process.execPath, process.argv[1]].filter((file) => Boolean(file));
+  const started = runtimeFingerprint(files);
+  setInterval(() => {
+    if (runtimeFingerprint(files) !== started)
+      exit("its code was updated");
+  }, intervalMs).unref();
+  return {
+    permissionMissing: () => {
+      if (process.uptime() < PERMISSION_RESTART_MIN_UPTIME_S)
+        return;
+      setTimeout(() => exit("macOS refused a desktop permission"), 1000).unref();
+    }
+  };
+}
+
 // src/agent/state-file.ts
 import { chmodSync as chmodSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync10, renameSync as renameSync3, writeFileSync as writeFileSync6 } from "fs";
 import { join as join11 } from "path";
@@ -6191,10 +6312,22 @@ function writeAgentState(status, tunnel, home = agentTunnelHome()) {
     renameSync3(tmp, stateFilePath(home));
   } catch {}
 }
+function isAlive2(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 readAgentState(home = agentTunnelHome()) {
   try {
     const parsed = JSON.parse(readFileSync10(stateFilePath(home), "utf8"));
-    return parsed && typeof parsed === "object" && typeof parsed.status === "string" ? parsed : null;
+    if (!parsed || typeof parsed !== "object" || typeof parsed.status !== "string")
+      return null;
+    return parsed.status !== "offline" && !isAlive2(parsed.pid) ? { ...parsed, status: "offline" } : parsed;
   } catch {
     return null;
   }
@@ -6207,13 +6340,18 @@ var FOREGROUND_FLAGS = ["foreground", "no-daemon", "no-service", "no-background"
 var DEFAULT_LOG_LINES = 60;
 function parseArgs(argv) {
   const flags = {};
+  const words = [];
   for (let i = 3;i < argv.length; i++) {
     const arg = argv[i];
-    if (!arg.startsWith("--"))
+    if (!arg.startsWith("--")) {
+      words.push(arg);
       continue;
+    }
     const next = argv[i + 1];
     flags[arg.slice(2)] = next && !next.startsWith("--") ? argv[++i] : "true";
   }
+  if (words.length > 0)
+    flags._ = words.join(" ");
   return { command: argv[2] || "help", flags };
 }
 var jsonMode = false;
@@ -6238,7 +6376,16 @@ function startAgent(config, options = {}) {
     process.stdout.write = process.stderr.write.bind(process.stderr);
     options = { ...options, service: true };
   }
-  const registry = createEnabledCapabilityRegistry(config);
+  let agent = null;
+  const restart = options.service ? watchForRestart((reason) => {
+    process.stdout.write(`[agent-tunnel] restarting: ${reason}
+`);
+    agent?.disconnect();
+    process.exit(0);
+  }) : null;
+  const registry = createEnabledCapabilityRegistry(config, undefined, {
+    onPermissionMissing: restart?.permissionMissing
+  });
   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.");
   }
@@ -6254,7 +6401,7 @@ function startAgent(config, options = {}) {
       version: agentTunnelVersion()
     });
   }
-  const agent = new TunnelAgent(config, registry, { onStatus: (status, current) => writeAgentState(status, current) }, {
+  agent = new TunnelAgent(config, registry, { onStatus: (status, current) => writeAgentState(status, current) }, {
     persistent: options.service === true,
     reloadConfig: () => loadConfig({ apiUrl: config.apiUrl })
   });
@@ -6263,31 +6410,37 @@ function startAgent(config, options = {}) {
     if (!options.service)
       console.log(`
 ${c.dim}  Shutting down…${c.reset}`);
-    agent.disconnect();
+    agent?.disconnect();
     process.exit(0);
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
 }
-async function chooseBackgroundMode(flags) {
+function chooseBackgroundMode(flags) {
   if (anyFlag(flags, BACKGROUND_FLAGS))
     return true;
   if (anyFlag(flags, FOREGROUND_FLAGS))
     return false;
-  if (jsonMode || !isInteractiveTerminal())
-    return false;
+  return !jsonMode && isInteractiveTerminal();
+}
+function printServiceControls() {
+  const npx = "npx @beeuni/agent-tunnel@latest";
+  console.log(`  ${c.dim}Runs in the background: starts at login, restarts after failures, keeps running after this terminal closes.${c.reset}`);
+  if (installedAppRunner()) {
+    console.log(`  ${c.dim}It runs on the Beeuni app on this Mac: same connection, same macOS permissions. Control it from Your computer in the app.${c.reset}`);
+  }
   blankLine();
-  console.log(`  ${glyph.warn} ${c.bold}Security note${c.reset}`);
-  console.log(`  ${c.dim}Background mode starts at login, continues after this terminal closes, and restarts after failures.${c.reset}`);
-  console.log(`  ${c.dim}The computer must remain powered on, awake, and connected to the internet.${c.reset}`);
+  field("Pause", `${c.white}${npx} stop${c.reset}`);
+  field("Resume", `${c.white}${npx} start${c.reset}`);
+  field("Disconnect", `${c.white}${npx} logout${c.reset}`);
   blankLine();
-  return promptYesNo("  Install the background service now?", DEFAULT_INSTALL_BACKGROUND_SERVICE);
 }
 async function launch(config, flags, lease) {
-  if (await chooseBackgroundMode(flags)) {
+  if (chooseBackgroundMode(flags)) {
     saveCredentials(config.tunnelId, config.token, config.apiUrl);
     if (!jsonMode) {
       renderServiceAction("install", SERVICE_ACTIONS.install.run());
+      printServiceControls();
       return;
     }
     try {
@@ -6495,7 +6648,7 @@ function commandStatus(flags) {
       serviceLabel: getServicePaths().label,
       service,
       state: readAgentState(),
-      access: readAccess(),
+      access: accessView(),
       lastActivity: lastServiceActivity()
     }, null, 2));
     return;
@@ -6552,8 +6705,8 @@ async function unpairOnServer() {
 async function commandLogout(flags) {
   const serverUnpaired = await unpairOnServer();
   const removed = clearSavedCredentials();
-  rmSync5(accessFilePath(), { force: true });
-  rmSync5(accessRequestPath(), { force: true });
+  rmSync6(accessFilePath(), { force: true });
+  rmSync6(accessRequestPath(), { force: true });
   const keepService = isTruthyFlag(flags["keep-service"]);
   if (!keepService)
     SERVICE_ACTIONS.uninstall.run();
@@ -6624,12 +6777,74 @@ function commandServiceAction(action, flags) {
   }
   renderServiceAction(action, SERVICE_ACTIONS[action].run());
 }
+function describeAccess(view) {
+  const clock = (iso) => new Date(iso).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  if (view.mode === "always")
+    return `${c.white}Always allowed${c.reset}`;
+  if (view.mode === "off")
+    return `${c.white}Off${c.reset} ${c.dim}(every agent call is refused)${c.reset}`;
+  const now = view.grantedUntil ? `allowed until ${clock(view.grantedUntil)}` : view.deniedUntil ? `denied until ${clock(view.deniedUntil)}` : "asks before the next call";
+  return `${c.white}Ask each time${c.reset} ${c.dim}· ${now}${c.reset}`;
+}
+function printAccess(view, flags) {
+  if (isTruthyFlag(flags.json)) {
+    console.log(JSON.stringify(view, null, 2));
+    return;
+  }
+  const npx = "npx @beeuni/agent-tunnel@latest";
+  blankLine();
+  field("access", describeAccess(view));
+  field("keep awake", view.keepAwakeSupported ? view.keepAwake ? `${c.white}on${c.reset}` : `${c.white}off${c.reset}` : `${c.dim}not available on this system${c.reset}`);
+  if (view.pendingRequest) {
+    field("waiting", `${c.white}${view.pendingRequest.change ? "a change asked for through Beeuni" : `an agent call (${view.pendingRequest.capability})`}${c.reset}`);
+    field("", `${c.dim}${npx} access --allow-for 60   or   --deny${c.reset}`);
+  }
+  blankLine();
+  console.log(`  ${c.dim}Change it:${c.reset} ${c.white}${npx} access ask|always|off${c.reset}${c.dim}, --allow-for <minutes>, --revoke, --deny${c.reset}`);
+  blankLine();
+}
+function commandAccess(flags) {
+  const change = {};
+  if (flags._)
+    change.mode = flags._;
+  if (flags["allow-for"] !== undefined) {
+    change.grantMinutes = Number(flags["allow-for"]);
+    if (!(change.grantMinutes > 0))
+      fail("--allow-for takes minutes, at most 1440. Example: agent-tunnel access --allow-for 60");
+  }
+  if (isTruthyFlag(flags.revoke))
+    change.revoke = true;
+  if (isTruthyFlag(flags.deny))
+    change.deny = true;
+  if (Object.keys(change).length === 0)
+    return printAccess(accessView(), flags);
+  if (change.mode !== undefined && !["ask", "always", "off"].includes(change.mode)) {
+    fail("Access is one of: ask, always, off. Example: agent-tunnel access ask");
+  }
+  if (change.grantMinutes !== undefined && change.mode === undefined && readAccess().mode !== "ask")
+    change.mode = "ask";
+  printAccess(applyAccess(change), flags);
+}
+function commandKeepAwake(flags) {
+  if (flags._ === undefined)
+    return printAccess(accessView(), flags);
+  if (flags._ !== "on" && flags._ !== "off")
+    fail("Keep awake is on or off. Example: agent-tunnel keep-awake on");
+  if (!accessView().keepAwakeSupported)
+    fail("Keep awake is not available on this system yet.");
+  printAccess(applyAccess({ keepAwake: flags._ === "on" }), flags);
+}
 var COMMANDS = {
   connect: {
     summary: "Pair this machine, then run it in the background or this terminal",
     run: commandConnect
   },
   status: { summary: "Show pairing, capabilities, and service state (--json)", run: commandStatus },
+  access: {
+    summary: "When Beeuni may use this computer: ask, always, off (--allow-for <min>, --revoke, --deny, --json)",
+    run: commandAccess
+  },
+  "keep-awake": { summary: "Keep this computer awake while connected: on, off (--json)", run: commandKeepAwake },
   logs: { summary: "Show recent service logs (--lines <n>, --all, --clear)", run: commandLogs },
   start: {
     summary: "Start the background service (resumes a paused one)",
@@ -6668,7 +6883,7 @@ var OPTIONS = [
   ["--reauth", "With connect: discard the saved credential and pair again"],
   ["--daemon / --foreground", "With connect: skip the prompt and choose the mode"],
   ["--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"],
+  ["--json", "With connect: NDJSON events, no prompts. With status, access, keep-awake, and logout: machine-readable output"],
   ["--keep-service", "With logout: keep the background service installed"]
 ];
 function showHelp() {
@@ -6700,14 +6915,14 @@ function showHelp() {
 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.`);
+  console.error(`  ${glyph.bad} --keep-awake is not a flag. Run: agent-tunnel keep-awake on`);
   process.exit(2);
 }
 var resolved = COMMANDS[command] ?? Object.values(COMMANDS).find((entry) => entry.aliases?.includes(command));
 if (!resolved) {
   showHelp();
 } else {
-  Promise.resolve(resolved.run(flags)).catch((error) => {
+  Promise.resolve().then(() => resolved.run(flags)).catch((error) => {
     fail(error instanceof Error ? error.message : String(error));
   });
 }