@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

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

@@ -158,12 +158,15 @@ export class ClaudeSkillsProvider extends SkillsProvider {
             continue;
           }
 
+          // A plugin may ship commands, skills, or both, and the CLI offers
+          // both halves. Reading only the first folder found hid every skill
+          // that sits beside a commands folder -- and hid the whole plugin when
+          // its commands are in a format this reader does not take.
           const commandsPath = path.join(pluginFolder, 'commands');
           if (await pathExistsAsDirectory(commandsPath)) {
             skills.push(
               ...(await this.listPluginCommandSkills(commandsPath, pluginId, pluginName)),
             );
-            continue;
           }
 
           const skillsPath = path.join(pluginFolder, 'skills');

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

@@ -2,12 +2,14 @@ import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provi
 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 { ClaudeForkProvider } from '@/modules/providers/list/claude/claude-fork.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';
 import { ClaudeSkillsProvider } from '@/modules/providers/list/claude/claude-skills.provider.js';
 import type {
   IProviderAuth,
+  IProviderFork,
   IProviderModels,
   IProviderRuntime,
   IProviderSessionSynchronizer,
@@ -23,6 +25,7 @@ export class ClaudeProvider extends AbstractProvider {
   readonly skills: IProviderSkills = new ClaudeSkillsProvider();
   readonly sessions: IProviderSessions = new ClaudeSessionsProvider();
   readonly sessionSynchronizer: IProviderSessionSynchronizer = new ClaudeSessionSynchronizer();
+  readonly fork: IProviderFork = new ClaudeForkProvider();
 
   constructor() {
     super('claude');

package/server/modules/providers/list/codex/codex-app-server.client.ts

@@ -0,0 +1,243 @@
+import { spawn } from 'node:child_process';
+import { stat } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import readline from 'node:readline';
+
+import { AppError } from '@/shared/utils.js';
+
+/**
+ * Minimal JSON-RPC client for `codex app-server`.
+ *
+ * Codex ships two entry points and they expose different things. The
+ * `@openai/codex-sdk` this app runs conversations through is a wrapper around
+ * `codex exec`, and its whole surface is `startThread` and `resumeThread` —
+ * there is no way to branch a thread or to resume one partway. The same
+ * binary's `app-server` subcommand speaks JSON-RPC and does have that
+ * primitive, `thread/fork`, which is what the Codex IDE clients build their
+ * own "fork" and "edit an earlier message" on top of.
+ *
+ * So this is a second transport to the same CLI, opened only for the
+ * operations the SDK cannot express. Everything else still goes through the
+ * SDK.
+ */
+
+/** How long a single request may take before the child is killed. */
+const REQUEST_TIMEOUT_MS = 30_000;
+
+type JsonRpcResponse = {
+  id?: number;
+  result?: unknown;
+  error?: { code?: number; message?: string };
+};
+
+/**
+ * One fork of a Codex thread.
+ *
+ * `path` is returned by the server rather than reconstructed: the rollout
+ * lands in today's date directory, not next to the file it was copied from,
+ * so deriving it from the source path would be wrong roughly every day.
+ */
+export type CodexThreadFork = {
+  threadId: string;
+  path: string;
+};
+
+/**
+ * Resolves the `codex` launcher shipped in node_modules.
+ *
+ * Deliberately not the `codex` on PATH: a machine can have a second, older
+ * install, and the protocol this speaks is only guaranteed against the
+ * version this package depends on.
+ */
+function resolveCodexLauncher(): string {
+  const require_ = createRequire(import.meta.url);
+  try {
+    return require_.resolve('@openai/codex/bin/codex.js');
+  } catch {
+    throw new AppError('The Codex CLI package is not installed, so Codex conversations cannot be branched.', {
+      code: 'CODEX_APP_SERVER_UNAVAILABLE',
+      statusCode: 501,
+    });
+  }
+}
+
+/**
+ * Runs one exchange against a freshly spawned `codex app-server`.
+ *
+ * A process per operation rather than a pooled long-lived one: the handshake
+ * costs a fraction of a second, forking happens at most once per user action,
+ * and a shared child would need lifecycle handling — restarts, back-pressure,
+ * a crash taking every pending fork with it — for no measurable gain next to
+ * the model turn that follows.
+ */
+async function withAppServer<T>(
+  run: (call: (method: string, params: unknown) => Promise<unknown>) => Promise<T>,
+): Promise<T> {
+  const launcher = resolveCodexLauncher();
+  const child = spawn(process.execPath, [launcher, 'app-server'], {
+    env: process.env,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  // The server logs sandbox and skill warnings to stderr on every start. They
+  // are not failures and drowning the app log in them helps nobody, so stderr
+  // is only kept around to explain a spawn that dies.
+  let stderr = '';
+  child.stderr?.on('data', (chunk) => {
+    stderr = (stderr + String(chunk)).slice(-2000);
+  });
+
+  let nextRequestId = 1;
+  const pending = new Map<number, (response: JsonRpcResponse) => void>();
+  let exitReason: string | null = null;
+
+  const reader = readline.createInterface({ input: child.stdout });
+  reader.on('line', (line) => {
+    if (!line.trim()) {
+      return;
+    }
+    let message: JsonRpcResponse;
+    try {
+      message = JSON.parse(line) as JsonRpcResponse;
+    } catch {
+      // Server-to-client notifications and any non-JSON banner are not
+      // replies to anything this client asked for.
+      return;
+    }
+    if (typeof message.id !== 'number') {
+      return;
+    }
+    pending.get(message.id)?.(message);
+    pending.delete(message.id);
+  });
+
+  const failPending = (reason: string) => {
+    exitReason = reason;
+    for (const resolve of pending.values()) {
+      resolve({ error: { message: reason } });
+    }
+    pending.clear();
+  };
+
+  child.on('error', (error) => failPending(error.message));
+  child.on('exit', (code, signal) => {
+    failPending(`codex app-server exited (code ${code ?? 'null'}, signal ${signal ?? 'null'})`);
+  });
+  // A child that dies mid-request leaves its pipes broken, and the next write
+  // raises EPIPE on the stream rather than at the call site. Without a
+  // listener that is an unhandled 'error' event, which takes the whole server
+  // down over one failed fork.
+  child.stdin?.on('error', (error) => failPending(error.message));
+  child.stdout?.on('error', (error) => failPending(error.message));
+  child.stderr?.on('error', () => {});
+
+  const call = (method: string, params: unknown): Promise<unknown> =>
+    new Promise((resolve, reject) => {
+      if (exitReason) {
+        reject(new AppError(`Codex app-server is not running: ${exitReason}`, {
+          code: 'CODEX_APP_SERVER_UNAVAILABLE',
+          statusCode: 502,
+        }));
+        return;
+      }
+
+      const id = nextRequestId++;
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new AppError(`Codex app-server did not answer "${method}" within ${REQUEST_TIMEOUT_MS}ms.`, {
+          code: 'CODEX_APP_SERVER_TIMEOUT',
+          statusCode: 504,
+        }));
+      }, REQUEST_TIMEOUT_MS);
+
+      pending.set(id, (response) => {
+        clearTimeout(timer);
+        if (response.error) {
+          reject(new AppError(response.error.message || `Codex app-server rejected "${method}".`, {
+            code: 'CODEX_APP_SERVER_ERROR',
+            statusCode: 502,
+            details: { method, rpcCode: response.error.code },
+          }));
+          return;
+        }
+        resolve(response.result);
+      });
+
+      child.stdin?.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+    });
+
+  try {
+    // `capabilities` is deliberately empty. `thread/fork` with `lastTurnId` is
+    // in the stable protocol; only `beforeTurnId` and the turn-listing methods
+    // are gated behind `experimentalApi`, and neither is needed here.
+    await call('initialize', {
+      clientInfo: { name: 'cloudcli', title: 'CloudCLI', version: '1' },
+      capabilities: {},
+    });
+    child.stdin?.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'initialized', params: {} })}\n`);
+
+    return await run(call);
+  } catch (error) {
+    if (error instanceof AppError && exitReason) {
+      throw new AppError(`${error.message}${stderr ? ` — ${stderr.trim().split('\n').slice(-1)[0]}` : ''}`, {
+        code: error.code,
+        statusCode: error.statusCode,
+      });
+    }
+    throw error;
+  } finally {
+    reader.close();
+    child.kill();
+  }
+}
+
+export const codexAppServer = {
+  /**
+   * Copies a thread into a new one that ends at `lastTurnId`, or copies the
+   * whole thread when it is omitted.
+   *
+   * `lastTurnId` is inclusive of the turn it names, which is the same
+   * convention the app's edit anchor uses ("the last row to keep").
+   *
+   * `cwd` decides the working directory recorded in the copy's `session_meta`,
+   * and that field is what the session indexer keys a session's project off —
+   * omitting it would file every fork under whatever directory this server
+   * happens to be running from.
+   */
+  async forkThread(input: {
+    threadId: string;
+    lastTurnId?: string;
+    cwd: string;
+  }): Promise<CodexThreadFork> {
+    return withAppServer(async (call) => {
+      const result = await call('thread/fork', {
+        threadId: input.threadId,
+        ...(input.lastTurnId ? { lastTurnId: input.lastTurnId } : {}),
+        ...(input.cwd ? { cwd: input.cwd } : {}),
+      }) as { thread?: { id?: unknown; path?: unknown } } | undefined;
+
+      const threadId = typeof result?.thread?.id === 'string' ? result.thread.id : '';
+      const path = typeof result?.thread?.path === 'string' ? result.thread.path : '';
+      if (!threadId || !path) {
+        throw new AppError('Codex reported a fork without a thread id or transcript path.', {
+          code: 'FORK_FAILED',
+          statusCode: 502,
+        });
+      }
+
+      // Confirmed rather than trusted: both callers are about to point a
+      // database row at this file, and a row naming a transcript that is not
+      // there is a session that can never be opened.
+      try {
+        await stat(path);
+      } catch {
+        throw new AppError('Codex reported a fork but wrote no transcript for it.', {
+          code: 'FORK_FAILED',
+          statusCode: 502,
+        });
+      }
+
+      return { threadId, path };
+    });
+  },
+};

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

@@ -0,0 +1,40 @@
+import { codexAppServer } from '@/modules/providers/list/codex/codex-app-server.client.js';
+import type { IProviderFork } from '@/shared/interfaces.js';
+
+/**
+ * Branches a Codex conversation into an independent thread.
+ *
+ * `thread/fork` writes a real rollout with its own thread id and a
+ * `forked_from_id` back-reference, which is what makes the copy resumable
+ * rather than an inert duplicate of the file.
+ *
+ * One difference from the Claude fork worth knowing about: Codex's unit is a
+ * turn, not a row. `upToAnchorId` names the turn a user message belongs to and
+ * the cut is inclusive of it, so forking from a message keeps that message
+ * *and the answer it got*. Claude's `upToMessageId` can stop at the prompt
+ * itself. There is no way to express the finer cut here — a turn is written as
+ * one thing — and the coarser one is the more useful of the two anyway.
+ */
+export class CodexForkProvider implements IProviderFork {
+  async forkSession(input: {
+    providerSessionId: string;
+    jsonlPath: string;
+    projectPath: string;
+    upToAnchorId?: string;
+    title?: string;
+  }): Promise<{ providerSessionId: string; jsonlPath: string }> {
+    // `title` is deliberately not forwarded. The sidebar name lives in this
+    // app's own session row, and naming the thread inside Codex would mean a
+    // second call that could fail after the fork already succeeded.
+    const fork = await codexAppServer.forkThread({
+      threadId: input.providerSessionId,
+      lastTurnId: input.upToAnchorId,
+      cwd: input.projectPath,
+    });
+
+    // The path is the one the server reported and already confirmed on disk,
+    // not one derived from the source: a fork lands in today's date directory
+    // rather than beside the transcript it was copied from.
+    return { providerSessionId: fork.threadId, jsonlPath: fork.path };
+  }
+}

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

@@ -18,6 +18,53 @@ import {
 /** Curated Codex catalog shipped as immutable CloudCLI defaults. */
 export const CODEX_PREDEFINED_MODELS: ProviderModelsDefinition = {
   OPTIONS: [
+    {
+      value: 'gpt-6-astra',
+      label: 'GPT-6 Astra',
+      description: 'Our most capable model for complex, demanding work.',
+      effort: {
+        default: 'low',
+        values: [
+          { value: 'low' },
+          { value: 'medium' },
+          { value: 'high' },
+          { value: 'xhigh' },
+          { value: 'max' },
+          { value: 'ultra' },
+        ],
+      },
+    },
+    {
+      value: 'gpt-6-sol',
+      label: 'GPT-6 Sol',
+      description: 'Workhorse model for coding and everyday work.',
+      effort: {
+        default: 'medium',
+        values: [
+          { value: 'low' },
+          { value: 'medium' },
+          { value: 'high' },
+          { value: 'xhigh' },
+          { value: 'max' },
+          { value: 'ultra' },
+        ],
+      },
+    },
+    {
+      value: 'gpt-6-luna',
+      label: 'GPT-6 Luna',
+      description: 'Fast and affordable model for easier tasks.',
+      effort: {
+        default: 'medium',
+        values: [
+          { value: 'low' },
+          { value: 'medium' },
+          { value: 'high' },
+          { value: 'xhigh' },
+          { value: 'max' },
+        ],
+      },
+    },
     {
       value: 'gpt-5.6-sol',
       label: 'GPT-5.6 Sol',