@assistkick/create 1.10.0 → 1.12.0

package/templates/assistkick-product-system/packages/backend/src/services/chat_cli_bridge.test.ts

@@ -0,0 +1,427 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, unlinkSync, readFileSync } from 'node:fs';
+import { ChatCliBridge, type PermissionMode } from './chat_cli_bridge.ts';
+
+/**
+ * Create a mock ChildProcess with controllable stdout/stderr/stdin.
+ * Allows simulating CLI output by pushing data and firing close/error events.
+ */
+const createMockChildProcess = () => {
+  const stdoutListeners: Record<string, Function[]> = {};
+  const stderrListeners: Record<string, Function[]> = {};
+  const processListeners: Record<string, Function[]> = {};
+
+  return {
+    stdin: {
+      write: mock.fn(),
+      end: mock.fn(),
+    },
+    stdout: {
+      on: mock.fn((event: string, cb: Function) => {
+        if (!stdoutListeners[event]) stdoutListeners[event] = [];
+        stdoutListeners[event].push(cb);
+      }),
+    },
+    stderr: {
+      on: mock.fn((event: string, cb: Function) => {
+        if (!stderrListeners[event]) stderrListeners[event] = [];
+        stderrListeners[event].push(cb);
+      }),
+    },
+    on: mock.fn((event: string, cb: Function) => {
+      if (!processListeners[event]) processListeners[event] = [];
+      processListeners[event].push(cb);
+    }),
+    kill: mock.fn(),
+    killed: false,
+    _emitStdout: (data: string) => {
+      for (const cb of stdoutListeners['data'] || []) cb(Buffer.from(data));
+    },
+    _emitStderr: (data: string) => {
+      for (const cb of stderrListeners['data'] || []) cb(Buffer.from(data));
+    },
+    _emitClose: (code: number | null) => {
+      for (const cb of processListeners['close'] || []) cb(code);
+    },
+    _emitError: (err: Error) => {
+      for (const cb of processListeners['error'] || []) cb(err);
+    },
+  };
+};
+
+/** Capture the args passed to spawn for assertions. */
+let lastSpawnArgs: { cmd: string; args: string[]; options: Record<string, unknown> } | null = null;
+let mockChild: ReturnType<typeof createMockChildProcess>;
+
+describe('ChatCliBridge', () => {
+  let bridge: ChatCliBridge;
+  let logMock: ReturnType<typeof mock.fn>;
+  const WORKSPACES_DIR = '/data/workspaces';
+  const PROJECT_ID = 'proj_test123';
+
+  /** Track MCP config files created during tests for cleanup */
+  const createdConfigs: string[] = [];
+
+  beforeEach(() => {
+    logMock = mock.fn();
+    mockChild = createMockChildProcess();
+    lastSpawnArgs = null;
+
+    bridge = new ChatCliBridge({
+      workspacesDir: WORKSPACES_DIR,
+      log: logMock,
+      backendPort: 3000,
+    });
+  });
+
+  afterEach(() => {
+    for (const path of createdConfigs) {
+      try { unlinkSync(path); } catch { /* already cleaned */ }
+    }
+    createdConfigs.length = 0;
+  });
+
+  describe('getWorkspaceCwd', () => {
+    it('returns the correct workspace path for a project', () => {
+      const cwd = bridge.getWorkspaceCwd('proj_abc');
+      assert.equal(cwd, '/data/workspaces/proj_abc');
+    });
+
+    it('uses the injected workspacesDir', () => {
+      const customBridge = new ChatCliBridge({
+        workspacesDir: '/custom/path',
+        log: logMock,
+      });
+      assert.equal(customBridge.getWorkspaceCwd('proj_x'), '/custom/path/proj_x');
+    });
+  });
+
+  describe('buildArgs', () => {
+    const baseOptions = {
+      projectId: PROJECT_ID,
+      message: 'Hello',
+      claudeSessionId: 'session-uuid-123',
+      isNewSession: true,
+      permissionMode: 'skip' as PermissionMode,
+      onEvent: mock.fn(),
+    };
+
+    it('includes -p - for stdin prompt delivery', () => {
+      const { args } = bridge.buildArgs(baseOptions);
+      const pIdx = args.indexOf('-p');
+      assert.ok(pIdx !== -1);
+      assert.equal(args[pIdx + 1], '-');
+    });
+
+    it('includes stream-json output format', () => {
+      const { args } = bridge.buildArgs(baseOptions);
+      const fmtIdx = args.indexOf('--output-format');
+      assert.ok(fmtIdx !== -1);
+      assert.equal(args[fmtIdx + 1], 'stream-json');
+    });
+
+    it('includes --verbose flag', () => {
+      const { args } = bridge.buildArgs(baseOptions);
+      assert.ok(args.includes('--verbose'));
+    });
+
+    it('includes --include-partial-messages flag', () => {
+      const { args } = bridge.buildArgs(baseOptions);
+      assert.ok(args.includes('--include-partial-messages'));
+    });
+
+    it('includes --append-system-prompt with project context', () => {
+      const { args } = bridge.buildArgs(baseOptions);
+      const promptIdx = args.indexOf('--append-system-prompt');
+      assert.ok(promptIdx !== -1);
+      assert.ok(args[promptIdx + 1].startsWith(`We are working on project-id ${PROJECT_ID}`));
+    });
+
+    describe('session mode', () => {
+      it('uses --session-id for new sessions', () => {
+        const { args } = bridge.buildArgs({ ...baseOptions, isNewSession: true });
+        assert.ok(args.includes('--session-id'));
+        assert.ok(!args.includes('--resume'));
+        assert.ok(args.includes('session-uuid-123'));
+      });
+
+      it('uses --resume for existing sessions', () => {
+        const { args } = bridge.buildArgs({ ...baseOptions, isNewSession: false });
+        assert.ok(args.includes('--resume'));
+        assert.ok(!args.includes('--session-id'));
+        assert.ok(args.includes('session-uuid-123'));
+      });
+    });
+
+    describe('permission modes', () => {
+      it('uses --dangerously-skip-permissions for skip mode', () => {
+        const { args } = bridge.buildArgs({ ...baseOptions, permissionMode: 'skip' });
+        assert.ok(args.includes('--dangerously-skip-permissions'));
+      });
+
+      it('uses --allowedTools for allowed_tools mode', () => {
+        const { args } = bridge.buildArgs({
+          ...baseOptions,
+          permissionMode: 'allowed_tools',
+          allowedTools: ['Read', 'Glob', 'Grep'],
+        });
+        assert.ok(!args.includes('--dangerously-skip-permissions'));
+        const allowedIndices = args.reduce((acc: number[], arg, i) => {
+          if (arg === '--allowedTools') acc.push(i);
+          return acc;
+        }, []);
+        assert.equal(allowedIndices.length, 3);
+        assert.equal(args[allowedIndices[0] + 1], 'Read');
+        assert.equal(args[allowedIndices[1] + 1], 'Glob');
+        assert.equal(args[allowedIndices[2] + 1], 'Grep');
+      });
+
+      it('uses --permission-prompt-tool and --mcp-config for prompt mode', () => {
+        const { args } = bridge.buildArgs({
+          ...baseOptions,
+          permissionMode: 'prompt',
+          permissionPromptTool: 'mcp__permission__ask',
+        });
+        assert.ok(!args.includes('--dangerously-skip-permissions'));
+
+        // Should have --mcp-config
+        const mcpConfigIdx = args.indexOf('--mcp-config');
+        assert.ok(mcpConfigIdx !== -1);
+        const configPath = args[mcpConfigIdx + 1];
+        assert.ok(configPath.includes('mcp-perm-'));
+        createdConfigs.push(configPath);
+
+        // Should have --permission-prompt-tool
+        const promptToolIdx = args.indexOf('--permission-prompt-tool');
+        assert.ok(promptToolIdx !== -1);
+        assert.equal(args[promptToolIdx + 1], 'mcp__permission__ask');
+      });
+
+      it('uses default tool name mcp__permission__ask when none specified for prompt mode', () => {
+        const { args } = bridge.buildArgs({
+          ...baseOptions,
+          permissionMode: 'prompt',
+        });
+
+        const promptToolIdx = args.indexOf('--permission-prompt-tool');
+        assert.ok(promptToolIdx !== -1);
+        assert.equal(args[promptToolIdx + 1], 'mcp__permission__ask');
+
+        // Clean up config
+        const mcpConfigIdx = args.indexOf('--mcp-config');
+        if (mcpConfigIdx !== -1) createdConfigs.push(args[mcpConfigIdx + 1]);
+      });
+
+      it('falls through to no permission flag when allowed_tools has empty list', () => {
+        const { args } = bridge.buildArgs({
+          ...baseOptions,
+          permissionMode: 'allowed_tools',
+          allowedTools: [],
+        });
+        assert.ok(!args.includes('--dangerously-skip-permissions'));
+        assert.ok(!args.includes('--allowedTools'));
+      });
+    });
+
+    describe('systemPrompt return value', () => {
+      it('returns the composed system prompt for new sessions', () => {
+        const { systemPrompt } = bridge.buildArgs({ ...baseOptions, isNewSession: true });
+        assert.ok(systemPrompt !== null);
+        assert.ok(systemPrompt!.includes(`We are working on project-id ${PROJECT_ID}`));
+      });
+
+      it('returns null systemPrompt for resumed sessions', () => {
+        const { systemPrompt } = bridge.buildArgs({ ...baseOptions, isNewSession: false });
+        assert.equal(systemPrompt, null);
+      });
+
+      it('includes continuation context in systemPrompt when provided', () => {
+        const { systemPrompt } = bridge.buildArgs({
+          ...baseOptions,
+          isNewSession: true,
+          continuationContext: 'Previous conversation summary here',
+        });
+        assert.ok(systemPrompt !== null);
+        assert.ok(systemPrompt!.includes('Previous conversation summary here'));
+        assert.ok(systemPrompt!.includes(`We are working on project-id ${PROJECT_ID}`));
+      });
+    });
+  });
+
+  describe('generateMcpConfig', () => {
+    it('creates a config file at the expected path', () => {
+      const configPath = bridge.generateMcpConfig('test-session-id', 'proj_123');
+      createdConfigs.push(configPath);
+      assert.ok(existsSync(configPath));
+      assert.ok(configPath.includes('mcp-perm-test-session'));
+    });
+
+    it('config file contains correct JSON structure', () => {
+      const configPath = bridge.generateMcpConfig('test-session-2', 'proj_456');
+      createdConfigs.push(configPath);
+
+      const content = JSON.parse(readFileSync(configPath, 'utf-8'));
+      assert.ok(content.mcpServers);
+      assert.ok(content.mcpServers.permission);
+      assert.equal(content.mcpServers.permission.command, 'npx');
+      assert.ok(Array.isArray(content.mcpServers.permission.args));
+      assert.equal(content.mcpServers.permission.env.CLAUDE_SESSION_ID, 'test-session-2');
+      assert.equal(content.mcpServers.permission.env.PROJECT_ID, 'proj_456');
+      assert.equal(content.mcpServers.permission.env.BACKEND_URL, 'http://localhost:3000');
+    });
+  });
+
+  describe('cleanupMcpConfig', () => {
+    it('removes the config file', () => {
+      const configPath = bridge.generateMcpConfig('cleanup-session', 'proj_789');
+      assert.ok(existsSync(configPath));
+      bridge.cleanupMcpConfig('cleanup-session');
+      assert.ok(!existsSync(configPath));
+    });
+
+    it('does not throw when config does not exist', () => {
+      assert.doesNotThrow(() => bridge.cleanupMcpConfig('nonexistent'));
+    });
+  });
+
+  describe('buildEnv', () => {
+    it('returns an environment object with PATH augmented', () => {
+      const env = bridge.buildEnv();
+      assert.ok(typeof env.PATH === 'string');
+      assert.ok(env.PATH.includes('/usr/local/bin'));
+    });
+
+    it('preserves existing environment variables', () => {
+      const originalHome = process.env.HOME;
+      const env = bridge.buildEnv();
+      assert.equal(env.HOME, originalHome);
+    });
+  });
+
+  describe('kill', () => {
+    it('returns false when no active process for session', () => {
+      assert.equal(bridge.kill('nonexistent'), false);
+    });
+  });
+
+  describe('isActive', () => {
+    it('returns false for unknown session', () => {
+      assert.equal(bridge.isActive('nonexistent'), false);
+    });
+  });
+
+  describe('getActiveCount', () => {
+    it('returns 0 when no processes are active', () => {
+      assert.equal(bridge.getActiveCount(), 0);
+    });
+  });
+
+  describe('killAll', () => {
+    it('does not throw when no processes are active', () => {
+      assert.doesNotThrow(() => bridge.killAll());
+    });
+  });
+
+  describe('processLine (via spawn event parsing)', () => {
+    it('parses valid JSON events and calls onEvent', () => {
+      const events: Record<string, unknown>[] = [];
+      const onEvent = (event: Record<string, unknown>) => { events.push(event); };
+      const processLine = (bridge as any).processLine.bind(bridge);
+
+      const assistantEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'Hello world' }] },
+      });
+
+      processLine(assistantEvent, onEvent, mock.fn());
+      assert.equal(events.length, 1);
+      assert.equal(events[0].type, 'assistant');
+    });
+
+    it('captures session_id from result events', () => {
+      let capturedSessionId: string | null = null;
+      const onSessionId = (sid: string) => { capturedSessionId = sid; };
+      const processLine = (bridge as any).processLine.bind(bridge);
+
+      const resultEvent = JSON.stringify({
+        type: 'result',
+        session_id: 'captured-session-uuid',
+        cost_usd: 0.05,
+        duration_ms: 3000,
+      });
+
+      processLine(resultEvent, mock.fn(), onSessionId);
+      assert.equal(capturedSessionId, 'captured-session-uuid');
+    });
+
+    it('does not capture session_id from non-result events', () => {
+      let capturedSessionId: string | null = null;
+      const onSessionId = (sid: string) => { capturedSessionId = sid; };
+      const processLine = (bridge as any).processLine.bind(bridge);
+
+      const assistantEvent = JSON.stringify({
+        type: 'assistant',
+        session_id: 'should-not-capture',
+      });
+
+      processLine(assistantEvent, mock.fn(), onSessionId);
+      assert.equal(capturedSessionId, null);
+    });
+
+    it('skips invalid JSON lines silently', () => {
+      const events: Record<string, unknown>[] = [];
+      const processLine = (bridge as any).processLine.bind(bridge);
+
+      processLine('not valid json', (e: any) => events.push(e), mock.fn());
+      processLine('', (e: any) => events.push(e), mock.fn());
+      processLine('{incomplete', (e: any) => events.push(e), mock.fn());
+
+      assert.equal(events.length, 0);
+    });
+
+    it('parses tool_use events correctly', () => {
+      const events: Record<string, unknown>[] = [];
+      const processLine = (bridge as any).processLine.bind(bridge);
+
+      const toolEvent = JSON.stringify({
+        type: 'assistant',
+        message: {
+          content: [
+            { type: 'tool_use', name: 'Read', input: { file_path: '/test/file.ts' } },
+          ],
+        },
+      });
+
+      processLine(toolEvent, (e: any) => events.push(e), mock.fn());
+
+      assert.equal(events.length, 1);
+      const msg = events[0].message as any;
+      assert.equal(msg.content[0].type, 'tool_use');
+      assert.equal(msg.content[0].name, 'Read');
+    });
+
+    it('parses result event with cost and duration', () => {
+      const events: Record<string, unknown>[] = [];
+      const processLine = (bridge as any).processLine.bind(bridge);
+
+      const resultEvent = JSON.stringify({
+        type: 'result',
+        session_id: 'test-uuid',
+        cost_usd: 0.0123,
+        duration_ms: 5432,
+        num_turns: 3,
+        stop_reason: 'end_turn',
+        result: 'Final response text',
+      });
+
+      processLine(resultEvent, (e: any) => events.push(e), mock.fn());
+
+      assert.equal(events.length, 1);
+      assert.equal(events[0].type, 'result');
+      assert.equal(events[0].cost_usd, 0.0123);
+      assert.equal(events[0].duration_ms, 5432);
+      assert.equal(events[0].result, 'Final response text');
+    });
+  });
+});