@cloudcli-ai/cloudcli 1.37.0 → 1.37.2

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

@@ -19,6 +19,18 @@ function createDirectoryEntry(name: string, directory: boolean): FileTreeDirecto
   };
 }
 
+/**
+ * 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,
@@ -40,7 +52,9 @@ function createFakeFileSystem(
     access: unexpectedOperation,
     stat: unexpectedOperation,
     lstat: unexpectedOperation,
-    readdir: unexpectedOperation,
+    openDirectory: () => ({
+      [Symbol.asyncIterator]: () => ({ next: unexpectedOperation }),
+    }),
     realpath: unexpectedOperation,
     readTextFile: unexpectedOperation,
     writeTextFile: unexpectedOperation,
@@ -73,37 +87,67 @@ function createDependencies(
   };
 }
 
-test('listProjectFiles builds a sorted tree and skips generated directories', async () => {
+test('listProjectFiles applies gitignore alongside hard directory exclusions', async () => {
   const projectRoot = path.resolve('file-tree-test-project');
+  const documentationDirectory = path.join(projectRoot, 'docs');
+  const buildDocumentationDirectory = path.join(documentationDirectory, 'build');
+  const gitDirectory = path.join(projectRoot, '.git');
+  const nodeModulesDirectory = path.join(projectRoot, 'node_modules');
   const sourceDirectory = path.join(projectRoot, 'src');
+  const readDirectories: string[] = [];
   const fileSystem = createFakeFileSystem({
     access: async () => undefined,
-    readdir: async (directoryPath) => {
+    readTextFile: async (filePath) => {
+      assert.equal(filePath, path.join(projectRoot, '.gitignore'));
+      return '*.log';
+    },
+    openDirectory: createDirectoryReader((directoryPath) => {
+      readDirectories.push(directoryPath);
       if (directoryPath === projectRoot) {
         return [
+          createDirectoryEntry('.git', true),
           createDirectoryEntry('node_modules', true),
           createDirectoryEntry('README.md', false),
+          createDirectoryEntry('docs', true),
           createDirectoryEntry('src', true),
         ];
       }
+      if (directoryPath === documentationDirectory) {
+        return [createDirectoryEntry('build', true)];
+      }
+      if (directoryPath === buildDocumentationDirectory) {
+        return [createDirectoryEntry('foo.md', false)];
+      }
       if (directoryPath === sourceDirectory) {
         return [createDirectoryEntry('index.ts', false)];
       }
       return [];
-    },
-    lstat: async (candidatePath) => createStats(candidatePath === sourceDirectory, 0o754),
+    }),
+    lstat: async (candidatePath) => createStats(
+      candidatePath === documentationDirectory
+        || candidatePath === buildDocumentationDirectory
+        || candidatePath === sourceDirectory
+        || candidatePath === gitDirectory
+        || candidatePath === nodeModulesDirectory,
+      0o754,
+    ),
   });
   const service = createFileTreeService(createDependencies(fileSystem, projectRoot));
 
-  const tree = await service.listProjectFiles('project-1');
+  const tree = await service.listProjectFiles('project-1', { respectGitignore: true });
 
-  assert.deepEqual(tree.map((entry) => entry.name), ['src', 'README.md']);
-  const sourceEntry = tree[0];
+  assert.deepEqual(tree.map((entry) => entry.name), ['docs', 'src', 'README.md']);
+  const documentationEntry = tree[0];
+  assert.deepEqual(documentationEntry?.children?.map((entry) => entry.name), ['build']);
+  assert.deepEqual(documentationEntry?.children?.[0]?.children?.map((entry) => entry.name), ['foo.md']);
+  const sourceEntry = tree[1];
   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']);
+  assert.equal(readDirectories.includes(gitDirectory), false);
+  assert.equal(readDirectories.includes(nodeModulesDirectory), false);
 });
 
 test('listProjectFiles excludes gitignored entries only when requested', async () => {
@@ -117,7 +161,7 @@ test('listProjectFiles excludes gitignored entries only when requested', async (
       assert.equal(filePath, path.join(projectRoot, '.gitignore'));
       return ['*.log', '!keep.log', 'cache/', 'src/generated.ts'].join('\n');
     },
-    readdir: async (directoryPath) => {
+    openDirectory: createDirectoryReader((directoryPath) => {
       readDirectories.push(directoryPath);
       if (directoryPath === projectRoot) {
         return [
@@ -138,7 +182,7 @@ test('listProjectFiles excludes gitignored entries only when requested', async (
         ];
       }
       return [];
-    },
+    }),
     lstat: async (candidatePath) => createStats(
       candidatePath === cacheDirectory || candidatePath === sourceDirectory,
       0o644,
@@ -153,23 +197,130 @@ test('listProjectFiles excludes gitignored entries only when requested', async (
   assert.equal(readDirectories.includes(cacheDirectory), false);
 });
 
-test('listProjectFiles returns the normal tree when no gitignore exists', async () => {
+test('listProjectFiles falls back to conventional directory names when no gitignore exists', async () => {
   const projectRoot = path.resolve('file-tree-test-project');
+  const documentationDirectory = path.join(projectRoot, 'docs');
+  const buildDocumentationDirectory = path.join(documentationDirectory, 'build');
+  const nodeModulesDirectory = path.join(projectRoot, 'node_modules');
+  const readDirectories: string[] = [];
   const fileSystem = createFakeFileSystem({
     access: async () => undefined,
     readTextFile: async () => {
       throw Object.assign(new Error('missing'), { code: 'ENOENT' });
     },
-    readdir: async (directoryPath) => directoryPath === projectRoot
-      ? [createDirectoryEntry('debug.log', false)]
-      : [],
-    lstat: async () => createStats(false, 0o644),
+    openDirectory: createDirectoryReader((directoryPath) => {
+      readDirectories.push(directoryPath);
+      if (directoryPath === projectRoot) {
+        return [
+          createDirectoryEntry('debug.log', false),
+          createDirectoryEntry('docs', true),
+          createDirectoryEntry('node_modules', true),
+        ];
+      }
+      if (directoryPath === documentationDirectory) {
+        return [
+          createDirectoryEntry('build', true),
+          createDirectoryEntry('guide.md', false),
+        ];
+      }
+      if (directoryPath === buildDocumentationDirectory) {
+        return [createDirectoryEntry('generated.md', false)];
+      }
+      return [];
+    }),
+    lstat: async (candidatePath) => createStats(candidatePath === documentationDirectory, 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']);
+  assert.deepEqual(tree.map((entry) => entry.name), ['docs', 'debug.log']);
+  assert.deepEqual(tree[0]?.children?.map((entry) => entry.name), ['guide.md']);
+  assert.equal(readDirectories.includes(nodeModulesDirectory), false);
+  assert.equal(readDirectories.includes(buildDocumentationDirectory), false);
+});
+
+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 () => {

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

@@ -0,0 +1,43 @@
+import { AppError } from '@/shared/utils.js';
+
+type GitCommandResult = {
+  stdout: string;
+  stderr: string;
+};
+
+type GitCommandRunner = (
+  command: string,
+  args: string[],
+  options: { cwd: string },
+) => Promise<GitCommandResult>;
+
+type DeleteLocalBranchInput = {
+  projectPath: string;
+  branch: string;
+  force: boolean;
+  runCommand: GitCommandRunner;
+};
+
+/** Used by the Git routes module to safely delete a non-current local branch. */
+export async function deleteLocalBranch(input: DeleteLocalBranchInput): Promise<string> {
+  const { stdout: currentBranch } = await input.runCommand(
+    'git',
+    ['branch', '--show-current'],
+    { cwd: input.projectPath },
+  );
+
+  if (currentBranch.trim() === input.branch) {
+    throw new AppError('Cannot delete the currently checked-out branch', {
+      code: 'GIT_CURRENT_BRANCH_DELETE',
+      statusCode: 400,
+    });
+  }
+
+  const deleteFlag = input.force ? '-D' : '-d';
+  const { stdout } = await input.runCommand(
+    'git',
+    ['branch', deleteFlag, '--', input.branch],
+    { cwd: input.projectPath },
+  );
+  return stdout;
+}

