@mmmbuto/nexuscrew 0.9.76 → 0.9.77

package/frontend/dist/index.html

@@ -11,7 +11,7 @@
   <meta name="apple-mobile-web-app-title" content="NexusCrew" />
   <link rel="manifest" href="/manifest.json" />
   <title>NexusCrew</title>
-  <script type="module" crossorigin src="/assets/index-BURtPwUi.js"></script>
+  <script type="module" crossorigin src="/assets/index-Cgd3OQws.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-B9GW2LHm.css">
 </head>
 <body>

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.76"}
+{"version":"0.9.77"}

package/lib/fleet/builtin.js

@@ -41,7 +41,7 @@ const {
   CATALOG, CLIENT_LABELS, CLIENT_ORDER, engineClient, ordinaEngine, isStandardClient,
   credential: resolveProfileCredential, extraModelsFrom, knownMcpServerNames, profileFor,
   normalizeManagedSpec, codexSurfaceNames,
-  engineModelDiscoveryPlan, ollamaCloudCatalogModels, declaredModelsFor, ALIBABA_PI_MODELS,
+  engineModelDiscoveryPlan, modelListingCredential, ollamaCloudCatalogModels, declaredModelsFor, ALIBABA_PI_MODELS,
 } = require('./managed.js');
 const { probeModel, probeCustomEndpoint } = require('./model-probe.js');
 const { createModelDiscovery, DISCOVERY_PROPOSAL_CAP } = require('./model-discovery.js');
@@ -1823,6 +1823,23 @@ async function createBuiltinFleet(cfg = {}) {
       ...(cause ? { cause } : {}),
     };
   }
+  // Backup proposals for fields no layer could fill: the missing-data dialog
+  // offers what the internal catalog knows, and the operator's confirmation
+  // is what turns a proposal into a user value.
+  function withBackupDefaults(records, profile) {
+    const internalIndex = internalModelIndex(profile);
+    return (Array.isArray(records) ? records : []).map((m) => {
+      const backupValues = {};
+      for (const field of ['contextWindow', 'maxTokens']) {
+        if (m[field] === undefined) {
+          const known = internalValueFor(internalIndex, m.id);
+          if (known && known[field] !== undefined) backupValues[field] = known[field];
+        }
+      }
+      return Object.keys(backupValues).length ? { ...m, backupValues } : m;
+    });
+  }
+
   async function discoverEngineModels(engineId, opts = {}) {
     const id = String(engineId || '');
     if (!id || id.length > 64 || !/^[A-Za-z0-9._-]+$/.test(id)) {
@@ -1843,16 +1860,10 @@ async function createBuiltinFleet(cfg = {}) {
       spec = profile ? { client: profile.client, provider: profile.provider, ...(profile.credentialProfile ? { credentialProfile: profile.credentialProfile } : {}) } : null;
     }
     if (!profile) { const e = new Error(`engine sconosciuto: ${id}`); e.status = 404; throw e; }
-    const plan = engineModelDiscoveryPlan(profile, spec, cfg, home, id);
-    if (!plan) {
-      // No HTTP listing to interrogate (login/native flows, local providers
-      // without a base URL): an honest empty answer, never an error, so the
-      // editor stays usable. The UI hides the section on `supported: false`.
-      return { engine: id, supported: false, source: 'unsupported', models: [] };
-    }
     // User layer: models declared in fleet.json for this engine (or its
     // profile) — the values the operator chose, always on top and never
-    // rewritten by discovery.
+    // rewritten by discovery. Built BEFORE the plan: an engine without a
+    // listing still has ids worth enriching.
     const extraModels = extraModelsFrom(defs);
     const userModels = [];
     const seenUser = new Set();
@@ -1876,33 +1887,57 @@ async function createBuiltinFleet(cfg = {}) {
     }
     const backupModels = backupModelsFor(profile);
     const wanted = [...new Set([...userModels, ...backupModels].map((m) => m.id))].slice(0, 32);
+    // The plan is the HTTP listing, when the profile has one. When it does
+    // not, the same composition still runs with the API layer explicitly
+    // unavailable: known ids are enriched from the public snapshot, with no
+    // invented collector, request or auth attempt.
+    const plan = engineModelDiscoveryPlan(profile, spec, cfg, home, id);
+    // The active model is configuration the operator already chose. It counts
+    // as a known id only when it is the ONLY one: with a declared model or a
+    // profile backup the proposal already has its ids, and adding it would
+    // duplicate a row or change the order.
+    const activeModel = spec && typeof spec.model === 'string' ? spec.model.trim() : '';
+    const knownIds = !userModels.length && !backupModels.length && activeModel ? [activeModel] : [];
     const result = await engineModelDiscovery.discoverEngine({
-      ...plan,
+      ...(plan || {}),
+      engine: id,
       home,
       userModels, backupModels,
+      knownIds,
       ...(wanted.length ? { detailIds: wanted } : {}),
-      publicCatalog: { provider: profile.provider, baseUrl: plan.baseUrl, ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}) },
+      publicCatalog: {
+        provider: profile.provider,
+        ...(plan && plan.baseUrl ? { baseUrl: plan.baseUrl } : {}),
+        ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
+      },
       ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
       ...(opts.refresh === true ? { noCache: true } : {}),
+      ...(plan ? {} : { apiAvailable: false }),
     });
     // Curated response: `plan` (baseUrl, apiKey) stays out; apiModels is
