@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/ask/non-streaming-api.test.ts

@@ -0,0 +1,281 @@
+import { describe, it, expect } from 'vitest';
+
+/**
+ * Tests for non-streaming API fallback.
+ * Verifies:
+ * 1. pi-ai → OpenAI message format conversion
+ * 2. SSE response reassembly (for proxies that ignore stream:false)
+ */
+
+// ─────────────────────────────────────────────────
+// Replicate helper functions from route.ts for unit testing
+// ─────────────────────────────────────────────────
+
+function piMessagesToOpenAI(piMessages: any[]): any[] {
+  return piMessages.map(msg => {
+    const role = msg.role;
+    if (role === 'system') return null;
+    if (role === 'user') {
+      return { role: 'user', content: typeof msg.content === 'string' ? msg.content : msg.content };
+    }
+    if (role === 'assistant') {
+      const content = msg.content;
+      let textContent = '';
+      const toolCalls: any[] = [];
+      if (Array.isArray(content)) {
+        for (const part of content) {
+          if (part.type === 'text' && part.text) {
+            textContent += part.text;
+          } else if (part.type === 'toolCall') {
+            toolCalls.push({
+              id: part.id ?? `call_fallback`,
+              type: 'function',
+              function: { name: part.name ?? 'unknown', arguments: JSON.stringify(part.arguments ?? {}) },
+            });
+          }
+        }
+      }
+      const result: any = { role: 'assistant' };
+      result.content = textContent || '';
+      if (toolCalls.length > 0) result.tool_calls = toolCalls;
+      return result;
+    }
+    if (role === 'toolResult') {
+      const contentText = Array.isArray(msg.content)
+        ? msg.content.filter((c: any) => c.type === 'text').map((c: any) => c.text ?? '').join('\n')
+        : String(msg.content ?? '');
+      return { role: 'tool', tool_call_id: msg.toolCallId ?? 'unknown', content: contentText };
+    }
+    return null;
+  }).filter(Boolean);
+}
+
+function reassembleSSE(sseText: string): any {
+  const lines = sseText.split('\n');
+  let content = '';
+  let role = 'assistant';
+  let finishReason = 'stop';
+  const toolCalls: Map<number, { id: string; type: string; function: { name: string; arguments: string } }> = new Map();
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('data:')) continue;
+    const payload = trimmed.slice(5).trim();
+    if (payload === '[DONE]') break;
+    let chunk: any;
+    try { chunk = JSON.parse(payload); } catch { continue; }
+    const delta = chunk?.choices?.[0]?.delta;
+    if (!delta) continue;
+    if (delta.role) role = delta.role;
+    if (delta.content) content += delta.content;
+    if (chunk.choices[0].finish_reason) finishReason = chunk.choices[0].finish_reason;
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        const idx = tc.index ?? 0;
+        const existing = toolCalls.get(idx);
+        if (!existing) {
+          toolCalls.set(idx, {
+            id: tc.id ?? '',
+            type: tc.type ?? 'function',
+            function: { name: tc.function?.name ?? '', arguments: tc.function?.arguments ?? '' },
+          });
+        } else {
+          if (tc.id) existing.id = tc.id;
+          if (tc.function?.name) existing.function.name += tc.function.name;
+          if (tc.function?.arguments) existing.function.arguments += tc.function.arguments;
+        }
+      }
+    }
+  }
+
+  const message: any = { role, content: content || null };
+  if (toolCalls.size > 0) {
+    message.tool_calls = Array.from(toolCalls.values());
+  }
+  return { choices: [{ message, finish_reason: finishReason }] };
+}
+
+// ─────────────────────────────────────────────────
+// piMessagesToOpenAI tests
+// ─────────────────────────────────────────────────
+
+describe('piMessagesToOpenAI', () => {
+  it('converts plain user message', () => {
+    expect(piMessagesToOpenAI([{ role: 'user', content: 'Hello!' }]))
+      .toEqual([{ role: 'user', content: 'Hello!' }]);
+  });
+
+  it('converts assistant text-only message', () => {
+    const result = piMessagesToOpenAI([{
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Response' }],
+    }]);
+    expect(result).toEqual([{ role: 'assistant', content: 'Response' }]);
+  });
+
+  it('converts assistant message with tool calls', () => {
+    const result = piMessagesToOpenAI([{
+      role: 'assistant',
+      content: [
+        { type: 'text', text: 'Calling tool' },
+        { type: 'toolCall', id: 'call_1', name: 'read_file', arguments: { path: '/tmp' } },
+      ],
+    }]);
+    expect(result[0].content).toBe('Calling tool');
+    expect(result[0].tool_calls[0]).toMatchObject({
+      id: 'call_1', type: 'function',
+      function: { name: 'read_file', arguments: '{"path":"/tmp"}' },
+    });
+  });
+
+  it('converts tool result message', () => {
+    expect(piMessagesToOpenAI([{
+      role: 'toolResult', toolCallId: 'call_1',
+      content: [{ type: 'text', text: 'result data' }],
+    }])).toEqual([{ role: 'tool', tool_call_id: 'call_1', content: 'result data' }]);
+  });
+
+  it('skips system messages', () => {
+    const result = piMessagesToOpenAI([
+      { role: 'system', content: 'sys' },
+      { role: 'user', content: 'hi' },
+    ]);
+    expect(result).toHaveLength(1);
+    expect(result[0].role).toBe('user');
+  });
+
+  it('handles empty assistant content', () => {
+    const result = piMessagesToOpenAI([{ role: 'assistant', content: [] }]);
+    expect(result[0]).toEqual({ role: 'assistant', content: '' });
+  });
+
+  it('handles complex conversation history', () => {
+    const result = piMessagesToOpenAI([
+      { role: 'user', content: 'list files' },
+      { role: 'assistant', content: [
+        { type: 'text', text: 'checking' },
+        { type: 'toolCall', id: 'c1', name: 'ls', arguments: {} },
+      ]},
+      { role: 'toolResult', toolCallId: 'c1', content: [{ type: 'text', text: 'a.txt' }] },
+      { role: 'assistant', content: [{ type: 'text', text: 'Found a.txt' }] },
+    ]);
+    expect(result).toHaveLength(4);
+    expect(result[0].role).toBe('user');
+    expect(result[1].role).toBe('assistant');
+    expect(result[1].tool_calls).toHaveLength(1);
+    expect(result[2].role).toBe('tool');
+    expect(result[3]).toMatchObject({ role: 'assistant', content: 'Found a.txt' });
+  });
+});
+
+// ─────────────────────────────────────────────────
+// reassembleSSE tests
+// ─────────────────────────────────────────────────
+
+describe('reassembleSSE', () => {
+  it('reassembles simple text SSE response', () => {
+    const sse = [
+      'data: {"choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"content":"Hello"},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"content":"!"},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"content":""},"finish_reason":"stop"}]}',
+      'data: [DONE]',
+    ].join('\n');
+
+    const result = reassembleSSE(sse);
+    expect(result.choices[0].message.content).toBe('Hello!');
+    expect(result.choices[0].message.role).toBe('assistant');
+    expect(result.choices[0].finish_reason).toBe('stop');
+  });
+
+  it('handles ikuncode-style empty response (proxy returns SSE with no content)', () => {
+    // This is the actual response from ikuncode when stream:false is sent
+    const sse = [
+      'data: {"id":"","object":"chat.completion.chunk","created":0,"model":"gpt-5.4","choices":[],"usage":{"prompt_tokens":28,"completion_tokens":0,"total_tokens":28}}',
+      '',
+      'data: [DONE]',
+    ].join('\n');
+
+    const result = reassembleSSE(sse);
+    // Should return empty content (no choices with delta)
+    expect(result.choices[0].message.content).toBeNull();
+    expect(result.choices[0].message.role).toBe('assistant');
+  });
+
+  it('reassembles SSE with tool calls', () => {
+    const sse = [
+      'data: {"choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_abc","type":"function","function":{"name":"read_","arguments":""}}]},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"name":"file","arguments":"{\\"pa"}}]},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"th\\":\\"/tmp\\"}"}}]},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"content":""},"finish_reason":"tool_calls"}]}',
+      'data: [DONE]',
+    ].join('\n');
+
+    const result = reassembleSSE(sse);
+    const msg = result.choices[0].message;
+    expect(msg.tool_calls).toHaveLength(1);
+    expect(msg.tool_calls[0].id).toBe('call_abc');
+    expect(msg.tool_calls[0].function.name).toBe('read_file');
+    expect(msg.tool_calls[0].function.arguments).toBe('{"path":"/tmp"}');
+    expect(result.choices[0].finish_reason).toBe('tool_calls');
+  });
+
+  it('handles SSE with multiple tool calls', () => {
+    const sse = [
+      'data: {"choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"c1","type":"function","function":{"name":"tool_a","arguments":"{}"}}]},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":1,"id":"c2","type":"function","function":{"name":"tool_b","arguments":"{}"}}]},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"content":""},"finish_reason":"tool_calls"}]}',
+      'data: [DONE]',
+    ].join('\n');
+
+    const result = reassembleSSE(sse);
+    expect(result.choices[0].message.tool_calls).toHaveLength(2);
+    expect(result.choices[0].message.tool_calls[0].id).toBe('c1');
+    expect(result.choices[0].message.tool_calls[1].id).toBe('c2');
+  });
+
+  it('handles SSE with text + tool calls mixed', () => {
+    const sse = [
+      'data: {"choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"content":"Let me "},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"content":"check."},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"c1","type":"function","function":{"name":"search","arguments":"{\\"q\\":\\"test\\"}"}}]},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"content":""},"finish_reason":"tool_calls"}]}',
+      'data: [DONE]',
+    ].join('\n');
+
+    const result = reassembleSSE(sse);
+    expect(result.choices[0].message.content).toBe('Let me check.');
+    expect(result.choices[0].message.tool_calls).toHaveLength(1);
+  });
+
+  it('skips invalid SSE lines gracefully', () => {
+    const sse = [
+      'data: {"choices":[{"index":0,"delta":{"content":"OK"},"finish_reason":null}]}',
+      'data: INVALID_JSON',
+      '',
+      ':comment line',
+      'data: {"choices":[{"index":0,"delta":{"content":""},"finish_reason":"stop"}]}',
+      'data: [DONE]',
+    ].join('\n');
+
+    const result = reassembleSSE(sse);
+    expect(result.choices[0].message.content).toBe('OK');
+  });
+
+  it('handles SSE with usage chunk at end (no delta)', () => {
+    const sse = [
+      'data: {"choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"content":"Hi"},"finish_reason":null}]}',
+      'data: {"choices":[{"index":0,"delta":{"content":""},"finish_reason":"stop"}]}',
+      'data: {"choices":[],"usage":{"prompt_tokens":10,"completion_tokens":5,"total_tokens":15}}',
+      'data: [DONE]',
+    ].join('\n');
+
+    const result = reassembleSSE(sse);
+    expect(result.choices[0].message.content).toBe('Hi');
+    expect(result.choices[0].finish_reason).toBe('stop');
+  });
+});

