@yancyyu/openhermit 1.6.42 → 1.6.43

package/src/shared/utils/__tests__/providerBackend.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  formatProviderBackendLabel,
+  getDefaultProviderBackendId,
+  isLegacyCodexProviderBackendId,
+  isTeamProviderBackendId,
+  migrateProviderBackendId,
+} from '../providerBackend';
+
+describe('getDefaultProviderBackendId', () => {
+  it('returns codex-native for Codex', () => {
+    expect(getDefaultProviderBackendId('codex')).toBe('codex-native');
+  });
+
+  it('returns undefined for non-Codex providers', () => {
+    expect(getDefaultProviderBackendId('anthropic')).toBeUndefined();
+    expect(getDefaultProviderBackendId('gemini')).toBeUndefined();
+    expect(getDefaultProviderBackendId('opencode')).toBeUndefined();
+    expect(getDefaultProviderBackendId(undefined)).toBeUndefined();
+  });
+});
+
+describe('isLegacyCodexProviderBackendId', () => {
+  it.each(['auto', 'adapter', 'api'])('identifies %s as legacy', (id) => {
+    expect(isLegacyCodexProviderBackendId(id)).toBe(true);
+  });
+
+  it.each(['codex-native', 'cli-sdk', undefined, null, '', 'unknown'])(
+    'does not identify %s as legacy',
+    (id) => {
+      expect(isLegacyCodexProviderBackendId(id)).toBe(false);
+    }
+  );
+});
+
+describe('isTeamProviderBackendId', () => {
+  it.each(['auto', 'adapter', 'api', 'cli-sdk', 'codex-native'])(
+    'accepts valid backend id %s',
+    (id) => {
+      expect(isTeamProviderBackendId(id)).toBe(true);
+    }
+  );
+
+  it.each(['', 'native', 'sdk', null, undefined])('rejects invalid %s', (id) => {
+    expect(isTeamProviderBackendId(id)).toBe(false);
+  });
+});
+
+describe('migrateProviderBackendId', () => {
+  it('forces codex-native for Codex when backend is missing or legacy', () => {
+    expect(migrateProviderBackendId('codex', null)).toBe('codex-native');
+    expect(migrateProviderBackendId('codex', undefined)).toBe('codex-native');
+    expect(migrateProviderBackendId('codex', 'auto')).toBe('codex-native');
+    expect(migrateProviderBackendId('codex', 'adapter')).toBe('codex-native');
+  });
+
+  it('keeps a valid non-legacy Codex backend', () => {
+    expect(migrateProviderBackendId('codex', 'cli-sdk')).toBe('cli-sdk');
+  });
+
+  it('passes through valid backends for non-Codex providers', () => {
+    expect(migrateProviderBackendId('gemini', 'cli-sdk')).toBe('cli-sdk');
+    expect(migrateProviderBackendId('anthropic', 'auto')).toBe('auto');
+  });
+
+  it('returns undefined for invalid backends on non-Codex providers', () => {
+    expect(migrateProviderBackendId('gemini', 'totally-bogus')).toBeUndefined();
+  });
+});
+
+describe('formatProviderBackendLabel', () => {
+  it('labels codex-native as "Codex native"', () => {
+    expect(formatProviderBackendLabel('codex', 'codex-native')).toBe('Codex native');
+  });
+
+  it('labels gemini cli-sdk as "CLI SDK"', () => {
+    expect(formatProviderBackendLabel('gemini', 'cli-sdk')).toBe('CLI SDK');
+  });
+
+  it('returns undefined for gemini auto backend', () => {
+    expect(formatProviderBackendLabel('gemini', 'auto')).toBeUndefined();
+  });
+
+  it('returns undefined when no backend resolves', () => {
+    expect(formatProviderBackendLabel('anthropic', undefined)).toBeUndefined();
+  });
+});

package/src/shared/utils/__tests__/providerLaunchArgs.test.ts