-    // already merged (with provenance) into `models`.
-    // `backupValues` rides along only for fields NO layer could fill: the
-    // internal catalog's proposal for the missing-data dialog. A field any
-    // layer answered carries no proposal — the dialog asks for what nobody
-    // knows, and the operator's confirmation is what turns a proposal into a
-    // user value.
-    const internalIndex = internalModelIndex(profile);
-    const models = result.models.map((m) => {
-      const backupValues = {};
-      for (const field of ['contextWindow', 'maxTokens']) {
-        if (m[field] === undefined) {
-          const known = internalValueFor(internalIndex, m.id);
-          if (known && known[field] !== undefined) backupValues[field] = known[field];
-        }
-      }
-      return Object.keys(backupValues).length ? { ...m, backupValues } : m;
-    });
+    // already merged (with provenance) into `models`. `backupValues` rides
+    // along only for fields NO layer could fill.
+    const models = withBackupDefaults(result.models, profile);
+    if (!plan) {
+      const cred = modelListingCredential(profile, spec, cfg, home);
+      return {
+        engine: id,
+        supported: false,
+        source: 'unsupported',
+        status: result.status,
+        stale: false,
+        error: '',
+        auth: {
+          credentialState: cred.credentialState,
+          ...(cred.envKey ? { envKey: cred.envKey } : {}),
+          attempted: false,
+          credentialSent: false,
+        },
+        ...(result.publicCatalog ? { publicCatalog: result.publicCatalog } : {}),
+        models,
+        cap: DISCOVERY_PROPOSAL_CAP,
+      };
+    }
     return {
       engine: id,
       supported: true,

package/lib/fleet/managed.js

@@ -1313,52 +1313,72 @@ const sharedModelDiscovery = createModelDiscovery();
 // (catalog engines) the profile id IS the engine id.
 function engineModelDiscoveryPlan(profile, spec, cfg, home, engineId) {
   if (!profile) return null;
-  const specBase = spec && typeof spec.baseUrl === 'string' && /^https?:\/\//i.test(spec.baseUrl) ? spec.baseUrl : '';
-  const profileBase = typeof profile.endpoint === 'string' && /^https?:\/\//i.test(profile.endpoint) ? profile.endpoint : '';
+  const httpUrl = (value) => (typeof value === 'string' && /^https?:\/\//i.test(value) ? value : '');
+  // Endpoint precedence follows the launcher: the normalized spec, the
+  // generated provider extension, then the profile's own endpoint. A native
+  // provider has no explicit endpoint here, and is never pointed at another
+  // client's profile.
+  const specBase = httpUrl(spec && spec.baseUrl);
+  const extensionBase = httpUrl(profile.piExtension && profile.piExtension.baseUrl);
+  const profileBase = httpUrl(profile.endpoint);
+  // The wire name may come hyphenated (`openai-completions`, the Pi form) or
+  // underscored (the normalized form). It is the same transport.
+  const rawWire = spec && typeof spec.protocol === 'string' && spec.protocol
+    ? spec.protocol : (typeof profile.protocol === 'string' ? profile.protocol : '');
+  const wire = rawWire.replace(/-/g, '_');
   let collector = null;
   let baseUrl = '';
   if (profile.provider === 'ollama' || profile.provider === 'ollama-cloud') {
+    // Ollama speaks its own listing API, whatever wire a client uses for chat.
     collector = 'ollama';
-    baseUrl = specBase || profileBase || 'http://127.0.0.1:11434';
+    baseUrl = specBase || extensionBase || profileBase || 'http://127.0.0.1:11434';
   } else if (profile.provider === 'lmstudio') {
     collector = 'lmstudio';
-    baseUrl = specBase || 'http://127.0.0.1:1234';
-  } else if (profile.protocol === 'anthropic_messages') {
+    baseUrl = specBase || extensionBase || 'http://127.0.0.1:1234';
+  } else if (wire === 'anthropic_messages') {
     collector = 'anthropic';
-    baseUrl = specBase || profileBase;
-  } else if (profile.protocol === 'openai_responses' || profile.protocol === 'openai_completions') {
+    baseUrl = specBase || extensionBase || profileBase;
+  } else if (wire === 'openai_responses' || wire === 'openai_completions') {
     collector = 'openai-compat';
-    baseUrl = specBase || profileBase;
+    baseUrl = specBase || extensionBase || profileBase;
   } else {
+    // `pi_native`, login flows and any other client-owned wire: no explicit
+    // listing contract, so no collector. An explicit endpoint alone is not
+    // proof of a listing API.
     return null;
   }
   if (!baseUrl) return null;
-  const plan = { engine: engineId || profile.id, collector, baseUrl };
-  // The credential STATE travels with the plan, from the same resolution the
-  // launcher uses (the caller never re-reads the credential sources):
-  // none / configured / missing / unavailable, plus the env NAME when one
-  // exists and the editor already shows it. A file that exists but cannot be
-  // read is "unavailable", not "missing" — the same distinction describeManaged
-  // makes for launching. The value, its provenance paths/hashes and any
-  // exception text stay here: the plan hands the key to the collector in
-  // memory and nothing else leaves.
+  return { engine: engineId || profile.id, collector, baseUrl, ...modelListingCredential(profile, spec, cfg, home) };
+}
+
+// Credential resolution for a model listing, from the same path the launcher
+// uses (the caller never re-reads the credential sources): none / configured /
+// missing / unavailable, plus the env NAME when one exists and the editor
+// already shows it. A file that exists but cannot be read is "unavailable",
+// not "missing" — the same distinction describeManaged makes for launching.
+// The value, its provenance paths/hashes and any exception text stay here:
+// the value is handed to a collector in memory and nothing else leaves. An
+// engine with no listing still gets the STATE: the diagnosis refers to the
+// listing only, never to the client's own login.
+function modelListingCredential(profile, spec, cfg, home) {
+  const out = { credentialState: 'unavailable' };
   try {
     const cred = credential(profile, spec || {}, cfg, home, { blocked: [] });
-    plan.credentialState = !cred ? 'unavailable'
+    out.credentialState = !cred ? 'unavailable'
       : cred.value ? 'configured'
         : cred.source === 'unreadable' ? 'unavailable'
           : cred.source === 'missing' ? 'missing'
             : 'none';
-    if (cred && cred.value) plan.apiKey = cred.value;
+    if (cred && cred.value) out.apiKey = cred.value;
     const envKey = cred && typeof cred.envKey === 'string' ? cred.envKey : '';
     // 'login'/'none' resolve to a pseudo key name: never invent one for them.
-    if (plan.credentialState !== 'none' && ENV_KEY_RE.test(envKey || '')) plan.envKey = envKey;
+    if (out.credentialState !== 'none' && ENV_KEY_RE.test(envKey || '')) out.envKey = envKey;
   } catch (_) {
     // Resolution itself failed: the key is not known to be missing — it is
     // unavailable, and an anonymous rejection will say exactly that.
-    plan.credentialState = 'unavailable';
+    out.credentialState = 'unavailable';
   }
-  return plan;
+  return out;
 }
 async function discoverOllamaModels(opts = {}) {
   const now = Date.now(); const ttl = opts.ttlMs === undefined ? 30000 : opts.ttlMs;
@@ -3165,7 +3185,7 @@ module.exports = {
   OPENCODE_GO_MESSAGES_MODELS, OPENCODE_GO_RESPONSES_MODELS, OPENCODE_GO_CHAT_MODELS, OPENCODE_GO_LIMITS,
   OPENCODE_GO_ANTHROPIC_ROOT, OPENCODE_GO_API_BASE,
   CLIENT_LABELS, CLIENT_ORDER, engineClient, ordinaEngine, isStandardClient, normalizeManagedSpec, profileFor,
-  defaultDefinitions, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, defaultGrokEngine, defaultVlEngine, describeManaged, describeCatalogCredential, discoverOllamaModels, engineModelDiscoveryPlan, resolveManagedEngine, needsExplicitNode,
+  defaultDefinitions, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, defaultGrokEngine, defaultVlEngine, describeManaged, describeCatalogCredential, discoverOllamaModels, engineModelDiscoveryPlan, modelListingCredential, resolveManagedEngine, needsExplicitNode,
   discoverPiModels, EXTERNAL_DISCOVERY_TIMEOUT_MS, parseEnvFile, parseProviderShellFile, findBinary, publicCatalog, writePiProviderExtension, customCatalogFor,
   codexSurfaceNames, writeCellCodexProfile,
   writeVlCellPrompt, vlSystemAppendGate,

package/lib/fleet/model-discovery.js

@@ -44,7 +44,9 @@ const CACHE_VERSION = 1;
 const MAX_SHOW_CALLS = 32;      // Ollama /api/show: only listed ids the caller asked about
 const ANTHROPIC_MAX_PAGES = 5;  // pagination safety bound
 const ANTHROPIC_VERSION = '2023-06-01';
-const MODEL_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
+// Bracketed markers such as `[1m]` are part of the model id the fleet file
+// accepts; they are kept intact and never stripped for a basename match.
+const MODEL_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:/\[\]-]{0,127}$/;
 const ENGINE_KEY_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/;
 const MERGE_FIELDS = Object.freeze(['contextWindow', 'maxTokens', 'tools', 'vision', 'reasoning', 'deprecated']);
 
@@ -986,24 +988,37 @@ function createModelDiscovery({ fetchImpl: defaultFetchImpl = globalThis.fetch,
   async function discoverEngine(opts = {}) {
     const {
       userModels = [], backupModels = [], publicCatalogModels, publicCatalog,
-      cap = DISCOVERY_PROPOSAL_CAP,
+      cap = DISCOVERY_PROPOSAL_CAP, apiAvailable = true, knownIds = [],
     } = opts;
-    const layer = await fetchEngineModels(opts);
+    // An engine with no listing endpoint still has ids worth enriching: the
+    // declared models and the profile backup. There is no API layer at all —
+    // not a fake collector and not a fake fetch — so the merge runs with the
+    // API explicitly unavailable and never claims an API answer.
+    const layer = apiAvailable
+      ? await fetchEngineModels(opts)
+      : { status: 'unsupported', fetchedAt: 0, apiModels: [], stale: false, error: '', disappeared: [] };
     let publicModels = Array.isArray(publicCatalogModels) ? publicCatalogModels : [];
     let publicLayer = null;
+    // Ids that are known from configuration but are not a user declaration
+    // (for example the engine's own active model). They join the public layer
+    // as bare ids: they can be enriched, never invented with values, and they
+    // stay after the declared ids in the proposal order.
+    const configuredIds = (Array.isArray(knownIds) ? knownIds : [])
+      .filter((id) => typeof id === 'string' && id);
+    const knownLayerIds = [...(layer.disappeared || []), ...configuredIds];
     if (!Array.isArray(publicCatalogModels) && publicCatalog) {
       publicLayer = await resolvePublicCatalogLayer(
-        opts, layer.apiModels, userModels, backupModels, layer.disappeared || []
+        opts, layer.apiModels, userModels, backupModels, knownLayerIds
       );
       publicModels = publicLayer.records;
     }
-    const apiKnown = layer.status !== 'backup';
+    const apiKnown = apiAvailable && layer.status !== 'backup';
     const models = mergeModelRecords({
       userModels,
       apiModels: layer.apiModels,
       publicCatalogModels: publicModels,
       backupModels,
-      knownModels: (layer.disappeared || []).map((id) => ({ id })),
+      knownModels: knownLayerIds.map((id) => ({ id })),
       apiKnown,
       fetchedAt: layer.fetchedAt || now(),
       cap,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscrew",
-  "version": "0.9.76",
+  "version": "0.9.77",
   "description": "Faithful browser tmux client — attach to live sessions over a real PTY, localhost-only, mobile-easy",
   "main": "lib/server.js",
   "bin": {