package/_standalone/__tests__/ask/save-insight.test.ts

@@ -0,0 +1,84 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { generateInsightPath, cleanInsightContent, formatInsightMarkdown } from '@/components/ask/save-insight-utils';
+
+describe('generateInsightPath', () => {
+  it('generates a path with Inbox prefix and date slug', () => {
+    const result = generateInsightPath('Some analysis about AI agents', new Date('2026-04-09'));
+    expect(result).toBe('Inbox/insight-2026-04-09.md');
+  });
+
+  it('generates a consistent path format for any content', () => {
+    const result = generateInsightPath('Short', new Date('2026-01-15'));
+    expect(result).toBe('Inbox/insight-2026-01-15.md');
+  });
+
+  it('handles empty content gracefully', () => {
+    const result = generateInsightPath('', new Date('2026-04-09'));
+    expect(result).toBe('Inbox/insight-2026-04-09.md');
+  });
+
+  it('appends counter when path would collide with existing files', () => {
+    const existing = new Set(['Inbox/insight-2026-04-09.md']);
+    const result = generateInsightPath('content', new Date('2026-04-09'), existing);
+    expect(result).toBe('Inbox/insight-2026-04-09-2.md');
+  });
+
+  it('increments counter for multiple collisions', () => {
+    const existing = new Set([
+      'Inbox/insight-2026-04-09.md',
+      'Inbox/insight-2026-04-09-2.md',
+    ]);
+    const result = generateInsightPath('content', new Date('2026-04-09'), existing);
+    expect(result).toBe('Inbox/insight-2026-04-09-3.md');
+  });
+});
+
+describe('cleanInsightContent', () => {
+  it('strips thinking tags from content', () => {
+    const input = '<thinking>some reasoning</thinking>The actual answer is 42.';
+    expect(cleanInsightContent(input)).toBe('The actual answer is 42.');
+  });
+
+  it('preserves normal markdown content', () => {
+    const input = '# Title\n\nSome **bold** text and a [link](url).';
+    expect(cleanInsightContent(input)).toBe(input);
+  });
+
+  it('returns empty string for content that is only thinking', () => {
+    const input = '<thinking>all thinking</thinking>';
+    expect(cleanInsightContent(input)).toBe('');
+  });
+
+  it('handles content with no thinking tags', () => {
+    const input = 'Just regular text';
+    expect(cleanInsightContent(input)).toBe('Just regular text');
+  });
+
+  it('trims whitespace after stripping', () => {
+    const input = '<thinking>blah</thinking>  \n  Real content  ';
+    expect(cleanInsightContent(input)).toBe('Real content');
+  });
+});
+
+describe('formatInsightMarkdown', () => {
+  it('wraps content with metadata header', () => {
+    const result = formatInsightMarkdown('Analysis content here', new Date('2026-04-09T10:30:00Z'));
+    expect(result).toContain('Analysis content here');
+    expect(result).toContain('2026-04-09');
+    expect(result).toMatch(/^> Saved from MindOS Ask/m);
+  });
+
+  it('handles multi-line content', () => {
+    const content = '# Title\n\n- Point 1\n- Point 2';
+    const result = formatInsightMarkdown(content, new Date('2026-04-09'));
+    expect(result).toContain('- Point 1');
+    expect(result).toContain('- Point 2');
+  });
+
+  it('produces valid markdown', () => {
+    const result = formatInsightMarkdown('test', new Date('2026-04-09'));
+    expect(result.startsWith('>')).toBe(true);
+    expect(result).toContain('\n\ntest');
+  });
+});