package/server/modules/git/git.routes.ts

@@ -8,6 +8,7 @@ import { AppError } from '@/shared/utils.js';
 
 // cross-spawn: drop-in spawn with Windows .cmd/PATHEXT resolution.
 import { parseGitLogWithStats, parseGitStatusOutput } from './git-parsing.service.js';
+import { deleteLocalBranch } from './git-branch.service.js';
 
 type GitRouterDependencies = {
   fileSystem: typeof import('node:fs/promises');
@@ -839,26 +840,32 @@ router.post('/create-branch', async (req, res) => {
 
 // Delete a local branch
 router.post('/delete-branch', async (req, res) => {
-  const { project, branch } = req.body;
+  const { project, branch, force = false } = req.body;
 
   if (!project || !branch) {
     return res.status(400).json({ error: 'Project id and branch name are required' });
   }
 
+  if (typeof force !== 'boolean') {
+    return res.status(400).json({ error: 'force must be a boolean' });
+  }
+
   try {
     const projectPath = await getActualProjectPath(project);
     await validateGitRepository(projectPath);
-
-    // Safety: cannot delete the currently checked-out branch
-    const { stdout: currentBranch } = await spawnAsync('git', ['branch', '--show-current'], { cwd: projectPath });
-    if (currentBranch.trim() === branch) {
-      return res.status(400).json({ error: 'Cannot delete the currently checked-out branch' });
-    }
-
-    const { stdout } = await spawnAsync('git', ['branch', '-d', branch], { cwd: projectPath });
+    validateBranchName(branch);
+    const stdout = await deleteLocalBranch({
+      projectPath,
+      branch,
+      force,
+      runCommand: spawnAsync,
+    });
     res.json({ success: true, output: stdout });
   } catch (error) {
     console.error('Git delete branch error:', error);
+    if (error instanceof AppError) {
+      return res.status(error.statusCode).json({ error: error.message });
+    }
     res.status(500).json({ error: error.message });
   }
 });

package/server/modules/git/tests/git-branch.service.test.ts

@@ -0,0 +1,60 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { deleteLocalBranch } from '../git-branch.service.js';
+
+test('deleteLocalBranch uses safe deletion by default', async () => {
+  const commands: string[][] = [];
+  const output = await deleteLocalBranch({
+    projectPath: '/workspace/repo',
+    branch: 'feature/safe-delete',
+    force: false,
+    runCommand: async (_command, args) => {
+      commands.push(args);
+      return {
+        stdout: args.includes('--show-current') ? 'main\n' : 'Deleted branch feature/safe-delete.\n',
+        stderr: '',
+      };
+    },
+  });
+
+  assert.equal(output, 'Deleted branch feature/safe-delete.\n');
+  assert.deepEqual(commands, [
+    ['branch', '--show-current'],
+    ['branch', '-d', '--', 'feature/safe-delete'],
+  ]);
+});
+
+test('deleteLocalBranch uses force deletion only when requested', async () => {
+  const commands: string[][] = [];
+  await deleteLocalBranch({
+    projectPath: '/workspace/repo',
+    branch: 'feature/unmerged',
+    force: true,
+    runCommand: async (_command, args) => {
+      commands.push(args);
+      return { stdout: args.includes('--show-current') ? 'main\n' : '', stderr: '' };
+    },
+  });
+
+  assert.deepEqual(commands, [
+    ['branch', '--show-current'],
+    ['branch', '-D', '--', 'feature/unmerged'],
+  ]);
+});
+
+test('deleteLocalBranch refuses to delete the current branch even when forced', async () => {
+  await assert.rejects(
+    deleteLocalBranch({
+      projectPath: '/workspace/repo',
+      branch: 'feature/current',
+      force: true,
+      runCommand: async () => ({ stdout: 'feature/current\n', stderr: '' }),
+    }),
+    (error: unknown) => {
+      assert.equal((error as { code?: string }).code, 'GIT_CURRENT_BRANCH_DELETE');
+      assert.equal((error as { statusCode?: number }).statusCode, 400);
+      return true;
+    },
+  );
+});

package/server/modules/git/tests/git-init.routes.test.ts

@@ -50,3 +50,86 @@ test('git init does not run when repository validation fails for an execution er
 
   assert.deepEqual(commands, [['rev-parse', '--is-inside-work-tree']]);
 });
+
+test('delete branch parses force and uses Git force deletion', async () => {
+  const commands: string[][] = [];
+  const spawnProcess = ((_command: string, args: string[]) => {
+    commands.push(args);
+    const child = new EventEmitter() as EventEmitter & { stdout: PassThrough; stderr: PassThrough };
+    child.stdout = new PassThrough();
+    child.stderr = new PassThrough();
+    process.nextTick(() => {
+      if (args.includes('--is-inside-work-tree')) child.stdout.write('true\n');
+      if (args.includes('--show-toplevel')) child.stdout.write('/workspace/repo\n');
+      if (args.includes('--show-current')) child.stdout.write('main\n');
+      if (args.includes('-D')) child.stdout.write('Deleted branch feature/unmerged.\n');
+      child.stdout.end();
+      child.stderr.end();
+      child.emit('close', 0);
+    });
+    return child;
+  }) as Parameters<typeof createGitRouter>[0]['spawnProcess'];
+  const unexpectedProvider = async (): Promise<never> => { throw new Error('unexpected provider call'); };
+  const router = createGitRouter({
+    fileSystem: { access: async () => undefined } as unknown as Parameters<typeof createGitRouter>[0]['fileSystem'],
+    spawnProcess,
+    resolveProjectPathById: () => '/workspace/repo',
+    queryClaude: unexpectedProvider,
+    queryCursor: unexpectedProvider,
+  });
+  const app = express();
+  app.use(express.json());
+  app.use('/api/git', router);
+  const server = app.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  try {
+    const address = server.address() as AddressInfo;
+    const response = await fetch(`http://127.0.0.1:${address.port}/api/git/delete-branch`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ project: 'project-1', branch: 'feature/unmerged', force: true }),
+    });
+    const body = await response.json() as { success: boolean; output: string };
+    assert.equal(response.status, 200);
+    assert.equal(body.success, true);
+    assert.match(body.output, /Deleted branch/);
+  } finally {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  }
+
+  assert.deepEqual(commands.at(-1), ['branch', '-D', '--', 'feature/unmerged']);
+});
+
+test('delete branch rejects a non-boolean force value before running Git', async () => {
+  const spawnProcess = (() => {
+    throw new Error('Git must not run for invalid input');
+  }) as Parameters<typeof createGitRouter>[0]['spawnProcess'];
+  const unexpectedProvider = async (): Promise<never> => { throw new Error('unexpected provider call'); };
+  const router = createGitRouter({
+    fileSystem: { access: async () => undefined } as unknown as Parameters<typeof createGitRouter>[0]['fileSystem'],
+    spawnProcess,
+    resolveProjectPathById: () => '/workspace/repo',
+    queryClaude: unexpectedProvider,
+    queryCursor: unexpectedProvider,
+  });
+  const app = express();
+  app.use(express.json());
+  app.use('/api/git', router);
+  const server = app.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  try {
+    const address = server.address() as AddressInfo;
+    const response = await fetch(`http://127.0.0.1:${address.port}/api/git/delete-branch`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ project: 'project-1', branch: 'feature/unmerged', force: 'yes' }),
+    });
+    const body = await response.json() as { error: string };
+    assert.equal(response.status, 400);
+    assert.equal(body.error, 'force must be a boolean');
+  } finally {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  }
+});

