@ycodium-ai/plugin-session-import 0.2.3018 → 0.2.3020

package/dist/index.js

@@ -164,9 +164,10 @@ var sessionImportSyncResultSchema = {
 };
 
 // src/sessionImportRuntime.ts
-import * as NodeCrypto3 from "node:crypto";
+import * as NodeCrypto4 from "node:crypto";
 import {
-  projectOrNull as projectOrNull2
+  projectOrNull as projectOrNull2,
+  threadOrNull as threadOrNull2
 } from "@ycodium-ai/plugin-api";
 
 // src/claudeSessionScan.ts
@@ -1130,8 +1131,126 @@ async function readRolloutModel(input, rolloutPath, sameDirectory) {
   return model;
 }
 
-// src/reconcileImportedTimeline.ts
+// src/existingTimeline.ts
 import * as NodeCrypto from "node:crypto";
+import {
+  isThreadNotFound,
+  threadOrNull,
+  THREAD_ACTIVITIES_LIST_LIMIT,
+  THREAD_MESSAGES_LIST_LIMIT,
+  TOOL_LIFECYCLE_ACTIVITY_KINDS
+} from "@ycodium-ai/plugin-api";
+var MESSAGES_PAGE = THREAD_MESSAGES_LIST_LIMIT;
+var ACTIVITIES_PAGE = THREAD_ACTIVITIES_LIST_LIMIT;
+var TOOL_KINDS = [...TOOL_LIFECYCLE_ACTIVITY_KINDS];
+var IMPORTED_KINDS = [...TOOL_KINDS, "reasoning"];
+var MAX_FULL_READS = 4;
+var TimelineKeptChangingError = class extends Error {
+  constructor() {
+    super("The thread's timeline kept changing while it was being read.");
+    this.name = "TimelineKeptChangingError";
+  }
+};
+async function readEveryPage(listPage) {
+  const rows = [];
+  let cursor = null;
+  let sequence;
+  let steady = true;
+  do {
+    const page = await listPage(cursor);
+    if (sequence !== void 0 && page.snapshotSequence !== sequence) steady = false;
+    sequence = page.snapshotSequence;
+    rows.push(...page.items);
+    cursor = page.nextCursor;
+  } while (cursor !== null);
+  return { rows, steady };
+}
+function digestOfRows(rows) {
+  const hash = NodeCrypto.createHash("sha256");
+  for (const row of rows) hash.update(JSON.stringify(row)).update("\n");
+  return hash.digest("hex");
+}
+async function readStable(listPage) {
+  let previousDigest;
+  for (let attempt = 0; attempt < MAX_FULL_READS; attempt++) {
+    const { rows, steady } = await readEveryPage(listPage);
+    if (new Set(rows.map((row) => row.id)).size !== rows.length) {
+      previousDigest = void 0;
+      continue;
+    }
+    if (steady) return rows;
+    const digest = digestOfRows(rows);
+    if (digest === previousDigest) return rows;
+    previousDigest = digest;
+  }
+  throw new TimelineKeptChangingError();
+}
+async function listAllMessages(threads, threadId) {
+  const newestFirst = await readStable(
+    (cursor) => threads.messages.list({ threadId, limit: MESSAGES_PAGE, cursor })
+  );
+  return newestFirst.toReversed().map((item) => ({
+    messageId: item.id,
+    role: item.role,
+    text: item.text,
+    createdAt: item.createdAt,
+    ...item.source === void 0 ? {} : { source: item.source },
+    ...item.modelSelection === void 0 ? {} : { modelSelection: item.modelSelection }
+  }));
+}
+async function listAllActivities(threads, threadId, query) {
+  const newestFirst = await readStable(
+    (cursor) => threads.activities.list({ threadId, ...query, limit: ACTIVITIES_PAGE, cursor })
+  );
+  return newestFirst.toReversed();
+}
+var activityOf = (item, payload) => ({
+  id: item.id,
+  kind: item.kind,
+  tone: item.tone,
+  summary: item.summary,
+  payload,
+  createdAt: item.createdAt,
+  turnId: item.turnId
+});
+async function readExistingThread(threads, threadId) {
+  const shell = await threadOrNull(threads, threadId);
+  if (shell === null) return null;
+  const timeline = await readExistingTimeline(threads, threadId);
+  return timeline === null ? null : { ...shell, ...timeline };
+}
+async function readExistingTimeline(threads, threadId) {
+  try {
+    const messages = await listAllMessages(threads, threadId);
+    const unturned = await listAllActivities(threads, threadId, {
+      kinds: IMPORTED_KINDS,
+      inTurn: "none"
+    });
+    const turned = await listAllActivities(threads, threadId, {
+      kinds: TOOL_KINDS,
+      inTurn: "any",
+      maxPayloadBytes: 0
+    });
+    const runtimeCalls = turned.filter((item) => item.turnId !== null).map((item) => {
+      const toolCallId2 = "toolCallId" in item ? item.toolCallId : void 0;
+      return activityOf(item, toolCallId2 === void 0 ? void 0 : { toolCallId: toolCallId2 });
+    });
+    return {
+      messages,
+      activities: [
+        // 这一趟没限载荷大小，行都带载荷；只有被 `maxPayloadBytes` 省掉的行才没有。
+        ...unturned.map((item) => activityOf(item, "payload" in item ? item.payload : void 0)),
+        ...runtimeCalls
+      ]
+    };
+  } catch (error) {
+    if (isThreadNotFound(error)) return null;
+    throw error;
+  }
+}
+
+// src/reconcileImportedTimeline.ts
+import * as NodeCrypto2 from "node:crypto";
 function record(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -1140,7 +1259,7 @@ function sourceId(value, input) {
   return source2?.kind === "native-session" && source2.provider === input.provider && source2.sessionId === input.nativeSessionId && typeof source2.messageId === "string" ? source2.messageId : void 0;
 }
 function stableId(input, kind, nativeId) {
-  const digest = NodeCrypto.createHash("sha256").update(JSON.stringify([input.threadId, input.provider, input.nativeSessionId, kind, nativeId])).digest("hex");
+  const digest = NodeCrypto2.createHash("sha256").update(JSON.stringify([input.threadId, input.provider, input.nativeSessionId, kind, nativeId])).digest("hex");
   return `native-${kind}:${digest}`;
 }
 function sourceFor(input, item) {
@@ -1745,7 +1864,7 @@ async function listSessions(ctx, input) {
 var describeError = (error) => error instanceof Error ? error.message : String(error);
 
 // src/sessionTranscript.ts
-import * as NodeCrypto2 from "node:crypto";
+import * as NodeCrypto3 from "node:crypto";
 var SESSION_IMPORT_ACTIVITY_LIMIT = 1e3;
 var SESSION_IMPORT_ACTIVITY_TEXT_LIMIT = 32e3;
 var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
@@ -1761,7 +1880,7 @@ function fallbackId(value) {
   } catch {
     text = "";
   }
-  return `record:${NodeCrypto2.createHash("sha256").update(text).digest("hex").slice(0, 20)}`;
+  return `record:${NodeCrypto3.createHash("sha256").update(text).digest("hex").slice(0, 20)}`;
 }
 function readableContent(value) {
   if (typeof value === "string") return value;
@@ -2153,6 +2272,7 @@ var SKIPPED_ACTIVE = {
   status: "skipped-active",
   appended: 0
 };
+var EXISTING_THREAD_NOT_IDLE = "The existing thread must be idle and unarchived before its history can be refreshed.";
 var IMPORTED_TITLE_MAX_LENGTH = 80;
 function resolveImportedTitle(transcript) {
   const first = transcript.messages.find((message) => message.role === "user");
@@ -2215,7 +2335,7 @@ function importedHistoryBatches(history) {
   if (count > 0) batches.push(batch);
   return batches;
 }
-var historyCommandId = (threadId, batch) => `native-history:${NodeCrypto3.createHash("sha256").update(JSON.stringify([threadId, batch])).digest("hex")}`;
+var historyCommandId = (threadId, batch) => `native-history:${NodeCrypto4.createHash("sha256").update(JSON.stringify([threadId, batch])).digest("hex")}`;
 var importsInFlight = /* @__PURE__ */ new WeakMap();
 async function runImport(ctx, input, emit) {
   let pending = importsInFlight.get(ctx);
@@ -2260,12 +2380,15 @@ async function runImportOnce(ctx, input, emit) {
     return fail("The selected provider does not own this native session.");
   }
   const bindings = await ctx.providers.sessions.list();
-  const existing = await ctx.projections.getThread(input.threadId, { includeActivities: true });
+  const existing = await readExistingThread(ctx.threads, input.threadId).catch((error) => {
+    if (error instanceof TimelineKeptChangingError) return fail(EXISTING_THREAD_NOT_IDLE);
+    throw error;
+  });
   const binding = bindings.find((candidate2) => candidate2.threadId === input.threadId);
   if (existing !== null) {
     const savedSources = [
       ...existing.messages.map((message) => message.source),
-      ...(existing.activities ?? []).map(
+      ...existing.activities.map(
         (activity) => activity.payload !== null && typeof activity.payload === "object" ? activity.payload.source : void 0
       )
     ].filter((source2) => source2 !== void 0);
@@ -2275,15 +2398,13 @@ async function runImportOnce(ctx, input, emit) {
     if (existing.projectId !== input.projectId || !pendingLink && (binding?.instanceId !== input.instanceId || providerKindOfDriver(binding.driver) !== input.provider || nativeSessionIdOf(input.provider, binding.resumeCursor) !== input.nativeSessionId))
       return fail("This thread is not linked to the selected native session.");
     if (existing.archivedAt !== null || existing.session?.activeTurnId != null || existing.session?.status === "running" || existing.session?.status === "starting")
-      return fail(
-        "The existing thread must be idle and unarchived before its history can be refreshed."
-      );
+      return fail(EXISTING_THREAD_NOT_IDLE);
     threadCreated = true;
   } else {
     for (const candidate2 of bindings) {
       if (providerKindOfDriver(candidate2.driver) !== input.provider || nativeSessionIdOf(input.provider, candidate2.resumeCursor) !== input.nativeSessionId)
         continue;
-      const imported = await ctx.projections.getThread(candidate2.threadId);
+      const imported = await threadOrNull2(ctx.threads, candidate2.threadId);
       if (imported?.projectId === input.projectId)
         return fail(
           "This native session is already imported. Refresh its existing thread instead.",
@@ -2472,11 +2593,19 @@ var NativeSessionTail = class {
     if (modifiedAt === null) return NOT_IMPORTED;
     const seen = await this.readBaseline(threadId);
     if (seen !== void 0 && modifiedAt <= seen) return UNCHANGED;
-    const thread = await this.ctx.projections.getThread(threadId, { includeActivities: true });
-    if (thread === null || thread.archivedAt !== null) return NOT_IMPORTED;
+    const thread = await threadOrNull2(this.ctx.threads, threadId);
+    if (thread === null) return NOT_IMPORTED;
     if (thread.session?.activeTurnId != null) return SKIPPED_ACTIVE;
     if (thread.session?.status === "running" || thread.session?.status === "starting")
       return SKIPPED_ACTIVE;
+    const timeline = await readExistingTimeline(this.ctx.threads, threadId).catch(
+      (error) => {
+        if (error instanceof TimelineKeptChangingError) return "busy";
+        throw error;
+      }
+    );
+    if (timeline === "busy") return SKIPPED_ACTIVE;
+    if (timeline === null) return NOT_IMPORTED;
     const records = await readClaudeSessionRecords({
       fs: this.ctx.fs,
       transcriptDir,
@@ -2490,8 +2619,8 @@ var NativeSessionTail = class {
       nativeSessionId,
       instanceId: binding.instanceId,
       transcript: readClaudeTranscript(records),
-      existingMessages: thread.messages,
-      existingActivities: thread.activities ?? [],
+      existingMessages: timeline.messages,
+      existingActivities: timeline.activities,
       fallbackIso: appendedAt
     });
     const batches = importedHistoryBatches(history);
@@ -2525,7 +2654,7 @@ var NativeSessionTail = class {
     });
     if (history.appendedMessageCount === 0 && (history.hasLegacyMatches || history.activities.length === 0))
       return { status: "synced", appended: history.appendedMessageCount };
-    const current = await this.ctx.projections.getThread(threadId);
+    const current = await threadOrNull2(this.ctx.threads, threadId);
     if (current?.session == null || current.session.status === "stopped" || current.session.activeTurnId !== null || current.session.status === "running" || current.session.status === "starting")
       return { status: "synced", appended: history.appendedMessageCount };
     await this.ctx.providers.sessions.stop(threadId).catch((error) => {
@@ -2541,7 +2670,7 @@ var NativeSessionTail = class {
 // src/index.ts
 var index_default = definePlugin({
   id: "session-import",
-  apiVersion: 8,
+  apiVersion: 9,
   activate: (ctx) => {
     ctx.command({
       name: "scan",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/plugin-session-import",
-  "version": "0.2.3018",
+  "version": "0.2.3020",
   "description": "Brings a session you started in a terminal into Ycodium.",
   "keywords": [
     "session-import",
@@ -20,7 +20,7 @@
     "effect": "4.0.0-beta.103",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.3018",
+    "@ycodium-ai/plugin-api": "0.2.3020",
     "ycodium-jsonl-stream": "0.0.0"
   },
   "ycodium": {