@yancyyu/openhermit 1.6.42 → 1.6.43

package/src/main/services/ccConnect/CcConnectBridge.ts

@@ -71,6 +71,13 @@ export class CcConnectBridge extends EventEmitter {
     this.connect();
   }
 
+  reconnect(): void {
+    if (this._disposed) return;
+    this._connected = false;
+    this.cleanup();
+    this.connect();
+  }
+
   dispose(): void {
     this._disposed = true;
     this.cleanup();
@@ -175,15 +182,20 @@ export class CcConnectBridge extends EventEmitter {
 
     logger.info(`Connecting to cc-connect Bridge: ${this.bridgeUrl}`);
 
-    try {
-      this.ws = new WebSocket(url);
-    } catch (error) {
-      logger.warn(`Failed to create WebSocket: ${error}`);
-      this.scheduleReconnect();
-      return;
-    }
+    const ws = (() => {
+      try {
+        return new WebSocket(url);
+      } catch (error) {
+        logger.warn(`Failed to create WebSocket: ${error}`);
+        this.scheduleReconnect();
+        return null;
+      }
+    })();
+    if (!ws) return;
+    this.ws = ws;
 
-    this.ws.addEventListener('open', () => {
+    ws.addEventListener('open', () => {
+      if (this.ws !== ws) return;
       logger.info('Bridge WebSocket connected');
       this._connected = true;
 
@@ -198,7 +210,8 @@ export class CcConnectBridge extends EventEmitter {
       this.emit('connected');
     });
 
-    this.ws.addEventListener('message', (event: MessageEvent) => {
+    ws.addEventListener('message', (event: MessageEvent) => {
+      if (this.ws !== ws) return;
       try {
         const data = typeof event.data === 'string' ? event.data : String(event.data);
         const msg = JSON.parse(data) as CcBridgeIncomingMessage;
@@ -208,13 +221,15 @@ export class CcConnectBridge extends EventEmitter {
       }
     });
 
-    this.ws.addEventListener('close', (event: CloseEvent) => {
+    ws.addEventListener('close', (event: CloseEvent) => {
       logger.info(`Bridge WebSocket closed: ${event.code} ${event.reason}`);
+      if (this.ws !== ws) return;
       this.handleDisconnect();
     });
 
-    this.ws.addEventListener('error', () => {
+    ws.addEventListener('error', () => {
       logger.warn('Bridge WebSocket error');
+      if (this.ws !== ws) return;
       this.handleDisconnect(new Error('WebSocket error'));
     });
   }

package/src/main/services/ccConnect/CcConnectClient.ts

@@ -251,11 +251,18 @@ export class CcConnectClient {
     );
   }
 
-  async createSession(projectName: string, name?: string): Promise<CcSessionDetail> {
+  async createSession(
+    projectName: string,
+    name?: string,
+    sessionKey?: string
+  ): Promise<CcSessionDetail> {
+    const body: Record<string, string> = {};
+    if (name) body.name = name;
+    if (sessionKey) body.session_key = sessionKey;
     return this.request<CcSessionDetail>(
       'POST',
       `/api/v1/projects/${encodeURIComponent(projectName)}/sessions`,
-      name ? { name } : {}
+      body
     );
   }
 

package/src/main/services/ccConnect/workDirReconcile.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  CC_CONNECT_PLACEHOLDER_WORK_DIR,
+  isPlaceholderWorkDir,
+  needsWorkDirReconcile,
+} from './workDirReconcile';
+
+describe('needsWorkDirReconcile', () => {
+  it('reconciles when the project still carries the default template placeholder', () => {
+    // The system-manager bind project ('my-project') collides with cc-connect's
+    // default template, whose work_dir is the never-filled placeholder. The agent
+    // spawn then fails with `chdir /path/to/your/project: no such file or directory`.
+    expect(needsWorkDirReconcile(CC_CONNECT_PLACEHOLDER_WORK_DIR, '/Users/me/code/hermit')).toBe(
+      true
+    );
+  });
+
+  it('does not reconcile when the work_dir already matches the manifest', () => {
+    expect(needsWorkDirReconcile('/Users/me/code/hermit', '/Users/me/code/hermit')).toBe(false);
+  });
+
+  it('reconciles when the work_dir drifted to a different real path', () => {
+    expect(needsWorkDirReconcile('/old/path', '/new/path')).toBe(true);
+  });
+
+  it('does not reconcile when there is no expected work_dir to enforce', () => {
+    // Never overwrite a project's work_dir with an empty value — that would clear
+    // a valid path rather than repair a bad one.
+    expect(needsWorkDirReconcile('/Users/me/code/hermit', '')).toBe(false);
+    expect(needsWorkDirReconcile('/Users/me/code/hermit', undefined)).toBe(false);
+    expect(needsWorkDirReconcile('/Users/me/code/hermit', '   ')).toBe(false);
+  });
+
+  it('reconciles when the project has no work_dir yet but a manifest dir exists', () => {
+    expect(needsWorkDirReconcile(undefined, '/Users/me/code/hermit')).toBe(true);
+    expect(needsWorkDirReconcile('', '/Users/me/code/hermit')).toBe(true);
+    expect(needsWorkDirReconcile(null, '/Users/me/code/hermit')).toBe(true);
+  });
+
+  it('treats whitespace-only differences as equal after trimming', () => {
+    expect(needsWorkDirReconcile('  /Users/me/code/hermit  ', '/Users/me/code/hermit')).toBe(false);
+  });
+});
+
+describe('isPlaceholderWorkDir', () => {
+  it('recognizes the cc-connect default template placeholder', () => {
+    expect(isPlaceholderWorkDir(CC_CONNECT_PLACEHOLDER_WORK_DIR)).toBe(true);
+    expect(isPlaceholderWorkDir('  /path/to/your/project  ')).toBe(true);
+  });
+
+  it('returns false for real or empty work_dirs', () => {
+    expect(isPlaceholderWorkDir('/Users/me/code/hermit')).toBe(false);
+    expect(isPlaceholderWorkDir('')).toBe(false);
+    expect(isPlaceholderWorkDir(undefined)).toBe(false);
+  });
+});

package/src/main/services/ccConnect/workDirReconcile.ts

@@ -0,0 +1,36 @@
+/**
+ * cc-connect spawns each agent subprocess with `chdir(<project work_dir>)`. When a
+ * project's work_dir is stale — or still the default template placeholder below —
+ * every session fails at agent start with `chdir ...: no such file or directory`,
+ * which cc-connect surfaces as "❌ 错误: 启动 Agent 会话失败". The session record is
+ * created fine, so the user sees the success message AND the failure.
+ *
+ * This hit the Helm Loop hardest: its bind project is `my-project`, the same name
+ * cc-connect ships as an unconfigured template (`work_dir = /path/to/your/project`).
+ */
+
+/** cc-connect's default template project work_dir — a placeholder that was never filled. */
+export const CC_CONNECT_PLACEHOLDER_WORK_DIR = '/path/to/your/project';
+
+/**
+ * Decide whether a cc-connect project's work_dir must be reconciled to the
+ * team manifest's work_dir.
+ *
+ * Reconcile only when we have a concrete expected dir AND the project's current
+ * work_dir differs. The placeholder is caught by the inequality check, so the
+ * common broken case needs no special-casing. We never overwrite with an empty
+ * expected value — that would clear a valid path instead of repairing a bad one.
+ */
+export function needsWorkDirReconcile(
+  actualWorkDir: string | undefined | null,
+  expectedWorkDir: string | undefined | null
+): boolean {
+  const expected = expectedWorkDir?.trim();
+  if (!expected) return false;
+  return (actualWorkDir?.trim() ?? '') !== expected;
+}
+
+/** True when a work_dir is cc-connect's default template placeholder. */
+export function isPlaceholderWorkDir(workDir: string | undefined | null): boolean {
+  return workDir?.trim() === CC_CONNECT_PLACEHOLDER_WORK_DIR;
+}

package/src/main/services/direct-cli/DirectCliSessionManager.test.ts

@@ -0,0 +1,397 @@
+import { EventEmitter } from 'events';
+
+import type { SpawnOptions } from 'child_process';
+
+import { describe, expect, it } from 'vitest';
+
+import {
+  buildClaudeStreamArgs,
+  DirectCliSessionManager,
+  formatClaudeStdinUserTurn,
+} from './DirectCliSessionManager';
+
+/** Minimal fake ChildProcess: stdout/stderr/stdin as EventEmitters + kill. */
+interface FakeChild {
+  stdout: EventEmitter;
+  stderr: EventEmitter;
+  stdin: { write: (data: string) => boolean; destroyed: boolean };
+  kill: (signal?: string) => void;
+  on: (event: string, cb: (...args: unknown[]) => void) => void;
+  emitExit: (code: number | null) => void;
+}
+
+function createFakeChild(): FakeChild {
+  const bus = new EventEmitter();
+  const child: FakeChild = {
+    stdout: new EventEmitter(),
+    stderr: new EventEmitter(),
+    stdin: { write: () => true, destroyed: false },
+    kill: () => undefined,
+    on: (event, cb) => bus.on(event, cb),
+    emitExit: (code) => bus.emit('exit', code),
+  };
+  return child;
+}
+
+function createManager(providerArgs: string[] = []): {
+  manager: DirectCliSessionManager;
+  child: FakeChild;
+} {
+  const child = createFakeChild();
+  const manager = new DirectCliSessionManager({
+    spawnFn: () => child as unknown as import('child_process').ChildProcess,
+    envResolver: async () => ({ env: { PATH: '/fake' }, providerArgs }),
+    binaryResolver: { resolve: async () => '/fake/claude' } as never,
+    store: new Map<string, string>() as never,
+  });
+  return { manager, child };
+}
+
+describe('buildClaudeStreamArgs', () => {
+  it('emits the base stream-json flags with --verbose by default', () => {
+    expect(buildClaudeStreamArgs()).toEqual([
+      '--output-format',
+      'stream-json',
+      '--input-format',
+      'stream-json',
+      '--permission-prompt-tool',
+      'stdio',
+      '--verbose',
+    ]);
+  });
+
+  it('adds --resume / --append-system-prompt / provider args when provided', () => {
+    expect(
+      buildClaudeStreamArgs({
+        resumeSessionId: 'sid-1',
+        appendSystemPrompt: 'You are admin.',
+        verbose: false,
+        providerArgs: ['--model', 'opus'],
+      })
+    ).toEqual([
+      '--output-format',
+      'stream-json',
+      '--input-format',
+      'stream-json',
+      '--permission-prompt-tool',
+      'stdio',
+      // no --verbose because verbose:false
+      '--resume',
+      'sid-1',
+      '--append-system-prompt',
+      'You are admin.',
+      '--model',
+      'opus',
+    ]);
+  });
+
+  it('omits --resume / --append-system-prompt when their values are blank', () => {
+    const args = buildClaudeStreamArgs({ resumeSessionId: '   ', appendSystemPrompt: '' });
+    expect(args).not.toContain('--resume');
+    expect(args).not.toContain('--append-system-prompt');
+  });
+});
+
+describe('formatClaudeStdinUserTurn', () => {
+  it('produces a single NDJSON user line terminated by a newline', () => {
+    const out = formatClaudeStdinUserTurn('fix the bug');
+    expect(out.endsWith('\n')).toBe(true);
+    const parsed = JSON.parse(out.trim());
+    expect(parsed).toEqual({
+      type: 'user',
+      message: { role: 'user', content: [{ type: 'text', text: 'fix the bug' }] },
+    });
+  });
+});
+
+describe('DirectCliSessionManager', () => {
+  it('spawns on first ensureSession with cwd=workDir and base args', async () => {
+    let spawnArgs: string[] = [];
+    let spawnOpts: SpawnOptions = {};
+    const child = createFakeChild();
+    const manager = new DirectCliSessionManager({
+      spawnFn: (_bin, args, opts) => {
+        spawnArgs = args;
+        spawnOpts = opts;
+        return child as unknown as import('child_process').ChildProcess;
+      },
+      envResolver: async () => ({ env: { X: '1' }, providerArgs: [] }),
+      binaryResolver: { resolve: async () => '/fake/claude' } as never,
+      store: new Map<string, string>() as never,
+    });
+
+    await manager.ensureSession({ sessionKey: 't:lead', workDir: '/proj' });
+
+    expect(manager.has('t:lead')).toBe(true);
+    expect(spawnOpts.cwd).toBe('/proj');
+    expect(spawnOpts.env).toEqual({ X: '1' });
+    expect(spawnArgs).toContain('--output-format');
+    expect(spawnArgs).toContain('stream-json');
+    expect(spawnArgs).toContain('--verbose');
+  });
+
+  it('does not spawn twice for the same session key (dedupes concurrent ensureSession)', async () => {
+    let spawnCount = 0;
+    const child = createFakeChild();
+    const manager = new DirectCliSessionManager({
+      spawnFn: () => {
+        spawnCount += 1;
+        return child as unknown as import('child_process').ChildProcess;
+      },
+      envResolver: async () => ({ env: {}, providerArgs: [] }),
+      binaryResolver: { resolve: async () => '/fake/claude' } as never,
+      store: new Map<string, string>() as never,
+    });
+
+    await Promise.all([
+      manager.ensureSession({ sessionKey: 't:lead', workDir: '/proj' }),
+      manager.ensureSession({ sessionKey: 't:lead', workDir: '/proj' }),
+    ]);
+    await manager.ensureSession({ sessionKey: 't:lead', workDir: '/proj' });
+
+    expect(spawnCount).toBe(1);
+  });
+
+  it('emits init → delta → tool → complete for a real stream and captures session id', async () => {
+    const { manager, child } = createManager(['--model', 'sonnet']);
+
+    const events: string[] = [];
+    manager.on('event', (e: { kind: string }) => events.push(e.kind));
+
+    await manager.send('t:lead', { text: 'fixbug', messageId: 'm1', workDir: '/proj' });
+
+    // system init carries the claude session id (captured for --resume next time)
+    child.stdout.emit(
+      'data',
+      JSON.stringify({ type: 'system', session_id: 'claude-sid-9', model: 'claude-sonnet-4-6' }) +
+        '\n'
+    );
+    // assistant text delta
+    child.stdout.emit(
+      'data',
+      JSON.stringify({
+        type: 'assistant',
+        message: { id: 'msg_1', content: [{ type: 'text', text: 'working on it' }] },
+      }) + '\n'
+    );
+    // assistant tool_use
+    child.stdout.emit(
+      'data',
+      JSON.stringify({
+        type: 'assistant',
+        message: {
+          content: [{ type: 'tool_use', id: 'tu', name: 'Bash', input: { command: 'ls' } }],
+        },
+      }) + '\n'
+    );
+    // result
+    child.stdout.emit(
+      'data',
+      JSON.stringify({
+        type: 'result',
+        subtype: 'success',
+        result: 'done',
+        session_id: 'claude-sid-9',
+      }) + '\n'
+    );
+
+    expect(events).toEqual(['init', 'delta', 'tool', 'complete']);
+    // getSessionId reads the handle's captured session id
+    expect(manager.getSessionId('t:lead')).toBe('claude-sid-9');
+  });
+
+  it('writes the user turn to stdin as NDJSON on send', async () => {
+    const child = createFakeChild();
+    let written = '';
+    child.stdin.write = (data: string) => {
+      written = data;
+      return true;
+    };
+    const manager = new DirectCliSessionManager({
+      spawnFn: () => child as unknown as import('child_process').ChildProcess,
+      envResolver: async () => ({ env: {}, providerArgs: [] }),
+      binaryResolver: { resolve: async () => '/fake/claude' } as never,
+      store: new Map<string, string>() as never,
+    });
+    await manager.send('t:lead', { text: 'hello', messageId: 'm1', workDir: '/proj' });
+    expect(JSON.parse(written.trim())).toEqual({
+      type: 'user',
+      message: { role: 'user', content: [{ type: 'text', text: 'hello' }] },
+    });
+  });
+
+  it('falls back to accumulated text when result has no result field', async () => {
+    const { manager, child } = createManager();
+    await manager.send('t:lead', { text: 'x', messageId: 'm1', workDir: '/proj' });
+    child.stdout.emit(
+      'data',
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'partial reply' }] },
+      }) + '\n'
+    );
+    let completeText = '';
+    manager.on('event', (e: { kind: string; text?: string }) => {
+      if (e.kind === 'complete') completeText = e.text ?? '';
+    });
+    child.stdout.emit('data', JSON.stringify({ type: 'result', subtype: 'success' }) + '\n');
+    expect(completeText).toBe('partial reply');
+  });
+
+  it('emits permission-request when a can_use_tool control_request arrives', async () => {
+    const { manager, child } = createManager();
+    await manager.send('t:lead', { text: 'x', messageId: 'm1', workDir: '/proj' });
+    const events: {
+      kind: string;
+      requestId?: string;
+      subtype?: string;
+      toolName?: string;
+      runId?: string;
+    }[] = [];
+    manager.on('event', (e) => {
+      if (e.kind === 'permission-request') events.push(e as (typeof events)[number]);
+    });
+    child.stdout.emit(
+      'data',
+      JSON.stringify({
+        type: 'control_request',
+        request_id: 'req_42',
+        request: { subtype: 'can_use_tool', tool_name: 'Bash', input: { command: 'ls' } },
+      }) + '\n'
+    );
+    expect(events).toHaveLength(1);
+    expect(events[0]).toMatchObject({
+      kind: 'permission-request',
+      requestId: 'req_42',
+      subtype: 'can_use_tool',
+      toolName: 'Bash',
+      toolInput: { command: 'ls' },
+    });
+    expect(typeof events[0].runId).toBe('string');
+  });
+
+  it('respondPermission writes a control_response line to stdin (allow/deny)', async () => {
+    const { manager, child } = createManager();
+    await manager.send('t:lead', { text: 'x', messageId: 'm1', workDir: '/proj' });
+    const written: string[] = [];
+    child.stdin.write = (data: string) => {
+      written.push(data);
+      return true;
+    };
+    manager.respondPermission('t:lead', 'req_42', true);
+    manager.respondPermission('t:lead', 'req_43', false, 'User denied');
+    expect(written.map((line) => JSON.parse(line.trim()))).toEqual([
+      {
+        type: 'control_response',
+        response: {
+          subtype: 'success',
+          request_id: 'req_42',
+          response: { behavior: 'allow', updatedInput: {} },
+        },
+      },
+      {
+        type: 'control_response',
+        response: {
+          subtype: 'success',
+          request_id: 'req_43',
+          response: { behavior: 'deny', message: 'User denied' },
+        },
+      },
+    ]);
+  });
+
+  it('respondPermission passes updatedInput through for AskUserQuestion answers (allow)', async () => {
+    const { manager, child } = createManager();
+    await manager.send('t:lead', { text: 'x', messageId: 'm1', workDir: '/proj' });
+    const written: string[] = [];
+    child.stdin.write = (data: string) => {
+      written.push(data);
+      return true;
+    };
+    const answers = { 'Pick one': 'A' };
+    manager.respondPermission('t:lead', 'req_99', true, undefined, {
+      ...{ prompt: 'Pick one' },
+      answers,
+    });
+    const parsed = JSON.parse(written[0].trim());
+    expect(parsed).toEqual({
+      type: 'control_response',
+      response: {
+        subtype: 'success',
+        request_id: 'req_99',
+        response: { behavior: 'allow', updatedInput: { prompt: 'Pick one', answers } },
+      },
+    });
+  });
+
+  it('respondPermission throws when the session is not running', async () => {
+    const { manager } = createManager();
+    expect(() => manager.respondPermission('missing:lead', 'req_1', true)).toThrow(
+      /is not running/
+    );
+  });
+
+  it('ignores parse-error and unknown lines without emitting', async () => {
+    const { manager, child } = createManager();
+    await manager.send('t:lead', { text: 'x', messageId: 'm1', workDir: '/proj' });
+    const events: string[] = [];
+    manager.on('event', (e: { kind: string }) => events.push(e.kind));
+    child.stdout.emit('data', 'this is not json\n');
+    child.stdout.emit('data', JSON.stringify({ type: 'stream_event' }) + '\n');
+    expect(events).toEqual([]);
+  });
+
+  it('emits error and drops the handle when the process exits non-zero mid-turn', async () => {
+    const { manager, child } = createManager();
+    const events: { kind: string; error?: string }[] = [];
+    manager.on('event', (e: { kind: string; error?: string }) => events.push(e));
+    await manager.send('t:lead', { text: 'x', messageId: 'm1', workDir: '/proj' });
+    child.emitExit(1);
+    expect(events.some((e) => e.kind === 'error')).toBe(true);
+    expect(manager.has('t:lead')).toBe(false);
+  });
+
+  it('synthesizes a complete event on clean exit mid-turn (no stuck bubble)', async () => {
+    const { manager, child } = createManager();
+    const events: { kind: string; text?: string }[] = [];
+    manager.on('event', (e: { kind: string; text?: string }) => events.push(e));
+    await manager.send('t:lead', { text: 'x', messageId: 'm1', workDir: '/proj' });
+    // No `result` line ever arrives — claude exits cleanly (e.g. bailed after a
+    // permission prompt). The turn must still terminate so the optimistic bubble
+    // doesn't hang forever.
+    child.emitExit(0);
+    expect(events.some((e) => e.kind === 'complete')).toBe(true);
+    expect(manager.has('t:lead')).toBe(false);
+  });
+
+  it('shutdown kills all live sessions', async () => {
+    const killed: string[] = [];
+    const child = createFakeChild();
+    child.kill = (signal?: string) => {
+      killed.push(signal ?? 'none');
+    };
+    const manager = new DirectCliSessionManager({
+      spawnFn: () => child as unknown as import('child_process').ChildProcess,
+      envResolver: async () => ({ env: {}, providerArgs: [] }),
+      binaryResolver: { resolve: async () => '/fake/claude' } as never,
+      store: new Map<string, string>() as never,
+    });
+    await manager.ensureSession({ sessionKey: 'a:lead', workDir: '/p' });
+    await manager.ensureSession({ sessionKey: 'b:lead', workDir: '/p' });
+    manager.shutdown();
+    expect(killed.length).toBe(2);
+    expect(manager.has('a:lead')).toBe(false);
+  });
+
+  it('throws a clear error when workDir is missing', async () => {
+    const manager = new DirectCliSessionManager({
+      spawnFn: () => createFakeChild() as unknown as import('child_process').ChildProcess,
+      envResolver: async () => ({ env: {}, providerArgs: [] }),
+      binaryResolver: { resolve: async () => '/fake/claude' } as never,
+      store: new Map<string, string>() as never,
+    });
+    await expect(manager.ensureSession({ sessionKey: 't:lead', workDir: '' })).rejects.toThrow(
+      /workDir/
+    );
+  });
+});