@agentknight/sdk 0.9.35

package/dist/chunks/chunk-MVUOCZFL.js

@@ -0,0 +1,47 @@
+import {
+  SessionAssistantPreviewSchema,
+  SessionUserPreviewSchema
+} from "./chunk-ZKAN2FO7.js";
+
+// src/assistant-preview.ts
+function isContentfulAssistant(item) {
+  return item.kind === "assistant-message" && item.actor === "assistant" && (item.content.trim().length > 0 || (item.attachments ?? []).some((attachment) => attachment.kind === "image"));
+}
+function userPreview(item) {
+  if (item.kind !== "human-message" || item.actor !== "human") return void 0;
+  return SessionUserPreviewSchema.parse({
+    id: item.id,
+    revision: item.revision,
+    timestamp: item.timestamp,
+    text: item.content.slice(0, 4096)
+  });
+}
+function latestPreviewItems(items) {
+  const latest = [...items].reverse();
+  return [
+    latest.find((item) => item.kind === "human-message" && item.actor === "human"),
+    latest.find(isContentfulAssistant)
+  ].filter((item) => item !== void 0);
+}
+function assistantPreview(item, referenceItem) {
+  if (item.kind !== "assistant-message" || !isContentfulAssistant(item)) return void 0;
+  const referenced = referenceItem(item);
+  const attachments = referenced.kind === "assistant-message" ? (referenced.attachments ?? []).filter((attachment) => attachment.kind === "image" && attachment.imageRef === "sha256").slice(0, 4) : [];
+  if (item.content.trim().length === 0 && attachments.length === 0) return void 0;
+  return SessionAssistantPreviewSchema.parse({
+    id: item.id,
+    revision: item.revision,
+    timestamp: item.timestamp,
+    sourceEventIds: item.sourceEventIds.slice(-1),
+    text: item.content.trim().slice(0, 4096),
+    final: item.final,
+    attachments
+  });
+}
+
+export {
+  isContentfulAssistant,
+  userPreview,
+  latestPreviewItems,
+  assistantPreview
+};

package/dist/chunks/chunk-SJHJER3B.js

