@parall/daemon 1.42.1 → 1.43.0

package/bundle/manifest.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.42.1",
-  "built_at": "2026-07-11T03:40:29.108Z",
+  "version": "1.43.0",
+  "built_at": "2026-07-13T04:04:48.217Z",
   "min_node_version": "20.0.0",
   "files": {
     "bb-browser-daemon.js": {
@@ -16,25 +16,29 @@
       "size": 18
     },
     "parall-browser-pod.js": {
-      "sha256": "4e98a70b593c352f4fa99cd2ff8b350346437942bd1134e3d500211585c5a94a",
-      "size": 1699246
+      "sha256": "464b249ca4be9ed4ebc520220f11b94fe78c4ceedda8cbfd3dee7c7e02ae4c38",
+      "size": 1699655
+    },
+    "parall-channel-exec.js": {
+      "sha256": "32c438151df40ccda7491c57bfa0cd9d6c4d762755353c6c751d5793af57b971",
+      "size": 7097
     },
     "parall-claude-agent.js": {
-      "sha256": "8d7d9a8c8b6d1d90f7e84489fd05c059c5c5d24d321274ff3916f12454df2e19",
-      "size": 1626635
+      "sha256": "084f01f1e64aa582dde65ee1eaf3d85a99b7960451a55b1157cb2ad61816d7bd",
+      "size": 1639412
     },
     "parall-codex-agent.js": {
-      "sha256": "5ab229def8061ab05bc040571d5cb175bb7c9d8fce565682ab04c6b1a81b8649",
-      "size": 1664012
+      "sha256": "4fa941ad4643333e97feb88dd728ec0badebc5cba21206dbe22d08a40cd76cf6",
+      "size": 1676742
     },
     "parall-daemon.js": {
-      "sha256": "354bdc719c5bde1e7f4eaae19f1d895fced7b1a6feee8590d727812b6e5fe2f4",
-      "size": 1719706
+      "sha256": "82f1047c975cb47e31063863a752163a756b857c962d63a7df9acbcdfe0c450d",
+      "size": 1726872
     },
     "parall-openclaw-agent.js": {
       "sha256": "505433b4bf3a4b8dbb7b96978d8693d6c48079f4513282ff1ee59a6d13b3eddf",
       "size": 9801
     }
   },
-  "signature": "T/TtjoBJx65Xb8MftcuGyi+F0J8kpPBmzKIl8hMLP+igdhlAzKTLEHvDN4gB72BOd7lUHOFLwufiyyUye/TbCg=="
+  "signature": "YRCOk2+FiAfFASvIWGt7sDPkt+iZE1yfUfVnu793pKZhbSmjKedFXwq6WdUM+lpM6WqL09/JPSf9d3gmDNc9AA=="
 }

package/bundle/parall-browser-pod.js

@@ -35076,16 +35076,6 @@ function clearAllProviderCreds(env) {
   delete env.PRLL_CLAUDE_ALLOW_API_KEY;
 }
 