package/_standalone/__tests__/ask/save-session.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+import {
+  generateSessionPath,
+  formatSessionContent,
+  sessionPreviewStats,
+} from '@/components/ask/save-insight-utils';
+import type { Message } from '@/lib/types';
+
+const mockMessages: Message[] = [
+  { role: 'user', content: 'What is React?' },
+  { role: 'assistant', content: 'React is a JavaScript library for building UIs.' },
+  { role: 'user', content: 'What about hooks?' },
+  { role: 'assistant', content: '<thinking>Let me explain hooks.</thinking>Hooks are functions that let you use state in function components.' },
+];
+
+describe('generateSessionPath', () => {
+  it('generates date-based session path', () => {
+    const path = generateSessionPath(new Date('2026-04-10'));
+    expect(path).toBe('Inbox/session-2026-04-10.md');
+  });
+});
+
+describe('formatSessionContent', () => {
+  it('formats full conversation with role headers', () => {
+    const result = formatSessionContent(mockMessages, 'full', new Date('2026-04-10'));
+    expect(result).toContain('> Saved session from MindOS Ask');
+    expect(result).toContain('### **User**');
+    expect(result).toContain('What is React?');
+    expect(result).toContain('### **Assistant**');
+    expect(result).toContain('React is a JavaScript library');
+    expect(result).toContain('---');
+  });
+
+  it('strips thinking tags in full format', () => {
+    const result = formatSessionContent(mockMessages, 'full', new Date('2026-04-10'));
+    expect(result).not.toContain('<thinking>');
+    expect(result).toContain('Hooks are functions');
+  });
+
+  it('formats AI-only with just assistant messages', () => {
+    const result = formatSessionContent(mockMessages, 'ai-only', new Date('2026-04-10'));
+    expect(result).toContain('React is a JavaScript library');
+    expect(result).toContain('Hooks are functions');
+    expect(result).not.toContain('What is React?');
+    expect(result).not.toContain('What about hooks?');
+  });
+
+  it('handles empty messages array', () => {
+    const result = formatSessionContent([], 'full', new Date('2026-04-10'));
+    expect(result).toContain('> Saved session from MindOS Ask');
+  });
+});
+
+describe('sessionPreviewStats', () => {
+  it('counts all messages for full format', () => {
+    const stats = sessionPreviewStats(mockMessages, 'full');
+    expect(stats.msgCount).toBe(4);
+    expect(stats.charCount).toBeGreaterThan(0);
+  });
+
+  it('counts only assistant messages for ai-only format', () => {
+    const stats = sessionPreviewStats(mockMessages, 'ai-only');
+    expect(stats.msgCount).toBe(2);
+    expect(stats.charCount).toBeGreaterThan(0);
+  });
+
+  it('excludes thinking tags from char count', () => {
+    const stats = sessionPreviewStats(mockMessages, 'ai-only');
+    // The thinking tag content should not be counted
+    const fullStats = sessionPreviewStats(mockMessages, 'full');
+    expect(fullStats.charCount).toBeGreaterThan(stats.charCount);
+  });
+});

