@cloudcli-ai/cloudcli 1.36.3 → 1.37.1

package/server/modules/file-tree/tests/file-tree.routes.test.ts

@@ -0,0 +1,157 @@
+import assert from 'node:assert/strict';
+import { once } from 'node:events';
+import type { AddressInfo } from 'node:net';
+import test from 'node:test';
+
+import express, { type RequestHandler } from 'express';
+
+import { createFileTreeRouter } from '@/modules/file-tree/file-tree.routes.js';
+import type { FileTreeServices } from '@/shared/types.js';
+
+function createFakeServices(overrides: Partial<FileTreeServices> = {}): FileTreeServices {
+  const unexpectedOperation = async (): Promise<never> => {
+    throw new Error('Unexpected File Tree service call');
+  };
+
+  return {
+    browseWorkspace: unexpectedOperation,
+    createWorkspaceFolder: unexpectedOperation,
+    readTextFile: unexpectedOperation,
+    openFile: unexpectedOperation,
+    saveTextFile: unexpectedOperation,
+    listProjectFiles: unexpectedOperation,
+    createEntry: unexpectedOperation,
+    renameEntry: unexpectedOperation,
+    deleteEntry: unexpectedOperation,
+    storeUploadedFiles: unexpectedOperation,
+    ...overrides,
+  };
+}
+
+const passUploadRequest: RequestHandler = (_request, _response, next) => next();
+
+async function withFileTreeServer(
+  services: FileTreeServices,
+  run: (baseUrl: string) => Promise<void>,
+): Promise<void> {
+  const app = express();
+  app.use(express.json());
+  app.use('/api/file-tree', createFileTreeRouter(
+    services,
+    passUploadRequest,
+    { maximumFileSizeMegabytes: 200, maximumFileCount: 20 },
+    { error: () => undefined },
+  ));
+
+  const server = app.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  try {
+    const address = server.address() as AddressInfo;
+    await run(`http://127.0.0.1:${address.port}`);
+  } finally {
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => error ? reject(error) : resolve());
+    });
+  }
+}
+
+test('project files route uses the File Tree API namespace and forwards the project id', async () => {
+  const inputs: Parameters<FileTreeServices['listProjectFiles']>[] = [];
+  const services = createFakeServices({
+    listProjectFiles: async (...input) => {
+      inputs.push(input);
+      return [];
+    },
+  });
+
+  await withFileTreeServer(services, async (baseUrl) => {
+    const response = await fetch(`${baseUrl}/api/file-tree/projects/project-1/files`);
+
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), []);
+  });
+
+  assert.deepEqual(inputs, [['project-1', { respectGitignore: false }]]);
+});
+
+test('project files route requests gitignore filtering when explicitly enabled', async () => {
+  const inputs: Parameters<FileTreeServices['listProjectFiles']>[] = [];
+  const services = createFakeServices({
+    listProjectFiles: async (...input) => {
+      inputs.push(input);
+      return [];
+    },
+  });
+
+  await withFileTreeServer(services, async (baseUrl) => {
+    const response = await fetch(
+      `${baseUrl}/api/file-tree/projects/project-1/files?respectGitignore=true`,
+    );
+
+    assert.equal(response.status, 200);
+  });
+
+  assert.deepEqual(inputs, [['project-1', { respectGitignore: true }]]);
+});
+
+test('create route parses the transport payload before invoking the service', async () => {
+  const inputs: Parameters<FileTreeServices['createEntry']>[0][] = [];
+  const services = createFakeServices({
+    createEntry: async (input) => {
+      inputs.push(input);
+      return {
+        success: true,
+        path: '/workspace/project/src/example.ts',
+        name: input.name,
+        type: input.type,
+        message: 'File created successfully',
+      };
+    },
+  });
+
+  await withFileTreeServer(services, async (baseUrl) => {
+    const response = await fetch(`${baseUrl}/api/file-tree/projects/project-1/files/create`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        path: '/workspace/project/src',
+        type: 'file',
+        name: 'example.ts',
+      }),
+    });
+
+    assert.equal(response.status, 200);
+  });
+
+  assert.deepEqual(inputs, [{
+    projectId: 'project-1',
+    parentPath: '/workspace/project/src',
+    type: 'file',
+    name: 'example.ts',
+  }]);
+});
+
+test('create route rejects invalid entry types without calling the service', async () => {
+  let createCalled = false;
+  const services = createFakeServices({
+    createEntry: async () => {
+      createCalled = true;
+      throw new Error('createEntry should not run for invalid input');
+    },
+  });
+
+  await withFileTreeServer(services, async (baseUrl) => {
+    const response = await fetch(`${baseUrl}/api/file-tree/projects/project-1/files/create`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ type: 'link', name: 'example' }),
+    });
+    const payload = await response.json() as { error: string };
+
+    assert.equal(response.status, 400);
+    assert.equal(payload.error, 'Type must be "file" or "directory"');
+  });
+
+  assert.equal(createCalled, false);
+});

