@tangle-network/agent-app 0.45.5 → 0.45.6

package/dist/chat-routes/index.js

@@ -100,7 +100,7 @@ import {
   flattenHistory,
   readSandboxBinaryBytes,
   statSandboxFileSize
-} from "../chunk-QGHQ2IRC.js";
+} from "../chunk-4XNCMUVI.js";
 import "../chunk-LWSJK546.js";
 import "../chunk-73F3CKVK.js";
 import "../chunk-ITCINLSU.js";

package/dist/{chunk-QGHQ2IRC.js → chunk-4XNCMUVI.js}

@@ -155,8 +155,213 @@ async function readSandboxBinaryBytes(box, absolutePath, expectedSize, options)
   return { succeeded: true, value: { bytes, size: expectedSize } };
 }
 
-// src/sandbox/diagnostics.ts
+// src/sandbox/recovery.ts
 var EGRESS_PROXY_RECOVERY_REQUIRED = "EGRESS_PROXY_RECOVERY_REQUIRED";
+var EGRESS_PROXY_RECOVERY_PHASE = "egress_proxy_recovery";
+var WORKSPACE_SANDBOX_MISSING = "WORKSPACE_SANDBOX_MISSING";
+var WORKSPACE_SANDBOX_HOST_EXHAUSTED = "WORKSPACE_SANDBOX_HOST_EXHAUSTED";
+var WORKSPACE_SANDBOX_UNRECOVERABLE = "WORKSPACE_SANDBOX_UNRECOVERABLE";
+var WORKSPACE_SANDBOX_SNAPSHOT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var CODES = {
+  [EGRESS_PROXY_RECOVERY_REQUIRED]: { snapshotUsable: true },
+  [WORKSPACE_SANDBOX_MISSING]: { snapshotUsable: false },
+  [WORKSPACE_SANDBOX_HOST_EXHAUSTED]: { snapshotUsable: false },
+  [WORKSPACE_SANDBOX_UNRECOVERABLE]: { snapshotUsable: false }
+};
+var ACTIONS = {
+  confirmation_required: { replacementChosen: false },
+  deletion_declined: { replacementChosen: false },
+  replacement_authorized: { replacementChosen: false },
+  snapshot_replacement_authorized: { replacementChosen: false },
+  replacement_started: { replacementChosen: true },
+  replacement_completed: { replacementChosen: true },
+  snapshot_replacement_started: { replacementChosen: true },
+  snapshot_restore_failed: { replacementChosen: true },
+  snapshot_replacement_completed: { replacementChosen: true },
+  missing_replacement_started: { replacementChosen: true },
+  missing_replacement_completed: { replacementChosen: true },
+  unrecoverable_replacement_started: { replacementChosen: true },
+  unrecoverable_replacement_completed: { replacementChosen: true }
+};
+var WorkspaceSandboxRecoveryRequiredError = class extends Error {
+  code = EGRESS_PROXY_RECOVERY_REQUIRED;
+  status = 409;
+  phase = EGRESS_PROXY_RECOVERY_PHASE;
+  recovery;
+  constructor(recovery, cause) {
+    super(workspaceSandboxRecoveryMessage(recovery), { cause });
+    this.name = "WorkspaceSandboxRecoveryRequiredError";
+    this.recovery = recovery;
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function asNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function errorChain(error) {
+  const pending = [error];
+  const visited = /* @__PURE__ */ new Set();
+  const chain = [];
+  while (pending.length > 0) {
+    const current = pending.shift();
+    if (current === void 0 || current === null || visited.has(current)) continue;
+    visited.add(current);
+    chain.push(current);
+    if (!isRecord(current)) continue;
+    if (current.cause !== void 0) pending.push(current.cause);
+    if (Array.isArray(current.errors)) pending.push(...current.errors);
+  }
+  return chain;
+}
+function isEgressProxyRecoveryRequiredError(error) {
+  return errorChain(error).some(
+    (current) => isRecord(current) && current.code === EGRESS_PROXY_RECOVERY_REQUIRED
+  );
+}
+function isWorkspaceSandboxSnapshotRestoreError(error) {
+  return errorChain(error).some((current) => {
+    const message = current instanceof Error ? current.message : isRecord(current) && typeof current.message === "string" ? current.message : "";
+    return /snapshot|fromSnapshot|restore/i.test(message);
+  });
+}
+function assessWorkspaceSandboxSnapshot(snapshot, sandboxId, now = Date.now()) {
+  if (!snapshot) return { availability: "missing", freshness: "unknown" };
+  const createdAt = Date.parse(snapshot.createdAt);
+  const ageMs = now - createdAt;
+  const isFresh = snapshot.fromSandboxId === sandboxId && Number.isFinite(createdAt) && ageMs >= 0 && ageMs <= WORKSPACE_SANDBOX_SNAPSHOT_MAX_AGE_MS;
+  return isFresh ? { availability: "available", freshness: "fresh", snapshot } : { availability: "stale", freshness: "stale", snapshot };
+}
+function isSnapshotAssessment(value) {
+  if (!isRecord(value)) return false;
+  const availability = value.availability;
+  const freshness = value.freshness;
+  return (availability === "available" || availability === "missing" || availability === "stale") && (freshness === "fresh" || freshness === "stale" || freshness === "unknown");
+}
+function isWorkspaceSandboxRecoveryAction(value) {
+  return typeof value === "string" && Object.hasOwn(ACTIONS, value);
+}
+function isWorkspaceSandboxRecoveryCode(value) {
+  return typeof value === "string" && Object.hasOwn(CODES, value);
+}
+function isWorkspaceSandboxRecoveryState(value) {
+  if (!isRecord(value)) return false;
+  return isWorkspaceSandboxRecoveryCode(value.code) && !!asNonEmptyString(value.sandboxId) && !!asNonEmptyString(value.detectedAt) && isSnapshotAssessment(value.snapshot) && isWorkspaceSandboxRecoveryAction(value.action);
+}
+function workspaceSandboxRecoveryFromError(error) {
+  for (const current of errorChain(error)) {
+    if (!isRecord(current) || !isWorkspaceSandboxRecoveryState(current.recovery)) continue;
+    return current.recovery;
+  }
+  return void 0;
+}
+function workspaceSandboxRecoveryMessage(recovery) {
+  if (recovery.code === WORKSPACE_SANDBOX_MISSING) {
+    return "The sandbox behind this workspace no longer exists on the platform. A replacement is being provisioned and your saved work is restored into it.";
+  }
+  if (!CODES[recovery.code].snapshotUsable) {
+    return "The sandbox behind this workspace could not be started again. A replacement is being provisioned and your saved work is restored into it.";
+  }
+  if (recovery.action === "deletion_declined") {
+    return "Sandbox recovery remains paused because replacement was declined. The stopped sandbox has not been deleted.";
+  }
+  if (recovery.action === "confirmation_required") {
+    const snapshotReason = recovery.snapshot.availability === "missing" ? "No restorable sandbox snapshot is available." : "The available sandbox snapshot is stale.";
+    return `Sandbox recovery requires owner confirmation before replacement. ${snapshotReason} The stopped sandbox has not been deleted.`;
+  }
+  if (recovery.action === "snapshot_restore_failed") {
+    return "Sandbox replacement could not restore its verified snapshot, and an empty fallback was not created because it could lose workspace state.";
+  }
+  return "Sandbox recovery is required before chat can continue. The stopped sandbox has not been deleted.";
+}
+function workspaceSandboxRecoveryRecommendedActions(recovery) {
+  if (!CODES[recovery.code].snapshotUsable) {
+    return ["Retry after the replacement sandbox finishes provisioning."];
+  }
+  if (recovery.action === "deletion_declined") {
+    return ["Keep the stopped sandbox for support or ask a workspace owner to authorize replacement."];
+  }
+  if (recovery.action === "confirmation_required") {
+    return ["An owner can explicitly replace the sandbox after accepting loss of unsnapshotted sandbox-local changes."];
+  }
+  if (recovery.action === "snapshot_restore_failed") {
+    return ["Retry snapshot restoration or contact support. An empty replacement is not created automatically."];
+  }
+  return ["Retry after sandbox recovery completes."];
+}
+function workspaceSandboxRecoveryDiagnostic(recovery) {
+  return {
+    sandboxId: recovery.sandboxId,
+    recoveryCode: recovery.code,
+    snapshotAvailability: recovery.snapshot.availability,
+    snapshotFreshness: recovery.snapshot.freshness,
+    selectedRecoveryAction: recovery.action,
+    replacementSandboxId: recovery.replacementSandboxId
+  };
+}
+function preferredWorkspaceSandboxRecoveryBoxKey(recovery) {
+  if (!recovery?.replacementBoxKey) return void 0;
+  return ACTIONS[recovery.action].replacementChosen ? recovery.replacementBoxKey : void 0;
+}
+function shouldRestoreWorkspaceSandboxRecovery(recovery) {
+  if (!recovery) return false;
+  if (!CODES[recovery.code].snapshotUsable) return false;
+  return !!preferredWorkspaceSandboxRecoveryBoxKey(recovery) && recovery.snapshot.availability === "available";
+}
+function createWorkspaceSandboxRecoveryManager(store) {
+  async function record(workspaceId, recovery) {
+    await store.write(workspaceId, recovery);
+  }
+  return {
+    read: store.read,
+    record,
+    async decide({ workspaceId, sandboxId, decision, replacementBoxKey }) {
+      const current = await store.read(workspaceId);
+      if (!current || current.sandboxId !== sandboxId) return void 0;
+      const next = {
+        ...current,
+        action: decision === "replace" ? current.snapshot.availability === "available" ? "snapshot_replacement_authorized" : "replacement_authorized" : "deletion_declined",
+        confirmedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...decision === "replace" && replacementBoxKey ? { replacementBoxKey } : {}
+      };
+      await record(workspaceId, next);
+      return next;
+    },
+    async complete({ workspaceId, replacementSandboxId }) {
+      const current = await store.read(workspaceId);
+      if (!current) return void 0;
+      const next = {
+        ...current,
+        action: completionFor(current.action),
+        replacementSandboxId
+      };
+      await record(workspaceId, next);
+      return next;
+    }
+  };
+}
+function completionFor(action) {
+  switch (action) {
+    case "missing_replacement_started":
+      return "missing_replacement_completed";
+    case "unrecoverable_replacement_started":
+      return "unrecoverable_replacement_completed";
+    case "snapshot_replacement_started":
+    case "snapshot_replacement_authorized":
+      return "snapshot_replacement_completed";
+    default:
+      return "replacement_completed";
+  }
+}
+var WORKSPACE_SANDBOX_RECOVERY_ACTIONS = Object.keys(
+  ACTIONS
+);
+var WORKSPACE_SANDBOX_RECOVERY_CODES = Object.keys(
+  CODES
+);
+
+// src/sandbox/diagnostics.ts
 var SAFE_ERROR_FIELDS = [
   "code",
   "status",
@@ -167,7 +372,7 @@ var SAFE_ERROR_FIELDS = [
   "sidecarVersion",
   "containerImage"
 ];
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function asSafeScalar(value) {
@@ -197,18 +402,18 @@ function readMessage(value) {
   if (typeof value === "string" && value.length > 0) return redactDiagnosticText(value);
   if (typeof value === "number" && Number.isFinite(value)) return String(value);
   if (typeof value === "boolean") return String(value);
-  if (!isRecord(value)) return void 0;
+  if (!isRecord2(value)) return void 0;
   const message = value.message;
   return typeof message === "string" && message.length > 0 ? redactDiagnosticText(message) : void 0;
 }
 function readName(value) {
   if (value instanceof Error) return redactDiagnosticText(value.name);
-  if (!isRecord(value)) return void 0;
+  if (!isRecord2(value)) return void 0;
   const name = value.name;
   return typeof name === "string" && name.length > 0 ? redactDiagnosticText(name) : void 0;
 }
 function readCause(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord2(value)) return void 0;
   return value.cause;
 }
 function serializeSandboxProvisioningError(error, options = {}) {
@@ -228,13 +433,13 @@ function serializeSandboxProvisioningError(error, options = {}) {
       });
       break;
     }
-    if (isRecord(current)) seen.add(current);
+    if (isRecord2(current)) seen.add(current);
     const cause = {};
     const name = readName(current);
     const message = readMessage(current);
     if (name) cause.name = name;
     if (message) cause.message = message;
-    if (isRecord(current)) {
+    if (isRecord2(current)) {
       for (const field of SAFE_ERROR_FIELDS) {
         const safeValue = asSafeScalar(current[field]);
         if (safeValue !== void 0) {
@@ -245,7 +450,7 @@ function serializeSandboxProvisioningError(error, options = {}) {
     if (Object.keys(cause).length > 0) causes.push(cause);
     current = readCause(current);
   }
-  if (!cycle && isRecord(current) && seen.has(current)) {
+  if (!cycle && isRecord2(current) && seen.has(current)) {
     cycle = true;
     causes.push({
       name: "CauseChainCycle",
@@ -1940,6 +2145,27 @@ export {
   statSandboxFileSize,
   readSandboxBinaryBytes,
   EGRESS_PROXY_RECOVERY_REQUIRED,
+  EGRESS_PROXY_RECOVERY_PHASE,
+  WORKSPACE_SANDBOX_MISSING,
+  WORKSPACE_SANDBOX_HOST_EXHAUSTED,
+  WORKSPACE_SANDBOX_UNRECOVERABLE,
+  WORKSPACE_SANDBOX_SNAPSHOT_MAX_AGE_MS,
+  WorkspaceSandboxRecoveryRequiredError,
+  isEgressProxyRecoveryRequiredError,
+  isWorkspaceSandboxSnapshotRestoreError,
+  assessWorkspaceSandboxSnapshot,
+  isWorkspaceSandboxRecoveryAction,
+  isWorkspaceSandboxRecoveryCode,
+  isWorkspaceSandboxRecoveryState,
+  workspaceSandboxRecoveryFromError,
+  workspaceSandboxRecoveryMessage,
+  workspaceSandboxRecoveryRecommendedActions,
+  workspaceSandboxRecoveryDiagnostic,
+  preferredWorkspaceSandboxRecoveryBoxKey,
+  shouldRestoreWorkspaceSandboxRecovery,
+  createWorkspaceSandboxRecoveryManager,
+  WORKSPACE_SANDBOX_RECOVERY_ACTIONS,
+  WORKSPACE_SANDBOX_RECOVERY_CODES,
   serializeSandboxProvisioningError,
   formatSandboxProvisioningSupportDetails,
   isSandboxAuthFailure,
@@ -1998,4 +2224,4 @@ export {
   isTerminalPromptEvent,
   detectInteractiveQuestion
 };
-//# sourceMappingURL=chunk-QGHQ2IRC.js.map
+//# sourceMappingURL=chunk-4XNCMUVI.js.map