@cloudcli-ai/cloudcli 1.37.2 → 1.37.3

package/server/modules/websocket/tests/shell-websocket.service.test.ts

@@ -1,5 +1,7 @@
 import assert from 'node:assert/strict';
 import { EventEmitter } from 'node:events';
+import os from 'node:os';
+import path from 'node:path';
 import test from 'node:test';
 
 import { WebSocket } from 'ws';
@@ -117,3 +119,109 @@ test('shell output detects and normalizes a wrapped authentication URL', () => {
 
   pty.emitExit();
 });
+
+test('bypassPermissions launches claude with --dangerously-skip-permissions', () => {
+  const spawnedCommands: string[] = [];
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: (_shell: string, args: string | string[]) => {
+      spawnedCommands.push(Array.isArray(args) ? args[args.length - 1] : args);
+      return createFakePty() as never;
+    },
+  };
+
+  const bypassSocket = createFakeSocket();
+  handleShellConnection(bypassSocket as never, dependencies);
+  bypassSocket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `bypass-on-${Date.now()}`,
+      hasSession: false,
+      provider: 'claude',
+      bypassPermissions: true,
+    })
+  );
+
+  const defaultSocket = createFakeSocket();
+  handleShellConnection(defaultSocket as never, dependencies);
+  defaultSocket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `bypass-off-${Date.now()}`,
+      hasSession: false,
+      provider: 'claude',
+    })
+  );
+
+  assert.deepEqual(spawnedCommands, ['claude --dangerously-skip-permissions', 'claude']);
+});
+
+test('bypassPermissions carries through to resumed claude sessions', () => {
+  const spawnedCommands: string[] = [];
+  const dependencies = {
+    resolveProviderSessionId: () => 'resumed-session-id',
+    spawnPty: (_shell: string, args: string | string[]) => {
+      spawnedCommands.push(Array.isArray(args) ? args[args.length - 1] : args);
+      return createFakePty() as never;
+    },
+  };
+
+  const socket = createFakeSocket();
+  handleShellConnection(socket as never, dependencies);
+  socket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `bypass-resume-${Date.now()}`,
+      hasSession: true,
+      provider: 'claude',
+      bypassPermissions: true,
+    })
+  );
+
+  assert.equal(spawnedCommands.length, 1);
+  if (os.platform() !== 'win32') {
+    assert.equal(
+      spawnedCommands[0],
+      'claude --resume "resumed-session-id" --dangerously-skip-permissions || claude --dangerously-skip-permissions'
+    );
+  }
+});
+
+test('a missing project directory is reported as an error frame and starts no pty', () => {
+  const socket = createFakeSocket();
+  let spawnCount = 0;
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => {
+      spawnCount += 1;
+      return createFakePty() as never;
+    },
+  };
+
+  handleShellConnection(socket as never, dependencies);
+  socket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      // A project row survives its directory being deleted or unmounted, so
+      // this is what the Shell tab sends for a stale sidebar entry.
+      projectPath: path.join(os.tmpdir(), `shell-missing-${Date.now()}`),
+      sessionId: `missing-path-${Date.now()}`,
+      hasSession: false,
+      provider: 'plain-shell',
+      isPlainShell: true,
+    })
+  );
+
+  assert.equal(spawnCount, 0);
+  assert.deepEqual(
+    socket.frames.map((frame) => JSON.parse(frame) as Record<string, unknown>),
+    [{ type: 'error', message: 'Invalid project path' }]
+  );
+});

package/server/shared/claude-cli-path.ts

@@ -69,13 +69,24 @@ function resolveClaudeWrapperBinary(
   return null;
 }
 
+/**
+ * Windows has no PATH lookup to fall back on: the SDK spawns the path we hand
+ * it with a raw `child_process.spawn`, which never consults PATH or PATHEXT.
+ * A bare `claude` therefore fails with "native binary not found at claude"
+ * even on a machine where the CLI is installed and on PATH, so an unresolved
+ * default returns undefined and lets the SDK use its own bundled binary.
+ */
 function resolveWindowsClaudeExecutablePath(
   configuredPath: string,
+  configuredExplicitly: boolean,
   deps: Required<ResolveClaudeCodeExecutablePathDependencies>,
-): string {
+): string | undefined {
   const pathApi = getPathApi(deps.platform);
   const extension = pathApi.extname(configuredPath).toLowerCase();
   const explicitPath = isPathLike(configuredPath) || pathApi.isAbsolute(configuredPath);
+  // An explicit CLAUDE_CLI_PATH is the operator's call even when we cannot
+  // verify it; only our own `claude` default defers to the SDK.
+  const unresolved = configuredExplicitly ? configuredPath : undefined;
 
   if (CLAUDE_SCRIPT_EXTENSIONS.has(extension)) {
     return configuredPath;
@@ -86,7 +97,7 @@ function resolveWindowsClaudeExecutablePath(
   }
 
   if (explicitPath) {
-    return resolveClaudeWrapperBinary(configuredPath, deps) ?? configuredPath;
+    return resolveClaudeWrapperBinary(configuredPath, deps) ?? unresolved;
   }
 
   try {
@@ -113,16 +124,22 @@ function resolveWindowsClaudeExecutablePath(
       }
     }
   } catch {
-    return configuredPath;
+    return unresolved;
   }
 
-  return configuredPath;
+  return unresolved;
 }
 
