@axhub/genie 0.2.6 → 0.2.8

package/server/utils/workspaceRoots.js

@@ -0,0 +1,154 @@
+import os from 'os';
+import path from 'path';
+
+export const UNIX_WORKSPACE_ROOTS = '__workspace_roots__';
+
+export function parseWorkspaceRoots(value) {
+  if (!value || typeof value !== 'string') {
+    return [];
+  }
+
+  const seen = new Set();
+  const roots = [];
+
+  for (const entry of value.split(',')) {
+    const trimmed = entry.trim();
+    if (!trimmed) continue;
+
+    const resolved = path.resolve(trimmed);
+    if (seen.has(resolved)) continue;
+
+    seen.add(resolved);
+    roots.push(resolved);
+  }
+
+  return roots;
+}
+
+export function getDefaultWorkspaceRoots({
+  platform = process.platform,
+  homeDir = os.homedir()
+} = {}) {
+  if (platform === 'win32') {
+    return [];
+  }
+
+  const roots = [path.resolve(homeDir)];
+
+  if (platform === 'darwin') {
+    roots.push('/Volumes');
+  } else if (platform === 'linux') {
+    roots.push('/mnt', '/media');
+    const userName = path.basename(homeDir);
+    if (userName) {
+      roots.push(path.join('/run/media', userName));
+    }
+  }
+
+  return [...new Set(roots.map((root) => path.resolve(root)))];
+}
+
+export function resolveWorkspaceRootSettings({
+  env = process.env,
+  platform = process.platform,
+  homeDir = os.homedir()
+} = {}) {
+  const configuredRoots = parseWorkspaceRoots(env.WORKSPACES_ROOTS);
+  const hasWorkspaceRootRestriction = configuredRoots.length > 0 || platform !== 'win32';
+  const allowedWorkspaceRoots = configuredRoots.length > 0
+    ? configuredRoots
+    : (hasWorkspaceRootRestriction ? getDefaultWorkspaceRoots({ platform, homeDir }) : []);
+
+  return {
+    defaultWorkspaceRoot: path.resolve(homeDir),
+    hasWorkspaceRootRestriction,
+    allowedWorkspaceRoots,
+  };
+}
+
+const workspaceRootSettings = resolveWorkspaceRootSettings();
+
+export const DEFAULT_WORKSPACES_ROOT = workspaceRootSettings.defaultWorkspaceRoot;
+export const HAS_WORKSPACES_ROOT_RESTRICTION = workspaceRootSettings.hasWorkspaceRootRestriction;
+export const WORKSPACES_ROOTS = workspaceRootSettings.allowedWorkspaceRoots;
+
+export function expandWorkspacePath(inputPath, homeDir = DEFAULT_WORKSPACES_ROOT) {
+  if (!inputPath) return inputPath;
+  if (inputPath === '~') {
+    return homeDir;
+  }
+  if (inputPath.startsWith('~/') || inputPath.startsWith('~\\')) {
+    return path.join(homeDir, inputPath.slice(2));
+  }
+  return inputPath;
+}
+
+export function isPathWithinAllowedRoots(candidatePath, allowedRoots) {
+  const normalizedCandidate = path.resolve(candidatePath);
+
+  return allowedRoots.some((allowedRoot) => {
+    const normalizedRoot = path.resolve(allowedRoot);
+    return normalizedCandidate === normalizedRoot
+      || normalizedCandidate.startsWith(normalizedRoot + path.sep);
+  });
+}
+
+export async function resolveAllowedWorkspaceRoots({
+  fsImpl,
+  allowedWorkspaceRoots = WORKSPACES_ROOTS
+} = {}) {
+  const resolvedRoots = [];
+  const seen = new Set();
+
+  for (const root of allowedWorkspaceRoots) {
+    let resolvedRoot;
+
+    try {
+      resolvedRoot = await fsImpl.realpath(root);
+    } catch (error) {
+      resolvedRoot = path.resolve(root);
+    }
+
+    if (seen.has(resolvedRoot)) continue;
+    seen.add(resolvedRoot);
+    resolvedRoots.push(resolvedRoot);
+  }
+
+  return resolvedRoots;
+}
+
+export function formatAllowedWorkspaceRoots(allowedRoots) {
+  return allowedRoots.join(', ');
+}
+
+export function shouldUseVirtualWorkspaceRoots({
+  dirPath,
+  hasWorkspaceRootRestriction = HAS_WORKSPACES_ROOT_RESTRICTION
+} = {}) {
+  return hasWorkspaceRootRestriction
+    && (!dirPath || dirPath === UNIX_WORKSPACE_ROOTS);
+}
+
+export function buildWorkspaceRootSuggestions({
+  allowedWorkspaceRoots = WORKSPACES_ROOTS,
+  homeDir = DEFAULT_WORKSPACES_ROOT
+} = {}) {
+  const resolvedHomeDir = path.resolve(homeDir);
+  const seen = new Set();
+  const suggestions = [];
+
+  for (const root of allowedWorkspaceRoots) {
+    const resolvedRoot = path.resolve(root);
+    if (seen.has(resolvedRoot)) continue;
+
+    seen.add(resolvedRoot);
+    suggestions.push({
+      path: resolvedRoot,
+      name: resolvedRoot === resolvedHomeDir ? 'Home' : (path.basename(resolvedRoot) || resolvedRoot),
+      type: 'directory',
+      isWorkspaceRoot: true
+    });
+  }
+
+  return suggestions;
+}