package/_standalone/__tests__/channel-cli-layers.test.ts

@@ -0,0 +1,108 @@
+import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+let fakeHome: string;
+
+beforeEach(() => {
+  fakeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-channel-home-'));
+  vi.resetModules();
+  vi.doMock('node:os', async () => {
+    const actual = await vi.importActual<typeof import('node:os')>('node:os');
+    return {
+      ...actual,
+      homedir: () => fakeHome,
+    };
+  });
+});
+
+afterEach(() => {
+  vi.doUnmock('node:os');
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+  fs.rmSync(fakeHome, { recursive: true, force: true });
+});
+
+describe('channel config layer', () => {
+  it('keeps CLI and app validation aligned for alternative credential sets', async () => {
+    const { validateChannelConfig } = await import('../../bin/lib/channel-config.js');
+    const { validatePlatformConfig } = await import('@/lib/im/config');
+
+    expect(validateChannelConfig('wecom', { webhook_key: 'abc123' })).toEqual({ valid: true });
+    expect(validatePlatformConfig('wecom', { webhook_key: 'abc123' })).toEqual({ valid: true });
+
+    expect(validateChannelConfig('wecom', { corp_id: 'wxcorp', corp_secret: 'corp-secret' })).toEqual({ valid: true });
+    expect(validatePlatformConfig('wecom', { corp_id: 'wxcorp', corp_secret: 'corp-secret' })).toEqual({ valid: true });
+
+    expect(validateChannelConfig('dingtalk', { webhook_url: 'https://example.com/hook' })).toEqual({ valid: true });
+    expect(validatePlatformConfig('dingtalk', { webhook_url: 'https://example.com/hook' })).toEqual({ valid: true });
+
+    expect(validateChannelConfig('dingtalk', { client_id: 'ding-app', client_secret: 'ding-secret' })).toEqual({ valid: true });
+    expect(validatePlatformConfig('dingtalk', { client_id: 'ding-app', client_secret: 'ding-secret' })).toEqual({ valid: true });
+  });
+
+  it('rejects telegram tokens consistently in CLI and app validation', async () => {
+    const { validateChannelConfig } = await import('../../bin/lib/channel-config.js');
+    const { validatePlatformConfig } = await import('@/lib/im/config');
+
+    expect(validateChannelConfig('telegram', { bot_token: 'bad-token' }).valid).toBe(false);
+    expect(validatePlatformConfig('telegram', { bot_token: 'bad-token' }).valid).toBe(false);
+  });
+
+  it('writes config with optimistic mtime protection', async () => {
+    const { writeChannelConfig, readChannelConfig, getChannelConfigMtime } = await import('../../bin/lib/channel-config.js');
+    writeChannelConfig({ providers: { telegram: { bot_token: '123456789:ABCdefGHIjklMNOpqrSTUvwxYZ' } } });
+    const mtime = getChannelConfigMtime();
+
+    const configPath = path.join(fakeHome, '.mindos', 'im.json');
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify({ providers: { discord: { bot_token: 'abc'.repeat(10) } } }), 'utf-8');
+
+    expect(() => {
+      writeChannelConfig({ providers: { telegram: { bot_token: '123456789:ABCdefGHIjklMNOpqrSTUvwxYZ' } } }, { expectedMtime: mtime - 1 });
+    }).toThrow('Configuration changed on disk. Retry your command.');
+
+    const onDisk = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    expect(onDisk).toEqual({ providers: { discord: { bot_token: 'abc'.repeat(10) } } });
+  });
+});
+
+describe('channel management layer', () => {
+  it('saves config when skipVerify is enabled', async () => {
+    const { channelAdd, channelVerify } = await import('../../bin/lib/channel-mgmt.js');
+    const add = await channelAdd('telegram', { bot_token: '123456789:ABCdefGHIjklMNOpqrSTUvwxYZ' }, { skipVerify: true });
+    expect(add.ok).toBe(true);
+    expect(add.message).toContain('verification skipped');
+
+    const verify = await channelVerify('telegram', { skipVerify: true });
+    expect(verify.valid).toBe(true);
+    expect(verify.details?.status).toBe('Format valid only');
+  });
+
+  it('does not save config when remote verification fails', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      status: 401,
+      json: async () => ({ error: 'Unauthorized: check bot_token' }),
+    }));
+
+    const { channelAdd } = await import('../../bin/lib/channel-mgmt.js');
+    const result = await channelAdd('telegram', { bot_token: '123456789:ABCdefGHIjklMNOpqrSTUvwxYZ' });
+    expect(result.ok).toBe(false);
+    expect(result.error).toContain('Use --skip-verify');
+
+    const configPath = path.join(fakeHome, '.mindos', 'im.json');
+    expect(fs.existsSync(configPath)).toBe(false);
+  });
+
+  it('surfaces timeout guidance when remote verification times out', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(Object.assign(new Error('Request timed out'), { name: 'TimeoutError' })));
+
+    const { channelAdd } = await import('../../bin/lib/channel-mgmt.js');
+    const result = await channelAdd('telegram', { bot_token: '123456789:ABCdefGHIjklMNOpqrSTUvwxYZ' });
+    expect(result.ok).toBe(false);
+    expect(result.error).toContain('Verification timed out');
+    expect(result.error).toContain('Use --skip-verify');
+  });
+});

