@cloudcli-ai/cloudcli 1.37.1 → 1.37.3

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

package/server/modules/projects/services/project-delete.service.ts

@@ -43,11 +43,23 @@ async function unlinkJsonlIfExists(filePath: string): Promise<void> {
  */
 export async function deleteSessionJsonlFilesForProjectPath(projectPath: string): Promise<void> {
   const sessions = sessionsDb.getSessionsByProjectPathIncludingArchived(projectPath);
-  const paths = uniqueJsonlPathsFromSessions(sessions);
+  // Including the transcripts a session has left behind: editing a message on
+  // a provider that rewinds by branching moves the session onto a copy, and
+  // the row stops pointing at the file the replaced turns are still in.
+  const paths = uniqueJsonlPathsFromSessions([
+    ...sessions,
+    ...sessions.flatMap((session) => sessionsDb
+      .getSupersededTranscriptPaths(session.session_id)
+      .map((jsonl_path) => ({ jsonl_path }))),
+  ]);
 
   for (const filePath of paths) {
     await unlinkJsonlIfExists(filePath);
   }
+
+  for (const session of sessions) {
+    sessionsDb.clearSupersededProviderSessions(session.session_id);
+  }
 }
 
 /**

package/server/modules/projects/services/project-star.service.ts

@@ -40,7 +40,7 @@ export function applyLegacyStarredProjectIds(projectIds: string[]): ApplyLegacyS
       continue;
     }
 
-    if (Boolean(project.isStarred)) {
+    if (project.isStarred) {
       continue;
     }
 
@@ -71,7 +71,7 @@ export function toggleProjectStar(projectId: string): ToggleProjectStarResult {
     });
   }
 
-  const nextStarredState = !Boolean(project.isStarred);
+  const nextStarredState = !project.isStarred;
   projectsDb.updateProjectIsStarredById(normalizedProjectId, nextStarredState);
 
   return { isStarred: nextStarredState };

package/server/modules/providers/index.ts

@@ -6,5 +6,9 @@ export { providerRuntimeService } from './services/provider-runtime.service.js';
 // providerModelsService: used by Commands to list models and resolve the active session model.
 export { providerModelsService } from './services/provider-models.service.js';
 
+// sessionsService: used by the websocket module's chat gateway to resolve an
+// edited message's resume point, which only the providers module can read.
+export { sessionsService } from './services/sessions.service.js';
+
 export { initializeSessionsWatcher } from './services/sessions-watcher.service.js';
 export { closeSessionsWatcher } from './services/sessions-watcher.service.js';

package/server/modules/providers/list/claude/claude-auth.provider.ts

@@ -25,7 +25,9 @@ export class ClaudeProviderAuth implements IProviderAuth {
    * Checks whether the Claude Code CLI is available on this host.
    */
   private checkInstalled(): boolean {
-    const cliPath = resolveClaudeCodeExecutablePath(process.env.CLAUDE_CLI_PATH);
+    // cross-spawn resolves shims and PATHEXT itself, so the bare command is a
+    // usable fallback here even where the SDK's raw spawn could not use it.
+    const cliPath = resolveClaudeCodeExecutablePath(process.env.CLAUDE_CLI_PATH) ?? 'claude';
     try {
       spawn.sync(cliPath, ['--version'], { stdio: 'ignore', timeout: 5000 });
       return true;
@@ -126,6 +128,24 @@ export class ClaudeProviderAuth implements IProviderAuth {
           };
         }
 
+        // `accessToken` is short-lived (hours). Claude Code renews it silently
+        // from `refreshToken` on the next CLI invocation, so an expired access
+        // token alongside a live refresh token is still a working login. Before
+        // this check, a still-signed-in account read as "login has expired"
+        // until something else happened to run the CLI — which is why opening
+        // the Shell tab and coming back made Settings flip to Connected.
+        const refreshToken = readOptionalString(oauth?.refreshToken);
+        const refreshTokenExpiresAt = typeof oauth?.refreshTokenExpiresAt === 'number'
+          ? oauth.refreshTokenExpiresAt
+          : undefined;
+        if (refreshToken && (!refreshTokenExpiresAt || Date.now() < refreshTokenExpiresAt)) {
+          return {
+            authenticated: true,
+            email,
+            method: 'credentials_file',
+          };
+        }
+
         return {
           authenticated: false,
           email: null,

package/server/modules/providers/list/claude/claude-fork.provider.ts

@@ -0,0 +1,57 @@
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+
+import { forkSession as forkClaudeSession } from '@anthropic-ai/claude-agent-sdk';
+
+import type { IProviderFork } from '@/shared/interfaces.js';
+import { AppError } from '@/shared/utils.js';
+
+/**
+ * Branches a Claude conversation by copying its transcript into a new session
+ * file.
+ *
+ * The SDK owns this: it remaps every message uuid and rewrites the parentUuid
+ * chain, which is what makes the copy resumable rather than just a duplicate
+ * file. `upToMessageId` is inclusive of the row it names.
+ */
+export class ClaudeForkProvider implements IProviderFork {
+  async forkSession(input: {
+    providerSessionId: string;
+    jsonlPath: string;
+    projectPath: string;
+    upToAnchorId?: string;
+    title?: string;
+  }): Promise<{ providerSessionId: string; jsonlPath: string }> {
+    // `dir` is the session's working directory, which the SDK encodes into the
+    // `~/.claude/projects/<encoded>` folder name itself — passing that folder
+    // makes it encode an already-encoded path and find nothing.
+    const { sessionId } = await forkClaudeSession(input.providerSessionId, {
+      dir: input.projectPath,
+      upToMessageId: input.upToAnchorId,
+      title: input.title,
+    });
+
+    if (!sessionId) {
+      throw new AppError('Claude did not return a session id for the fork.', {
+        code: 'FORK_FAILED',
+        statusCode: 502,
+      });
+    }
+
+    // Confirmed rather than assumed: the caller is about to write a database
+    // row claiming this file exists, and a half-created row would show up in
+    // the sidebar as a session that can never be opened.
+    // The fork lands beside the transcript it was copied from.
+    const forkedPath = path.join(path.dirname(input.jsonlPath), `${sessionId}.jsonl`);
+    try {
+      await stat(forkedPath);
+    } catch {
+      throw new AppError('Claude reported a fork but wrote no transcript for it.', {
+        code: 'FORK_FAILED',
+        statusCode: 502,
+      });
+    }
+
+    return { providerSessionId: sessionId, jsonlPath: forkedPath };
+  }
+}

package/server/modules/providers/list/claude/claude-models.provider.ts

@@ -9,6 +9,19 @@ import type {
 } from '@/shared/types.js';
 import { buildDefaultProviderCurrentActiveModel } from '@/shared/utils.js';
 
+/**
+ * Ultracode is not one of the SDK's reasoning-effort levels. Selecting it runs the turn at
+ * `xhigh` effort with standing dynamic-workflow orchestration, which the Claude runtime
+ * translates into the session-scoped `ultracode` setting. It is therefore only offered on
+ * models this catalog already marks as xhigh-capable.
+ */
+export const CLAUDE_ULTRACODE_EFFORT = 'ultracode';
+
+const ULTRACODE_EFFORT_OPTION = {
+  value: CLAUDE_ULTRACODE_EFFORT,
+  description: 'Highest effort plus standing workflow orchestration.',
+};
+
 export const CLAUDE_PREDEFINED_MODELS: ProviderModelsDefinition = {
   OPTIONS: [
     {
@@ -37,6 +50,7 @@ export const CLAUDE_PREDEFINED_MODELS: ProviderModelsDefinition = {
           { value: 'high' },
           { value: 'xhigh' },
           { value: 'max' },
+          ULTRACODE_EFFORT_OPTION,
         ],
       },
     },
@@ -52,6 +66,7 @@ export const CLAUDE_PREDEFINED_MODELS: ProviderModelsDefinition = {
           { value: 'high' },
           { value: 'xhigh' },
           { value: 'max' },
+          ULTRACODE_EFFORT_OPTION,
         ],
       },
     },
@@ -67,6 +82,7 @@ export const CLAUDE_PREDEFINED_MODELS: ProviderModelsDefinition = {
           { value: 'high' },
           { value: 'xhigh' },
           { value: 'max' },
+          ULTRACODE_EFFORT_OPTION,
         ],
       },
     },
