@zhin.js/client 1.1.3 → 1.1.5

package/client/message-content/MarkdownContent.tsx

@@ -0,0 +1,128 @@
+import { Fragment, useMemo, useState, type ReactNode } from 'react';
+import {
+  highlightCodeLine,
+  parseMarkdown,
+  type MarkdownInline,
+} from './markdown.js';
+
+export interface MarkdownContentProps {
+  readonly text: string;
+  readonly className?: string;
+}
+
+function InlineContent({ content }: { readonly content: readonly MarkdownInline[] }) {
+  const nodes: ReactNode[] = [];
+  content.forEach((token, index) => {
+    const key = `${token.type}-${index}`;
+    const value = token.value.split('\n').map((line, lineIndex, lines) => (
+      <Fragment key={`${key}-line-${lineIndex}`}>
+        {line}
+        {lineIndex < lines.length - 1 ? <br /> : null}
+      </Fragment>
+    ));
+    if (token.type === 'strong') nodes.push(<strong key={key}>{value}</strong>);
+    else if (token.type === 'emphasis') nodes.push(<em key={key}>{value}</em>);
+    else if (token.type === 'strike') nodes.push(<del key={key}>{value}</del>);
+    else if (token.type === 'code') nodes.push(<code key={key} className="im-inline-code">{token.value}</code>);
+    else if (token.type === 'link') nodes.push(
+      <a key={key} href={token.href} target={token.href.startsWith('#') ? undefined : '_blank'} rel="noreferrer" className="im-message-link">{value}</a>,
+    );
+    else nodes.push(<Fragment key={key}>{value}</Fragment>);
+  });
+  return <>{nodes}</>;
+}
+
+export function CodeBlock({ code, language = '', closed = true }: { readonly code: string; readonly language?: string; readonly closed?: boolean }) {
+  const [copied, setCopied] = useState(false);
+  const [wrapped, setWrapped] = useState(false);
+  const [expanded, setExpanded] = useState(false);
+  const lines = useMemo(() => code.split('\n'), [code]);
+  const isLong = lines.length > 18 || code.length > 1800;
+  const visibleLines = isLong && !expanded ? lines.slice(0, 18) : lines;
+
+  const copy = async () => {
+    try {
+      await navigator.clipboard.writeText(code);
+      setCopied(true);
+      window.setTimeout(() => setCopied(false), 1600);
+    } catch {
+      setCopied(false);
+    }
+  };
+
+  return (
+    <figure className="zhin-code-block">
+      <figcaption className="zhin-code-toolbar">
+        <span className="zhin-code-language">{language || 'plain text'}</span>
+        {!closed ? <span className="zhin-code-streaming">生成中</span> : null}
+        <span className="zhin-code-actions">
+          <button type="button" onClick={() => setWrapped((value) => !value)} aria-pressed={wrapped}>{wrapped ? '不折行' : '折行'}</button>
+          <button type="button" onClick={() => void copy()}>{copied ? '已复制' : '复制'}</button>
+        </span>
+      </figcaption>
+      <pre className={wrapped ? 'zhin-code-pre zhin-code-pre--wrap' : 'zhin-code-pre'}>
+        <code>
+          {visibleLines.map((line, lineIndex) => (
+            <span className="zhin-code-line" key={`${lineIndex}-${line}`}>
+              <span className="zhin-code-line-number" aria-hidden="true">{lineIndex + 1}</span>
+              <span className="zhin-code-line-content">
+                {highlightCodeLine(line, language).map((token, tokenIndex) => (
+                  <span key={`${token.kind}-${tokenIndex}`} className={`zhin-code-token zhin-code-token--${token.kind}`}>{token.value}</span>
+                ))}
+                {'\n'}
+              </span>
+            </span>
+          ))}
+        </code>
+      </pre>
+      {isLong ? (
+        <button type="button" className="zhin-code-expand" onClick={() => setExpanded((value) => !value)}>
+          {expanded ? '收起代码' : `展开其余 ${lines.length - visibleLines.length} 行`}
+        </button>
+      ) : null}
+    </figure>
+  );
+}
+
+export function MarkdownContent({ text, className }: MarkdownContentProps) {
+  const blocks = useMemo(() => parseMarkdown(text), [text]);
+
+  return (
+    <div className={['im-markdown-body', 'zhin-markdown', className].filter(Boolean).join(' ')}>
+      {blocks.map((block, index) => {
+        if (block.type === 'heading') {
+          const Heading = `h${block.level}` as keyof React.JSX.IntrinsicElements;
+          return <Heading key={index} className={`im-markdown-heading im-markdown-heading-${block.level}`}><InlineContent content={block.content} /></Heading>;
+        }
+        if (block.type === 'paragraph') return <p key={index} className="im-markdown-paragraph"><InlineContent content={block.content} /></p>;
+        if (block.type === 'quote') return <blockquote key={index} className="im-markdown-quote"><InlineContent content={block.content} /></blockquote>;
+        if (block.type === 'rule') return <hr key={index} className="zhin-markdown-rule" />;
+        if (block.type === 'code') return <CodeBlock key={index} code={block.value} language={block.language} closed={block.closed} />;
+        if (block.type === 'list') {
+          const List = block.ordered ? 'ol' : 'ul';
+          return (
+            <List key={index} className={`im-markdown-list${block.ordered ? ' im-markdown-list-ordered' : ''}`}>
+              {block.items.map((item, itemIndex) => (
+                <li key={itemIndex} className={item.checked === undefined ? undefined : 'zhin-markdown-task'}>
+                  {item.checked === undefined ? null : <input type="checkbox" checked={item.checked} readOnly aria-label={item.checked ? '已完成' : '未完成'} />}
+                  <InlineContent content={item.content} />
+                </li>
+              ))}
+            </List>
+          );
+        }
+        if (block.type === 'table') {
+          return (
+            <div className="zhin-markdown-table-wrap" key={index}>
+              <table className="zhin-markdown-table">
+                <thead><tr>{block.header.map((cell, cellIndex) => <th key={cellIndex}><InlineContent content={cell} /></th>)}</tr></thead>
+                <tbody>{block.rows.map((row, rowIndex) => <tr key={rowIndex}>{row.map((cell, cellIndex) => <td key={cellIndex}><InlineContent content={cell} /></td>)}</tr>)}</tbody>
+              </table>
+            </div>
+          );
+        }
+        return null;
+      })}
+    </div>
+  );
+}

