@cloudcli-ai/cloudcli 1.36.3 → 1.37.1

package/server/{claude-sdk.js → modules/providers/list/claude/claude-runtime.provider.js}

@@ -19,19 +19,20 @@ import path from 'path';
 
 import { query } from '@anthropic-ai/claude-agent-sdk';
 
-import { buildClaudeUserContent, normalizeImageDescriptors } from './shared/image-attachments.js';
-import { CLAUDE_FALLBACK_MODELS } from './modules/providers/list/claude/claude-models.provider.js';
-import { providerModelsService } from './modules/providers/services/provider-models.service.js';
-import { resolveClaudeCodeExecutablePath } from './shared/claude-cli-path.js';
+import {
+  appendFilesInputTag,
+  buildClaudeUserContent,
+  normalizeImageDescriptors
+} from '@/shared/image-attachments.js';
+import { CLAUDE_PREDEFINED_MODELS } from '@/modules/providers/list/claude/claude-models.provider.js';
+import { resolveClaudeCodeExecutablePath } from '@/shared/claude-cli-path.js';
 import {
   createNotificationEvent,
   notifyRunFailed,
   notifyRunStopped,
   notifyUserIfEnabled
-} from './services/notification-orchestrator.js';
-import { sessionsService } from './modules/providers/services/sessions.service.js';
-import { providerAuthService } from './modules/providers/services/provider-auth.service.js';
-import { createCompleteMessage, createNormalizedMessage } from './shared/utils.js';
+} from '@/modules/notifications/index.js';
+import { createCompleteMessage, createNormalizedMessage } from '@/shared/utils.js';
 
 const activeSessions = new Map();
 const pendingToolApprovals = new Map();
