@gakim-digital/dexter-bridge 0.11.6 → 0.11.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gakim-digital/dexter-bridge",
-  "version": "0.11.6",
+  "version": "0.11.8",
   "description": "Local bridge for InstaWebAI and Dexter — runs Codex, Claude Code, or OpenCode on your machine.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'node:url';
 import crossSpawn from 'cross-spawn';
 import {
   getFramerProjectAuthorization,
+  isCompanionPairingInvalidError,
   postRunEvent,
   reportFramerProjectAuthorizationVerification,
 } from './api.js';
@@ -1523,6 +1524,9 @@ async function callProviderAdapter(
         if (controlRequestsCancellation(response)) await requestCancel();
       })
       .catch((error) => {
+        if (isCompanionPairingInvalidError(error)) {
+          void requestCancel();
+        }
         if (!finished) {
           trace?.warn('adapter_activity_post_failed', {
             error: errorMeta(error),
@@ -1562,6 +1566,10 @@ async function callProviderAdapter(
         if (controlRequestsCancellation(response)) await requestCancel();
       } catch (error) {
         if (monitorAbort.signal.aborted) return;
+        if (isCompanionPairingInvalidError(error)) {
+          await requestCancel();
+          return;
+        }
         trace?.warn('adapter_control_poll_failed', { error: errorMeta(error) });
       }
     }
@@ -2006,6 +2014,9 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
           if (controlRequestsCancellation(response)) requestCliCancel();
         })
         .catch((error) => {
+          if (isCompanionPairingInvalidError(error)) {
+            requestCliCancel();
+          }
           if (!cliFinished) {
             options.trace?.warn('cli_activity_post_failed', {
               error: errorMeta(error),
@@ -2044,6 +2055,10 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
           if (cliCancelled) return;
         } catch (error) {
           if (monitorAbort.signal.aborted) return;
+          if (isCompanionPairingInvalidError(error)) {
+            requestCliCancel();
+            return;
+          }
           options.trace?.warn('cli_control_poll_failed', {
             error: errorMeta(error),
           });
@@ -2255,6 +2270,9 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
         }
       })
       .catch((error) => {
+        if (isCompanionPairingInvalidError(error)) {
+          void requestCancel('device_disconnect');
+        }
         if (!finished) {
           options.trace?.warn?.('outcome_activity_post_failed', {
             error: errorMeta(error),
@@ -2331,6 +2349,10 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
           await requestCancel(controlCancellationSource(response));
         }
       } catch (error) {
+        if (isCompanionPairingInvalidError(error)) {
+          await requestCancel('device_disconnect');
+          return;
+        }
         if (!controlMonitorAbort.signal.aborted && !cancelRequested) {
           options.trace?.warn?.('outcome_control_poll_failed', {
             error: errorMeta(error),
@@ -2991,6 +3013,7 @@ export function checkCommand(command, args = ['--version'], timeoutMs = 10000) {
 
 export async function checkAgentAvailability(agent, model, options = {}) {
   const normalizedAgent = normalizeAgentName(agent);
+  const modelCatalogRefreshedAt = nowIso();
   if (normalizedAgent === 'dry-run') {
     return {
       ok: true,
@@ -3002,6 +3025,8 @@ export async function checkAgentAvailability(agent, model, options = {}) {
       installed: true,
       signedIn: true,
       status: 'ready',
+      modelCatalogSource: 'runtime',
+      modelCatalogRefreshedAt,
     };
   }
   const definition = definitionForAgent(normalizedAgent);
@@ -3025,6 +3050,8 @@ export async function checkAgentAvailability(agent, model, options = {}) {
       installed: false,
       signedIn: false,
       status: 'unavailable',
+      modelCatalogSource: 'fallback',
+      modelCatalogRefreshedAt,
     };
   }
   if (normalizedAgent === 'codex') {
@@ -3051,9 +3078,19 @@ export async function checkAgentAvailability(agent, model, options = {}) {
           error:
             detection.error
             || 'Codex is not signed in. Run `codex login` on this computer, then run the bridge command again.',
+          modelCatalogSource: 'fallback',
+          modelCatalogRefreshedAt,
         };
       }
-      const reportedModels = await adapter.models();
+      let reportedModels = supportedModels;
+      let modelCatalogSource = 'fallback';
+      let modelCatalogError = null;
+      try {
+        reportedModels = await adapter.models();
+        modelCatalogSource = 'runtime';
+      } catch (error) {
+        modelCatalogError = error?.message || String(error);
+      }
       return {
         ...runtime,
         ...detection,
@@ -3062,7 +3099,9 @@ export async function checkAgentAvailability(agent, model, options = {}) {
         label: definition.label,
         models: reportedModels.map((candidate) => candidate.id),
         modelDetails: reportedModels,
-        modelCatalogSource: 'runtime',
+        modelCatalogSource,
+        modelCatalogRefreshedAt,
+        ...(modelCatalogError ? { modelCatalogError } : {}),
         installed: true,
         signedIn: true,
         status: 'ready',
@@ -3108,6 +3147,7 @@ export async function checkAgentAvailability(agent, model, options = {}) {
     models: reportedModels.map((candidate) => candidate.id),
     modelDetails: reportedModels,
     modelCatalogSource,
+    modelCatalogRefreshedAt,
     ...(modelCatalogError ? { modelCatalogError } : {}),
     installed: true,
   };

package/src/api.js

@@ -16,6 +16,15 @@ export class DexterBridgeApiError extends Error {
   }
 }
 
+export function isCompanionPairingInvalidError(error) {
+  return error instanceof DexterBridgeApiError
+    && error.status === 401
+    && (
+      error.body?.code === 'FRAMER_COMPANION_NOT_PAIRED'
+      || /not paired|pair again/i.test(error.message)
+    );
+}
+
 function bearerHeaders(deviceToken) {
   return deviceToken ? { Authorization: `Bearer ${deviceToken}` } : {};
 }

package/src/cli.js

@@ -19,8 +19,8 @@ import {
 import { checkAgentAvailability, checkAllAgents, executeRun } from './agent.js';
 import {
   claimPairing,
-  DexterBridgeApiError,
   heartbeat,
+  isCompanionPairingInvalidError,
   pollRun,
 } from './api.js';
 import {
@@ -228,12 +228,7 @@ function wait(delayMs) {
 }
 
 function isInvalidPairingError(error) {
-  return error instanceof DexterBridgeApiError
-    && error.status === 401
-    && (
-      error.body?.code === 'FRAMER_COMPANION_NOT_PAIRED'
-      || /not paired|pair again/i.test(error.message)
-    );
+  return isCompanionPairingInvalidError(error);
 }
 
 function clearInvalidPairing(configDir, cause) {
@@ -266,7 +261,48 @@ function agentEnvironment(config = {}, baseEnv = process.env) {
   return env;
 }
 
-async function inspectAvailability(config = {}, runtimeSelection = null) {
+function modelCatalogStatus(runtimeProfiles = []) {
+  return Object.fromEntries(
+    runtimeProfiles.flatMap((profile) => {
+      const agent =
+        profile.driver === 'codex-app-server'
+          ? 'codex'
+          : profile.driver === 'claude-code-cli'
+            ? 'claude-code'
+            : null;
+      return agent ? [[agent, profile.modelCatalog]] : [];
+    }),
+  );
+}
+
+function preserveLastKnownModelCatalog(previousProfiles = [], nextProfiles = []) {
+  const previousById = new Map(previousProfiles.map((profile) => [profile.id, profile]));
+  return nextProfiles.map((profile) => {
+    const previous = previousById.get(profile.id);
+    if (
+      !previous?.models?.length
+      || profile.modelCatalog?.source === 'runtime'
+      || !profile.modelCatalog?.error
+    ) {
+      return profile;
+    }
+    return {
+      ...profile,
+      models: previous.models,
+      modelCatalog: {
+        ...profile.modelCatalog,
+        source: 'stale',
+        modelCount: previous.models.length,
+      },
+    };
+  });
+}
+
+async function inspectAvailability(
+  config = {},
+  runtimeSelection = null,
+  { forceModelRefresh = false, previousRuntimeProfiles = [] } = {},
+) {
   try {
     const bridgeEnv = agentEnvironment(config);
     const checks =
@@ -275,22 +311,33 @@ async function inspectAvailability(config = {}, runtimeSelection = null) {
             agents: [
               await checkAgentAvailability(runtimeSelection, undefined, {
                 env: bridgeEnv,
+                forceModelRefresh,
               }),
             ],
             dryRun: null,
           }
         : runtimeSelection === 'opencode'
           ? { agents: [], dryRun: null }
-          : await checkAllAgents({ env: bridgeEnv });
+          : await checkAllAgents({ env: bridgeEnv, forceModelRefresh });
     const allChecks = [...checks.agents, ...(checks.dryRun ? [checks.dryRun] : [])];
     const available = allChecks.filter((check) => check.ok);
-    const runtimeProfiles = await discoverRuntimeProfiles({
+    const discoveredRuntimeProfiles = await discoverRuntimeProfiles({
       agentChecks: checks.agents,
       config,
       env: bridgeEnv,
       runtimeSelection,
     });
+    const runtimeProfiles = preserveLastKnownModelCatalog(
+      previousRuntimeProfiles,
+      discoveredRuntimeProfiles,
+    );
     const profileModels = runtimeProfiles.flatMap((profile) => profile.models || []);
+    const catalogStatus = modelCatalogStatus(runtimeProfiles);
+    const refreshedAt = Object.values(catalogStatus)
+      .map((status) => status?.refreshedAt)
+      .filter(Boolean)
+      .sort()
+      .at(-1);
     return {
       metadata: {
         availableAgents: available.map((check) => check.agent).join(','),
@@ -298,6 +345,8 @@ async function inspectAvailability(config = {}, runtimeSelection = null) {
         availableModelDetails: JSON.stringify(
           profileModels,
         ),
+        modelCatalogStatus: JSON.stringify(catalogStatus),
+        ...(refreshedAt ? { modelCatalogRefreshedAt: refreshedAt } : {}),
         agentVersions: available.map((check) => `${check.agent}=${check.version || 'unknown'}`).join(','),
         bridgeCapabilities: BRIDGE_CAPABILITIES.join(','),
         bridgeVersion: BRIDGE_VERSION,
@@ -555,7 +604,10 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
     while (true) {
       if (Date.now() >= nextCatalogRefreshAt) {
         try {
-          const refreshedAvailability = await inspectAvailability(activeConfig, runtimeSelection);
+          const refreshedAvailability = await inspectAvailability(activeConfig, runtimeSelection, {
+            forceModelRefresh: true,
+            previousRuntimeProfiles: availability.runtimeProfiles,
+          });
           const refreshedRuntimeProfile = runtimeSelection
             ? requireAvailableRuntime(refreshedAvailability, runtimeSelection)
             : null;
@@ -598,7 +650,9 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
             status: error.status,
             code: error.body?.code || null,
           });
-          throw clearInvalidPairing(configDir, error);
+          const disconnected = clearInvalidPairing(configDir, error);
+          console.log(disconnected.message);
+          return;
         }
         if (once) throw error;
         pollFailureCount += 1;
@@ -610,6 +664,45 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
         await wait(retryInMs);
         continue;
       }
+      if (poll?.control?.refreshModelCatalog) {
+        try {
+          const refreshedAvailability = await inspectAvailability(activeConfig, runtimeSelection, {
+            forceModelRefresh: true,
+            previousRuntimeProfiles: availability.runtimeProfiles,
+          });
+          availability = refreshedAvailability;
+          runtimeProfile = runtimeSelection
+            ? requireAvailableRuntime(refreshedAvailability, runtimeSelection)
+            : null;
+          check = runtimeProfile
+            ? null
+            : requireAvailableAgent(refreshedAvailability, agent);
+          model = runtimeProfile
+            ? runtimeProfile.models.find((candidate) => candidate.id === requestedModel)?.id
+              || runtimeProfile.models[0].id
+            : availableModel(check, requestedModel);
+          metadata = availability.metadata;
+          profiles = runtimeProfileMap(availability.runtimeProfiles);
+          await heartbeat(apiBaseUrl, {
+            deviceToken,
+            status: 'ready',
+            agent,
+            model,
+            metadata,
+            runtimeProfiles: availability.runtimeProfiles.map(publicRuntimeProfile),
+            allowInsecureHttp: flags['allow-insecure-http'],
+          });
+          pollLogger.info('model_catalog_refresh_completed', {
+            requestedAt: poll.control.refreshModelCatalog.requestedAt,
+            models: availability.runtimeProfiles.flatMap((profile) =>
+              profile.models.map((candidate) => candidate.id)),
+          });
+        } catch (error) {
+          pollLogger.warn('model_catalog_refresh_failed', { error: errorMeta(error) });
+        } finally {
+          nextCatalogRefreshAt = Date.now() + MODEL_CATALOG_REFRESH_MS;
+        }
+      }
       if (poll.run) {
         console.log(`Claimed run ${poll.run.runId}.`);
         const runtimeProfile = poll.run?.runtimeProfile || null;

package/src/config.js

@@ -52,6 +52,7 @@ export const BRIDGE_CAPABILITIES = [
   'runtime-profiles-v1',
   'native-skills-v1',
   'model-progress-v1',
+  'model-catalog-refresh-v1',
 ];
 export const BRIDGE_PRODUCTS = {
   dexter: {

package/src/framerAgentTools.js

@@ -503,7 +503,7 @@ const TOOL_BY_NAME = new Map(
   ]),
 );
 const sessionsByProject = new Map();
-let hostedSetupPromise = null;
+let framerSetupPromise = null;
 
 function isRecord(value) {
   return Boolean(value && typeof value === 'object' && !Array.isArray(value));
@@ -537,6 +537,12 @@ function framerSkillRoot(env) {
   ].find((root) => fs.existsSync(path.join(root, 'SKILL.md'))) || null;
 }
 
+function isMissingFramerSkillError(error) {
+  return /could not find an installed framer skill|run [`'"]?@framer\/agent setup/i.test(
+    String(error?.message || ''),
+  );
+}
+
 function installedFramerAgentVersion() {
   try {
     let current = path.dirname(resolveFramerAgentCli());
@@ -1184,6 +1190,9 @@ export function createFramerAgentToolRuntime({
     doctrineLoaded: false,
     doctrineVersion: null,
   };
+  let framerSetupAttempts = 0;
+  let framerSetupRecoveredSession = false;
+  let framerSetupCompleted = hasInstalledFramerSkill(env);
   const framerAgentVersion = installedFramerAgentVersion();
   let operationSequence = 0;
   let lastMutationSequence = 0;
@@ -1210,23 +1219,49 @@ export function createFramerAgentToolRuntime({
     return result;
   };
 
-  const ensureHostedSetup = async () => {
-    if (env.DEXTER_HOSTED_FRAMER_AUTO_SETUP !== 'true') return;
-    if (hasInstalledFramerSkill(env)) return;
-    if (!hostedSetupPromise) {
+  const ensureFramerSetup = async ({ force = false } = {}) => {
+    const automaticSetupEnabled =
+      runCli === runFramerAgentCli
+      || env.DEXTER_FRAMER_AUTO_SETUP === 'true';
+    if (!force && !automaticSetupEnabled) return;
+    if (!force && hasInstalledFramerSkill(env)) {
+      framerSetupCompleted = true;
+      return;
+    }
+    if (!framerSetupPromise) {
+      framerSetupAttempts += 1;
       reportActivity({
         kind: 'status_update',
         source: 'framer-agent',
-        message: 'Preparing the Framer harness.',
+        message: 'Getting Framer ready.',
       });
-      hostedSetupPromise = executeCli(['setup'], {
+      framerSetupPromise = executeCli(['setup'], {
         timeoutMs: 30_000,
-      }).catch((error) => {
-        hostedSetupPromise = null;
-        throw error;
-      });
+      })
+        .then(() => {
+          if (!hasInstalledFramerSkill(env)) {
+            throw toolError(
+              'FRAMER_AGENT_SETUP_FAILED',
+              'Framer setup completed without installing the required Framer skill.',
+              503,
+            );
+          }
+          framerSetupCompleted = true;
+        })
+        .catch((error) => {
+          if (error?.code === 'FRAMER_AGENT_SETUP_FAILED') throw error;
+          throw toolError(
+            'FRAMER_AGENT_SETUP_FAILED',
+            `Dexter could not prepare the Framer editing tools: ${String(error?.message || 'Framer setup failed.')}`,
+            503,
+          );
+        })
+        .finally(() => {
+          framerSetupPromise = null;
+        });
     }
-    await hostedSetupPromise;
+    await framerSetupPromise;
+    framerSetupCompleted = hasInstalledFramerSkill(env);
   };
 
   const projectIsAuthorizedLocally = async () => {
@@ -1351,7 +1386,7 @@ export function createFramerAgentToolRuntime({
   };
 
   const ensureSession = async () => {
-    await ensureHostedSetup();
+    await ensureFramerSetup();
     if (sessionId) return sessionId;
     if (sessionPromise) return sessionPromise;
     sessionPromise = (async () => {
@@ -1397,7 +1432,14 @@ export function createFramerAgentToolRuntime({
         if (authorization) {
           await installProjectAuthorization(authorization);
         }
-        created = await createSession();
+        try {
+          created = await createSession();
+        } catch (error) {
+          if (!isMissingFramerSkillError(error)) throw error;
+          await ensureFramerSetup({ force: true });
+          created = await createSession();
+          framerSetupRecoveredSession = true;
+        }
       } catch (error) {
         if (isAuthorizationFailure(error)) {
           await reportRejectedAuthorization(authorization, error);
@@ -2829,6 +2871,11 @@ export function createFramerAgentToolRuntime({
       taskPlan: taskPlanSnapshot(),
       verification: verification(),
       framerAgentVersion,
+      framerSetup: {
+        completed: framerSetupCompleted,
+        attempts: framerSetupAttempts,
+        recoveredSession: framerSetupRecoveredSession,
+      },
       framerGuidanceLoaded: guidanceMetadata.loaded,
       doctrineLoaded: promptMetadata.doctrineLoaded,
       guidanceHash: guidanceMetadata.contentHash,
@@ -2863,5 +2910,5 @@ export function createFramerAgentToolRuntime({
 
 export function __resetFramerAgentToolRuntimeForTests() {
   sessionsByProject.clear();
-  hostedSetupPromise = null;
+  framerSetupPromise = null;
 }

package/src/runtimeProfiles.js

@@ -71,6 +71,20 @@ function normalizeCapabilities(value = {}) {
   };
 }
 
+function normalizeModelCatalog(value = {}) {
+  const source = ['runtime', 'fallback', 'stale', 'error'].includes(value.source)
+    ? value.source
+    : 'fallback';
+  return {
+    source,
+    refreshedAt: text(value.refreshedAt, 80) || new Date().toISOString(),
+    modelCount: Number.isFinite(Number(value.modelCount))
+      ? Math.max(0, Math.floor(Number(value.modelCount)))
+      : 0,
+    ...(text(value.error, 500) ? { error: text(value.error, 500) } : {}),
+  };
+}
+
 export function normalizeRuntimeProfile(value, { includeSecret = false } = {}) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
   const driver = text(value.driver, 80);
@@ -110,6 +124,10 @@ export function normalizeRuntimeProfile(value, { includeSecret = false } = {}) {
     continuationIdentity: text(value.continuationIdentity, 180) || stableIdentity(driver, instanceId),
     capabilities: normalizeCapabilities(value.capabilities),
     models,
+    modelCatalog: normalizeModelCatalog({
+      ...(value.modelCatalog || {}),
+      modelCount: models.length,
+    }),
     ...(text(value.keyLast4, 16) ? { keyLast4: text(value.keyLast4, 16) } : {}),
     ...(text(value.command, 2048) ? { command: text(value.command, 2048) } : {}),
     ...(Array.isArray(value.args)
@@ -169,6 +187,12 @@ function profileFromAgentCheck(check) {
       cancellation: true,
     },
     models: check.modelDetails || [],
+    modelCatalog: {
+      source: check.modelCatalogSource || 'fallback',
+      refreshedAt: check.modelCatalogRefreshedAt,
+      modelCount: check.modelDetails?.length || 0,
+      ...(check.modelCatalogError ? { error: check.modelCatalogError } : {}),
+    },
   });
 }