@zixt/host 0.0.8 → 0.0.10

package/dist/index.js

@@ -31,7 +31,7 @@ import { homedir } from "node:os";
 // package.json
 var package_default = {
   name: "@zixt/host",
-  version: "0.0.8",
+  version: "0.0.10",
   type: "module",
   exports: {
     ".": "./src/client.ts",
@@ -15272,6 +15272,12 @@ var HostTelemetry = external_exports.object({
      * recovery path; this is deliberately not inferred from package version.
      */
     taskAuthorityLifecycle: external_exports.literal(true).optional(),
+    /**
+     * Understands structured provider-operation retry responses and can
+     * wait cancellably before repeating the same logical request. Missing
+     * legacy Hosts must receive the original strict refusal frame.
+     */
+    providerOperationGrantRetry: external_exports.literal(true).optional(),
     linearToolPack: external_exports.boolean().default(false),
     providerToolPacks: external_exports.array(ProviderToolPackCapability).max(20).superRefine((capabilities, ctx) => {
       const providers = capabilities.map(({ provider }) => provider);
@@ -15412,12 +15418,37 @@ var HostRequiredIntegrationSummary = external_exports.object({
   failedCount: external_exports.number().int().min(0),
   unknownCount: external_exports.number().int().min(0)
 });
+var HostQueuedTaskDetail = external_exports.object({
+  id: TaskId,
+  title: external_exports.string().min(1).max(300),
+  agentName: external_exports.string().min(1).max(120),
+  runnerType: RunnerType,
+  placement: external_exports.enum([
+    "ready_here",
+    "ready_elsewhere",
+    "blocked_everywhere",
+    "assigned_elsewhere",
+    "evaluation_unknown"
+  ]),
+  placementReason: external_exports.string().min(1).max(2e3),
+  eligibleMachineCount: external_exports.number().int().min(0),
+  /** A bounded preview; eligibleMachineCount remains exact when this is truncated. */
+  eligibleMachineNames: external_exports.array(external_exports.string().min(1).max(120)).max(10),
+  /** Queue timing is independent from Machine placement above. */
+  queueState: external_exports.enum(["ready", "decision_pending", "waiting", "retry_due", "retry_overdue"]),
+  queueReason: external_exports.string().min(1).max(2e3),
+  retryAt: IsoDate2.nullable()
+});
 var HostWorkSummary = external_exports.object({
   activeTaskCount: external_exports.number().int().min(0),
   queuedOrgTaskCount: external_exports.number().int().min(0),
   queuedEligibleTaskCount: external_exports.number().int().min(0),
+  /** Exact count across the full relevant queue, independent of the bounded detail preview. */
+  overdueRelevantTaskCount: external_exports.number().int().min(0),
   /** Runner families used by queued Tasks that may target this Machine. */
   queuedRunnerTypes: external_exports.array(RunnerType),
+  /** Bounded attention-first queue preview with exact Admin/Owner placement evidence. */
+  queuedTaskDetails: external_exports.array(HostQueuedTaskDetail).max(10),
   eligibilityState: HostEligibilityState,
   eligibilityReason: external_exports.string().min(1).max(2e3)
 });
@@ -15907,8 +15938,8 @@ var CreateTaskInput = external_exports.object({
   /** May be empty only when the message carries attachments (TS-15). */
   instructions: external_exports.string().max(1e5),
   priority: Task.shape.priority.default(0),
-  /** Must name one of the selected agent's configured workspaces. */
-  workspace: SafeDisplayPath.optional(),
+  /** Omitted uses the teammate default; null explicitly uses its Zixt-owned persistent folder. */
+  workspace: SafeDisplayPath.nullable().optional(),
   interactionMode: InteractionMode.optional(),
   /** Ask the agent to post a plan via ask_user before doing any work. */
   planFirst: external_exports.boolean().optional(),
@@ -18133,6 +18164,30 @@ var ProviderOperationGrantRequestFrame = external_exports.discriminatedUnion("op
     }
   )
 ]);
+var ProviderOperationGrantFailureCode = external_exports.enum([
+  "provider_timeout",
+  "provider_rate_limited",
+  "provider_unavailable",
+  "provider_authority_rejected",
+  "provider_request_rejected",
+  "provider_not_found",
+  "provider_invalid_response",
+  "provider_issuance_unresolved",
+  "provider_grant_delivery_unresolved"
+]);
+var ProviderOperationGrantRetryCode = external_exports.enum([
+  "provider_timeout",
+  "provider_rate_limited",
+  "provider_unavailable",
+  "provider_invalid_response",
+  "provider_issuance_unresolved",
+  "provider_grant_delivery_unresolved"
+]);
+var ProviderOperationGrantRetry = external_exports.object({
+  code: ProviderOperationGrantRetryCode,
+  /** Never earlier than the durable claim's safe reclaim boundary. */
+  retryAt: IsoDate
+}).strict();
 var ProviderOperationGrantResultFrame = external_exports.discriminatedUnion("ok", [
   external_exports.object({
     type: external_exports.literal("provider.operation.grant.result"),
@@ -18150,7 +18205,9 @@ var ProviderOperationGrantResultFrame = external_exports.discriminatedUnion("ok"
     requestId: external_exports.string().min(1).max(200),
     ok: external_exports.literal(false),
     grant: external_exports.never().optional(),
-    error: external_exports.string().min(1).max(2e3).optional()
+    error: external_exports.string().min(1).max(2e3).optional(),
+    /** Sent only when the connected Host explicitly advertised support. */
+    retry: ProviderOperationGrantRetry.optional()
   }).strict()
 ]);
 var BrowserStateFrame = external_exports.object({
@@ -19210,6 +19267,52 @@ var GithubGrantError = class extends Error {
     this.name = `GithubGrantError:${reason}`;
   }
 };
+async function waitForOperationGrantRetry(retryAt, signal) {
+  const deadline = Date.parse(retryAt);
+  if (!Number.isFinite(deadline) || signal.aborted) return false;
+  if (deadline <= Date.now()) return true;
+  return await new Promise((resolve13) => {
+    let settled = false;
+    let timer;
+    const finish = (ready) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      resolve13(ready);
+    };
+    const onAbort = () => finish(false);
+    const schedule = () => {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        finish(true);
+        return;
+      }
+      timer = setTimeout(schedule, Math.min(remaining, 2147e6));
+      timer.unref?.();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted) {
+      finish(false);
+      return;
+    }
+    schedule();
+  });
+}
+function operationGrantRetryCause(code) {
+  if (code === "provider_timeout") return "GitHub did not answer the credential request in time";
+  if (code === "provider_rate_limited") return "GitHub rate-limited the credential request";
+  if (code === "provider_invalid_response") {
+    return "GitHub returned an invalid credential response";
+  }
+  if (code === "provider_issuance_unresolved") {
+    return "GitHub credential issuance is still unresolved";
+  }
+  if (code === "provider_grant_delivery_unresolved") {
+    return "Zixt is waiting for a previously issued GitHub credential to expire before retrying delivery";
+  }
+  return "GitHub is temporarily unavailable for credential issuance";
+}
 var HostClient = class _HostClient {
   constructor(opts) {
     this.opts = opts;
@@ -19887,7 +19990,13 @@ var HostClient = class _HostClient {
         if (!frame.ok) {
           clearTimeout(waiter.timer);
           this.operationGrantWaiters.delete(frame.requestId);
-          waiter.deny(false, "refused_by_zixt", frame.error);
+          waiter.deny(
+            frame.retry !== void 0,
+            "refused_by_zixt",
+            frame.error,
+            frame.retry?.retryAt,
+            frame.retry?.code
+          );
           return;
         }
         const { grant } = frame;
@@ -19977,6 +20086,7 @@ var HostClient = class _HostClient {
         capabilities: {
           ...measuredCapabilities,
           linearToolPack: measured.capabilities?.linearToolPack ?? false,
+          providerOperationGrantRetry: true,
           ...workerWatchdogIsActive() ? { taskAuthorityLifecycle: true } : {}
         },
         // Evidence, not configuration: the cloud says which paths matter and
@@ -20458,9 +20568,11 @@ var HostClient = class _HostClient {
         throw new Error("No GitHub change was attempted; the authority grant was not received.");
       }
       const attempts = options?.maxAttempts ?? 1;
+      let attemptBudget = attempts;
+      let structuredRetryUsed = false;
       let failureReason = "no_reply_from_zixt";
       let failureDetail;
-      for (let attempt = 0; attempt < attempts; attempt++) {
+      for (let attempt = 0; attempt < attemptBudget; attempt++) {
         if (authorityController.signal.aborted) break;
         const socket = this.ws;
         if (!socket || socket.readyState !== WebSocket.OPEN) break;
@@ -20497,7 +20609,14 @@ var HostClient = class _HostClient {
               addSensitiveValues(providerGrantSensitiveValues(grant));
               resolve13({ grant });
             },
-            deny: (retryable, reason, detail) => resolve13({ grant: null, retryable, reason, ...detail ? { detail } : {} })
+            deny: (retryable, reason, detail, retryAt, retryCode) => resolve13({
+              grant: null,
+              retryable,
+              reason,
+              ...detail ? { detail } : {},
+              ...retryAt ? { retryAt } : {},
+              ...retryCode ? { retryCode } : {}
+            })
           });
           try {
             socket.send(JSON.stringify(parsed.data));
@@ -20515,7 +20634,22 @@ var HostClient = class _HostClient {
         }
         failureReason = outcome.reason;
         failureDetail = outcome.detail;
-        if (!outcome.retryable) break;
+        const structuredRetryAt = outcome.retryAt;
+        const structuredRetryCode = outcome.retryCode;
+        const structuredRetry = structuredRetryAt !== void 0 && structuredRetryCode !== void 0;
+        if (structuredRetry && structuredRetryAt && structuredRetryCode) {
+          if (structuredRetryUsed) break;
+          structuredRetryUsed = true;
+          if (attempt + 1 >= attemptBudget) attemptBudget += 1;
+          emitEvent(
+            "status",
+            `${operationGrantRetryCause(structuredRetryCode)}. Zixt will retry automatically at ${structuredRetryAt}; no repository change was attempted.`
+          );
+        }
+        if (!outcome.retryable || attempt + 1 >= attemptBudget) break;
+        if (outcome.retryAt !== void 0 && !await waitForOperationGrantRetry(outcome.retryAt, authorityController.signal)) {
+          break;
+        }
       }
       throw new GithubGrantError(failureReason, failureDetail);
     };
@@ -20708,6 +20842,10 @@ var HostClient = class _HostClient {
           });
         }
       }
+      try {
+        this.opts.onTaskSettled?.();
+      } catch {
+      }
     }
   }
   /** Dial an MCP server on the cloud's behalf and report its tools/health. */
@@ -20754,6 +20892,28 @@ function releaseSourceUrl() {
 var DEFAULT_INTERVAL_MS = 15 * 6e4;
 var MIN_INTERVAL_MS = 6e4;
 var REQUEST_TIMEOUT_MS2 = 1e4;
+function createIdleUpdateRestartGate(options) {
+  let pending = null;
+  let restarting = false;
+  const restartIfIdle = () => {
+    if (restarting || pending === null || options.activeTasks() > 0) return;
+    restarting = true;
+    const version2 = pending;
+    pending = null;
+    options.restart(version2);
+  };
+  return {
+    updateAvailable(version2) {
+      if (restarting || pending !== null) return;
+      pending = version2;
+      const activeTasks = options.activeTasks();
+      if (activeTasks > 0) options.deferred?.(version2, activeTasks);
+      restartIfIdle();
+    },
+    taskSettled: restartIfIdle,
+    pendingVersion: () => pending
+  };
+}
 async function fetchPublishedVersion(registryUrl = DEFAULT_REGISTRY_URL, fetchImpl = fetch) {
   try {
     const response = await fetchImpl(registryUrl, {
@@ -20952,7 +21112,7 @@ function posixProcessRecordsFromPs(output) {
   const seen = /* @__PURE__ */ new Set();
   for (const line of output.split(/\r?\n/)) {
     if (!line.trim()) continue;
-    const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s*$/.exec(line);
+    const match = /^\s*(?:(\d+)\s+)?(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s*$/.exec(line);
     if (!match) {
       throw new ProcessTreeTerminationError(
         "state_unknown",
@@ -20960,12 +21120,13 @@ function posixProcessRecordsFromPs(output) {
       );
     }
     const record2 = {
-      pid: Number(match[1]),
-      ppid: Number(match[2]),
-      pgid: Number(match[3]),
-      stat: match[4]
+      uid: match[1] === void 0 ? null : Number(match[1]),
+      pid: Number(match[2]),
+      ppid: Number(match[3]),
+      pgid: Number(match[4]),
+      stat: match[5]
     };
-    if (!Number.isSafeInteger(record2.pid) || record2.pid <= 0 || !Number.isSafeInteger(record2.ppid) || record2.ppid < 0 || !Number.isSafeInteger(record2.pgid) || record2.pgid < 0 || seen.has(record2.pid)) {
+    if (record2.uid !== null && (!Number.isSafeInteger(record2.uid) || record2.uid < 0) || !Number.isSafeInteger(record2.pid) || record2.pid <= 0 || !Number.isSafeInteger(record2.ppid) || record2.ppid < 0 || !Number.isSafeInteger(record2.pgid) || record2.pgid < 0 || seen.has(record2.pid)) {
       throw new ProcessTreeTerminationError(
         "state_unknown",
         "POSIX process-tree observation returned invalid evidence"
@@ -20978,7 +21139,7 @@ function posixProcessRecordsFromPs(output) {
 }
 async function snapshotPosixProcesses() {
   return new Promise((resolve13, reject3) => {
-    const observer = spawn2("/bin/ps", ["-axo", "pid=,ppid=,pgid=,stat="], {
+    const observer = spawn2("/bin/ps", ["-axo", "uid=,pid=,ppid=,pgid=,stat="], {
       stdio: ["ignore", "pipe", "ignore"]
     });
     let output = "";
@@ -21042,6 +21203,9 @@ async function snapshotPosixProcesses() {
     });
   });
 }
+function legacyPosixProcessIsDefinitelyForeign(record2, currentUid = process.getuid?.()) {
+  return record2.uid !== null && currentUid !== void 0 && record2.uid !== currentUid;
+}
 function capturePosixTree(rootPid, records) {
   const byPid = new Map(records.map((record2) => [record2.pid, record2]));
   const host = byPid.get(process.pid);
@@ -21514,6 +21678,7 @@ async function terminateRecordedProcessTree(pid, identity, options = {}) {
   const liveGroup = records.some((record2) => record2.pgid === pid && !record2.stat.startsWith("Z"));
   if (!root && !liveGroup) return;
   if (!identity) {
+    if (root && legacyPosixProcessIsDefinitelyForeign(root)) return;
     throw new ProcessTreeTerminationError(
       "state_unknown",
       "a live legacy runner has no process identity and cannot be stopped safely"
@@ -27199,7 +27364,10 @@ function createGithubRepositoryCreator(input) {
             operation: "repository.clone_created",
             repositoryId: repository.repositoryId
           },
-          { maxAttempts: 1 }
+          // The request only obtains fenced credential authority; it does not
+          // repeat repository creation. A second transport probe is required
+          // to recover a cloud commit whose volatile success frame was lost.
+          { maxAttempts: 2 }
         ),
         {
           operation: "repository.clone_created",
@@ -36245,6 +36413,28 @@ var connectionContext = connectionLogContext({
   cloud: cloudTarget,
   version: HOST_VERSION
 });
+var stopUpdateWatch = () => {
+};
+var updateRestartGate = createIdleUpdateRestartGate({
+  activeTasks: () => activeSessions,
+  deferred: (version2, activeTasks) => {
+    log.info("A newer Zixt Host is ready; update waits for active Tasks to finish", {
+      machine,
+      version: version2,
+      running: HOST_VERSION,
+      activeTasks
+    });
+  },
+  restart: (version2) => {
+    log.info("Active Tasks settled; restarting to update Zixt Host", {
+      machine,
+      version: version2,
+      running: HOST_VERSION
+    });
+    stopUpdateWatch();
+    shutdown(UPDATE_EXIT_CODE);
+  }
+});
 var client = new HostClient({
   url: url2,
   token,
@@ -36266,6 +36456,7 @@ var client = new HostClient({
       forgetSupersededTerminalOutcomes(hostId, taskId, epoch, terminalOutcomeRoot)
     ]);
   },
+  onTaskSettled: () => updateRestartGate.taskSettled(),
   onUnwindStalled: (reason) => {
     retainRunAssignments();
     log.error("Task cleanup did not finish; restarting the Host to recover safely", {
@@ -36337,17 +36528,11 @@ function shutdown(exitCode = 0) {
   ).unref();
   void client.stop().then(() => process.exit(exitCode));
 }
-var stopUpdateWatch = !packagedBuild ? () => {
+stopUpdateWatch = !packagedBuild ? () => {
 } : watchForUpdates({
   onUpdateAvailable: (version2) => {
-    log.info("A newer Zixt Host was published; restarting to pick it up", {
-      machine,
-      version: version2,
-      running: HOST_VERSION,
-      activeTasks: activeSessions
-    });
     stopUpdateWatch();
-    shutdown(UPDATE_EXIT_CODE);
+    updateRestartGate.updateAvailable(version2);
   }
 });
 process.on("SIGINT", () => shutdown());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zixt/host",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
   "exports": {
     ".": "./src/client.ts",