@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

package/server/modules/providers/provider.routes.ts

@@ -1,6 +1,7 @@
 import express, { type Request, type Response } from 'express';
 
 import { providerAuthService } from '@/modules/providers/services/provider-auth.service.js';
+import { claudeSettingsPermissionsService } from '@/modules/providers/services/claude-settings-permissions.service.js';
 import { providerCapabilitiesService } from '@/modules/providers/services/provider-capabilities.service.js';
 import { providerMcpService } from '@/modules/providers/services/mcp.service.js';
 import { providerModelsService } from '@/modules/providers/services/provider-models.service.js';
@@ -9,6 +10,7 @@ import { providerSkillsService } from '@/modules/providers/services/skills.servi
 import { sessionConversationsSearchService } from '@/modules/providers/services/session-conversations-search.service.js';
 import { sessionsService } from '@/modules/providers/services/sessions.service.js';
 import type {
+  CustomProviderModelEffort,
   CustomProviderModelInput,
   LLMProvider,
   McpScope,
@@ -53,6 +55,35 @@ const parseSessionId = (value: unknown): string => {
   return sessionId;
 };
 
+/** A workflow run id as the harness mints one (`wf_16fbf852-274`). */
+const WORKFLOW_RUN_ID_PATTERN = /^wf_[A-Za-z0-9-]+$/;
+/** A workflow agent id as the CLI mints one: `a` and sixteen hex digits. */
+const WORKFLOW_AGENT_ID_PATTERN = /^a[0-9a-f]{16}$/;
+
+// Both ids name a file under the session's transcript directory, so nothing
+// outside these shapes may reach the filesystem.
+const parseWorkflowRunId = (value: unknown): string => {
+  const runId = readPathParam(value, 'runId');
+  if (!WORKFLOW_RUN_ID_PATTERN.test(runId)) {
+    throw new AppError('Invalid workflow run id.', {
+      code: 'INVALID_WORKFLOW_RUN_ID',
+      statusCode: 400,
+    });
+  }
+  return runId;
+};
+
+const parseWorkflowAgentId = (value: unknown): string => {
+  const agentId = readPathParam(value, 'agentId');
+  if (!WORKFLOW_AGENT_ID_PATTERN.test(agentId)) {
+    throw new AppError('Invalid workflow agent id.', {
+      code: 'INVALID_WORKFLOW_AGENT_ID',
+      statusCode: 400,
+    });
+  }
+  return agentId;
+};
+
 const readOptionalQueryString = (value: unknown): string | undefined => {
   if (typeof value !== 'string') {
     return undefined;
@@ -297,6 +328,28 @@ const parseProvider = (value: unknown): LLMProvider => {
   });
 };
 
+/** Both fields are optional: an empty body forks the whole conversation. */
+const parseSessionForkPayload = (payload: unknown): { upToAnchorId?: string; title?: string } => {
+  if (payload === undefined || payload === null) {
+    return {};
+  }
+  if (typeof payload !== 'object') {
+    throw new AppError('Request body must be an object.', {
+      code: 'INVALID_REQUEST_BODY',
+      statusCode: 400,
+    });
+  }
+
+  const body = payload as Record<string, unknown>;
+  const upToAnchorId = typeof body.upToAnchorId === 'string' ? body.upToAnchorId.trim() : '';
+  const title = typeof body.title === 'string' ? body.title.trim() : '';
+
+  return {
+    ...(upToAnchorId ? { upToAnchorId } : {}),
+    ...(title ? { title } : {}),
+  };
+};
+
 const parseSessionRenameSummary = (payload: unknown): string => {
   if (!payload || typeof payload !== 'object') {
     throw new AppError('Request body must be an object.', {
@@ -443,6 +496,78 @@ const parseModelRecordId = (value: unknown): number => {
   return recordId;
 };
 
+const invalidModelEffort = (message: string): AppError => new AppError(message, {
+  code: 'INVALID_MODEL_EFFORT',
+  statusCode: 400,
+});
+
+/**
+ * Upper bound on declared effort levels, far above any provider's level set.
+ * Checked before the per-entry loop so an oversized body (the JSON parser
+ * accepts up to 50 MB) is rejected at once instead of being walked in full.
+ */
+const MAX_MODEL_EFFORT_LEVELS = 32;
+
+/**
+ * Parses the optional `effort` field of a custom-model payload.
+ *
+ * Only the shape is checked here (unique, trimmed, non-empty level ids and a
+ * default drawn from them); which levels a provider accepts is decided by the
+ * Providers service. `undefined` means "not sent" and `null` or an empty
+ * `values` list means "no effort levels".
+ */
+const parseCustomProviderModelEffort = (
+  value: unknown,
+): CustomProviderModelEffort | null | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (value === null) {
+    return null;
+  }
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw invalidModelEffort('effort must be an object with a values array.');
+  }
+
+  const effort = value as Record<string, unknown>;
+  if (!Array.isArray(effort.values)) {
+    throw invalidModelEffort('effort.values must be an array of effort levels.');
+  }
+  if (effort.values.length > MAX_MODEL_EFFORT_LEVELS) {
+    throw invalidModelEffort(`effort.values can list at most ${MAX_MODEL_EFFORT_LEVELS} effort levels.`);
+  }
+
+  const values: string[] = [];
+  const seenLevels = new Set<string>();
+  for (const entry of effort.values) {
+    const level = typeof entry === 'string' ? entry.trim() : '';
+    if (!level || level.length > 40) {
+      throw invalidModelEffort('effort.values must contain non-empty strings of 40 characters or fewer.');
+    }
+    if (seenLevels.has(level)) {
+      throw invalidModelEffort(`effort.values contains "${level}" more than once.`);
+    }
+    seenLevels.add(level);
+    values.push(level);
+  }
+
+  if (effort.default !== undefined && effort.default !== null && typeof effort.default !== 'string') {
+    throw invalidModelEffort('effort.default must be a string.');
+  }
+  const defaultLevel = readOptionalQueryString(effort.default);
+  if (values.length === 0) {
+    if (defaultLevel) {
+      throw invalidModelEffort('effort.default requires at least one effort level.');
+    }
+    return null;
+  }
+  if (defaultLevel && !values.includes(defaultLevel)) {
+    throw invalidModelEffort('effort.default must be one of effort.values.');
+  }
+
+  return defaultLevel ? { values, default: defaultLevel } : { values };
+};
+
 const parseCustomProviderModelPayload = (payload: unknown): CustomProviderModelInput => {
   if (!payload || typeof payload !== 'object') {
     throw new AppError('Request body must be an object.', {
@@ -479,7 +604,8 @@ const parseCustomProviderModelPayload = (payload: unknown): CustomProviderModelI
     });
   }
 
-  return { model, id };
+  const effort = parseCustomProviderModelEffort(body.effort);
+  return effort === undefined ? { model, id } : { model, id, effort };
 };
 
 router.get(
@@ -695,6 +821,15 @@ router.get(
   }),
 );
 
+// Read-only: the rules Claude's own settings files add on top of the UI's lists.
+router.get(
+  '/claude/settings-permissions',
+  asyncHandler(async (_req: Request, res: Response) => {
+    const sources = await claudeSettingsPermissionsService.listRuleSources();
+    res.json(createApiSuccessResponse({ sources }));
+  }),
+);
+
 // ----------------- Session routes -----------------
 /**
  * Session gateway entry point: allocates the stable app-facing session id for
@@ -717,7 +852,7 @@ router.post(
 router.get(
   '/sessions/running',
   asyncHandler(async (_req: Request, res: Response) => {
-    const sessions = sessionsService.listRunningSessions();
+    const sessions = await sessionsService.listRunningSessions();
     res.json(createApiSuccessResponse({ sessions }));
   }),
 );
@@ -792,6 +927,15 @@ router.post(
   }),
 );
 
+router.post(
+  '/sessions/:sessionId/fork',
+  asyncHandler(async (req: Request, res: Response) => {
+    const sessionId = parseSessionId(req.params.sessionId);
+    const result = await sessionsService.forkSessionById(sessionId, parseSessionForkPayload(req.body));
+    res.status(201).json(createApiSuccessResponse(result));
+  }),
+);
+
 router.put(
   '/sessions/:sessionId',
   asyncHandler(async (req: Request, res: Response) => {
@@ -817,6 +961,22 @@ router.get(
   }),
 );
 
+/**
+ * One workflow agent's timeline, read on demand when its row in the workflow
+ * card is opened. History does not carry it: a run can spawn a dozen agents
+ * with hundreds of tool calls each, and the card only lists them.
+ */
+router.get(
+  '/sessions/:sessionId/workflows/:runId/agents/:agentId',
+  asyncHandler(async (req: Request, res: Response) => {
+    const sessionId = parseSessionId(req.params.sessionId);
+    const runId = parseWorkflowRunId(req.params.runId);
+    const agentId = parseWorkflowAgentId(req.params.agentId);
+    const result = await sessionsService.readWorkflowAgentActivity(sessionId, runId, agentId);
+    res.json(createApiSuccessResponse(result));
+  }),
+);
+
 router.get('/search/sessions', asyncHandler(async (req: Request, res: Response) => {
   const query = parseSessionSearchQuery(req.query.q);
   const limit = parseSessionSearchLimit(req.query.limit);

package/server/modules/providers/services/claude-cli-liveness.service.ts

@@ -0,0 +1,121 @@
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+/**
+ * One Claude CLI process that is currently producing a response.
+ *
+ * `providerSessionId` is Claude's own session id, which is what the registry
+ * records; callers map it onto an app session themselves.
+ */
+type LiveClaudeCliSession = {
+  providerSessionId: string;
+  startedAt: number;
+};
+
+/**
+ * Claude Code keeps one file per running session here, named `<pid>.json`.
+ * The directory belongs to the CLI, not to CloudCLI: it is only ever read.
+ */
+const registryDirectory = () => path.join(os.homedir(), '.claude', 'sessions');
+
+/**
+ * Upper bound on registry files inspected per poll.
+ *
+ * The running-sessions endpoint is polled continuously, so a directory left
+ * full of stale files by repeated crashes must not turn every poll into
+ * unbounded filesystem work. Real installations hold a handful of entries.
+ */
+const MAX_REGISTRY_FILES = 256;
+
+/**
+ * Whether `pid` is still the process the registry recorded.
+ *
+ * A registry file outlives a crash, so its mere presence proves nothing. The
+ * signal-0 probe answers "does this pid exist" (EPERM means it exists but is
+ * owned by someone else, which still counts), and on Linux the recorded
+ * `procStart` is compared against the kernel's start-time for that pid so a
+ * reused pid cannot be mistaken for the original process.
+ */
+async function isRecordedProcessAlive(pid: number, procStart: unknown): Promise<boolean> {
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code !== 'EPERM') {
+      return false;
+    }
+  }
+
+  if (process.platform !== 'linux' || typeof procStart !== 'string' || !procStart) {
+    return true;
+  }
+
+  try {
+    const stat = await fsp.readFile(`/proc/${pid}/stat`, 'utf8');
+    // The comm field is parenthesised and may itself contain spaces, so the
+    // fields are counted from the last ')'. starttime is the 22nd field
+    // overall, i.e. the 20th of what follows the comm field.
+    const fields = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+    return fields[19] === procStart;
+  } catch {
+    // No procfs entry means the process is gone between the two checks.
+    return false;
+  }
+}
+
+/** Reads one registry file, returning null for anything that is not a live busy session. */
+async function readLiveBusySession(filePath: string): Promise<LiveClaudeCliSession | null> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(await fsp.readFile(filePath, 'utf8'));
+  } catch {
+    // Unreadable, half-written or malformed entries are simply not evidence
+    // of a running session.
+    return null;
+  }
+
+  const record = parsed as Record<string, unknown> | null;
+  if (!record || typeof record !== 'object') {
+    return null;
+  }
+
+  const providerSessionId = typeof record.sessionId === 'string' ? record.sessionId : '';
+  const pid = typeof record.pid === 'number' ? record.pid : NaN;
+  if (!providerSessionId || !Number.isInteger(pid) || pid <= 0 || record.status !== 'busy') {
+    return null;
+  }
+
+  if (!(await isRecordedProcessAlive(pid, record.procStart))) {
+    return null;
+  }
+
+  const startedAt = typeof record.startedAt === 'number' ? record.startedAt : Date.now();
+  return { providerSessionId, startedAt };
+}
+
+/**
+ * Lists the Claude CLI sessions that are mid-turn right now.
+ *
+ * Used by the providers module's sessions service so the running-sessions poll
+ * also reports turns driven outside CloudCLI's own chat runs — including the
+ * `claude` processes CloudCLI itself spawns for the Shell view, which live in
+ * the PTY map rather than the chat-run registry. Liveness is ephemeral, so it
+ * is recomputed on every read instead of being cached or persisted.
+ */
+export async function listBusyClaudeCliSessions(): Promise<LiveClaudeCliSession[]> {
+  let entries: string[];
+  try {
+    entries = await fsp.readdir(registryDirectory());
+  } catch {
+    // No registry directory at all is the normal case for an install that has
+    // never run the CLI, and an unreadable one is not worth failing a poll for.
+    return [];
+  }
+
+  const registryFiles = entries.filter((entry) => entry.endsWith('.json')).slice(0, MAX_REGISTRY_FILES);
+  const sessions = await Promise.all(
+    registryFiles.map((entry) => readLiveBusySession(path.join(registryDirectory(), entry))),
+  );
+
+  return sessions.filter((session): session is LiveClaudeCliSession => session !== null);
+}

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,23 @@ 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.
+   */
+  supportsMessageEditing: boolean;
+  /**
+   * Whether a session's transcript can be branched into an independent one.
+   */
+  supportsSessionForking: boolean;
 };
 
 /**
@@ -44,6 +61,11 @@ 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,
+    supportsSessionForking: true,
   },
   cursor: {
     provider: 'cursor',
@@ -55,6 +77,9 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     supportsPermissionRequests: false,
     supportsTokenUsage: false,
     supportsEffort: false,
+    effortLevels: [],
+    supportsMessageEditing: false,
+    supportsSessionForking: false,
   },
   codex: {
     provider: 'codex',
@@ -66,6 +91,13 @@ 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,
+    // which is how Codex's own IDE clients do it.
+    supportsMessageEditing: true,
+    supportsSessionForking: true,
   },
   opencode: {
     provider: 'opencode',
@@ -80,11 +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 {