dr-claw 1.1.2

package/server/__tests__/gemini-legacy-thought.test.mjs

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import { splitLegacyGeminiThoughtContent } from '../../shared/geminiThoughtParser.js';
+import { normalizePersistedGeminiAssistantEntries } from '../gemini-cli.js';
+
+describe('splitLegacyGeminiThoughtContent (server)', () => {
+  it('returns null for plain text without markers', () => {
+    expect(splitLegacyGeminiThoughtContent('Hello world')).toBeNull();
+  });
+
+  it('returns null for non-string input', () => {
+    expect(splitLegacyGeminiThoughtContent(null)).toBeNull();
+    expect(splitLegacyGeminiThoughtContent(undefined)).toBeNull();
+    expect(splitLegacyGeminiThoughtContent(42)).toBeNull();
+  });
+
+  it('returns null for empty string', () => {
+    expect(splitLegacyGeminiThoughtContent('')).toBeNull();
+  });
+
+  it('returns null when marker produces fewer than 2 segments', () => {
+    expect(splitLegacyGeminiThoughtContent('[Thought: true]')).toBeNull();
+  });
+
+  it('splits single marker into thinking + final', () => {
+    const result = splitLegacyGeminiThoughtContent('thinking\n[Thought: true]\nfinal');
+    expect(result).toEqual([
+      { content: 'thinking', isThinking: true },
+      { content: 'final', isThinking: false },
+    ]);
+  });
+
+  it('splits multiple markers correctly', () => {
+    const result = splitLegacyGeminiThoughtContent(
+      't1\n[Thought: true]\nt2\n[Thought: true]\nfinal'
+    );
+    expect(result).toEqual([
+      { content: 't1', isThinking: true },
+      { content: 't2', isThinking: true },
+      { content: 'final', isThinking: false },
+    ]);
+  });
+
+  it('is case insensitive', () => {
+    const result = splitLegacyGeminiThoughtContent('thinking\n[thought: TRUE]\nfinal');
+    expect(result).toEqual([
+      { content: 'thinking', isThinking: true },
+      { content: 'final', isThinking: false },
+    ]);
+  });
+});
+
+describe('normalizePersistedGeminiAssistantEntries', () => {
+  it('returns single assistant entry for plain text', () => {
+    const result = normalizePersistedGeminiAssistantEntries('Hello world');
+    expect(result).toEqual([
+      { role: 'assistant', content: 'Hello world', type: 'message' },
+    ]);
+  });
+
+  it('splits legacy thought text into thinking + message entries', () => {
+    const result = normalizePersistedGeminiAssistantEntries(
+      'thinking content\n[Thought: true]\nfinal answer'
+    );
+    expect(result).toEqual([
+      { role: 'assistant', type: 'thinking', content: 'thinking content' },
+      { role: 'assistant', content: 'final answer', type: 'message' },
+    ]);
+  });
+
+  it('handles multiple thinking segments', () => {
+    const result = normalizePersistedGeminiAssistantEntries(
+      't1\n[Thought: true]\nt2\n[Thought: true]\nfinal'
+    );
+    expect(result).toEqual([
+      { role: 'assistant', type: 'thinking', content: 't1' },
+      { role: 'assistant', type: 'thinking', content: 't2' },
+      { role: 'assistant', content: 'final', type: 'message' },
+    ]);
+  });
+
+  it('preserves non-string content as-is', () => {
+    const content = { parts: [{ text: 'hello' }] };
+    const result = normalizePersistedGeminiAssistantEntries(content);
+    expect(result).toEqual([
+      { role: 'assistant', content, type: 'message' },
+    ]);
+  });
+});

package/server/__tests__/runtimePorts.test.mjs