@@ -82,6 +98,7 @@ export const CLAUDE_PREDEFINED_MODELS: ProviderModelsDefinition = {
           { value: 'high' },
           { value: 'xhigh' },
           { value: 'max' },
+          ULTRACODE_EFFORT_OPTION,
         ],
       },
     },
@@ -97,6 +114,7 @@ export const CLAUDE_PREDEFINED_MODELS: ProviderModelsDefinition = {
           { value: 'high' },
           { value: 'xhigh' },
           { value: 'max' },
+          ULTRACODE_EFFORT_OPTION,
         ],
       },
     },
@@ -112,6 +130,7 @@ export const CLAUDE_PREDEFINED_MODELS: ProviderModelsDefinition = {
           { value: 'high' },
           { value: 'xhigh' },
           { value: 'max' },
+          ULTRACODE_EFFORT_OPTION,
         ],
       },
     },
@@ -132,6 +151,7 @@ export const CLAUDE_PREDEFINED_MODELS: ProviderModelsDefinition = {
           { value: 'high' },
           { value: 'xhigh' },
           { value: 'max' },
+          ULTRACODE_EFFORT_OPTION,
         ],
       },
     },
@@ -166,7 +186,15 @@ const ANSI_PATTERN = new RegExp(
   'g',
 );
 