+/**
+ * Resolves the Claude Code executable to hand the SDK.
+ *
+ * Returns undefined when no real executable could be found and the caller did
+ * not configure one, which means "let the SDK pick its own bundled binary".
+ */
 export function resolveClaudeCodeExecutablePath(
   configuredPath: string | undefined = process.env.CLAUDE_CLI_PATH,
   dependencies: ResolveClaudeCodeExecutablePathDependencies = {},
-): string {
+): string | undefined {
   const deps: Required<ResolveClaudeCodeExecutablePathDependencies> = {
     execFileSync: dependencies.execFileSync ?? execFileSync,
     existsSync: dependencies.existsSync ?? fs.existsSync,
@@ -130,10 +147,11 @@ export function resolveClaudeCodeExecutablePath(
     readFileSync: dependencies.readFileSync ?? fs.readFileSync,
   };
 
+  const configuredExplicitly = Boolean(stripWrappingQuotes(configuredPath || ''));
   const normalizedPath = stripWrappingQuotes(configuredPath || DEFAULT_CLAUDE_COMMAND);
   if (deps.platform !== 'win32') {
     return normalizedPath;
   }
 
-  return resolveWindowsClaudeExecutablePath(normalizedPath, deps);
+  return resolveWindowsClaudeExecutablePath(normalizedPath, configuredExplicitly, deps);
 }

package/server/shared/index.ts

@@ -0,0 +1,3 @@
+export { appendFilesInputTag, buildCodexInputItems, normalizeImageDescriptors } from './image-attachments.js';
+export { createCompleteMessage, createNormalizedMessage } from './utils.js';
+export type { AnyRecord, ProviderRuntimeContext, ProviderRuntimeWriter } from './types.js';

package/server/shared/interfaces.ts

@@ -53,6 +53,36 @@ export interface IProvider {
   readonly skills: IProviderSkills;
   readonly sessions: IProviderSessions;
   readonly sessionSynchronizer: IProviderSessionSynchronizer;
+  /**
+   * Transcript branching. Present only for providers that can materialise a
+   * prefix of one conversation as an independent, resumable provider session;
+   * its absence is what makes "fork session" unavailable.
+   */
+  readonly fork?: IProviderFork;
+}
+
+// ---------------------------
+//----------------- PROVIDER FORK INTERFACE ------------
+/**
+ * Transcript-branching contract for one provider.
+ */
+export interface IProviderFork {
+  /**
+   * Copies a session's transcript, up to and including `upToAnchorId` (the
+   * whole conversation when omitted), into a brand-new provider session.
+   *
+   * Returns the new provider-native id and the path of the artifact it wrote,
+   * so the caller can insert the database row before the filesystem watcher
+   * notices the file and indexes it as an unrelated session.
+   */
+  forkSession(input: {
+    providerSessionId: string;
+    jsonlPath: string;
+    /** The session's working directory — how providers scope a session lookup. */
+    projectPath: string;
+    upToAnchorId?: string;
+    title?: string;
+  }): Promise<{ providerSessionId: string; jsonlPath: string }>;
 }
 
 // ---------------------------
@@ -154,6 +184,38 @@ export interface IProviderMcp {
 export interface IProviderSessions {
   normalizeMessage(raw: unknown, sessionId: string | null): NormalizedMessage[];
   fetchHistory(sessionId: string, options?: FetchHistoryOptions): Promise<FetchHistoryResult>;
+
+  /**
+   * Resolves where a conversation must resume from so that the turn identified
+   * by `anchorId`, and everything after it, is replaced.
+   *
+   * `resumeThroughId` is the last transcript row to KEEP — resuming is
+   * inclusive of it — or `null` when the edited turn is the first prompt and
+   * the conversation should start over. `found` is false when `anchorId` is not
+   * in the transcript, which the caller must report rather than guess at.
+   *
+   * Implemented only by providers whose transcripts have stable per-row
+   * identity; its absence is what makes "edit this message" unavailable.
+   */
+  resolveEditAnchor?(
+    sessionId: string,
+    anchorId: string,
+  ): Promise<{ found: boolean; resumeThroughId: string | null }>;
+
+  /**
+   * Rewinds the session so `keepThroughId` is the last row of its
+   * conversation, and points the session at whatever provider session now
+   * holds it. `null` keeps nothing: the conversation starts over.
+   *
+   * Implemented only by providers whose runtime cannot resume a transcript
+   * partway and have to branch instead. Codex is one — it has no
+   * resume-at-a-row, so the rewind is a `thread/fork` that leaves the pre-edit
+   * thread on disk and moves the session onto the copy. Providers that can
+   * resume partway leave this undefined, and the anchor is handed to their
+   * runtime as a resume option instead; that is the difference the edit
+   * gateway branches on.
+   */
+  rewindSession?(sessionId: string, keepThroughId: string | null): Promise<void>;
 }
 
 // ---------------------------