@cloudcli-ai/cloudcli 1.36.2 → 1.37.0

package/server/{routes/git.js → modules/git/git.routes.ts}

@@ -1,12 +1,29 @@
-import express from 'express';
-// cross-spawn: drop-in spawn with Windows .cmd/PATHEXT resolution.
-import spawn from 'cross-spawn';
+// @ts-nocheck -- temporary while Git workflows are extracted into the injected service.
 import path from 'path';
-import { promises as fs } from 'fs';
-import { projectsDb } from '../modules/database/index.js';
-import { queryClaudeSDK } from '../claude-sdk.js';
-import { spawnCursor } from '../cursor-cli.js';
 
+import express from 'express';
+
+import type { ProviderRunFunction } from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+
+// cross-spawn: drop-in spawn with Windows .cmd/PATHEXT resolution.
+import { parseGitLogWithStats, parseGitStatusOutput } from './git-parsing.service.js';
+
+type GitRouterDependencies = {
+  fileSystem: typeof import('node:fs/promises');
+  spawnProcess: typeof import('cross-spawn').default;
+  resolveProjectPathById(projectId: string): string | null;
+  queryClaude: ProviderRunFunction;
+  queryCursor: ProviderRunFunction;
+};
+
+/** Creates Git routes around explicit repository, filesystem, subprocess, and AI adapters. */
+export function createGitRouter(dependencies: GitRouterDependencies): express.Router {
+const fs = dependencies.fileSystem;
+const spawn = dependencies.spawnProcess;
+const projectsDb = { getProjectPathById: dependencies.resolveProjectPathById };
+const queryClaudeSDK = dependencies.queryClaude;
+const spawnCursor = dependencies.queryCursor;
 const router = express.Router();
 const COMMIT_DIFF_CHARACTER_LIMIT = 500_000;
 
@@ -162,13 +179,30 @@ async function validateGitRepository(projectPath) {
     const { stdout: insideWorkTreeOutput } = await spawnAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: projectPath });
     const isInsideWorkTree = insideWorkTreeOutput.trim() === 'true';
     if (!isInsideWorkTree) {
-      throw new Error('Not inside a git work tree');
+      throw new AppError('Not a git repository', {
+        code: 'NOT_A_GIT_REPOSITORY',
+        statusCode: 400,
+      });
     }
 
     // Ensure git can resolve the repository root for this directory.
     await spawnAsync('git', ['rev-parse', '--show-toplevel'], { cwd: projectPath });
-  } catch {
-    throw new Error('Not a git repository. This directory does not contain a .git folder. Initialize a git repository with "git init" to use source control features.');
+  } catch (error) {
+    if (
+      error instanceof AppError
+      && error.code === 'NOT_A_GIT_REPOSITORY'
+    ) {
+      throw error;
+    }
+
+    if (/not a git repository/i.test(getGitErrorDetails(error))) {
+      throw new AppError('Not a git repository. Initialize a git repository with "git init" to use source control features.', {
+        code: 'NOT_A_GIT_REPOSITORY',
+        statusCode: 400,
+      });
+    }
+
+    throw error;
   }
 }
 
@@ -293,77 +327,7 @@ async function resolveRepositoryFilePath(projectPath, filePath) {
   };
 }
 