-const extractClaudeEventModel = (event: ClaudeInitEvent, sessionId: string): string | null => {
+/**
+ * Claude Code stamps locally-synthesized rows (API-error placeholders and the
+ * like) with `model: "<synthetic>"`. Angle-bracketed values are placeholders,
+ * never real model ids, and must not be surfaced as the session's model.
+ */
+const isPlaceholderModel = (model: string): boolean => model.startsWith('<') && model.endsWith('>');
+
+/** Exported for tests. */
+export const extractClaudeEventModel = (event: ClaudeInitEvent, sessionId: string): string | null => {
   const eventSessionId = event.sessionId ?? event.session_id;
   if (eventSessionId && eventSessionId !== sessionId) {
     return null;
@@ -178,12 +206,12 @@ const extractClaudeEventModel = (event: ClaudeInitEvent, sessionId: string): str
   }
 
   const directModel = event.model?.trim();
-  if (directModel) {
+  if (directModel && !isPlaceholderModel(directModel)) {
     return directModel;
   }
 
   const messageModel = event.message?.model?.trim();
-  return messageModel || null;
+  return messageModel && !isPlaceholderModel(messageModel) ? messageModel : null;
 };
 
 const stripAnsi = (value: string): string => value.replace(ANSI_PATTERN, '');
@@ -199,13 +227,15 @@ const extractClaudeModelFromTextContent = (content: string): string | null => {
   if (localCommandStdout !== null) {
     const cleanedStdout = stripAnsi(localCommandStdout).replace(/\s+/g, ' ').trim();
     const changedModel = /(?:set|changed|switched)\s+model\s+to\s+(.+?)\.?$/i.exec(cleanedStdout);
-    if (changedModel?.[1]?.trim()) {
-      return changedModel[1].trim();
+    const stdoutModel = changedModel?.[1]?.trim();
+    // A placeholder stdout hit must not shadow a real <model> tag further down.
+    if (stdoutModel && !isPlaceholderModel(stdoutModel)) {
+      return stdoutModel;
     }
   }
 
   const modelTag = extractTaggedContent(content, 'model')?.trim();
-  return modelTag || null;
+  return modelTag && !isPlaceholderModel(modelTag) ? modelTag : null;
 };
 
 const extractClaudeModelFromMessageContent = (content: unknown): string | null => {
@@ -222,6 +252,8 @@ const extractClaudeModelFromMessageContent = (content: unknown): string | null =
       continue;
     }
 
+    // extractClaudeModelFromTextContent rejects placeholders, so a placeholder
+    // part yields null here and a later part can still supply the real model.
     const model = extractClaudeModelFromTextContent(part.text);
     if (model) {
       return model;