linkshell-cli 0.3.6 → 0.3.8

package/src/runtime/acp/agent-workspace.ts

@@ -9,8 +9,8 @@ import {
 import { AcpClient } from "./acp-client.js";
 import { ClaudeSdkClient } from "./claude-sdk-client.js";
 import { ClaudeStreamJsonClient } from "./claude-stream-json-client.js";
-import { listClaudeStoredSessions } from "./claude-sessions.js";
-import { listCodexStoredSessions } from "./codex-sessions.js";
+import { listClaudeStoredSessions, loadClaudeStoredTimeline } from "./claude-sessions.js";
+import { listCodexStoredSessions, loadCodexStoredTimeline } from "./codex-sessions.js";
 import type { AgentProtocol, AgentProvider } from "./provider-resolver.js";
 import { resolveAgentCommand } from "./provider-resolver.js";
 
@@ -1163,6 +1163,7 @@ function parseRemoteSessions(value: unknown): Array<{
   model?: string;
   createdAt?: number;
   lastActivityAt?: number;
+  archived?: boolean;
 }> {
   const raw = asRecord(value);
   const sessionsValue =
@@ -1178,6 +1179,7 @@ function parseRemoteSessions(value: unknown): Array<{
     model?: string;
     createdAt?: number;
     lastActivityAt?: number;
+    archived?: boolean;
   }> = [];
   for (const entry of sessionsValue) {
     const session = asRecord(entry);
@@ -1196,6 +1198,7 @@ function parseRemoteSessions(value: unknown): Array<{
       model: firstString(source, ["model", "modelId"]),
       createdAt: parseTimestamp(source.createdAt ?? source.created_at),
       lastActivityAt: parseTimestamp(source.lastActivityAt ?? source.updatedAt ?? source.modifiedAt ?? source.lastModified ?? source.updated_at),
+      archived: typeof source.archived === "boolean" ? source.archived : undefined,
     });
   }
   return result;
@@ -1472,7 +1475,7 @@ export class AgentWorkspaceProxy {
         permissionMode: existing?.permissionMode,
         collaborationMode: existing?.collaborationMode,
         status: existing?.status ?? "idle",
-        archived: existing?.archived ?? false,
+        archived: remote.archived ?? existing?.archived ?? false,
         lastMessagePreview: existing?.lastMessagePreview,
         lastActivityAt: remote.lastActivityAt ?? existing?.lastActivityAt ?? now,
         createdAt: remote.createdAt ?? existing?.createdAt ?? now,
@@ -1561,24 +1564,6 @@ export class AgentWorkspaceProxy {
     title?: string;
   }): Promise<AgentConversation | undefined> {
     const provider = payload.provider ?? this.input.availableProviders[0];
-    if (!provider) {
-      return this.openFailure(payload, "没有可用的 Agent provider。");
-    }
-    if (!this.input.availableProviders.includes(provider)) {
-      return this.openFailure(
-        payload,
-        `${providerLabel(provider)} 未安装或不可用。`,
-      );
-    }
-
-    const client = await this.ensureProviderClient(provider);
-    if (!client) {
-      return this.openFailure(
-        payload,
-        `${providerLabel(provider)} 启动失败。请确认 CLI 已安装并可用。`,
-      );
-    }
-
     const cwd = payload.cwd ?? this.input.cwd;
     let agentSessionId = payload.agentSessionId;
     let existingConversation =
@@ -1589,6 +1574,7 @@ export class AgentWorkspaceProxy {
       if (payload.conversationId && existingConversation.id !== payload.conversationId) {
         existingConversation = this.adoptConversationId(existingConversation.id, payload.conversationId);
       }
+      this.hydrateStoredTimeline(existingConversation);
       this.activeConversationId = existingConversation.id;
       this.input.send(createEnvelope({
         type: "agent.v2.conversation.opened",
@@ -1601,6 +1587,24 @@ export class AgentWorkspaceProxy {
       return existingConversation;
     }
 
+    if (!provider) {
+      return this.openFailure(payload, "没有可用的 Agent provider。");
+    }
+    if (!this.input.availableProviders.includes(provider)) {
+      return this.openFailure(
+        payload,
+        `${providerLabel(provider)} 未安装或不可用。`,
+      );
+    }
+
+    const client = await this.ensureProviderClient(provider);
+    if (!client) {
+      return this.openFailure(
+        payload,
+        `${providerLabel(provider)} 启动失败。请确认 CLI 已安装并可用。`,
+      );
+    }
+
     try {
       const result = agentSessionId
         ? await client.loadSession({ sessionId: agentSessionId, cwd })
@@ -1629,6 +1633,7 @@ export class AgentWorkspaceProxy {
       this.conversationByAgentSessionId.set(agentSessionId, conversation.id);
       this.activeConversationId = conversation.id;
       this.timelines.set(conversation.id, this.timelines.get(conversation.id) ?? []);
+      this.hydrateStoredTimeline(conversation);
       this.input.send(createEnvelope({
         type: "agent.v2.conversation.opened",
         hostDeviceId: this.input.hostDeviceId,
@@ -2970,6 +2975,13 @@ export class AgentWorkspaceProxy {
   }
 
   private sendSnapshot(conversationId?: string): void {
+    if (conversationId) {
+      const conversation = this.conversations.get(conversationId);
+      if (conversation) this.hydrateStoredTimeline(conversation);
+    } else if (this.activeConversationId) {
+      const conversation = this.conversations.get(this.activeConversationId);
+      if (conversation) this.hydrateStoredTimeline(conversation);
+    }
     const conversations = [...this.conversations.values()];
     const items = conversationId
       ? this.timelines.get(conversationId) ?? []
@@ -2985,6 +2997,31 @@ export class AgentWorkspaceProxy {
     }));
   }
 
+  private hydrateStoredTimeline(conversation: AgentConversation): void {
+    if (!conversation.agentSessionId) return;
+    const existing = this.timelines.get(conversation.id) ?? [];
+    if (existing.length > 0) return;
+    const result = conversation.provider === "codex"
+      ? loadCodexStoredTimeline(conversation.agentSessionId, conversation.id, conversation.cwd || this.input.cwd)
+      : conversation.provider === "claude"
+      ? loadClaudeStoredTimeline(conversation.agentSessionId, conversation.id)
+      : { items: [] };
+    if (result.items.length === 0) return;
+    const items = result.items
+      .sort((a, b) => a.createdAt - b.createdAt)
+      .slice(-MAX_TIMELINE_ITEMS) as AgentTimelineItem[];
+    this.timelines.set(conversation.id, items);
+    for (const item of items) this.rememberItemConversationId(conversation.id, item);
+    const lastMessage = [...items].reverse().find((item) => item.text?.trim());
+    if (lastMessage?.text && !conversation.lastMessagePreview) {
+      conversation.lastMessagePreview = previewText(lastMessage.text);
+    }
+    const lastActivityAt = items.at(-1)?.createdAt;
+    if (lastActivityAt) {
+      conversation.lastActivityAt = Math.max(conversation.lastActivityAt, lastActivityAt);
+    }
+  }
+
   private conversationIdFromParams(params: unknown): string | undefined {
     const raw = asRecord(params);
     if (!raw) return undefined;

package/src/runtime/acp/claude-sessions.ts

@@ -1,9 +1,11 @@
-import { closeSync, existsSync, openSync, readdirSync, readSync, statSync } from "node:fs";
+import { closeSync, existsSync, openSync, readFileSync, readdirSync, readSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join, resolve } from "node:path";
 
 const SAMPLE_BYTES = 64 * 1024;
+const HISTORY_BYTES = 2 * 1024 * 1024;
 const MAX_SESSIONS = 200;
+const MAX_HISTORY_ITEMS = 200;
 
 export interface ClaudeStoredSession {
   id: string;
@@ -13,6 +15,18 @@ export interface ClaudeStoredSession {
   lastModified: number;
 }
 
+export interface StoredAgentTimelineItem {
+  id: string;
+  conversationId: string;
+  type: "message";
+  role: "user" | "assistant" | "system";
+  content: Array<{ type: "text"; text: string }>;
+  text: string;
+  createdAt: number;
+  updatedAt?: number;
+  metadata?: Record<string, unknown>;
+}
+
 function asRecord(value: unknown): Record<string, unknown> | undefined {
   return value && typeof value === "object" && !Array.isArray(value)
     ? value as Record<string, unknown>
@@ -70,6 +84,32 @@ function extractMessageText(value: unknown): string | undefined {
   return extractMessageText(record.content ?? record.text);
 }
 
+function extractHistoryText(value: unknown): string | undefined {
+  if (typeof value === "string") {
+    const text = value.replace(/\r\n/g, "\n").trim();
+    return text || undefined;
+  }
+  if (Array.isArray(value)) {
+    const text = value
+      .map((part) => {
+        if (typeof part === "string") return part;
+        const record = asRecord(part);
+        return typeof record?.text === "string"
+          ? record.text
+          : typeof record?.content === "string"
+          ? record.content
+          : "";
+      })
+      .filter(Boolean)
+      .join("\n")
+      .trim();
+    return text || undefined;
+  }
+  const record = asRecord(value);
+  if (!record) return undefined;
+  return extractHistoryText(record.content ?? record.text ?? record.message);
+}
+
 function guessCwdFromProjectDir(projectDirName: string, fallbackCwd: string): string {
   const trimmed = projectDirName.replace(/^-+/, "");
   if (!trimmed) return resolve(fallbackCwd);
@@ -104,6 +144,32 @@ function readSample(filePath: string, size: number): string {
   }
 }
 
+function readHistorySample(filePath: string, size: number): string {
+  try {
+    if (size <= HISTORY_BYTES) return readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+
+  let fd: number | undefined;
+  try {
+    fd = openSync(filePath, "r");
+    const buffer = Buffer.alloc(HISTORY_BYTES);
+    const bytesRead = readSync(fd, buffer, 0, HISTORY_BYTES, Math.max(0, size - HISTORY_BYTES));
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } catch {
+    return "";
+  } finally {
+    if (typeof fd === "number") {
+      try {
+        closeSync(fd);
+      } catch {
+        // Ignore close failures while reading best-effort local history.
+      }
+    }
+  }
+}
+
 function readClaudeSessionMetadata(filePath: string, fallbackCwd: string): Omit<ClaudeStoredSession, "id" | "lastModified"> & {
   lastModified?: number;
 } {
@@ -185,3 +251,96 @@ export function listClaudeStoredSessions(inputCwd: string): { sessions: ClaudeSt
   sessions.sort((a, b) => b.lastModified - a.lastModified);
   return { sessions: sessions.slice(0, MAX_SESSIONS) };
 }
+
+function findClaudeSessionFile(sessionId: string): string | undefined {
+  const root = join(homedir(), ".claude", "projects");
+  if (!existsSync(root)) return undefined;
+  try {
+    for (const projectEntry of readdirSync(root, { withFileTypes: true })) {
+      if (!projectEntry.isDirectory()) continue;
+      const projectDir = join(root, projectEntry.name);
+      for (const sessionEntry of readdirSync(projectDir, { withFileTypes: true })) {
+        if (!sessionEntry.isFile() || !sessionEntry.name.endsWith(".jsonl")) continue;
+        if (basename(sessionEntry.name, ".jsonl") === sessionId) {
+          return join(projectDir, sessionEntry.name);
+        }
+      }
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+function historyMessage(
+  conversationId: string,
+  index: number,
+  role: "user" | "assistant" | "system",
+  text: string,
+  createdAt: number,
+  source: string,
+): StoredAgentTimelineItem {
+  return {
+    id: `history:${source}:${index}`,
+    conversationId,
+    type: "message",
+    role,
+    content: [{ type: "text", text }],
+    text,
+    createdAt,
+    metadata: { source: "device-history", provider: "claude" },
+  };
+}
+
+export function loadClaudeStoredTimeline(
+  sessionId: string,
+  conversationId: string,
+): { items: StoredAgentTimelineItem[] } {
+  const filePath = findClaudeSessionFile(sessionId);
+  if (!filePath) return { items: [] };
+  let statMtime = Date.now();
+  let statSize = 0;
+  try {
+    const stat = statSync(filePath);
+    statMtime = stat.mtimeMs;
+    statSize = stat.size;
+  } catch {
+    return { items: [] };
+  }
+
+  const items: StoredAgentTimelineItem[] = [];
+  let index = 0;
+  for (const line of readHistorySample(filePath, statSize).split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      const record = asRecord(JSON.parse(trimmed));
+      if (!record) continue;
+      const message = asRecord(record.message);
+      const rawRole = typeof record.role === "string"
+        ? record.role
+        : typeof message?.role === "string"
+        ? message.role
+        : typeof record.type === "string"
+        ? record.type
+        : undefined;
+      const role = rawRole === "assistant" ? "assistant" : rawRole === "user" ? "user" : undefined;
+      if (!role) continue;
+      const text = extractHistoryText(message?.content ?? record.content ?? record.text);
+      if (!text) continue;
+      const createdAt =
+        parseTimestamp(record.timestamp ?? record.createdAt ?? record.created_at) ??
+        statMtime + index;
+      items.push(historyMessage(conversationId, index, role, text, createdAt, sessionId));
+      index += 1;
+    } catch {
+      // Ignore malformed or partial JSONL lines in the history window.
+    }
+  }
+
+  return {
+    items: items
+      .sort((a, b) => a.createdAt - b.createdAt)
+      .slice(-MAX_HISTORY_ITEMS),
+  };
+}

package/src/runtime/acp/codex-sessions.ts

@@ -1,9 +1,11 @@
-import { closeSync, existsSync, openSync, readdirSync, readSync, statSync } from "node:fs";
+import { closeSync, existsSync, openSync, readFileSync, readdirSync, readSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join, resolve } from "node:path";
 
 const SAMPLE_BYTES = 64 * 1024;
+const HISTORY_BYTES = 2 * 1024 * 1024;
 const MAX_SESSIONS = 200;
+const MAX_HISTORY_ITEMS = 200;
 
 export interface CodexStoredSession {
   id: string;
@@ -11,6 +13,19 @@ export interface CodexStoredSession {
   title?: string;
   createdAt?: number;
   lastModified: number;
+  archived?: boolean;
+}
+
+export interface StoredAgentTimelineItem {
+  id: string;
+  conversationId: string;
+  type: "message";
+  role: "user" | "assistant" | "system";
+  content: Array<{ type: "text"; text: string }>;
+  text: string;
+  createdAt: number;
+  updatedAt?: number;
+  metadata?: Record<string, unknown>;
 }
 
 interface CodexIndexEntry {
@@ -76,6 +91,32 @@ function readSample(filePath: string, size: number): string {
   }
 }
 
+function readHistorySample(filePath: string, size: number): string {
+  try {
+    if (size <= HISTORY_BYTES) return readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+
+  let fd: number | undefined;
+  try {
+    fd = openSync(filePath, "r");
+    const buffer = Buffer.alloc(HISTORY_BYTES);
+    const bytesRead = readSync(fd, buffer, 0, HISTORY_BYTES, Math.max(0, size - HISTORY_BYTES));
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } catch {
+    return "";
+  } finally {
+    if (typeof fd === "number") {
+      try {
+        closeSync(fd);
+      } catch {
+        // Best-effort local history scan.
+      }
+    }
+  }
+}
+
 function loadSessionIndex(root: string): Map<string, CodexIndexEntry> {
   const indexPath = join(root, "session_index.jsonl");
   const entries = new Map<string, CodexIndexEntry>();
@@ -158,15 +199,15 @@ function readCodexSessionFile(filePath: string, fallbackCwd: string): Omit<Codex
   };
 }
 
-function collectJsonlFiles(dir: string, result: string[]): void {
+function collectJsonlFiles(dir: string, result: Array<{ path: string; archived: boolean }>, archived: boolean): void {
   if (!existsSync(dir)) return;
   try {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const path = join(dir, entry.name);
       if (entry.isDirectory()) {
-        collectJsonlFiles(path, result);
+        collectJsonlFiles(path, result, archived);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-        result.push(path);
+        result.push({ path, archived });
       }
     }
   } catch {
@@ -174,18 +215,95 @@ function collectJsonlFiles(dir: string, result: string[]): void {
   }
 }
 
+function findCodexSessionFile(sessionId: string, inputCwd: string): { path: string; archived: boolean } | undefined {
+  const root = join(homedir(), ".codex");
+  if (!existsSync(root)) return undefined;
+  const files: Array<{ path: string; archived: boolean }> = [];
+  collectJsonlFiles(join(root, "sessions"), files, false);
+  collectJsonlFiles(join(root, "archived_sessions"), files, true);
+
+  let best: { path: string; archived: boolean; lastModified: number } | undefined;
+  for (const file of files) {
+    const fileId = sessionIdFromRolloutFile(file.path);
+    let metadata: ReturnType<typeof readCodexSessionFile> | undefined;
+    if (fileId !== sessionId) {
+      metadata = readCodexSessionFile(file.path, inputCwd);
+      if (metadata?.id !== sessionId) continue;
+    }
+    let lastModified = metadata?.lastModified;
+    if (!lastModified) {
+      try {
+        lastModified = statSync(file.path).mtimeMs;
+      } catch {
+        lastModified = 0;
+      }
+    }
+    if (!best || file.archived || lastModified > best.lastModified) {
+      best = { ...file, lastModified };
+    }
+  }
+  return best;
+}
+
+function normalizeHistoryText(value: unknown): string | undefined {
+  if (typeof value === "string") {
+    const text = value.replace(/\r\n/g, "\n").trim();
+    return text || undefined;
+  }
+  if (Array.isArray(value)) {
+    const text = value
+      .map((part) => {
+        if (typeof part === "string") return part;
+        const record = asRecord(part);
+        return typeof record?.text === "string"
+          ? record.text
+          : typeof record?.content === "string"
+          ? record.content
+          : "";
+      })
+      .filter(Boolean)
+      .join("\n")
+      .trim();
+    return text || undefined;
+  }
+  const record = asRecord(value);
+  if (!record) return undefined;
+  return normalizeHistoryText(record.content ?? record.text ?? record.message);
+}
+
+function historyMessage(
+  conversationId: string,
+  index: number,
+  role: "user" | "assistant" | "system",
+  text: string,
+  createdAt: number,
+  source: string,
+): StoredAgentTimelineItem {
+  const id = `history:${source}:${index}`;
+  return {
+    id,
+    conversationId,
+    type: "message",
+    role,
+    content: [{ type: "text", text }],
+    text,
+    createdAt,
+    metadata: { source: "device-history", provider: "codex" },
+  };
+}
+
 export function listCodexStoredSessions(inputCwd: string): { sessions: CodexStoredSession[] } {
   const root = join(homedir(), ".codex");
   if (!existsSync(root)) return { sessions: [] };
 
   const index = loadSessionIndex(root);
-  const files: string[] = [];
-  collectJsonlFiles(join(root, "sessions"), files);
-  collectJsonlFiles(join(root, "archived_sessions"), files);
+  const files: Array<{ path: string; archived: boolean }> = [];
+  collectJsonlFiles(join(root, "sessions"), files, false);
+  collectJsonlFiles(join(root, "archived_sessions"), files, true);
 
   const sessionsById = new Map<string, CodexStoredSession>();
   for (const file of files) {
-    const metadata = readCodexSessionFile(file, inputCwd);
+    const metadata = readCodexSessionFile(file.path, inputCwd);
     if (!metadata) continue;
     const indexed = index.get(metadata.id);
     const session: CodexStoredSession = {
@@ -194,9 +312,10 @@ export function listCodexStoredSessions(inputCwd: string): { sessions: CodexStor
       title: indexed?.title,
       createdAt: metadata.createdAt,
       lastModified: indexed?.updatedAt ?? metadata.lastModified ?? Date.now(),
+      archived: file.archived,
     };
     const existing = sessionsById.get(session.id);
-    if (!existing || session.lastModified > existing.lastModified) {
+    if (!existing || session.lastModified > existing.lastModified || session.archived) {
       sessionsById.set(session.id, session);
     }
   }
@@ -208,6 +327,7 @@ export function listCodexStoredSessions(inputCwd: string): { sessions: CodexStor
       cwd: resolve(inputCwd),
       title: indexed.title,
       lastModified: indexed.updatedAt ?? Date.now(),
+      archived: false,
     });
   }
 
@@ -217,3 +337,56 @@ export function listCodexStoredSessions(inputCwd: string): { sessions: CodexStor
       .slice(0, MAX_SESSIONS),
   };
 }
+
+export function loadCodexStoredTimeline(
+  sessionId: string,
+  conversationId: string,
+  inputCwd: string,
+): { items: StoredAgentTimelineItem[] } {
+  const file = findCodexSessionFile(sessionId, inputCwd);
+  if (!file) return { items: [] };
+  let statMtime = Date.now();
+  let statSize = 0;
+  try {
+    const stat = statSync(file.path);
+    statMtime = stat.mtimeMs;
+    statSize = stat.size;
+  } catch {
+    return { items: [] };
+  }
+
+  const items: StoredAgentTimelineItem[] = [];
+  let index = 0;
+  for (const line of readHistorySample(file.path, statSize).split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      const entry = asRecord(JSON.parse(trimmed));
+      const payload = asRecord(entry?.payload);
+      if (entry?.type !== "event_msg" || !payload) continue;
+      const eventType = typeof payload.type === "string" ? payload.type : undefined;
+      const createdAt =
+        parseTimestamp(entry.timestamp ?? payload.created_at ?? payload.started_at ?? payload.completed_at) ??
+        statMtime + index;
+      if (eventType === "user_message") {
+        const text = normalizeHistoryText(payload.message);
+        if (!text || text.startsWith("<turn_aborted>")) continue;
+        items.push(historyMessage(conversationId, index, "user", text, createdAt, sessionId));
+        index += 1;
+      } else if (eventType === "agent_message") {
+        const text = normalizeHistoryText(payload.message);
+        if (!text) continue;
+        items.push(historyMessage(conversationId, index, "assistant", text, createdAt, sessionId));
+        index += 1;
+      }
+    } catch {
+      // Ignore malformed or partial JSONL lines in the history window.
+    }
+  }
+
+  return {
+    items: items
+      .sort((a, b) => a.createdAt - b.createdAt)
+      .slice(-MAX_HISTORY_ITEMS),
+  };
+}