@@ -0,0 +1,115 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const probeResults = [];
+
+vi.mock('net', () => ({
+  default: {
+    createServer() {
+      let errorHandler = null;
+
+      return {
+        once(event, handler) {
+          if (event === 'error') {
+            errorHandler = handler;
+          }
+        },
+        off(event, handler) {
+          if (event === 'error' && errorHandler === handler) {
+            errorHandler = null;
+          }
+        },
+        listen(port, host, callback) {
+          const nextResult = probeResults.shift();
+          if (nextResult instanceof Error) {
+            queueMicrotask(() => errorHandler?.(nextResult));
+            return;
+          }
+          queueMicrotask(() => callback());
+        },
+        close(callback) {
+          queueMicrotask(() => callback?.());
+        },
+      };
+    },
+  },
+}));
+
+const {
+  DEFAULT_FRONTEND_PORT,
+  getBackendPortSync,
+  getFrontendPortSync,
+  listenOnAvailablePort,
+  setRuntimePortSync,
+} = await import('../utils/runtimePorts.js');
+
+const cleanupTasks = [];
+
+function createFakeHttpServer() {
+  let errorHandler = null;
+  let listenedPort = null;
+
+  return {
+    once(event, handler) {
+      if (event === 'error') {
+        errorHandler = handler;
+      }
+    },
+    off(event, handler) {
+      if (event === 'error' && errorHandler === handler) {
+        errorHandler = null;
+      }
+    },
+    listen(port, host, callback) {
+      listenedPort = port;
+      queueMicrotask(() => callback());
+    },
+    get listenedPort() {
+      return listenedPort;
+    },
+  };
+}
+
+afterEach(async () => {
+  probeResults.length = 0;
+
+  while (cleanupTasks.length > 0) {
+    const task = cleanupTasks.pop();
+    await task();
+  }
+
+  delete process.env.DR_CLAW_RUNTIME_DIR;
+  delete process.env.DR_CLAW_RUNTIME_FILE;
+});
+
+describe('runtimePorts', () => {
+  it('listens on the next available backend port when the requested port is occupied', async () => {
+    const busyPortError = new Error('busy');
+    busyPortError.code = 'EADDRINUSE';
+    probeResults.push(busyPortError, true);
+
+    const server = createFakeHttpServer();
+    const activePort = await listenOnAvailablePort(server, {
+      startPort: 3001,
+      host: '0.0.0.0',
+      maxAttempts: 5,
+    });
+
+    expect(activePort).toBe(3002);
+    expect(server.listenedPort).toBe(3002);
+  });
+
+  it('reads runtime ports from an override directory and ignores stale process entries', async () => {
+    const runtimeDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dr-claw-runtime-'));
+    process.env.DR_CLAW_RUNTIME_DIR = runtimeDir;
+    cleanupTasks.push(() => fs.rm(runtimeDir, { recursive: true, force: true }));
+
+    setRuntimePortSync('backend', 4321);
+    setRuntimePortSync('frontend', 9876, 999999999);
+
+    expect(getBackendPortSync(3001)).toBe(4321);
+    expect(getFrontendPortSync(DEFAULT_FRONTEND_PORT)).toBe(DEFAULT_FRONTEND_PORT);
+  });
+});

package/server/__tests__/session-delete.test.mjs