@@ -0,0 +1,220 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveProviderLaunchArgs } from '../providerLaunchArgs';
+
+describe('resolveProviderLaunchArgs', () => {
+  describe('model resolution', () => {
+    it('appends the [1m] suffix to opus for Anthropic by default', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+        effort: 'high',
+        skipPermissions: true,
+      });
+      expect(result.resolvedModel).toBe('opus[1m]');
+      expect(result.providerArgs).toEqual([
+        '--model',
+        'opus[1m]',
+        '--effort',
+        'high',
+        '--dangerously-skip-permissions',
+      ]);
+    });
+
+    it('strips the [1m] suffix when limitContext is set', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+        effort: 'high',
+        limitContext: true,
+      });
+      expect(result.resolvedModel).toBe('opus');
+      expect(result.providerArgs).toContain('--model');
+      expect(result.providerArgs).not.toContain('opus[1m]');
+    });
+
+    it('does not add [1m] to models that do not support it (haiku)', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'haiku',
+      });
+      expect(result.resolvedModel).toBe('haiku');
+    });
+
+    it('passes an explicit model through for non-Anthropic providers', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'gemini',
+        model: 'gemini-2.5-pro',
+      });
+      expect(result.resolvedModel).toBe('gemini-2.5-pro');
+      expect(result.providerArgs).toContain('gemini-2.5-pro');
+    });
+
+    it('drops the model arg when a non-Anthropic provider uses the default sentinel', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'gemini',
+        model: '__provider_default__',
+      });
+      expect(result.resolvedModel).toBeNull();
+      expect(result.providerArgs).not.toContain('--model');
+    });
+
+    it('infers the provider id from the model when none is given', () => {
+      const result = resolveProviderLaunchArgs({ model: 'gemini-2.5-pro' });
+      expect(result.resolvedProviderId).toBe('gemini');
+    });
+
+    it('reports an issue when Codex has no resolved model', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'codex',
+        model: '__provider_default__',
+      });
+      expect(result.resolvedModel).toBeNull();
+      expect(result.connectionIssues.model).toMatch(/Codex/);
+    });
+  });
+
+  describe('effort validation', () => {
+    it('keeps effort valid for the provider', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+        effort: 'max',
+      });
+      expect(result.providerArgs).toContain('--effort');
+      expect(result.providerArgs).toContain('max');
+    });
+
+    it('drops effort that is invalid for the provider and records an issue', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+        effort: 'minimal', // minimal is not valid for anthropic
+      });
+      expect(result.providerArgs).not.toContain('--effort');
+      expect(result.connectionIssues.effort).toMatch(/minimal/);
+    });
+
+    it('accepts minimal effort for Codex', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'codex',
+        model: 'gpt-5.2',
+        effort: 'minimal',
+      });
+      expect(result.providerArgs).toContain('minimal');
+    });
+  });
+
+  describe('permissions and worktree', () => {
+    it('adds --dangerously-skip-permissions only when explicitly opted in', () => {
+      const withFlag = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+        skipPermissions: true,
+      });
+      expect(withFlag.providerArgs).toContain('--dangerously-skip-permissions');
+
+      // No opt-in (e.g. the MCP diagnostic path) → flag is NOT added.
+      const noOptIn = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+      });
+      expect(noOptIn.providerArgs).not.toContain('--dangerously-skip-permissions');
+    });
+
+    it('omits --dangerously-skip-permissions when skipPermissions is false', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+        skipPermissions: false,
+      });
+      expect(result.providerArgs).not.toContain('--dangerously-skip-permissions');
+    });
+
+    it('appends --worktree when a worktree name is given', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+        worktree: 'feature-x',
+      });
+      expect(result.providerArgs).toContain('--worktree');
+      expect(result.providerArgs).toContain('feature-x');
+    });
+  });
+
+  describe('extra CLI args', () => {
+    it('appends shell-split custom args', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+        extraCliArgs: '--verbose --max-turns 5',
+      });
+      expect(result.providerArgs).toContain('--verbose');
+      expect(result.providerArgs).toContain('--max-turns');
+      expect(result.providerArgs).toContain('5');
+    });
+
+    it('drops a conflicting value flag AND its value from extra args', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+        extraCliArgs: '--model gpt-4 --verbose',
+      });
+      // The emitted --model opus[1m] stays (exactly once); the user's --model gpt-4
+      // and its value are dropped as a conflict.
+      expect(result.providerArgs.filter((a) => a === '--model')).toHaveLength(1);
+      expect(result.providerArgs).toContain('opus[1m]');
+      expect(result.providerArgs).not.toContain('gpt-4');
+      expect(result.providerArgs).toContain('--verbose');
+      expect(result.connectionIssues.extraCliArgs).toMatch(/--model/);
+    });
+
+    it('drops a conflicting boolean flag from extra args', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+        skipPermissions: true,
+        extraCliArgs: '--dangerously-skip-permissions --verbose',
+      });
+      expect(result.connectionIssues.extraCliArgs).toMatch(/--dangerously-skip-permissions/);
+      // only one --dangerously-skip-permissions should remain (the one we emit)
+      const count = result.providerArgs.filter(
+        (a) => a === '--dangerously-skip-permissions'
+      ).length;
+      expect(count).toBe(1);
+    });
+
+    it('preserves an unmanaged flag the resolver did not emit', () => {
+      // No skipPermissions → the resolver does not emit --dangerously-skip-permissions,
+      // so the user's explicit copy must be preserved (not treated as a conflict).
+      const result = resolveProviderLaunchArgs({
+        providerId: 'anthropic',
+        model: 'opus',
+        extraCliArgs: '--dangerously-skip-permissions --verbose',
+      });
+      expect(result.connectionIssues.extraCliArgs).toBeUndefined();
+      expect(result.providerArgs).toContain('--dangerously-skip-permissions');
+    });
+  });
+
+  describe('backend migration', () => {
+    it('migrates legacy Codex backend to codex-native', () => {
+      const result = resolveProviderLaunchArgs({
+        providerId: 'codex',
+        model: 'gpt-5.2',
+        providerBackendId: 'auto',
+      });
+      expect(result.resolvedProviderBackendId).toBe('codex-native');
+    });
+  });
+
+  describe('empty input', () => {
+    it('returns empty args and issues with no provider info', () => {
+      const result = resolveProviderLaunchArgs();
+      expect(result.providerArgs).toEqual([]);
+      expect(result.connectionIssues).toEqual({});
+      expect(result.resolvedProviderId).toBeUndefined();
+      expect(result.resolvedModel).toBeNull();
+    });
+  });
+});

