@cloudcli-ai/cloudcli 1.37.1 → 1.37.2

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
 };