refactor(vis): rewrite for new agent-core protocol

apps/vis/server/src/app.ts

@@ -8,7 +8,6 @@ import { contextRoute } from './routes/context';
 import { sessionDetailRoute } from './routes/session-detail';
 import { sessionsRoute } from './routes/sessions';
 import { subagentsRoute } from './routes/subagents';
-import { toolResultsRoute } from './routes/tool-results';
 import { wireRoute } from './routes/wire';
 
 /** Resolve the SPA bundle directory next to the compiled server.mjs, if it
@@ -87,9 +86,11 @@ export async function createApp(options: CreateAppOptions = {}): Promise<Hono> {
   api.route('/sessions', sessionsRoute());
   api.route('/sessions', sessionDetailRoute());
   api.route('/sessions', wireRoute());
-  api.route('/sessions', contextRoute());
   api.route('/sessions', subagentsRoute());
-  api.route('/sessions', toolResultsRoute());
+  // Mount contextRoute last because it currently uses a catch-all stub
+  // (Phase C scope) that would otherwise shadow more specific routes
+  // registered below it.
+  api.route('/sessions', contextRoute());
 
   app.route('/api', api);
 

apps/vis/server/src/config.ts

@@ -1,4 +1,3 @@
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
@@ -53,104 +52,3 @@ export function resolveVisAuthToken(host: string = resolveHost()): string | unde
 }
 
 export const KIMI_CODE_HOME: string = resolveKimiCodeHome();
-
-export class VisPathConfig {
-  readonly sessionsDir: string;
-
-  constructor(readonly home: string) {
-    this.sessionsDir = join(home, 'sessions');
-  }
-
-  sessionDir(sessionId: string): string {
-    return (
-      this.findIndexedSessionDir(sessionId) ??
-      this.findNestedSessionDir(sessionId) ??
-      join(this.sessionsDir, sessionId)
-    );
-  }
-
-  statePath(sessionId: string): string {
-    return join(this.sessionDir(sessionId), 'state.json');
-  }
-
-  mainAgentDir(sessionId: string): string {
-    const sessionDir = this.sessionDir(sessionId);
-    const mainDir = join(sessionDir, 'agents', 'main');
-    return isDirectory(mainDir) ? mainDir : sessionDir;
-  }
-
-  wirePath(sessionId: string): string {
-    return join(this.mainAgentDir(sessionId), 'wire.jsonl');
-  }
-
-  subagentDir(sessionId: string, agentId: string): string {
-    const sessionDir = this.sessionDir(sessionId);
-    const agentDir = join(sessionDir, 'agents', agentId);
-    return isDirectory(agentDir) ? agentDir : join(sessionDir, 'subagents', agentId);
-  }
-
-  toolResultArchivePath(sessionId: string, toolCallId: string): string {
-    const sessionDir = this.sessionDir(sessionId);
-    const mainPath = join(sessionDir, 'agents', 'main', 'tool-results', `${toolCallId}.txt`);
-    return existsSync(mainPath) ? mainPath : join(sessionDir, 'tool-results', `${toolCallId}.txt`);
-  }
-
-  private findIndexedSessionDir(sessionId: string): string | null {
-    const indexPath = join(this.home, 'session_index.jsonl');
-    let raw: string;
-    try {
-      raw = readFileSync(indexPath, 'utf8');
-    } catch {
-      return null;
-    }
-    for (const line of raw.split(/\r?\n/)) {
-      if (line.trim().length === 0) continue;
-      try {
-        const parsed = JSON.parse(line) as {
-          sessionId?: unknown;
-          session_id?: unknown;
-          sessionDir?: unknown;
-          session_dir?: unknown;
-        };
-        const id = stringValue(parsed.sessionId) ?? stringValue(parsed.session_id);
-        if (id !== sessionId) continue;
-        const dir = stringValue(parsed.sessionDir) ?? stringValue(parsed.session_dir);
-        if (dir !== null && isDirectory(dir)) return dir;
-      } catch {
-        // Ignore malformed index lines.
-      }
-    }
-    return null;
-  }
-
-  private findNestedSessionDir(sessionId: string): string | null {
-    const direct = join(this.sessionsDir, sessionId);
-    if (isDirectory(direct)) return direct;
-    let entries: string[];
-    try {
-      entries = readdirSync(this.sessionsDir);
-    } catch {
-      return null;
-    }
-    for (const entry of entries) {
-      const candidate = join(this.sessionsDir, entry, sessionId);
-      if (isDirectory(candidate)) return candidate;
-    }
-    return null;
-  }
-}
-
-function stringValue(value: unknown): string | null {
-  return typeof value === 'string' && value.length > 0 ? value : null;
-}
-
-function isDirectory(path: string): boolean {
-  try {
-    return statSync(path).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-/** Singleton path config pinned to the resolved KIMI_CODE_HOME. */
-export const pathConfig = new VisPathConfig(KIMI_CODE_HOME);

