synabun 2.1.0 → 2.2.1

package/neural-interface/lib/mcp-external-servers.js

@@ -10,7 +10,9 @@ const object = value => value && typeof value === 'object' && !Array.isArray(val
 const canonical = path => { try { return realpathSync(path); } catch { return resolve(path); } };
 const claudeProject = (user, cwd) => user.projects?.[canonical(cwd)] || user.projects?.[resolve(cwd)] || {};
 const external = name => name !== 'SynaBun';
-export const EXTERNAL_SERVER_LIMITATIONS = Object.freeze({ codex: 'Plugin-provided MCP servers cannot be enumerated from config.toml', 'claude-code': 'claude.ai connectors are unavailable under strict MCP configuration' });
+export const EXTERNAL_SERVER_LIMITATIONS = Object.freeze({ codex: 'Plugin-provided MCP servers cannot be enumerated from config.toml', 'claude-code': 'claude.ai connectors are unavailable under strict MCP configuration', antigravity: 'A project\'s own .agents/mcp_config.json still loads into an Antigravity session; managed brains, workers and restricted panel sessions refuse enabled project servers before starting agy' });
+/** Where Antigravity keeps its MCP servers: { mcpServers: { name: { command, args, env, disabled } | { serverUrl, headers, disabled } } }. */
+export function antigravityMcpConfigPath(home = homedir()) { return join(home, '.gemini', 'config', 'mcp_config.json'); }
 export const externalServerName = name => typeof name === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/.test(name) && external(name);
 function read(path, fallback = null) {
   try { return readFileSync(path, 'utf8'); }
@@ -144,7 +146,7 @@ export function claudePluginDefinitions(pluginRoot, manifest = document(join(plu
 function claudeEntry(entry) { return structuredClone(entry); }
 
 /** This is the only filesystem discovery boundary; definitions never escape through servers/catalogView. */
-export function externalServerInventory({ provider, cwd = process.cwd(), codexHome, home = homedir(), dataHome, registry, opencodeConfig, readProject = true, env = process.env } = {}) {
+export function externalServerInventory({ provider, cwd = process.cwd(), codexHome, home = homedir(), dataHome, registry, opencodeConfig, antigravityConfigPath = antigravityMcpConfigPath(home), readProject = true, env = process.env } = {}) {
   const reg = registry || (dataHome ? document(join(dataHome, 'data', 'mcp-registry.json')) : {});
   const access = agentAccessFrom(reg), definitions = new Map(), rows = new Map();
   function add(name, entry, source, deliverable = true, reason = null, kind = null) {
@@ -172,6 +174,13 @@ export function externalServerInventory({ provider, cwd = process.cwd(), codexHo
     for (const [name, entry] of Object.entries(mcpServersOf(base))) add(name, entry, 'user');
     if (env.OPENCODE_CONFIG) for (const [name, entry] of Object.entries(mcpServersOf(document(resolve(env.OPENCODE_CONFIG))))) add(name, entry, 'user-override');
     if (readProject) for (const path of projectOpenCodeConfigs(cwd)) for (const [name, entry] of Object.entries(mcpServersOf(document(path)))) add(name, entry, 'project');
+  } else if (provider === 'antigravity') {
+    // A remote server names its address `serverUrl` there; `disabled: true` turns it off in Antigravity itself.
+    for (const [name, entry] of Object.entries(object(document(antigravityConfigPath).mcpServers))) {
+      const own = object(entry);
+      const url = typeof own.serverUrl === 'string' ? own.serverUrl : own.url;
+      add(name, url !== undefined && own.url === undefined ? { ...own, url } : own, 'user', true, null, url !== undefined ? 'http' : 'stdio');
+    }
   } else if (provider === 'claude-code') {
     const configDir = env.CLAUDE_CONFIG_DIR || join(home, '.claude');
     const settings = { ...document(join(configDir, 'settings.json')), ...document(join(cwd, '.claude', 'settings.json')), ...document(join(cwd, '.claude', 'settings.local.json')) };
@@ -247,8 +256,8 @@ export function selectExternalServers(tools, inventory) {
 }
 export function externalCatalog(options = {}) {
   const rows = new Map();
-  for (const provider of ['codex', 'opencode', 'claude-code']) for (const row of discoverExternalServers({ ...options, provider })) {
-    if (!rows.has(row.name)) rows.set(row.name, { ref: `mcp:${row.name}`, label: row.name, selectable: row.selectable, providers: { codex: 'absent', opencode: 'absent', 'claude-code': 'absent' }, blocked: row.blocked });
+  for (const provider of ['codex', 'opencode', 'claude-code', 'antigravity']) for (const row of discoverExternalServers({ ...options, provider })) {
+    if (!rows.has(row.name)) rows.set(row.name, { ref: `mcp:${row.name}`, label: row.name, selectable: row.selectable, providers: { codex: 'absent', opencode: 'absent', 'claude-code': 'absent', antigravity: 'absent' }, blocked: row.blocked });
     rows.get(row.name).providers[provider] = row.blocked ? 'blocked' : row.deliverable ? 'deliverable' : 'unavailable';
   }
   return [...rows.values()].sort((a, b) => a.ref.localeCompare(b.ref));
@@ -310,14 +319,38 @@ export async function waitForClaudeMcpScope(q, names, { timeoutMs = 30000 } = {}
   }
   throw Object.assign(new Error('Claude MCP scope could not be enforced before the first turn'), { code: 'MCP_SCOPE_UNENFORCED' });
 }
+/** Values shorter than this are never redacted: a short or common word would be erased from ordinary output. */
+export const MIN_MCP_SECRET_LENGTH = 8;
 export function redactMcpValues(value, values) {
-  if (typeof value === 'string') { for (const secret of [...new Set(values)].filter(Boolean).sort((a, b) => b.length - a.length)) value = value.split(secret).join('[MCP value]'); return value; }
+  if (typeof value === 'string') { for (const secret of [...new Set(values)].filter(item => typeof item === 'string' && item.length >= MIN_MCP_SECRET_LENGTH).sort((a, b) => b.length - a.length)) value = value.split(secret).join('[MCP value]'); return value; }
   if (Array.isArray(value)) return value.map(item => redactMcpValues(item, values));
   if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactMcpValues(item, values)]));
   return value;
 }
 
-export function mcpDefinitionValues(servers) {
+const SECRET_QUERY_NAME = /token|key|secret|auth|pass|pwd|sig|credential|session|code/i;
+/** The secrets a URL carries (userinfo, credential-named query values), never the URL itself. */
+export function urlSecretValues(url) {
+  if (typeof url !== 'string' || !url) return [];
+  let parsed; try { parsed = new URL(url); } catch { return []; }
+  const out = [];
+  for (const part of [parsed.username, parsed.password]) if (part) { out.push(part); try { out.push(decodeURIComponent(part)); } catch {} }
+  for (const [name, value] of parsed.searchParams) if (value && SECRET_QUERY_NAME.test(name)) { out.push(value); out.push(encodeURIComponent(value)); }
+  return out;
+}
+
+/**
+ * The real secrets of MCP server definitions: env / environment and header values, authToken, oauth strings
+ * and the secrets inside a URL. Never command, args, cwd, type or a whole URL, and never SynaBun's own entry
+ * (its headers name the project, terminal and role: ordinary words). `${VAR}` / `{env:VAR}` references are
+ * expanded through `env` when given. Values under MIN_MCP_SECRET_LENGTH are dropped.
+ */
+export function mcpSecretValues(servers, { env = null, exclude = ['SynaBun'] } = {}) {
   const strings = value => typeof value === 'string' ? [value] : Array.isArray(value) ? value.flatMap(strings) : value && typeof value === 'object' ? Object.values(value).flatMap(strings) : [];
-  return [...new Set(Object.values(servers || {}).flatMap(entry => ['command', 'args', 'cwd', 'env', 'environment', 'headers', 'url', 'oauth', 'headersHelper', 'authToken'].flatMap(field => strings(entry[field]))))].filter(Boolean);
+  const expand = value => env ? value.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}|\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (whole, a, b) => env[a || b] ?? whole) : value;
+  const values = Object.entries(servers || {}).filter(([name]) => !exclude.includes(name)).flatMap(([, entry]) => entry && typeof entry === 'object' ? [
+    ...['env', 'environment', 'headers', 'oauth', 'authToken'].flatMap(field => strings(entry[field])).flatMap(value => { const bare = /^(?:Bearer|Basic|Token|Bot)\s+(\S.*)$/i.exec(value); return bare ? [value, bare[1]] : [value]; }),
+    ...urlSecretValues(entry.url),
+  ] : []).map(expand);
+  return [...new Set(values)].filter(value => value.length >= MIN_MCP_SECRET_LENGTH);
 }

package/neural-interface/lib/mcp-installer.js

@@ -422,7 +422,8 @@ function scanHints(repoPath) {
   const hints = [];
   if (existsSync(join(repoPath, '.claude-plugin', 'plugin.json'))) hints.push('claude-plugin');
   if (existsSync(join(repoPath, '.codex'))) hints.push('codex');
-  if (existsSync(join(repoPath, 'gemini-extension.json'))) hints.push('gemini');
+  // Antigravity's plugins: its own manifests, and the Gemini CLI extensions `agy plugin install` imports.
+  if (['gemini-extension.json', join('.antigravity-plugin', 'plugin.json'), join('.gemini-plugin', 'plugin.json')].some((file) => existsSync(join(repoPath, file)))) hints.push('antigravity');
   if (existsSync(join(repoPath, '.cursor'))) hints.push('cursor');
   if (existsSync(join(repoPath, '.windsurf'))) hints.push('windsurf');
   return hints;

package/neural-interface/lib/memory-session-capture.js

@@ -4,10 +4,24 @@ import { detectProject } from '../../mcp-server/dist/config.js';
 import { normalizeMemoryEvents, ingestMemoryEvents } from '../../mcp-server/dist/services/memory-sessions.js';
 import { maintenancePaused } from './memory-timers.js';
 
-export function queueMemoryCapture({host,sessionId,filePath,project,cwd}) {
-  if(!filePath || !sessionId || !['claude-code','codex'].includes(host))return;
+/** The hosts whose transcripts are captured from a file (OpenCode's rows are taken in session-cache-builder.js). */
+export const CAPTURE_HOSTS=Object.freeze(['claude-code','codex','antigravity']);
+
+/**
+ * `size`: the transcript's size now, when the caller knows it. A file already read to that size is left as it is
+ * (a pass over every Antigravity conversation would otherwise mark each one pending again).
+ */
+export function queueMemoryCapture({host,sessionId,filePath,project,cwd,size=null}) {
+  if(!filePath || !sessionId || !CAPTURE_HOSTS.includes(host))return;
+  if(size!=null) {
+    const row=getDb().prepare('SELECT file_path,byte_offset,status,cwd FROM memory_capture_files WHERE host=? AND session_id=?').get(host,sessionId);
+    if(row && row.status==='complete' && row.file_path===filePath && Number(row.byte_offset)===Number(size) && (row.cwd || null)===(cwd || null))return;
+  }
+  // An Antigravity conversation whose folder agy named only later is read again from its start: its events take the
+  // project (each step keeps its source id, so nothing is stored twice).
   getDb().prepare(`INSERT INTO memory_capture_files(host,session_id,file_path,project,cwd) VALUES(?,?,?,?,?)
-    ON CONFLICT(host,session_id) DO UPDATE SET file_path=excluded.file_path,project=excluded.project,cwd=excluded.cwd,status='pending',error=NULL`)
+    ON CONFLICT(host,session_id) DO UPDATE SET file_path=excluded.file_path,project=excluded.project,cwd=excluded.cwd,status='pending',error=NULL,
+      byte_offset=CASE WHEN excluded.host='antigravity' AND memory_capture_files.cwd IS NOT excluded.cwd THEN 0 ELSE memory_capture_files.byte_offset END`)
     .run(host,sessionId,filePath,cwd ? detectProject(cwd) : project || 'global',cwd || null);
 }
 

package/neural-interface/lib/morelogin.js

@@ -47,7 +47,8 @@ export function isMoreLoginInstalled() {
   } else if (process.platform === 'win32') {
     const { LOCALAPPDATA, ProgramFiles } = process.env;
     const PF86 = process.env['ProgramFiles(x86)'];
-    if (LOCALAPPDATA) candidates.push(`${LOCALAPPDATA}\\Programs\\MoreLogin\\MoreLogin.exe`, `${LOCALAPPDATA}\\MoreLogin\\MoreLogin.exe`);
+    if (process.env.MORELOGIN_APP_PATH) candidates.push(process.env.MORELOGIN_APP_PATH);
+    if (LOCALAPPDATA) candidates.push(`${LOCALAPPDATA}\\Programs\\MoreLogin\\MoreLogin.exe`, `${LOCALAPPDATA}\\Programs\\morelogin\\MoreLogin.exe`, `${LOCALAPPDATA}\\MoreLogin\\MoreLogin.exe`);
     if (ProgramFiles) candidates.push(`${ProgramFiles}\\MoreLogin\\MoreLogin.exe`);
     if (PF86) candidates.push(`${PF86}\\MoreLogin\\MoreLogin.exe`);
   } else {
@@ -100,40 +101,147 @@ function buildHeaders(opts = {}) {
 
 /**
  * Low-level POST to the MoreLogin local API. Returns the `data` payload.
- * Throws with a `.code` of MORELOGIN_UNREACHABLE | MORELOGIN_HTTP | MORELOGIN_API.
+ * Throws with a `.code` of MORELOGIN_UNREACHABLE | MORELOGIN_HTTP | MORELOGIN_API | MORELOGIN_SHAPE
+ * (answered 2xx with a body that is not JSON).
+ */
+// Loopback hosts to try, in order. MoreLogin's local server may listen on IPv6 only
+// (an Electron server bound to "localhost" resolves to ::1 first on Windows), so a
+// refused 127.0.0.1 is retried on [::1]. The host that answered is remembered.
+const LOOPBACK_HOSTS = ['127.0.0.1', '[::1]'];
+let _preferredHost = LOOPBACK_HOSTS[0];
+let _lastAnswerAt = 0; // when the local API last answered anything (any status, any body)
+export function _resetMoreLoginHostForTests() { _preferredHost = LOOPBACK_HOSTS[0]; _lastAnswerAt = 0; }
+export function _preferredMoreLoginHostForTests() { return _preferredHost; }
+
+/** Whether the local API answered within the last `withinMs` (no request is made). */
+export function moreLoginApiAnsweredRecently(withinMs = 120000) {
+  return _lastAnswerAt > 0 && Date.now() - _lastAnswerAt <= withinMs;
+}
+
+/**
+ * Cheap, synchronous "is MoreLogin here": the exe is in a known folder (or
+ * MORELOGIN_APP_PATH) or its local API answered recently. Callers that need a
+ * fresh answer probe first (probeMoreLoginApi).
+ */
+export function isMoreLoginPresent(withinMs = 120000) {
+  let exe = false;
+  try { exe = isMoreLoginInstalled().installed; } catch { exe = false; }
+  return exe || moreLoginApiAnsweredRecently(withinMs);
+}
+
+// Error codes that prove the connection never opened, so the request was never
+// delivered and the other loopback host may be tried even for a call that changes
+// state (create, start). Anything else (a reset after sending, a malformed answer)
+// may have reached MoreLogin: it is thrown, never sent a second time.
+const NEVER_CONNECTED_CODES = new Set([
+  'ECONNREFUSED', 'EHOSTUNREACH', 'ENETUNREACH', 'EADDRNOTAVAIL', 'EAFNOSUPPORT', 'ENOTFOUND',
+  'EAI_AGAIN', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_CONNECT',
+]);
+export function _neverConnected(err) {
+  for (let e = err, i = 0; e && i < 4; e = e.cause, i++) {
+    if (NEVER_CONNECTED_CODES.has(e.code)) return true;
+    if (Array.isArray(e.errors) && e.errors.some(x => NEVER_CONNECTED_CODES.has(x?.code))) return true;
+  }
+  return false;
+}
+
+/**
+ * One deadline for the whole call (opts.timeout, default 15 s): each loopback host
+ * gets what is left of it, so two hosts never double the budget. The other host is
+ * tried while time remains when the first one provably never connected; a timeout
+ * is tried on the other host only for a read (opts.idempotent), since a timed-out
+ * write may have been received.
  */
 async function request(path, body, opts = {}) {
   const port = opts.port || getMoreLoginPort(opts.savedCfg);
-  const url = `http://127.0.0.1:${port}${path}`;
+  const fetchImpl = opts.fetch || fetch;
+  const idempotent = opts.idempotent ?? (path === '/api/env/page' || path === '/api/env/status');
+  const budget = opts.timeout || 15000;
+  const deadline = Date.now() + budget;
+  const hosts = [_preferredHost, ...LOOPBACK_HOSTS.filter(h => h !== _preferredHost)];
   let res;
-  try {
-    res = await fetch(url, {
-      method: 'POST',
-      headers: buildHeaders(opts),
-      body: JSON.stringify(body || {}),
-      signal: AbortSignal.timeout(opts.timeout || 15000),
-    });
-  } catch (err) {
-    const e = new Error(`MoreLogin API unreachable on :${port} (${err?.message || err})`);
+  let lastErr = null;
+  for (const host of hosts) {
+    const left = deadline - Date.now();
+    if (left <= 0) break;
+    try {
+      res = await fetchImpl(`http://${host}:${port}${path}`, {
+        method: 'POST',
+        headers: buildHeaders(opts),
+        body: JSON.stringify(body || {}),
+        signal: AbortSignal.timeout(left),
+      });
+      _preferredHost = host;
+      _lastAnswerAt = Date.now();
+      break;
+    } catch (err) {
+      lastErr = err;
+      const timedOut = err?.name === 'TimeoutError' || err?.name === 'AbortError';
+      const retry = _neverConnected(err) || (timedOut && idempotent);
+      if (!retry) break;
+    }
+  }
+  if (!res) {
+    const err = lastErr;
+    const reason = !err ? `no time left of ${budget} ms` : (err?.cause?.code || err?.code || err?.message || err);
+    const e = new Error(`MoreLogin API unreachable on :${port} (${reason})`);
     e.code = 'MORELOGIN_UNREACHABLE';
     throw e;
   }
   let json = null;
+  let unparsable = false;
   try { json = await res.json(); }
-  catch { try { await res.body?.cancel(); } catch { /* ignore */ } }
+  catch { unparsable = true; try { await res.body?.cancel(); } catch { /* ignore */ } }
   if (!res.ok) {
-    const e = new Error(`MoreLogin API ${path} → HTTP ${res.status}`);
+    const detail = json && (json.msg || json.message);
+    const e = new Error(`MoreLogin API ${path} → HTTP ${res.status}${detail ? ` (${detail})` : ''}${res.status === 401 || res.status === 403 ? ' (set the API ID and API Key from MoreLogin → Settings → API in SynaBun Settings → MoreLogin)' : ''}`);
     e.code = 'MORELOGIN_HTTP';
     e.status = res.status;
     throw e;
   }
   if (json && json.code !== undefined && json.code !== 0) {
-    const e = new Error(`MoreLogin API ${path}: ${json.msg || `code ${json.code}`}`);
+    const msg = json.msg || json.message || `code ${json.code}`;
+    const e = new Error(`MoreLogin API ${path}: ${msg}${looksLikeAuthError(json.code, msg) ? ' (set the API ID and API Key from MoreLogin → Settings → API in SynaBun Settings → MoreLogin)' : ''}`);
     e.code = 'MORELOGIN_API';
     e.apiCode = json.code;
     throw e;
   }
-  return json ? json.data : null;
+  if (unparsable || !json || typeof json !== 'object') {
+    const type = res.headers?.get?.('content-type') || 'no content type';
+    const e = new Error(`MoreLogin API ${path} answered HTTP ${res.status} with a body that is not JSON (${type}); is something else listening on port ${port}?`);
+    e.code = 'MORELOGIN_SHAPE';
+    throw e;
+  }
+  return json.data;
+}
+
+function looksLikeAuthError(code, msg) {
+  return /auth|sign|api.?key|api.?id|nonce|unauthori[sz]ed|forbidden|permission|token/i.test(String(msg || ''))
+    || code === 401 || code === 403;
+}
+
+const PROFILE_LIST_KEYS = ['dataList', 'list', 'records', 'rows'];
+
+/** Profile rows across response shapes: data.dataList | data.list | data.records | data.rows | data (array). A non-empty array wins over an empty one. */
+export function profileRows(data) {
+  if (Array.isArray(data)) return data;
+  if (!data || typeof data !== 'object') return [];
+  const arrays = PROFILE_LIST_KEYS.map(k => data[k]).filter(Array.isArray);
+  return arrays.find(a => a.length) || arrays[0] || [];
+}
+
+/** Whether a profile-page answer has a shape SynaBun reads (an array, a known list key, or a total). */
+export function hasProfileShape(data) {
+  if (Array.isArray(data)) return true;
+  if (!data || typeof data !== 'object') return false;
+  return PROFILE_LIST_KEYS.some(k => Array.isArray(data[k])) || (data.total != null && Number.isFinite(Number(data.total)));
+}
+
+function shapeError(data) {
+  const keys = data && typeof data === 'object' ? Object.keys(data).slice(0, 8).join(', ') : typeof data;
+  const e = new Error(`MoreLogin API /api/env/page answered in a shape SynaBun does not read (data: ${keys || 'empty'}); a newer MoreLogin may have changed its API`);
+  e.code = 'MORELOGIN_SHAPE';
+  return e;
 }
 
 /**
@@ -171,19 +279,29 @@ function normalizeProfile(e = {}) {
 /** List browser profiles (environments). Returns normalized rows. */
 export async function listProfiles(opts = {}) {
   const data = await request('/api/env/page', { pageNo: opts.pageNo || 1, pageSize: opts.pageSize || 100 }, opts);
-  const list = (data && (data.dataList || data.list)) || [];
-  return list.map(normalizeProfile).filter(p => p.id);
+  if (!hasProfileShape(data)) throw shapeError(data);
+  return profileRows(data).map(normalizeProfile).filter(p => p.id);
 }
 
-/** Lightweight reachability probe. Never throws — returns {running, count}. */
+/**
+ * Lightweight reachability probe. Never throws — returns {running, count}.
+ * `running` means the local API answered at all: an answer that is an HTTP or API
+ * error (signature required, API disabled, ...) still proves MoreLogin is up, and its
+ * reason is returned in `apiError` instead of being reported as "not running".
+ */
 export async function probeMoreLoginApi(opts = {}) {
   try {
     const data = await request('/api/env/page', { pageNo: 1, pageSize: 1 }, { ...opts, timeout: opts.timeout || 4000 });
-    const total = data && data.total != null ? Number(data.total)
-      : (data && (data.dataList || data.list) ? (data.dataList || data.list).length : 0);
+    if (!hasProfileShape(data)) throw shapeError(data);
+    const total = data && !Array.isArray(data) && data.total != null ? Number(data.total) : profileRows(data).length;
     return { running: true, count: Number.isFinite(total) ? total : 0 };
   } catch (err) {
-    return { running: false, count: 0, error: err?.message || String(err), errCode: err?.code || null };
+    const answered = err?.code === 'MORELOGIN_HTTP' || err?.code === 'MORELOGIN_API' || err?.code === 'MORELOGIN_SHAPE';
+    return {
+      running: answered, count: 0,
+      error: err?.message || String(err), errCode: err?.code || null,
+      ...(answered ? { apiError: err?.message || String(err) } : {}),
+    };
   }
 }
 
@@ -221,13 +339,17 @@ export async function getMoreLoginStatus(opts = {}) {
   const port = getMoreLoginPort(opts.savedCfg);
   const probe = await probeMoreLoginApi({ ...opts, port });
   return {
-    installed: inst.installed,
+    // An answering local API is proof of an install, wherever it lives (a custom
+    // install folder on Windows is not among the known paths).
+    installed: inst.installed || probe.running,
     appPath: inst.path,
     port,
     running: probe.running,
+    apiError: probe.apiError || null,
     profileCount: probe.count || 0,
     signed: !!((opts.appId || process.env.MORELOGIN_API_ID) && (opts.secretKey || process.env.MORELOGIN_SECRET)),
-    error: probe.error || null,
+    // Transport failures only: an API that answered with an error is running, and says why in apiError.
+    error: probe.running ? null : (probe.error || null),
   };
 }
 
@@ -259,7 +381,7 @@ export async function startProfile(envId, opts = {}) {
   try {
     data = await request('/api/env/start', { envId: String(envId), ...(opts.startArgs || {}) }, opts);
   } catch (err) {
-    if (err?.code === 'MORELOGIN_UNREACHABLE' || err?.code === 'MORELOGIN_HTTP') throw err;
+    if (err?.code === 'MORELOGIN_UNREACHABLE' || err?.code === 'MORELOGIN_HTTP' || err?.code === 'MORELOGIN_SHAPE') throw err;
     // MORELOGIN_API (e.g. "already running") → fall through to status recovery.
   }
   let port = extractDebugPort(data);