@@ -44,7 +45,7 @@ const TOOL_APPROVAL_TIMEOUT_MS = parseInt(process.env.CLAUDE_TOOL_APPROVAL_TIMEO
 
 const TOOLS_REQUIRING_INTERACTION = new Set(['AskUserQuestion', 'ExitPlanMode']);
 
-function resolveClaudeEffort(model, effort, modelsDefinition = CLAUDE_FALLBACK_MODELS) {
+function resolveClaudeEffort(model, effort, modelsDefinition = CLAUDE_PREDEFINED_MODELS) {
   const selectedModel = modelsDefinition?.OPTIONS?.find((option) => option.value === model) || null;
   const allowedEfforts = selectedModel?.effort?.values
     ?.map((value) => value.value) || [];
@@ -158,12 +159,15 @@ function matchesToolPermission(entry, toolName, input) {
 }
 
 function mapCliOptionsToSDK(options = {}) {
-  const { sessionId, cwd, toolsSettings, permissionMode, effort } = options;
+  const { providerSessionId, cwd, toolsSettings, permissionMode, effort } = options;
 
   const sdkOptions = {};
 
   // Forward all host env vars (e.g. ANTHROPIC_BASE_URL) to the subprocess.
   // Since SDK 0.2.113, options.env replaces process.env instead of overlaying it.
+  // This snapshot is also how CLI-side knobs reach the child: e.g. how long the CLI waits for
+  // still-running background agents after a turn ends is set by CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS
+  // (default 600000 ms; 0 = wait indefinitely) on this server's own environment.
   sdkOptions.env = { ...process.env };
 
   // Resolve the executable eagerly on Windows because the SDK uses raw child_process.spawn,
@@ -208,12 +212,12 @@ function mapCliOptionsToSDK(options = {}) {
 
   sdkOptions.disallowedTools = settings.disallowedTools || [];
 
-  sdkOptions.model = options.model || CLAUDE_FALLBACK_MODELS.DEFAULT;
+  sdkOptions.model = options.model || CLAUDE_PREDEFINED_MODELS.DEFAULT;
 
   const resolvedEffort = resolveClaudeEffort(
     sdkOptions.model,
     effort,
-    options.effortModels || CLAUDE_FALLBACK_MODELS,
+    options.effortModels || CLAUDE_PREDEFINED_MODELS,
   );
   if (resolvedEffort) {
     sdkOptions.effort = resolvedEffort;
@@ -226,8 +230,9 @@ function mapCliOptionsToSDK(options = {}) {
 
   sdkOptions.settingSources = ['project', 'user', 'local'];
 
-  if (sessionId) {
-    sdkOptions.resume = sessionId;
+  // The SDK resumes with the provider-native session id, never the app id.
+  if (providerSessionId) {
+    sdkOptions.resume = providerSessionId;
   }
 
   return sdkOptions;
@@ -371,15 +376,17 @@ function extractTokenBudget(sdkMessage) {
  *
  * @param {string} command - User prompt
  * @param {Array} images - Image descriptors ({ path, name?, mimeType? })
- * @param {string} cwd - Project working directory image paths resolve against
+ * @param {Array} files - Non-image attachment descriptors
+ * @param {string} cwd - Project working directory attachment paths resolve against
  * @returns {Promise<string|AsyncIterable>} SDK prompt payload
  */
-async function buildPromptPayload(command, images, cwd) {
+async function buildPromptPayload(command, images, files, cwd) {
+  const promptWithFiles = appendFilesInputTag(command, files);
   if (normalizeImageDescriptors(images).length === 0) {
-    return command;
+    return promptWithFiles;
   }
 
-  const content = await buildClaudeUserContent(command, images, cwd);
+  const content = await buildClaudeUserContent(promptWithFiles, images, cwd);
   return (async function* () {
     yield {
       type: 'user',
@@ -455,12 +462,21 @@ async function loadMcpConfig(cwd) {
  * @param {string} command - User prompt/command
  * @param {Object} options - Query options
  * @param {Object} ws - WebSocket connection
+ * @param {Object} context - Provider-scoped model, session, and auth lookups
  * @returns {Promise<void>}
  */
-async function queryClaudeSDK(command, options = {}, ws) {
+async function queryClaudeSDK(command, options = {}, ws, context) {
   const { sessionId, sessionSummary } = options;
-  let capturedSessionId = sessionId;
+  // Callers pass the stable app session id; the SDK only understands the
+  // provider-native id recorded on the session row.
+  const providerSessionId = context.resolveProviderSessionId(sessionId);
+  // Provider-native id as the SDK reports it (starts as the resume id, or is
+  // captured from the stream for brand-new sessions).
+  let capturedSessionId = providerSessionId;
   let sessionCreatedSent = false;
+  // Process-map key: the app session id when the caller supplied one, else
+  // the provider-native id once captured (legacy/direct API callers).
+  const sessionKey = () => sessionId || capturedSessionId || null;
 
   const emitNotification = (event) => {
     notifyUserIfEnabled({
@@ -471,20 +487,17 @@ async function queryClaudeSDK(command, options = {}, ws) {
   };
 
   try {
-    const resolvedModel = await providerModelsService.resolveResumeModel(
-      'claude',
-      sessionId,
-      options.model,
-    );
-    let effortModels = CLAUDE_FALLBACK_MODELS;
+    const resolvedModel = await context.resolveResumeModel(sessionId, options.model);
+    let effortModels = CLAUDE_PREDEFINED_MODELS;
     try {
-      effortModels = (await providerModelsService.getProviderModels('claude')).models;
+      effortModels = await context.getProviderModels();
     } catch (error) {
       console.warn('[Claude SDK] Unable to load provider models for effort validation:', error);
     }
 
     const sdkOptions = mapCliOptionsToSDK({
       ...options,
+      providerSessionId,
       model: resolvedModel || options.model,
       effortModels,
     });
@@ -497,22 +510,23 @@ async function queryClaudeSDK(command, options = {}, ws) {
     // Turns with image attachments switch to streaming input so the images
     // ride along as real content blocks. Built per query attempt because an
     // async generator cannot be replayed once consumed.
-    const createPrompt = () => buildPromptPayload(command, options.images, options.cwd);
+    const createPrompt = () => buildPromptPayload(command, options.images, options.files, options.cwd);
 
     sdkOptions.hooks = {
       Notification: [{
         matcher: '',
         hooks: [async (input) => {
           const message = typeof input?.message === 'string' ? input.message : 'Claude requires your attention.';
+          // Notifications are app-facing, so they carry the app session id.
           emitNotification(createNotificationEvent({
             provider: 'claude',
-            sessionId: capturedSessionId || sessionId || null,
+            sessionId: sessionId || capturedSessionId || null,
             kind: 'action_required',
             code: 'agent.notification',
             meta: { message, sessionName: sessionSummary },
             severity: 'warning',
             requiresUserAction: true,
-            dedupeKey: `claude:hook:notification:${capturedSessionId || sessionId || 'none'}:${message}`
+            dedupeKey: `claude:hook:notification:${sessionId || capturedSessionId || 'none'}:${message}`
           }));
           return {};
         }]
@@ -552,20 +566,22 @@ async function queryClaudeSDK(command, options = {}, ws) {
       ws.send(createNormalizedMessage({ kind: 'permission_request', requestId, toolName, input, sessionId: capturedSessionId || sessionId || null, provider: 'claude' }));
       emitNotification(createNotificationEvent({
         provider: 'claude',
-        sessionId: capturedSessionId || sessionId || null,
+        sessionId: sessionId || capturedSessionId || null,
         kind: 'action_required',
         code: 'permission.required',
         meta: { toolName, sessionName: sessionSummary },
         severity: 'warning',
         requiresUserAction: true,
-        dedupeKey: `claude:permission:${capturedSessionId || sessionId || 'none'}:${requestId}`
+        dedupeKey: `claude:permission:${sessionId || capturedSessionId || 'none'}:${requestId}`
       }));
 
       const decision = await waitForToolApproval(requestId, {
         timeoutMs: requiresInteraction ? 0 : undefined,
         signal: context?.signal,
         metadata: {
-          _sessionId: capturedSessionId || sessionId || null,
+          // Keyed by the app session id so `chat.subscribe` can look pending
+          // approvals up directly; provider id only for legacy callers.
+          _sessionId: sessionId || capturedSessionId || null,
           _toolName: toolName,
           _input: input,
           _receivedAt: new Date(),
@@ -597,10 +613,6 @@ async function queryClaudeSDK(command, options = {}, ws) {
       return { behavior: 'deny', message: decision.message ?? 'User denied tool use' };
     };
 
-    // Query constructor reads this synchronously.
-    const prevStreamTimeout = process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT;
-    process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT = '300000';
-
     let queryInstance;
     try {
       queryInstance = query({
@@ -618,16 +630,9 @@ async function queryClaudeSDK(command, options = {}, ws) {
       });
     }
 
-    // Restore immediately — Query constructor already captured the value
-    if (prevStreamTimeout !== undefined) {
-      process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT = prevStreamTimeout;
-    } else {
-      delete process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT;
-    }
-
     // Track the query instance for abort capability
-    if (capturedSessionId) {
-      addSession(capturedSessionId, queryInstance, ws);
+    if (sessionKey()) {
+      addSession(sessionKey(), queryInstance, ws);
     }
 
     // Process streaming messages
@@ -637,15 +642,15 @@ async function queryClaudeSDK(command, options = {}, ws) {
       if (message.session_id && !capturedSessionId) {
 
         capturedSessionId = message.session_id;
-        addSession(capturedSessionId, queryInstance, ws);
+        addSession(sessionKey(), queryInstance, ws);
 
         // Set session ID on writer
         if (ws.setSessionId && typeof ws.setSessionId === 'function') {
           ws.setSessionId(capturedSessionId);
         }
 
-        // Send session-created event only once for new sessions
-        if (!sessionId && !sessionCreatedSent) {
+        // Send session-created event only once for sessions with nothing to resume
+        if (!providerSessionId && !sessionCreatedSent) {
           sessionCreatedSent = true;
           ws.send(createNormalizedMessage({ kind: 'session_created', newSessionId: capturedSessionId, sessionId: capturedSessionId, provider: 'claude' }));
         }
@@ -658,7 +663,7 @@ async function queryClaudeSDK(command, options = {}, ws) {
       const sid = capturedSessionId || sessionId || null;
 
       // Use adapter to normalize SDK events into NormalizedMessage[]
-      const normalized = sessionsService.normalizeMessage('claude', transformedMessage, sid);
+      const normalized = context.normalizeMessage(transformedMessage, sid);
       for (const msg of normalized) {
         // Preserve parentToolUseId from SDK wrapper for subagent tool grouping
         if (transformedMessage.parentToolUseId && !msg.parentToolUseId) {
@@ -675,20 +680,20 @@ async function queryClaudeSDK(command, options = {}, ws) {
     }
 
     // Clean up session on completion
-    if (capturedSessionId) {
-      removeSession(capturedSessionId);
+    if (sessionKey()) {
+      removeSession(sessionKey());
     }
 
     // Send the terminal completion event — skipped for aborted runs, whose
     // terminal `complete` (aborted: true) was already sent by abort-session.
-    const wasAborted = capturedSessionId ? abortedSessionIds.delete(capturedSessionId) : false;
+    const wasAborted = sessionKey() ? abortedSessionIds.delete(sessionKey()) : false;
     if (!wasAborted) {
       ws.send(createCompleteMessage({ provider: 'claude', sessionId: capturedSessionId || sessionId || null, exitCode: 0 }));
     }
     notifyRunStopped({
       userId: ws?.userId || null,
       provider: 'claude',
-      sessionId: capturedSessionId || sessionId || null,
+      sessionId: sessionId || capturedSessionId || null,
       sessionName: sessionSummary,
       stopReason: wasAborted ? 'aborted' : 'completed'
     });
@@ -698,11 +703,11 @@ async function queryClaudeSDK(command, options = {}, ws) {
     console.error('SDK query error:', error);
 
     // Clean up session on error
-    if (capturedSessionId) {
-      removeSession(capturedSessionId);
+    if (sessionKey()) {
+      removeSession(sessionKey());
     }
 
-    const wasAborted = capturedSessionId ? abortedSessionIds.delete(capturedSessionId) : false;
+    const wasAborted = sessionKey() ? abortedSessionIds.delete(sessionKey()) : false;
     if (wasAborted) {
       // The abort already produced the terminal complete; a generator throw
       // caused by interrupt() is expected noise, not a user-facing error.
@@ -710,7 +715,7 @@ async function queryClaudeSDK(command, options = {}, ws) {
     }
 
     // Check if Claude CLI is installed for a clearer error message
-    const installed = await providerAuthService.isProviderInstalled('claude');
+    const installed = await context.isProviderInstalled();
     const errorContent = !installed
       ? 'Claude Code is not installed. Please install it first: https://docs.anthropic.com/en/docs/claude-code'
       : error.message;
@@ -721,7 +726,7 @@ async function queryClaudeSDK(command, options = {}, ws) {
     notifyRunFailed({
       userId: ws?.userId || null,
       provider: 'claude',
-      sessionId: capturedSessionId || sessionId || null,
+      sessionId: sessionId || capturedSessionId || null,
       sessionName: sessionSummary,
       error
     });
@@ -821,6 +826,15 @@ function reconnectSessionWriter(sessionId, newRawWs) {
   return true;
 }
 
+export const claudeRuntime = {
+  run: queryClaudeSDK,
+  abort: abortClaudeSDKSession,
+  permissions: {
+    resolve: resolveToolApproval,
+    listPending: getPendingApprovalsForSession,
+  },
+};
+
 // Export public API
 export {
   queryClaudeSDK,

package/server/modules/providers/list/claude/claude-session-synchronizer.provider.ts

@@ -26,10 +26,11 @@ export class ClaudeSessionSynchronizer implements IProviderSessionSynchronizer {
   private readonly claudeHome = path.join(os.homedir(), '.claude');
 
   /**
-   * Returns true when a JSONL file is a subagent transcript rather than a
-   * top-level session.
+   * Returns true when a JSONL file is a subagent transcript or tool result
+   * rather than a top-level session.
    *
-   * Claude stores subagent transcripts under a `subagents/` directory, e.g.
+   * Claude stores subagent transcripts under a `subagents/` directory and
+   * tool results under a `tool-results/` directory, e.g.
    * `~/.claude/projects/<encoded-cwd>/<session-id>/subagents/agent-<id>.jsonl`.
    * Those files repeat the parent session's `sessionId`, so indexing them as
    * standalone sessions overwrites the parent row's `jsonl_path` and corrupts
@@ -37,7 +38,8 @@ export class ClaudeSessionSynchronizer implements IProviderSessionSynchronizer {
    * them, so both entry points must skip them.
    */
   private isSubagentTranscript(filePath: string): boolean {
-    return path.normalize(filePath).split(path.sep).includes('subagents');
+    const pathParts = path.normalize(filePath).split(path.sep);
+    return pathParts.includes('subagents') || pathParts.includes('tool-results');
   }
 
   /**

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

@@ -5,6 +5,7 @@ import readline from 'node:readline';
 
 import type { IProviderSessions } from '@/shared/interfaces.js';
 import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
+import { parseFilesInputTag } from '@/shared/image-attachments.js';
 import { createNormalizedMessage, generateMessageId, readObjectRecord, sliceTailPage } from '@/shared/utils.js';
 import { sessionsDb } from '@/modules/database/index.js';
 
@@ -211,11 +212,19 @@ async function getSessionMessages(
  * - local command payloads (`<command-name>...`) and stdout wrappers
  *   (`<local-command-stdout>...`) should be remapped into normal chat messages
  *   instead of being discarded as internal content
+ *
+ * Skill bodies belong in the first group. When a skill is invoked, Claude
+ * injects the entire SKILL.md as a synthetic user turn. Persisted transcripts
+ * tag it `isMeta: true`, but the live SDK stream does not, so without a
+ * content-level check the same payload renders as a huge user bubble during the
+ * run and then vanishes on reload. The skill is already represented by the
+ * `Skill` tool call, so it is never user-visible content.
  */
 const INTERNAL_CONTENT_PREFIXES = [
   '<system-reminder>',
   'Caveat:',
   '[Request interrupted',
+  'Base directory for this skill:',
 ] as const;
 
 function isInternalContent(content: string): boolean {
@@ -324,6 +333,7 @@ export class ClaudeSessionsProvider implements IProviderSessions {
           }
         }
         let imagesAttached = false;
+        let filesAttached = false;
 
         for (let partIndex = 0; partIndex < raw.message.content.length; partIndex++) {
           const part = raw.message.content[partIndex];
@@ -342,7 +352,11 @@ export class ClaudeSessionsProvider implements IProviderSessions {
             }));
           } else if (part.type === 'text') {
             const text = part.text || '';
-            if (text && !isInternalContent(text)) {
+            const parsedFiles = parseFilesInputTag(text);
+            if (
+              (parsedFiles.text || parsedFiles.attachments.length > 0)
+              && !isInternalContent(parsedFiles.text)
+            ) {
               messages.push(createNormalizedMessage({
                 id: `${baseId}_text_${partIndex}`,
                 sessionId,
@@ -350,10 +364,14 @@ export class ClaudeSessionsProvider implements IProviderSessions {
                 provider: PROVIDER,
                 kind: 'text',
                 role: 'user',
-                content: text,
+                content: parsedFiles.text,
                 images: !imagesAttached && imageAttachments.length > 0 ? imageAttachments : undefined,
+                files: !filesAttached && parsedFiles.attachments.length > 0
+                  ? parsedFiles.attachments
+                  : undefined,
               }));
               imagesAttached = true;
+              filesAttached = filesAttached || parsedFiles.attachments.length > 0;
             }
           }
         }
@@ -468,7 +486,11 @@ export class ClaudeSessionsProvider implements IProviderSessions {
           return messages;
         }
 
-        if (text && !isInternalContent(text)) {
+        const parsedFiles = parseFilesInputTag(text);
+        if (
+          (parsedFiles.text || parsedFiles.attachments.length > 0)
+          && !isInternalContent(parsedFiles.text)
+        ) {
           messages.push(createNormalizedMessage({
             id: baseId,
             sessionId,
@@ -476,7 +498,8 @@ export class ClaudeSessionsProvider implements IProviderSessions {
             provider: PROVIDER,
             kind: 'text',
             role: 'user',
-            content: text,
+            content: parsedFiles.text,
+            files: parsedFiles.attachments.length > 0 ? parsedFiles.attachments : undefined,
           }));
         }
       }

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

@@ -1,6 +1,7 @@
 import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provider.js';
 import { ClaudeProviderAuth } from '@/modules/providers/list/claude/claude-auth.provider.js';
 import { ClaudeProviderModels } from '@/modules/providers/list/claude/claude-models.provider.js';
+import { claudeRuntime } from '@/modules/providers/list/claude/claude-runtime.provider.js';
 import { ClaudeMcpProvider } from '@/modules/providers/list/claude/claude-mcp.provider.js';
 import { ClaudeSessionSynchronizer } from '@/modules/providers/list/claude/claude-session-synchronizer.provider.js';
 import { ClaudeSessionsProvider } from '@/modules/providers/list/claude/claude-sessions.provider.js';
@@ -8,12 +9,14 @@ import { ClaudeSkillsProvider } from '@/modules/providers/list/claude/claude-ski
 import type {
   IProviderAuth,
   IProviderModels,
+  IProviderRuntime,
   IProviderSessionSynchronizer,
   IProviderSkills,
   IProviderSessions,
 } from '@/shared/interfaces.js';
 
 export class ClaudeProvider extends AbstractProvider {
+  readonly runtime: IProviderRuntime = claudeRuntime;
   readonly models: IProviderModels = new ClaudeProviderModels();
   readonly mcp = new ClaudeMcpProvider();
   readonly auth: IProviderAuth = new ClaudeProviderAuth();