@cloudcli-ai/cloudcli 1.37.3 → 1.37.4

package/server/modules/providers/services/claude-settings-permissions.service.ts

@@ -0,0 +1,127 @@
+import { readFile, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { readObjectRecord, readStringArray } from '@/shared/utils.js';
+
+/**
+ * The permission rules one Claude settings file contributes.
+ *
+ * `status` says whether the rules could be read at all: `missing` means there
+ * is no such file, `invalid` means it exists but the CLI would not load it
+ * either (unreadable, over its size cap, or not a JSON object). Both report
+ * empty rule lists rather than failing the request, so one bad file never hides
+ * the others.
+ */
+type ClaudeSettingsPermissionSource = {
+  scope: 'user' | 'managed';
+  path: string;
+  status: 'ok' | 'missing' | 'invalid';
+  allow: string[];
+  deny: string[];
+  ask: string[];
+};
+
+/**
+ * The user's own settings file. The CLI reads it from `CLAUDE_CONFIG_DIR` when
+ * that is set, and the server forwards its whole env to every CLI it spawns,
+ * so the same override has to apply here.
+ */
+const userSettingsPath = (): string => {
+  const configDirectory = process.env.CLAUDE_CONFIG_DIR?.trim();
+  const baseDirectory = configDirectory && path.isAbsolute(configDirectory)
+    ? configDirectory
+    : path.join(os.homedir(), '.claude');
+  return path.join(baseDirectory, 'settings.json');
+};
+
+/** The administrator-managed settings file, at the fixed path the CLI uses per OS. */
+const managedSettingsPath = (): string => {
+  if (process.platform === 'darwin') {
+    return '/Library/Application Support/ClaudeCode/managed-settings.json';
+  }
+  if (process.platform === 'win32') {
+    return 'C:\\Program Files\\ClaudeCode\\managed-settings.json';
+  }
+  return '/etc/claude-code/managed-settings.json';
+};
+
+// The CLI refuses to load a settings file larger than this (2 MB).
+const MAX_SETTINGS_FILE_BYTES = 2 * 1024 * 1024;
+
+/**
+ * Decodes a settings file the way the CLI does: UTF-16LE when it starts with
+ * that byte order mark, UTF-8 otherwise, without the leading BOM. Windows
+ * editors and PowerShell often save one, and the CLI still applies such files.
+ */
+const decodeSettingsFile = (bytes: Buffer): string => {
+  const isUtf16LittleEndian = bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe;
+  return bytes.toString(isUtf16LittleEndian ? 'utf16le' : 'utf8').replace(/^\uFEFF/, '');
+};
+
+/** Keeps non-empty string rules only, without duplicates, in file order. */
+const readRuleList = (value: unknown): string[] => [
+  ...new Set((readStringArray(value) ?? []).map((rule) => rule.trim()).filter(Boolean)),
+];
+
+async function readPermissionSource(
+  scope: ClaudeSettingsPermissionSource['scope'],
+  filePath: string,
+): Promise<ClaudeSettingsPermissionSource> {
+  const empty = { scope, path: filePath, allow: [], deny: [], ask: [] };
+
+  let content: string;
+  try {
+    if ((await stat(filePath)).size > MAX_SETTINGS_FILE_BYTES) {
+      return { ...empty, status: 'invalid' };
+    }
+    content = decodeSettingsFile(await readFile(filePath));
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    return { ...empty, status: code === 'ENOENT' || code === 'ENOTDIR' ? 'missing' : 'invalid' };
+  }
+
+  // The CLI loads an empty or whitespace-only file as `{}`.
+  if (!content.trim()) {
+    return { ...empty, status: 'ok' };
+  }
+
+  let settings: Record<string, unknown> | null;
+  try {
+    settings = readObjectRecord(JSON.parse(content));
+  } catch {
+    settings = null;
+  }
+  if (!settings) {
+    return { ...empty, status: 'invalid' };
+  }
+
+  // A file without a `permissions` block is perfectly valid; it just adds no rules.
+  const permissions = readObjectRecord(settings.permissions) ?? {};
+  return {
+    ...empty,
+    status: 'ok',
+    allow: readRuleList(permissions.allow),
+    deny: readRuleList(permissions.deny),
+    ask: readRuleList(permissions.ask),
+  };
+}
+
+/**
+ * Read-only view of the permission rules the Claude CLI applies from its own
+ * settings files, on top of the allowed/blocked lists CloudCLI passes it.
+ *
+ * Used by provider.routes.ts for the Claude permissions panel in Settings.
+ * Project-level files are left out on purpose: the panel has no project, and
+ * those files only apply to chats started inside their project. CloudCLI never
+ * writes to any of these files.
+ */
+export const claudeSettingsPermissionsService = {
+  /** `managedPath` is only overridden by tests, which cannot write to the system path. */
+  async listRuleSources(managedPath: string = managedSettingsPath()): Promise<ClaudeSettingsPermissionSource[]> {
+    return Promise.all([
+      readPermissionSource('user', userSettingsPath()),
+      readPermissionSource('managed', managedPath),
+    ]);
+  },
+};

package/server/modules/providers/services/provider-capabilities.service.ts

@@ -25,6 +25,14 @@ type ProviderCapabilities = {
   supportsTokenUsage: boolean;
   /** Whether the provider runtime can accept model-level reasoning effort. */
   supportsEffort: boolean;
+  /**
+   * Reasoning-effort levels the runtime can pass on, weakest first, and so the
+   * levels a custom model-library entry may declare. Empty exactly when
+   * `supportsEffort` is false. Covers every level a predefined model declares
+   * (a providers test enforces this) and, unlike the model catalog, does not
+   * depend on which upstream providers this machine has connected.
+   */
+  effortLevels: string[];
   /**
    * Whether an already-sent message can be replaced, which requires the
    * provider to re-run a conversation truncated at a chosen point.
@@ -53,6 +61,7 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     supportsPermissionRequests: true,
     supportsTokenUsage: true,
     supportsEffort: true,
+    effortLevels: ['low', 'medium', 'high', 'xhigh', 'max', 'ultracode'],
     // `resumeSessionAt` re-runs a conversation truncated at a message, and
     // `forkSession` copies a transcript prefix into a new session file.
     supportsMessageEditing: true,
@@ -68,6 +77,7 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     supportsPermissionRequests: false,
     supportsTokenUsage: false,
     supportsEffort: false,
+    effortLevels: [],
     supportsMessageEditing: false,
     supportsSessionForking: false,
   },
@@ -81,6 +91,7 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     supportsPermissionRequests: false,
     supportsTokenUsage: true,
     supportsEffort: true,
+    effortLevels: ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
     // Not from the Codex SDK, which only starts and resumes threads: both ride
     // the same CLI's `app-server` protocol, whose `thread/fork` copies a
     // thread up to a chosen turn. Editing is that fork plus a new prompt,
@@ -101,13 +112,18 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     supportsPermissionRequests: false,
     supportsTokenUsage: true,
     supportsEffort: true,
+    // Passed on as OpenCode's `--variant`. `thinking` (MiniMax's on/off
+    // variant, paired with `none`) is not a strength, so it sorts last.
+    effortLevels: ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'thinking'],
     supportsMessageEditing: false,
     supportsSessionForking: false,
   },
 };
 
 /**
- * Application service exposing the provider capability matrix.
+ * Application service exposing the provider capability matrix. Used by the
+ * Providers routes (the capabilities endpoints) and by the Providers model
+ * service, which reads `effortLevels` to validate custom-model effort.
  */
 export const providerCapabilitiesService = {
   getProviderCapabilities(provider: LLMProvider): ProviderCapabilities {

package/server/modules/providers/services/provider-models.service.ts

@@ -1,5 +1,6 @@
 import { providerModelsDb, sessionsDb } from '@/modules/database/index.js';
 import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import { providerCapabilitiesService } from '@/modules/providers/services/provider-capabilities.service.js';
 import type { IProvider } from '@/shared/interfaces.js';
 import type {
   CustomProviderModelInput,
@@ -36,6 +37,15 @@ type ProviderModelsServiceDependencies = {
   sessions?: ProviderModelsSessionStore;
 };
 
+/**
+ * Converts a stored custom row into a catalog option.
+ *
+ * `effort` is emitted in the same shape predefined models use, so the composer
+ * and every runtime's effort validation treat declared levels identically.
+ * Rows without declared levels omit `effort` on purpose: the composer then
+ * hides Reasoning and runtimes send no effort, instead of guessing levels the
+ * model might reject.
+ */
 const toCustomProviderModelOption = (
   record: CustomProviderModelRecord,
 ): ProviderModelOption => ({
@@ -43,9 +53,32 @@ const toCustomProviderModelOption = (
   label: record.model,
   recordId: record.recordId,
   isCustom: true,
+  ...(record.effort
+    ? {
+      effort: {
+        ...(record.effort.default ? { default: record.effort.default } : {}),
+        values: record.effort.values.map((value) => ({ value })),
+      },
+    }
+    : {}),
 });
 
+/**
+ * Effort levels a custom model of this provider may declare, weakest first:
+ * the levels its runtime can pass on, from the capability matrix. Empty
+ * (Cursor) means no effort support at all.
+ *
+ * Deliberately not derived from the predefined models: OpenCode narrows its
+ * catalog to the upstream providers this machine has connected, and only its
+ * OpenCode Go models declare effort, so a catalog-derived set would vanish for
+ * Zen, Anthropic, or OpenAI users and change with unrelated credentials.
+ */
+const readCustomModelEffortLevels = (provider: LLMProvider): string[] => (
+  providerCapabilitiesService.getProviderCapabilities(provider).effortLevels
+);
+
 const mergeProviderModels = (
+  provider: LLMProvider,
   predefined: ProviderModelsDefinition,
   custom: CustomProviderModelRecord[],
 ): ProviderModelsDefinition => {
@@ -55,14 +88,46 @@ const mergeProviderModels = (
       ...custom.map(toCustomProviderModelOption),
     ],
     DEFAULT: predefined.DEFAULT,
+    // Copied so no caller can mutate the shared capability matrix.
+    EFFORT_LEVELS: [...readCustomModelEffortLevels(provider)],
   };
 };
 
 const normalizeCustomModelInput = (input: CustomProviderModelInput): CustomProviderModelInput => ({
   id: input.id.trim(),
   model: input.model.trim(),
+  ...(input.effort === undefined ? {} : { effort: input.effort }),
 });
 
+const assertEffortLevelsSupported = (
+  provider: LLMProvider,
+  input: CustomProviderModelInput,
+): void => {
+  const declaredLevels = input.effort?.values ?? [];
+  if (declaredLevels.length === 0) {
+    return;
+  }
+
+  const supportedLevels = readCustomModelEffortLevels(provider);
+  if (supportedLevels.length === 0) {
+    throw new AppError(`${provider} models do not support reasoning effort.`, {
+      code: 'MODEL_EFFORT_NOT_SUPPORTED',
+      statusCode: 400,
+    });
+  }
+
+  const unsupportedLevel = declaredLevels.find((level) => !supportedLevels.includes(level));
+  if (unsupportedLevel) {
+    throw new AppError(
+      `"${unsupportedLevel}" is not a ${provider} effort level. Use one of: ${supportedLevels.join(', ')}.`,
+      {
+        code: 'INVALID_MODEL_EFFORT',
+        statusCode: 400,
+      },
+    );
+  }
+};
+
 const isUniqueConstraintError = (error: unknown): boolean => (
   error !== null
   && error !== undefined
@@ -87,7 +152,7 @@ export const createProviderModelsService = (dependencies: ProviderModelsServiceD
 
   const getProviderModels = async (provider: LLMProvider): Promise<ProviderModelsDefinition> => {
     const predefined = await resolveProvider(provider).models.getSupportedModels();
-    return mergeProviderModels(predefined, catalog.listCustomProviderModels(provider));
+    return mergeProviderModels(provider, predefined, catalog.listCustomProviderModels(provider));
   };
 
   const getCurrentActiveModel = async (
@@ -139,12 +204,13 @@ export const createProviderModelsService = (dependencies: ProviderModelsServiceD
     const predefined = await resolveProvider(provider).models.getSupportedModels();
     const normalized = normalizeCustomModelInput(input);
     assertModelIdAvailable(provider, predefined, normalized.id);
+    assertEffortLevelsSupported(provider, normalized);
 
     try {
       const created = catalog.createCustomProviderModel(provider, normalized);
       return {
         model: toCustomProviderModelOption(created),
-        models: mergeProviderModels(predefined, catalog.listCustomProviderModels(provider)),
+        models: mergeProviderModels(provider, predefined, catalog.listCustomProviderModels(provider)),
       };
     } catch (error) {
       if (isUniqueConstraintError(error)) {
@@ -166,6 +232,7 @@ export const createProviderModelsService = (dependencies: ProviderModelsServiceD
     readCustomModel(provider, recordId);
     const normalized = normalizeCustomModelInput(input);
     assertModelIdAvailable(provider, predefined, normalized.id, recordId);
+    assertEffortLevelsSupported(provider, normalized);
 
     try {
       const updated = catalog.updateCustomProviderModel(provider, recordId, normalized);
@@ -178,7 +245,7 @@ export const createProviderModelsService = (dependencies: ProviderModelsServiceD
 
       return {
         model: toCustomProviderModelOption(updated),
-        models: mergeProviderModels(predefined, catalog.listCustomProviderModels(provider)),
+        models: mergeProviderModels(provider, predefined, catalog.listCustomProviderModels(provider)),
       };
     } catch (error) {
       if (isUniqueConstraintError(error)) {
@@ -207,7 +274,7 @@ export const createProviderModelsService = (dependencies: ProviderModelsServiceD
 
     return {
       model: toCustomProviderModelOption(removed),
-      models: mergeProviderModels(predefined, catalog.listCustomProviderModels(provider)),
+      models: mergeProviderModels(provider, predefined, catalog.listCustomProviderModels(provider)),
     };
   };
 

package/server/modules/providers/services/provider-runtime.service.ts

@@ -91,6 +91,17 @@ export function createProviderRuntimeService(
       return Boolean(await dependencies.resolveProvider(providerName).runtime.abort(sessionId));
     },
 
+    async stopBackgroundTask(providerName: LLMProvider, sessionId: string, taskId: string): Promise<boolean> {
+      // A runtime that never holds background work has no task to stop.
+      const { runtime } = dependencies.resolveProvider(providerName);
+      return Boolean(await runtime.stopBackgroundTask?.(sessionId, taskId));
+    },
+
+    hasBackgroundWork(sessionId: string): boolean {
+      return dependencies.listProviders().some((provider) =>
+        (provider.runtime.listBackgroundWork?.() ?? []).some((entry) => entry.sessionId === sessionId));
+    },
+
     resolveToolApproval(requestId: string, decision: ProviderPermissionDecision): void {
       for (const provider of dependencies.listProviders()) {
         provider.runtime.permissions?.resolve(requestId, decision);

package/server/modules/providers/services/session-conversations-search.service.ts

@@ -5,6 +5,7 @@ import readline from 'node:readline';
 import { spawn } from 'cross-spawn';
 import { rgPath } from '@vscode/ripgrep';
 
+import { stripAnsiSequences } from '@/shared/utils.js';
 import { projectsDb, sessionsDb } from '@/modules/database/index.js';
 
 type AnyRecord = Record<string, any>;
@@ -409,10 +410,6 @@ function buildClaudeLocalCommandDisplayText(payload: ClaudeLocalCommandPayload):
   return commandArgs ? `${baseCommand} ${commandArgs}` : baseCommand;
 }
 
-function stripAnsiFormatting(text: string): string {
-  return text.replace(/\u001B\[[0-9;?]*[ -/]*[@-~]/g, '');
-}
-
 type ClaudeSearchableMessage = {
   text: string;
   role: 'user' | 'assistant';
@@ -456,7 +453,7 @@ function extractClaudeSearchableMessage(entry: AnyRecord): ClaudeSearchableMessa
 
     const localCommandStdout = extractTaggedContent(content, 'local-command-stdout');
     if (localCommandStdout !== null) {
-      const stdoutText = stripAnsiFormatting(localCommandStdout).trim();
+      const stdoutText = stripAnsiSequences(localCommandStdout).trim();
       return stdoutText
         ? {
             text: stdoutText,

package/server/modules/providers/services/session-history-cache.service.ts

@@ -16,8 +16,14 @@ import type { FetchHistoryResult } from '@/shared/types.js';
  * request against the transcript file's identity (path + mtime + size), so
  * only the first read after the file changes pays the parse. Anything that
  * rewrites history (a new turn, an edit, a rewind, a fork) touches the file
- * and invalidates naturally; no explicit invalidation hooks exist or are
- * needed.
+ * and invalidates naturally.
+ *
+ * One thing the file cannot tell: whether the CLI process behind the session
+ * is still running. Claude's history reader answers a background agent's
+ * status from that, so a session's entry is also dropped explicitly when its
+ * process starts or ends (`invalidate`) — otherwise a page read while the
+ * process was up would keep reporting `running` after it had gone, until the
+ * next row happened to land in the file.
  *
  * Only history readers that read `jsonl_path` itself may use this cache —
  * callers pass `transcriptPath: null` for providers whose messages live
@@ -133,6 +139,11 @@ export function createSessionHistoryCache(
         pendingLoads.delete(sessionId);
       }
     },
+
+    /** Forgets a session's entry so the next read re-parses its transcript. */
+    invalidate(sessionId: string): void {
+      entries.delete(sessionId);
+    },
   };
 }
 

package/server/modules/providers/services/sessions.service.ts

@@ -5,15 +5,44 @@ import path from 'node:path';
 import { projectsDb, sessionsDb } from '@/modules/database/index.js';
 import { broadcastSessionUpserted, chatRunRegistry } from '@/modules/websocket/index.js';
 import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import { listBusyClaudeCliSessions } from '@/modules/providers/services/claude-cli-liveness.service.js';
 import { sessionHistoryCache } from '@/modules/providers/services/session-history-cache.service.js';
 import type {
+  BackgroundTaskSummary,
   FetchHistoryOptions,
   FetchHistoryResult,
   LLMProvider,
   NormalizedMessage,
+  WorkflowAgentActivity,
 } from '@/shared/types.js';
 import { AppError, sliceTailPage } from '@/shared/utils.js';
 
+/**
+ * One session the running-sessions poll reports as busy.
+ *
+ * A chat run in progress is listed as before. A session whose turn has ended
+ * but whose background tasks are still outstanding is listed with
+ * `background: true` and `canInterrupt: false`: the composer stays usable
+ * (the runtime accepts a new turn while the work runs) and there is no run to
+ * abort — a task is stopped by id through `chat.stop-task` instead. `tasks`
+ * rides along on both kinds whenever the session has any.
+ *
+ * A turn driven outside CloudCLI — the Claude CLI in the Shell view, or a
+ * terminal the user opened themselves — is listed the same way, with
+ * `canInterrupt: false` because there is no run here to abort, and a
+ * `statusText` saying where the work is happening.
+ */
+type RunningSessionEntry = {
+  sessionId: string;
+  provider: LLMProvider;
+  startedAt: number;
+  lastSeq: number;
+  background?: true;
+  canInterrupt?: false;
+  statusText?: string;
+  tasks?: BackgroundTaskSummary[];
+};
+
 type CreateAppSessionResult = {
   sessionId: string;
   provider: LLMProvider;
@@ -125,18 +154,61 @@ export const sessionsService = {
   },
 
   /**
-   * Returns app-facing ids for provider runs that are currently processing.
+   * Returns app-facing ids for provider runs that are currently processing,
+   * plus every session whose background work outlived its turn.
    *
    * This is intentionally status-only: callers that only need sidebar activity
    * indicators should not attach to chat streams or request replayed messages.
    */
-  listRunningSessions(): Array<{
-    sessionId: string;
-    provider: LLMProvider;
-    startedAt: number;
-    lastSeq: number;
-  }> {
-    return chatRunRegistry.listRunningRuns();
+  async listRunningSessions(): Promise<RunningSessionEntry[]> {
+    const entries: RunningSessionEntry[] = chatRunRegistry.listRunningRuns();
+    const runningById = new Map(entries.map((entry) => [entry.sessionId, entry]));
+
+    for (const provider of providerRegistry.listProviders()) {
+      for (const { sessionId, tasks } of provider.runtime.listBackgroundWork?.() ?? []) {
+        const running = runningById.get(sessionId);
+        if (running) {
+          running.tasks = tasks;
+          continue;
+        }
+        entries.push({
+          sessionId,
+          provider: provider.id,
+          startedAt: Math.min(...tasks.map((task) => task.startedAt)),
+          // The completed run stays in the registry for a while, and a client
+          // that subscribes with its lastSeq replays the tail it missed.
+          lastSeq: chatRunRegistry.getRun(sessionId)?.lastSeq ?? 0,
+          background: true,
+          canInterrupt: false,
+          tasks,
+        });
+      }
+    }
+
+    // The chat-run registry only knows about turns CloudCLI drives itself, so
+    // without this a session working under the Claude CLI — including one
+    // CloudCLI spawned for its own Shell view — looks idle. A session already
+    // listed above keeps its richer entry.
+    for (const live of await listBusyClaudeCliSessions()) {
+      const session = sessionsDb.getSessionByProviderSessionId(live.providerSessionId);
+      if (!session || runningById.has(session.session_id)) {
+        continue;
+      }
+
+      entries.push({
+        sessionId: session.session_id,
+        provider: session.provider as LLMProvider,
+        startedAt: live.startedAt,
+        lastSeq: chatRunRegistry.getRun(session.session_id)?.lastSeq ?? 0,
+        // There is no run here to abort: the turn belongs to a CLI process
+        // CloudCLI does not own, so it can be reported but not interrupted.
+        canInterrupt: false,
+        statusText: 'Running in the Claude CLI',
+      });
+      runningById.set(session.session_id, entries[entries.length - 1]);
+    }
+
+    return entries;
   },
 
   /**
@@ -489,6 +561,34 @@ export const sessionsService = {
     };
   },
 
+  /**
+   * Reads what one agent of a workflow run did, for the card that opened it.
+   *
+   * Not found covers both a provider that spawns no workflow agents and a run
+   * that left no transcript for this agent: either way there is nothing to
+   * show, and the card says so in one line.
+   */
+  async readWorkflowAgentActivity(sessionId: string, runId: string, agentId: string): Promise<WorkflowAgentActivity> {
+    const session = sessionsDb.getSessionById(sessionId);
+    if (!session) {
+      throw new AppError(`Session "${sessionId}" was not found.`, {
+        code: 'SESSION_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    const sessions = providerRegistry.resolveProvider(session.provider as LLMProvider).sessions;
+    const activity = await sessions.readWorkflowAgentActivity?.(sessionId, runId, agentId);
+    if (!activity) {
+      throw new AppError(`Workflow agent "${agentId}" was not found.`, {
+        code: 'WORKFLOW_AGENT_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    return activity;
+  },
+
   /**
    * Resolves one session (by app id, falling back to the provider-native id)
    * to its metadata plus the owning project.