package/shared/conversationEvents.js

@@ -16,6 +16,7 @@ export const CONVERSATION_EVENT_KINDS = {
   ASSISTANT_TEXT_START: 'assistant_text_start',
   ASSISTANT_TEXT_DELTA: 'assistant_text_delta',
   ASSISTANT_TEXT_END: 'assistant_text_end',
+  ASSISTANT_CONTENT_BLOCK: 'assistant_content_block',
   REASONING_START: 'reasoning_start',
   REASONING_DELTA: 'reasoning_delta',
   REASONING_END: 'reasoning_end',
@@ -23,6 +24,9 @@ export const CONVERSATION_EVENT_KINDS = {
   TOOL_CALL_INPUT: 'tool_call_input',
   TOOL_CALL_END: 'tool_call_end',
   TOOL_RESULT: 'tool_result',
+  PLAN_UPDATE: 'plan_update',
+  MODE_UPDATE: 'mode_update',
+  AVAILABLE_COMMANDS_UPDATE: 'available_commands_update',
   APPROVAL_REQUEST: 'approval_request',
   APPROVAL_RESOLVED: 'approval_resolved',
   ARTIFACT_CREATED: 'artifact_created',
@@ -236,6 +240,167 @@ function stringifyToolContent(value) {
   }
 }
 
+function cloneJsonValue(value) {
+  if (value == null) {
+    return value;
+  }
+
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
+}
+
+function normalizeMessageContentBlocks(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value
+    .filter((item) => item && typeof item === 'object')
+    .map((item) => cloneJsonValue(item));
+}
+
+function getConversationEventClientRequestId(event) {
+  const rawValue = event?.extensions?.clientRequestId || event?.payload?.clientRequestId || null;
+  return typeof rawValue === 'string' && rawValue.trim()
+    ? rawValue.trim()
+    : null;
+}
+
+function getTimelineMessageClientRequestId(message) {
+  const rawValue = message?.clientRequestId || message?.extensions?.clientRequestId || null;
+  return typeof rawValue === 'string' && rawValue.trim()
+    ? rawValue.trim()
+    : null;
+}
+
+function buildComparableUserMessageContentBlocks(message = {}) {
+  const imageBlocks = Array.isArray(message?.images)
+    ? message.images.map((image) => ({
+        type: 'image',
+        data: image?.data || image?.image || '',
+        mimeType: image?.mimeType || 'application/octet-stream',
+        name: image?.name || image?.filename || ''
+      }))
+    : [];
+
+  return [
+    ...imageBlocks,
+    ...normalizeMessageContentBlocks(message?.contentBlocks)
+  ];
+}
+
+function findMatchingOptimisticUserMessageIndex(messages, event, payload = {}) {
+  const clientRequestId = getConversationEventClientRequestId(event);
+  if (!clientRequestId) {
+    return -1;
+  }
+
+  const expectedContentBlocks = JSON.stringify(normalizeMessageContentBlocks(payload.contentBlocks));
+
+  return findLatestTimelineMessageIndex(messages, (message) => {
+    if (String(message?.type || '').trim().toLowerCase() !== 'user') {
+      return false;
+    }
+
+    if (getTimelineMessageClientRequestId(message) !== clientRequestId) {
+      return false;
+    }
+
+    if (String(message?.content || '') !== String(payload.text || '')) {
+      return false;
+    }
+
+    const actualContentBlocks = JSON.stringify(buildComparableUserMessageContentBlocks(message));
+    return actualContentBlocks === expectedContentBlocks;
+  });
+}
+
+function normalizeAcpModeState(value) {
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+
+  const availableModes = Array.isArray(value.availableModes)
+    ? value.availableModes
+        .filter((mode) => mode && typeof mode === 'object' && String(mode.id || '').trim())
+        .map((mode) => ({
+          id: String(mode.id).trim(),
+          name: String(mode.name || mode.id || '').trim() || String(mode.id).trim(),
+          description: mode.description == null ? null : String(mode.description)
+        }))
+    : [];
+  const currentModeId = typeof value.currentModeId === 'string' && value.currentModeId.trim()
+    ? value.currentModeId.trim()
+    : null;
+
+  if (!availableModes.length && !currentModeId) {
+    return null;
+  }
+
+  return {
+    availableModes,
+    currentModeId: currentModeId || availableModes[0]?.id || null
+  };
+}
+
+function normalizeAcpAvailableCommands(value) {
+  const commands = Array.isArray(value?.availableCommands)
+    ? value.availableCommands
+    : Array.isArray(value)
+      ? value
+      : [];
+
+  return commands
+    .filter((command) => command && typeof command === 'object' && String(command.name || '').trim())
+    .map((command) => ({
+      name: String(command.name).trim(),
+      description: command.description == null ? '' : String(command.description),
+      input: command.input && typeof command.input === 'object' ? cloneJsonValue(command.input) : null,
+      source: 'acp',
+      namespace: 'acp',
+      type: 'acp'
+    }));
+}
+
+function mergeToolCallSnapshot(existingSnapshot = null, payload = {}) {
+  const nextSnapshot = existingSnapshot && typeof existingSnapshot === 'object'
+    ? { ...existingSnapshot }
+    : {};
+
+  if (payload.title != null) {
+    nextSnapshot.title = String(payload.title);
+  }
+
+  if (payload.kind != null) {
+    nextSnapshot.kind = String(payload.kind);
+  }
+
+  if (payload.status != null) {
+    nextSnapshot.status = String(payload.status);
+  }
+
+  if (payload.rawInput !== undefined) {
+    nextSnapshot.rawInput = cloneJsonValue(payload.rawInput);
+  }
+
+  if (payload.rawOutput !== undefined) {
+    nextSnapshot.rawOutput = cloneJsonValue(payload.rawOutput);
+  }
+
+  if (Array.isArray(payload.contentBlocks)) {
+    nextSnapshot.content = cloneJsonValue(payload.contentBlocks);
+  }
+
+  if (Array.isArray(payload.locations)) {
+    nextSnapshot.locations = cloneJsonValue(payload.locations);
+  }
+
+  return Object.keys(nextSnapshot).length > 0 ? nextSnapshot : null;
+}
+
 function collectClaudeToolResults(rawMessages) {
   const toolResults = new Map();
   for (const msg of rawMessages || []) {
@@ -279,7 +444,6 @@ function ensureStreamingTextMessage(messages, {
 }) {
   const index = findLatestTimelineMessageIndex(messages, (message) => (
     message?.eventMessageId === messageId &&
-    !!message?.isStreaming &&
     !message.isToolUse &&
     !!message.isThinking === !!isThinking
   ));
@@ -310,6 +474,40 @@ function ensureStreamingTextMessage(messages, {
   return { messages, index: messages.length - 1 };
 }
 
+function ensureConversationMessage(messages, {
+  messageId,
+  timestamp,
+  provider,
+  role = 'assistant'
+}) {
+  const index = findLatestTimelineMessageIndex(messages, (message) => (
+    message?.eventMessageId === messageId &&
+    !message.isToolUse &&
+    !message.isThinking &&
+    String(message?.type || '').trim().toLowerCase() === String(role || 'assistant').trim().toLowerCase()
+  ));
+
+  if (index >= 0) {
+    const existing = { ...messages[index] };
+    if (provider) existing.provider = provider;
+    if (timestamp && !existing.timestamp) existing.timestamp = timestamp;
+    messages[index] = existing;
+    return { messages, index };
+  }
+
+  messages.push({
+    type: role,
+    content: '',
+    timestamp,
+    provider,
+    isStreaming: false,
+    eventMessageId: messageId,
+    contentBlocks: []
+  });
+
+  return { messages, index: messages.length - 1 };
+}
+
 function ensureToolMessage(messages, {
   toolCallId,
   toolName,
@@ -458,14 +656,41 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
   const payload = event.payload || {};
 
   switch (event.kind) {
-    case CONVERSATION_EVENT_KINDS.USER_MESSAGE:
+    case CONVERSATION_EVENT_KINDS.USER_MESSAGE: {
+      const clientRequestId = getConversationEventClientRequestId(event);
+      const optimisticIndex = findMatchingOptimisticUserMessageIndex(nextMessages, event, payload);
+      const normalizedContentBlocks = normalizeMessageContentBlocks(payload.contentBlocks);
+
+      if (optimisticIndex >= 0) {
+        const existingMessage = nextMessages[optimisticIndex] || {};
+        const nextContentBlocks = Array.isArray(existingMessage.images) && existingMessage.images.length > 0
+          ? normalizedContentBlocks.filter((block) => block?.type !== 'image')
+          : normalizedContentBlocks;
+
+        nextMessages[optimisticIndex] = {
+          ...existingMessage,
+          type: 'user',
+          content: payload.text || existingMessage.content || '',
+          timestamp: existingMessage.timestamp || timestamp,
+          provider,
+          contentBlocks: nextContentBlocks,
+          clientRequestId: clientRequestId || existingMessage.clientRequestId || null,
+          eventId: event.eventId || existingMessage.eventId,
+          id: existingMessage.id || event.eventId || existingMessage.id
+        };
+        break;
+      }
+
       nextMessages.push({
         type: 'user',
         content: payload.text || '',
         timestamp,
-        provider
+        provider,
+        contentBlocks: normalizedContentBlocks,
+        clientRequestId
       });
       break;
+    }
 
     case CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_START: {
       const messageId = payload.messageId || event.extensions?.messageId || createEventId('assistant_text');
@@ -496,6 +721,26 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
       break;
     }
 
+    case CONVERSATION_EVENT_KINDS.ASSISTANT_CONTENT_BLOCK: {
+      const messageId = payload.messageId || event.extensions?.messageId || createEventId('assistant_content');
+      const { index } = ensureConversationMessage(nextMessages, {
+        messageId,
+        timestamp,
+        provider,
+        role: 'assistant'
+      });
+      const target = { ...nextMessages[index] };
+      const nextBlocks = Array.isArray(target.contentBlocks) ? [...target.contentBlocks] : [];
+      if (payload.contentBlock && typeof payload.contentBlock === 'object') {
+        nextBlocks.push(cloneJsonValue(payload.contentBlock));
+      }
+      target.contentBlocks = nextBlocks;
+      target.provider = target.provider || provider;
+      target.timestamp = target.timestamp || timestamp;
+      nextMessages[index] = target;
+      break;
+    }
+
     case CONVERSATION_EVENT_KINDS.REASONING_START: {
       const messageId = payload.messageId || event.extensions?.messageId || createEventId('reasoning');
       ensureStreamingTextMessage(nextMessages, { messageId, timestamp, provider, isThinking: true });
@@ -534,7 +779,11 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
         timestamp,
         provider
       });
-      nextMessages[index] = { ...nextMessages[index], toolName: payload.toolName || nextMessages[index].toolName };
+      nextMessages[index] = {
+        ...nextMessages[index],
+        toolName: payload.toolName || nextMessages[index].toolName,
+        acpToolCall: mergeToolCallSnapshot(nextMessages[index].acpToolCall, payload)
+      };
       break;
     }
 
@@ -548,8 +797,13 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
       });
       nextMessages[index] = {
         ...nextMessages[index],
-        toolInput: stringifyToolContent(payload.input || ''),
-        provider: nextMessages[index].provider || provider
+        toolInput: payload.input !== undefined
+          ? stringifyToolContent(payload.input)
+          : payload.rawInput !== undefined
+            ? stringifyToolContent(payload.rawInput)
+            : nextMessages[index].toolInput,
+        provider: nextMessages[index].provider || provider,
+        acpToolCall: mergeToolCallSnapshot(nextMessages[index].acpToolCall, payload)
       };
       break;
     }
@@ -563,7 +817,12 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
         timestamp,
         provider
       });
-      nextMessages[index] = { ...nextMessages[index], toolName: payload.toolName || nextMessages[index].toolName };
+      nextMessages[index] = {
+        ...nextMessages[index],
+        toolName: payload.toolName || nextMessages[index].toolName,
+        toolEndedAt: timestamp,
+        acpToolCall: mergeToolCallSnapshot(nextMessages[index].acpToolCall, payload)
+      };
       break;
     }
 