@@ -0,0 +1,166 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtemp, mkdir, rm, writeFile } from 'fs/promises';
+import os from 'os';
+import path from 'path';
+
+const originalHome = process.env.HOME;
+const originalUserProfile = process.env.USERPROFILE;
+const originalDatabasePath = process.env.DATABASE_PATH;
+
+let tempRoot = null;
+
+async function loadTestModules() {
+  vi.resetModules();
+  const projects = await import('../projects.js');
+  const database = await import('../database/db.js');
+  await database.initializeDatabase();
+  return { projects, database };
+}
+
+async function writeCodexSessionFile({
+  relativePath,
+  sessionId,
+  cwd = '/tmp/test-project',
+  userMessage = 'Hello from Codex',
+  assistantMessage = 'Hi there',
+  timestamp = '2026-03-30T11:00:00.000Z',
+}) {
+  const sessionFile = path.join(tempRoot, '.codex', 'sessions', relativePath);
+  await mkdir(path.dirname(sessionFile), { recursive: true });
+
+  const lines = [
+    {
+      timestamp,
+      type: 'session_meta',
+      payload: {
+        id: sessionId,
+        timestamp,
+        cwd,
+        model: 'gpt-5.4',
+      },
+    },
+    {
+      timestamp,
+      type: 'event_msg',
+      payload: {
+        type: 'user_message',
+        message: userMessage,
+      },
+    },
+    {
+      timestamp,
+      type: 'response_item',
+      payload: {
+        type: 'message',
+        role: 'assistant',
+        content: [{ type: 'output_text', text: assistantMessage }],
+      },
+    },
+  ].map((entry) => JSON.stringify(entry)).join('\n');
+
+  await writeFile(sessionFile, `${lines}\n`, 'utf8');
+  return sessionFile;
+}
+
+describe('session deletion fallbacks', () => {
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(os.tmpdir(), 'dr-claw-session-delete-'));
+    process.env.HOME = tempRoot;
+    process.env.USERPROFILE = tempRoot;
+    process.env.DATABASE_PATH = path.join(tempRoot, 'db', 'auth.db');
+  });
+
+  afterEach(async () => {
+    vi.resetModules();
+
+    if (originalHome === undefined) delete process.env.HOME;
+    else process.env.HOME = originalHome;
+
+    if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = originalUserProfile;
+
+    if (originalDatabasePath === undefined) delete process.env.DATABASE_PATH;
+    else process.env.DATABASE_PATH = originalDatabasePath;
+
+    if (tempRoot) {
+      await rm(tempRoot, { recursive: true, force: true });
+      tempRoot = null;
+    }
+  });
+
+  it('deletes a Claude session from the index when the project directory is missing', async () => {
+    const { projects, database } = await loadTestModules();
+    const projectName = 'tmp-project';
+    const sessionId = 'claude-session-missing-file';
+
+    database.sessionDb.upsertSessionPlaceholder(sessionId, projectName, 'claude');
+    expect(database.sessionDb.getSessionById(sessionId)?.provider).toBe('claude');
+
+    await expect(projects.deleteSession(projectName, sessionId, 'claude')).resolves.toBe(true);
+    expect(database.sessionDb.getSessionById(sessionId)).toBeNull();
+  });
+
+  it('deletes a Gemini session from the index when the jsonl file is missing', async () => {
+    const { projects, database } = await loadTestModules();
+    const projectName = 'tmp-project';
+    const sessionId = 'gemini-session-missing-file';
+
+    database.sessionDb.upsertSessionPlaceholder(sessionId, projectName, 'gemini');
+    expect(database.sessionDb.getSessionById(sessionId)?.provider).toBe('gemini');
+
+    await expect(projects.deleteSession(projectName, sessionId, 'gemini')).resolves.toBe(true);
+    expect(database.sessionDb.getSessionById(sessionId)).toBeNull();
+  });
+
+  it('deletes a Codex session from the index when the jsonl file is missing', async () => {
+    const { projects, database } = await loadTestModules();
+    const projectName = 'tmp-project';
+    const sessionId = 'codex-session-missing-file';
+
+    database.sessionDb.upsertSessionPlaceholder(sessionId, projectName, 'codex');
+    expect(database.sessionDb.getSessionById(sessionId)?.provider).toBe('codex');
+
+    await expect(projects.deleteCodexSession(sessionId)).resolves.toBe(true);
+    expect(database.sessionDb.getSessionById(sessionId)).toBeNull();
+  });
+
+  it('reads Codex session messages by embedded metadata when the filename lookup key differs', async () => {
+    const { projects } = await loadTestModules();
+    const sessionId = '019d3967-fcdc-7501-8441-f443c81e2de0';
+
+    await writeCodexSessionFile({
+      relativePath: path.join('2026', '03', '30', 'rollout-2026-03-30T07-43-29-mismatched-name.jsonl'),
+      sessionId,
+      cwd: path.join(tempRoot, 'workspace', 'proj-a'),
+      userMessage: 'Hello from regression test',
+      assistantMessage: 'Codex responded successfully',
+    });
+
+    const result = await projects.getCodexSessionMessages(sessionId);
+    expect(result.messages.length).toBeGreaterThanOrEqual(1);
+
+    const assistantMessages = result.messages.filter((entry) => entry?.message?.role === 'assistant');
+
+    expect(assistantMessages.some((entry) => entry.message.content.includes('Codex responded successfully'))).toBe(true);
+  });
+
+  it('indexes Codex sessions using the real session id from metadata', async () => {
+    const { projects } = await loadTestModules();
+    const sessionId = '019d3967-a181-7171-9e9f-7b73811c0d71';
+    const projectPath = path.join(tempRoot, 'workspace', 'proj-b');
+
+    await writeCodexSessionFile({
+      relativePath: path.join('2026', '03', '30', `rollout-2026-03-30T07-43-06-${sessionId}.jsonl`),
+      sessionId,
+      cwd: projectPath,
+      userMessage: 'Inspect the project state',
+      assistantMessage: 'I found the pipeline files',
+    });
+
+    const sessions = await projects.getCodexSessions(projectPath, { limit: 10 });
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0].id).toBe(sessionId);
+    expect(sessions[0].provider).toBe('codex');
+    expect(sessions[0].summary).toContain('Inspect the project state');
+  });
+});

