@gakim-digital/dexter-bridge 0.5.21 → 0.11.0

package/src/agentOutput.js

@@ -241,6 +241,215 @@ function parseClaudeStreamUsage(events) {
   };
 }
 
+function progressText(value, maximum = 500) {
+  if (typeof value !== 'string') return '';
+  return value.replace(/\s+/g, ' ').trim().slice(0, maximum);
+}
+
+function progressPath(value, cwd) {
+  if (typeof value !== 'string') return undefined;
+  let normalized = value.trim().replaceAll('\\', '/').replace(/\/+/g, '/');
+  const normalizedCwd = typeof cwd === 'string'
+    ? cwd.trim().replaceAll('\\', '/').replace(/\/+$/, '')
+    : '';
+  if (normalizedCwd && normalized.startsWith(`${normalizedCwd}/`)) {
+    normalized = normalized.slice(normalizedCwd.length + 1);
+  }
+  normalized = normalized.replace(/^\.\/+/, '');
+  if (!normalized || normalized.split('/').some((part) => part === '..')) return undefined;
+  if (normalized.startsWith('/') || /^[A-Za-z]:\//.test(normalized)) {
+    const parts = normalized.split('/').filter(Boolean);
+    normalized = parts.slice(-2).join('/');
+  }
+  return normalized.slice(0, 500) || undefined;
+}
+
+function claudeToolProgress(name, input = {}, cwd) {
+  const toolName = String(name || '').trim();
+  const shortName = toolName.replace(/^mcp__instawebai__/, '');
+  const filePath = progressPath(
+    input.file_path || input.path || input.notebook_path,
+    cwd,
+  );
+  const paths = filePath ? [filePath] : undefined;
+  const description = progressText(input.description, 180);
+  const messages = {
+    Read: [
+      filePath ? `Reading ${filePath}` : 'Reading a project file',
+      filePath ? `Read ${filePath}` : 'Finished reading the project file',
+    ],
+    Write: [
+      filePath ? `Creating ${filePath}` : 'Creating a project file',
+      filePath ? `Created ${filePath}` : 'Created the project file',
+    ],
+    Edit: [
+      filePath ? `Updating ${filePath}` : 'Updating a project file',
+      filePath ? `Updated ${filePath}` : 'Updated the project file',
+    ],
+    Glob: ['Finding project files', 'Found the project files'],
+    Grep: ['Searching the code', 'Finished searching the code'],
+    Bash: [
+      description || 'Running a project command',
+      description ? `Finished: ${description}` : 'Finished the project command',
+    ],
+    workspace_inspect: ['Inspecting the project', 'Finished inspecting the project'],
+    workspace_sync: ['Saving project changes', 'Saved the project changes'],
+    shell_run: [
+      description || 'Running project checks',
+      description ? `Finished: ${description}` : 'Finished the project checks',
+    ],
+    preview_control: ['Starting the live preview', 'Started the live preview'],
+    browser_control: ['Checking the app in the browser', 'Finished checking the app in the browser'],
+    data_inspect: ['Checking app data', 'Finished checking app data'],
+    verification_run: ['Running final verification', 'Finished final verification'],
+  };
+  const [startedMessage, completedMessage] = messages[shortName] || [
+    `Using ${shortName || 'a project tool'}`,
+    `Finished using ${shortName || 'the project tool'}`,
+  ];
+  return {
+    startedMessage,
+    completedMessage,
+    failedMessage: `Couldn’t finish: ${startedMessage}`,
+    paths,
+  };
+}
+
+function summedClaudeProgressUsage(turnUsage) {
+  const total = normalizeCompanionTokenUsage();
+  for (const usage of turnUsage.values()) {
+    for (const field of TOKEN_FIELDS) total[field] += usage[field];
+    total.totalTokens += usage.totalTokens;
+  }
+  return total;
+}
+
+export function createClaudeProgressParser(onProgress, options = {}) {
+  let buffer = '';
+  let lastUsage = '';
+  const tools = new Map();
+  const emittedTools = new Set();
+  const emittedText = new Set();
+  const turnUsage = new Map();
+
+  const emit = (event) => {
+    onProgress?.({
+      provider: 'claude-code',
+      occurredAt: new Date().toISOString(),
+      ...event,
+    });
+  };
+
+  const updateUsage = (message) => {
+    if (!message?.id || !message.usage || typeof message.usage !== 'object') return;
+    const current = turnUsage.get(message.id) || normalizeCompanionTokenUsage();
+    mergeMaximumUsage(current, message.usage);
+    turnUsage.set(message.id, current);
+    const tokenUsage = summedClaudeProgressUsage(turnUsage);
+    const serialized = JSON.stringify(tokenUsage);
+    if (!usageHasReportedTokens(tokenUsage) || serialized === lastUsage) return;
+    lastUsage = serialized;
+    emit({ kind: 'token_usage', tokenUsage });
+  };
+
+  const processAssistant = (row) => {
+    const message = row.message;
+    if (!message || typeof message !== 'object') return;
+    updateUsage(message);
+    for (const [index, part] of (Array.isArray(message.content) ? message.content : []).entries()) {
+      if (part?.type === 'text') {
+        const text = progressText(part.text);
+        const key = `${message.id || 'assistant'}:${index}:${text}`;
+        if (
+          !text
+          || emittedText.has(key)
+          || (text.startsWith('{') && text.endsWith('}'))
+        ) {
+          continue;
+        }
+        emittedText.add(key);
+        emit({
+          kind: 'output_delta',
+          message: text,
+          activity: `assistant:${message.id || key}:${index}`,
+        });
+        continue;
+      }
+      if (part?.type !== 'tool_use' || !part.id || emittedTools.has(part.id)) continue;
+      emittedTools.add(part.id);
+      const input = part.input && typeof part.input === 'object' && !Array.isArray(part.input)
+        ? part.input
+        : {};
+      if (
+        String(part.name || '').replace(/^mcp__instawebai__/, '') === 'progress_update'
+        && progressText(input.message)
+      ) {
+        tools.set(part.id, { suppressResult: true });
+        emit({
+          kind: 'output_delta',
+          message: progressText(input.message),
+          activity: `assistant-progress:${part.id}`,
+        });
+        continue;
+      }
+      const progress = claudeToolProgress(part.name, input, options.cwd);
+      tools.set(part.id, { name: part.name, ...progress });
+      emit({
+        kind: 'item_started',
+        name: part.name,
+        phase: 'started',
+        activity: `tool:${part.id}`,
+        paths: progress.paths,
+        message: progress.startedMessage,
+      });
+    }
+  };
+
+  const processUser = (row) => {
+    const content = row.message?.content;
+    if (!Array.isArray(content)) return;
+    for (const part of content) {
+      if (part?.type !== 'tool_result' || !part.tool_use_id) continue;
+      const tool = tools.get(part.tool_use_id);
+      if (!tool || tool.suppressResult) continue;
+      const failed = part.is_error === true || Boolean(row.toolDenialKind);
+      emit({
+        kind: failed ? 'item_failed' : 'item_completed',
+        name: tool.name,
+        phase: failed ? 'failed' : 'completed',
+        activity: `tool:${part.tool_use_id}`,
+        paths: tool.paths,
+        message: failed ? tool.failedMessage : tool.completedMessage,
+      });
+    }
+  };
+
+  const processLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    try {
+      const row = JSON.parse(trimmed);
+      if (row?.type === 'assistant') processAssistant(row);
+      if (row?.type === 'user') processUser(row);
+    } catch {
+      // Claude may split JSON records across chunks. Incomplete records remain buffered.
+    }
+  };
+
+  return {
+    push(chunk) {
+      buffer += String(chunk || '');
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || '';
+      for (const line of lines) processLine(line);
+    },
+    flush() {
+      if (buffer.trim()) processLine(buffer);
+      buffer = '';
+    },
+  };
+}
+
 export function parseClaudeOutput(stdout) {
   const whole = parseWholeJson(stdout);
   if (whole && typeof whole === 'object' && !Array.isArray(whole)) {

package/src/api.js

@@ -39,9 +39,14 @@ export async function requestJson(apiBaseUrl, path, {
   body,
   deviceToken,
   fetchImpl = fetch,
+  signal,
+  allowInsecureHttp = false,
 } = {}) {
-  const response = await fetchImpl(`${normalizeApiBaseUrl(apiBaseUrl)}${path}`, {
+  const response = await fetchImpl(`${normalizeApiBaseUrl(apiBaseUrl, {
+    allowInsecureHttp,
+  })}${path}`, {
     method,
+    signal,
     headers: {
       Accept: 'application/json',
       'Content-Type': 'application/json',
@@ -75,6 +80,8 @@ export function claimPairing(apiBaseUrl, {
   agent,
   model,
   metadata,
+  runtimeProfiles,
+  runtimeSelection,
   fetchImpl,
 }) {
   const normalizedAgent = normalizeAgentName(agent);
@@ -89,6 +96,8 @@ export function claimPairing(apiBaseUrl, {
       platform: process.platform,
       companionVersion: BRIDGE_VERSION,
       metadata: bridgeMetadata(normalizedAgent, normalizedModel, metadata),
+      runtimeProfiles,
+      runtimeSelection,
     },
   });
 }
@@ -99,7 +108,9 @@ export function heartbeat(apiBaseUrl, {
   agent,
   model,
   metadata,
+  runtimeProfiles,
   fetchImpl,
+  allowInsecureHttp,
 }) {
   const normalizedAgent = normalizeAgentName(agent);
   const normalizedModel = normalizeCompanionModelName(model, normalizedAgent);
@@ -107,11 +118,13 @@ export function heartbeat(apiBaseUrl, {
     method: 'POST',
     deviceToken,
     fetchImpl,
+    allowInsecureHttp,
     body: {
       status,
       platform: process.platform,
       companionVersion: BRIDGE_VERSION,
       metadata: bridgeMetadata(normalizedAgent, normalizedModel, metadata),
+      runtimeProfiles,
     },
   });
 }
@@ -137,7 +150,9 @@ export function pollRun(apiBaseUrl, {
   agent,
   model,
   metadata,
+  runtimeProfiles,
   fetchImpl,
+  allowInsecureHttp,
 }) {
   const normalizedAgent = normalizeAgentName(agent);
   const normalizedModel = normalizeCompanionModelName(model, normalizedAgent);
@@ -145,26 +160,58 @@ export function pollRun(apiBaseUrl, {
     method: 'POST',
     deviceToken,
     fetchImpl,
+    allowInsecureHttp,
     body: {
       waitMs,
       platform: process.platform,
       companionVersion: BRIDGE_VERSION,
       status: 'polling',
       metadata: bridgeMetadata(normalizedAgent, normalizedModel, metadata),
+      runtimeProfiles,
     },
   });
 }
 
+export function getFramerProjectAuthorization(apiBaseUrl, {
+  deviceToken,
+  runId,
+  initiate = false,
+  forceRefresh = false,
+  fetchImpl,
+  signal,
+  allowInsecureHttp,
+}) {
+  return requestJson(
+    apiBaseUrl,
+    `/ai/framer/companion/runs/${encodeURIComponent(runId)}/framer-authorization`,
+    {
+      method: 'POST',
+      deviceToken,
+      fetchImpl,
+      signal,
+      allowInsecureHttp,
+      body: {
+        initiate,
+        forceRefresh,
+        platform: process.platform,
+        companionVersion: BRIDGE_VERSION,
+      },
+    },
+  );
+}
+
 export function postRunEvent(apiBaseUrl, {
   deviceToken,
   runId,
   event,
   fetchImpl,
+  allowInsecureHttp,
 }) {
   return requestJson(apiBaseUrl, `/ai/framer/companion/runs/${encodeURIComponent(runId)}/events`, {
     method: 'POST',
     deviceToken,
     fetchImpl,
+    allowInsecureHttp,
     body: {
       event,
       platform: process.platform,