package/src/shared/utils/claudeStreamJson.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, it } from 'vitest';
+
+import { classifyClaudeStreamLine } from './claudeStreamJson';
+
+describe('classifyClaudeStreamLine', () => {
+  it('returns null for empty / whitespace-only lines', () => {
+    expect(classifyClaudeStreamLine('')).toBeNull();
+    expect(classifyClaudeStreamLine('   ')).toBeNull();
+    expect(classifyClaudeStreamLine('\n\t')).toBeNull();
+  });
+
+  it('classifies a system init line carrying session_id + model', () => {
+    const line = JSON.stringify({
+      type: 'system',
+      subtype: 'init',
+      session_id: 'abc-123',
+      model: 'claude-sonnet-4-6',
+      cwd: '/Users/x/hermit',
+    });
+    expect(classifyClaudeStreamLine(line)).toEqual({
+      type: 'session-init',
+      sessionId: 'abc-123',
+      model: 'claude-sonnet-4-6',
+    });
+  });
+
+  it('treats a system line without session_id as unknown (no id to resume)', () => {
+    expect(classifyClaudeStreamLine(JSON.stringify({ type: 'system', subtype: 'init' }))).toEqual({
+      type: 'unknown',
+    });
+  });
+
+  it('extracts text blocks from an assistant message (wrapped format)', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        id: 'msg_1',
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello there' }],
+      },
+    });
+    expect(classifyClaudeStreamLine(line)).toEqual({
+      type: 'assistant',
+      blocks: [{ kind: 'text', text: 'Hello there' }],
+      messageId: 'msg_1',
+    });
+  });
+
+  it('extracts tool_use blocks with name + input', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        content: [{ type: 'tool_use', id: 'toolu_1', name: 'Bash', input: { command: 'ls -la' } }],
+      },
+    });
+    expect(classifyClaudeStreamLine(line)).toEqual({
+      type: 'assistant',
+      blocks: [
+        {
+          kind: 'tool-use',
+          toolName: 'Bash',
+          toolInput: { command: 'ls -la' },
+          toolId: 'toolu_1',
+        },
+      ],
+      messageId: undefined,
+    });
+  });
+
+  it('keeps all block kinds when an assistant message carries text + thinking + tool_use', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        id: 'msg_2',
+        content: [
+          { type: 'thinking', thinking: 'planning...' },
+          { type: 'text', text: 'Running a command' },
+          { type: 'tool_use', id: 'toolu_2', name: 'Read', input: { file_path: '/a' } },
+        ],
+      },
+    });
+    expect(classifyClaudeStreamLine(line)).toEqual({
+      type: 'assistant',
+      messageId: 'msg_2',
+      blocks: [
+        { kind: 'thinking', text: 'planning...' },
+        { kind: 'text', text: 'Running a command' },
+        { kind: 'tool-use', toolName: 'Read', toolInput: { file_path: '/a' }, toolId: 'toolu_2' },
+      ],
+    });
+  });
+
+  it('drops empty text/thinking blocks but keeps tool_use', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        content: [
+          { type: 'text', text: '' },
+          { type: 'tool_use', name: 'Grep' },
+        ],
+      },
+    });
+    expect(classifyClaudeStreamLine(line)).toEqual({
+      type: 'assistant',
+      blocks: [{ kind: 'tool-use', toolName: 'Grep', toolInput: undefined, toolId: undefined }],
+      messageId: undefined,
+    });
+  });
+
+  it('classifies a result line with the turn text + subtype + session_id', () => {
+    const line = JSON.stringify({
+      type: 'result',
+      subtype: 'success',
+      result: 'final answer',
+      session_id: 'abc-123',
+      total_cost_usd: 0.01,
+    });
+    expect(classifyClaudeStreamLine(line)).toEqual({
+      type: 'result',
+      text: 'final answer',
+      subtype: 'success',
+      sessionId: 'abc-123',
+    });
+  });
+
+  it('handles result lines missing result text or subtype', () => {
+    expect(classifyClaudeStreamLine(JSON.stringify({ type: 'result' }))).toEqual({
+      type: 'result',
+      text: '',
+      subtype: '',
+      sessionId: undefined,
+    });
+  });
+
+  it('classifies control_request / control_cancel_request as control-request', () => {
+    expect(
+      classifyClaudeStreamLine(
+        JSON.stringify({
+          type: 'control_request',
+          request_id: 'req_1',
+          request: { subtype: 'can_use_tool', tool_name: 'Bash', input: { command: 'ls' } },
+        })
+      )
+    ).toEqual({
+      type: 'control-request',
+      requestId: 'req_1',
+      subtype: 'can_use_tool',
+      toolName: 'Bash',
+      toolInput: { command: 'ls' },
+    });
+    expect(classifyClaudeStreamLine(JSON.stringify({ type: 'control_cancel_request' }))).toEqual({
+      type: 'control-request',
+      requestId: undefined,
+      subtype: undefined,
+      toolName: undefined,
+      toolInput: undefined,
+    });
+  });
+
+  it('treats user/tool_result lines as unknown', () => {
+    expect(
+      classifyClaudeStreamLine(
+        JSON.stringify({
+          type: 'user',
+          message: { content: [{ type: 'tool_result', content: 'ok' }] },
+        })
+      )
+    ).toEqual({ type: 'unknown' });
+  });
+
+  it('flags non-JSON lines as parse-error (keeps the raw line)', () => {
+    expect(classifyClaudeStreamLine('not json at all')).toEqual({
+      type: 'parse-error',
+      line: 'not json at all',
+    });
+  });
+
+  it('returns unknown for valid JSON we do not model', () => {
+    expect(classifyClaudeStreamLine(JSON.stringify({ type: 'stream_event', delta: 'x' }))).toEqual({
+      type: 'unknown',
+    });
+    // assistant with no content array
+    expect(classifyClaudeStreamLine(JSON.stringify({ type: 'assistant', message: {} }))).toEqual({
+      type: 'unknown',
+    });
+  });
+});