package/server/modules/file-tree/tests/file-tree.service.test.ts

@@ -0,0 +1,317 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import test from 'node:test';
+
+import { createFileTreeService } from '@/modules/file-tree/file-tree.service.js';
+import type {
+  FileTreeDirectoryEntry,
+  FileTreeFileSystem,
+  FileTreeServiceDependencies,
+  FileTreeStats,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+
+function createDirectoryEntry(name: string, directory: boolean): FileTreeDirectoryEntry {
+  return {
+    name,
+    isDirectory: () => directory,
+  };
+}
+
+/**
+ * Adapts a path-keyed listing to the streaming directory contract so tests keep
+ * describing directories as plain arrays.
+ */
+function createDirectoryReader(
+  listDirectory: (directoryPath: string) => FileTreeDirectoryEntry[],
+): FileTreeFileSystem['openDirectory'] {
+  return async function* openDirectory(directoryPath) {
+    yield* listDirectory(directoryPath);
+  };
+}
+
+function createStats(directory: boolean, mode: number): FileTreeStats {
+  return {
+    size: directory ? 0 : 24,
+    mtime: new Date('2026-01-02T03:04:05.000Z'),
+    mode,
+    isDirectory: () => directory,
+    isSymbolicLink: () => false,
+  };
+}
+
+function createFakeFileSystem(
+  overrides: Partial<FileTreeFileSystem> = {},
+): FileTreeFileSystem {
+  const unexpectedOperation = async (): Promise<never> => {
+    throw new Error('Unexpected File Tree filesystem operation');
+  };
+
+  return {
+    access: unexpectedOperation,
+    stat: unexpectedOperation,
+    lstat: unexpectedOperation,
+    openDirectory: () => ({
+      [Symbol.asyncIterator]: () => ({ next: unexpectedOperation }),
+    }),
+    realpath: unexpectedOperation,
+    readTextFile: unexpectedOperation,
+    writeTextFile: unexpectedOperation,
+    makeDirectory: unexpectedOperation,
+    rename: unexpectedOperation,
+    removeDirectory: unexpectedOperation,
+    unlink: unexpectedOperation,
+    copyFile: unexpectedOperation,
+    createReadStream: () => Readable.from([]),
+    ...overrides,
+  };
+}
+
+function createDependencies(
+  fileSystem: FileTreeFileSystem,
+  projectRoot: string,
+): FileTreeServiceDependencies {
+  return {
+    fileSystem,
+    projects: {
+      getProjectPathById: async () => projectRoot,
+    },
+    workspace: {
+      rootPath: projectRoot,
+      validatePath: async (candidatePath) => ({ valid: true, resolvedPath: candidatePath }),
+    },
+    resolveMimeType: () => 'text/plain',
+    fileSystemConcurrency: 4,
+    logger: { error: () => undefined },
+  };
+}
+
+test('listProjectFiles builds a sorted tree and skips generated directories', async () => {
+  const projectRoot = path.resolve('file-tree-test-project');
+  const sourceDirectory = path.join(projectRoot, 'src');
+  const fileSystem = createFakeFileSystem({
+    access: async () => undefined,
+    openDirectory: createDirectoryReader((directoryPath) => {
+      if (directoryPath === projectRoot) {
+        return [
+          createDirectoryEntry('node_modules', true),
+          createDirectoryEntry('README.md', false),
+          createDirectoryEntry('src', true),
+        ];
+      }
+      if (directoryPath === sourceDirectory) {
+        return [createDirectoryEntry('index.ts', false)];
+      }
+      return [];
+    }),
+    lstat: async (candidatePath) => createStats(candidatePath === sourceDirectory, 0o754),
+  });
+  const service = createFileTreeService(createDependencies(fileSystem, projectRoot));
+
+  const tree = await service.listProjectFiles('project-1');
+
+  assert.deepEqual(tree.map((entry) => entry.name), ['src', 'README.md']);
+  const sourceEntry = tree[0];
+  assert.ok(sourceEntry);
+  assert.equal(sourceEntry.type, 'directory');
+  assert.equal(sourceEntry.permissions, '754');
+  assert.equal(sourceEntry.permissionsRwx, 'rwxr-xr--');
+  assert.deepEqual(sourceEntry.children?.map((entry) => entry.name), ['index.ts']);
+});
+
+test('listProjectFiles excludes gitignored entries only when requested', async () => {
+  const projectRoot = path.resolve('file-tree-test-project');
+  const cacheDirectory = path.join(projectRoot, 'cache');
+  const sourceDirectory = path.join(projectRoot, 'src');
+  const readDirectories: string[] = [];
+  const fileSystem = createFakeFileSystem({
+    access: async () => undefined,
+    readTextFile: async (filePath) => {
+      assert.equal(filePath, path.join(projectRoot, '.gitignore'));
+      return ['*.log', '!keep.log', 'cache/', 'src/generated.ts'].join('\n');
+    },
+    openDirectory: createDirectoryReader((directoryPath) => {
+      readDirectories.push(directoryPath);
+      if (directoryPath === projectRoot) {
+        return [
+          createDirectoryEntry('.gitignore', false),
+          createDirectoryEntry('cache', true),
+          createDirectoryEntry('ignored.log', false),
+          createDirectoryEntry('keep.log', false),
+          createDirectoryEntry('src', true),
+        ];
+      }
+      if (directoryPath === cacheDirectory) {
+        return [createDirectoryEntry('cached.txt', false)];
+      }
+      if (directoryPath === sourceDirectory) {
+        return [
+          createDirectoryEntry('generated.ts', false),
+          createDirectoryEntry('index.ts', false),
+        ];
+      }
+      return [];
+    }),
+    lstat: async (candidatePath) => createStats(
+      candidatePath === cacheDirectory || candidatePath === sourceDirectory,
+      0o644,
+    ),
+  });
+  const service = createFileTreeService(createDependencies(fileSystem, projectRoot));
+
+  const tree = await service.listProjectFiles('project-1', { respectGitignore: true });
+
+  assert.deepEqual(tree.map((entry) => entry.name), ['src', '.gitignore', 'keep.log']);
+  assert.deepEqual(tree[0]?.children?.map((entry) => entry.name), ['index.ts']);
+  assert.equal(readDirectories.includes(cacheDirectory), false);
+});
+
+test('listProjectFiles returns the normal tree when no gitignore exists', async () => {
+  const projectRoot = path.resolve('file-tree-test-project');
+  const fileSystem = createFakeFileSystem({
+    access: async () => undefined,
+    readTextFile: async () => {
+      throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+    },
+    openDirectory: createDirectoryReader((directoryPath) => directoryPath === projectRoot
+      ? [createDirectoryEntry('debug.log', false)]
+      : []),
+    lstat: async () => createStats(false, 0o644),
+  });
+  const service = createFileTreeService(createDependencies(fileSystem, projectRoot));
+
+  const tree = await service.listProjectFiles('project-1', { respectGitignore: true });
+
+  assert.deepEqual(tree.map((entry) => entry.name), ['debug.log']);
+});
+
+test('listProjectFiles rejects a tree that exceeds the server entry limit', async () => {
+  const projectRoot = path.resolve('file-tree-test-project');
+  const fileSystem = createFakeFileSystem({
+    access: async () => undefined,
+    openDirectory: createDirectoryReader((directoryPath) => directoryPath === projectRoot
+      ? Array.from({ length: 10_001 }, (_, index) => createDirectoryEntry(`file-${index}.txt`, false))
+      : []),
+    lstat: async () => createStats(false, 0o644),
+  });
+  const service = createFileTreeService(createDependencies(fileSystem, projectRoot));
+
+  await assert.rejects(
+    service.listProjectFiles('project-1'),
+    (error: unknown) => error instanceof AppError
+      && error.code === 'FILE_TREE_TOO_LARGE'
+      && error.statusCode === 413,
+  );
+});
+
+test('listProjectFiles abandons a directory stream as soon as the entry limit is passed', async () => {
+  const projectRoot = path.resolve('file-tree-test-project');
+  let streamedEntries = 0;
+  const fileSystem = createFakeFileSystem({
+    access: async () => undefined,
+    // Endless on purpose: the walk has to stop consuming the stream itself
+    // instead of waiting for the directory listing to be materialized.
+    openDirectory: async function* (directoryPath) {
+      if (directoryPath !== projectRoot) {
+        return;
+      }
+      for (let index = 0; ; index += 1) {
+        streamedEntries += 1;
+        yield createDirectoryEntry(`file-${index}.txt`, false);
+      }
+    },
+    lstat: async () => createStats(false, 0o644),
+  });
+  const service = createFileTreeService(createDependencies(fileSystem, projectRoot));
+
+  await assert.rejects(
+    service.listProjectFiles('project-1'),
+    (error: unknown) => error instanceof AppError
+      && error.code === 'FILE_TREE_TOO_LARGE'
+      && error.statusCode === 413,
+  );
+  // The budget plus the single entry that proves it was exceeded.
+  assert.equal(streamedEntries, 10_001);
+});
+
+test('listProjectFiles shares the entry limit across nested directories', async () => {
+  const projectRoot = path.resolve('file-tree-test-project');
+  const firstDirectory = path.join(projectRoot, 'first');
+  const secondDirectory = path.join(projectRoot, 'second');
+  const directoryPaths = new Set([firstDirectory, secondDirectory]);
+  const fileSystem = createFakeFileSystem({
+    access: async () => undefined,
+    openDirectory: createDirectoryReader((directoryPath) => {
+      if (directoryPath === projectRoot) {
+        return [
+          createDirectoryEntry('first', true),
+          createDirectoryEntry('second', true),
+        ];
+      }
+      if (directoryPaths.has(directoryPath)) {
+        return Array.from(
+          { length: 5_000 },
+          (_, index) => createDirectoryEntry(`${path.basename(directoryPath)}-${index}.txt`, false),
+        );
+      }
+      return [];
+    }),
+    lstat: async (candidatePath) => createStats(directoryPaths.has(candidatePath), 0o644),
+  });
+  const service = createFileTreeService(createDependencies(fileSystem, projectRoot));
+
+  await assert.rejects(
+    service.listProjectFiles('project-1'),
+    (error: unknown) => error instanceof AppError
+      && error.code === 'FILE_TREE_TOO_LARGE'
+      && error.statusCode === 413,
+  );
+});
+
+test('readTextFile rejects traversal before invoking the filesystem adapter', async () => {
+  const projectRoot = path.resolve('file-tree-test-project');
+  const readPaths: string[] = [];
+  const fileSystem = createFakeFileSystem({
+    readTextFile: async (filePath) => {
+      readPaths.push(filePath);
+      return 'should not be read';
+    },
+  });
+  const service = createFileTreeService(createDependencies(fileSystem, projectRoot));
+
+  await assert.rejects(
+    service.readTextFile('project-1', '../secret.txt'),
+    (error: unknown) => error instanceof AppError
+      && error.code === 'PATH_OUTSIDE_PROJECT'
+      && error.statusCode === 403,
+  );
+  assert.deepEqual(readPaths, []);
+});
+
+test('createEntry performs filesystem mutation only through the injected adapter', async () => {
+  const projectRoot = path.resolve('file-tree-test-project');
+  const targetPath = path.join(projectRoot, 'notes.txt');
+  const writtenFiles: Array<{ filePath: string; content: string }> = [];
+  const fileSystem = createFakeFileSystem({
+    access: async (candidatePath) => {
+      if (candidatePath === targetPath) {
+        throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+      }
+    },
+    writeTextFile: async (filePath, content) => {
+      writtenFiles.push({ filePath, content });
+    },
+  });
+  const service = createFileTreeService(createDependencies(fileSystem, projectRoot));
+
+  const result = await service.createEntry({
+    projectId: 'project-1',
+    parentPath: projectRoot,
+    type: 'file',
+    name: 'notes.txt',
+  });
+
+  assert.equal(result.path, targetPath);
+  assert.deepEqual(writtenFiles, [{ filePath: targetPath, content: '' }]);
+});

package/server/modules/git/git-parsing.service.ts

@@ -0,0 +1,66 @@
+type GitStatusSummary = {
+  modified: string[];
+  added: string[];
+  deleted: string[];
+  untracked: string[];
+  staged: string[];
+};
+
+type GitCommitSummary = {
+  hash: string;
+  parents: string[];
+  refs: string[];
+  author: string;
+  email: string;
+  date: string;
+  message: string;
+  stats: string;
+};
+
+const GIT_LOG_FIELD_SEPARATOR = '\u001f';
+
+/** Parses NUL-delimited porcelain output into UI status buckets. */
+export function parseGitStatusOutput(statusOutput: string): GitStatusSummary {
+  const result: GitStatusSummary = { modified: [], added: [], deleted: [], untracked: [], staged: [] };
+  const entries = statusOutput.split('\0');
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (!entry || entry.length < 4) continue;
+    const indexStatus = entry[0];
+    const worktreeStatus = entry[1];
+    const filePath = entry.slice(3);
+    if (indexStatus === 'R' || indexStatus === 'C') index += 1;
+    if (indexStatus === '?') { result.untracked.push(filePath); continue; }
+    if (indexStatus === '!') continue;
+    const conflict = indexStatus === 'U' || worktreeStatus === 'U'
+      || (indexStatus === 'A' && worktreeStatus === 'A')
+      || (indexStatus === 'D' && worktreeStatus === 'D');
+    if (conflict) { result.modified.push(filePath); continue; }
+    if (indexStatus !== ' ') result.staged.push(filePath);
+    if (indexStatus === 'D' || worktreeStatus === 'D') result.deleted.push(filePath);
+    else if (indexStatus === 'A' || worktreeStatus === 'A') result.added.push(filePath);
+    else result.modified.push(filePath);
+  }
+  return result;
+}
+
+/** Parses the Git history format used by the commits endpoint, including shortstat lines. */
+export function parseGitLogWithStats(stdout: string): GitCommitSummary[] {
+  const commits: GitCommitSummary[] = [];
+  for (const rawLine of stdout.split('\n')) {
+    const line = rawLine.trimEnd();
+    if (!line.trim()) continue;
+    if (line.includes(GIT_LOG_FIELD_SEPARATOR)) {
+      const [hash = '', parents = '', refs = '', author = '', email = '', date = '', ...message] =
+        line.split(GIT_LOG_FIELD_SEPARATOR);
+      commits.push({
+        hash, parents: parents.split(' ').filter(Boolean), refs: refs.split(', ').filter(Boolean),
+        author, email, date, message: message.join(GIT_LOG_FIELD_SEPARATOR), stats: '',
+      });
+    } else if (commits.length > 0 && /files? changed/.test(line)) {
+      const latestCommit = commits.at(-1);
+      if (latestCommit) latestCommit.stats = line.trim();
+    }
+  }
+  return commits;
+}

package/server/modules/git/git.module.ts

@@ -0,0 +1,22 @@
+import * as fs from 'node:fs/promises';
+
+import spawn from 'cross-spawn';
+
+import { projectsDb } from '@/modules/database/index.js';
+
+import { createGitRouter } from './git.routes.js';
+
+type GitExternalDependencies = Pick<
+  Parameters<typeof createGitRouter>[0],
+  'queryClaude' | 'queryCursor'
+>;
+
+/** Assembles the Git router with runners from the centralized provider runtime service. */
+export function createGitModule(externalDependencies: GitExternalDependencies) {
+  return createGitRouter({
+    fileSystem: fs,
+    spawnProcess: spawn,
+    resolveProjectPathById: (projectId) => projectsDb.getProjectPathById(projectId),
+    ...externalDependencies,
+  });
+}