@edgehero/pi-dispatch-admin 5.1.0 → 5.2.1

package/dist/sandbox-session-monitor.mjs

@@ -102209,6 +102209,10 @@ var CONTAINER_ENV_NAMES = /* @__PURE__ */ new Set([
   "PI_RUNNER_OBSERVABLE",
   // Issue #693: derived from the resolved job memory, never chosen by a trigger or forwarded host value.
   "PI_CODEMODE_MAX_WORKERS",
+  // Issue #865: the job's size as the job reads it (job-size.mjs `jobSizeEnv`). A trigger binding one through
+  // run.secrets, or a forwarded host value, would tell the job's tools a size the container was not given.
+  "PI_JOB_SIZE_CPUS",
+  "PI_JOB_SIZE_MEMORY_MIB",
   "PI_PROVIDER",
   "PI_MODEL",
   "PI_FORK_ENTRY",
@@ -102285,6 +102289,7 @@ var DOLLAR_ENV_NAMES = Object.freeze({ maxCostUsd: "PI_MAX_COST_USD", dailyCostU
 var DOLLAR_WINDOW_KEYS = Object.freeze(["dailyCostUsd", "weeklyCostUsd", "monthlyCostUsd"]);
 
 // ../worker/src/config.mjs
+var DEFAULT_VALKEY_URL = "redis://127.0.0.1:6379";
 var WORKER_ONLY_SECRET_VARS = /* @__PURE__ */ new Set(["GITHUB_APP_PRIVATE_KEY", "VALKEY_PASSWORD"]);
 var WORKER_ONLY_WHY = Object.freeze({
   GITHUB_APP_PRIVATE_KEY: "the App's signing key mints tokens for every repository the App is installed on",
@@ -103361,10 +103366,12 @@ function valkeyClientContext({ env: env2 = process.env, cwd = process.cwd(), pla
   const envPath = join(cwd, ".env");
   let content = null;
   let error = null;
+  let absent = false;
   try {
     content = readEnv3(envPath);
   } catch (err) {
-    if (err?.code !== "ENOENT") error = `${envPath} could not be read (${err?.code ?? err?.message})`;
+    if (err?.code === "ENOENT") absent = true;
+    else error = `${envPath} could not be read (${err?.code ?? err?.message})`;
   }
   const fileKeys = {};
   if (content !== null) {
@@ -103378,10 +103385,10 @@ function valkeyClientContext({ env: env2 = process.env, cwd = process.cwd(), pla
     if (keys.error) error ??= keys.error;
     else for (const k of [VALKEY_SHARED_KEY, VALKEY_PASSWORD_KEY, "VALKEY_URL"]) if (typeof keys.keys[k] === "string") fileKeys[k] = keys.keys[k];
   }
-  return valkeyContextFromKeys({ env: env2, envPath, fileKeys, error, platform, rootRefused });
+  return valkeyContextFromKeys({ env: env2, envPath, fileKeys, error, absent, platform, rootRefused });
 }
 var VALKEY_CONTEXT_KEYS = Object.freeze(["VALKEY_URL", VALKEY_PASSWORD_KEY, VALKEY_SHARED_KEY, "PI_BACKENDS", "PI_OPENSHELL_ENGINE"]);
-function valkeyContextFromKeys({ env: env2 = process.env, envPath = null, fileKeys = {}, error = null, platform = process.platform, rootRefused } = {}) {
+function valkeyContextFromKeys({ env: env2 = process.env, envPath = null, fileKeys = {}, error = null, absent = false, platform = process.platform, rootRefused } = {}) {
   const fileVenue = typeof fileKeys.PI_BACKENDS === "string" ? { PI_BACKENDS: fileKeys.PI_BACKENDS } : {};
   const shared = valkeySharedOn(fileKeys[VALKEY_SHARED_KEY]);
   const filePassword = fileKeys[VALKEY_PASSWORD_KEY] || null;
@@ -103395,7 +103402,7 @@ function valkeyContextFromKeys({ env: env2 = process.env, envPath = null, fileKe
   const engine = typeof env2.PI_OPENSHELL_ENGINE === "string" ? env2.PI_OPENSHELL_ENGINE : fileKeys.PI_OPENSHELL_ENGINE;
   const derived = platform === "linux" && (venues.podmanUsed && !venues.localUsed || openshellSetupOf(venues, { PI_OPENSHELL_ENGINE: engine }).valkeyEngine === "podman");
   const envUrl = typeof env2.VALKEY_URL === "string" ? env2.VALKEY_URL : null;
-  return { envPath, shared, rootRefused: typeof rootRefused === "boolean" ? rootRefused : derived, error, password: { environment: envPassword, file: filePassword }, url: { environment: envUrl, file: fileUrl } };
+  return { envPath, shared, rootRefused: typeof rootRefused === "boolean" ? rootRefused : derived, error, absent: absent === true, password: { environment: envPassword, file: filePassword }, url: { environment: envUrl, file: fileUrl } };
 }
 function valkeyUrlProblem(url) {
   let u;
@@ -103532,10 +103539,12 @@ if (!Redis.prototype[SELECT_HOOK]) {
   };
   Redis.prototype[SELECT_HOOK] = true;
 }
-function parseConnection(url, { failFast = false, servername = null, context = null, judge = null, withoutPassword = false, freshContext = false } = {}) {
+function parseConnection(url, { failFast = false, servername = null, context = null, judge = null, withoutPassword = false, freshContext = false, commandTimeoutMs = null } = {}) {
   const u = new URL(url);
   const dbProblem = valkeyUrlProblem(url);
   if (dbProblem) throw valkeyRefusal(dbProblem);
+  const bounded = Number.isSafeInteger(commandTimeoutMs) && commandTimeoutMs > 0;
+  if (bounded && !failFast) throw new TypeError("parseConnection: a command bound (commandTimeoutMs) is for a failFast client only, which has no offline queue to send a command that timed out from later");
   const where = context ?? defaultValkeyContext();
   const { password } = valkeyPasswordFor(url, where, { withoutPassword });
   return {
@@ -103544,7 +103553,9 @@ function parseConnection(url, { failFast = false, servername = null, context = n
     // reports. `context` is where the client stands (`valkeyClientContext`), the process's own when not given.
     Connector: JudgedConnector,
     // `judge` is a test seam only: the function asked for the address (judgedEndpoint when not given).
-    [JUDGE]: { url, context: where, ...judge ? { judge } : {}, ...freshContext && !context ? { freshContext: true } : {}, ...failFast ? { failFast: true } : {} },
+    // `freshPassword` (issue #845): a client that judges by the context as it is at each connect sends the password that
+    // context gives then, unless it was built to send none (`withoutPassword`, a probe of what another account sees).
+    [JUDGE]: { url, context: where, ...judge ? { judge } : {}, ...freshContext && !context ? { freshContext: true, ...withoutPassword ? {} : { freshPassword: true } } : {}, ...failFast ? { failFast: true } : {}, ...bounded ? { commandBound: true } : {} },
     // WHATWG URL keeps an IPv6 literal's brackets in `hostname` (`[::1]`), and net.connect then looks up the name
     // "[::1]", which never resolves, so a `redis://[::1]:6379` VALKEY_URL never connected (issue #464, measured on
     // Fedora 44: ETIMEDOUT). The address is the part inside them.
@@ -103566,9 +103577,29 @@ function parseConnection(url, { failFast = false, servername = null, context = n
       // don't buffer commands while disconnected -- error now
       retryStrategy: (attempts) => attempts > 2 ? null : 200
       // give up after ~2 tries
-    } : {}
+    } : {},
+    // ioredis' resend of what was on a connection that died is off with the bound: the caller was told such a command
+    // failed, and a resend on the next connection would make it run after that.
+    ...bounded ? { commandTimeout: commandTimeoutMs, autoResendUnfulfilledCommands: false } : {}
   };
 }
+var COMMAND_BOUND_HOOK = /* @__PURE__ */ Symbol.for("pi-dispatch.valkey-command-bound");
+if (!Redis.prototype[COMMAND_BOUND_HOOK]) {
+  const sendCommand = Redis.prototype.sendCommand;
+  Redis.prototype.sendCommand = function sendCommandWithBound(command, stream11) {
+    const answer = sendCommand.call(this, command, stream11);
+    if (this.options?.[JUDGE]?.commandBound !== true) return answer;
+    command._commandTimeoutTimer?.unref?.();
+    if (this.commandQueue?.peekBack?.()?.command !== command) return answer;
+    answer?.catch?.((err) => {
+      if (!err || typeof err !== "object" || err.name === "ReplyError" || err.valkeyRefused) return;
+      if (err.message === "Command timed out") err.code ??= "ETIMEDOUT";
+      err.valkeyMayStillRun = true;
+    });
+    return answer;
+  };
+  Redis.prototype[COMMAND_BOUND_HOOK] = true;
+}
 var BoundedRedis = class extends Redis {
   sendCommand(command, stream11) {
     const answer = super.sendCommand(command, stream11);
@@ -103594,6 +103625,21 @@ function makeRedisClient(url, { servername = null, context = null, failFast = fa
   return bounded ? new BoundedRedis(options) : new Redis(options);
 }
 var JUDGE = "piDispatchValkeyJudge";
+var FRESH_PASSWORD = /* @__PURE__ */ Symbol.for("pi-dispatch.valkey-fresh-password");
+var PASSWORD_DECLINED = /* @__PURE__ */ Symbol.for("pi-dispatch.valkey-password-declined");
+function sameValkeyServer(a, b) {
+  const x2 = valkeyTarget(a);
+  const y = valkeyTarget(b);
+  return !x2.error && !y.error && x2.host === y.host && x2.port === y.port;
+}
+function freshPasswordVerdict(judge, context, held) {
+  if (!context || context.error || context.absent === true) return { take: false, declined: null };
+  if ((context.envPath ?? null) !== (judge?.context?.envPath ?? null)) return { take: false, declined: null };
+  const { password, from } = valkeyPasswordFor(judge.url, context);
+  const fromFile2 = from !== "VALKEY_URL" && from !== "the environment";
+  if (fromFile2 && !sameValkeyServer(context.url?.file ?? DEFAULT_VALKEY_URL, judge.url)) return { take: false, declined: (password ?? null) !== (held ?? null) };
+  return { take: true, password: password ?? null };
+}
 var JudgedConnector = class _JudgedConnector extends AbstractConnector {
   constructor(options) {
     super(options.disconnectTimeout);
@@ -103603,6 +103649,55 @@ var JudgedConnector = class _JudgedConnector extends AbstractConnector {
   check() {
     return !this[DB_REFUSED];
   }
+  /**
+   * Issue #845: a `freshPassword` client's password, as `valkeyPasswordFor` reads it from the context as it is now, put
+   * where ioredis reads it for the connect about to start (the hook below). Here and not in `connect()`: by the time
+   * ioredis asks the connector for a stream it has already built that connect's AUTH from `options.password`. The options
+   * are the client's own object (ioredis hands its `options` to the Connector it constructs), so this is what the client
+   * sends. A password from VALKEY_URL's userinfo comes back as it is, so it stays fixed. The last password is kept by a
+   * context that:
+   *   - throws, or names an `error` (a `.env` that cannot be read, or a line in it the service's loader reads
+   *     differently): it cannot say which password the file holds, and dropping the one that worked would refuse a client
+   *     that is fine;
+   *   - finds no file (`absent`): a `.env` gone, for good or for the moment an editor replaces it, is not a file that
+   *     sets no password, so it does not drop one either (the console says to put the file back before a restart);
+   *   - would answer from the `.env` while that file does not name the Valkey this client dials: a password the file
+   *     gives (or the lack of one) belongs to the Valkey the file's VALKEY_URL names, the default one when it names
+   *     none, and a held client never moves to another Valkey. Review of PR #878, measured with two Valkeys: one
+   *     deployment moving to another Valkey changes both lines together, a symlinked deployment folder repointed reads
+   *     another deployment's file through the same path, and a shell that exports VALKEY_URL keeps the client on its URL
+   *     whatever the file says; in each the new Valkey's password went to the old one, which refused it, and the pages
+   *     lost the old Valkey too. The check is against the URL the client dials, not the context's own choice of URL
+   *     (`valkeyUrlFor`, which prefers this shell's and so never moved), and by the server each names (`sameValkeyServer`:
+   *     `valkeyTarget`'s host and port, so a scheme alias, a database path or a trailing `/` is the same Valkey, while
+   *     `localhost` and `127.0.0.1` stay two names, as `valkeyEndpointTag` keeps them). A rotation keeps the file's URL,
+   *     so it is taken, and so is a password a bad line hid at start once the line is fixed, when the file names the
+   *     client's Valkey. A password declined here that is not the one the client holds is recorded (`PASSWORD_DECLINED`,
+   *     `passwordDeclinedOf`), so the console names VALKEY_PASSWORD as needing a restart rather than going on refused in
+   *     silence (a shell that exports `redis://localhost:6440` over a file's `redis://127.0.0.1:6440`, say);
+   *   - is read from another `.env` path than the one the client was built with: the pi extension's context follows the
+   *     deployment pointer, and that alone says the file is another deployment's.
+   * A password from this process's environment, or from VALKEY_URL's own userinfo, is not the file's, and is taken as it
+   * comes. A context that passes all of these and gives no password drops it, as a restart would.
+   */
+  [FRESH_PASSWORD]() {
+    const judge = this.options?.[JUDGE];
+    if (judge?.freshPassword !== true) return;
+    let context;
+    try {
+      context = defaultValkeyContext();
+    } catch {
+      return;
+    }
+    const verdict = freshPasswordVerdict(judge, context, this.options.password);
+    if (!verdict.take) {
+      if (verdict.declined !== null) this[PASSWORD_DECLINED] = verdict.declined;
+      return;
+    }
+    this[PASSWORD_DECLINED] = false;
+    if (verdict.password) this.options.password = verdict.password;
+    else delete this.options.password;
+  }
   connect() {
     const { options } = this;
     if (this[DB_REFUSED]) return Promise.reject(this[DB_REFUSED]);
@@ -103634,6 +103729,18 @@ var JudgedConnector = class _JudgedConnector extends AbstractConnector {
   }
 };
 JudgedConnector.dial = { net: netConnect2, tls: tlsConnect };
+var FRESH_PASSWORD_HOOK = /* @__PURE__ */ Symbol.for("pi-dispatch.valkey-fresh-password-hook");
+if (!Redis.prototype[FRESH_PASSWORD_HOOK]) {
+  const connect = Redis.prototype.connect;
+  Redis.prototype.connect = function connectWithFreshPassword(...args) {
+    try {
+      this.connector?.[FRESH_PASSWORD]?.();
+    } catch {
+    }
+    return connect.apply(this, args);
+  };
+  Redis.prototype[FRESH_PASSWORD_HOOK] = true;
+}
 
 // ../worker/src/sandbox.mjs
 import { execFile as execFile6, spawn as spawn2 } from "node:child_process";
@@ -106450,7 +106557,7 @@ var MCP_REFUSAL_COMMENT = Object.freeze({
   "mcp-list-invalid": "the list this job carries is not one the triggers file's loader writes (a service in this deployment may be at another version)",
   "mcp-config-invalid": "this deployment's list of MCP servers (mcp.json in the overlay) cannot be used",
   "mcp-server-unknown": "this deployment does not offer that server",
-  "mcp-secret-reserved": "that server would be handed a credential this deployment keeps for the job itself",
+  "mcp-secret-reserved": "that server would be handed a variable this deployment keeps for the job itself",
   "mcp-secret-unmapped": "a credential that server needs is not passed by this trigger",
   "mcp-excluded": "this trigger's run.excludeTools removes every way the job could reach that server",
   "mcp-egress-unreachable": "the egress policy does not let a job reach that server",
@@ -106721,6 +106828,10 @@ var VENUE_RUNTIME = Object.freeze({ [DEFAULT_BACKEND]: "docker", [PODMAN_BACKEND
 var NON_SECRET_ENV_KEYS = /* @__PURE__ */ new Set([
   // Issue #693: a memory-derived concurrency count, never a credential; keep it in the structural venue env.
   "PI_CODEMODE_MAX_WORKERS",
+  // Issue #865: the job's size, two integers, never a secret. Listed, or OpenShell would put each in the job's credential
+  // provider and the agent would read a placeholder where a tool's worker count needs the number.
+  "PI_JOB_SIZE_CPUS",
+  "PI_JOB_SIZE_MEMORY_MIB",
   "PI_PROVIDER",
   "PI_MODEL",
   "PI_FORK_ENTRY",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edgehero/pi-dispatch-admin",
-  "version": "5.1.0",
+  "version": "5.2.1",
   "description": "Go from sitting next to one AI coding agent to running many in the background: the web console and /dispatch panel of pi-dispatch, over the queue, spend caps, scoped limits, run history and insights, editable cron and GitHub, GitLab, Forgejo and Azure DevOps triggers, pause windows, and human-confirmed tools your AI can operate.",
   "keywords": [
     "pi-package",