package/_standalone/__tests__/channel-cli-subprocess.test.ts

@@ -0,0 +1,73 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const CLI = path.join(ROOT, 'bin', 'cli.js');
+
+let tempHome: string;
+
+beforeEach(() => {
+  tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-channel-smoke-'));
+});
+
+afterEach(() => {
+  fs.rmSync(tempHome, { recursive: true, force: true });
+});
+
+function run(args: string[], extraEnv: Record<string, string> = {}) {
+  try {
+    const stdout = execFileSync(process.execPath, [CLI, ...args], {
+      encoding: 'utf-8',
+      env: {
+        ...process.env,
+        HOME: tempHome,
+        USERPROFILE: tempHome,
+        NODE_ENV: 'test',
+        ...extraEnv,
+      },
+      timeout: 15000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { stdout, stderr: '', exitCode: 0 };
+  } catch (err) {
+    const e = err as { stdout?: string; stderr?: string; status?: number };
+    return {
+      stdout: e.stdout || '',
+      stderr: e.stderr || '',
+      exitCode: e.status ?? 1,
+    };
+  }
+}
+
+describe('channel CLI subprocess smoke', () => {
+  it('lists platforms without crashing in empty home', () => {
+    const result = run(['channel', 'list']);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain('Configured IM Platforms');
+  });
+
+  it('supports env + skip-verify flow in subprocess', () => {
+    const result = run(
+      ['channel', 'add', 'telegram', '--env', '--skip-verify'],
+      { TELEGRAM_BOT_TOKEN: '123456789:ABCdefGHIjklMNOpqrSTUvwxYZ' },
+    );
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain('verification skipped');
+
+    const configPath = path.join(tempHome, '.mindos', 'im.json');
+    const onDisk = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    expect(onDisk.providers.telegram).toBeDefined();
+  });
+
+  it('supports alternate env credential mode for wecom', () => {
+    const result = run(
+      ['channel', 'add', 'wecom', '--env', '--skip-verify'],
+      { WECOM_WEBHOOK_KEY: 'robot-webhook-key' },
+    );
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain('verification skipped');
+  });
+});