package/client/message-content/markdown.test.ts

@@ -0,0 +1,48 @@
+import { highlightCodeLine, isSafeMarkdownHref, parseMarkdown, parseMarkdownInline } from './markdown.js';
+
+describe('message markdown', () => {
+  it('parses rich blocks including tables and tasks', () => {
+    const blocks = parseMarkdown(`# Result
+
+- [x] inspect runtime
+- [ ] publish patch
+
+| field | value |
+| --- | --- |
+| status | **ready** |`);
+
+    expect(blocks.map((block) => block.type)).toEqual(['heading', 'list', 'table']);
+    expect(blocks[1]).toMatchObject({ type: 'list', items: [{ checked: true }, { checked: false }] });
+  });
+
+  it('keeps incomplete streaming fences renderable', () => {
+    expect(parseMarkdown('```ts\nconst ready = true')).toEqual([
+      { type: 'code', language: 'ts', value: 'const ready = true', closed: false },
+    ]);
+  });
+
+  it('rejects unsafe markdown links without emitting active links', () => {
+    expect(isSafeMarkdownHref('javascript:alert(1)')).toBe(false);
+    expect(isSafeMarkdownHref('https://zhin.dev/docs')).toBe(true);
+    expect(parseMarkdownInline('[run](javascript:alert(1))')).toEqual([
+      { type: 'text', value: '[run](javascript:alert(1))' },
+    ]);
+  });
+
+  it('treats repeated unmatched link openers as plain text', () => {
+    const value = '['.repeat(20_000);
+    expect(parseMarkdownInline(value)).toEqual([{ type: 'text', value }]);
+  });
+
+  it('tokenizes common code without producing html', () => {
+    expect(highlightCodeLine('const answer = "<safe>" // note', 'ts')).toEqual([
+      { kind: 'keyword', value: 'const' },
+      { kind: 'plain', value: ' ' },
+      { kind: 'plain', value: 'answer' },
+      { kind: 'plain', value: ' = ' },
+      { kind: 'string', value: '"<safe>"' },
+      { kind: 'plain', value: ' ' },
+      { kind: 'comment', value: '// note' },
+    ]);
+  });
+});