-// ts/agent-core/dist/logger.js
-function createLogger(prefix) {
-  return {
-    info: (msg) => console.log(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
-    warn: (msg) => console.warn(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
-    error: (msg) => console.error(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
-    child: (sub) => createLogger(`${prefix}:${sub}`)
-  };
-}
-
 // ts/sdk/dist/constants.js
 var API_BASE = "/api/v1";
 var WIKI_BASE = "/wiki/v1";
@@ -35443,6 +35433,7 @@ var ParallClient = class _ParallClient {
   setTokens;
   refreshPromise = null;
   swimlaneName;
+  getFeatureFlagOverrides;
   /** Auth endpoints excluded from automatic 401 refresh to prevent recursion. */
   static AUTH_PATHS = /* @__PURE__ */ new Set([
     "/auth/login",
@@ -35473,7 +35464,7 @@ var ParallClient = class _ParallClient {
     return apiError;
   }
   /** Build headers common to all requests (auth, swimlane). */
-  buildHeaders(extra) {
+  buildHeaders(path6, extra) {
     const headers = {
       "Content-Type": "application/json",
       ...extra
@@ -35484,6 +35475,11 @@ var ParallClient = class _ParallClient {
     if (this.swimlaneName) {
       headers["X-Prll-Swimlane"] = this.swimlaneName;
     }
+    if (path6.startsWith(API_BASE)) {
+      const overrides = this.getFeatureFlagOverrides?.();
+      if (overrides)
+        headers["X-Prll-FF-Override"] = overrides;
+    }
     return headers;
   }
   constructor(options = {}) {
@@ -35494,6 +35490,7 @@ var ParallClient = class _ParallClient {
     this.getRefreshToken = options.getRefreshToken;
     this.setTokens = options.setTokens;
     this.swimlaneName = options.swimlaneName;
+    this.getFeatureFlagOverrides = options.getFeatureFlagOverrides;
   }
   /**
    * Pick the origin for a request path: wiki-service base for `/wiki/v1`
@@ -35580,7 +35577,7 @@ var ParallClient = class _ParallClient {
       if (qs)
         url += `?${qs}`;
     }
-    const headers = this.buildHeaders();
+    const headers = this.buildHeaders(path6);
     const timeoutSignal = AbortSignal.timeout(opts?.timeoutMs ?? 15e3);
     const signal = opts?.signal ? AbortSignal.any([opts.signal, timeoutSignal]) : timeoutSignal;
     let res;
@@ -35637,7 +35634,7 @@ var ParallClient = class _ParallClient {
     if (!retried) {
       await this.ensureFreshToken(path6);
     }
-    const { "Content-Type": _drop, ...headers } = this.buildHeaders();
+    const { "Content-Type": _drop, ...headers } = this.buildHeaders(path6);
     void _drop;
     let res;
     try {
@@ -36482,7 +36479,7 @@ var ParallClient = class _ParallClient {
     if (currentVersion !== void 0) {
       extra["If-None-Match"] = currentVersion;
     }
-    const headers = this.buildHeaders(extra);
+    const headers = this.buildHeaders(ENDPOINTS.PLATFORM_CONFIG, extra);
     let res;
     try {
       res = await fetch(url, {
@@ -37266,6 +37263,19 @@ function buildApiError(res, rawErrorBody) {
   return apiError;
 }
 
+// ts/agent-core/dist/gateway-lane-flow.js
+var TYPED_BACKOFF_CAP_MS = 5 * 6e4;
+
+// ts/agent-core/dist/logger.js
+function createLogger(prefix) {
+  return {
+    info: (msg) => console.log(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
+    warn: (msg) => console.warn(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
+    error: (msg) => console.error(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
+    child: (sub) => createLogger(`${prefix}:${sub}`)
+  };
+}
+
 // ts/agent-core/dist/telemetry.js
 import { AsyncLocalStorage } from "node:async_hooks";
 var sessionKeyStorage = new AsyncLocalStorage();
@@ -40441,7 +40451,7 @@ var ClipProcessManager = class {
    * (GetBindings), then forward the invoke through the hub (Invoke) to the bound
    * BrowserProfile's host. No local shortcut, no fallback — unbound is rejected.
    * The execution daemon never verifies clip_token; the hub does.
-   * See docs/engineering-design/browser-profile-clip-integration.md §11.3.
+   * See docs/archive/engineering-design/browser-profile-clip-integration.md §11.3.
    */
   async invokeDependency(clipName, command, input, context) {
     if (!isBrowserDependencyName(clipName)) {
@@ -40474,7 +40484,7 @@ var ClipProcessManager = class {
    * synthetic "browser" clip). The hub forwards clip_token as the PLAINTEXT
    * browser_profile_id, which the host daemon uses directly as the bb-browser
    * account. Only daemons that host BrowserProfiles register this capability.
-   * See docs/engineering-design/browser-profile-clip-integration.md §11.2.
+   * See docs/archive/engineering-design/browser-profile-clip-integration.md §11.2.
    */
   async invokeBrowserCapability(clipToken, command, input) {
     if (!this.browserProfileManager) {

package/bundle/parall-channel-exec.js

@@ -0,0 +1,224 @@
+// ts/agent-core/dist/bin/channel-exec.js
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+
+// ts/agent-core/dist/channel-capability.js
+var CHANNEL_POINTER_MAGIC = "parall channel capability pointer";
+
+// ts/agent-core/dist/channel-token.js
+var ChannelTokenError = class extends Error {
+};
+var MINT_TIMEOUT_MS = 1e4;
+async function mintChannelToken(channelType, env) {
+  const apiUrl = (env.PRLL_API_URL || "").replace(/\/+$/, "");
+  const apiKey = env.PRLL_API_KEY || "";
+  const orgId = env.PRLL_ORG_ID || "";
+  if (!apiUrl || !apiKey || !orgId) {
+    throw new ChannelTokenError("PRLL_API_URL/PRLL_API_KEY/PRLL_ORG_ID missing from the environment");
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`
+  };
+  const swimlane = (env.PRLL_SWIMLANE_NAME || "").trim();
+  if (swimlane)
+    headers["X-Prll-Swimlane"] = swimlane;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), MINT_TIMEOUT_MS);
+  let resp;
+  try {
+    resp = await fetch(`${apiUrl}/api/v1/orgs/${encodeURIComponent(orgId)}/agents/me/channel-token`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ channel_type: channelType }),
+      signal: controller.signal
+    });
+  } catch (err) {
+    throw new ChannelTokenError(`could not reach the Parall platform to authenticate (${String(err)}); channel actions are unavailable right now`);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!resp.ok) {
+    let msg = `platform returned HTTP ${resp.status}`;
+    try {
+      const body = await resp.json();
+      if (body?.error?.message)
+        msg = body.error.message;
+    } catch {
+    }
+    throw new ChannelTokenError(msg);
+  }
+  const minted = await resp.json();
+  const nonEmpty = (v) => typeof v === "string" && v.length > 0;
+  if (!minted || !nonEmpty(minted.token) || !nonEmpty(minted.app_id) || !nonEmpty(minted.brand)) {
+    throw new ChannelTokenError("platform returned an unusable token payload");
+  }
+  return minted;
+}
+
+// ts/agent-core/dist/bin/channel-exec.js
+var CHANNEL_BIN = { feishu: "lark-cli" };
+function fail(prefix, msg, code) {
+  try {
+    fs.writeSync(2, `${prefix}: ${msg}
+`);
+  } catch {
+  }
+  process.exit(code);
+}
+function parseArgs(argv) {
+  const out = { channel: "", skipDir: "", rest: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--") {
+      out.rest = argv.slice(i + 1);
+      break;
+    }
+    if (a === "--channel")
+      out.channel = argv[++i] ?? "";
+    else if (a === "--skip-dir")
+      out.skipDir = argv[++i] ?? "";
+    else
+      fail("channel-exec", `unknown argument ${a}`, 2);
+  }
+  if (!out.channel) {
+    fail("channel-exec", "usage: channel-exec --channel <type> [--skip-dir <dir>] -- <args\u2026>", 2);
+  }
+  return out;
+}
+function isCapabilityPointer(candidate) {
+  try {
+    const fd = fs.openSync(candidate, "r");
+    try {
+      const buf = Buffer.alloc(256);
+      const n = fs.readSync(fd, buf, 0, buf.length, 0);
+      return buf.toString("utf8", 0, n).includes(CHANNEL_POINTER_MAGIC);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return false;
+  }
+}
+function resolveRealBin(bin, skipDir) {
+  const isWin = process.platform === "win32";
+  const exts = isWin ? [".cmd", ".exe", ".bat"] : [""];
+  let skipReal = null;
+  if (skipDir) {
+    try {
+      skipReal = fs.realpathSync(skipDir);
+    } catch {
+      skipReal = null;
+    }
+  }
+  for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+    if (!dir)
+      continue;
+    let real;
+    try {
+      real = fs.realpathSync(dir);
+    } catch {
+      continue;
+    }
+    if (skipReal && real === skipReal)
+      continue;
+    for (const ext of exts) {
+      const candidate = path.join(dir, bin + ext);
+      try {
+        if (fs.statSync(candidate).isFile() && !isCapabilityPointer(candidate))
+          return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+var FEISHU_OWNED_ENV = [
+  // injected (canonical values set below)
+  "LARKSUITE_CLI_APP_ID",
+  "LARKSUITE_CLI_BRAND",
+  "LARKSUITE_CLI_TENANT_ACCESS_TOKEN",
+  "LARKSUITE_CLI_DEFAULT_AS",
+  "LARKSUITE_CLI_STRICT_MODE",
+  // ambient auth bypass inputs that must not reach the child
+  "LARKSUITE_CLI_APP_SECRET",
+  "LARKSUITE_CLI_USER_ACCESS_TOKEN",
+  "LARKSUITE_CLI_AUTH_PROXY",
+  "LARKSUITE_CLI_PROXY_KEY"
+];
+function buildChildEnv(channel, minted) {
+  const env = { ...process.env };
+  if (channel === "feishu") {
+    const owned = new Set(FEISHU_OWNED_ENV);
+    for (const key of Object.keys(env)) {
+      if (owned.has(key.toUpperCase()))
+        delete env[key];
+    }
+    env.LARKSUITE_CLI_APP_ID = minted.app_id;
+    env.LARKSUITE_CLI_BRAND = minted.brand || "feishu";
+    env.LARKSUITE_CLI_TENANT_ACCESS_TOKEN = minted.token;
+    env.LARKSUITE_CLI_DEFAULT_AS = "bot";
+    env.LARKSUITE_CLI_STRICT_MODE = "bot";
+    return env;
+  }
+  fail("channel-exec", `unsupported channel type "${channel}"`, 2);
+}
+var CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
+function escapeCmdArgument(arg) {
+  let out = `${arg}`;
+  out = out.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, "$1$1");
+  out = `"${out}"`;
+  out = out.replace(CMD_META_CHARS, "^$1").replace(CMD_META_CHARS, "^$1");
+  return out;
+}
+function escapeCmdCommand(command) {
+  return command.replace(CMD_META_CHARS, "^$1");
+}
+function runReal(realBin, args, env, prefix) {
+  const isWinScript = process.platform === "win32" && /\.(cmd|bat)$/i.test(realBin);
+  const result = isWinScript ? spawnSync(process.env.comspec || "cmd.exe", [
+    "/d",
+    "/s",
+    "/c",
+    `"${[escapeCmdCommand(realBin), ...args.map(escapeCmdArgument)].join(" ")}"`
+  ], { stdio: "inherit", env, windowsVerbatimArguments: true }) : spawnSync(realBin, args, { stdio: "inherit", env });
+  if (result.error) {
+    fail(prefix, `failed to run ${realBin}: ${String(result.error)}`, 1);
+  }
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+    process.exit(1);
+  }
+  process.exit(result.status === null ? 1 : result.status);
+}
+async function main() {
+  const { channel, skipDir, rest } = parseArgs(process.argv.slice(2));
+  const bin = CHANNEL_BIN[channel];
+  if (!bin)
+    fail("channel-exec", `unsupported channel type "${channel}"`, 2);
+  const prefix = bin;
+  let minted;
+  try {
+    minted = await mintChannelToken(channel, process.env);
+  } catch (err) {
+    if (err instanceof ChannelTokenError)
+      fail(prefix, err.message, 1);
+    fail(prefix, String(err), 1);
+  }
+  const real = resolveRealBin(bin, skipDir);
+  if (!real) {
+    const hint = channel === "feishu" ? "Install it once with:\n  npm i -g @larksuite/cli && npx skills add larksuite/cli -y -g" : "Install it and retry.";
+    fail(prefix, `the ${bin} binary is not installed. ${hint}`, 127);
+  }
+  runReal(real, rest, buildChildEnv(channel, minted), prefix);
+}
+var invokedPath = process.argv[1];
+if (invokedPath && import.meta.url === pathToFileURL(invokedPath).href) {
+  void main();
+}
+export {
+  escapeCmdArgument,
+  escapeCmdCommand
+};