devez-vibe 1.9.34 → 1.9.36

package/bridge/claude-agent-sdk-bridge.mjs

@@ -330,10 +330,40 @@ function catalogEntry(model, defaultResolvedModel) {
   };
 }
 
+function compareVersions(left, right) {
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const difference = (left[index] ?? 0) - (right[index] ?? 0);
+    if (difference) return difference;
+  }
+  return 0;
+}
+
+/** Each family's newest model in CLAUDE_MODEL_ORDER first, then older ones by family and version. */
+function sortClaudeModels(models) {
+  const ranked = models.map((model) => {
+    const [family = "", version = ""] = compactClaudeModelName(model).toLowerCase().split(" ");
+    return { model, family, version: version.match(/\d+/g)?.map(Number) ?? [] };
+  });
+  const newest = new Map();
+  for (const { family, version } of ranked) {
+    if (!newest.has(family) || compareVersions(version, newest.get(family)) > 0) newest.set(family, version);
+  }
+  const tier = (entry) => (compareVersions(entry.version, newest.get(entry.family)) === 0 ? 0 : 1);
+  const familyOrder = ({ family }) => {
+    const index = CLAUDE_MODEL_ORDER.indexOf(family);
+    return index < 0 ? CLAUDE_MODEL_ORDER.length : index;
+  };
+  return ranked
+    .sort((left, right) => tier(left) - tier(right)
+      || familyOrder(left) - familyOrder(right)
+      || compareVersions(right.version, left.version))
+    .map(({ model }) => model);
+}
+
 function claudeCatalogEntries(models, defaultResolvedModel) {
-  const catalogModels = models.filter((model) => model.value && model.value !== "default"
+  const catalogModels = sortClaudeModels(models.filter((model) => model.value && model.value !== "default"
     && ![model.value, model.resolvedModel]
-      .some((name) => stripClaudeModel(String(name || "")).startsWith(RETIRED_OPUS_MODEL)));
+      .some((name) => stripClaudeModel(String(name || "")).startsWith(RETIRED_OPUS_MODEL))));
   const entries = catalogModels.map((model) => catalogEntry(model, defaultResolvedModel));
   const existingIndex = entries.findIndex((entry) =>
     stripClaudeModel(entry.model) === PREVIOUS_OPUS_MODEL
@@ -401,14 +431,6 @@ async function loadModelCatalog(params) {
       const defaultResolvedModel = String(
         models.find((model) => model.value === "default")?.resolvedModel || "",
       );
-      models.sort((left, right) => {
-        const leftFamily = String(left.value || "").match(/(fable|opus|sonnet|haiku)/i)?.[1]?.toLowerCase();
-        const rightFamily = String(right.value || "").match(/(fable|opus|sonnet|haiku)/i)?.[1]?.toLowerCase();
-        const leftOrder = CLAUDE_MODEL_ORDER.indexOf(leftFamily);
-        const rightOrder = CLAUDE_MODEL_ORDER.indexOf(rightFamily);
-        return (leftOrder < 0 ? CLAUDE_MODEL_ORDER.length : leftOrder)
-          - (rightOrder < 0 ? CLAUDE_MODEL_ORDER.length : rightOrder);
-      });
       return {
         data: claudeCatalogEntries(models, defaultResolvedModel),
       };
@@ -1463,11 +1485,41 @@ async function createSession(params, resumeId) {
     session.model = visibleModel(capabilities.value);
   }
   session.effort = supportedEffort(capabilities, params.effort);
+  watchMcpStartup(session);
   const account = initialization.account || await safeAccount(agentQuery);
   const usage = await safeUsage(agentQuery);
   return { session, initialization, account, usage };
 }
 
+// Claude connects MCP servers in the background and reports a failure only
+// through mcpServerStatus(). Once nothing is pending, each failed or signed-out
+// server goes to the host as Codex's startup notification, so both providers
+// warn the same way. The first look waits a second so the host already knows
+// this thread when the notice arrives.
+async function watchMcpStartup(session, attempts = 30, delay = 1000) {
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    if (sessions.get(session.id) !== session) return;
+    let statuses;
+    try { statuses = await session.query.mcpServerStatus(); } catch { return; }
+    if (!Array.isArray(statuses)) return;
+    if (statuses.some((server) => server?.status === "pending")) continue;
+    for (const server of statuses) {
+      if (server?.status !== "failed" && server?.status !== "needs-auth") continue;
+      const source = server.source || server.scope;
+      notify("mcpServer/startupStatus/updated", {
+        threadId: session.id,
+        name: String(server.name || "MCP"),
+        status: "failed",
+        ...(server.status === "needs-auth" ? { failureReason: "authenticationRequired" } : {}),
+        ...(server.error ? { error: String(server.error) } : {}),
+        ...(source ? { source: String(source) } : {}),
+      });
+    }
+    return;
+  }
+}
+
 async function safeAccount(agentQuery) {
   try { return await agentQuery.accountInfo(); } catch { return null; }
 }
@@ -4230,6 +4282,39 @@ async function runSelfTest() {
   if (reconnected.join(",") !== "connected,disabled") {
     throw new Error(`Claude MCP reconnect self-test failed: ${reconnected.join(",")}`);
   }
+  // Startup failures wait out pending servers, then go out once each.
+  const startupPolls = [
+    [{ name: "slow", status: "pending" }],
+    [
+      { name: "ok", status: "connected" },
+      { name: "broken", status: "failed", error: "HTTP 401: token_expired" },
+      { name: "claude.ai Notion", status: "needs-auth", scope: "claudeai" },
+    ],
+  ];
+  const startupSession = {
+    id: "mcp-startup-self-test",
+    query: { mcpServerStatus: async () => startupPolls.shift() || [] },
+  };
+  sessions.set(startupSession.id, startupSession);
+  const startupNotices = [];
+  const startupWrite = process.stdout.write;
+  process.stdout.write = (chunk) => { startupNotices.push(JSON.parse(String(chunk))); return true; };
+  try {
+    await watchMcpStartup(startupSession, 3, 0);
+  } finally {
+    process.stdout.write = startupWrite;
+    sessions.delete(startupSession.id);
+  }
+  const startupNames = startupNotices.map((notice) => notice.params?.name).join(",");
+  if (startupNames !== "broken,claude.ai Notion"
+    || startupNotices.some((notice) => notice.method !== "mcpServer/startupStatus/updated"
+      || notice.params?.threadId !== startupSession.id
+      || notice.params?.status !== "failed")
+    || startupNotices[0].params.error !== "HTTP 401: token_expired"
+    || startupNotices[1].params.failureReason !== "authenticationRequired"
+    || startupNotices[1].params.source !== "claudeai") {
+    throw new Error(`Claude MCP startup self-test failed: ${JSON.stringify(startupNotices)}`);
+  }
   const user = (uuid, text) => ({
     type: "user",
     uuid,
@@ -4575,6 +4660,19 @@ async function runSelfTest() {
     ) !== "max") {
     throw new Error(`Claude pinned model self-test failed: ${JSON.stringify(catalog)}`);
   }
+  const orderedNames = claudeCatalogEntries([
+    { value: "haiku", displayName: "Haiku 4.5" },
+    { value: "claude-sonnet-4-6", displayName: "Sonnet 4.6" },
+    { value: "fable", displayName: "Fable 5" },
+    { value: "opus", resolvedModel: "claude-opus-5-5", displayName: "Opus" },
+    { value: "sonnet", displayName: "Sonnet 5" },
+    { value: "claude-opus-6", displayName: "Opus 6" },
+    { value: "claude-fable-5-1", displayName: "Fable 5.1" },
+    { value: "nova", displayName: "Nova 1" },
+  ].map((model) => ({ resolvedModel: model.value, ...model })), "").filter((entry) => !entry.hidden).map((entry) => entry.displayName).join(",");
+  if (orderedNames !== "Fable 5.1,Opus 6,Sonnet 5,Haiku 4.5,Nova 1,Fable 5,Opus 5.5,Sonnet 4.6") {
+    throw new Error(`Claude model order self-test failed: ${orderedNames}`);
+  }
   const inheritedFork = forkSessionSelection(
     { model: "claude:sonnet", effort: "high" },
     { model: "claude:opus", effort: "max" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devez-vibe",
-  "version": "1.9.34",
+  "version": "1.9.36",
   "type": "module",
   "description": "Stable terminal UI for Codex and Claude Agent SDK",
   "keywords": [