@@ -578,17 +837,44 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
       nextMessages[index] = {
         ...nextMessages[index],
         toolResult: {
-          content: stringifyToolContent(payload.content || ''),
+          content: stringifyToolContent(payload.content ?? ''),
           isError: !!payload.isError,
           toolUseResult: payload.toolUseResult || null,
+          rawOutput: payload.rawOutput,
+          contentBlocks: Array.isArray(payload.contentBlocks) ? cloneJsonValue(payload.contentBlocks) : null,
+          status: payload.status || null,
           timestamp
         },
         toolError: !!payload.isError,
-        provider: nextMessages[index].provider || provider
+        toolEndedAt: nextMessages[index].toolEndedAt || timestamp,
+        provider: nextMessages[index].provider || provider,
+        acpToolCall: mergeToolCallSnapshot(nextMessages[index].acpToolCall, payload)
       };
       break;
     }
 
+    case CONVERSATION_EVENT_KINDS.PLAN_UPDATE: {
+      const planEntries = Array.isArray(payload.entries) ? cloneJsonValue(payload.entries) : [];
+      const index = findLatestTimelineMessageIndex(nextMessages, (message) => !!message?.isPlanUpdate);
+      const nextPlanMessage = {
+        ...(index >= 0 ? nextMessages[index] : {}),
+        id: (index >= 0 ? nextMessages[index]?.id : null) || `plan:${event.sessionId || provider}`,
+        type: 'assistant',
+        content: String(payload.message || 'Plan updated'),
+        timestamp,
+        provider,
+        isPlanUpdate: true,
+        planEntries
+      };
+
+      if (index >= 0) {
+        nextMessages[index] = nextPlanMessage;
+      } else {
+        nextMessages.push(nextPlanMessage);
+      }
+      break;
+    }
+
     case CONVERSATION_EVENT_KINDS.APPROVAL_REQUEST:
       if (payload.message) {
         nextMessages.push({
@@ -641,6 +927,8 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
       break;
 
     case CONVERSATION_EVENT_KINDS.SESSION_STATE_CHANGED:
+    case CONVERSATION_EVENT_KINDS.MODE_UPDATE:
+    case CONVERSATION_EVENT_KINDS.AVAILABLE_COMMANDS_UPDATE:
     case CONVERSATION_EVENT_KINDS.ARTIFACT_CREATED:
     default:
       break;
@@ -661,6 +949,39 @@ export function conversationEventsToTimelineMessages(events = [], sessionProvide
   );
 }
 
+export function extractAcpSessionMetadataFromConversationEvents(events = []) {
+  const metadata = {
+    modeState: null,
+    availableCommands: []
+  };
+
+  for (const event of Array.isArray(events) ? events : []) {
+    if (!isConversationEvent(event)) {
+      continue;
+    }
+
+    if (event.kind === CONVERSATION_EVENT_KINDS.MODE_UPDATE) {
+      const nextModeState = normalizeAcpModeState(event.payload || {});
+      if (nextModeState) {
+        metadata.modeState = metadata.modeState
+          ? {
+              availableModes: nextModeState.availableModes.length > 0
+                ? nextModeState.availableModes
+                : metadata.modeState.availableModes,
+              currentModeId: nextModeState.currentModeId || metadata.modeState.currentModeId || null
+            }
+          : nextModeState;
+      }
+    }
+
+    if (event.kind === CONVERSATION_EVENT_KINDS.AVAILABLE_COMMANDS_UPDATE) {
+      metadata.availableCommands = normalizeAcpAvailableCommands(event.payload || {});
+    }
+  }
+
+  return metadata;
+}
+
 function inferRealtimeMessageId(payload, provider, sessionId, kindPrefix = 'assistant_text') {
   const data = payload?.data || {};
   const idCandidate =
@@ -736,7 +1057,7 @@ export function normalizeRealtimePayloadToConversationEvents(payload, fallbackPr
   const rawRef = { type: payload.type };
 
   if (payload.type === 'session-created') {
-    return [
+    const events = [
       createConversationEvent({
         kind: CONVERSATION_EVENT_KINDS.SESSION_STATE_CHANGED,
         provider,
@@ -746,6 +1067,22 @@ export function normalizeRealtimePayloadToConversationEvents(payload, fallbackPr
         rawRef
       })
     ];
+
+    const initialModeState = normalizeAcpModeState(payload.modes || null);
+    if (initialModeState) {
+      events.push(
+        createConversationEvent({
+          kind: CONVERSATION_EVENT_KINDS.MODE_UPDATE,
+          provider,
+          sessionId,
+          timestamp,
+          payload: initialModeState,
+          rawRef
+        })
+      );
+    }
+
+    return events;
   }
 
   if (payload.type === 'claude-permission-request') {