@axhub/genie 0.2.7 → 0.2.9

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

@@ -185,11 +185,61 @@ function createTextEndEvent({
   ];
 }
 
+function extractProtocolUserMessage(value) {
+  const text = String(value || '').trim();
+  if (!text) {
+    return null;
+  }
+
+  const dynamicContextMatch = text.match(
+    /<dynamic_context(?:\s[^>]*)?>[\s\S]*?<\/dynamic_context>\s*<user_message(?:\s[^>]*)?>\s*([\s\S]*?)\s*<\/user_message>/i
+  );
+  if (!dynamicContextMatch) {
+    return null;
+  }
+
+  return String(dynamicContextMatch[1] || '').trim();
+}
+
+function hasAcpProtocolTags(value) {
+  return /<\/?(?:subagent_notification|environment_context|dynamic_context|user_message)(?:\s[^>]*)?>/i.test(String(value || ''));
+}
+
+export function stripAssistantProtocolTags(text) {
+  if (typeof text !== 'string') {
+    return text;
+  }
+
+  const visibleUserMessage = extractProtocolUserMessage(text);
+  if (visibleUserMessage != null) {
+    return visibleUserMessage;
+  }
+
+  const hadProtocolTags = hasAcpProtocolTags(text);
+  let result = text;
+
+  result = result.replace(/<subagent_notification(?:\s[^>]*)?>[\s\S]*?<\/subagent_notification>/gi, '');
+  result = result.replace(/<environment_context(?:\s[^>]*)?>[\s\S]*?<\/environment_context>/gi, '');
+  result = result.replace(/<dynamic_context(?:\s[^>]*)?>[\s\S]*?<\/dynamic_context>/gi, '');
+  result = result.replace(/<\/?(?:subagent_notification|environment_context|dynamic_context|user_message)(?:\s[^>]*)?>/gi, '');
+
+  if (hadProtocolTags) {
+    result = result.replace(/["']?\s*\}\s*\}\s*$/g, '');
+  }
+
+  return result.trim();
+}
+
 function extractVisibleUserMessage(value) {
   const text = String(value || '').trim();
   if (!text) return '';
 
-  if (text.startsWith('# AGENTS.md instructions for ') || text.includes('<environment_context>')) {
+  if (
+    text.startsWith('# AGENTS.md instructions for ') ||
+    text.includes('<environment_context>') ||
+    text.startsWith('<subagent_notification>') ||
+    text.startsWith('</subagent_notification>')
+  ) {
     return '';
   }
 
@@ -202,11 +252,9 @@ function extractVisibleUserMessage(value) {
     return '';
   }
 
-  const dynamicContextMatch = text.match(
-    /^<dynamic_context(?:\s[^>]*)?>[\s\S]*?<\/dynamic_context>\s*<user_message>\s*([\s\S]*?)\s*<\/user_message>$/i
-  );
-  if (dynamicContextMatch) {
-    return String(dynamicContextMatch[1] || '').trim();
+  const protocolUserMessage = extractProtocolUserMessage(text);
+  if (protocolUserMessage != null) {
+    return protocolUserMessage;
   }
 
   return text;
@@ -222,12 +270,16 @@ function isHiddenSystemContextContent(value) {
     text.startsWith('[Dynamic Context]') ||
     text.startsWith('[Hidden Context]') ||
     text.startsWith('# AGENTS.md instructions for ') ||
-    text.startsWith('[DYNAMIC CONTEXT V1]')
+    text.startsWith('[DYNAMIC CONTEXT V1]') ||
+    text.startsWith('<subagent_notification>') ||
+    text.startsWith('</subagent_notification>')
   ) {
     return true;
   }
 
-  return /^<dynamic_context(?:\s|>)/i.test(text) || text.includes('<environment_context>');
+  return /^<dynamic_context(?:\s|>)/i.test(text)
+    || text.includes('<environment_context>')
+    || /<subagent_notification(?:\s|>)/i.test(text);
 }
 
 function stringifyToolContent(value) {
@@ -613,8 +665,11 @@ export function normalizeLegacyHistoryEntries(rawMessages = [], provider = 'clau
     if (msg?.message?.role === 'assistant' && msg?.message?.content) {
       if (Array.isArray(msg.message.content)) {
         for (const part of msg.message.content) {
-          if (part?.type === 'text' && !isHiddenSystemContextContent(part.text)) {
-            events.push(...createTextSpanEvents({ text: part.text, provider, sessionId, timestamp, rawRef }));
+          if (part?.type === 'text') {
+            const cleanText = stripAssistantProtocolTags(part.text);
+            if (cleanText && !isHiddenSystemContextContent(cleanText)) {
+              events.push(...createTextSpanEvents({ text: cleanText, provider, sessionId, timestamp, rawRef }));
+            }
           } else if (part?.type === 'tool_use') {
             const toolCallId = part.id || createEventId('tool');
             const result = toolResults.get(part.id);
@@ -633,8 +688,11 @@ export function normalizeLegacyHistoryEntries(rawMessages = [], provider = 'clau
             }
           }
         }
-      } else if (!isHiddenSystemContextContent(msg.message.content)) {
-        events.push(...createTextSpanEvents({ text: msg.message.content, provider, sessionId, timestamp, rawRef }));
+      } else {
+        const cleanText = stripAssistantProtocolTags(msg.message.content);
+        if (cleanText && !isHiddenSystemContextContent(cleanText)) {
+          events.push(...createTextSpanEvents({ text: cleanText, provider, sessionId, timestamp, rawRef }));
+        }
       }
       continue;
     }
@@ -660,6 +718,12 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
       const clientRequestId = getConversationEventClientRequestId(event);
       const optimisticIndex = findMatchingOptimisticUserMessageIndex(nextMessages, event, payload);
       const normalizedContentBlocks = normalizeMessageContentBlocks(payload.contentBlocks);
+      const rawText = typeof payload.text === 'string' ? payload.text : '';
+      const visibleText = rawText ? extractVisibleUserMessage(rawText) : '';
+
+      if (rawText.trim() && !visibleText && normalizedContentBlocks.length === 0) {
+        break;
+      }
 
       if (optimisticIndex >= 0) {
         const existingMessage = nextMessages[optimisticIndex] || {};
@@ -670,7 +734,7 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
         nextMessages[optimisticIndex] = {
           ...existingMessage,
           type: 'user',
-          content: payload.text || existingMessage.content || '',
+          content: visibleText || existingMessage.content || '',
           timestamp: existingMessage.timestamp || timestamp,
           provider,
           contentBlocks: nextContentBlocks,
@@ -683,7 +747,7 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
 
       nextMessages.push({
         type: 'user',
-        content: payload.text || '',
+        content: visibleText,
         timestamp,
         provider,
         contentBlocks: normalizedContentBlocks,