wind-agent-cli 1.37.2

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/claude-cli-path.ts

@@ -0,0 +1,139 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const DEFAULT_CLAUDE_COMMAND = 'claude';
+const CLAUDE_SCRIPT_EXTENSIONS = new Set(['.cjs', '.js', '.jsx', '.mjs', '.ts', '.tsx']);
+const CLAUDE_WRAPPER_SEGMENTS = ['node_modules', '@anthropic-ai', 'claude-code', 'bin', 'claude.exe'] as const;
+
+export type ResolveClaudeCodeExecutablePathDependencies = {
+  execFileSync?: typeof execFileSync;
+  existsSync?: typeof fs.existsSync;
+  platform?: NodeJS.Platform;
+  readFileSync?: typeof fs.readFileSync;
+};
+
+function getPathApi(platform: NodeJS.Platform) {
+  return platform === 'win32' ? path.win32 : path;
+}
+
+function stripWrappingQuotes(value: string): string {
+  const trimmed = value.trim();
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function isPathLike(value: string): boolean {
+  return value.includes('/') || value.includes('\\');
+}
+
+function resolveClaudeWrapperBinary(
+  wrapperPath: string,
+  deps: Required<ResolveClaudeCodeExecutablePathDependencies>,
+): string | null {
+  const pathApi = getPathApi(deps.platform);
+  const directCandidate = pathApi.resolve(pathApi.dirname(wrapperPath), ...CLAUDE_WRAPPER_SEGMENTS);
+
+  if (deps.existsSync(directCandidate)) {
+    return directCandidate;
+  }
+
+  let content: string;
+  try {
+    content = deps.readFileSync(wrapperPath, 'utf8');
+  } catch {
+    return null;
+  }
+
+  const matches = content.matchAll(/["']([^"'\\\r\n]*claude\.exe)["']/gi);
+  for (const match of matches) {
+    const rawTarget = match[1]
+      .replace(/^\$basedir[\\/]/i, '')
+      .replace(/^%dp0%[\\/]/i, '')
+      .replace(/^%~dp0[\\/]/i, '');
+    const normalizedTarget = rawTarget.replace(/[\\/]/g, pathApi.sep);
+    const candidate = pathApi.isAbsolute(normalizedTarget)
+      ? normalizedTarget
+      : pathApi.resolve(pathApi.dirname(wrapperPath), normalizedTarget);
+
+    if (deps.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function resolveWindowsClaudeExecutablePath(
+  configuredPath: string,
+  deps: Required<ResolveClaudeCodeExecutablePathDependencies>,
+): string {
+  const pathApi = getPathApi(deps.platform);
+  const extension = pathApi.extname(configuredPath).toLowerCase();
+  const explicitPath = isPathLike(configuredPath) || pathApi.isAbsolute(configuredPath);
+
+  if (CLAUDE_SCRIPT_EXTENSIONS.has(extension)) {
+    return configuredPath;
+  }
+
+  if (explicitPath && extension === '.exe') {
+    return configuredPath;
+  }
+
+  if (explicitPath) {
+    return resolveClaudeWrapperBinary(configuredPath, deps) ?? configuredPath;
+  }
+
+  try {
+    const stdout = deps.execFileSync('where.exe', [configuredPath], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      windowsHide: true,
+    });
+    const candidates = stdout
+      .split(/\r?\n/)
+      .map((entry) => entry.trim())
+      .filter(Boolean);
+
+    for (const candidate of candidates) {
+      if (pathApi.extname(candidate).toLowerCase() === '.exe') {
+        return candidate;
+      }
+    }
+
+    for (const candidate of candidates) {
+      const resolved = resolveClaudeWrapperBinary(candidate, deps);
+      if (resolved) {
+        return resolved;
+      }
+    }
+  } catch {
+    return configuredPath;
+  }
+
+  return configuredPath;
+}
+
+export function resolveClaudeCodeExecutablePath(
+  configuredPath: string | undefined = process.env.CLAUDE_CLI_PATH,
+  dependencies: ResolveClaudeCodeExecutablePathDependencies = {},
+): string {
+  const deps: Required<ResolveClaudeCodeExecutablePathDependencies> = {
+    execFileSync: dependencies.execFileSync ?? execFileSync,
+    existsSync: dependencies.existsSync ?? fs.existsSync,
+    platform: dependencies.platform ?? process.platform,
+    readFileSync: dependencies.readFileSync ?? fs.readFileSync,
+  };
+
+  const normalizedPath = stripWrappingQuotes(configuredPath || DEFAULT_CLAUDE_COMMAND);
+  if (deps.platform !== 'win32') {
+    return normalizedPath;
+  }
+
+  return resolveWindowsClaudeExecutablePath(normalizedPath, deps);
+}

package/server/shared/frontmatter.ts

@@ -0,0 +1,18 @@
+import matter from 'gray-matter';
+
+const disabledFrontmatterEngine = () => ({});
+
+const frontmatterOptions = {
+  language: 'yaml',
+  // Disable JS/JSON frontmatter parsing to avoid executable project content.
+  // Mirrors Gatsby's mitigation for gray-matter.
+  engines: {
+    js: disabledFrontmatterEngine,
+    javascript: disabledFrontmatterEngine,
+    json: disabledFrontmatterEngine,
+  },
+};
+
+export function parseFrontMatter(content: string) {
+  return matter(content, frontmatterOptions);
+}