@@ -0,0 +1,340 @@
+import {
+  SESSION_NAME_MAX_LENGTH,
+  SessionCommunicationDataSchema,
+  SessionNameSchema,
+  WorkbenchOperationStatusSchema
+} from "./chunk-ZKAN2FO7.js";
+
+// src/session-operations.ts
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+var MAX_OPERATIONS = 2048;
+var MAX_ACTIVE_OPERATIONS = 8;
+var MAX_RESULT_BYTES = 8 * 1024 * 1024;
+var RESULT_RETENTION_MS = 15 * 6e4;
+var RECORD_RETENTION_MS = 24 * 60 * 6e4;
+var RecordSchema = z.object({
+  key: z.string().length(64),
+  fingerprint: z.string().length(64),
+  createdAt: z.number().finite().nonnegative(),
+  updatedAt: z.number().finite().nonnegative(),
+  status: z.object({
+    operationId: WorkbenchOperationStatusSchema.shape.operationId,
+    operation: WorkbenchOperationStatusSchema.shape.operation,
+    agentRunId: WorkbenchOperationStatusSchema.shape.agentRunId,
+    error: WorkbenchOperationStatusSchema.shape.error,
+    // Completed results are intentionally not written to the operation journal.
+    state: z.enum(["running", "succeeded", "failed", "uncertain", "result-expired"])
+  }).strict()
+}).strict();
+var JournalSchema = z.object({
+  version: z.literal(1),
+  records: z.array(RecordSchema).max(MAX_OPERATIONS)
+}).strict();
+var SessionOperationError = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "SessionOperationError";
+    this.outcome = options?.outcome ?? "failed";
+  }
+  code;
+  outcome;
+};
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, stableValue(item)]));
+  }
+  return value;
+}
+function digest(value) {
+  return createHash("sha256").update(JSON.stringify(stableValue(value))).digest("hex");
+}
+var SessionOperations = class {
+  constructor(options) {
+    this.options = options;
+    this.#path = join(options.directory, "workbench-operations.json");
+  }
+  options;
+  #records = /* @__PURE__ */ new Map();
+  #active = /* @__PURE__ */ new Set();
+  #path;
+  #initialization;
+  #transition = Promise.resolve();
+  #fatalError;
+  #closed = false;
+  #expiryTimer;
+  #now() {
+    return this.options.now?.() ?? Date.now();
+  }
+  get hasActiveOperations() {
+    return this.#active.size > 0;
+  }
+  #key(owner, operationId) {
+    return digest([this.options.namespace ?? "", owner.clientId, owner.sessionId, operationId]);
+  }
+  async submit(options) {
+    await this.#initialize();
+    return this.#serialize(async () => {
+      if (this.#closed) throw new SessionOperationError("OPERATIONS_CLOSED", "The PC is stopping");
+      if (options.expectedAgentRunId !== this.options.agentRunId) {
+        throw new SessionOperationError("RUNTIME_CHANGED", "The PC restarted; refresh before starting an operation");
+      }
+      const createdAt = Date.parse(options.operationCreatedAt);
+      if (!Number.isFinite(createdAt) || createdAt > this.#now() + 5 * 6e4) {
+        throw new SessionOperationError("CLOCK_MISMATCH", "Check the phone and PC clocks before starting an operation");
+      }
+      if (this.#now() - createdAt >= RECORD_RETENTION_MS) {
+        throw new SessionOperationError("OPERATION_EXPIRED", "The submission expired; it has not been retried");
+      }
+      const key = this.#key(options, options.operationId);
+      const fingerprint = digest([options.operation, options.operationCreatedAt, options.data]);
+      const existing = this.#records.get(key);
+      if (existing !== void 0) {
+        if (existing.fingerprint !== fingerprint) {
+          throw new SessionOperationError("OPERATION_CONFLICT", "The operation ID was reused with different data");
+        }
+        return this.#publicStatus(existing);
+      }
+      if (this.#active.size >= MAX_ACTIVE_OPERATIONS) {
+        throw new SessionOperationError("OPERATION_BUSY", "Too many session operations are still running");
+      }
+      this.#prune();
+      if (this.#records.size >= MAX_OPERATIONS) {
+        throw new SessionOperationError("OPERATION_CAPACITY", "The operation journal is full");
+      }
+      const record = {
+        key,
+        fingerprint,
+        createdAt,
+        updatedAt: this.#now(),
+        status: {
+          operationId: options.operationId,
+          operation: options.operation,
+          agentRunId: this.options.agentRunId,
+          state: "running"
+        }
+      };
+      this.#records.set(key, record);
+      await this.#persist();
+      const work = Promise.resolve().then(options.execute).then((result) => SessionCommunicationDataSchema.parse(result)).then(
+        (result) => this.#settle(record, { state: "succeeded", result }),
+        (error) => {
+          this.options.onError(error);
+          return this.#settle(record, {
+            state: error instanceof SessionOperationError ? error.outcome : "uncertain",
+            error: {
+              code: error instanceof SessionOperationError ? error.code : "OPERATION_FAILED",
+              message: error instanceof SessionOperationError ? error.message : "The result could not be confirmed; the operation was not retried"
+            }
+          });
+        }
+      ).catch((error) => {
+        this.options.onError(error);
+      }).finally(() => this.#active.delete(work));
+      this.#active.add(work);
+      return this.#publicStatus(record);
+    });
+  }
+  async get(owner, operationId) {
+    await this.#initialize();
+    return this.#serialize(async () => {
+      const record = this.#records.get(this.#key(owner, operationId));
+      if (record === void 0) {
+        throw new SessionOperationError("OPERATION_NOT_FOUND", "The operation is unavailable; it has not been retried");
+      }
+      return this.#publicStatus(record);
+    });
+  }
+  async stopAccepting() {
+    this.#closed = true;
+    this.#scheduleExpiration();
+    await this.#initialization;
+    await this.#transition;
+  }
+  async close() {
+    await this.stopAccepting();
+    await Promise.all(this.#active);
+    await this.#transition;
+  }
+  #publicStatus(record) {
+    this.#expire(record);
+    return WorkbenchOperationStatusSchema.parse(record.status);
+  }
+  #expire(record, force = false) {
+    if (record.status.state === "succeeded" && (force || this.#closed || this.#now() - record.updatedAt >= RESULT_RETENTION_MS)) {
+      const { result: _result, ...status } = record.status;
+      record.status = { ...status, state: "result-expired" };
+    }
+  }
+  #scheduleExpiration() {
+    clearTimeout(this.#expiryTimer);
+    this.#expiryTimer = void 0;
+    let next = Infinity;
+    let bytes = 0;
+    const results = [];
+    for (const record of this.#records.values()) {
+      this.#expire(record);
+      if (record.status.state === "succeeded") {
+        const size = Buffer.byteLength(JSON.stringify(record.status.result));
+        bytes += size;
+        results.push({ record, size });
+      }
+    }
+    results.sort((left, right) => left.record.updatedAt - right.record.updatedAt);
+    for (const { record, size } of results) {
+      if (bytes > MAX_RESULT_BYTES) {
+        this.#expire(record, true);
+        bytes -= size;
+      } else {
+        next = Math.min(next, record.updatedAt + RESULT_RETENTION_MS);
+      }
+    }
+    if (Number.isFinite(next)) {
+      this.#expiryTimer = setTimeout(() => this.#scheduleExpiration(), Math.max(1, next - this.#now()));
+      this.#expiryTimer.unref();
+    }
+  }
+  async #settle(record, outcome) {
+    await this.#serialize(async () => {
+      const { result: _result, error: _error, ...identity } = record.status;
+      record.status = { ...identity, ...outcome };
+      record.updatedAt = this.#now();
+      this.#scheduleExpiration();
+      await this.#persist();
+    });
+  }
+  #prune() {
+    for (const [key, record] of this.#records) {
+      if (record.status.state !== "running" && this.#now() - record.createdAt >= RECORD_RETENTION_MS) {
+        this.#records.delete(key);
+      }
+    }
+  }
+  #initialize() {
+    this.#initialization ??= this.#load();
+    return this.#initialization;
+  }
+  async #load() {
+    await mkdir(this.options.directory, { recursive: true });
+    let content;
+    try {
+      content = await readFile(this.#path, "utf8");
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
+      throw error;
+    }
+    if (Buffer.byteLength(content) > 4 * 1024 * 1024) throw new Error("Operation journal is too large");
+    const journal = JournalSchema.parse(JSON.parse(content));
+    for (const stored of journal.records) {
+      if (this.#records.has(stored.key)) throw new Error("Duplicate operation journal entry");
+      const status = stored.status.state === "running" ? {
+        ...stored.status,
+        state: "uncertain",
+        error: { code: "OPERATION_INTERRUPTED", message: "The PC restarted before the result was recorded; the operation was not retried" }
+      } : stored.status.state === "succeeded" ? { ...stored.status, state: "result-expired" } : stored.status;
+      this.#records.set(stored.key, { ...stored, status });
+    }
+  }
+  async #persist() {
+    const temporary = `${this.#path}.${randomUUID()}.tmp`;
+    try {
+      const records = [...this.#records.values()].map((record) => {
+        const { result: _result, ...status } = record.status;
+        return { ...record, status };
+      });
+      const handle = await open(temporary, "wx", 384);
+      try {
+        await handle.writeFile(`${JSON.stringify({ version: 1, records })}
+`);
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await rename(temporary, this.#path);
+    } catch (error) {
+      this.#fatalError = new Error("The operation journal could not be saved", { cause: error });
+      try {
+        await unlink(temporary);
+      } catch (cleanupError) {
+        if (!(cleanupError instanceof Error && "code" in cleanupError && cleanupError.code === "ENOENT")) {
+          this.options.onError(cleanupError);
+        }
+      }
+      throw this.#fatalError;
+    }
+  }
+  #serialize(run) {
+    const next = this.#transition.then(() => {
+      if (this.#fatalError !== void 0) throw this.#fatalError;
+      return run();
+    });
+    this.#transition = next.then(() => void 0, () => void 0);
+    return next;
+  }
+};
+
+// src/coding-agent-adapter.ts
+var AgentModelListingError = class extends AggregateError {
+  constructor(errors, availableModels) {
+    super(errors, errors.map((error) => error.message).join("; "));
+    this.availableModels = availableModels;
+    this.name = "AgentModelListingError";
+  }
+  availableModels;
+};
+function captureResearchAccess(adapter, sessionId) {
+  if (adapter.agentId === "managed" && adapter.captureResearchAccess !== void 0) {
+    return adapter.captureResearchAccess(sessionId);
+  }
+  return { detached: false, assertCurrent: captureWorkbenchAccess(adapter, sessionId) };
+}
+function captureWorkbenchAccess(adapter, sessionId) {
+  if (adapter.workbench === void 0 || adapter.agentId !== "copilot" && adapter.agentId !== "managed" || adapter.agentId === "managed" && adapter.captureWorkbenchAccess === void 0 || adapter.agentId === "copilot" && sessionId.startsWith("managed:")) {
+    throw new SessionOperationError("AGENT_OPERATION_UNSUPPORTED", "This coding agent does not support the session workbench");
+  }
+  return adapter.captureWorkbenchAccess?.(sessionId) ?? (() => {
+    if (adapter.isSessionVisible?.(sessionId) === false) {
+      throw new SessionOperationError("SESSION_NOT_SHARED", "This session is no longer shared");
+    }
+  });
+}
+var UnsupportedAgentOperationError = class extends Error {
+  code = "AGENT_OPERATION_UNSUPPORTED";
+  constructor(agentId, operation) {
+    super(`${agentId} does not support ${operation}`);
+    this.name = "UnsupportedAgentOperationError";
+  }
+};
+var AgentSessionRenameError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AgentSessionRenameError";
+  }
+  code;
+};
+function validateSessionName(name) {
+  const result = SessionNameSchema.safeParse(name);
+  if (!result.success) {
+    throw new AgentSessionRenameError(
+      "INVALID_SESSION_NAME",
+      `Enter a nonempty single-line session name of at most ${SESSION_NAME_MAX_LENGTH} characters.`
+    );
+  }
+  return result.data;
+}
+
+export {
+  SessionOperationError,
+  SessionOperations,
+  AgentModelListingError,
+  captureResearchAccess,
+  captureWorkbenchAccess,
+  UnsupportedAgentOperationError,
+  AgentSessionRenameError,
+  validateSessionName
+};