-// Get git status for a project
-/**
- * Parses `git status --porcelain=v1 -z` output into the response shape the
- * git panel consumes. NUL-separated entries carry no path quoting, so names
- * with spaces/unicode survive intact (the plain porcelain output quotes and
- * escapes them, which broke the old line-based parser).
- *
- * `staged` lists paths with index-side changes. The UI renders its "Staged"
- * section from this list so it always mirrors the real git index (including
- * files staged outside the app, e.g. via VSCode or the terminal).
- *
- * Exported for tests.
- */
-export function parseGitStatusOutput(statusOutput) {
-  const modified = [];
-  const added = [];
-  const deleted = [];
-  const untracked = [];
-  const staged = [];
-
-  const statusEntries = statusOutput.split('\0');
-  for (let entryIndex = 0; entryIndex < statusEntries.length; entryIndex++) {
-    const entry = statusEntries[entryIndex];
-    if (!entry || entry.length < 4) continue;
-
-    // Porcelain v1: X = index (staged) status, Y = worktree (unstaged) status.
-    const indexStatus = entry[0];
-    const worktreeStatus = entry[1];
-    const file = entry.slice(3);
-
-    // Renames/copies carry the original path as the following NUL entry;
-    // the UI tracks the post-rename path only.
-    if (indexStatus === 'R' || indexStatus === 'C') {
-      entryIndex += 1;
-    }
-
-    if (indexStatus === '?') {
-      untracked.push(file);
-      continue;
-    }
-    if (indexStatus === '!') {
-      continue; // ignored files are never reported
-    }
-
-    const isConflict =
-      indexStatus === 'U' || worktreeStatus === 'U' ||
-      (indexStatus === 'A' && worktreeStatus === 'A') ||
-      (indexStatus === 'D' && worktreeStatus === 'D');
-    if (isConflict) {
-      // Merge conflicts must be resolved in the worktree first; surface them
-      // as modified and never as staged.
-      modified.push(file);
-      continue;
-    }
-
-    if (indexStatus !== ' ') {
-      staged.push(file);
-    }
-
-    if (indexStatus === 'D' || worktreeStatus === 'D') {
-      deleted.push(file);
-    } else if (indexStatus === 'A' || worktreeStatus === 'A') {
-      added.push(file);
-    } else {
-      modified.push(file);
-    }
-  }
-
-  return { modified, added, deleted, untracked, staged };
-}
-
+// Get Git status for a project; parsing is isolated in git-parsing.service.ts.
 router.get('/status', async (req, res) => {
   const { project } = req.query;
 
@@ -393,18 +357,55 @@ router.get('/status', async (req, res) => {
       staged
     });
   } catch (error) {
-    console.error('Git status error:', error);
+    // Case-insensitive so "Not a git repository..." from validateGitRepository
+    // matches; `notGitRepository` lets the UI offer a one-click `git init`.
+    const isNotGitRepository = error instanceof AppError && error.code === 'NOT_A_GIT_REPOSITORY';
+    // A project without a repository is an expected state, not a failure.
+    if (!isNotGitRepository) {
+      console.error('Git status error:', error);
+    }
     res.json({
-      error: error.message.includes('not a git repository') || error.message.includes('Project directory is not a git repository')
-        ? error.message
-        : 'Git operation failed',
-      details: error.message.includes('not a git repository') || error.message.includes('Project directory is not a git repository')
-        ? error.message
-        : `Failed to get git status: ${error.message}`
+      error: isNotGitRepository ? 'Not a git repository' : 'Git operation failed',
+      details: isNotGitRepository ? error.message : `Failed to get git status: ${error.message}`,
+      notGitRepository: isNotGitRepository
     });
   }
 });
 