package/src/shared/utils/claudeStreamJson.ts

@@ -0,0 +1,153 @@
+/**
+ * Pure per-line classifier for `claude --output-format stream-json` (NDJSON) output.
+ *
+ * Shared between the main-process DirectCliSessionManager (stdout relay) and any
+ * renderer-side interpretation, so the wire-format knowledge lives in one place.
+ * Line types mirror the ones the cc-connect `claudecode` agent parses
+ * (`agent/claudecode/session.go`): `system` / `assistant` / `user` / `result` /
+ * `control_request` / `control_cancel_request`.
+ *
+ * Note: stream-json emits message-level events (one `assistant` line per completed
+ * message), not per-token deltas. Token-by-token feel comes from emitting each
+ * assistant message as it lands — consistent with the existing cc-connect path.
+ */
+
+export interface ParsedAssistantBlock {
+  kind: 'text' | 'thinking' | 'tool-use';
+  text?: string;
+  toolName?: string;
+  toolInput?: unknown;
+  toolId?: string;
+}
+
+export type ClaudeStreamLine =
+  | { type: 'session-init'; sessionId: string; model?: string }
+  | { type: 'assistant'; blocks: ParsedAssistantBlock[]; messageId?: string }
+  | { type: 'result'; text: string; subtype: string; sessionId?: string }
+  | {
+      type: 'control-request';
+      requestId?: string;
+      /** `can_use_tool` = a tool needs interactive approval; other subtypes are auto-allowed. */
+      subtype?: string;
+      toolName?: string;
+      toolInput?: Record<string, unknown>;
+    }
+  | { type: 'unknown' }
+  | { type: 'parse-error'; line: string };
+
+interface RawContentBlock {
+  type?: string;
+  text?: string;
+  thinking?: string;
+  id?: string;
+  name?: string;
+  input?: unknown;
+}
+
+/**
+ * Classify a single NDJSON line from `claude --output-format stream-json`.
+ * Returns `null` for blank lines so callers can skip without distinguishing
+ * from `unknown` (a valid JSON object we don't model).
+ */
+export function classifyClaudeStreamLine(line: string): ClaudeStreamLine | null {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+
+  let raw: Record<string, unknown>;
+  try {
+    const parsed: unknown = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== 'object') return { type: 'unknown' };
+    raw = parsed as Record<string, unknown>;
+  } catch {
+    return { type: 'parse-error', line: trimmed };
+  }
+
+  const eventType = typeof raw.type === 'string' ? raw.type : '';
+
+  switch (eventType) {
+    case 'system': {
+      const sessionId = typeof raw.session_id === 'string' ? raw.session_id.trim() : '';
+      if (!sessionId) return { type: 'unknown' };
+      const model = typeof raw.model === 'string' && raw.model ? raw.model : undefined;
+      return { type: 'session-init', sessionId, model };
+    }
+
+    case 'assistant': {
+      const message = raw.message as Record<string, unknown> | undefined;
+      const rawContent = (message?.content ?? raw.content) as RawContentBlock[] | undefined;
+      if (!Array.isArray(rawContent)) return { type: 'unknown' };
+
+      const messageId =
+        typeof (message?.id ?? raw.id) === 'string'
+          ? ((message?.id ?? raw.id) as string)
+          : undefined;
+
+      const blocks: ParsedAssistantBlock[] = [];
+      for (const block of rawContent) {
+        if (!block || typeof block !== 'object') continue;
+        switch (block.type) {
+          case 'text':
+            if (typeof block.text === 'string' && block.text) {
+              blocks.push({ kind: 'text', text: block.text });
+            }
+            break;
+          case 'thinking':
+            if (typeof block.thinking === 'string' && block.thinking) {
+              blocks.push({ kind: 'thinking', text: block.thinking });
+            }
+            break;
+          case 'tool_use':
+            blocks.push({
+              kind: 'tool-use',
+              toolName: typeof block.name === 'string' ? block.name : 'Unknown',
+              toolInput: block.input,
+              toolId: typeof block.id === 'string' ? block.id : undefined,
+            });
+            break;
+          default:
+            break;
+        }
+      }
+      if (!blocks.length) return { type: 'unknown' };
+      return { type: 'assistant', blocks, messageId };
+    }
+
+    case 'user': {
+      // tool_result echo back from the CLI; not needed for streaming display.
+      return { type: 'unknown' };
+    }
+
+    case 'result': {
+      const text = typeof raw.result === 'string' ? raw.result : '';
+      const subtype = typeof raw.subtype === 'string' ? raw.subtype : '';
+      const sessionId = typeof raw.session_id === 'string' ? raw.session_id : undefined;
+      return { type: 'result', text, subtype, sessionId };
+    }
+
+    case 'control_request':
+    case 'control_cancel_request': {
+      // The CLI nests the gate details under `request`: { subtype, tool_name, input }.
+      // Only `subtype: can_use_tool` is a real tool-approval gate; other subtypes are
+      // surfaced so the caller can auto-allow them and avoid deadlocking the stream.
+      const req =
+        raw.request && typeof raw.request === 'object'
+          ? (raw.request as Record<string, unknown>)
+          : undefined;
+      const strField = (v: unknown): string | undefined => (typeof v === 'string' ? v : undefined);
+      const inputRaw = req?.input as unknown;
+      return {
+        type: 'control-request',
+        requestId: typeof raw.request_id === 'string' ? raw.request_id : undefined,
+        subtype: strField(req?.subtype),
+        toolName: strField(req?.tool_name),
+        toolInput:
+          inputRaw && typeof inputRaw === 'object'
+            ? (inputRaw as Record<string, unknown>)
+            : undefined,
+      };
+    }
+
+    default:
+      return { type: 'unknown' };
+  }
+}