@cloudcli-ai/cloudcli 1.36.3 → 1.37.1

package/server/modules/worktrees/tests/worktree-merge.service.test.ts

@@ -0,0 +1,213 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { mergeWorktree } from '@/modules/worktrees/services/worktree-merge.service.js';
+import type { GitCommandResult } from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+
+const PORCELAIN = [
+  'worktree /home/user/repo',
+  'HEAD 1111111111111111111111111111111111111111',
+  'branch refs/heads/main',
+  '',
+  'worktree /home/user/repo-worktrees/feature-login',
+  'HEAD 2222222222222222222222222222222222222222',
+  'branch refs/heads/feature/login',
+  '',
+].join('\n');
+
+type RecordedCall = { args: string[]; cwd: string };
+
+type FakeRunnerOptions = {
+  /** Worktree paths whose `git status --porcelain` should report dirty files. */
+  dirtyPaths?: string[];
+  /** When true, `git merge` fails and reports one conflicted file. */
+  mergeConflicts?: boolean;
+  rollbackFails?: boolean;
+};
+
+function createFakeRunner(options: FakeRunnerOptions = {}) {
+  const calls: RecordedCall[] = [];
+  const runner = async (args: string[], cwd: string): Promise<GitCommandResult> => {
+    calls.push({ args, cwd });
+
+    if (args[0] === 'worktree' && args[1] === 'list') {
+      return { stdout: PORCELAIN, stderr: '' };
+    }
+
+    if (args[0] === 'status') {
+      const isDirty = (options.dirtyPaths ?? []).some((dirtyPath) => cwd.includes(dirtyPath));
+      return { stdout: isDirty ? ' M file.txt\n' : '', stderr: '' };
+    }
+
+    if (args[0] === 'merge' && options.mergeConflicts) {
+      throw new AppError('git merge failed', {
+        code: 'GIT_COMMAND_FAILED',
+        details: 'CONFLICT (content): Merge conflict in file.txt',
+      });
+    }
+
+    if (args[0] === 'diff' && args.includes('--diff-filter=U')) {
+      return { stdout: options.mergeConflicts ? 'file.txt\n' : '', stderr: '' };
+    }
+
+    if (args[0] === 'reset' && options.rollbackFails) {
+      throw new AppError('git reset failed', {
+        code: 'GIT_COMMAND_FAILED',
+        details: 'index.lock permission denied',
+      });
+    }
+
+    return { stdout: '', stderr: '' };
+  };
+
+  return { calls, runner };
+}
+
+function createDependencies(runner: ReturnType<typeof createFakeRunner>['runner']) {
+  return {
+    runGit: runner,
+    removeWorktree: async () => {
+      throw new Error('removeWorktree should not be called by this test');
+    },
+  };
+}
+
+test('mergeWorktree squash-merges into the main worktree branch', async () => {
+  const { calls, runner } = createFakeRunner();
+
+  const result = await mergeWorktree(
+    {
+      projectPath: '/home/user/repo-worktrees/feature-login',
+      worktreePath: '/home/user/repo-worktrees/feature-login',
+      squash: true,
+    },
+    createDependencies(runner),
+  );
+
+  assert.equal(result.mergedBranch, 'feature/login');
+  assert.equal(result.targetBranch, 'main');
+  assert.equal(result.squash, true);
+  assert.equal(result.removedWorktree, null);
+  assert.equal(result.cleanupError, null);
+
+  const mergeCall = calls.find((call) => call.args[0] === 'merge');
+  assert.ok(mergeCall, 'expected a merge call');
+  assert.deepEqual(mergeCall.args, ['merge', '--squash', 'feature/login']);
+  // Squash merges run in the main worktree, never in the source worktree.
+  assert.ok(mergeCall.cwd.endsWith('repo'));
+
+  const commitCall = calls.find((call) => call.args[0] === 'commit');
+  assert.ok(commitCall, 'expected a commit call after squash');
+  assert.equal(commitCall.args[2], "Squash merge branch 'feature/login'");
+});
+
+test('mergeWorktree performs a regular --no-ff merge with a custom message', async () => {
+  const { calls, runner } = createFakeRunner();
+
+  await mergeWorktree(
+    {
+      projectPath: '/home/user/repo',
+      worktreePath: '/home/user/repo-worktrees/feature-login',
+      squash: false,
+      message: 'Land the login feature',
+    },
+    createDependencies(runner),
+  );
+
+  const mergeCall = calls.find((call) => call.args[0] === 'merge');
+  assert.ok(mergeCall);
+  assert.deepEqual(mergeCall.args, ['merge', '--no-ff', 'feature/login', '-m', 'Land the login feature']);
+});
+
+test('mergeWorktree rejects when the source worktree is dirty', async () => {
+  const { runner } = createFakeRunner({ dirtyPaths: ['feature-login'] });
+
+  await assert.rejects(
+    mergeWorktree(
+      {
+        projectPath: '/home/user/repo',
+        worktreePath: '/home/user/repo-worktrees/feature-login',
+      },
+      createDependencies(runner),
+    ),
+    (error: unknown) =>
+      error instanceof AppError && error.code === 'WORKTREE_SOURCE_DIRTY' && error.statusCode === 409,
+  );
+});
+
+test('mergeWorktree aborts and reports conflicted files on merge conflict', async () => {
+  const { calls, runner } = createFakeRunner({ mergeConflicts: true });
+
+  await assert.rejects(
+    mergeWorktree(
+      {
+        projectPath: '/home/user/repo',
+        worktreePath: '/home/user/repo-worktrees/feature-login',
+      },
+      createDependencies(runner),
+    ),
+    (error: unknown) =>
+      error instanceof AppError &&
+      error.code === 'WORKTREE_MERGE_CONFLICT' &&
+      error.statusCode === 409 &&
+      Array.isArray(error.details) &&
+      error.details.includes('file.txt'),
+  );
+
+  const resetCall = calls.find((call) => call.args[0] === 'reset');
+  assert.ok(resetCall, 'expected the merge to be rolled back');
+  assert.deepEqual(resetCall.args, ['reset', '--merge']);
+});
+
+test('mergeWorktree reports rollback failure instead of claiming a conflict was aborted', async () => {
+  const { runner } = createFakeRunner({ mergeConflicts: true, rollbackFails: true });
+
+  await assert.rejects(
+    mergeWorktree(
+      {
+        projectPath: '/home/user/repo',
+        worktreePath: '/home/user/repo-worktrees/feature-login',
+      },
+      createDependencies(runner),
+    ),
+    (error: unknown) =>
+      error instanceof AppError
+      && error.code === 'WORKTREE_MERGE_ROLLBACK_FAILED'
+      && typeof error.details === 'object',
+  );
+});
+
+test('mergeWorktree preserves merge success when optional worktree cleanup fails', async () => {
+  const { runner } = createFakeRunner();
+  const result = await mergeWorktree(
+    {
+      projectPath: '/home/user/repo',
+      worktreePath: '/home/user/repo-worktrees/feature-login',
+      removeAfterMerge: true,
+    },
+    {
+      runGit: runner,
+      removeWorktree: async () => { throw new Error('cleanup unavailable'); },
+    },
+  );
+
+  assert.equal(result.mergedBranch, 'feature/login');
+  assert.equal(result.removedWorktree, null);
+  assert.equal(result.cleanupError, 'cleanup unavailable');
+});
+
+test('mergeWorktree refuses to merge the main worktree into itself', async () => {
+  const { runner } = createFakeRunner();
+
+  await assert.rejects(
+    mergeWorktree(
+      {
+        projectPath: '/home/user/repo',
+        worktreePath: '/home/user/repo',
+      },
+      createDependencies(runner),
+    ),
+    (error: unknown) => error instanceof AppError && error.code === 'WORKTREE_MERGE_MAIN',
+  );
+});