package/client/message-content/markdown.ts

@@ -0,0 +1,247 @@
+export type MarkdownInline =
+  | { readonly type: 'text'; readonly value: string }
+  | { readonly type: 'strong' | 'emphasis' | 'strike' | 'code'; readonly value: string }
+  | { readonly type: 'link'; readonly value: string; readonly href: string };
+
+export type MarkdownBlock =
+  | { readonly type: 'heading'; readonly level: number; readonly content: MarkdownInline[] }
+  | { readonly type: 'paragraph' | 'quote'; readonly content: MarkdownInline[] }
+  | { readonly type: 'list'; readonly ordered: boolean; readonly items: ReadonlyArray<{ readonly content: MarkdownInline[]; readonly checked?: boolean }> }
+  | { readonly type: 'code'; readonly language: string; readonly value: string; readonly closed: boolean }
+  | { readonly type: 'table'; readonly header: ReadonlyArray<MarkdownInline[]>; readonly rows: ReadonlyArray<ReadonlyArray<MarkdownInline[]>> }
+  | { readonly type: 'rule' };
+
+export type CodeTokenKind = 'plain' | 'comment' | 'string' | 'number' | 'keyword' | 'literal';
+
+export interface CodeToken {
+  readonly kind: CodeTokenKind;
+  readonly value: string;
+}
+
+// Excluding another opening bracket from link labels prevents the regexp
+// engine from rescanning an attacker-controlled run of `[` characters.
+const INLINE_PATTERN = /(`[^`\n]+`)|(\*\*[^*\n]+\*\*|__[^_\n]+__)|(~~[^~\n]+~~)|(\*[^*\n]+\*|_[^_\n]+_)|(\[[^\[\]\n]+\]\([^\s()]+(?:\s+"[^"\n]*")?\))|(https?:\/\/[^\s<>()]+)/g;
+const TABLE_DIVIDER = /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+
+export function isSafeMarkdownHref(href: string): boolean {
+  const value = href.trim();
+  if (!value) return false;
+  if (/^(https?:|mailto:)/i.test(value)) return true;
+  return /^(\/|#|\.\/|\.\.\/)/.test(value);
+}
+
+export function parseMarkdownInline(value: string): MarkdownInline[] {
+  const tokens: MarkdownInline[] = [];
+  let cursor = 0;
+  let match: RegExpExecArray | null;
+  INLINE_PATTERN.lastIndex = 0;
+
+  while ((match = INLINE_PATTERN.exec(value)) !== null) {
+    if (match.index > cursor) tokens.push({ type: 'text', value: value.slice(cursor, match.index) });
+    const raw = match[0];
+    if (match[1]) {
+      tokens.push({ type: 'code', value: raw.slice(1, -1) });
+    } else if (match[2]) {
+      tokens.push({ type: 'strong', value: raw.slice(2, -2) });
+    } else if (match[3]) {
+      tokens.push({ type: 'strike', value: raw.slice(2, -2) });
+    } else if (match[4]) {
+      tokens.push({ type: 'emphasis', value: raw.slice(1, -1) });
+    } else if (match[5]) {
+      const parsed = raw.match(/^\[([^\[\]]+)\]\(([^\s()]+)(?:\s+"[^"\n]*")?\)$/);
+      if (parsed && isSafeMarkdownHref(parsed[2])) {
+        tokens.push({ type: 'link', value: parsed[1], href: parsed[2] });
+      } else {
+        tokens.push({ type: 'text', value: raw });
+      }
+    } else if (match[6]) {
+      tokens.push({ type: 'link', value: raw, href: raw });
+    }
+    cursor = INLINE_PATTERN.lastIndex;
+  }
+
+  if (cursor < value.length) tokens.push({ type: 'text', value: value.slice(cursor) });
+  const merged: MarkdownInline[] = [];
+  for (const token of tokens) {
+    const previous = merged.at(-1);
+    if (token.type === 'text' && previous?.type === 'text') {
+      merged[merged.length - 1] = { type: 'text', value: previous.value + token.value };
+    } else {
+      merged.push(token);
+    }
+  }
+  return merged.length > 0 ? merged : [{ type: 'text', value }];
+}
+
+function splitTableRow(line: string): string[] {
+  return line
+    .trim()
+    .replace(/^\|/, '')
+    .replace(/\|$/, '')
+    .split(/(?<!\\)\|/)
+    .map((cell) => cell.trim().replace(/\\\|/g, '|'));
+}
+
+function startsBlock(lines: readonly string[], index: number): boolean {
+  const line = lines[index] ?? '';
+  return /^(?:```|~~~|#{1,6}\s+|>\s?|\s*(?:[-+*]|\d+[.)])\s+|\s*(?:-{3,}|\*{3,}|_{3,})\s*$)/.test(line)
+    || (line.includes('|') && TABLE_DIVIDER.test(lines[index + 1] ?? ''));
+}
+
+export function parseMarkdown(value: string): MarkdownBlock[] {
+  const lines = value.replace(/\r\n?/g, '\n').split('\n');
+  const blocks: MarkdownBlock[] = [];
+  let index = 0;
+
+  while (index < lines.length) {
+    const line = lines[index];
+    if (!line.trim()) {
+      index += 1;
+      continue;
+    }
+
+    const fence = line.match(/^\s*(```|~~~)\s*([^\s`]*)?.*$/);
+    if (fence) {
+      const marker = fence[1];
+      const language = (fence[2] ?? '').toLowerCase();
+      const code: string[] = [];
+      let closed = false;
+      index += 1;
+      while (index < lines.length) {
+        if (lines[index].trim() === marker) {
+          closed = true;
+          index += 1;
+          break;
+        }
+        code.push(lines[index]);
+        index += 1;
+      }
+      blocks.push({ type: 'code', language, value: code.join('\n'), closed });
+      continue;
+    }
+
+    const heading = line.match(/^(#{1,6})\s+(.+)$/);
+    if (heading) {
+      blocks.push({ type: 'heading', level: heading[1].length, content: parseMarkdownInline(heading[2]) });
+      index += 1;
+      continue;
+    }
+
+    if (/^\s*(?:-{3,}|\*{3,}|_{3,})\s*$/.test(line)) {
+      blocks.push({ type: 'rule' });
+      index += 1;
+      continue;
+    }
+
+    if (/^>\s?/.test(line)) {
+      const quoted: string[] = [];
+      while (index < lines.length && /^>\s?/.test(lines[index])) {
+        quoted.push(lines[index].replace(/^>\s?/, ''));
+        index += 1;
+      }
+      blocks.push({ type: 'quote', content: parseMarkdownInline(quoted.join('\n')) });
+      continue;
+    }
+
+    const listMatch = line.match(/^\s*([-+*]|\d+[.)])\s+(.+)$/);
+    if (listMatch) {
+      const ordered = /^\d/.test(listMatch[1]);
+      const items: Array<{ content: MarkdownInline[]; checked?: boolean }> = [];
+      while (index < lines.length) {
+        const item = lines[index].match(/^\s*([-+*]|\d+[.)])\s+(.+)$/);
+        if (!item || /^\d/.test(item[1]) !== ordered) break;
+        const task = item[2].match(/^\[([ xX])\]\s+(.+)$/);
+        items.push({
+          content: parseMarkdownInline(task ? task[2] : item[2]),
+          ...(task ? { checked: task[1].toLowerCase() === 'x' } : {}),
+        });
+        index += 1;
+      }
+      blocks.push({ type: 'list', ordered, items });
+      continue;
+    }
+
+    if (line.includes('|') && TABLE_DIVIDER.test(lines[index + 1] ?? '')) {
+      const header = splitTableRow(line).map(parseMarkdownInline);
+      const rows: MarkdownInline[][][] = [];
+      index += 2;
+      while (index < lines.length && lines[index].includes('|') && lines[index].trim()) {
+        rows.push(splitTableRow(lines[index]).map(parseMarkdownInline));
+        index += 1;
+      }
+      blocks.push({ type: 'table', header, rows });
+      continue;
+    }
+
+    const paragraph = [line];
+    index += 1;
+    while (index < lines.length && lines[index].trim() && !startsBlock(lines, index)) {
+      paragraph.push(lines[index]);
+      index += 1;
+    }
+    blocks.push({ type: 'paragraph', content: parseMarkdownInline(paragraph.join('\n')) });
+  }
+
+  return blocks;
+}
+
+const KEYWORDS: Record<string, ReadonlySet<string>> = {
+  javascript: new Set(['async', 'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'default', 'delete', 'do', 'else', 'export', 'extends', 'finally', 'for', 'from', 'function', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'of', 'return', 'static', 'switch', 'throw', 'try', 'typeof', 'var', 'void', 'while', 'yield']),
+  typescript: new Set(['abstract', 'any', 'as', 'asserts', 'async', 'await', 'boolean', 'break', 'case', 'catch', 'class', 'const', 'continue', 'declare', 'default', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'finally', 'for', 'from', 'function', 'if', 'implements', 'import', 'in', 'infer', 'instanceof', 'interface', 'keyof', 'let', 'namespace', 'never', 'new', 'number', 'object', 'of', 'readonly', 'return', 'satisfies', 'static', 'string', 'switch', 'symbol', 'throw', 'try', 'type', 'typeof', 'undefined', 'unknown', 'var', 'void', 'while', 'yield']),
+  python: new Set(['and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']),
+  shell: new Set(['case', 'do', 'done', 'elif', 'else', 'esac', 'export', 'fi', 'for', 'function', 'if', 'in', 'local', 'then', 'while']),
+  css: new Set(['@import', '@media', '@supports', 'and', 'important', 'not', 'only']),
+};
+
+const LANGUAGE_ALIASES: Record<string, string> = {
+  js: 'javascript', jsx: 'javascript', mjs: 'javascript', cjs: 'javascript',
+  ts: 'typescript', tsx: 'typescript', mts: 'typescript', cts: 'typescript',
+  py: 'python', bash: 'shell', sh: 'shell', zsh: 'shell', jsonc: 'json',
+};
+
+export function highlightCodeLine(line: string, language = ''): CodeToken[] {
+  const normalized = LANGUAGE_ALIASES[language] ?? language;
+  const keywords = KEYWORDS[normalized] ?? KEYWORDS.javascript;
+  const tokens: CodeToken[] = [];
+  let index = 0;
+
+  const push = (kind: CodeTokenKind, value: string) => {
+    if (value) tokens.push({ kind, value });
+  };
+
+  while (index < line.length) {
+    const rest = line.slice(index);
+    const comment = normalized === 'python' || normalized === 'shell'
+      ? rest.match(/^#.*/)
+      : rest.match(/^\/\/.*|^\/\*.*?\*\//);
+    if (comment) {
+      push('comment', comment[0]);
+      index += comment[0].length;
+      continue;
+    }
+    const string = rest.match(/^(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`)/);
+    if (string) {
+      push('string', string[0]);
+      index += string[0].length;
+      continue;
+    }
+    const number = rest.match(/^(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)/i);
+    if (number) {
+      push('number', number[0]);
+      index += number[0].length;
+      continue;
+    }
+    const word = rest.match(/^[A-Za-z_$@][\w$-]*/);
+    if (word) {
+      const literal = /^(?:true|false|null|undefined|None|True|False)$/.test(word[0]);
+      push(literal ? 'literal' : keywords.has(word[0]) ? 'keyword' : 'plain', word[0]);
+      index += word[0].length;
+      continue;
+    }
+    const plain = rest.match(/^[^A-Za-z_$@'"`\d/#]+/) ?? rest.match(/^./);
+    push('plain', plain?.[0] ?? '');
+    index += plain?.[0].length ?? 1;
+  }
+
+  return tokens;
+}

package/client/persistence/idb-store.test.ts

@@ -0,0 +1,139 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { applyConsoleEvent, idbListInbox } from "./idb-store.js";
+
+/**
+ * 最小内存 IndexedDB stub：仅实现 idb-store 用到的 open/upgrade/getAll/put 语义，
+ * 含版本检查（低版本 open 触发 VersionError）。
+ */
+type StoreData = Map<string, Record<string, unknown>>;
+interface DbData {
+  version: number;
+  stores: Map<string, StoreData>;
+}
+
+function createFakeIndexedDB() {
+  const dbs = new Map<string, DbData>();
+
+  function makeRequest<T>(run: (req: IDBRequest<T>) => void): IDBRequest<T> {
+    const req = {
+      result: undefined as T,
+      error: null as unknown,
+      onsuccess: null as (() => void) | null,
+      onerror: null as (() => void) | null,
+      onupgradeneeded: null as (() => void) | null,
+    } as unknown as IDBRequest<T>;
+    queueMicrotask(() => run(req));
+    return req;
+  }
+
+  function makeDb(data: DbData): IDBDatabase {
+    return {
+      objectStoreNames: {
+        contains: (name: string) => data.stores.has(name),
+      },
+      createObjectStore: (name: string) => {
+        data.stores.set(name, new Map());
+      },
+      transaction: (name: string) => {
+        const store = data.stores.get(name);
+        const tx = {
+          oncomplete: null as (() => void) | null,
+          onerror: null as (() => void) | null,
+          error: null as unknown,
+          objectStore: () => ({
+            getAll: () =>
+              makeRequest<Record<string, unknown>[]>((req) => {
+                (req as { result: unknown }).result = [...(store?.values() ?? [])];
+                req.onsuccess?.();
+              }),
+            put: (record: Record<string, unknown>) => {
+              store?.set(String(record.id), record);
+              queueMicrotask(() => tx.oncomplete?.());
+            },
+          }),
+        };
+        return tx;
+      },
+      close: () => undefined,
+    } as unknown as IDBDatabase;
+  }
+
+  return {
+    open(name: string, version = 1) {
+      return makeRequest<IDBDatabase>((req) => {
+        let data = dbs.get(name);
+        if (data && data.version > version) {
+          (req as { error: unknown }).error = new Error("VersionError");
+          req.onerror?.();
+          return;
+        }
+        const upgrading = !data || data.version < version;
+        if (!data) {
+          data = { version, stores: new Map() };
+          dbs.set(name, data);
+        }
+        data.version = version;
+        (req as { result: unknown }).result = makeDb(data);
+        if (upgrading) req.onupgradeneeded?.();
+        req.onsuccess?.();
+      });
+    },
+  };
+}
+
+const PUSH = {
+  type: "message.receive",
+  data: { adapter: "icqq", endpointKey: "bot-1", channelId: "1001" },
+};
+
+describe("applyConsoleEvent inbox record ids", () => {
+  beforeEach(() => {
+    vi.stubGlobal("indexedDB", createFakeIndexedDB());
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it("keeps two events of the same conversation within one millisecond (no key overwrite)", async () => {
+    // 回归：旧主键 `${adapter}:${endpointKey}:${type}:${Date.now()}` 在同毫秒会互相覆盖。
+    vi.spyOn(Date, "now").mockReturnValue(1700000000000);
+    await applyConsoleEvent(PUSH);
+    await applyConsoleEvent(PUSH);
+
+    const rows = await idbListInbox("icqq", "bot-1", "message");
+    expect(rows).toHaveLength(2);
+    expect(new Set(rows.map((r) => r.id)).size).toBe(2);
+  });
+
+  it('deduplicates the same resumable event across history and live delivery', async () => {
+    const event = { ...PUSH, runtimeId: 'runtime-a', eventId: 7, timestamp: 1700000000000 };
+    await applyConsoleEvent(event);
+    await applyConsoleEvent(event);
+
+    const rows = await idbListInbox('icqq', 'bot-1', 'message');
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.id).toBe('runtime-a:7');
+    expect(rows[0]?.updatedAt).toBe(1700000000000);
+  });
+
+  it("reads legacy records that only carry endpointKey (camelCase)", async () => {
+    // 旧版（DB v1 时代）记录只有 endpointKey 字段，升级后仍需能被列出
+    const { idbPutInbox } = await import("./idb-store.js");
+    const legacy = {
+      id: "icqq:bot-1:message:1700000000000:legacy",
+      adapter: "icqq",
+      endpointKey: "bot-1",
+      kind: "message",
+      payload: {},
+      updatedAt: 1700000000000,
+    };
+    await idbPutInbox(legacy as unknown as Parameters<typeof idbPutInbox>[0]);
+
+    const rows = await idbListInbox("icqq", "bot-1", "message");
+    expect(rows).toHaveLength(1);
+    expect(rows[0].id).toBe(legacy.id);
+  });
+});

package/client/persistence/idb-store.ts

@@ -1,12 +1,16 @@
+import { parseConsoleInboxEvent } from "@zhin.js/console-protocol";
+
 const DB_NAME = "zhin-console";
-const DB_VERSION = 1;
+const DB_VERSION = 2;
 const STORE_INBOX = "inbox";
 const STORE_PENDING = "pending";
 
+let inboxEventSeq = 0;
+
 export type InboxRecord = {
   id: string;
   adapter: string;
-  botId: string;
+  endpoint_id: string;
   kind: "message" | "request" | "notice";
   payload: unknown;
   updatedAt: number;
@@ -42,7 +46,7 @@ export async function idbPutInbox(record: InboxRecord): Promise<void> {
 
 export async function idbListInbox(
   adapter: string,
-  botId: string,
+  endpoint_id: string,
   kind: InboxRecord["kind"],
 ): Promise<InboxRecord[]> {
   const db = await openDb();
@@ -53,24 +57,42 @@ export async function idbListInbox(
     req.onerror = () => reject(req.error);
   });
   db.close();
-  return all.filter((r) => r.adapter === adapter && r.botId === botId && r.kind === kind);
+  return all.filter(
+    (r) =>
+      r.adapter === adapter &&
+      (r.endpoint_id === endpoint_id ||
+        (r as { endpointKey?: string }).endpointKey === endpoint_id) &&
+      r.kind === kind,
+  );
 }
 
-export async function applyConsoleEvent(event: { type: string; data?: unknown }): Promise<void> {
-  const t = event.type;
-  if (t === "bot:message" || t === "bot:request" || t === "bot:notice") {
-    const data = event.data as Record<string, unknown> | undefined;
-    if (!data) return;
-    const adapter = String(data.adapter ?? "");
-    const botId = String(data.botId ?? data.bot ?? "");
-    const id = `${adapter}:${botId}:${t}:${Date.now()}`;
-    await idbPutInbox({
-      id,
-      adapter,
-      botId,
-      kind: t === "bot:message" ? "message" : t === "bot:request" ? "request" : "notice",
-      payload: data,
-      updatedAt: Date.now(),
-    });
-  }
+export async function applyConsoleEvent(event: {
+  type: string;
+  data?: unknown;
+  runtimeId?: string;
+  eventId?: number;
+  timestamp?: number;
+}): Promise<void> {
+  const parsed = parseConsoleInboxEvent(event);
+  if (!parsed) return;
+  const updatedAt = typeof event.timestamp === 'number' && Number.isFinite(event.timestamp)
+    ? event.timestamp
+    : Date.now();
+  const resumableId = typeof event.runtimeId === 'string'
+    && event.runtimeId
+    && Number.isSafeInteger(event.eventId)
+    && (event.eventId ?? 0) > 0
+    ? `${event.runtimeId}:${event.eventId}`
+    : null;
+  await idbPutInbox({
+    // Resumable Host events are idempotent across history/live redelivery.
+    // Legacy/unsequenced sources retain collision-safe append ids.
+    id: resumableId
+      ?? `${parsed.adapter}:${parsed.endpointKey}:${parsed.type}:${updatedAt}:${inboxEventSeq++}:${Math.random().toString(36).slice(2, 8)}`,
+    adapter: parsed.adapter,
+    endpoint_id: parsed.endpointKey,
+    kind: parsed.kind,
+    payload: parsed.payload,
+    updatedAt,
+  });
 }

package/client/runtime/index.ts

@@ -1,4 +1,4 @@
-import type { RuntimeEnv } from "@zhin.js/console-types";
+import type { RuntimeEnv } from "@zhin.js/contract";
 
 let runtimeEnvFn: (() => RuntimeEnv) | null = null;
 

package/client/segments.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { segmentsForAgentPanel, segmentsForImDelivery } from '../client/segments.js';
+
+describe('console segmentsForImDelivery', () => {
+  it('inbox view strips AI-only segments', () => {
+    const full = [
+      { type: 'thinking', data: { text: 'plan' } },
+      { type: 'text', data: { text: 'hi' } },
+      { type: 'tool_call', data: { name: 'bash' } },
+    ];
+    expect(segmentsForImDelivery(full)).toEqual([
+      { type: 'text', data: { text: 'hi' } },
+    ]);
+    expect(segmentsForAgentPanel(full)).toEqual(full);
+  });
+});