remote-codex 0.11.27 → 0.11.28

package/README.md

@@ -103,6 +103,18 @@ remote-codex relay-supervisor
 `45679` is used by default in copied setup commands to avoid common local
 `8787` port conflicts. You can change it if needed.
 
+By default, `remote-codex relay-supervisor` starts itself inside a detached
+`tmux` session so closing the terminal does not take the device offline. Manage
+it with:
+
+```bash
+remote-codex relay-supervisor status
+remote-codex relay-supervisor stop
+```
+
+If `tmux` is not installed it runs in the foreground. Use
+`remote-codex relay-supervisor run` for explicit foreground/debug mode.
+
 ### Local Mode
 
 ```bash
@@ -247,6 +259,17 @@ remote-codex relay-supervisor
 
 复制命令默认使用 `45679`，用于避开本机常见的 `8787` 端口冲突；需要时可以手动换。
 
+默认情况下，`remote-codex relay-supervisor` 会尝试启动到 detached `tmux`
+session 里，这样关闭终端窗口不会让设备下线。可以用下面命令管理：
+
+```bash
+remote-codex relay-supervisor status
+remote-codex relay-supervisor stop
+```
+
+如果设备没有安装 `tmux`，它会自动退回前台运行。需要显式前台调试时使用
+`remote-codex relay-supervisor run`。
+
 ### 本地模式
 
 ```bash

package/apps/supervisor-api/dist/index.js

@@ -18362,6 +18362,9 @@ var ThreadDetailAssembler = class {
       input.record.model,
       input.record.reasoningEffort
     );