package/server/modules/worktrees/tests/worktree-open.service.test.ts

@@ -0,0 +1,122 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { openWorktreeAsProject } from '@/modules/worktrees/services/worktree-open.service.js';
+import type { GitCommandResult, ProjectRepositoryRow } from '@/shared/types.js';
+import { normalizeProjectPath } from '@/shared/utils.js';
+
+const MAIN_PATH = normalizeProjectPath('/home/user/repo');
+const WORKTREE_PATH = normalizeProjectPath('/home/user/repo-worktrees/feature-login');
+const PORCELAIN = [
+  'worktree /home/user/repo',
+  'HEAD 1111111111111111111111111111111111111111',
+  'branch refs/heads/main',
+  '',
+  'worktree /home/user/repo-worktrees/feature-login',
+  'HEAD 2222222222222222222222222222222222222222',
+  'branch refs/heads/feature/login',
+  '',
+].join('\n');
+
+function createFakeRunner() {
+  return async (args: string[]): Promise<GitCommandResult> => {
+    if (args[0] === 'worktree' && args[1] === 'list') {
+      return { stdout: PORCELAIN, stderr: '' };
+    }
+
+    return { stdout: '', stderr: '' };
+  };
+}
+
+function createProjectRow(isArchived = false): ProjectRepositoryRow {
+  return {
+    project_id: 'project-1',
+    project_path: WORKTREE_PATH,
+    custom_project_name: 'repo · feature/login',
+    isStarred: 0,
+    isArchived: isArchived ? 1 : 0,
+  };
+}
+
+test('openWorktreeAsProject returns an already-active linked project', async () => {
+  const projectRow = createProjectRow();
+  let createCalls = 0;
+  let restoreCalls = 0;
+
+  const result = await openWorktreeAsProject(
+    { projectPath: MAIN_PATH, worktreePath: WORKTREE_PATH },
+    {
+      runGit: createFakeRunner(),
+      projects: {
+        getProjectByPath: () => projectRow,
+        createProject: async () => {
+          createCalls += 1;
+          return { outcome: 'created' as const, project: { projectId: 'unexpected' } };
+        },
+        restoreProject: () => {
+          restoreCalls += 1;
+        },
+      },
+    },
+  );
+
+  assert.equal(result.projectId, 'project-1');
+  assert.equal(result.path, WORKTREE_PATH);
+  assert.equal(createCalls, 0);
+  assert.equal(restoreCalls, 0);
+});
+
+test('openWorktreeAsProject restores an archived linked project', async () => {
+  const projectRow = createProjectRow(true);
+  const restoredProjectIds: string[] = [];
+
+  const result = await openWorktreeAsProject(
+    { projectPath: MAIN_PATH, worktreePath: WORKTREE_PATH },
+    {
+      runGit: createFakeRunner(),
+      projects: {
+        getProjectByPath: () => projectRow,
+        createProject: async () => ({
+          outcome: 'created' as const,
+          project: { projectId: 'unexpected' },
+        }),
+        restoreProject: (projectId) => {
+          restoredProjectIds.push(projectId);
+          projectRow.isArchived = 0;
+        },
+      },
+    },
+  );
+
+  assert.equal(result.projectId, 'project-1');
+  assert.deepEqual(restoredProjectIds, ['project-1']);
+});
+
+test('openWorktreeAsProject registers a worktree that has no project record', async () => {
+  let projectRow: ProjectRepositoryRow | null = null;
+  const createInputs: Array<{ projectPath: string; customName: string }> = [];
+
+  const result = await openWorktreeAsProject(
+    { projectPath: MAIN_PATH, worktreePath: WORKTREE_PATH },
+    {
+      runGit: createFakeRunner(),
+      projects: {
+        getProjectByPath: () => projectRow,
+        createProject: async (input) => {
+          createInputs.push(input);
+          projectRow = createProjectRow();
+          return { outcome: 'created' as const, project: { projectId: 'project-1' } };
+        },
+        restoreProject: () => {
+          throw new Error('restoreProject should not be called for a new project');
+        },
+      },
+    },
+  );
+
+  assert.equal(result.projectId, 'project-1');
+  assert.deepEqual(createInputs, [{
+    projectPath: WORKTREE_PATH,
+    customName: 'repo · feature/login',
+  }]);
+});

