dr-claw 1.1.2

package/server/utils/runtimePorts.js

@@ -0,0 +1,212 @@
+import fs from 'fs';
+import net from 'net';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export const DEFAULT_BACKEND_PORT = 3001;
+export const DEFAULT_FRONTEND_PORT = 5173;
+const DEFAULT_MAX_PORT_ATTEMPTS = 20;
+
+function getProjectRoot() {
+    return path.join(__dirname, '../..');
+}
+
+function getRuntimePortsPath() {
+    if (process.env.DR_CLAW_RUNTIME_FILE) {
+        return process.env.DR_CLAW_RUNTIME_FILE;
+    }
+
+    const runtimeDir = process.env.DR_CLAW_RUNTIME_DIR || path.join(getProjectRoot(), '.runtime');
+    return path.join(runtimeDir, 'ports.json');
+}
+
+function ensureRuntimeDirSync() {
+    fs.mkdirSync(path.dirname(getRuntimePortsPath()), { recursive: true });
+}
+
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+
+function sanitizeRuntimeEntry(entry) {
+    if (!entry || typeof entry !== 'object') {
+        return null;
+    }
+
+    const port = Number(entry.port);
+    if (!Number.isInteger(port) || port <= 0) {
+        return null;
+    }
+
+    const pid = Number(entry.pid);
+    if (Number.isInteger(pid) && pid > 0 && !isPidAlive(pid)) {
+        return null;
+    }
+
+    return {
+        port,
+        pid: Number.isInteger(pid) && pid > 0 ? pid : null,
+        updatedAt: typeof entry.updatedAt === 'string' ? entry.updatedAt : null,
+    };
+}
+
+function readRawRuntimePortsSync() {
+    try {
+        const content = fs.readFileSync(getRuntimePortsPath(), 'utf8');
+        const parsed = JSON.parse(content);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    } catch (error) {
+        if (error.code !== 'ENOENT') {
+            console.warn('[runtimePorts] Failed to read runtime ports file:', error.message);
+        }
+        return {};
+    }
+}
+
+function writeRawRuntimePortsSync(state) {
+    ensureRuntimeDirSync();
+    fs.writeFileSync(getRuntimePortsPath(), `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+
+export function parsePortNumber(value, fallback) {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+export function getRuntimePortStateSync() {
+    const rawState = readRawRuntimePortsSync();
+    return {
+        backend: sanitizeRuntimeEntry(rawState.backend),
+        frontend: sanitizeRuntimeEntry(rawState.frontend),
+    };
+}
+
+export function getRuntimePortSync(kind, fallback) {
+    const state = getRuntimePortStateSync();
+    return state[kind]?.port ?? fallback;
+}
+
+export function getBackendPortSync(fallback = DEFAULT_BACKEND_PORT) {
+    return getRuntimePortSync('backend', fallback);
+}
+
+export function getFrontendPortSync(fallback = DEFAULT_FRONTEND_PORT) {
+    return getRuntimePortSync('frontend', fallback);
+}
+
+export function setRuntimePortSync(kind, port, pid = process.pid) {
+    const normalizedPort = parsePortNumber(port, null);
+    if (!normalizedPort) {
+        throw new Error(`Invalid port for ${kind}: ${port}`);
+    }
+
+    const rawState = readRawRuntimePortsSync();
+    rawState[kind] = {
+        port: normalizedPort,
+        pid,
+        updatedAt: new Date().toISOString(),
+    };
+    writeRawRuntimePortsSync(rawState);
+}
+
+async function isPortAvailable(port, host) {
+    return new Promise((resolve, reject) => {
+        const probe = net.createServer();
+
+        const handleError = (error) => {
+            cleanup();
+            if (error.code === 'EADDRINUSE') {
+                resolve(false);
+                return;
+            }
+            reject(error);
+        };
+
+        const cleanup = () => {
+            probe.off('error', handleError);
+        };
+
+        probe.once('error', handleError);
+        probe.listen(port, host, () => {
+            probe.close((error) => {
+                cleanup();
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(true);
+            });
+        });
+    });
+}
+
+async function listenOnce(server, port, host) {
+    await new Promise((resolve, reject) => {
+        const handleError = (error) => {
+            cleanup();
+            reject(error);
+        };
+
+        const cleanup = () => {
+            server.off('error', handleError);
+        };
+
+        server.once('error', handleError);
+        server.listen(port, host, () => {
+            cleanup();
+            resolve();
+        });
+    });
+}
+
+export async function listenOnAvailablePort(server, options = {}) {
+    const startPort = parsePortNumber(options.startPort, DEFAULT_BACKEND_PORT);
+    const host = options.host || '0.0.0.0';
+    const maxAttempts = Number.isInteger(options.maxAttempts) && options.maxAttempts > 0
+        ? options.maxAttempts
+        : DEFAULT_MAX_PORT_ATTEMPTS;
+
+    let lastError = null;
+
+    for (let offset = 0; offset < maxAttempts; offset += 1) {
+        const port = startPort + offset;
+
+        try {
+            const available = await isPortAvailable(port, host);
+            if (!available) {
+                const portBusyError = new Error(`Port ${port} is already in use.`);
+                portBusyError.code = 'EADDRINUSE';
+                lastError = portBusyError;
+                continue;
+            }
+
+            await listenOnce(server, port, host);
+
+            return port;
+        } catch (error) {
+            if (error.code !== 'EADDRINUSE') {
+                throw error;
+            }
+            lastError = error;
+        }
+    }
+
+    const endPort = startPort + maxAttempts - 1;
+    const error = new Error(`No available port found between ${startPort} and ${endPort}.`);
+    error.code = 'EADDRINUSE';
+    error.cause = lastError;
+    throw error;
+}

package/server/utils/sessionFormatting.js

@@ -0,0 +1,68 @@
+/**
+ * Utility functions for formatting and cleaning session content.
+ */
+
+/**
+ * Strips internal [Context: ...] prefixes from message text.
+ * Handles full prefixes [Context: ...] and common truncated ones like [Context: Tre...
+ * @param {string} text - The message text
+ * @param {boolean} returnDefaultOnEmpty - Whether to return 'New Session' if result is empty
+ * @returns {string|null} - Cleaned text or null/default if empty
+ */
+export function stripInternalContextPrefix(text, returnDefaultOnEmpty = true) {
+  if (typeof text !== 'string') return returnDefaultOnEmpty ? '' : null;
+  
+  let cleaned = text;
+  let hasMatch = false;
+
+  const internalCommandTagPattern = /<\/?(?:command-name|command-message|command-args|local-command-stdout)>/i;
+  const skillContentPattern = /Base directory for this skill:\s*\S+/i;
+
+  if (internalCommandTagPattern.test(cleaned) || skillContentPattern.test(cleaned)) {
+    cleaned = cleaned
+      .replace(/<command-name>[^<]*<\/command-name>/gi, '')
+      .replace(/<command-message>[^<]*<\/command-message>/gi, '')
+      .replace(/<command-args>[^<]*<\/command-args>/gi, '')
+      .replace(/<local-command-stdout>[\s\S]*?<\/local-command-stdout>/gi, '')
+      .replace(/^[❯>]\s*Base directory for this skill:\s*\S+\s*/gim, '')
+      .replace(/^Base directory for this skill:\s*\S+\s*/gim, '')
+      .trim();
+    hasMatch = true;
+  }
+  
+  // 1. Match full [Context: ...] prefixes at the start of the string, including multiple ones
+  const fullPrefixPattern = /^\s*\[Context:[^\]]*\]\s*/i;
+  while (fullPrefixPattern.test(cleaned)) {
+    cleaned = cleaned.replace(fullPrefixPattern, '');
+    hasMatch = true;
+  }
+  
+  // 2. Match common truncated prefixes like "[Context: session-mode=..." or "[Context: Tre..."
+  // This is specifically for database entries where the summary was truncated before the closing bracket
+  const truncatedPrefixPattern = /^\s*\[Context:[^\]]*$/i;
+  if (truncatedPrefixPattern.test(cleaned)) {
+    // If it's JUST a truncated context prefix and we have no other content, return default or null
+    return returnDefaultOnEmpty ? 'New Session' : null;
+  }
+
+  const result = cleaned.trim();
+  
+  // If we didn't find any context prefix and we have text, return it as is
+  if (!hasMatch && result) {
+    return result;
+  }
+
+  // If it's empty after cleaning, but we had a match (it was pure context)
+  if (!result && hasMatch) {
+    if (!returnDefaultOnEmpty) return null;
+    
+    // Fallback: If it's a new session and we ONLY have context, 
+    // try to find some semantic info in the context itself or return a better default
+    if (text.includes('session-mode=workspace_qa')) return 'Workspace Q&A';
+    if (text.includes('session-mode=research')) return 'Research Session';
+    
+    return 'New Session';
+  }
+  
+  return result || (returnDefaultOnEmpty ? 'New Session' : null);
+}

package/server/utils/sessionIndex.js

@@ -0,0 +1,100 @@
+import { sessionDb, tagDb } from '../database/db.js';
+import { encodeProjectPath } from '../projects.js';
+
+function defaultSessionName(provider) {
+  switch (provider) {
+    case 'cursor':
+      return 'Untitled Session';
+    case 'codex':
+      return 'Codex Session';
+    case 'gemini':
+      return 'Gemini Session';
+    case 'openrouter':
+      return 'OpenRouter Session';
+    case 'local':
+      return 'Local GPU Session';
+    default:
+      return 'New Session';
+  }
+}
+
+function normalizeStageTagKeys(stageTagKeys = []) {
+  const normalized = Array.from(new Set(
+    (Array.isArray(stageTagKeys) ? stageTagKeys : [])
+      .map((value) => String(value || '').trim().toLowerCase())
+      .filter((value) => ['survey', 'ideation', 'experiment', 'publication', 'promotion'].includes(value))
+  ));
+
+  return normalized;
+}
+
+export function applyStageTagsToSession({
+  sessionId,
+  projectPath = null,
+  projectName = null,
+  stageTagKeys = [],
+  source = 'chat_context',
+  linkedBy = null,
+}) {
+  if (!sessionId) {
+    return [];
+  }
+
+  const normalizedStageTagKeys = normalizeStageTagKeys(stageTagKeys);
+  if (normalizedStageTagKeys.length === 0) {
+    return [];
+  }
+
+  const resolvedProjectName = projectName || (projectPath ? encodeProjectPath(projectPath) : null);
+  if (!resolvedProjectName) {
+    return [];
+  }
+
+  tagDb.ensureDefaultStageTags(resolvedProjectName);
+  return tagDb.appendSessionTagsByKeys(sessionId, resolvedProjectName, 'stage', normalizedStageTagKeys, {
+    source,
+    linkedBy,
+  });
+}
+
+export function recordIndexedSession({
+  sessionId,
+  provider,
+  projectPath,
+  sessionMode = 'research',
+  displayName = null,
+  lastActivity = null,
+  stageTagKeys = [],
+  tagSource = 'chat_context',
+  linkedBy = null,
+}) {
+  if (!sessionId || !provider || !projectPath) {
+    return;
+  }
+
+  const projectName = encodeProjectPath(projectPath);
+  sessionDb.upsertSessionPlaceholder(
+    sessionId,
+    projectName,
+    provider,
+    displayName || defaultSessionName(provider),
+    lastActivity || new Date().toISOString(),
+    {
+      sessionMode,
+      projectPath,
+      indexState: 'placeholder',
+    },
+  );
+
+  // Dual-path tag application: tags are also applied at spawn start (in the CLI modules)
+  // for immediate tagging of existing sessions. This second call ensures tags are applied
+  // for newly created sessions. INSERT OR IGNORE in appendSessionTagsByKeys prevents duplicates.
+  applyStageTagsToSession({
+    sessionId,
+    projectPath,
+    projectName,
+    stageTagKeys,
+    source: tagSource,
+    linkedBy,
+  });
+}

package/server/utils/sessionMode.js

@@ -0,0 +1,95 @@
+const EXPLICIT_SESSION_MODES = new Set(['research', 'workspace_qa']);
+
+function normalizeSessionModeValue(value) {
+  return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+
+export function normalizeSessionMode(value) {
+  return normalizeSessionModeValue(value) === 'workspace_qa' ? 'workspace_qa' : 'research';
+}
+
+export function readExplicitSessionModeValue(value) {
+  const normalized = normalizeSessionModeValue(value);
+  return EXPLICIT_SESSION_MODES.has(normalized) ? normalized : null;
+}
+
+export function extractSessionModeFromMetadata(metadata) {
+  if (!metadata || typeof metadata !== 'object') {
+    return 'research';
+  }
+
+  return readExplicitSessionModeFromMetadata(metadata) || 'research';
+}
+
+export function readExplicitSessionModeFromMetadata(metadata) {
+  if (!metadata || typeof metadata !== 'object') {
+    return null;
+  }
+
+  return readExplicitSessionModeValue(metadata.sessionMode)
+    || readExplicitSessionModeValue(metadata.mode);
+}
+
+export function extractSessionModeFromText(value) {
+  const text = String(value || '');
+  if (/\[Context:\s*session-mode=workspace_qa\]/i.test(text)) {
+    return 'workspace_qa';
+  }
+  if (/\[Context:\s*session-mode=research\]/i.test(text)) {
+    return 'research';
+  }
+  return null;
+}
+
+export function inferSessionModeFromUserMessage(value) {
+  const text = String(value || '').trim();
+  if (!text) {
+    return null;
+  }
+
+  const strongWorkspacePatterns = [
+    /\bpull request\b/i,
+    /\bgit\b/i,
+    /\bcommit\b/i,
+    /\bpush\b/i,
+    /\brepo(?:sitory)?\b/i,
+    /提交/,
+    /推送/,
+    /仓库/,
+  ];
+  if (strongWorkspacePatterns.some((pattern) => pattern.test(text))) {
+    return 'workspace_qa';
+  }
+
+  const gitBranchPatterns = [
+    /\bgit\s+branch(?:es)?\b/i,
+    /git.*分支/i,
+    /分支.*git/i,
+  ];
+  if (gitBranchPatterns.some((pattern) => pattern.test(text))) {
+    return 'workspace_qa';
+  }
+
+  const researchPatterns = [
+    /\bresearch\b/i,
+    /\bpaper(?:s)?\b/i,
+    /\bdataset(?:s)?\b/i,
+    /\bexperiment(?:s|al)?\b/i,
+    /\bhypothesis\b/i,
+    /\bsurvey\b/i,
+    /\bbenchmark(?:s)?\b/i,
+    /\bliterature\b/i,
+    /研究/,
+    /论文/,
+    /实验/,
+    /数据集/,
+    /调研/,
+    /综述/,
+    /假设/,
+  ];
+  if (researchPatterns.some((pattern) => pattern.test(text))) {
+    return 'research';
+  }
+
+  return null;
+}

package/server/utils/sessionTokenUsage.js

@@ -0,0 +1,105 @@
+function getFiniteNumber(value) {
+  return Number.isFinite(value) ? value : null;
+}
+
+function findNestedTokenTotal(source, paths) {
+  for (const path of paths) {
+    let cursor = source;
+    let missing = false;
+    for (const key of path) {
+      if (!cursor || typeof cursor !== 'object' || !(key in cursor)) {
+        missing = true;
+        break;
+      }
+      cursor = cursor[key];
+    }
+    if (!missing) {
+      const candidate = getFiniteNumber(cursor);
+      if (candidate != null) return candidate;
+    }
+  }
+  return null;
+}
+
+export function buildCodexUnsupportedContextTokenUsage({
+  total = 200000,
+  lifetimeTokens = null,
+} = {}) {
+  return {
+    used: null,
+    total,
+    unsupportedContext: true,
+    message: 'Current context usage is unavailable for Codex sessions.',
+    ...(lifetimeTokens != null ? { lifetimeTokens } : {}),
+  };
+}
+
+export function buildCodexTokenUsageFromJsonl(fileContent) {
+  const lines = String(fileContent || '').trim().split('\n').filter(Boolean);
+
+  let contextWindow = 200000;
+  let lifetimeTokens = null;
+
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    try {
+      const entry = JSON.parse(lines[i]);
+      if (entry.type !== 'event_msg' || entry.payload?.type !== 'token_count' || !entry.payload?.info) {
+        continue;
+      }
+
+      const tokenInfo = entry.payload.info;
+      const contextFromPayload = findNestedTokenTotal(tokenInfo, [
+        ['current_context_usage', 'total_tokens'],
+        ['current_context_token_usage', 'total_tokens'],
+        ['context_usage', 'total_tokens'],
+        ['active_context_usage', 'total_tokens'],
+        ['context_window_usage', 'total_tokens'],
+      ]);
+
+      const totalFromPayload = getFiniteNumber(tokenInfo.model_context_window);
+      if (totalFromPayload != null) {
+        contextWindow = totalFromPayload;
+      }
+
+      lifetimeTokens = findNestedTokenTotal(tokenInfo, [
+        ['total_token_usage', 'total_tokens'],
+        ['lifetime_token_usage', 'total_tokens'],
+      ]);
+
+      if (contextFromPayload != null) {
+        return {
+          used: contextFromPayload,
+          total: contextWindow,
+        };
+      }
+
+      break;
+    } catch {
+      // Ignore malformed lines and keep scanning backwards.
+    }
+  }
+
+  return buildCodexUnsupportedContextTokenUsage({
+    total: contextWindow,
+    lifetimeTokens,
+  });
+}
+
+export function buildCodexRealtimeTokenBudget(eventUsage, contextWindow = 200000) {
+  const contextTokens = findNestedTokenTotal(eventUsage, [
+    ['current_context_usage', 'total_tokens'],
+    ['context_usage', 'total_tokens'],
+    ['context_window_usage', 'total_tokens'],
+    ['current_context_tokens'],
+    ['context_tokens'],
+  ]);
+
+  if (contextTokens != null) {
+    return {
+      used: contextTokens,
+      total: contextWindow,
+    };
+  }
+
+  return buildCodexUnsupportedContextTokenUsage({ total: contextWindow });
+}

package/server/utils/taskmaster-websocket.js

@@ -0,0 +1,129 @@
+/**
+ * TASKMASTER WEBSOCKET UTILITIES
+ * ==============================
+ * 
+ * Utilities for broadcasting TaskMaster state changes via WebSocket.
+ * Integrates with the existing WebSocket system to provide real-time updates.
+ */
+
+/**
+ * Broadcast TaskMaster project update to all connected clients
+ * @param {WebSocket.Server} wss - WebSocket server instance
+ * @param {string} projectName - Name of the updated project
+ * @param {Object} taskMasterData - Updated TaskMaster data
+ */
+export function broadcastTaskMasterProjectUpdate(wss, projectName, taskMasterData) {
+    if (!wss || !projectName) {
+        console.warn('TaskMaster WebSocket broadcast: Missing wss or projectName');
+        return;
+    }
+
+    const message = {
+        type: 'taskmaster-project-updated',
+        projectName,
+        taskMasterData,
+        timestamp: new Date().toISOString()
+    };
+
+    
+    wss.clients.forEach((client) => {
+        if (client.readyState === 1) { // WebSocket.OPEN
+            try {
+                client.send(JSON.stringify(message));
+            } catch (error) {
+                console.error('Error sending TaskMaster project update:', error);
+            }
+        }
+    });
+}
+
+/**
+ * Broadcast TaskMaster tasks update for a specific project
+ * @param {WebSocket.Server} wss - WebSocket server instance  
+ * @param {string} projectName - Name of the project with updated tasks
+ * @param {Object} tasksData - Updated tasks data
+ */
+export function broadcastTaskMasterTasksUpdate(wss, projectName, tasksData) {
+    if (!wss || !projectName) {
+        console.warn('TaskMaster WebSocket broadcast: Missing wss or projectName');
+        return;
+    }
+
+    const message = {
+        type: 'taskmaster-tasks-updated',
+        projectName,
+        tasksData,
+        timestamp: new Date().toISOString()
+    };
+
+    
+    wss.clients.forEach((client) => {
+        if (client.readyState === 1) { // WebSocket.OPEN
+            try {
+                client.send(JSON.stringify(message));
+            } catch (error) {
+                console.error('Error sending TaskMaster tasks update:', error);
+            }
+        }
+    });
+}
+
+/**
+ * Broadcast MCP server status change
+ * @param {WebSocket.Server} wss - WebSocket server instance
+ * @param {Object} mcpStatus - Updated MCP server status
+ */
+export function broadcastMCPStatusChange(wss, mcpStatus) {
+    if (!wss) {
+        console.warn('TaskMaster WebSocket broadcast: Missing wss');
+        return;
+    }
+
+    const message = {
+        type: 'taskmaster-mcp-status-changed',
+        mcpStatus,
+        timestamp: new Date().toISOString()
+    };
+
+    
+    wss.clients.forEach((client) => {
+        if (client.readyState === 1) { // WebSocket.OPEN
+            try {
+                client.send(JSON.stringify(message));
+            } catch (error) {
+                console.error('Error sending TaskMaster MCP status update:', error);
+            }
+        }
+    });
+}
+
+/**
+ * Broadcast general TaskMaster update notification
+ * @param {WebSocket.Server} wss - WebSocket server instance
+ * @param {string} updateType - Type of update (e.g., 'initialization', 'configuration')
+ * @param {Object} data - Additional data about the update
+ */
+export function broadcastTaskMasterUpdate(wss, updateType, data = {}) {
+    if (!wss || !updateType) {
+        console.warn('TaskMaster WebSocket broadcast: Missing wss or updateType');
+        return;
+    }
+
+    const message = {
+        type: 'taskmaster-update',
+        updateType,
+        data,
+        timestamp: new Date().toISOString()
+    };
+
+    
+    wss.clients.forEach((client) => {
+        if (client.readyState === 1) { // WebSocket.OPEN
+            try {
+                client.send(JSON.stringify(message));
+            } catch (error) {
+                console.error('Error sending TaskMaster update:', error);
+            }
+        }
+    });
+}