package/server/modules/notifications/index.ts

@@ -9,6 +9,8 @@ export {
   notifyRunFailed,
   // Used by provider runtimes to report stopped or completed agent runs.
   notifyRunStopped,
+  // Used by provider runtimes to report background work that finished after its turn ended.
+  notifyBackgroundWorkCompleted,
 } from '@/modules/notifications/services/notification-orchestrator.service.js';
 export {
   registerDesktopNotificationClient,

package/server/modules/notifications/services/notification-orchestrator.service.js

@@ -155,6 +155,7 @@ function buildNotificationPayload(event) {
       ? `Action Required: Tool "${normalizedEvent.meta.toolName}" needs approval`
       : 'Action Required: A tool needs your approval',
     'run.stopped': normalizedEvent.meta?.stopReason || 'Run Stopped: The run has stopped',
+    'run.background_completed': 'Background work finished',
     'run.failed': normalizedEvent.meta?.error ? `Run Failed: ${normalizedEvent.meta.error}` : 'Run Failed: The run encountered an error',
     'agent.notification': normalizedEvent.meta?.message ? String(normalizedEvent.meta.message) : 'You have a new notification',
     'push.enabled': 'Push notifications are now enabled!'
@@ -261,6 +262,27 @@ function notifyRunStopped({ userId, provider, sessionId = null, stopReason = 'co
   });
 }
 
+/**
+ * Reports background work that finished after its turn had already completed.
+ *
+ * Uses the `stop` kind so it rides the existing "run stopped" preference rather
+ * than needing a new opt-in that would default to off. No explicit dedupeKey, so
+ * the default composite key collapses repeats inside the dedupe window.
+ */
+function notifyBackgroundWorkCompleted({ userId, provider, sessionId = null, sessionName = null }) {
+  notifyUserIfEnabled({
+    userId,
+    event: createNotificationEvent({
+      provider,
+      sessionId,
+      kind: 'stop',
+      code: 'run.background_completed',
+      meta: { sessionName },
+      severity: 'info'
+    })
+  });
+}
+
 function notifyRunFailed({ userId, provider, sessionId = null, error, sessionName = null }) {
   const errorMessage = normalizeErrorMessage(error);
 
@@ -283,5 +305,6 @@ export {
   createNotificationEvent,
   notifyUserIfEnabled,
   notifyRunStopped,
-  notifyRunFailed
+  notifyRunFailed,
+  notifyBackgroundWorkCompleted
 };