+    const persistedItemsByTurnIdForPatch = this.input.callbacks.listPersistedHistoryItemsByTurnId(
+      input.localThreadId
+    );
     const activeDisplayTurnId = this.input.liveState.displayTurnIdForRuntimeTurn(
       input.localThreadId,
       input.record.providerTurnId
@@ -18373,6 +18376,15 @@ var ThreadDetailAssembler = class {
     if (input.record.providerTurnId && threadPatch.status === "idle" && activeLiveItems && activeLiveItems.items.length > 0) {
       threadPatch.status = "running";
     }
+    const latestPersistedFailure = latestPersistedFailureAfter(
+      persistedItemsByTurnIdForPatch,
+      input.turnMetadataById,
+      newestRemoteTurnStartedAt(remoteSession.turns)
+    );
+    if (threadPatch.status !== "running" && latestPersistedFailure) {
+      threadPatch.status = "failed";
+      threadPatch.lastError = latestPersistedFailure.error;
+    }
     const nextThreadPatch = {
       ...threadPatch,
       ...threadPatch.status !== "running" ? { providerTurnId: null } : {}
@@ -18400,8 +18412,17 @@ var ThreadDetailAssembler = class {
       this.input.liveState,
       input.turnMetadataById
     );
-    const orderedVisibleTurns = applyLiveAgentMessageOrderingHints(
+    const visibleTurnsWithPersistedFailures = appendPersistedFailureTurnsIfMissing(
       visibleTurnsWithActiveLiveTurn,
+      persistedItemsByTurnId,
+      input.turnMetadataById,
+      {
+        includeAllMissing: shouldCacheFullDetail,
+        includeLatestMissing: options.beforeTurnId === void 0
+      }
+    );
+    const orderedVisibleTurns = applyLiveAgentMessageOrderingHints(
+      visibleTurnsWithPersistedFailures,
       input.localThreadId,
       this.input.liveState
     );
@@ -18447,13 +18468,16 @@ var ThreadDetailAssembler = class {
       input.record,
       latestThreadTurnMetadata(input.turnMetadataById)
     );
-    const localTurns = localSession?.turns ?? [...persistedItemsByTurnId.keys()].map((turnId) => ({
-      id: turnId,
-      startedAt: null,
-      status: "completed",
-      error: null,
-      items: []
-    }));
+    const localTurns = localSession?.turns ?? [...persistedItemsByTurnId.entries()].map(([turnId, items]) => {
+      const error = persistedTurnError(items);
+      return {
+        id: turnId,
+        startedAt: input.turnMetadataById.get(turnId)?.createdAt ?? null,
+        status: error ? "failed" : "completed",
+        error,
+        items: []
+      };
+    });
     const turns = mergePersistedHistoryItemsIntoTurns(
       applyRecordedTurnItemOrders(
         localTurns,
@@ -18552,6 +18576,87 @@ function appendActiveLiveTurnIfMissing(turns, localThreadId, providerTurnId, liv
     }
   ];
 }
+function appendPersistedFailureTurnsIfMissing(turns, persistedItemsByTurnId, metadataById, options) {
+  if (persistedItemsByTurnId.size === 0) {
+    return turns;
+  }
+  const existingTurnIds = new Set(turns.map((turn) => turn.id));
+  const newestVisibleStartedAt = newestStartedAt(turns);
+  const missingFailureTurns = [];
+  for (const [turnId, items] of persistedItemsByTurnId.entries()) {
+    if (existingTurnIds.has(turnId)) {
+      continue;
+    }
+    const error = persistedTurnError(items);
+    if (!error) {
+      continue;
+    }
+    const startedAt = metadataById.get(turnId)?.createdAt ?? earliestItemCreatedAt(items);
+    const shouldInclude = options.includeAllMissing || options.includeLatestMissing && (!newestVisibleStartedAt || !startedAt || startedAt >= newestVisibleStartedAt);
+    if (!shouldInclude) {
+      continue;
+    }
+    missingFailureTurns.push({
+      id: turnId,
+      startedAt,
+      status: "failed",
+      error,
+      items: []
+    });
+  }
+  if (missingFailureTurns.length === 0) {
+    return turns;
+  }
+  return sortTurnsByStartedAt([...turns, ...missingFailureTurns]);
+}
+function persistedTurnError(items) {
+  const failedItem = [...items].reverse().find(
+    (item) => item.status === "failed" || item.status === "error"
+  );
+  return failedItem?.text?.trim() || null;
+}
+function earliestItemCreatedAt(items) {
+  return items.map((item) => item.createdAt).filter((value) => Boolean(value)).sort()[0] ?? null;
+}
+function newestStartedAt(turns) {
+  return turns.map((turn) => turn.startedAt).filter((value) => Boolean(value)).sort().at(-1) ?? null;
+}
+function newestRemoteTurnStartedAt(turns) {
+  return turns.map((turn) => turn.startedAt).filter((value) => Boolean(value)).sort().at(-1) ?? null;
+}
+function latestPersistedFailureAfter(persistedItemsByTurnId, metadataById, timestamp) {
+  let latest = null;
+  for (const [turnId, items] of persistedItemsByTurnId.entries()) {
+    const error = persistedTurnError(items);
+    if (!error) {
+      continue;
+    }
+    const startedAt = metadataById.get(turnId)?.createdAt ?? earliestItemCreatedAt(items);
+    if (timestamp && startedAt && startedAt < timestamp) {
+      continue;
+    }
+    if (!latest || !latest.startedAt && startedAt || latest.startedAt && startedAt && startedAt > latest.startedAt) {
+      latest = { error, startedAt };
+    }
+  }
+  return latest;
+}
+function sortTurnsByStartedAt(turns) {
+  return turns.map((turn, index) => ({ turn, index })).sort((left, right) => {
+    const leftStartedAt = left.turn.startedAt;
+    const rightStartedAt = right.turn.startedAt;
+    if (!leftStartedAt && !rightStartedAt) {
+      return left.index - right.index;
+    }
+    if (!leftStartedAt) {
+      return 1;
+    }
+    if (!rightStartedAt) {
+      return -1;
+    }
+    return leftStartedAt.localeCompare(rightStartedAt) || left.index - right.index;
+  }).map(({ turn }) => turn);
+}
 function buildTurnDto(turn, metadata) {
   const tokenUsage = parseThreadTurnTokenUsageJson(metadata?.tokenUsageJson);
   const displayPrompt = metadata?.displayPrompt?.trim();
@@ -19005,10 +19110,20 @@ var ThreadManagementCoordinator = class {
 };
 
 // src/thread-prompt-turn-coordinator.ts
+import { randomUUID as randomUUID3 } from "crypto";
 function isAutoGeneratedTitle(title) {
   const normalized = title?.trim();
   return !normalized || normalized === "Untitled thread" || normalized === "Thread";
 }
+function errorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function promptStartFailureMessage(error, runtime, fallbackProvider) {
+  const providerLabel = runtime.displayName || fallbackProvider || "Agent backend";
+  const rawMessage = errorMessage3(error).trim() || "Unknown error.";
+  const codeLabel = error instanceof AgentRuntimeError ? ` (${error.code})` : "";
+  return `${providerLabel} failed to start this turn${codeLabel}: ${rawMessage}`;
+}
 var ThreadPromptTurnCoordinator = class {
   constructor(db, liveState, providerRuntime, callbacks) {
     this.db = db;
@@ -19051,7 +19166,22 @@ var ThreadPromptTurnCoordinator = class {
     if (input.displayTurnId) {
       startTurnInput.displayTurnId = input.displayTurnId;
     }
-    const turn = await runtime.startTurn(startTurnInput);
+    let turn;
+    try {
+      turn = await runtime.startTurn(startTurnInput);
+    } catch (error) {
+      const failureMessage = promptStartFailureMessage(error, runtime, record.provider);
+      this.persistPromptStartFailure(localThreadId, record, input, {
+        displayPrompt,
+        message: failureMessage,
+        modelRecords,
+        pricingSnapshot
+      });
+      throw new HttpError(503, {
+        code: "service_unavailable",
+        message: failureMessage
+      });
+    }
     const displayTurnId = input.displayTurnId ?? turn.providerTurnId;
     if (displayTurnId !== turn.providerTurnId) {
       this.liveState.setRuntimeDisplayTurnMapping(localThreadId, {
@@ -19104,6 +19234,80 @@ var ThreadPromptTurnCoordinator = class {
     const updated = getThreadRecordById(this.db, localThreadId);
     return this.callbacks.toThreadDto(updated, /* @__PURE__ */ new Set([record.providerSessionId]));
   }
+  persistPromptStartFailure(localThreadId, record, input, failure) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const displayTurnId = input.displayTurnId ?? `local-failed-${randomUUID3()}`;
+    const items = input.hidden ? [
+      {
+        id: `${displayTurnId}:error`,
+        kind: "agentMessage",
+        text: failure.message,
+        status: "failed",
+        createdAt: now,
+        transcriptOrder: 0,
+        sourceTurnId: displayTurnId
+      }
+    ] : [
+      {
+        id: `${displayTurnId}:user`,
+        kind: "userMessage",
+        text: failure.displayPrompt,
+        createdAt: now,
+        transcriptOrder: 0
+      },
+      {
+        id: `${displayTurnId}:error`,
+        kind: "agentMessage",
+        text: failure.message,
+        status: "failed",
+        createdAt: now,
+        transcriptOrder: 1,
+        sourceTurnId: displayTurnId
+      }
+    ];
+    upsertThreadTurnMetadata(this.db, {
+      threadId: localThreadId,
+      turnId: displayTurnId,
+      model: input.effectiveModel,
+      reasoningEffort: input.normalizedReasoning,
+      reasoningEffortAvailable: this.providerRuntime.reasoningEffortAvailableForModel(
+        failure.modelRecords,
+        input.effectiveModel
+      ),
+      pricingModelKey: failure.pricingSnapshot?.pricingModelKey ?? null,
+      pricingTierKey: failure.pricingSnapshot?.pricingTierKey ?? null,
+      displayPrompt: input.hidden ? null : failure.displayPrompt
+    });
+    for (const item of items) {
+      upsertThreadHistoryItemRecord(this.db, {
+        threadId: localThreadId,
+        turnId: displayTurnId,
+        itemId: item.id,
+        itemJson: JSON.stringify(item)
+      });
+    }
+    const patch = {
+      providerTurnId: displayTurnId,
+      status: "failed",
+      lastError: failure.message,
+      lastTurnStartedAt: now,
+      lastTurnCompletedAt: now,
+      model: input.effectiveModel,
+      reasoningEffort: input.normalizedReasoning,
+      collaborationMode: input.collaborationMode,
+      sandboxMode: input.sandboxMode
+    };
+    if (!input.hidden) {
+      patch.summaryText = failure.displayPrompt;
+      if (isAutoGeneratedTitle(record.title)) {
+        patch.title = truncateAutoThreadTitle(failure.displayPrompt);
+      }
+    }
+    updateThreadRecord(this.db, localThreadId, patch);
+    this.liveState.setLivePlan(localThreadId, null);
+    this.liveState.setLiveItems(localThreadId, null);
+    this.callbacks.invalidateThreadDetailCache(localThreadId);
+  }
   async steerOrStartPromptTurn(localThreadId, record, input) {
     const runtime = this.callbacks.runtimeForProvider(record.provider);
     let steerTurnId = record.providerTurnId;
@@ -19214,15 +19418,16 @@ function normalizeCollaborationMode(value) {
   return value === "plan" ? "plan" : "default";
 }
 function buildThreadPatch(remoteSession, model, reasoningEffort) {
-  const failedTurn = "turns" in remoteSession ? remoteSession.turns.find((turn) => turn.status === "failed") : null;
+  const latestTurn = "turns" in remoteSession ? remoteSession.turns.at(-1) ?? null : null;
+  const latestStatus = latestTurn?.status === "failed" ? "failed" : latestTurn?.status === "interrupted" ? "interrupted" : remoteSession.status;
   return {
     provider: remoteSession.provider,
     providerSessionId: remoteSession.providerSessionId,
-    status: remoteSession.status,
+    status: latestStatus,
     summaryText: remoteSession.preview || null,
     model: model ?? null,
     reasoningEffort: normalizeReasoningEffort2(reasoningEffort),
-    lastError: failedTurn?.error?.message ?? null,
+    lastError: latestTurn?.status === "failed" ? latestTurn.error?.message ?? "Turn failed." : null,
     updatedAt: remoteSession.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -21287,7 +21492,7 @@ var ThreadForkCoordinator = class {
 };
 
 // src/thread-attachment-coordinator.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import fs12 from "fs/promises";
 import path16 from "path";
 async function pathExists(absPath) {
@@ -21305,7 +21510,7 @@ function sanitizeAttachmentFileName(originalName) {
   const sanitizedStem = rawStem.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 64);
   const stem = sanitizedStem || "attachment";
   const normalizedExtension = extension.slice(0, 16);
-  return `${stem}-${randomUUID3().slice(0, 8)}${normalizedExtension}`;
+  return `${stem}-${randomUUID4().slice(0, 8)}${normalizedExtension}`;
 }
 function threadTempDirectoryPath2(workspacePath, localThreadId) {
   return path16.join(workspacePath, ".temp", "threads", localThreadId);
@@ -25010,7 +25215,7 @@ async function registerAuthRoutes(app2) {
 // src/provider-host-config-service.ts
 import fs20 from "fs/promises";
 import path23 from "path";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 function providerError(message, statusCode = 404) {
   const error = new Error(message);
   error.statusCode = statusCode;
@@ -25158,7 +25363,7 @@ var ProviderHostConfigService = class {
     const providerHome = this.providerHome(provider2);
     const fileNames = this.archiveFileNames(provider2);
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-    const id = `${createdAt.replace(/[-:.TZ]/g, "").slice(0, 14)}-${randomUUID4().slice(0, 8)}`;
+    const id = `${createdAt.replace(/[-:.TZ]/g, "").slice(0, 14)}-${randomUUID5().slice(0, 8)}`;
     const archivePath = resolveArchivePath(providerHome, id);
     const files = Object.fromEntries(
       fileNames.map((name) => [