package/server/modules/worktrees/tests/worktree-remove.service.test.ts

@@ -0,0 +1,227 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { removeWorktree } from '@/modules/worktrees/services/worktree-remove.service.js';
+import type { GitCommandResult, ProjectRepositoryRow } from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+
+const PORCELAIN = [
+  'worktree /home/user/repo',
+  'HEAD 1111111111111111111111111111111111111111',
+  'branch refs/heads/main',
+  '',
+  'worktree /home/user/repo-worktrees/feature-login',
+  'HEAD 2222222222222222222222222222222222222222',
+  'branch refs/heads/feature/login',
+  '',
+].join('\n');
+
+type RecordedCall = { args: string[]; cwd: string };
+
+function createFakeRunner(options: {
+  dirty?: boolean;
+  branchDeleteFails?: boolean;
+  statusFails?: boolean;
+} = {}) {
+  const calls: RecordedCall[] = [];
+  const runner = async (args: string[], cwd: string): Promise<GitCommandResult> => {
+    calls.push({ args, cwd });
+
+    if (args[0] === 'worktree' && args[1] === 'list') {
+      return { stdout: PORCELAIN, stderr: '' };
+    }
+
+    if (args[0] === 'status') {
+      if (options.statusFails) {
+        throw new AppError('status failed', { code: 'GIT_COMMAND_FAILED' });
+      }
+      return { stdout: options.dirty ? '?? new-file.txt\n' : '', stderr: '' };
+    }
+
+    if (args[0] === 'branch' && args[1] === '-D' && options.branchDeleteFails) {
+      throw new AppError('branch delete failed', { code: 'GIT_COMMAND_FAILED' });
+    }
+
+    return { stdout: '', stderr: '' };
+  };
+
+  return { calls, runner };
+}
+
+function createDependencies(
+  runner: ReturnType<typeof createFakeRunner>['runner'],
+  linkedProject: ProjectRepositoryRow | null = null,
+  archiveError: Error | null = null,
+) {
+  const archivedProjectIds: string[] = [];
+
+  return {
+    archivedProjectIds,
+    dependencies: {
+      runGit: runner,
+      projects: {
+        getProjectByPath: () => linkedProject,
+        archiveProject: async (projectId: string) => {
+          if (archiveError) {
+            throw archiveError;
+          }
+          archivedProjectIds.push(projectId);
+        },
+      },
+    },
+  };
+}
+
+test('removeWorktree removes a clean worktree and deletes its branch', async () => {
+  const { calls, runner } = createFakeRunner();
+  const { dependencies } = createDependencies(runner);
+
+  const result = await removeWorktree(
+    {
+      projectPath: '/home/user/repo',
+      worktreePath: '/home/user/repo-worktrees/feature-login',
+      deleteBranch: true,
+    },
+    dependencies,
+  );
+
+  assert.equal(result.branch, 'feature/login');
+  assert.equal(result.branchDeleted, true);
+  assert.equal(result.archivedProjectId, null);
+  assert.equal(result.archivalError, null);
+
+  const removeCall = calls.find((call) => call.args[0] === 'worktree' && call.args[1] === 'remove');
+  assert.ok(removeCall, 'expected a worktree remove call');
+  assert.ok(!removeCall.args.includes('--force'));
+
+  const branchDeleteCall = calls.find((call) => call.args[0] === 'branch' && call.args[1] === '-D');
+  assert.ok(branchDeleteCall, 'expected the branch to be deleted');
+  assert.equal(branchDeleteCall.args[2], 'feature/login');
+});
+
+test('removeWorktree rejects a dirty worktree unless forced', async () => {
+  const { runner } = createFakeRunner({ dirty: true });
+  const { dependencies } = createDependencies(runner);
+
+  await assert.rejects(
+    removeWorktree(
+      {
+        projectPath: '/home/user/repo',
+        worktreePath: '/home/user/repo-worktrees/feature-login',
+      },
+      dependencies,
+    ),
+    (error: unknown) =>
+      error instanceof AppError && error.code === 'WORKTREE_DIRTY' && error.statusCode === 409,
+  );
+});
+
+test('removeWorktree does not remove when status cannot confirm the worktree is clean', async () => {
+  const { calls, runner } = createFakeRunner({ statusFails: true });
+  const { dependencies } = createDependencies(runner);
+
+  await assert.rejects(removeWorktree({
+    projectPath: '/home/user/repo',
+    worktreePath: '/home/user/repo-worktrees/feature-login',
+  }, dependencies));
+
+  assert.equal(calls.some((call) => call.args[0] === 'worktree' && call.args[1] === 'remove'), false);
+});
+
+test('removeWorktree passes --force through and skips the dirty check', async () => {
+  const { calls, runner } = createFakeRunner({ dirty: true });
+  const { dependencies } = createDependencies(runner);
+
+  await removeWorktree(
+    {
+      projectPath: '/home/user/repo',
+      worktreePath: '/home/user/repo-worktrees/feature-login',
+      force: true,
+    },
+    dependencies,
+  );
+
+  const removeCall = calls.find((call) => call.args[0] === 'worktree' && call.args[1] === 'remove');
+  assert.ok(removeCall);
+  assert.ok(removeCall.args.includes('--force'));
+});
+
+test('removeWorktree reports branchDeleted=false when branch deletion fails', async () => {
+  const { runner } = createFakeRunner({ branchDeleteFails: true });
+  const { dependencies } = createDependencies(runner);
+
+  const result = await removeWorktree(
+    {
+      projectPath: '/home/user/repo',
+      worktreePath: '/home/user/repo-worktrees/feature-login',
+      deleteBranch: true,
+    },
+    dependencies,
+  );
+
+  assert.equal(result.branchDeleted, false);
+});
+
+test('removeWorktree archives an active project linked to the removed path', async () => {
+  const { runner } = createFakeRunner();
+  const linkedProject: ProjectRepositoryRow = {
+    project_id: 'project-1',
+    project_path: '/home/user/repo-worktrees/feature-login',
+    custom_project_name: 'repo · feature/login',
+    isStarred: 0,
+    isArchived: 0,
+  };
+  const { archivedProjectIds, dependencies } = createDependencies(runner, linkedProject);
+
+  const result = await removeWorktree(
+    {
+      projectPath: '/home/user/repo',
+      worktreePath: linkedProject.project_path,
+    },
+    dependencies,
+  );
+
+  assert.equal(result.archivedProjectId, 'project-1');
+  assert.equal(result.archivalError, null);
+  assert.deepEqual(archivedProjectIds, ['project-1']);
+});
+
+test('removeWorktree reports archival failure after successful Git removal', async () => {
+  const { runner } = createFakeRunner();
+  const linkedProject: ProjectRepositoryRow = {
+    project_id: 'project-1',
+    project_path: '/home/user/repo-worktrees/feature-login',
+    custom_project_name: 'feature/login',
+    isStarred: 0,
+    isArchived: 0,
+  };
+  const { dependencies } = createDependencies(runner, linkedProject, new Error('archive failed'));
+
+  const result = await removeWorktree({
+    projectPath: '/home/user/repo',
+    worktreePath: linkedProject.project_path,
+  }, dependencies);
+
+  assert.equal(result.removedPath.replace(/\\/g, '/'), linkedProject.project_path);
+  assert.equal(result.archivedProjectId, null);
+  assert.equal(result.archivalError, 'archive failed');
+});
+
+test('removeWorktree never removes the main worktree', async () => {
+  const { runner } = createFakeRunner();
+  const { dependencies } = createDependencies(runner);
+
+  await assert.rejects(
+    removeWorktree(
+      {
+        projectPath: '/home/user/repo-worktrees/feature-login',
+        worktreePath: '/home/user/repo',
+      },
+      dependencies,
+    ),
+    (error: unknown) =>
+      error instanceof AppError
+      && error.code === 'WORKTREE_MAIN_NOT_REMOVABLE'
+      && error.statusCode === 400,
+  );
+});