@cloudcli-ai/cloudcli 1.36.2 → 1.37.0

package/server/modules/worktrees/tests/worktrees.routes.test.ts

@@ -0,0 +1,199 @@
+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 NextFunction,
+  type Request,
+  type Response,
+} from 'express';
+
+import { createWorktreesRouter } from '@/modules/worktrees/worktrees.routes.js';
+import type {
+  CreateWorktreeInput,
+  WorktreeServices,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+
+function createFakeServices(overrides: Partial<WorktreeServices> = {}): WorktreeServices {
+  const unused = async (): Promise<never> => {
+    throw new Error('Unexpected Worktrees service call');
+  };
+
+  return {
+    resolveProjectPath: () => {
+      throw new Error('Unexpected project resolution');
+    },
+    list: unused,
+    create: unused,
+    createAndOpen: unused,
+    open: unused,
+    merge: unused,
+    remove: unused,
+    ...overrides,
+  };
+}
+
+async function withWorktreesServer(
+  services: WorktreeServices,
+  run: (baseUrl: string) => Promise<void>,
+): Promise<void> {
+  const app = express();
+  app.use(express.json());
+  app.use('/api/worktrees', createWorktreesRouter(services));
+  app.use((error: unknown, _req: Request, res: Response, _next: NextFunction) => {
+    if (error instanceof AppError) {
+      res.status(error.statusCode).json({ error: error.code });
+      return;
+    }
+
+    res.status(500).json({ error: 'INTERNAL_ERROR' });
+  });
+
+  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('create route parses input and invokes the create-and-open application service', async () => {
+  const createInputs: CreateWorktreeInput[] = [];
+  const services = createFakeServices({
+    resolveProjectPath: (projectId) => {
+      assert.equal(projectId, 'project-1');
+      return '/workspace/repo';
+    },
+    createAndOpen: async (input) => {
+      createInputs.push(input);
+      return {
+        worktreePath: '/workspace/repo-worktrees/feature-login',
+        branch: input.branch,
+        createdBranch: true,
+        project: {
+          projectId: 'worktree-project-1',
+          path: '/workspace/repo-worktrees/feature-login',
+          fullPath: '/workspace/repo-worktrees/feature-login',
+          displayName: 'repo worktree',
+          isStarred: false,
+          sessions: [],
+          sessionMeta: { hasMore: false, total: 0 },
+        },
+      };
+    },
+  });
+
+  await withWorktreesServer(services, async (baseUrl) => {
+    const response = await fetch(`${baseUrl}/api/worktrees/create`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        project: ' project-1 ',
+        branch: ' feature/login ',
+        baseBranch: 'main',
+      }),
+    });
+    const payload = await response.json() as {
+      success: boolean;
+      data: { project: { projectId: string } };
+    };
+
+    assert.equal(response.status, 200);
+    assert.equal(payload.success, true);
+    assert.equal(payload.data.project.projectId, 'worktree-project-1');
+  });
+
+  assert.deepEqual(createInputs, [{
+    projectPath: '/workspace/repo',
+    branch: 'feature/login',
+    baseBranch: 'main',
+  }]);
+});
+
+test('create route rejects missing branch before calling a mutation service', async () => {
+  let createCalled = false;
+  const services = createFakeServices({
+    resolveProjectPath: () => '/workspace/repo',
+    createAndOpen: async () => {
+      createCalled = true;
+      throw new Error('create should not run for invalid input');
+    },
+  });
+
+  await withWorktreesServer(services, async (baseUrl) => {
+    const response = await fetch(`${baseUrl}/api/worktrees/create`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ project: 'project-1' }),
+    });
+    const payload = await response.json() as { error: string };
+
+    assert.equal(response.status, 400);
+    assert.equal(payload.error, 'INVALID_REQUEST_BODY');
+  });
+
+  assert.equal(createCalled, false);
+});
+
+test('merge and remove routes do not coerce string booleans to true', async () => {
+  const mergeInputs: Array<{ squash?: boolean; removeAfterMerge?: boolean }> = [];
+  const removeInputs: Array<{ force?: boolean; deleteBranch?: boolean }> = [];
+  const services = createFakeServices({
+    resolveProjectPath: () => '/workspace/repo',
+    merge: async (input) => {
+      mergeInputs.push(input);
+      return {
+        mergedBranch: 'feature/login',
+        targetBranch: 'main',
+        squash: false,
+        removedWorktree: null,
+        cleanupError: null,
+      };
+    },
+    remove: async (input) => {
+      removeInputs.push(input);
+      return {
+        removedPath: input.worktreePath,
+        branch: 'feature/login',
+        branchDeleted: false,
+        archivedProjectId: null,
+        archivalError: null,
+      };
+    },
+  });
+
+  await withWorktreesServer(services, async (baseUrl) => {
+    const body = {
+      project: 'project-1',
+      worktreePath: '/workspace/repo-worktrees/feature-login',
+      squash: 'false',
+      removeAfterMerge: 'false',
+      force: 'false',
+      deleteBranch: 'false',
+    };
+    const mergeResponse = await fetch(`${baseUrl}/api/worktrees/merge`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    const removeResponse = await fetch(`${baseUrl}/api/worktrees/remove`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    assert.equal(mergeResponse.status, 200);
+    assert.equal(removeResponse.status, 200);
+  });
+
+  assert.equal(mergeInputs[0].squash, false);
+  assert.equal(mergeInputs[0].removeAfterMerge, false);
+  assert.equal(removeInputs[0].force, false);
+  assert.equal(removeInputs[0].deleteBranch, false);
+});

package/server/modules/worktrees/worktrees.module.ts

@@ -0,0 +1,113 @@
+import { access } from 'node:fs/promises';
+
+import { projectsDb } from '@/modules/database/index.js';
+import {
+  createProject,
+  deleteOrArchiveProject,
+  restoreArchivedProject,
+} from '@/modules/projects/index.js';
+import type {
+  WorktreeFileSystem,
+  WorktreeProjectGateway,
+  WorktreeServices,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+import { createWorktree } from '@/modules/worktrees/services/worktree-create.service.js';
+import { createAndOpenWorktree } from '@/modules/worktrees/services/worktree-create-and-open.service.js';
+import { runGitCommand } from '@/modules/worktrees/services/worktree-git.service.js';
+import { listWorktrees } from '@/modules/worktrees/services/worktree-list.service.js';
+import { mergeWorktree } from '@/modules/worktrees/services/worktree-merge.service.js';
+import { openWorktreeAsProject } from '@/modules/worktrees/services/worktree-open.service.js';
+import { removeWorktree } from '@/modules/worktrees/services/worktree-remove.service.js';
+import { createWorktreesRouter } from '@/modules/worktrees/worktrees.routes.js';
+
+/**
+ * Real filesystem adapter used only by Worktrees production composition.
+ *
+ * Services depend on the shared capability type and therefore cannot touch a
+ * developer's filesystem unless this adapter is explicitly supplied.
+ */
+const worktreeFileSystem: WorktreeFileSystem = {
+  async pathExists(candidatePath: string): Promise<boolean> {
+    try {
+      await access(candidatePath);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+};
+
+/**
+ * Projects boundary for Worktrees production workflows.
+ *
+ * Imports are deliberately restricted to the Database and Projects barrel
+ * files. No Worktrees service knows which repository or project service backs
+ * these operations.
+ */
+const worktreeProjects: WorktreeProjectGateway = {
+  getProjectPathById: (projectId) => projectsDb.getProjectPathById(projectId),
+  getProjectByPath: (projectPath) => projectsDb.getProjectPath(projectPath),
+  createProject: (input) => createProject(input),
+  restoreProject: (projectId) => restoreArchivedProject(projectId),
+  archiveProject: (projectId) => deleteOrArchiveProject(projectId, false),
+};
+
+const remove: WorktreeServices['remove'] = (input) => removeWorktree(input, {
+  runGit: runGitCommand,
+  projects: worktreeProjects,
+});
+
+const create: WorktreeServices['create'] = (input) => createWorktree(input, {
+  runGit: runGitCommand,
+  fileSystem: worktreeFileSystem,
+});
+
+const open: WorktreeServices['open'] = (input) => openWorktreeAsProject(input, {
+  runGit: runGitCommand,
+  projects: worktreeProjects,
+});
+
+/**
+ * Production Worktrees application-service surface.
+ *
+ * This is the module's composition root: it is the only location that combines
+ * concrete adapters with the independently testable workflow functions.
+ */
+const worktreeServices: WorktreeServices = {
+  resolveProjectPath(projectId) {
+    const projectPath = worktreeProjects.getProjectPathById(projectId);
+    if (!projectPath) {
+      throw new AppError(`Unable to resolve project path for "${projectId}"`, {
+        code: 'PROJECT_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    return projectPath;
+  },
+  list: (input) => listWorktrees(input, {
+    runGit: runGitCommand,
+    getProjectByPath: worktreeProjects.getProjectByPath,
+  }),
+  create,
+  createAndOpen: (input) => createAndOpenWorktree(input, {
+    createWorktree: create,
+    openWorktree: open,
+    removeWorktree: remove,
+  }),
+  open,
+  merge: (input) => mergeWorktree(input, {
+    runGit: runGitCommand,
+    removeWorktree: remove,
+  }),
+  remove,
+};
+
+/**
+ * Worktrees router mounted by the server entrypoint at `/api/worktrees`.
+ *
+ * It is assembled here so other modules consume only the Worktrees barrel and
+ * cannot depend on route or service implementation files.
+ */
+export const worktreesRoutes = createWorktreesRouter(worktreeServices);

package/server/modules/worktrees/worktrees.routes.ts

@@ -0,0 +1,116 @@
+import express from 'express';
+
+import type { WorktreeServices } from '@/shared/types.js';
+import { AppError, asyncHandler, createApiSuccessResponse } from '@/shared/utils.js';
+
+/**
+ * Parses the project identifier shared by all Worktrees routes.
+ *
+ * Path resolution intentionally remains in the injected application service so
+ * this transport layer never reaches into the Database module.
+ */
+function readProjectId(projectIdValue: unknown): string {
+  const projectId = typeof projectIdValue === 'string' ? projectIdValue.trim() : '';
+  if (!projectId) {
+    throw new AppError('project is required', {
+      code: 'PROJECT_ID_REQUIRED',
+      statusCode: 400,
+    });
+  }
+
+  return projectId;
+}
+
+function readRequiredString(value: unknown, name: string): string {
+  const parsed = typeof value === 'string' ? value.trim() : '';
+  if (!parsed) {
+    throw new AppError(`${name} is required`, {
+      code: 'INVALID_REQUEST_BODY',
+      statusCode: 400,
+    });
+  }
+  return parsed;
+}
+
+/**
+ * Builds the Worktrees HTTP router around an injected application-service API.
+ *
+ * Keeping construction explicit lets route tests supply deterministic services
+ * and ensures parsing remains the route layer's only responsibility.
+ */
+export function createWorktreesRouter(services: WorktreeServices): express.Router {
+  const router = express.Router();
+
+  router.get(
+    '/',
+    asyncHandler(async (req, res) => {
+      const projectPath = services.resolveProjectPath(readProjectId(req.query.project));
+      const result = await services.list({ projectPath });
+      res.json(createApiSuccessResponse(result));
+    }),
+  );
+
+  router.post(
+    '/create',
+    asyncHandler(async (req, res) => {
+      const body = req.body as Record<string, unknown>;
+      const projectPath = services.resolveProjectPath(readProjectId(body.project));
+      const branch = readRequiredString(body.branch, 'branch');
+      const baseBranch = typeof body.baseBranch === 'string' ? body.baseBranch : null;
+
+      const result = await services.createAndOpen({ projectPath, branch, baseBranch });
+      res.json(createApiSuccessResponse(result));
+    }),
+  );
+
+  router.post(
+    '/open',
+    asyncHandler(async (req, res) => {
+      const body = req.body as Record<string, unknown>;
+      const projectPath = services.resolveProjectPath(readProjectId(body.project));
+      const worktreePath = readRequiredString(body.worktreePath, 'worktreePath');
+
+      const project = await services.open({ projectPath, worktreePath });
+      res.json(createApiSuccessResponse({ project }));
+    }),
+  );
+
+  router.post(
+    '/merge',
+    asyncHandler(async (req, res) => {
+      const body = req.body as Record<string, unknown>;
+      const projectPath = services.resolveProjectPath(readProjectId(body.project));
+      const worktreePath = readRequiredString(body.worktreePath, 'worktreePath');
+
+      const result = await services.merge({
+        projectPath,
+        worktreePath,
+        squash: typeof body.squash === 'boolean' ? body.squash : false,
+        message: typeof body.message === 'string' ? body.message : null,
+        removeAfterMerge: typeof body.removeAfterMerge === 'boolean' ? body.removeAfterMerge : false,
+      });
+
+      res.json(createApiSuccessResponse(result));
+    }),
+  );
+
+  router.post(
+    '/remove',
+    asyncHandler(async (req, res) => {
+      const body = req.body as Record<string, unknown>;
+      const projectPath = services.resolveProjectPath(readProjectId(body.project));
+      const worktreePath = readRequiredString(body.worktreePath, 'worktreePath');
+
+      const result = await services.remove({
+        projectPath,
+        worktreePath,
+        force: typeof body.force === 'boolean' ? body.force : false,
+        deleteBranch: typeof body.deleteBranch === 'boolean' ? body.deleteBranch : false,
+      });
+
+      res.json(createApiSuccessResponse(result));
+    }),
+  );
+
+  return router;
+}

package/server/shared/image-attachments.ts

@@ -3,17 +3,18 @@ import os from 'node:os';
 import path from 'node:path';
 
 /**
- * Shared image-attachment plumbing for every provider runtime.
+ * Shared chat-attachment plumbing for every provider runtime.
  *
- * Uploaded chat images are persisted once in the global `~/.cloudcli/assets`
+ * Uploaded chat files are persisted once in the global `~/.cloudcli/assets`
  * folder and referenced by absolute path everywhere else:
  * - Claude: paths are read back into base64 `image` content blocks.
  * - Codex: paths become `local_image` input items.
- * - Cursor/OpenCode: paths are appended to the prompt inside an
- *   `<images_input>` tag, which is stripped again when history is read.
+ * - General files: verified paths are appended inside a `<files_input>` tag,
+ *   which every provider history adapter strips back out for display.
+ * - Cursor/OpenCode images: paths use the equivalent `<images_input>` tag.
  *
- * The chat UI loads them through the dedicated `/api/assets/images/:filename`
- * route, which serves only from this folder.
+ * The chat UI loads them through dedicated `/api/assets/images/:filename` and
+ * `/api/assets/files/:filename` routes, which serve only from this folder.
  */
 
 /** Global storage folder for uploaded chat image attachments. */
@@ -26,8 +27,12 @@ export type ImageAttachmentDescriptor = {
   path: string;
   name?: string;
   mimeType?: string;
+  size?: number;
 };
 
+/** Provider-neutral descriptor used for both image and non-image chat attachments. */
+export type ChatAttachmentDescriptor = ImageAttachmentDescriptor;
+
 /** Media types the Claude Messages API accepts for base64 image blocks. */
 const CLAUDE_IMAGE_MEDIA_TYPES = new Set([
   'image/jpeg',
@@ -46,17 +51,17 @@ const EXTENSION_TO_MEDIA_TYPE: Record<string, string> = {
 };
 
 /**
- * Accepts the loosely-typed `options.images` payload from chat.send and
- * returns only well-formed descriptors. Plain path strings are supported so
- * callers can also pass bare path arrays.
+ * Accepts a loosely typed chat attachment payload and returns only well-formed
+ * descriptors. The websocket gateway and provider adapters use this to handle
+ * current `attachments` payloads and legacy image path arrays consistently.
  */
-export function normalizeImageDescriptors(images: unknown): ImageAttachmentDescriptor[] {
-  if (!Array.isArray(images)) {
+export function normalizeAttachmentDescriptors(attachments: unknown): ChatAttachmentDescriptor[] {
+  if (!Array.isArray(attachments)) {
     return [];
   }
 
-  const descriptors: ImageAttachmentDescriptor[] = [];
-  for (const entry of images) {
+  const descriptors: ChatAttachmentDescriptor[] = [];
+  for (const entry of attachments) {
     if (typeof entry === 'string' && entry.trim()) {
       descriptors.push({ path: entry.trim() });
       continue;
@@ -67,16 +72,40 @@ export function normalizeImageDescriptors(images: unknown): ImageAttachmentDescr
       if (!entryPath) {
         continue;
       }
-      descriptors.push({
-        path: entryPath,
-        name: typeof record.name === 'string' ? record.name : undefined,
-        mimeType: typeof record.mimeType === 'string' ? record.mimeType : undefined,
-      });
+      const descriptor: ChatAttachmentDescriptor = { path: entryPath };
+      if (typeof record.name === 'string') {
+        descriptor.name = record.name;
+      }
+      if (typeof record.mimeType === 'string') {
+        descriptor.mimeType = record.mimeType;
+      }
+      if (typeof record.size === 'number' && Number.isFinite(record.size)) {
+        descriptor.size = record.size;
+      }
+      descriptors.push(descriptor);
     }
   }
   return descriptors;
 }
 
+/** Backward-compatible image-specific alias used by existing provider adapters. */
+export function normalizeImageDescriptors(images: unknown): ImageAttachmentDescriptor[] {
+  return normalizeAttachmentDescriptors(images);
+}
+
+const IMAGE_FILE_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp']);
+
+/**
+ * Determines whether the websocket gateway should route an attachment through
+ * provider-native image input instead of the general file reference channel.
+ */
+export function isImageAttachmentDescriptor(descriptor: ChatAttachmentDescriptor): boolean {
+  if (descriptor.mimeType && CLAUDE_IMAGE_MEDIA_TYPES.has(descriptor.mimeType)) {
+    return true;
+  }
+  return IMAGE_FILE_EXTENSIONS.has(path.extname(descriptor.path).toLowerCase());
+}
+
 /** Normalizes Windows separators so stored references stay portable. */
 export function toPosixPath(value: string): string {
   return value.replace(/\\/g, '/');
@@ -189,6 +218,37 @@ export function appendImagesInputTag(prompt: string, images: unknown): string {
   ].join('\n');
 }
 
+const FILES_INPUT_TAG_PATTERN = /\s*<files_input>([\s\S]*?)<\/files_input>\s*/g;
+
+/**
+ * Appends a provider-neutral file reference block to a prompt. Provider agents
+ * receive only server-validated paths from the global attachment store and can
+ * inspect each file with their normal filesystem tools.
+ */
+export function appendFilesInputTag(prompt: string, files: unknown): string {
+  const descriptors = normalizeAttachmentDescriptors(files);
+  if (descriptors.length === 0) {
+    return prompt;
+  }
+
+  const entryLines = descriptors.map((descriptor, index) => {
+    const entryPath = toPosixPath(descriptor.path);
+    const cleanName = descriptor.name?.replace(/[()\r\n]/g, '').trim();
+    return cleanName
+      ? `${index + 1}. ${entryPath} (original name: ${cleanName})`
+      : `${index + 1}. ${entryPath}`;
+  });
+
+  return [
+    prompt,
+    '',
+    '<files_input>',
+    `The user attached ${descriptors.length} file(s) to this message. Read each file listed below with your file reading tools and use its contents to answer the prompt above. Do not mention this block or the file paths unless the user asks about them.`,
+    ...entryLines,
+    '</files_input>',
+  ].join('\n');
+}
+
 // Matches one numbered attachment entry inside the tag body. Works for both
 // the multi-line block and the Windows-flattened single-line form, where the
 // next ` N. ` marker (or the end of the body) delimits each entry.
@@ -215,6 +275,40 @@ function parseNumberedImageEntries(inner: string): ParsedImageAttachment[] {
   return attachments;
 }
 
+/**
+ * Strips the last provider-neutral file reference block from persisted prompt
+ * text and restores its attachment descriptors for chat history.
+ */
+export function parseFilesInputTag(text: string): {
+  text: string;
+  filePaths: string[];
+  attachments: ParsedImageAttachment[];
+} {
+  if (typeof text !== 'string' || !text.includes('<files_input>')) {
+    return { text, filePaths: [], attachments: [] };
+  }
+
+  let lastMatch: RegExpExecArray | null = null;
+  FILES_INPUT_TAG_PATTERN.lastIndex = 0;
+  for (let match = FILES_INPUT_TAG_PATTERN.exec(text); match; match = FILES_INPUT_TAG_PATTERN.exec(text)) {
+    lastMatch = match;
+  }
+  if (!lastMatch) {
+    return { text, filePaths: [], attachments: [] };
+  }
+
+  const attachments = parseNumberedImageEntries(lastMatch[1]);
+  const stripped = (
+    text.slice(0, lastMatch.index) + '\n' + text.slice(lastMatch.index + lastMatch[0].length)
+  ).trim();
+
+  return {
+    text: stripped,
+    filePaths: attachments.map((attachment) => attachment.path),
+    attachments,
+  };
+}
+
 /**
  * Strips one `<images_input>` block from persisted prompt text and returns
  * the clean text plus the referenced attachments (path and original name).