@parall/daemon 1.32.0 → 1.32.1

package/bundle/parall-daemon.js

@@ -17718,9 +17718,9 @@ var require_getMachineId_linux = __commonJS({
     var api_1 = (init_esm(), __toCommonJS(esm_exports));
     async function getMachineId() {
       const paths = ["/etc/machine-id", "/var/lib/dbus/machine-id"];
-      for (const path11 of paths) {
+      for (const path12 of paths) {
         try {
-          const result = await fs_1.promises.readFile(path11, { encoding: "utf8" });
+          const result = await fs_1.promises.readFile(path12, { encoding: "utf8" });
           return result.trim();
         } catch (e) {
           api_1.diag.debug(`error reading machine id: ${e}`);
@@ -21123,7 +21123,7 @@ function appendRootPathToUrlIfNeeded(url) {
     return void 0;
   }
 }
-function appendResourcePathToUrl(url, path11) {
+function appendResourcePathToUrl(url, path12) {
   try {
     new URL(url);
   } catch (_a) {
@@ -21133,11 +21133,11 @@ function appendResourcePathToUrl(url, path11) {
   if (!url.endsWith("/")) {
     url = url + "/";
   }
-  url += path11;
+  url += path12;
   try {
     new URL(url);
   } catch (_b) {
-    diag2.warn("Configuration: Provided URL appended with '" + path11 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
+    diag2.warn("Configuration: Provided URL appended with '" + path12 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
     return void 0;
   }
   return url;
@@ -26656,8 +26656,8 @@ var updater_exports = {};
 __export(updater_exports, {
   DaemonUpdater: () => DaemonUpdater
 });
-import * as fs9 from "node:fs";
-import * as path9 from "node:path";
+import * as fs10 from "node:fs";
+import * as path10 from "node:path";
 import * as https2 from "node:https";
 import * as http3 from "node:http";
 import { createHash as createHash3 } from "node:crypto";
@@ -26748,20 +26748,20 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
           return false;
         if (!state.previous_version)
           return false;
-        const previousDir = path9.join(this.bundleDir, "versions", state.previous_version);
-        if (!fs9.existsSync(previousDir))
+        const previousDir = path10.join(this.bundleDir, "versions", state.previous_version);
+        if (!fs10.existsSync(previousDir))
           return false;
         this.log.warn(`rollback: ${current.version} failed ${state.boot_count} boots, reverting to ${state.previous_version}`);
         if (process.platform === "win32") {
-          const currentDir = path9.join(this.bundleDir, "current");
-          if (fs9.existsSync(currentDir)) {
-            for (const file of fs9.readdirSync(currentDir)) {
-              fs9.unlinkSync(path9.join(currentDir, file));
+          const currentDir = path10.join(this.bundleDir, "current");
+          if (fs10.existsSync(currentDir)) {
+            for (const file of fs10.readdirSync(currentDir)) {
+              fs10.unlinkSync(path10.join(currentDir, file));
             }
           }
-          fs9.mkdirSync(currentDir, { recursive: true });
-          for (const file of fs9.readdirSync(previousDir)) {
-            fs9.copyFileSync(path9.join(previousDir, file), path9.join(currentDir, file));
+          fs10.mkdirSync(currentDir, { recursive: true });
+          for (const file of fs10.readdirSync(previousDir)) {
+            fs10.copyFileSync(path10.join(previousDir, file), path10.join(currentDir, file));
           }
         } else {
           this.swapSymlink(state.previous_version);
@@ -26869,11 +26869,11 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
             return false;
           }
         }
-        const stagingDir = path9.join(this.bundleDir, "staging");
+        const stagingDir = path10.join(this.bundleDir, "staging");
         this.cleanDir(stagingDir);
-        fs9.mkdirSync(stagingDir, { recursive: true });
+        fs10.mkdirSync(stagingDir, { recursive: true });
         for (const [filename, meta] of Object.entries(remote.files)) {
-          const filePath = path9.join(stagingDir, filename);
+          const filePath = path10.join(stagingDir, filename);
           const fileUrl = `${this.cdnBaseUrl}/${remote.version}/${filename}`;
           try {
             await this.downloadFile(fileUrl, filePath);
@@ -26882,7 +26882,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
             this.cleanDir(stagingDir);
             return false;
           }
-          const content = fs9.readFileSync(filePath);
+          const content = fs10.readFileSync(filePath);
           const hash = createHash3("sha256").update(content).digest("hex");
           if (hash !== meta.sha256) {
             this.log.error(`update: sha256 mismatch for ${filename} (expected ${meta.sha256}, got ${hash})`);
@@ -26895,7 +26895,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
             return false;
           }
         }
-        fs9.writeFileSync(path9.join(stagingDir, "manifest.json"), JSON.stringify(remote, null, 2));
+        fs10.writeFileSync(path10.join(stagingDir, "manifest.json"), JSON.stringify(remote, null, 2));
         this.atomicSwap(stagingDir, remote.version);
         const newState = {
           confirmed_version: local?.version ?? state?.confirmed_version,
@@ -26909,24 +26909,24 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
         return true;
       }
       atomicSwap(stagingDir, newVersion) {
-        const versionsDir = path9.join(this.bundleDir, "versions");
-        const targetDir = path9.join(versionsDir, newVersion);
-        const currentLink = path9.join(this.bundleDir, "current");
-        fs9.mkdirSync(versionsDir, { recursive: true });
-        if (fs9.existsSync(targetDir)) {
-          fs9.rmSync(targetDir, { recursive: true });
-        }
-        fs9.renameSync(stagingDir, targetDir);
+        const versionsDir = path10.join(this.bundleDir, "versions");
+        const targetDir = path10.join(versionsDir, newVersion);
+        const currentLink = path10.join(this.bundleDir, "current");
+        fs10.mkdirSync(versionsDir, { recursive: true });
+        if (fs10.existsSync(targetDir)) {
+          fs10.rmSync(targetDir, { recursive: true });
+        }
+        fs10.renameSync(stagingDir, targetDir);
         if (process.platform === "win32") {
           const currentDir = currentLink;
-          if (fs9.existsSync(currentDir)) {
-            for (const file of fs9.readdirSync(currentDir)) {
-              fs9.unlinkSync(path9.join(currentDir, file));
+          if (fs10.existsSync(currentDir)) {
+            for (const file of fs10.readdirSync(currentDir)) {
+              fs10.unlinkSync(path10.join(currentDir, file));
             }
           }
-          fs9.mkdirSync(currentDir, { recursive: true });
-          for (const file of fs9.readdirSync(targetDir)) {
-            fs9.copyFileSync(path9.join(targetDir, file), path9.join(currentDir, file));
+          fs10.mkdirSync(currentDir, { recursive: true });
+          for (const file of fs10.readdirSync(targetDir)) {
+            fs10.copyFileSync(path10.join(targetDir, file), path10.join(currentDir, file));
           }
         } else {
           this.swapSymlink(newVersion);
@@ -26934,14 +26934,14 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
         this.pruneOldVersions(versionsDir, newVersion);
       }
       swapSymlink(version) {
-        const currentLink = path9.join(this.bundleDir, "current");
+        const currentLink = path10.join(this.bundleDir, "current");
         const tmpLink = `${currentLink}.new`;
         try {
-          fs9.unlinkSync(tmpLink);
+          fs10.unlinkSync(tmpLink);
         } catch {
         }
-        fs9.symlinkSync(`versions/${version}`, tmpLink);
-        fs9.renameSync(tmpLink, currentLink);
+        fs10.symlinkSync(`versions/${version}`, tmpLink);
+        fs10.renameSync(tmpLink, currentLink);
       }
       pruneOldVersions(versionsDir, currentVersion) {
         const state = this.loadUpdateState();
@@ -26951,9 +26951,9 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
         if (state?.confirmed_version)
           keep.add(state.confirmed_version);
         try {
-          for (const entry of fs9.readdirSync(versionsDir)) {
+          for (const entry of fs10.readdirSync(versionsDir)) {
             if (!keep.has(entry)) {
-              fs9.rmSync(path9.join(versionsDir, entry), { recursive: true });
+              fs10.rmSync(path10.join(versionsDir, entry), { recursive: true });
             }
           }
         } catch {
@@ -26961,26 +26961,26 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
       }
       // --- Manifest & State I/O ---
       loadLocalManifest() {
-        const currentDir = path9.join(this.bundleDir, "current");
-        const manifestPath = path9.join(currentDir, "manifest.json");
+        const currentDir = path10.join(this.bundleDir, "current");
+        const manifestPath = path10.join(currentDir, "manifest.json");
         try {
-          return JSON.parse(fs9.readFileSync(manifestPath, "utf-8"));
+          return JSON.parse(fs10.readFileSync(manifestPath, "utf-8"));
         } catch {
           return null;
         }
       }
       loadUpdateState() {
-        const statePath = path9.join(this.bundleDir, "update-state.json");
+        const statePath = path10.join(this.bundleDir, "update-state.json");
         try {
-          return JSON.parse(fs9.readFileSync(statePath, "utf-8"));
+          return JSON.parse(fs10.readFileSync(statePath, "utf-8"));
         } catch {
           return null;
         }
       }
       saveUpdateState(state) {
-        const statePath = path9.join(this.bundleDir, "update-state.json");
-        fs9.mkdirSync(path9.dirname(statePath), { recursive: true });
-        fs9.writeFileSync(statePath, JSON.stringify(state, null, 2));
+        const statePath = path10.join(this.bundleDir, "update-state.json");
+        fs10.mkdirSync(path10.dirname(statePath), { recursive: true });
+        fs10.writeFileSync(statePath, JSON.stringify(state, null, 2));
       }
       // --- HTTP helpers ---
       httpGet(url, maxRedirects = 5) {
@@ -27030,14 +27030,14 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
               reject(new Error(`HTTP ${res.statusCode} for ${url}`));
               return;
             }
-            const file = fs9.createWriteStream(dest);
+            const file = fs10.createWriteStream(dest);
             res.pipe(file);
             file.on("finish", () => {
               file.close();
               resolve5();
             });
             file.on("error", (err) => {
-              fs9.unlinkSync(dest);
+              fs10.unlinkSync(dest);
               reject(err);
             });
           });
@@ -27049,7 +27049,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
       }
       cleanDir(dir) {
         try {
-          fs9.rmSync(dir, { recursive: true });
+          fs10.rmSync(dir, { recursive: true });
         } catch {
         }
       }
@@ -27506,10 +27506,10 @@ var ParallClient = class _ParallClient {
    * REFRESH_THRESHOLD_S, refresh it **before** sending the request.
    * No-op when the token is still fresh, missing, or un-parseable.
    */
-  async ensureFreshToken(path11) {
+  async ensureFreshToken(path12) {
     if (!this.token || !this.getRefreshToken)
       return;
-    const pathSuffix = path11.replace(/^\/api\/v1/, "");
+    const pathSuffix = path12.replace(/^\/api\/v1/, "");
     if (_ParallClient.AUTH_PATHS.has(pathSuffix))
       return;
     const exp = _ParallClient.decodeJwtExp(this.token);
@@ -27541,11 +27541,11 @@ var ParallClient = class _ParallClient {
       this.refreshPromise = null;
     }
   }
-  async request(method, path11, body, query, retried = false, opts) {
+  async request(method, path12, body, query, retried = false, opts) {
     if (!retried) {
-      await this.ensureFreshToken(path11);
+      await this.ensureFreshToken(path12);
     }
-    let url = `${this.baseUrl}${path11}`;
+    let url = `${this.baseUrl}${path12}`;
     if (query) {
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(query)) {
@@ -27570,12 +27570,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path11.replace(/^\/api\/v1/, "");
+      const pathSuffix = path12.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.request(method, path11, body, query, true, opts);
+          return this.request(method, path12, body, query, true, opts);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -27584,15 +27584,7 @@ var ParallClient = class _ParallClient {
     }
     if (!res.ok) {
       const rawErrorBody = await res.json().catch(() => ({}));
-      const errorBody = rawErrorBody !== null && typeof rawErrorBody === "object" ? rawErrorBody : {};
-      const errorObj = errorBody?.error && typeof errorBody.error === "object" ? errorBody.error : void 0;
-      const errMsg = errorObj?.message ?? (typeof errorBody?.error === "string" ? errorBody.error : void 0);
-      const errCode = errorObj?.code ?? (typeof errorBody?.code === "string" ? errorBody.code : void 0);
-      const apiError = new ApiError(res.status, errMsg ?? res.statusText, errCode);
-      const { error: _e, code: _c, message: _m, ...extras } = errorBody;
-      if (Object.keys(extras).length > 0)
-        apiError.extras = extras;
-      throw apiError;
+      throw buildApiError(res, rawErrorBody);
     }
     if (res.status === 204)
       return void 0;
@@ -27612,15 +27604,15 @@ var ParallClient = class _ParallClient {
    * hit the 100 MiB cap, so a longer 5-minute timeout is used so a
    * 50 MiB blob on a slow connection doesn't get chopped at 15 s.
    */
-  async multipartRequest(method, path11, body, retried = false) {
+  async multipartRequest(method, path12, body, retried = false) {
     if (!retried) {
-      await this.ensureFreshToken(path11);
+      await this.ensureFreshToken(path12);
     }
     const { "Content-Type": _drop, ...headers } = this.buildHeaders();
     void _drop;
     let res;
     try {
-      res = await fetch(`${this.baseUrl}${path11}`, {
+      res = await fetch(`${this.baseUrl}${path12}`, {
         method,
         headers,
         body,
@@ -27630,12 +27622,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path11.replace(/^\/api\/v1/, "");
+      const pathSuffix = path12.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.multipartRequest(method, path11, body, true);
+          return this.multipartRequest(method, path12, body, true);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -27644,15 +27636,7 @@ var ParallClient = class _ParallClient {
     }
     if (!res.ok) {
       const rawErrorBody = await res.json().catch(() => ({}));
-      const errorBody = rawErrorBody !== null && typeof rawErrorBody === "object" ? rawErrorBody : {};
-      const errorObj = errorBody?.error && typeof errorBody.error === "object" ? errorBody.error : void 0;
-      const errMsg = errorObj?.message ?? (typeof errorBody?.error === "string" ? errorBody.error : void 0);
-      const errCode = errorObj?.code ?? (typeof errorBody?.code === "string" ? errorBody.code : void 0);
-      const apiError = new ApiError(res.status, errMsg ?? res.statusText, errCode);
-      const { error: _e, code: _c, message: _m, ...extras } = errorBody;
-      if (Object.keys(extras).length > 0)
-        apiError.extras = extras;
-      throw apiError;
+      throw buildApiError(res, rawErrorBody);
     }
     if (res.status === 204)
       return void 0;
@@ -28233,8 +28217,8 @@ var ParallClient = class _ParallClient {
   async requestMachineUpdate(orgId, machineId, mandatory = false) {
     await this.request("POST", ENDPOINTS.MACHINE_REQUEST_UPDATE(orgId, machineId), { mandatory });
   }
-  async browseMachineFilesystem(orgId, machineId, path11) {
-    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path11 }, void 0, false, { timeoutMs: 15e3 });
+  async browseMachineFilesystem(orgId, machineId, path12) {
+    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path12 }, void 0, false, { timeoutMs: 15e3 });
   }
   /** Create a new machine key. Returns the raw key string (shown once) + metadata. */
   async createMachineKey(orgId, machineId, name) {
@@ -28334,15 +28318,7 @@ var ParallClient = class _ParallClient {
       return null;
     if (!res.ok) {
       const rawErrorBody = await res.json().catch(() => ({}));
-      const errorBody = rawErrorBody !== null && typeof rawErrorBody === "object" ? rawErrorBody : {};
-      const errorObj = errorBody?.error && typeof errorBody.error === "object" ? errorBody.error : void 0;
-      const errMsg = errorObj?.message ?? (typeof errorBody?.error === "string" ? errorBody.error : void 0);
-      const errCode = errorObj?.code ?? (typeof errorBody?.code === "string" ? errorBody.code : void 0);
-      const apiError = new ApiError(res.status, errMsg ?? res.statusText, errCode);
-      const { error: _e, code: _c, message: _m, ...extras } = errorBody;
-      if (Object.keys(extras).length > 0)
-        apiError.extras = extras;
-      throw apiError;
+      throw buildApiError(res, rawErrorBody);
     }
     return res.json();
   }
@@ -28603,8 +28579,8 @@ var ParallClient = class _ParallClient {
   async deleteWikiPathScope(orgId, wikiId, scopeId) {
     await this.request("DELETE", ENDPOINTS.WIKI_PATH_SCOPE(orgId, wikiId, scopeId));
   }
-  async getWikiAccessStatus(orgId, wikiId, path11) {
-    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path11 ? { path: path11 } : void 0);
+  async getWikiAccessStatus(orgId, wikiId, path12) {
+    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path12 ? { path: path12 } : void 0);
   }
   async createWikiAccessRequest(orgId, wikiId, data) {
     await this.request("POST", ENDPOINTS.WIKI_ACCESS_REQUESTS(orgId, wikiId), data);
@@ -28613,14 +28589,14 @@ var ParallClient = class _ParallClient {
   async getWikiCommits(orgId, wikiId, params) {
     return this.request("GET", ENDPOINTS.WIKI_COMMITS(orgId, wikiId), void 0, params);
   }
-  async getWikiFileCommits(orgId, wikiId, path11, params) {
+  async getWikiFileCommits(orgId, wikiId, path12, params) {
     return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, {
-      path: path11,
+      path: path12,
       ...params
     });
   }
-  async getWikiBlame(orgId, wikiId, path11, ref) {
-    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path11, ref });
+  async getWikiBlame(orgId, wikiId, path12, ref) {
+    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path12, ref });
   }
   // ---- Wiki Operations (audit log) ----
   async getWikiOperations(orgId, wikiId, params) {
@@ -28808,6 +28784,12 @@ var ApiError = class extends Error {
   status;
   code;
   extras;
+  /** Attempted action (authorization denials) — e.g. "chat.add_member". */
+  action;
+  /** Target resource URI that was evaluated — e.g. "prll://cht_…". */
+  resourceUri;
+  /** Whether the action is approval-executable (PERMISSION_DENIED only). */
+  approvable;
   constructor(status, message, code) {
     super(message);
     this.status = status;
@@ -28815,6 +28797,33 @@ var ApiError = class extends Error {
     this.name = "ApiError";
   }
 };
+function buildApiError(res, rawErrorBody) {
+  const errorBody = rawErrorBody !== null && typeof rawErrorBody === "object" ? rawErrorBody : {};
+  const errorObj = errorBody.error && typeof errorBody.error === "object" ? errorBody.error : void 0;
+  const errMsg = (typeof errorObj?.message === "string" ? errorObj.message : void 0) ?? (typeof errorBody.message === "string" ? errorBody.message : void 0) ?? (typeof errorBody.error === "string" ? errorBody.error : void 0);
+  const errCode = (typeof errorObj?.code === "string" ? errorObj.code : void 0) ?? (typeof errorBody.code === "string" ? errorBody.code : void 0);
+  const apiError = new ApiError(res.status, errMsg ?? res.statusText, errCode);
+  const anchors = errorObj ?? errorBody;
+  if (typeof anchors.action === "string")
+    apiError.action = anchors.action;
+  if (typeof anchors.resource_uri === "string")
+    apiError.resourceUri = anchors.resource_uri;
+  if (typeof anchors.approvable === "boolean")
+    apiError.approvable = anchors.approvable;
+  const structural = /* @__PURE__ */ new Set(["error", "code", "message", "status"]);
+  const extras = {};
+  for (const [k, v] of Object.entries(errorBody))
+    if (!structural.has(k))
+      extras[k] = v;
+  if (errorObj) {
+    for (const [k, v] of Object.entries(errorObj))
+      if (!structural.has(k))
+        extras[k] = v;
+  }
+  if (Object.keys(extras).length > 0)
+    apiError.extras = extras;
+  return apiError;
+}
 
 // ts/sdk/dist/ws.js
 function isRetryableNetworkError(err) {
@@ -29283,8 +29292,8 @@ init_config();
 
 // ts/daemon/dist/supervisor.js
 import { spawn as spawn3 } from "node:child_process";
-import * as fs8 from "node:fs";
-import * as path8 from "node:path";
+import * as fs9 from "node:fs";
+import * as path9 from "node:path";
 
 // ts/daemon/dist/filesystem.js
 import * as fs2 from "fs";
@@ -29913,9 +29922,8 @@ function isNodeError(err) {
 }
 
 // ts/daemon/dist/clip-runtime/process-manager.js
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
-import { execFileSync } from "node:child_process";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
 
 // ts/daemon/dist/clip-runtime/process.js
 import { spawn as spawn2 } from "node:child_process";
@@ -30487,6 +30495,39 @@ var ClipProcess = class {
   }
 };
 
+// ts/daemon/dist/clip-runtime/bun-resolver.js
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+import { execFileSync } from "node:child_process";
+function findBunBinary() {
+  const isWindows = process.platform === "win32";
+  const binName = isWindows ? "bun.exe" : "bun";
+  const embedded = path6.join(path6.dirname(process.execPath), binName);
+  if (fs6.existsSync(embedded))
+    return embedded;
+  if (!isWindows) {
+    const candidates = [
+      path6.join(process.env.HOME || "", ".bun", "bin", "bun"),
+      "/usr/local/bin/bun",
+      "/opt/homebrew/bin/bun"
+    ];
+    for (const candidate of candidates) {
+      if (fs6.existsSync(candidate))
+        return candidate;
+    }
+  }
+  const lookupCmd = isWindows ? "where.exe" : "which";
+  const lookupArg = isWindows ? "bun.exe" : "bun";
+  try {
+    const result = execFileSync(lookupCmd, [lookupArg], { encoding: "utf-8" }).trim();
+    const firstLine = result.split("\n")[0]?.trim();
+    if (firstLine)
+      return firstLine;
+  } catch {
+  }
+  throw new Error("bun binary not found \u2014 install Bun (https://bun.sh) or set bunPath option");
+}
+
 // ts/daemon/dist/clip-runtime/process-manager.js
 var ClipProcessManager = class {
   bunPath;
@@ -30664,10 +30705,10 @@ var ClipProcessManager = class {
    * Reads clip-config.json if present, or scans subdirectories for clip.json files.
    */
   async loadInstalledClips() {
-    const configFile = path6.join(path6.dirname(this.clipsDir), "clip-config.json");
-    if (fs6.existsSync(configFile)) {
+    const configFile = path7.join(path7.dirname(this.clipsDir), "clip-config.json");
+    if (fs7.existsSync(configFile)) {
       try {
-        const content = fs6.readFileSync(configFile, "utf-8");
+        const content = fs7.readFileSync(configFile, "utf-8");
         const configs = JSON.parse(content);
         for (const config of configs) {
           this.registerClip(config);
@@ -30677,18 +30718,18 @@ var ClipProcessManager = class {
         console.warn("[clip-manager] failed to parse clip-config.json, scanning directory");
       }
     }
-    if (!fs6.existsSync(this.clipsDir))
+    if (!fs7.existsSync(this.clipsDir))
       return;
-    const entries = fs6.readdirSync(this.clipsDir, { withFileTypes: true });
+    const entries = fs7.readdirSync(this.clipsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const clipDir = path6.join(this.clipsDir, entry.name);
-      const clipJsonPath = path6.join(clipDir, "clip.json");
-      const pkgJsonPath = path6.join(clipDir, "package.json");
-      if (fs6.existsSync(clipJsonPath)) {
+      const clipDir = path7.join(this.clipsDir, entry.name);
+      const clipJsonPath = path7.join(clipDir, "clip.json");
+      const pkgJsonPath = path7.join(clipDir, "package.json");
+      if (fs7.existsSync(clipJsonPath)) {
         try {
-          const clipJson = JSON.parse(fs6.readFileSync(clipJsonPath, "utf-8"));
+          const clipJson = JSON.parse(fs7.readFileSync(clipJsonPath, "utf-8"));
           this.registerClip({
             name: clipJson.name || entry.name,
             package: clipJson.name,
@@ -30699,9 +30740,9 @@ var ClipProcessManager = class {
         } catch {
           console.warn(`[clip-manager] failed to parse clip.json in ${clipDir}`);
         }
-      } else if (fs6.existsSync(pkgJsonPath)) {
+      } else if (fs7.existsSync(pkgJsonPath)) {
         try {
-          const pkgJson = JSON.parse(fs6.readFileSync(pkgJsonPath, "utf-8"));
+          const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
           this.registerClip({
             name: pkgJson.name || entry.name,
             package: pkgJson.name,
@@ -30740,8 +30781,14 @@ var ClipProcessManager = class {
   async spawnProcess(config) {
     const proc = new ClipProcess(config);
     const clipDataDir = this.ensureClipDataDir(config);
-    proc.spawn(this.resolveBun(), {
-      PINIX_DATA_DIR: clipDataDir
+    const bunPath = this.resolveBun();
+    proc.spawn(bunPath, {
+      PINIX_DATA_DIR: clipDataDir,
+      // Expose the embedded bun's directory on the clip's PATH so a clip that
+      // shells out to `bun` by name resolves it — the daemon's launchd PATH
+      // does not include Frameworks/. Symmetric with installDeps(); relies on
+      // the embedded binary being named `bun` (Frameworks/bun).
+      PATH: `${path7.dirname(bunPath)}${path7.delimiter}${process.env.PATH ?? ""}`
     });
     this.setStatus(config.name, "running", "starting");
     try {
@@ -30770,8 +30817,8 @@ var ClipProcessManager = class {
     return proc;
   }
   ensureClipDataDir(config) {
-    const dir = path6.join(this.dataDir, config.name);
-    fs6.mkdirSync(dir, { recursive: true });
+    const dir = path7.join(this.dataDir, config.name);
+    fs7.mkdirSync(dir, { recursive: true });
     return dir;
   }
   removeIfSame(name, proc) {
@@ -30789,30 +30836,6 @@ var ClipProcessManager = class {
     }
   }
 };
-function findBunBinary() {
-  const isWindows = process.platform === "win32";
-  if (!isWindows) {
-    const candidates = [
-      path6.join(process.env.HOME || "", ".bun", "bin", "bun"),
-      "/usr/local/bin/bun",
-      "/opt/homebrew/bin/bun"
-    ];
-    for (const candidate of candidates) {
-      if (fs6.existsSync(candidate))
-        return candidate;
-    }
-  }
-  const lookupCmd = isWindows ? "where.exe" : "which";
-  const lookupArg = isWindows ? "bun.exe" : "bun";
-  try {
-    const result = execFileSync(lookupCmd, [lookupArg], { encoding: "utf-8" }).trim();
-    const firstLine = result.split("\n")[0]?.trim();
-    if (firstLine)
-      return firstLine;
-  } catch {
-  }
-  throw new Error("bun binary not found \u2014 install Bun (https://bun.sh) or set bunPath option");
-}
 
 // ts/daemon/dist/clip-runtime/clip-provider.js
 import * as http2 from "node:http2";
@@ -30995,7 +31018,7 @@ var ClipProvider = class _ClipProvider {
         void this.openStream();
         return;
       }
-      this.sendProviderMessage({ heartbeat: {} }).catch((err) => {
+      this.sendProviderMessage({ ping: { sentAtUnixMs: Date.now() } }).catch((err) => {
         this.opts.log.warn(`[clip-provider] heartbeat send failed: ${String(err)}`);
       });
     }, _ClipProvider.HEARTBEAT_INTERVAL_MS);
@@ -31024,12 +31047,12 @@ var ClipProvider = class _ClipProvider {
   // ---------------------------------------------------------------------------
   subscribeStatusChanges() {
     const mgr = this.opts.clipManager;
-    this.statusUnsubscribe = mgr.addStatusListener((name, status, _message) => {
+    this.statusUnsubscribe = mgr.addStatusListener((name, status, message) => {
       if (!this.connected)
         return;
-      const protoStatus = status === "running" ? "CLIP_ONLINE_STATUS_ONLINE" : status === "error" ? "CLIP_ONLINE_STATUS_ERROR" : "CLIP_ONLINE_STATUS_OFFLINE";
+      const protoStatus = status === "running" ? "CLIP_STATUS_RUNNING" : status === "error" ? "CLIP_STATUS_ERROR" : "CLIP_STATUS_SLEEPING";
       this.sendProviderMessage({
-        clipStatusChanged: { alias: name, status: protoStatus }
+        clipStatusChanged: { name, status: protoStatus, message }
       }).catch((err) => {
         this.opts.log.warn(`[clip-provider] status change send failed: ${String(err)}`);
       });
@@ -31048,18 +31071,16 @@ var ClipProvider = class _ClipProvider {
   // Message handling
   // ---------------------------------------------------------------------------
   handleHubMessage(msg) {
-    if (msg.registered) {
-      this.handleRegistered(msg.registered);
+    if (msg.registerResponse) {
+      this.handleRegistered(msg.registerResponse);
     } else if (msg.invokeCommand) {
       void this.handleInvokeCommand(msg.invokeCommand);
-    } else if (msg.heartbeat !== void 0) {
-      this.sendProviderMessage({ heartbeat: {} }).catch(() => {
-      });
+    } else if (msg.pong !== void 0) {
     }
   }
   handleRegistered(reg) {
     if (reg.accepted) {
-      this.opts.log.info(`[clip-provider] registered with hub (org=${reg.orgId})`);
+      this.opts.log.info(`[clip-provider] registered with hub (org=${this.opts.orgId})`);
       this.connected = true;
       this.reconnectAttempt = 0;
       this.startHeartbeat();
@@ -31071,7 +31092,7 @@ var ClipProvider = class _ClipProvider {
     }
   }
   async handleInvokeCommand(cmd) {
-    const { requestId, clipAlias, commandName } = cmd;
+    const { requestId, clipName, command } = cmd;
     const timeoutMs = cmd.timeoutMs ?? 3e4;
     try {
       let input;
@@ -31085,7 +31106,7 @@ var ClipProvider = class _ClipProvider {
       }
       let timer;
       const output = await Promise.race([
-        this.opts.clipManager.invoke(clipAlias, commandName, input),
+        this.opts.clipManager.invoke(clipName, command, input),
         new Promise((_, reject) => {
           timer = setTimeout(() => reject(new Error("invoke timeout")), timeoutMs);
         })
@@ -31102,7 +31123,10 @@ var ClipProvider = class _ClipProvider {
       await this.sendProviderMessage({
         invokeResult: {
           requestId,
-          error: isCommandError ? err.message : String(err),
+          error: {
+            code: isCommandError ? "CLIP_COMMAND_ERROR" : "INVOKE_FAILED",
+            message: isCommandError ? err.message : String(err)
+          },
           errorIsCommand: isCommandError,
           done: true
         }
@@ -31118,8 +31142,7 @@ var ClipProvider = class _ClipProvider {
     await this.sendProviderMessage({
       register: {
         providerName: this.opts.providerName,
-        clips,
-        orgId: this.opts.orgId
+        clips
       }
     });
   }
@@ -31147,26 +31170,50 @@ var ClipProvider = class _ClipProvider {
   clipConfigToRegistration(clip) {
     const manifest = clip.manifest;
     const commands = manifest ? manifest.commandDetails.map((cmd) => this.commandDetailToInfo(cmd)) : [];
+    const pkg = manifest?.package ?? clip.package ?? clip.name;
     return {
       alias: clip.name,
-      name: manifest?.package ?? clip.package ?? clip.name,
+      package: pkg,
       version: manifest?.version ?? clip.version ?? "",
-      commands
+      domain: manifest?.domain,
+      commands,
+      hasWeb: manifest?.hasWeb ?? false,
+      dependencies: this.dependencyNames(manifest?.dependencies),
+      tokenProtected: Boolean(clip.token),
+      name: pkg,
+      patterns: manifest?.patterns,
+      entities: this.stringEntities(manifest?.entities),
+      description: manifest?.description
     };
   }
   commandDetailToInfo(detail) {
     return {
       name: detail.name,
       description: detail.description ?? "",
-      inputSchema: detail.input ? Buffer.from(detail.input, "utf-8").toString("base64") : void 0,
-      outputSchema: detail.output ? Buffer.from(detail.output, "utf-8").toString("base64") : void 0
+      input: detail.input,
+      output: detail.output
     };
   }
+  dependencyNames(deps) {
+    if (!deps)
+      return void 0;
+    const names = Object.entries(deps).map(([slot, dep]) => dep.package ?? slot).filter((name) => name.length > 0);
+    return names.length > 0 ? names : void 0;
+  }
+  stringEntities(entities) {
+    if (!entities)
+      return void 0;
+    const out = {};
+    for (const [key, value] of Object.entries(entities)) {
+      out[key] = typeof value === "string" ? value : JSON.stringify(value);
+    }
+    return out;
+  }
 };
 
 // ts/daemon/dist/clip-runtime/clip-installer.js
-import * as fs7 from "node:fs";
-import * as path7 from "node:path";
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
 import * as crypto from "node:crypto";
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { pipeline } from "node:stream/promises";
@@ -31245,7 +31292,7 @@ async function httpDownload(url, destPath, maxRedirects = 10) {
         reject(new Error(`download failed: HTTP ${res.statusCode} for ${url}`));
         return;
       }
-      const ws = fs7.createWriteStream(destPath);
+      const ws = fs8.createWriteStream(destPath);
       pipeline(res, ws).then(resolve5, reject);
     });
     req.on("error", reject);
@@ -31377,11 +31424,11 @@ function verifyChecksum(filePath, algo, expectedHex) {
     return;
   }
   const hash = crypto.createHash(algo);
-  const content = fs7.readFileSync(filePath);
+  const content = fs8.readFileSync(filePath);
   hash.update(content);
   const actual = hash.digest("hex");
   if (actual !== expectedHex) {
-    throw new Error(`checksum mismatch for ${path7.basename(filePath)}: expected ${algo}:${expectedHex}, got ${algo}:${actual}`);
+    throw new Error(`checksum mismatch for ${path8.basename(filePath)}: expected ${algo}:${expectedHex}, got ${algo}:${actual}`);
   }
 }
 function validateTarEntries(tarballPath) {
@@ -31398,18 +31445,18 @@ function validateTarEntries(tarballPath) {
     const trimmed = entry.trim();
     if (!trimmed)
       continue;
-    if (path7.isAbsolute(trimmed)) {
+    if (path8.isAbsolute(trimmed)) {
       throw new Error(`tarball contains absolute path: "${trimmed}"`);
     }
-    const normalized = path7.normalize(trimmed);
-    if (normalized.startsWith("..") || normalized.includes(`${path7.sep}..${path7.sep}`)) {
+    const normalized = path8.normalize(trimmed);
+    if (normalized.startsWith("..") || normalized.includes(`${path8.sep}..${path8.sep}`)) {
       throw new Error(`tarball contains path traversal: "${trimmed}"`);
     }
   }
 }
 function extractTarball(tarballPath, destDir) {
   const stripComponents = detectStripComponents(tarballPath);
-  fs7.mkdirSync(destDir, { recursive: true });
+  fs8.mkdirSync(destDir, { recursive: true });
   try {
     execFileSync2("tar", [
       "xzf",
@@ -31450,74 +31497,95 @@ function detectStripComponents(tarballPath) {
   return commonPrefix ? 1 : 0;
 }
 function installDeps(clipDir) {
-  const pkgJsonPath = path7.join(clipDir, "package.json");
-  if (!fs7.existsSync(pkgJsonPath))
+  const pkgJsonPath = path8.join(clipDir, "package.json");
+  if (!fs8.existsSync(pkgJsonPath))
     return;
   let hasDeps = false;
   try {
-    const pkg = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
     hasDeps = !!(pkg.dependencies && Object.keys(pkg.dependencies).length > 0);
   } catch {
   }
-  const runners = [
-    { cmd: "bun", args: ["install", "--frozen-lockfile"] },
-    { cmd: "bun", args: ["install"] },
-    { cmd: "npm", args: ["install", "--production"] }
-  ];
-  for (const runner of runners) {
-    try {
-      execFileSync2(runner.cmd, runner.args, {
-        cwd: clipDir,
-        stdio: "pipe",
-        timeout: 12e4
-      });
-      return;
-    } catch {
+  const failures = [];
+  let bunPath = null;
+  try {
+    bunPath = findBunBinary();
+  } catch (err) {
+    failures.push(`resolve bun: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (bunPath) {
+    const bunEnv = {
+      ...process.env,
+      PATH: `${path8.dirname(bunPath)}${path8.delimiter}${process.env.PATH ?? ""}`
+    };
+    for (const args of [["install", "--frozen-lockfile"], ["install"]]) {
+      try {
+        execFileSync2(bunPath, args, {
+          cwd: clipDir,
+          stdio: "pipe",
+          timeout: 12e4,
+          env: bunEnv
+        });
+        return;
+      } catch (err) {
+        failures.push(`bun ${args.join(" ")}: ${err instanceof Error ? err.message : String(err)}`);
+      }
     }
   }
+  try {
+    execFileSync2("npm", ["install", "--production"], {
+      cwd: clipDir,
+      stdio: "pipe",
+      timeout: 12e4
+    });
+    return;
+  } catch (err) {
+    failures.push(`npm install: ${err instanceof Error ? err.message : String(err)}`);
+  }
   if (hasDeps) {
-    throw new Error(`failed to install dependencies in ${clipDir} \u2014 clip declares dependencies but no package manager succeeded`);
+    throw new Error(`failed to install dependencies in ${clipDir} \u2014 clip declares dependencies but no package manager succeeded:
+  ${failures.join("\n  ")}`);
   }
-  console.warn(`[clip-installer] could not run package manager in ${clipDir} (no dependencies declared, continuing)`);
+  console.warn(`[clip-installer] could not run a package manager in ${clipDir} (no dependencies declared, continuing): ${failures.join("; ")}`);
 }
 async function installClip(opts) {
   const registryUrl = (opts.registryUrl ?? DEFAULT_REGISTRY_URL).replace(/\/+$/, "");
   const parsed = parseSource(opts.source);
   const alias = opts.alias ?? deriveAlias(parsed);
-  const destDir = path7.join(opts.clipsDir, alias);
+  const destDir = path8.join(opts.clipsDir, alias);
   const versionMeta = await resolveVersionMeta(registryUrl, parsed);
-  const tmpDir = path7.join(opts.clipsDir, `.tmp-${alias}-${Date.now()}`);
-  fs7.mkdirSync(tmpDir, { recursive: true });
-  const tarballPath = path7.join(tmpDir, `${alias}-${versionMeta.version}.tgz`);
-  const stageDir = path7.join(tmpDir, "stage");
+  const tmpDir = path8.join(opts.clipsDir, `.tmp-${alias}-${Date.now()}`);
+  fs8.mkdirSync(tmpDir, { recursive: true });
+  const tarballPath = path8.join(tmpDir, `${alias}-${versionMeta.version}.tgz`);
+  const stageDir = path8.join(tmpDir, "stage");
   try {
     await httpDownload(versionMeta.tarball, tarballPath);
     verifyChecksum(tarballPath, versionMeta.checksumAlgo, versionMeta.checksumHex);
     validateTarEntries(tarballPath);
     extractTarball(tarballPath, stageDir);
     installDeps(stageDir);
-    const backupDir = path7.join(opts.clipsDir, `.backup-${alias}-${Date.now()}`);
+    const backupDir = path8.join(opts.clipsDir, `.backup-${alias}-${Date.now()}`);
     let backedUp = false;
     try {
-      if (fs7.existsSync(destDir)) {
-        fs7.renameSync(destDir, backupDir);
+      if (fs8.existsSync(destDir)) {
+        fs8.renameSync(destDir, backupDir);
         backedUp = true;
       }
-      fs7.renameSync(stageDir, destDir);
+      fs8.renameSync(stageDir, destDir);
       if (backedUp) {
-        fs7.rmSync(backupDir, { recursive: true, force: true });
+        fs8.rmSync(backupDir, { recursive: true, force: true });
       }
     } catch (swapErr) {
-      if (backedUp && !fs7.existsSync(destDir)) {
+      if (backedUp && !fs8.existsSync(destDir)) {
         try {
-          fs7.renameSync(backupDir, destDir);
+          fs8.renameSync(backupDir, destDir);
         } catch {
         }
       }
       throw swapErr;
     }
   } finally {
-    fs7.rmSync(tmpDir, { recursive: true, force: true });
+    fs8.rmSync(tmpDir, { recursive: true, force: true });
   }
   return {
     alias,
@@ -31599,8 +31667,8 @@ var DaemonSupervisor = class {
     this.migrateFlatLayout();
     if (process.env.PRLL_CLIP_RUNTIME_ENABLED === "true") {
       this.clipManager = new ClipProcessManager({
-        clipsDir: path8.join(this.config.rootStateDir, "clips"),
-        dataDir: path8.join(this.config.rootStateDir, "clip-data")
+        clipsDir: path9.join(this.config.rootStateDir, "clips"),
+        dataDir: path9.join(this.config.rootStateDir, "clip-data")
       });
       try {
         await this.clipManager.loadInstalledClips();
@@ -31827,15 +31895,15 @@ var DaemonSupervisor = class {
    */
   migrateFlatLayout() {
     const root = this.config.rootStateDir;
-    const agentsDir = path8.join(root, "agents");
-    const flatWorkspace = path8.join(root, "workspace");
-    if (!fs8.existsSync(flatWorkspace) || fs8.existsSync(agentsDir))
+    const agentsDir = path9.join(root, "agents");
+    const flatWorkspace = path9.join(root, "workspace");
+    if (!fs9.existsSync(flatWorkspace) || fs9.existsSync(agentsDir))
       return;
     let ownerAgentId;
-    const sessionsDir = path8.join(root, "sessions");
-    if (fs8.existsSync(sessionsDir)) {
+    const sessionsDir = path9.join(root, "sessions");
+    if (fs9.existsSync(sessionsDir)) {
       try {
-        for (const file of fs8.readdirSync(sessionsDir)) {
+        for (const file of fs9.readdirSync(sessionsDir)) {
           if (!file.endsWith(".json"))
             continue;
           const decoded = Buffer.from(file.replace(".json", ""), "base64url").toString();
@@ -31849,13 +31917,13 @@ var DaemonSupervisor = class {
       }
     }
     const targetId = ownerAgentId ?? "_orphan";
-    const targetDir = path8.join(agentsDir, targetId);
+    const targetDir = path9.join(agentsDir, targetId);
     try {
-      fs8.mkdirSync(targetDir, { recursive: true });
+      fs9.mkdirSync(targetDir, { recursive: true });
       for (const sub of ["workspace", "sessions", "dispatch-context"]) {
-        const src = path8.join(root, sub);
-        if (fs8.existsSync(src)) {
-          fs8.renameSync(src, path8.join(targetDir, sub));
+        const src = path9.join(root, sub);
+        if (fs9.existsSync(src)) {
+          fs9.renameSync(src, path9.join(targetDir, sub));
         }
       }
       this.log.info(`migrated legacy flat state \u2192 agents/${targetId}/`);
@@ -31950,7 +32018,7 @@ var DaemonSupervisor = class {
         });
         return true;
       }
-      const clipsDir = path8.join(this.config.rootStateDir, "clips");
+      const clipsDir = path9.join(this.config.rootStateDir, "clips");
       let source = data.source_ref;
       if (data.version) {
         let sourceHasVersion = false;
@@ -32136,9 +32204,9 @@ var DaemonSupervisor = class {
     const isK8s = !!process.env.KUBERNETES_SERVICE_HOST;
     const claudeHome = isK8s ? agentClaudeHomeFor(this.config.rootClaudeHome, agentId) : this.config.rootClaudeHome;
     try {
-      fs8.mkdirSync(stateDir, { recursive: true });
+      fs9.mkdirSync(stateDir, { recursive: true });
       if (isK8s) {
-        fs8.mkdirSync(claudeHome, { recursive: true });
+        fs9.mkdirSync(claudeHome, { recursive: true });
         this.ensureSharedCredentialLink(claudeHome, agentId);
       }
     } catch (err) {
@@ -32276,31 +32344,31 @@ var DaemonSupervisor = class {
     });
   }
   ensureSharedCredentialLink(agentClaudeHome, agentId) {
-    const sharedCredentials = path8.resolve(sharedClaudeCredentialsFileFor(this.config.rootClaudeHome));
+    const sharedCredentials = path9.resolve(sharedClaudeCredentialsFileFor(this.config.rootClaudeHome));
     const agentCredentials = agentClaudeCredentialsFileFor(agentClaudeHome);
-    const agentCredentialsDir = path8.dirname(agentCredentials);
-    fs8.mkdirSync(path8.dirname(sharedCredentials), { recursive: true });
-    fs8.mkdirSync(agentCredentialsDir, { recursive: true });
+    const agentCredentialsDir = path9.dirname(agentCredentials);
+    fs9.mkdirSync(path9.dirname(sharedCredentials), { recursive: true });
+    fs9.mkdirSync(agentCredentialsDir, { recursive: true });
     try {
-      const existing = fs8.lstatSync(agentCredentials);
+      const existing = fs9.lstatSync(agentCredentials);
       if (existing.isSymbolicLink()) {
-        const currentTarget = fs8.readlinkSync(agentCredentials);
-        if (path8.resolve(agentCredentialsDir, currentTarget) === sharedCredentials) {
+        const currentTarget = fs9.readlinkSync(agentCredentials);
+        if (path9.resolve(agentCredentialsDir, currentTarget) === sharedCredentials) {
           return;
         }
-        fs8.unlinkSync(agentCredentials);
+        fs9.unlinkSync(agentCredentials);
       } else if (existing.isDirectory()) {
         this.log.warn(`agent ${agentId}: credential path is a directory, cannot link ${agentCredentials}`);
         return;
       } else {
-        fs8.unlinkSync(agentCredentials);
+        fs9.unlinkSync(agentCredentials);
       }
     } catch (err) {
       if (err.code !== "ENOENT") {
         throw err;
       }
     }
-    fs8.symlinkSync(sharedCredentials, agentCredentials);
+    fs9.symlinkSync(sharedCredentials, agentCredentials);
   }
 };
 
@@ -32309,8 +32377,8 @@ init_updater();
 
 // ts/daemon/dist/cli.js
 init_config();
-import * as fs10 from "node:fs";
-import * as path10 from "node:path";
+import * as fs11 from "node:fs";
+import * as path11 from "node:path";
 import * as os3 from "node:os";
 import * as readline from "node:readline";
 import { spawn as spawn4, execSync } from "node:child_process";
@@ -32318,15 +32386,15 @@ var CONFIG_DIR = daemonConfigDir();
 var CONFIG_PATH = daemonConfigPath();
 function readConfig() {
   try {
-    return JSON.parse(fs10.readFileSync(CONFIG_PATH, "utf-8"));
+    return JSON.parse(fs11.readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeConfig(config) {
-  fs10.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
-  fs10.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
-  fs10.chmodSync(CONFIG_PATH, 384);
+  fs11.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  fs11.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
+  fs11.chmodSync(CONFIG_PATH, 384);
 }
 function prompt(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -32345,10 +32413,10 @@ function isLinux() {
 }
 var PLIST_LABEL = "com.parall.daemon";
 function plistPath() {
-  return path10.join(os3.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+  return path11.join(os3.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
 }
 function systemdUnitPath() {
-  return path10.join(os3.homedir(), ".config", "systemd", "user", "parall-daemon.service");
+  return path11.join(os3.homedir(), ".config", "systemd", "user", "parall-daemon.service");
 }
 function getDaemonBin() {
   try {
@@ -32358,7 +32426,7 @@ function getDaemonBin() {
   }
 }
 function generatePlist(daemonBin) {
-  const logPath = path10.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
+  const logPath = path11.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -32407,16 +32475,16 @@ function installService() {
   }
   const bin = getDaemonBin();
   if (isMacOS()) {
-    const dir = path10.dirname(plistPath());
-    fs10.mkdirSync(dir, { recursive: true });
-    fs10.writeFileSync(plistPath(), generatePlist(bin));
+    const dir = path11.dirname(plistPath());
+    fs11.mkdirSync(dir, { recursive: true });
+    fs11.writeFileSync(plistPath(), generatePlist(bin));
     execSync(`launchctl bootout gui/$(id -u) ${plistPath()} 2>/dev/null || true`);
     execSync(`launchctl bootstrap gui/$(id -u) ${plistPath()}`);
     console.log(`launchd agent installed: ${plistPath()}`);
   } else if (isLinux()) {
-    const dir = path10.dirname(systemdUnitPath());
-    fs10.mkdirSync(dir, { recursive: true });
-    fs10.writeFileSync(systemdUnitPath(), generateSystemdUnit(bin));
+    const dir = path11.dirname(systemdUnitPath());
+    fs11.mkdirSync(dir, { recursive: true });
+    fs11.writeFileSync(systemdUnitPath(), generateSystemdUnit(bin));
     execSync("systemctl --user daemon-reload");
     execSync("systemctl --user enable --now parall-daemon");
     console.log(`systemd service installed: ${systemdUnitPath()}`);
@@ -32483,8 +32551,8 @@ function cmdLogs(lines) {
     child2.on("exit", (code) => process.exit(code ?? 0));
     return;
   }
-  const logPath = path10.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
-  if (!fs10.existsSync(logPath)) {
+  const logPath = path11.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
+  if (!fs11.existsSync(logPath)) {
     console.log("No log file found at", logPath);
     return;
   }
@@ -32494,14 +32562,14 @@ function cmdLogs(lines) {
 function cmdServiceUninstall() {
   if (isMacOS()) {
     execSync(`launchctl bootout gui/$(id -u) ${plistPath()} 2>/dev/null || true`);
-    if (fs10.existsSync(plistPath()))
-      fs10.unlinkSync(plistPath());
+    if (fs11.existsSync(plistPath()))
+      fs11.unlinkSync(plistPath());
     console.log("launchd agent uninstalled.");
   } else if (isLinux()) {
     execSync("systemctl --user stop parall-daemon 2>/dev/null || true");
     execSync("systemctl --user disable parall-daemon 2>/dev/null || true");
-    if (fs10.existsSync(systemdUnitPath()))
-      fs10.unlinkSync(systemdUnitPath());
+    if (fs11.existsSync(systemdUnitPath()))
+      fs11.unlinkSync(systemdUnitPath());
     execSync("systemctl --user daemon-reload");
     console.log("systemd service uninstalled.");
   } else {