@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

package/server/shared/tests/claude-cli-path.test.ts

@@ -47,7 +47,7 @@ test('resolveClaudeCodeExecutablePath can parse a wrapper file path containing l
   assert.equal(resolved, nativePath);
 });
 
-test('resolveClaudeCodeExecutablePath falls back to the configured command when PATH lookup fails', () => {
+test('resolveClaudeCodeExecutablePath keeps an explicitly configured command when PATH lookup fails', () => {
   const execFileSync = (() => {
     throw new Error('not found');
   }) as unknown as ResolveClaudeCodeExecutablePathDependencies['execFileSync'];
@@ -59,3 +59,60 @@ test('resolveClaudeCodeExecutablePath falls back to the configured command when
 
   assert.equal(resolved, 'claude');
 });
+
+test('resolveClaudeCodeExecutablePath returns undefined on Windows when the default resolves to nothing', () => {
+  // The SDK spawns this path directly, so a bare `claude` would fail with
+  // "native binary not found at claude"; undefined means "use your own binary".
+  const execFileSync = (() => {
+    throw new Error('not found');
+  }) as unknown as ResolveClaudeCodeExecutablePathDependencies['execFileSync'];
+
+  const resolved = resolveClaudeCodeExecutablePath(undefined, {
+    platform: 'win32',
+    execFileSync,
+  });
+
+  assert.equal(resolved, undefined);
+});
+
+test('resolveClaudeCodeExecutablePath returns undefined when every wrapper on PATH is a JavaScript launcher', () => {
+  // An older global install ships cli.js and no bin/claude.exe, so nothing on
+  // PATH maps to a native binary the SDK can spawn.
+  const wrapperDir = 'C:\\Users\\dev\\AppData\\Roaming\\npm';
+  const execFileSync =
+    (() => `${wrapperDir}\\claude\r\n${wrapperDir}\\claude.cmd\r\n`) as unknown as ResolveClaudeCodeExecutablePathDependencies['execFileSync'];
+  const readFileSync = (() => 'exec node "$basedir/node_modules/@anthropic-ai/claude-code/cli.js" "$@"') as unknown as ResolveClaudeCodeExecutablePathDependencies['readFileSync'];
+
+  const resolved = resolveClaudeCodeExecutablePath(undefined, {
+    platform: 'win32',
+    execFileSync,
+    existsSync: () => false,
+    readFileSync,
+  });
+
+  assert.equal(resolved, undefined);
+});
+
+test('resolveClaudeCodeExecutablePath still resolves the native exe when both installs are on PATH', () => {
+  const staleDir = 'C:\\Users\\dev\\AppData\\Roaming\\npm';
+  const nativeDir = 'C:\\nvm4w\\nodejs';
+  const nativePath = `${nativeDir}\\node_modules\\@anthropic-ai\\claude-code\\bin\\claude.exe`;
+  const execFileSync =
+    (() => `${staleDir}\\claude\r\n${nativeDir}\\claude\r\n`) as unknown as ResolveClaudeCodeExecutablePathDependencies['execFileSync'];
+  const readFileSync = (() => 'exec node "$basedir/node_modules/@anthropic-ai/claude-code/cli.js" "$@"') as unknown as ResolveClaudeCodeExecutablePathDependencies['readFileSync'];
+
+  const resolved = resolveClaudeCodeExecutablePath(undefined, {
+    platform: 'win32',
+    execFileSync,
+    existsSync: (candidate) => candidate === nativePath,
+    readFileSync,
+  });
+
+  assert.equal(resolved, nativePath);
+});
+
+test('resolveClaudeCodeExecutablePath leaves non-Windows platforms on the bare command', () => {
+  const resolved = resolveClaudeCodeExecutablePath(undefined, { platform: 'linux' });
+
+  assert.equal(resolved, 'claude');
+});

package/server/shared/tests/message-unification.test.ts

@@ -0,0 +1,218 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { prepareTranscriptMessages } from '@/shared/message-unification.js';
+import type { NormalizedMessage } from '@/shared/types.js';
+
+let nextId = 0;
+
+const message = (fields: Partial<NormalizedMessage>): NormalizedMessage => ({
+  id: `m-${(nextId += 1)}`,
+  sessionId: 'session',
+  timestamp: '2026-08-22T00:00:00.000Z',
+  provider: 'claude',
+  kind: 'text',
+  ...fields,
+} as NormalizedMessage);
+
+const prose = () => message({ kind: 'text', role: 'assistant', content: 'Working on it.' });
+
+const taskCall = (
+  toolName: string,
+  toolId: string,
+  toolInput: Record<string, unknown>,
+  toolUseResult: unknown,
+) => message({ kind: 'tool_use', toolName, toolId, toolInput, toolResult: { content: 'ok', toolUseResult } });
+
+const todosOf = (entry: NormalizedMessage) =>
+  (entry.toolInput as { todos: Array<{ content: string; status: string }> }).todos
+    .map((todo) => `${todo.status}:${todo.content}`);
+
+test('Claude task-tracker calls become one evolving checklist', () => {
+  const unified = prepareTranscriptMessages([
+    taskCall('TaskCreate', 't1', { subject: 'Read notes', activeForm: 'Reading notes' }, { task: { id: '1' } }),
+    taskCall('TaskCreate', 't2', { subject: 'Run tests', activeForm: 'Running tests' }, { task: { id: '2' } }),
+    prose(),
+    taskCall('TaskUpdate', 't3', { taskId: '1', status: 'completed' }, { success: true }),
+  ]);
+
+  const snapshots = unified.filter((entry) => entry.toolName === 'TodoWrite');
+  assert.equal(snapshots.length, 2, 'the two adjacent creates collapse into one snapshot');
+  assert.deepEqual(todosOf(snapshots[0]), ['pending:Read notes', 'pending:Run tests']);
+  assert.deepEqual(todosOf(snapshots[1]), ['completed:Read notes', 'pending:Run tests']);
+  assert.equal(
+    (snapshots[0].toolInput as { todos: Array<{ activeForm?: string }> }).todos[0].activeForm,
+    'Reading notes',
+  );
+});
+
+test('a task listing keeps the wording each task was created with', () => {
+  const unified = prepareTranscriptMessages([
+    taskCall('TaskCreate', 't1', { subject: 'Read notes', activeForm: 'Reading notes' }, { task: { id: '1' } }),
+    prose(),
+    taskCall('TaskList', 't2', {}, { tasks: [{ id: '1', subject: 'Read notes', status: 'in_progress' }] }),
+  ]);
+
+  const listed = unified.filter((entry) => entry.toolName === 'TodoWrite').at(-1);
+  assert.deepEqual(todosOf(listed!), ['in_progress:Read notes']);
+  assert.equal(
+    (listed!.toolInput as { todos: Array<{ activeForm?: string }> }).todos[0].activeForm,
+    'Reading notes',
+  );
+});
+
+test('a checklist that has not changed since it was last drawn is dropped', () => {
+  const unified = prepareTranscriptMessages([
+    message({ kind: 'tool_use', toolName: 'TodoWrite', toolId: 'w1', toolInput: { todos: [{ content: 'Ship it', status: 'pending' }] } }),
+    prose(),
+    message({ kind: 'tool_use', toolName: 'TodoWrite', toolId: 'w2', toolInput: { todos: [{ content: 'Ship it', status: 'pending' }] } }),
+  ]);
+
+  assert.deepEqual(unified.map((entry) => entry.toolId), ['w1', undefined]);
+});
+
+test('a superseded checklist and its result row both go', () => {
+  const unified = prepareTranscriptMessages([
+    message({ kind: 'tool_use', toolName: 'TodoWrite', toolId: 'w1', toolInput: { todos: [{ content: 'One', status: 'pending' }] } }),
+    message({ kind: 'tool_result', toolId: 'w1', content: 'stale' }),
+    message({ kind: 'tool_use', toolName: 'TodoWrite', toolId: 'w2', toolInput: { todos: [{ content: 'One', status: 'completed' }] } }),
+    message({ kind: 'tool_result', toolId: 'w2', content: 'fresh' }),
+  ]);
+
+  assert.deepEqual(unified.map((entry) => entry.toolId), ['w2']);
+});
+
+test('a result that names its call is not shipped alongside it', () => {
+  const unified = prepareTranscriptMessages([
+    message({ kind: 'tool_use', toolName: 'Bash', toolId: 'b1', toolInput: { command: 'ls' }, toolResult: { content: 'a\nb' } }),
+    message({ kind: 'tool_result', toolId: 'b1', content: 'a\nb' }),
+  ]);
+
+  assert.equal(unified.length, 1, 'the result already rides on the call it belongs to');
+  assert.equal(unified[0].kind, 'tool_use');
+  assert.equal(unified[0].toolResult?.content, 'a\nb');
+});
+
+test('a result with no call to attach to is kept', () => {
+  const unified = prepareTranscriptMessages([
+    message({ kind: 'tool_result', content: 'orphaned output' }),
+  ]);
+
+  assert.deepEqual(unified.map((entry) => entry.kind), ['tool_result']);
+});
+
+test("Codex's request_user_input becomes an answered AskUserQuestion", () => {
+  const [unified] = prepareTranscriptMessages([
+    message({
+      provider: 'codex',
+      kind: 'tool_use',
+      toolName: 'request_user_input',
+      toolId: 'call-1',
+      toolInput: JSON.stringify({
+        questions: [{ id: 'season', header: 'Quick test', question: 'Which season?', options: [{ label: 'Summer' }] }],
+      }),
+      toolResult: { content: '{"answers":{"season":{"answers":["Summer"]}}}' },
+    }),
+  ]);
+
+  assert.equal(unified.toolName, 'AskUserQuestion');
+  assert.deepEqual((unified.toolInput as { answers: unknown }).answers, { 'Which season?': 'Summer' });
+});
+
+test('a multi-select Codex answer keeps every label it picked', () => {
+  const [unified] = prepareTranscriptMessages([
+    message({
+      provider: 'codex',
+      kind: 'tool_use',
+      toolName: 'request_user_input',
+      toolId: 'call-1',
+      toolInput: JSON.stringify({ questions: [{ id: 'scope', question: 'Which areas?', options: [] }] }),
+      toolResult: { content: '{"answers":{"scope":{"answers":["Providers","Tests"]}}}' },
+    }),
+  ]);
+
+  assert.deepEqual((unified.toolInput as { answers: unknown }).answers, { 'Which areas?': 'Providers, Tests' });
+});
+
+test("Claude's AskUserQuestion answer is folded into the question it answers", () => {
+  const [unified] = prepareTranscriptMessages([
+    message({
+      kind: 'tool_use',
+      toolName: 'AskUserQuestion',
+      toolId: 'call-1',
+      toolInput: { questions: [{ question: 'What next?', header: 'Focus', options: [{ label: 'Branch changes' }] }] },
+      toolResult: {
+        content: 'Your questions have been answered.',
+        toolUseResult: { answers: { 'What next?': 'Branch changes' } },
+      },
+    }),
+  ]);
+
+  assert.deepEqual((unified.toolInput as { answers: unknown }).answers, { 'What next?': 'Branch changes' });
+});
+
+test('a live Claude answer is recovered from the acknowledgement sentence', () => {
+  const [unified] = prepareTranscriptMessages([
+    message({
+      kind: 'tool_use',
+      toolName: 'AskUserQuestion',
+      toolId: 'call-1',
+      toolInput: { questions: [{ question: 'What next?', options: [] }] },
+      toolResult: {
+        content: 'Your questions have been answered: "What next?"="Branch changes". You can now continue.',
+      },
+    }),
+  ]);
+
+  assert.deepEqual((unified.toolInput as { answers: unknown }).answers, { 'What next?': 'Branch changes' });
+});
+
+test('a question that was never answered carries no answers', () => {
+  const [unified] = prepareTranscriptMessages([
+    message({
+      kind: 'tool_use',
+      toolName: 'AskUserQuestion',
+      toolId: 'call-1',
+      toolInput: { questions: [{ question: 'What next?', options: [] }] },
+      toolResult: { content: '<tool_use_error>InputValidationError</tool_use_error>', isError: true },
+    }),
+  ]);
+
+  assert.equal((unified.toolInput as { answers?: unknown }).answers, undefined);
+});
+
+test('a huge tool output is capped, and says how much it dropped', () => {
+  const body = 'x'.repeat(120_000);
+  const [unified] = prepareTranscriptMessages([
+    message({
+      kind: 'tool_use',
+      toolName: 'Read',
+      toolId: 'r1',
+      toolInput: { file_path: '/tmp/shot.png' },
+      toolResult: { content: body, toolUseResult: { file: { base64: body } } },
+    }),
+  ]);
+
+  const content = String(unified.toolResult?.content);
+  assert.ok(content.length < body.length / 2, 'the output must not survive at full size');
+  assert.match(content, /… 80000 more characters$/);
+  const nested = (unified.toolResult?.toolUseResult as { file: { base64: string } }).file.base64;
+  assert.equal(nested, content, 'the structured copy is capped the same way');
+});
+
+test('a search result keeps every file it found', () => {
+  const filenames = Array.from({ length: 900 }, (_, index) => `/repo/src/file-${index}.ts`);
+  const [unified] = prepareTranscriptMessages([
+    message({
+      kind: 'tool_use',
+      toolName: 'Glob',
+      toolId: 'g1',
+      toolInput: { pattern: '**/*.ts' },
+      toolResult: { content: 'ok', toolUseResult: { numFiles: filenames.length, filenames } },
+    }),
+  ]);
+
+  const result = unified.toolResult?.toolUseResult as { filenames: string[]; numFiles: number };
+  assert.equal(result.numFiles, 900);
+  assert.deepEqual(result.filenames, filenames);
+});

package/server/shared/tests/read-only-roots.test.ts

@@ -0,0 +1,139 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, realpath, rm, symlink, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test, { after } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+// The Claude projects root is derived from `os.homedir()` when the utils module
+// is first imported, so HOME has to point at the fixture home *before* that
+// import runs. The fixture lives beside this file rather than under the temp
+// directory: a home under `/tmp` would put everything under a read-only root
+// and make the escape tests pass for the wrong reason.
+const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = await realpath(await mkdtemp(path.join(testDirectory, 'read-only-roots-fixture-')));
+const fixtureHome = path.join(fixtureRoot, 'home');
+const claudeProjectsRoot = path.join(fixtureHome, '.claude', 'projects');
+// Under no read-only root: not the temp directory, not the Claude projects dir.
+const outsideDirectory = path.join(fixtureRoot, 'outside');
+await mkdir(claudeProjectsRoot, { recursive: true });
+await mkdir(outsideDirectory);
+
+const previousHome = process.env.HOME;
+const previousUserProfile = process.env.USERPROFILE;
+process.env.HOME = fixtureHome;
+process.env.USERPROFILE = fixtureHome;
+
+const { resolvePathUnderRoots, resolveReadOnlyRootPath, validateWorkspacePath } = await import('@/shared/utils.js');
+
+after(async () => {
+  if (previousHome === undefined) {
+    delete process.env.HOME;
+  } else {
+    process.env.HOME = previousHome;
+  }
+  if (previousUserProfile === undefined) {
+    delete process.env.USERPROFILE;
+  } else {
+    process.env.USERPROFILE = previousUserProfile;
+  }
+  await rm(fixtureRoot, { recursive: true, force: true });
+});
+
+test('a path under the system temp directory resolves as readable', async () => {
+  const temporaryDirectory = await mkdtemp(path.join(os.tmpdir(), 'read-only-root-'));
+
+  try {
+    const filePath = path.join(temporaryDirectory, 'agent.output');
+    await writeFile(filePath, 'agent output', 'utf8');
+
+    // A background command's log is quoted straight out of the transcript, so
+    // this exact shape has to resolve.
+    const resolvedDirectory = await resolveReadOnlyRootPath(temporaryDirectory);
+    assert.ok(resolvedDirectory);
+    assert.equal(await resolveReadOnlyRootPath(filePath), path.join(resolvedDirectory, 'agent.output'));
+  } finally {
+    await rm(temporaryDirectory, { recursive: true, force: true });
+  }
+});
+
+test('a background agent output link resolves to its transcript under the Claude projects directory', async () => {
+  const temporaryDirectory = await mkdtemp(path.join(os.tmpdir(), 'read-only-root-'));
+
+  try {
+    // Claude writes `/tmp/claude-<uid>/<project>/<session>/tasks/<task>.output`
+    // as a symlink to the agent's transcript under `~/.claude/projects`.
+    const transcriptDirectory = path.join(claudeProjectsRoot, '-home-user-project', 'session-1', 'subagents');
+    await mkdir(transcriptDirectory, { recursive: true });
+    const transcriptPath = path.join(transcriptDirectory, 'agent-1.jsonl');
+    await writeFile(transcriptPath, '{"type":"assistant"}\n', 'utf8');
+
+    const tasksDirectory = path.join(temporaryDirectory, 'tasks');
+    await mkdir(tasksDirectory);
+    const outputLink = path.join(tasksDirectory, 'task-1.output');
+    await symlink(transcriptPath, outputLink);
+
+    assert.equal(await resolveReadOnlyRootPath(outputLink), transcriptPath);
+    assert.equal(await resolveReadOnlyRootPath(transcriptPath), transcriptPath);
+  } finally {
+    await rm(temporaryDirectory, { recursive: true, force: true });
+  }
+});
+
+test('the temp directory stays read-only: it is still not a valid workspace location', async () => {
+  const temporaryDirectory = await mkdtemp(path.join(os.tmpdir(), 'read-only-root-'));
+
+  try {
+    // Being browsable must not make it writable — the write policy is
+    // `validateWorkspacePath` and it does not consult the read-only roots.
+    const validation = await validateWorkspacePath(temporaryDirectory);
+    assert.equal(validation.valid, false);
+  } finally {
+    await rm(temporaryDirectory, { recursive: true, force: true });
+  }
+});
+
+test('paths outside the read-only roots do not resolve', async () => {
+  assert.equal(await resolveReadOnlyRootPath(outsideDirectory), null);
+  assert.equal(await resolveReadOnlyRootPath('/etc/passwd'), null);
+  assert.equal(await resolveReadOnlyRootPath('relative/path'), null);
+  assert.equal(await resolveReadOnlyRootPath(''), null);
+});
+
+test('a symlink planted in the temp directory cannot read outside every root', async () => {
+  const temporaryDirectory = await mkdtemp(path.join(os.tmpdir(), 'read-only-root-'));
+
+  try {
+    await writeFile(path.join(outsideDirectory, 'secret.txt'), 'secret', 'utf8');
+    const escapeLink = path.join(temporaryDirectory, 'escape');
+    await symlink(outsideDirectory, escapeLink);
+
+    // The name is under a read-only root but the file is not, so resolving the
+    // link before comparing is what keeps this closed.
+    assert.equal(await resolveReadOnlyRootPath(escapeLink), null);
+    assert.equal(await resolveReadOnlyRootPath(path.join(escapeLink, 'secret.txt')), null);
+  } finally {
+    await rm(temporaryDirectory, { recursive: true, force: true });
+  }
+});
+
+test('a root that does not exist does not stop later roots from matching', async () => {
+  const temporaryDirectory = await mkdtemp(path.join(os.tmpdir(), 'read-only-root-'));
+
+  try {
+    // `/tmp` does not exist on Windows; the temp directory listed after it
+    // must still be checked rather than the whole search giving up.
+    const missingRoot = path.join(fixtureRoot, 'missing');
+    assert.equal(await resolvePathUnderRoots(temporaryDirectory, [missingRoot]), null);
+    assert.equal(
+      await resolvePathUnderRoots(temporaryDirectory, [missingRoot, os.tmpdir()]),
+      await realpath(temporaryDirectory),
+    );
+  } finally {
+    await rm(temporaryDirectory, { recursive: true, force: true });
+  }
+});
+
+test('traversal out of the temp directory does not resolve', async () => {
+  assert.equal(await resolveReadOnlyRootPath(`${os.tmpdir()}/../etc/passwd`), null);
+});

package/server/shared/tests/strip-ansi-sequences.test.ts

@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { stripAnsiSequences } from '@/shared/utils.js';
+
+test('strips the SGR colors a CLI writes around its own warnings', () => {
+  const styled = '\u001B[93m\u001B[1m! \u001B[0m\u001B[0mpermission requested: external_directory';
+  assert.equal(stripAnsiSequences(styled), '! permission requested: external_directory');
+});
+
+test('strips CSI cursor control, including the 8-bit introducer', () => {
+  assert.equal(stripAnsiSequences('a\u001B[2Kb\u001B[?25lc'), 'abc');
+  assert.equal(stripAnsiSequences('a\u009B31mb'), 'ab');
+});
+
+test('strips an OSC sequence with either terminator, without eating the rest', () => {
+  assert.equal(stripAnsiSequences('\u001B]0;title\u0007done'), 'done');
+  assert.equal(stripAnsiSequences('\u001B]8;;https://example.com\u001B\\link'), 'link');
+});
+
+test('strips other ECMA-48 escape sequences such as charset selection', () => {
+  assert.equal(stripAnsiSequences('\u001B(Bplain'), 'plain');
+});
+
+test('leaves text without escape sequences untouched', () => {
+  assert.equal(stripAnsiSequences('plain [93m-looking text'), 'plain [93m-looking text');
+});
+
+test('strips a CSI sequence that carries a private parameter byte', () => {
+  assert.equal(stripAnsiSequences('a\u001B[>cb'), 'ab');
+});
+
+test('stops an unterminated OSC at the next escape, so later styling still strips', () => {
+  assert.equal(
+    stripAnsiSequences('\u001B]0;unterminated\u001B[31mred\u001B[0m'),
+    '0;unterminatedred',
+  );
+});
+
+test('reduces a styling-only chunk to an empty string', () => {
+  assert.equal(stripAnsiSequences('\u001B[0m\u001B[2K'), '');
+});