remote-codex 0.11.27 → 0.11.29

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/relay-server/dist/index.js

@@ -697,7 +697,9 @@ var RelayStore = class _RelayStore {
         device_id TEXT NOT NULL REFERENCES relay_devices(id) ON DELETE CASCADE,
         device_name TEXT,
         thread_id TEXT NOT NULL,
+        thread_title TEXT,
         workspace_id TEXT,
+        workspace_label TEXT,
         label TEXT,
         thread_access TEXT NOT NULL DEFAULT 'control',
         workspace_access TEXT NOT NULL DEFAULT 'none',
@@ -747,7 +749,9 @@ var RelayStore = class _RelayStore {
     `);
     this.ensureColumn("relay_users", "last_seen_at", "TEXT");
     this.ensureColumn("relay_devices", "token", "TEXT");
+    this.ensureColumn("relay_shares", "thread_title", "TEXT");
     this.ensureColumn("relay_shares", "workspace_id", "TEXT");
+    this.ensureColumn("relay_shares", "workspace_label", "TEXT");
     this.ensureColumn("relay_shares", "thread_access", "TEXT NOT NULL DEFAULT 'control'");
     this.ensureColumn("relay_shares", "workspace_access", "TEXT NOT NULL DEFAULT 'none'");
     this.ensureColumn("relay_shares", "expires_at", "TEXT");
@@ -934,9 +938,9 @@ var RelayStore = class _RelayStore {
       `
           INSERT INTO relay_shares (
             id, owner_user_id, owner_username, target_user_id, target_username,
-            device_id, device_name, thread_id, workspace_id, label,
+            device_id, device_name, thread_id, thread_title, workspace_id, workspace_label, label,
             thread_access, workspace_access, created_at, revoked_at, expires_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         `
     ).run(
       share.id,
@@ -947,7 +951,9 @@ var RelayStore = class _RelayStore {
       share.deviceId,
       share.deviceName,
       share.threadId,
+      share.threadTitle,
       share.workspaceId,
+      share.workspaceLabel,
       share.label,
       share.threadAccess,
       share.workspaceAccess,
@@ -956,6 +962,26 @@ var RelayStore = class _RelayStore {
       share.expiresAt
     );
   }
+  updateShareMetadata(shareId, input) {
+    const threadTitle = normalizeOptionalMetadata(input.threadTitle);
+    const workspaceLabel = normalizeOptionalMetadata(input.workspaceLabel);
+    if (threadTitle === void 0 && workspaceLabel === void 0) {
+      return this.rowToShare(
+        this.sqlite.prepare("SELECT * FROM relay_shares WHERE id = ?").get(shareId)
+      );
+    }
+    this.sqlite.prepare(
+      `
+          UPDATE relay_shares
+          SET thread_title = COALESCE(?, thread_title),
+              workspace_label = COALESCE(?, workspace_label)
+          WHERE id = ?
+        `
+    ).run(threadTitle ?? null, workspaceLabel ?? null, shareId);
+    return this.rowToShare(
+      this.sqlite.prepare("SELECT * FROM relay_shares WHERE id = ?").get(shareId)
+    );
+  }
   getShareAccessEvents(shareId) {
     return this.sqlite.prepare(
       `
@@ -1129,9 +1155,9 @@ var RelayStore = class _RelayStore {
       deviceId: row.device_id,
       deviceName: row.device_name ?? "Remote Codex device",
       threadId: row.thread_id,
-      threadTitle: null,
+      threadTitle: row.thread_title ?? null,
       workspaceId: row.workspace_id ?? null,
-      workspaceLabel: null,
+      workspaceLabel: row.workspace_label ?? null,
       label: row.label,
       threadAccess: normalizeThreadAccess(row.thread_access),
       workspaceAccess: normalizeWorkspaceAccess(row.workspace_access),
@@ -1186,6 +1212,12 @@ function normalizeExpiresAt(value) {
   const timestamp = Date.parse(value);
   return Number.isNaN(timestamp) ? null : new Date(timestamp).toISOString();
 }
+function normalizeOptionalMetadata(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return value?.trim() || void 0;
+}
 function normalizeConversationWindowDays(value) {
   if (!Number.isFinite(value ?? NaN)) {
     return 7;
@@ -1461,7 +1493,7 @@ function buildRelayServer(config2, options = {}) {
     if (!user) {
       return;
     }
-    return enrichPortalSummary(store.portalSummary(user.id, connectionStatus(state)), state);
+    return enrichPortalSummary(store.portalSummary(user.id, connectionStatus(state)), state, store);
   });
   app2.get("/relay/access", async (request, reply) => {
     const user = requireRelayUser(request, reply, store);
@@ -2233,13 +2265,16 @@ async function fetchRelayThreads(supervisor, deviceId) {
   }
   return threads.slice(0, 80);
 }
-async function enrichPortalSummary(portal, state) {
+async function enrichPortalSummary(portal, state, store) {
   const threadCache = /* @__PURE__ */ new Map();
   const workspaceCache = /* @__PURE__ */ new Map();
   const enrichShare = async (share) => {
     const supervisor = state.supervisors.get(share.deviceId);
     if (!supervisor || supervisor.socket.readyState !== WEBSOCKET_OPEN) {
-      return share;
+      return {
+        ...share,
+        threadTitle: stableShareThreadTitle(share)
+      };
     }
     const threadCacheKey = `${share.deviceId}:${share.threadId}`;
     let threadTitlePromise = threadCache.get(threadCacheKey);
@@ -2266,10 +2301,16 @@ async function enrichPortalSummary(portal, state) {
       threadTitlePromise,
       workspaceLabelPromise
     ]);
+    if (threadTitle || workspaceLabel) {
+      store.updateShareMetadata(share.id, {
+        threadTitle,
+        workspaceLabel
+      });
+    }
     return {
       ...share,
-      threadTitle,
-      workspaceLabel
+      threadTitle: threadTitle ?? stableShareThreadTitle(share),
+      workspaceLabel: workspaceLabel ?? share.workspaceLabel
     };
   };
   const [sharedWithMe, sharedByMe] = await Promise.all([
@@ -2295,6 +2336,14 @@ async function fetchRelayWorkspaceLabel(supervisor, deviceId, workspaceId) {
   const payload = await forwardSupervisorJson(supervisor, deviceId, `/api/workspaces/${encodeURIComponent(workspaceId)}`);
   return stringField(payload, "label");
 }
+function stableShareThreadTitle(share) {
+  const threadTitle = share.threadTitle?.trim();
+  if (!threadTitle) {
+    return null;
+  }
+  const label = share.label?.trim();
+  return label && threadTitle === label ? null : threadTitle;
+}
 async function forwardSupervisorJson(supervisor, deviceId, targetPath, options = {}) {
   try {
     const response = await supervisor.requestBroker.forward(

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,16 @@ 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),
+      new Set(remoteSession.turns.map((turn) => turn.providerTurnId))
+    );
+    if (threadPatch.status !== "running" && latestPersistedFailure) {
+      threadPatch.status = "failed";
+      threadPatch.lastError = latestPersistedFailure.error;
+    }
     const nextThreadPatch = {
       ...threadPatch,
       ...threadPatch.status !== "running" ? { providerTurnId: null } : {}
@@ -18400,8 +18413,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 +18469,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 +18577,93 @@ 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, remoteTurnIds) {
+  let latest = null;
+  for (const [turnId, items] of persistedItemsByTurnId.entries()) {
+    if (persistedItemsBelongToRemoteTurn(turnId, items, remoteTurnIds)) {
+      continue;
+    }
+    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 persistedItemsBelongToRemoteTurn(turnId, items, remoteTurnIds) {
+  return remoteTurnIds.has(turnId) || items.some((item) => item.sourceTurnId && remoteTurnIds.has(item.sourceTurnId));
+}
+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 +19117,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 +19173,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 +19241,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 +19425,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 +21499,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 +21517,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 +25222,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 +25370,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) => [