apps/vis/server/src/lib/agent-record-types.ts

@@ -0,0 +1,99 @@
+// apps/vis/server/src/lib/agent-record-types.ts
+// Single source of truth: everything below comes from agent-core directly.
+// Do NOT add local interfaces that duplicate upstream shapes.
+
+export type {
+  AgentRecord,
+  AgentRecordEvents,
+  AgentRecordOf,
+  AgentConfigUpdateData,
+  CompactionBeginData,
+  CompactionResult,
+  PermissionApprovalResultRecord,
+  PermissionMode,
+  UsageRecordScope,
+  ToolStoreUpdate,
+  LoopRecordedEvent,
+  ContextMessage,
+  PromptOrigin,
+} from '@moonshot-ai/agent-core';
+export { AGENT_WIRE_PROTOCOL_VERSION } from '@moonshot-ai/agent-core';
+export type { Message, ContentPart, ToolCall, TokenUsage } from '@moonshot-ai/kosong';
+
+// ── vis-only DTOs ──────────────────────────────────────────────────────────
+
+export interface ApiError {
+  error: string;
+  code:
+    | 'NOT_FOUND'
+    | 'BAD_REQUEST'
+    | 'UNAUTHORIZED'
+    | 'READ_ERROR'
+    | 'PARSE_ERROR'
+    | 'DELETE_ERROR'
+    | 'UNSUPPORTED_PROTOCOL';
+}
+
+export type SessionHealth =
+  | 'ok'
+  | 'broken_state'
+  | 'missing_main_wire'
+  | 'unsupported_protocol';
+
+export interface SessionSummary {
+  sessionId: string;
+  sessionDir: string;
+  workDir: string;
+  title: string | null;
+  lastPrompt: string | null;
+  isCustomTitle: boolean;
+  createdAt: number;
+  updatedAt: number;
+  agentCount: number;
+  mainAgentExists: boolean;
+  mainWireRecordCount: number;
+  wireProtocolVersion: string | null;
+  health: SessionHealth;
+}
+
+export interface AgentInfo {
+  agentId: string;
+  type: 'main' | 'sub' | 'independent';
+  parentAgentId: string | null;
+  homedir: string;
+  wireExists: boolean;
+  wireRecordCount: number;
+  wireProtocolVersion: string | null;
+}
+
+export interface SessionDetail {
+  sessionId: string;
+  workDir: string;
+  state: unknown; // 原样透传，前端按 state.json 真实形状渲染
+  agents: AgentInfo[];
+}
+
+export type WireLine = { _lineNo: number } & {
+  // structural unification with AgentRecord; preserves discriminant
+  [K in keyof import('@moonshot-ai/agent-core').AgentRecordEvents]: import('@moonshot-ai/agent-core').AgentRecordOf<K> & {
+    _lineNo: number;
+  };
+}[keyof import('@moonshot-ai/agent-core').AgentRecordEvents];
+
+export interface WireResponse {
+  sessionId: string;
+  agentId: string;
+  protocolVersion: string;
+  metadata: { protocolVersion: string; createdAt: number };
+  records: readonly WireLine[];
+  warnings: string[];
+}
+
+export interface AgentNode extends AgentInfo {
+  children: AgentNode[];
+}
+
+export interface AgentTreeResponse {
+  sessionId: string;
+  tree: AgentNode[];
+}

apps/vis/server/src/lib/agent-tree.ts

@@ -0,0 +1,33 @@
+import type { AgentInfo } from './agent-record-types';
+
+export interface AgentNode extends AgentInfo {
+  children: AgentNode[];
+}
+
+/**
+ * Build a parent/child tree from the flat agent inventory found on
+ * `state.json.agents`. Roots are agents with no `parentAgentId`, plus any
+ * agent whose `parentAgentId` does not resolve in the inventory (orphans).
+ * The returned roots are sorted so that the `main` agent always appears
+ * first; remaining roots fall back to a stable lexicographic order.
+ */
+export function buildAgentTree(agents: ReadonlyArray<AgentInfo>): AgentNode[] {
+  const byId = new Map<string, AgentNode>();
+  for (const a of agents) byId.set(a.agentId, { ...a, children: [] });
+
+  const roots: AgentNode[] = [];
+  for (const node of byId.values()) {
+    if (node.parentAgentId !== null && byId.has(node.parentAgentId)) {
+      byId.get(node.parentAgentId)!.children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  return roots.sort(sortAgents);
+}
+
+function sortAgents(a: AgentNode, b: AgentNode): number {
+  if (a.agentId === 'main') return -1;
+  if (b.agentId === 'main') return 1;
+  return a.agentId.localeCompare(b.agentId);
+}