+// Initialize a new git repository in the project directory
+router.post('/init', async (req, res) => {
+  const { project } = req.body;
+
+  if (!project) {
+    return res.status(400).json({ error: 'Project id is required' });
+  }
+
+  try {
+    const projectPath = await getActualProjectPath(project);
+
+    let isAlreadyRepository = false;
+    try {
+      await validateGitRepository(projectPath);
+      isAlreadyRepository = true;
+    } catch (error) {
+      if (!(error instanceof AppError) || error.code !== 'NOT_A_GIT_REPOSITORY') {
+        throw error;
+      }
+      // Not a repository yet — proceed with git init.
+    }
+
+    if (isAlreadyRepository) {
+      return res.json({ success: true, output: 'Repository already initialized' });
+    }
+
+    const { stdout, stderr } = await spawnAsync('git', ['init'], { cwd: projectPath });
+    res.json({ success: true, output: stdout.trim() || stderr.trim() });
+  } catch (error) {
+    console.error('Git init error:', error);
+    res.json({ success: false, error: error.stderr?.trim() || error.message });
+  }
+});
+
 // Get diff for a specific file
 router.get('/diff', async (req, res) => {
   const { project, file } = req.query;
@@ -864,51 +865,8 @@ router.post('/delete-branch', async (req, res) => {
 
 // Fields are joined with the ASCII unit separator so pipes (or anything else
 // typed into a commit subject) cannot break parsing.
-const GIT_LOG_FIELD_SEPARATOR = '\u001f';
 const GIT_LOG_PRETTY_FORMAT = '%H%x1f%P%x1f%D%x1f%an%x1f%ae%x1f%ad%x1f%s';
 
-/**
- * Parses `git log --shortstat` output produced with GIT_LOG_PRETTY_FORMAT.
- *
- * Each commit is one format line (hash, parent hashes, ref decorations,
- * author, email, date, subject) optionally followed by its `--shortstat`
- * summary line ("N files changed, ..."). Parents and refs feed the commit
- * graph rendered by the History view; merge commits carry no shortstat line,
- * so their `stats` stays empty.
- *
- * Exported for tests.
- */
-export function parseGitLogWithStats(stdout) {
-  const commits = [];
-
-  for (const rawLine of stdout.split('\n')) {
-    const line = rawLine.trimEnd();
-    if (!line.trim()) continue;
-
-    if (line.includes(GIT_LOG_FIELD_SEPARATOR)) {
-      const [hash, parents, refs, author, email, date, ...messageParts] = line.split(GIT_LOG_FIELD_SEPARATOR);
-      commits.push({
-        hash,
-        parents: parents ? parents.split(' ').filter(Boolean) : [],
-        // `%D` decorations, e.g. "HEAD -> main", "origin/main", "tag: v1.0".
-        refs: refs ? refs.split(', ').filter(Boolean) : [],
-        author,
-        email,
-        date,
-        message: messageParts.join(GIT_LOG_FIELD_SEPARATOR),
-        stats: ''
-      });
-      continue;
-    }
-
-    if (commits.length > 0 && /files? changed/.test(line)) {
-      commits[commits.length - 1].stats = line.trim();
-    }
-  }
-
-  return commits;
-}
-
 // Get recent commits (across all branches, in graph order)
 router.get('/commits', async (req, res) => {
   const { project, limit = 10 } = req.query;
@@ -1631,4 +1589,5 @@ router.post('/delete-untracked', async (req, res) => {
   }
 });
 
-export default router;
+return router;
+}

package/server/modules/git/index.ts

@@ -0,0 +1,2 @@
+// createGitModule: used by the server entrypoint to assemble Git routes with provider runtimes.
+export { createGitModule } from './git.module.js';

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

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import { EventEmitter, once } from 'node:events';
+import type { AddressInfo } from 'node:net';
+import { PassThrough } from 'node:stream';
+import test from 'node:test';
+
+import express from 'express';
+
+import { createGitRouter } from '@/modules/git/git.routes.js';
+
+test('git init does not run when repository validation fails for an execution error', 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(() => child.emit('error', Object.assign(new Error('permission denied'), {
+      code: 'EACCES',
+    })));
+    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/init`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ project: 'project-1' }),
+    });
+    const body = await response.json() as { success: boolean; error: string };
+    assert.equal(body.success, false);
+    assert.match(body.error, /permission denied/);
+  } finally {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  }
+
+  assert.deepEqual(commands, [['rev-parse', '--is-inside-work-tree']]);
+});

package/server/{routes/git.test.js → modules/git/tests/git.test.ts}

@@ -1,11 +1,11 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 
-import { parseGitLogWithStats, parseGitStatusOutput } from './git.js';
+import { parseGitLogWithStats, parseGitStatusOutput } from '../git-parsing.service.js';
 
 // Builds `git status --porcelain=v1 -z` output: NUL-separated entries with a
 // trailing NUL, exactly as git emits it.
-const porcelain = (...entries) => entries.join('\0') + '\0';
+const porcelain = (...entries: string[]) => entries.join('\0') + '\0';
 
 test('parseGitStatusOutput buckets files and reports index-side staging', () => {
   const output = porcelain(
@@ -69,7 +69,7 @@ test('parseGitStatusOutput handles empty output', () => {
 
 // Builds one `git log --pretty=format:%H%x1f%P%x1f%D%x1f%an%x1f%ae%x1f%ad%x1f%s` line.
 const US = '';
-const logLine = (hash, parents, refs, subject) =>
+const logLine = (hash: string, parents: string, refs: string, subject: string) =>
   [hash, parents, refs, 'Alice', 'a@x.com', '2026-07-06T10:00:00+03:00', subject].join(US);
 
 test('parseGitLogWithStats parses commits with parents, refs, and shortstat lines', () => {

package/server/modules/notifications/index.ts

@@ -1,8 +1,13 @@
 export {
+  // Used by notification tests and delivery workflows to create channel payloads.
   buildNotificationPayload,
+  // Used by provider runtimes and Settings to create normalized notification events.
   createNotificationEvent,
+  // Used by provider runtimes and Settings to deliver events through enabled channels.
   notifyUserIfEnabled,
+  // Used by provider runtimes to report failed agent runs.
   notifyRunFailed,
+  // Used by provider runtimes to report stopped or completed agent runs.
   notifyRunStopped,
 } from '@/modules/notifications/services/notification-orchestrator.service.js';
 export {
@@ -11,3 +16,7 @@ export {
   unregisterDesktopNotificationClient,
 } from '@/modules/notifications/services/desktop-notification-clients.service.js';
 export { handleDesktopNotificationsConnection } from '@/modules/notifications/websocket/desktop-notifications-websocket.service.js';
+// getPublicKey: used by Settings to expose the Web Push subscription key.
+export { getPublicKey } from './vapid-keys.service.js';
+// configureWebPush: used by the server entrypoint during notification startup.
+export { configureWebPush } from './vapid-keys.service.js';

package/server/modules/notifications/tests/notification-orchestrator.integration.test.ts

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import {
+  closeConnection,
+  initializeDatabase,
+  sessionsDb,
+} from '@/modules/database/index.js';
+
+import {
+  buildNotificationPayload,
+} from '../services/notification-orchestrator.service.js';
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const temporaryDirectory = await mkdtemp(path.join(tmpdir(), 'notification-orchestrator-'));
+  const databasePath = path.join(temporaryDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  await initializeDatabase();
+
+  try {
+    await runTest();
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(temporaryDirectory, { recursive: true, force: true });
+  }
+}
+
+test('notification payload uses the app session id for a provider session id', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-session-1', 'claude', '/workspace/demo');
+    sessionsDb.assignProviderSessionId('app-session-1', 'claude-native-1');
+
+    const payload = buildNotificationPayload({
+      provider: 'claude',
+      sessionId: 'claude-native-1',
+      kind: 'stop',
+      code: 'run.stopped',
+      meta: { stopReason: 'completed' },
+    });
+
+    assert.equal(payload.data.sessionId, 'app-session-1');
+    assert.match(payload.data.tag, /app-session-1/);
+  });
+});

package/server/{services/vapid-keys.js → modules/notifications/vapid-keys.service.ts}

@@ -1,5 +1,7 @@
+// @ts-nocheck -- web-push does not provide declarations in this project.
 import webPush from 'web-push';
-import { getConnection } from '../modules/database/connection.js';
+
+import { getConnection } from '../database/index.js';
 
 let cachedKeys = null;
 const db = getConnection();

package/server/modules/plugins/index.ts

@@ -0,0 +1,9 @@
+// pluginsRoutes: used by the server entrypoint to mount protected plugin-management endpoints.
+export { pluginsRoutes } from './plugins.module.js';
+
+// startEnabledPluginServers: used by the server entrypoint to start enabled plugin subprocesses.
+export { startEnabledPluginServers } from './plugin-process.service.js';
+// stopAllPlugins: used by the server entrypoint to stop plugin subprocesses during shutdown.
+export { stopAllPlugins } from './plugin-process.service.js';
+// getPluginPort: used by WebSocket setup in the server entrypoint to proxy plugin connections.
+export { getPluginPort } from './plugin-process.service.js';

package/server/{utils/plugin-process-manager.js → modules/plugins/plugin-process.service.ts}

@@ -1,8 +1,10 @@
+// @ts-nocheck -- subprocess records are narrowed at the Plugins composition boundary.
 import path from 'path';
 
 // cross-spawn: drop-in spawn with Windows .cmd/PATHEXT resolution.
 import spawn from 'cross-spawn';
-import { scanPlugins, getPluginsConfig, getPluginDir } from './plugin-loader.js';
+
+import { scanPlugins, getPluginsConfig, getPluginDir } from './plugin-registry.service.js';
 
 // Map<pluginName, { process, port }>
 const runningPlugins = new Map();

package/server/{utils/plugin-loader.js → modules/plugins/plugin-registry.service.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck -- the registry's dynamic manifest schema is narrowed by Plugins service adapters.
 import fs from 'fs';
 import path from 'path';
 import os from 'os';

package/server/modules/plugins/plugins.module.ts

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import mime from 'mime-types';
+
+import {
+  getPluginDir, getPluginsConfig, getPluginsDir, installPluginFromGit,
+  resolvePluginAssetPath, savePluginsConfig, scanPlugins, uninstallPlugin, updatePluginFromGit,
+} from './plugin-registry.service.js';
+import {
+  getPluginPort, isPluginRunning, startPluginServer, stopPluginServer,
+} from './plugin-process.service.js';
+import { createPluginsRouter } from './plugins.routes.js';
+import { createPluginsService } from './plugins.service.js';
+
+const pluginsService = createPluginsService({
+  scanPlugins, readConfig: getPluginsConfig, saveConfig: savePluginsConfig,
+  getPluginDirectory: getPluginDir, getPluginsDirectory: getPluginsDir,
+  resolveAsset: resolvePluginAssetPath,
+  assetIsFile: (assetPath) => { try { return fs.statSync(assetPath).isFile(); } catch { return false; } },
+  contentType: (assetPath) => mime.lookup(assetPath) || 'application/octet-stream',
+  install: installPluginFromGit,
+  update: updatePluginFromGit,
+  uninstall: async (pluginName) => { await uninstallPlugin(pluginName); },
+  startServer: startPluginServer,
+  stopServer: async (pluginName) => { await stopPluginServer(pluginName); },
+  getServerPort: getPluginPort, isServerRunning: isPluginRunning,
+  joinPath: path.join,
+  logError: (message, error) => console.error(message, error),
+});
+
+/** Plugin router assembled with filesystem, loader, and process adapters. */
+export const pluginsRoutes = createPluginsRouter(pluginsService);

package/server/modules/plugins/plugins.routes.ts

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import http from 'node:http';
+
+import express from 'express';
+
+import type { createPluginsService } from './plugins.service.js';
+
+function wildcardPath(req: express.Request): string {
+  return ((req.params as Record<string, string>)['0'] ?? '').trim();
+}
+
+function routeParameter(value: string | string[]): string {
+  return Array.isArray(value) ? value[0] ?? '' : value;
+}
+
+/** Creates plugin routes; transport streaming remains here while decisions live in the service. */
+export function createPluginsRouter(service: ReturnType<typeof createPluginsService>): express.Router {
+  const router = express.Router();
+  const respond = (operation: (req: express.Request) => unknown | Promise<unknown>) =>
+    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+      try { res.json(await operation(req)); } catch (error) { next(error); }
+    };
+
+  router.get('/', respond(() => service.list()));
+  router.get('/:name/manifest', respond((req) => service.getManifest(routeParameter(req.params.name))));
+  router.get('/:name/assets/*', async (req, res, next) => {
+    try {
+      const asset = service.resolveAsset(routeParameter(req.params.name), wildcardPath(req));
+      res.setHeader('Content-Type', asset.contentType);
+      res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
+      const stream = fs.createReadStream(asset.path);
+      stream.on('error', next);
+      stream.pipe(res);
+    } catch (error) { next(error); }
+  });
+  router.put('/:name/enable', respond((req) => service.setEnabled(routeParameter(req.params.name), req.body?.enabled)));
+  router.post('/install', respond((req) => service.install(req.body?.url)));
+  router.post('/:name/update', respond((req) => service.update(routeParameter(req.params.name))));
+  router.all('/:name/rpc/*', async (req, res, next) => {
+    try {
+      const { port, secrets } = await service.prepareRpc(routeParameter(req.params.name));
+      const headers: Record<string, string> = {
+        'content-type': String(req.headers['content-type'] ?? 'application/json'),
+      };
+      for (const [key, value] of Object.entries(secrets)) {
+        headers[`x-plugin-secret-${key.toLowerCase()}`] = String(value);
+      }
+      const query = req.url.includes('?') ? `?${req.url.split('?').slice(1).join('?')}` : '';
+      const proxyRequest = http.request({
+        hostname: '127.0.0.1', port, path: `/${wildcardPath(req)}${query}`, method: req.method, headers,
+      }, (proxyResponse) => {
+        res.writeHead(proxyResponse.statusCode ?? 502, proxyResponse.headers);
+        proxyResponse.pipe(res);
+      });
+      proxyRequest.on('error', next);
+      if (req.headers['content-length'] && req.body !== undefined) {
+        const body = JSON.stringify(req.body);
+        proxyRequest.setHeader('content-length', Buffer.byteLength(body));
+        proxyRequest.write(body);
+      }
+      proxyRequest.end();
+    } catch (error) { next(error); }
+  });
+  router.delete('/:name', respond((req) => service.uninstall(routeParameter(req.params.name))));
+  return router;
+}