package/dist/chunks/chunk-W3PG2W3C.js

@@ -0,0 +1,139 @@
+import {
+  IdSchema
+} from "./chunk-ZKAN2FO7.js";
+
+// src/data-directory.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, realpath, rm } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { z } from "zod";
+var OwnerSchema = z.object({ pid: z.number().int().positive(), instanceId: z.uuid().optional() });
+function validateDataDirectory(directory) {
+  if (typeof directory !== "string" || directory.trim().length === 0 || !isAbsolute(directory)) {
+    throw new Error("dataDirectory must be an explicitly configured absolute path.");
+  }
+  return resolve(directory);
+}
+async function readOwner(path) {
+  try {
+    return OwnerSchema.parse(JSON.parse(await readFile(path, "utf8")));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function processExists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ESRCH") return false;
+    throw error;
+  }
+}
+var DataDirectoryLease = class _DataDirectoryLease {
+  constructor(directory, instanceId, lockPath) {
+    this.directory = directory;
+    this.instanceId = instanceId;
+    this.lockPath = lockPath;
+  }
+  directory;
+  instanceId;
+  lockPath;
+  #released = false;
+  #attached = false;
+  static async acquire(dataDirectory) {
+    const requested = validateDataDirectory(dataDirectory);
+    await mkdir(requested, { recursive: true, mode: 448 });
+    const directory = await realpath(requested);
+    const runDirectory = join(directory, "run");
+    await mkdir(runDirectory, { recursive: true, mode: 448 });
+    const lockPath = join(runDirectory, "instance.lock");
+    let lock;
+    try {
+      lock = await open(lockPath, "wx", 384);
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+      const recovery = join(runDirectory, "lock-recovery");
+      try {
+        await mkdir(recovery, { mode: 448 });
+      } catch (cause) {
+        throw new Error(`Another startup is recovering ${lockPath}. Retry; if interrupted, inspect ${recovery}.`, { cause });
+      }
+      try {
+        const previous = await readOwner(lockPath);
+        if (previous !== void 0) {
+          if (processExists(previous.pid)) throw new Error(`An Agent is already running (PID ${previous.pid}).`);
+          await rm(lockPath);
+        }
+        lock = await open(lockPath, "wx", 384);
+      } finally {
+        await rm(recovery, { recursive: true });
+      }
+    }
+    const instanceId = randomUUID();
+    try {
+      await lock.writeFile(JSON.stringify({ pid: process.pid, instanceId }));
+    } catch (error) {
+      await lock.close();
+      await rm(lockPath);
+      throw error;
+    }
+    await lock.close();
+    return new _DataDirectoryLease(directory, instanceId, lockPath);
+  }
+  async attach(dataDirectory) {
+    if (this.#released || this.#attached) throw new Error("Data directory lease is released or already attached to an SDK instance.");
+    if (await realpath(validateDataDirectory(dataDirectory)) !== this.directory) {
+      throw new Error("Data directory lease belongs to another directory.");
+    }
+    if (this.#released || this.#attached) throw new Error("Data directory lease is released or already attached to an SDK instance.");
+    this.#attached = true;
+    return () => {
+      this.#attached = false;
+    };
+  }
+  async release() {
+    if (this.#released) return;
+    if (this.#attached) throw new Error("Stop the SDK instance before releasing its data directory.");
+    const owner = await readOwner(this.lockPath);
+    if (owner?.pid !== process.pid || owner.instanceId !== this.instanceId) {
+      throw new Error("Data directory ownership changed; refusing to remove another instance's lock.");
+    }
+    await rm(this.lockPath);
+    this.#released = true;
+  }
+};
+
+// src/peer-chat-request.ts
+import { z as z2 } from "zod";
+var PEER_CHAT_TIMEOUT_MS = 12e4;
+var PeerChatRequestSchema = z2.object({
+  sessionId: IdSchema,
+  targetMachineId: IdSchema,
+  targetSessionId: IdSchema,
+  prompt: z2.string().trim().min(1).max(16e3)
+});
+var PeerConversationSchema = z2.object({
+  contextId: IdSchema,
+  exchanges: z2.array(z2.object({
+    taskId: IdSchema,
+    requestMessageId: IdSchema,
+    responseMessageId: IdSchema,
+    request: z2.string(),
+    response: z2.string()
+  }))
+});
+var PeerChatResultSchema = z2.object({
+  reply: z2.string(),
+  peerReplies: z2.array(z2.string()),
+  conversation: PeerConversationSchema.optional()
+});
+
+export {
+  validateDataDirectory,
+  DataDirectoryLease,
+  PEER_CHAT_TIMEOUT_MS,
+  PeerChatRequestSchema,
+  PeerChatResultSchema
+};