remote-codex 0.11.42 → 0.11.44

package/apps/relay-server/dist/index.js

@@ -4702,6 +4702,10 @@ function buildRelayServer(config2, options = {}) {
               parsed.clientId
             );
             const eventThreadId = threadIdFromSocketPayload(parsed.payload);
+            const shellEventForClient = clientConnection ? isShellEventForClient(
+              parsed.payload,
+              clientConnection.attachedShellId
+            ) : false;
             if (clientConnection) {
               const freshAccess = store.effectiveAccess(
                 clientConnection.user.id,
@@ -4724,7 +4728,7 @@ function buildRelayServer(config2, options = {}) {
                 clientConnection.user.id
               );
               const connectionControlEvent = parsed.payload.type === "supervisor.connected" || parsed.payload.type === "supervisor.pong";
-              if (isolation?.enabled && !connectionControlEvent && (!eventThreadId || !store.ownsHostedThread(
+              if (isolation?.enabled && !connectionControlEvent && !shellEventForClient && (!eventThreadId || !store.ownsHostedThread(
                 isolation.sandboxId,
                 clientConnection.user.id,
                 eventThreadId
@@ -4734,7 +4738,8 @@ function buildRelayServer(config2, options = {}) {
             }
             if (clientConnection && clientConnection.socket.readyState === WEBSOCKET_OPEN && shouldForwardSocketEvent(
               parsed.payload,
-              clientConnection.threadId
+              clientConnection.threadId,
+              clientConnection.attachedShellId
             )) {
               clientConnection.socket.send(JSON.stringify(parsed.payload));
             }
@@ -5319,6 +5324,7 @@ function connectRelayWebsocket(supervisor, socket, store, user, deviceId, thread
   supervisor.clientSockets.set(clientId, {
     socket,
     threadId,
+    attachedShellId: null,
     deviceId,
     user,
     access
@@ -5351,6 +5357,10 @@ function connectRelayWebsocket(supervisor, socket, store, user, deviceId, thread
       socket.close(1008, "Shared read-only session cannot control supervisor.");
       return;
     }
+    const attachedShellId = shellAttachIdFromSocketPayload(payload);
+    if (clientConnection && attachedShellId) {
+      clientConnection.attachedShellId = attachedShellId;
+    }
     sendToSupervisor(supervisor, {
       type: "relay.client.message",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6047,14 +6057,25 @@ function isAllowedSharedWorkspacePath(access, methodName, pathname, workspaceId)
   ];
   return ["POST", "PUT", "PATCH", "DELETE"].includes(methodName) && writePatterns.some((pattern) => pattern.test(pathname));
 }
-function shouldForwardSocketEvent(event, threadId) {
+function shouldForwardSocketEvent(event, threadId, attachedShellId) {
   if (!threadId) {
     return true;
   }
   if (event.type === "supervisor.connected" || event.type === "supervisor.pong") {
     return true;
   }
-  return "threadId" in event && event.threadId === threadId;
+  if ("threadId" in event && event.threadId === threadId) {
+    return true;
+  }
+  return isShellEventForClient(event, attachedShellId);
+}
+function shellAttachIdFromSocketPayload(payload) {
+  return isObject(payload) && payload.type === "shell.attach" && typeof payload.shellId === "string" ? payload.shellId : null;
+}
+function isShellEventForClient(event, attachedShellId) {
+  return Boolean(
+    attachedShellId && event.type.startsWith("shell.") && "shellId" in event && event.shellId === attachedShellId
+  );
 }
 function relayRequestBody(body) {
   if (body === void 0 || body === null) {

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

@@ -12089,7 +12089,7 @@ function mapModelInfo(model, index) {
   return {
     id: model.value,
     model: model.value,
-    displayName: model.displayName,
+    displayName: versionedClaudeModelDisplayName(model),
     description: model.description,
     isDefault: index === 0,
     hidden: false,
@@ -12100,11 +12100,48 @@ function mapModelInfo(model, index) {
     defaultReasoningEffort: model.supportsEffort ? "medium" : null
   };
 }
+function versionedClaudeModelDisplayName(model) {
+  const resolved = model.resolvedModel?.match(
+    /^claude-(sonnet|opus|haiku|fable)-(\d+)(?:-(\d+))?(?:-|\[|$)/i
+  );
+  if (!resolved) {
+    return model.displayName;
+  }
+  const family = `${resolved[1][0].toUpperCase()}${resolved[1].slice(1).toLowerCase()}`;
+  const version2 = resolved[3] ? `${resolved[2]}.${resolved[3]}` : resolved[2];
+  if (model.value === "default") {
+    return `Default \xB7 ${family} ${version2}`;
+  }
+  const qualifier = model.displayName.match(/\s*(\([^)]+\))\s*$/)?.[1];
+  return `${family} \xB7 ${version2}${qualifier ? ` ${qualifier}` : ""}`;
+}
+function versionedAlias(alias, discovered, qualifier) {
+  if (!discovered) {
+    return alias;
+  }
+  return {
+    ...alias,
+    displayName: `${discovered.displayName.replace(/\s+\([^)]+\)\s*$/, "")}${qualifier ?? ""}`,
+    description: discovered.description,
+    supportedReasoningEfforts: discovered.supportedReasoningEfforts,
+    defaultReasoningEffort: discovered.defaultReasoningEffort
+  };
+}
 function withClaudeCodeModelAliases(models) {
-  const output = [...models];
-  const defaultSonnet = DEFAULT_CLAUDE_MODELS[0];
-  const oneMillionSonnet = DEFAULT_CLAUDE_MODELS[1];
-  const fable = DEFAULT_CLAUDE_MODELS[2];
+  const discoveredSonnet = models.find((model) => /^Sonnet · /.test(model.displayName));
+  const discoveredFable = models.find((model) => /^Fable · /.test(model.displayName));
+  const discoveredOpus = models.find((model) => /^Opus · /.test(model.displayName));
+  const output = models.filter(
+    (model) => model !== discoveredFable || discoveredFable.model === "fable"
+  );
+  const defaultSonnet = versionedAlias(DEFAULT_CLAUDE_MODELS[0], discoveredSonnet);
+  const oneMillionSonnet = versionedAlias(
+    DEFAULT_CLAUDE_MODELS[1],
+    discoveredSonnet,
+    " (1M context)"
+  );
+  const fable = versionedAlias(DEFAULT_CLAUDE_MODELS[2], discoveredFable);
+  const opus = versionedAlias(DEFAULT_CLAUDE_MODELS[3], discoveredOpus);
   const hasSonnetAlias = output.some((model) => model.model === "sonnet");
   if (!hasSonnetAlias) {
     output.unshift(defaultSonnet);
@@ -12115,6 +12152,10 @@ function withClaudeCodeModelAliases(models) {
   if (!output.some((model) => model.model === "fable")) {
     output.splice(2, 0, fable);
   }
+  if (!output.some((model) => model.model === "opus")) {
+    const discoveredOpusIndex = output.findIndex((model) => /^Opus · /.test(model.displayName));
+    output.splice(discoveredOpusIndex >= 0 ? discoveredOpusIndex : output.length, 0, opus);
+  }
   return output.map((model, index) => ({
     ...model,
     isDefault: index === 0
@@ -12613,6 +12654,7 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
   subscriptionUsageWindows = /* @__PURE__ */ new Map();
   subscriptionAuthKind = "unknown";
   subscriptionUsageObservedAt = null;
+  modelOptionsCache = null;
   historicalTurnIdAliases = /* @__PURE__ */ new Map();
   clientApp;
   sdkLoadError = null;
@@ -12733,14 +12775,33 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
   }
   async listModels() {
     const active = [...this.activeTurns.values()][0];
-    if (!active) {
-      return DEFAULT_CLAUDE_MODELS;
+    if (!active && this.modelOptionsCache) {
+      return this.modelOptionsCache;
     }
+    let query = active?.query ?? null;
     try {
-      const models = await active.query.supportedModels();
-      return withClaudeCodeModelAliases(models.map(mapModelInfo));
+      query ??= this.queryFactory({
+        prompt: "",
+        options: queryOptionsForRuntime({
+          home: this.options.home,
+          command: this.options.command,
+          clientApp: this.clientApp,
+          approvalMode: "guarded",
+          includePartialMessages: false,
+          tools: [],
+          maxTurns: 1
+        })
+      });
+      const models = await query.supportedModels();
+      const mapped = withClaudeCodeModelAliases(models.map(mapModelInfo));
+      this.modelOptionsCache = mapped;
+      return mapped;
     } catch {
-      return DEFAULT_CLAUDE_MODELS;
+      return this.modelOptionsCache ?? DEFAULT_CLAUDE_MODELS;
+    } finally {
+      if (!active && query) {
+        query.close();
+      }
     }
   }
   async listSessions() {