@agentknight/sdk 0.9.47 → 0.9.48

package/dist/chunks/{claude-adapter-YHNFRQLV.js → claude-adapter-WCIDCXOP.js}

@@ -1,24 +1,25 @@
 import {
   hasClaudeProviderConfiguration
-} from "./chunk-EIFNERXM.js";
+} from "./chunk-T6226JFS.js";
 import {
   latestPreviewItems
-} from "./chunk-QBKKQQCB.js";
+} from "./chunk-6VEMXJW4.js";
 import {
   UnsupportedAgentOperationError,
   validateSessionName
-} from "./chunk-7A2SQAZ7.js";
+} from "./chunk-R5LSWHRH.js";
 import {
   ConversationItemSchema,
   InteractionRequestSchema,
   InteractionResponseSchema,
   SESSION_TIMELINE_PAGE_SIZE,
   SessionSummarySchema
-} from "./chunk-DUMC5F2D.js";
+} from "./chunk-BDKVGENQ.js";
 
 // src/claude-adapter.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { z as z4 } from "zod";
 
@@ -178,11 +179,13 @@ var ClaudeInteractions = class {
 import { createHash } from "node:crypto";
 import { z as z2 } from "zod";
 var identity = (value) => createHash("sha256").update(value).digest("hex");
+var sourceId = (value) => value.length > 256 ? identity(value) : value;
 var ObjectSchema = z2.record(z2.string(), z2.unknown());
 var EnvelopeSchema = z2.object({
   type: z2.string(),
   uuid: z2.string().optional(),
-  parent_tool_use_id: z2.string().nullable().optional()
+  parent_tool_use_id: z2.string().nullable().optional(),
+  timestamp: z2.iso.datetime().optional()
 }).passthrough();
 var BlockSchema = z2.object({
   type: z2.string(),
@@ -203,6 +206,7 @@ var ClaudeTimeline = class {
   publish;
   #streams = /* @__PURE__ */ new Map();
   #seen = /* @__PURE__ */ new Set();
+  #timestamp;
   upsert(value) {
     const index = this.items.findIndex((item2) => item2.id === value.id);
     const previous = this.items[index];
@@ -218,7 +222,13 @@ var ClaudeTimeline = class {
     this.publish(structuredClone(item));
   }
   base(id, turnId) {
-    return { id, turnId, revision: 1, timestamp: (/* @__PURE__ */ new Date()).toISOString(), sourceEventIds: [id] };
+    return {
+      id: sourceId(id),
+      turnId: sourceId(turnId),
+      revision: 1,
+      timestamp: this.#timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      sourceEventIds: [sourceId(id)]
+    };
   }
   notice(turnId, content, severity = "error") {
     const id = identity(`${turnId}:notice:${content}`);
@@ -246,6 +256,14 @@ var ClaudeTimeline = class {
   }
   project(raw, turnId) {
     const message = EnvelopeSchema.parse(raw);
+    this.#timestamp = message.timestamp;
+    try {
+      this.#project(message, turnId);
+    } finally {
+      this.#timestamp = void 0;
+    }
+  }
+  #project(message, turnId) {
     if (message.uuid && this.#seen.has(message.uuid)) return;
     if (message.uuid) this.#seen.add(message.uuid);
     const source = message.uuid ?? turnId;
@@ -262,9 +280,21 @@ var ClaudeTimeline = class {
       const detached = z2.object({ detachedToolCall: z2.literal(true) }).safeParse(message.tool_use_result);
       if (detached.success) return;
       const body = z2.object({ content: z2.unknown() }).parse(message.message);
+      const blocks = Array.isArray(body.content) ? body.content.map((block) => BlockSchema.parse(block)) : [];
+      const text = typeof body.content === "string" ? body.content : blocks.filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n");
+      const uuid = message.uuid;
+      if (text && uuid && !this.items.some((item) => item.id === sourceId(uuid))) {
+        this.upsert({
+          ...this.base(uuid, turnId),
+          sourceMessageIds: [sourceId(uuid)],
+          kind: "human-message",
+          actor: "human",
+          content: text,
+          attachments: []
+        });
+      }
       if (!Array.isArray(body.content)) return;
-      for (const rawBlock of body.content) {
-        const block = BlockSchema.parse(rawBlock);
+      for (const block of blocks) {
         if (block.type === "tool_result" && block.tool_use_id) {
           this.#tool(block.tool_use_id, void 0, block.is_error ? "failed" : "completed", turnId);
         }
@@ -321,7 +351,7 @@ var ClaudeTimeline = class {
     if (!final && old?.kind === "assistant-message" && old.final) return;
     this.upsert({
       ...this.base(id, old?.turnId ?? turnId),
-      sourceMessageIds: [messageId],
+      sourceMessageIds: [sourceId(messageId)],
       kind: "assistant-message",
       actor: "assistant",
       content,
@@ -339,7 +369,7 @@ var ClaudeTimeline = class {
       kind: "activity-group",
       actor: "assistant",
       status,
-      sourceMessageIds: [toolId],
+      sourceMessageIds: [sourceId(toolId)],
       steps: [{ id, kind: "tool", name: (name ?? oldStep?.name ?? "Tool").slice(0, 256), status }]
     });
   }
@@ -458,9 +488,12 @@ var StoredSchema = z4.object({
   summary: SessionSummarySchema,
   nativeId: UuidSchema.optional(),
   modelId: z4.string().min(1).max(256),
+  nativeDirectory: z4.string().min(1).optional(),
   items: z4.array(ConversationItemSchema),
   receipts: z4.array(ReceiptSchema),
   unsafe: z4.boolean()
+}).refine((stored) => stored.nativeDirectory === void 0 || stored.nativeId !== void 0 && stored.summary.sessionId === `claude:native:${stored.nativeId}`, {
+  message: "Invalid Claude native session identity"
 });
 var MessageSchema = z4.object({
   type: z4.string(),
@@ -486,6 +519,8 @@ var ClaudeCodingAgentAdapter = class {
   #options;
   #directory;
   #sessions = /* @__PURE__ */ new Map();
+  #discovered = /* @__PURE__ */ new Map();
+  #retiredSessions = /* @__PURE__ */ new Set();
   #interactions;
   #callbacks;
   #started = false;
@@ -502,6 +537,9 @@ var ClaudeCodingAgentAdapter = class {
     const exitTimeout = options.processExitTimeoutMs ?? 5e3;
     if (!Number.isSafeInteger(exitTimeout) || exitTimeout < 1) throw new Error("Invalid Claude process exit timeout");
     this.#options = options;
+    if (options.nativeSessionOwner !== void 0) {
+      SessionSummarySchema.pick({ userId: true, machineId: true }).parse(options.nativeSessionOwner);
+    }
     this.#directory = join(resolve(options.dataDirectory), "claude");
     this.#interactions = new ClaudeInteractions(() => this.#callbacks, timeout);
   }
@@ -571,12 +609,12 @@ var ClaudeCodingAgentAdapter = class {
   }
   #known(id) {
     this.#ready();
-    const session = this.#sessions.get(id);
+    const session = this.#sessions.get(id) ?? this.#discovered.get(id);
     if (!session) throw new Error(`Unknown host-owned Claude session: ${id}`);
     return session;
   }
   isSessionVisible(id) {
-    return this.#started && !this.#stopping && this.#sessions.has(id);
+    return this.#started && !this.#stopping && (this.#sessions.has(id) || this.#discovered.has(id));
   }
   sessionPublicationSource(id) {
     this.#known(id);
@@ -587,7 +625,77 @@ var ClaudeCodingAgentAdapter = class {
   }
   async listSessions(userId, machineId) {
     this.#ready();
-    return [...this.#sessions.values()].filter((s) => s.stored.summary.userId === userId && s.stored.summary.machineId === machineId).map((s) => structuredClone(s.stored.summary));
+    const owner = this.#options.nativeSessionOwner;
+    if (owner?.userId === userId && owner.machineId === machineId) await this.#scanNative(owner);
+    return [...this.#sessions.values(), ...this.#discovered.values()].filter((s) => s.stored.summary.userId === userId && s.stored.summary.machineId === machineId).map((s) => structuredClone(s.stored.summary));
+  }
+  async #nativeSessions() {
+    return this.#options.nativeSessions ?? import("@anthropic-ai/claude-agent-sdk");
+  }
+  async #scanNative(owner) {
+    const sdk = await this.#nativeSessions();
+    const sessions = z4.array(z4.object({
+      sessionId: UuidSchema,
+      summary: z4.string(),
+      customTitle: z4.string().optional(),
+      lastModified: z4.number(),
+      createdAt: z4.number().optional(),
+      cwd: z4.string().optional()
+    })).parse(await sdk.listSessions({ includeProgrammatic: true }));
+    this.#ready();
+    const next = /* @__PURE__ */ new Map();
+    const present = new Set(sessions.map((native) => `claude:native:${native.sessionId}`));
+    for (const native of sessions) {
+      const owned = [...this.#sessions.values()].find((session) => session.stored.nativeId === native.sessionId);
+      if (owned && !owned.stored.nativeDirectory) continue;
+      const id = `claude:native:${native.sessionId}`;
+      this.#retiredSessions.delete(id);
+      const previous = owned ?? this.#discovered.get(id);
+      if (previous && (previous.stored.summary.userId !== owner.userId || previous.stored.summary.machineId !== owner.machineId)) {
+        throw new Error("Claude native session belongs to another PC owner");
+      }
+      const summary = SessionSummarySchema.parse({
+        ...owner,
+        sessionId: id,
+        summary: (native.customTitle || native.summary).slice(0, 4096),
+        ...native.cwd === void 0 ? {} : { workingDirectory: native.cwd },
+        createdAt: previous?.stored.summary.createdAt ?? new Date(native.createdAt ?? native.lastModified).toISOString(),
+        modifiedAt: new Date(native.lastModified).toISOString(),
+        isRemote: false,
+        renameSupported: true
+      });
+      if (previous) {
+        previous.stored.summary = summary;
+        if (!owned) next.set(id, previous);
+      } else {
+        const env = this.#options.env ?? process.env;
+        next.set(id, this.#newSession({
+          version: 1,
+          summary,
+          nativeId: native.sessionId,
+          nativeDirectory: resolve(env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude")),
+          modelId: CLAUDE_DEFAULT_MODEL_ID,
+          items: [],
+          receipts: [],
+          unsafe: false
+        }));
+      }
+    }
+    for (const id of this.#discovered.keys()) {
+      if (!next.has(id) && !this.#sessions.has(id)) this.#retiredSessions.add(id);
+    }
+    this.#discovered.clear();
+    for (const [id, session] of next) this.#discovered.set(id, session);
+    for (const [id, session] of this.#sessions) {
+      if (session.stored.nativeDirectory && !present.has(id) && !session.work && !session.operations && !session.queue.length) {
+        await session.saving;
+        this.#ready();
+        if (session.work || session.operations || session.cancellations || session.aborting || session.stored.unsafe || session.error) continue;
+        this.#sessions.delete(id);
+        this.#retiredSessions.add(id);
+        await rm(join(this.#directory, `${identity(id)}.json`));
+      }
+    }
   }
   async listModels() {
     this.#ready();
@@ -631,7 +739,9 @@ var ClaudeCodingAgentAdapter = class {
   async setPeerChatEnabled(enabled) {
     if (enabled) this.#unsupported("peer chat");
   }
-  async watchSession(id, _watched) {
+  async watchSession(id, watched) {
+    this.#ready();
+    if (!watched && this.#retiredSessions.has(id)) return;
     this.#known(id);
   }
   #validate(options) {
@@ -670,6 +780,13 @@ var ClaudeCodingAgentAdapter = class {
     const session = this.#known(id);
     const title = validateSessionName(name);
     assertAccess?.();
+    if (session.stored.nativeDirectory && session.stored.nativeId) {
+      const sdk = await this.#nativeSessions();
+      assertAccess?.();
+      await sdk.renameSession(session.stored.nativeId, title, this.#nativeReadOptions(session));
+      assertAccess?.();
+      this.#known(id);
+    }
     session.stored.summary.summary = title;
     await this.#save(session);
     this.#callbacks?.onSessionInventoryChanged(id);
@@ -679,6 +796,18 @@ var ClaudeCodingAgentAdapter = class {
     const session = this.#known(id);
     const size = options.pageSize ?? SESSION_TIMELINE_PAGE_SIZE;
     if (!Number.isSafeInteger(size) || size < 1 || size > SESSION_TIMELINE_PAGE_SIZE) throw new Error("Invalid Claude page size");
+    if (session.stored.nativeDirectory && !session.work) {
+      session.operations++;
+      const read = session.lock.then(async () => {
+        if (!session.work && !session.queue.length) await this.#readNativeHistory(session);
+      });
+      session.lock = read.then(() => void 0, () => void 0);
+      try {
+        await read;
+      } finally {
+        session.operations--;
+      }
+    }
     const items = session.stored.items;
     const boundary = options.cursor === void 0 ? items.length : items.findIndex((item) => `${identity(id)}:${item.id}` === options.cursor);
     const end = boundary < 0 ? items.length : boundary;
@@ -691,6 +820,50 @@ var ClaudeCodingAgentAdapter = class {
       cursorStatus: boundary < 0 ? "expired" : "ok"
     };
   }
+  #nativeReadOptions(session) {
+    const dir = session.stored.summary.workingDirectory;
+    return dir === void 0 ? {} : { dir };
+  }
+  async #readNativeHistory(session) {
+    const sdk = await this.#nativeSessions();
+    const nativeId = UuidSchema.parse(session.stored.nativeId);
+    const raw = await sdk.getSessionMessages(nativeId, this.#nativeReadOptions(session));
+    const messages = z4.array(z4.object({
+      type: z4.enum(["user", "assistant", "system"]),
+      uuid: z4.string(),
+      session_id: UuidSchema,
+      message: z4.unknown(),
+      timestamp: z4.iso.datetime().optional(),
+      parent_tool_use_id: z4.string().nullable(),
+      parent_agent_id: z4.string().nullable()
+    }).passthrough()).parse(raw);
+    this.#known(session.stored.summary.sessionId);
+    const items = [];
+    const timeline = new ClaudeTimeline(session.stored.summary.sessionId, items, () => void 0);
+    let turnId = session.stored.summary.sessionId;
+    for (const message of messages) {
+      if (message.session_id !== nativeId) throw new Error("Claude returned history for another native session");
+      if (message.parent_agent_id || message.parent_tool_use_id) continue;
+      if (message.type === "user") {
+        const body = z4.object({ content: z4.unknown() }).parse(message.message);
+        if (typeof body.content === "string" || Array.isArray(body.content) && body.content.some((block) => z4.object({ type: z4.literal("text") }).safeParse(block).success)) turnId = message.uuid;
+      }
+      timeline.project({ ...message, timestamp: message.timestamp ?? session.stored.summary.createdAt }, turnId);
+    }
+    const projected = items.map((item) => {
+      const previous = session.stored.items.find((entry) => entry.id === item.id);
+      if (!previous) return item;
+      const candidate = { ...item, timestamp: previous.timestamp, revision: previous.revision };
+      if (previous.kind === "human-message" && candidate.kind === "human-message" && previous.operationId) {
+        candidate.operationId = previous.operationId;
+      }
+      if (JSON.stringify(candidate) !== JSON.stringify(previous)) candidate.revision++;
+      return candidate;
+    });
+    const ids = new Set(projected.map((item) => item.id));
+    const notices = session.stored.items.filter((item) => item.kind === "notice" && item.actor === "system" && item.severity !== "info" && !ids.has(item.id));
+    session.stored.items.splice(0, session.stored.items.length, ...projected, ...notices);
+  }
   async sendPrompt(id, prompt, mode, attachments = [], _persistInteractions = true, files = [], operationId, avatar) {
     const session = this.#known(id);
     if (attachments.length || files.length) this.#unsupported("attachments");
@@ -705,6 +878,11 @@ var ClaudeCodingAgentAdapter = class {
       if (session.error instanceof ClaudeProcessTerminationError) throw session.error;
       if (session.error) throw new Error("Claude session persistence failed", { cause: session.error });
       if (session.stored.unsafe) throw new Error("Claude native session identity is uncertain; create a new session");
+      if (session.stored.nativeDirectory) {
+        this.#environment(session);
+        const directory = session.stored.summary.workingDirectory;
+        if (!directory || !isAbsolute(directory)) throw new Error("Claude native session working directory is unavailable; open it in the CLI first");
+      }
       const duplicate = operationId === void 0 ? void 0 : session.stored.receipts.find((entry) => entry.operationId === operationId);
       if (duplicate) {
         if (duplicate.prompt !== prompt || duplicate.mode !== mode) throw new Error("Claude operation ID already has different content");
@@ -717,6 +895,12 @@ var ClaudeCodingAgentAdapter = class {
         if (session.stored.unsafe) throw new Error("Claude native session identity is uncertain; create a new session");
       }
       const acceptedEpoch = session.epoch;
+      if (this.#discovered.has(id)) {
+        await this.#readNativeHistory(session);
+        if (session.epoch !== epoch || this.#stopping) throw new Error("Claude prompt cancelled before acceptance");
+        this.#sessions.set(id, session);
+        this.#discovered.delete(id);
+      }
       const queued = session.busy || session.queue.length > 0;
       const receipt = ReceiptSchema.parse({
         id: randomUUID2(),
@@ -766,8 +950,11 @@ var ClaudeCodingAgentAdapter = class {
       this.#callbacks?.onSyncError(session.stored.summary.sessionId, error);
     });
   }
-  #environment() {
-    return prepareClaudeEnvironment(this.#options.env ?? process.env, join(this.#directory, "native"));
+  #environment(session) {
+    return prepareClaudeEnvironment(
+      this.#options.env ?? process.env,
+      session.stored.nativeDirectory ?? join(this.#directory, "native")
+    );
   }
   async #consume(session, epoch) {
     const id = session.stored.summary.sessionId;
@@ -778,7 +965,7 @@ var ClaudeCodingAgentAdapter = class {
     session.controller = controller;
     const seen = /* @__PURE__ */ new Set();
     try {
-      const env = this.#environment();
+      const env = this.#environment(session);
       const sdk = this.#options.sdk ?? await import("@anthropic-ai/claude-agent-sdk");
       if (epoch !== session.epoch || this.#stopping) return;
       const query = sdk.query({
@@ -943,7 +1130,14 @@ var ClaudeCodingAgentAdapter = class {
     }
   }
   async abortSession(id) {
+    this.#ready();
+    if (this.#retiredSessions.has(id)) return;
     const session = this.#known(id);
+    if (this.#discovered.has(id)) {
+      session.epoch++;
+      await session.lock;
+      return;
+    }
     if (session.aborting) return session.aborting;
     const cancellation = this.#cancel(session, true);
     const work = (async () => {
@@ -993,6 +1187,7 @@ var ClaudeCodingAgentAdapter = class {
     this.#interactions.replay();
   }
   #save(session) {
+    if (!this.#sessions.has(session.stored.summary.sessionId)) return Promise.resolve();
     const data = JSON.stringify(StoredSchema.parse(session.stored));
     const file = join(this.#directory, `${identity(session.stored.summary.sessionId)}.json`);
     session.saves++;
@@ -1032,6 +1227,7 @@ var ClaudeCodingAgentAdapter = class {
       await session.saving;
     }));
     this.#started = false;
+    this.#retiredSessions.clear();
   }
 };
 export {