package/server/bin/compute-node

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { ComputeNode } from '../compute-node.js';
+import path from 'path';
+
+// Parse args
+const args = process.argv.slice(2);
+const command = args[0];
+
+// Check for --no-sync flag
+const noSync = args.includes('--no-sync');
+
+// Check for --node <id> flag
+let nodeId = null;
+const nodeIdx = args.indexOf('--node');
+if (nodeIdx >= 0 && args[nodeIdx + 1]) {
+  nodeId = args[nodeIdx + 1];
+}
+
+// Filter out flags
+const filteredArgs = args.filter((a, i) => {
+  if (a === '--no-sync') return false;
+  if (a === '--node') return false;
+  if (i > 0 && args[i - 1] === '--node') return false;
+  return true;
+});
+
+async function main() {
+  try {
+    if (command === 'configure') {
+      const config = {};
+      for (let i = 1; i < filteredArgs.length; i++) {
+        if (filteredArgs[i].startsWith('--')) {
+          const key = filteredArgs[i].substring(2);
+          const value = filteredArgs[i+1];
+          config[key] = value;
+          i++;
+        }
+      }
+      console.log(await ComputeNode.configure(config));
+    }
+    else if (command === 'sync') {
+      const direction = filteredArgs[1] || 'up';
+      console.log(await ComputeNode.sync({ nodeId, direction, cwd: process.cwd() }));
+    }
+    else if (command === 'run') {
+      const cmd = filteredArgs.slice(1).join(' ');
+      console.log(await ComputeNode.run({
+        nodeId,
+        command: cmd,
+        cwd: noSync ? undefined : process.cwd(),
+        skipSync: noSync
+      }));
+    }
+    else {
+      console.log("Usage: compute-node [configure|sync|run] [--node <id>] [--no-sync]");
+      console.log("  configure --host X --user Y --workDir Z");
+      console.log("  sync [up|down]                     (sync active node)");
+      console.log("  sync --node <id> [up|down]         (sync specific node)");
+      console.log("  run \"command\"                      (auto-syncs code first)");
+      console.log("  run --no-sync \"command\"            (run without syncing)");
+      console.log("  run --node <id> --no-sync \"cmd\"    (run on specific node)");
+    }
+  } catch (error) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+}
+
+main();