@anusornneal/chat-relay 0.7.2 → 0.8.0

package/agent/file-manager.mjs

@@ -5,6 +5,19 @@ import { randomUUID } from "node:crypto";
 const MAX_READ_BYTES = 256 * 1024;
 const DEFAULT_READ_RESPONSE_BYTES = 32 * 1024;
 const DEFAULT_MULTI_READ_RESPONSE_BYTES = 48 * 1024;
+const DEFAULT_BATCH_RESPONSE_BYTES = 48 * 1024;
+const MAX_BATCH_OPERATIONS = 20;
+const MAX_ARTIFACT_BYTES = 40 * 1024;
+const ARTIFACT_MIME_TYPES = new Map([
+  [".txt", "text/plain; charset=utf-8"],
+  [".log", "text/plain; charset=utf-8"],
+  [".md", "text/markdown; charset=utf-8"],
+  [".json", "application/json"],
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+]);
+
 const MAX_READ_RESPONSE_BYTES = 48 * 1024;
 const MIN_READ_RESPONSE_BYTES = 1024;
 const MAX_WRITE_BYTES = 256 * 1024;
@@ -101,12 +114,23 @@ export class FileManager {
     await this.#walkList(target, 0, maxDepth, entries, start + pageLimit + 1);
 
     const selected = entries.slice(start, start + pageLimit);
-    while (selected.length > 1 && byteSize({ path: target, entries: selected, offset: start }) > responseBudget) selected.pop();
-    if (selected.length === 1 && byteSize({ path: target, entries: selected, offset: start }) > responseBudget) throw new Error("list_entry_too_large");
+    const payloadFor = (items) => {
+      const nextOffset = start + items.length;
+      const hasMore = nextOffset < entries.length;
+      return {
+        path: target,
+        entries: items,
+        offset: start,
+        limit: pageLimit,
+        maxBytes: responseBudget,
+        truncated: hasMore,
+        nextOffset: hasMore ? nextOffset : null,
+      };
+    };
+    while (selected.length > 1 && byteSize(payloadFor(selected)) > responseBudget) selected.pop();
+    if (selected.length === 1 && byteSize(payloadFor(selected)) > responseBudget) throw new Error("list_entry_too_large");
 
-    const nextOffset = start + selected.length;
-    const hasMore = nextOffset < entries.length;
-    return { path: target, entries: selected, offset: start, limit: pageLimit, maxBytes: responseBudget, truncated: hasMore, nextOffset: hasMore ? nextOffset : null };
+    return payloadFor(selected);
   }
 
   async #walkList(current, level, maxDepth, output, stopAfter = 1001) {
@@ -244,6 +268,127 @@ export class FileManager {
     };
   }
 
+
+  async batch(operations, maxTotalBytes = DEFAULT_BATCH_RESPONSE_BYTES) {
+    if (!Array.isArray(operations) || operations.length === 0 || operations.length > MAX_BATCH_OPERATIONS) {
+      throw new Error("invalid_batch");
+    }
+
+    const totalBudget = boundedReadBytes(maxTotalBytes, DEFAULT_BATCH_RESPONSE_BYTES, 4 * 1024);
+    const results = [];
+    let nextIndex = null;
+
+    for (let index = 0; index < operations.length; index++) {
+      const operation = operations[index] || {};
+      const op = String(operation.op || "");
+      const base = {
+        index,
+        ...(typeof operation.id === "string" && operation.id ? { id: operation.id.slice(0, 128) } : {}),
+        op,
+        ...(typeof operation.path === "string" ? { path: operation.path } : {}),
+      };
+      const minimumBudget = op === "list" ? 4 * 1024 : MIN_READ_RESPONSE_BYTES;
+      const fallbackBudget = op === "list" ? DEFAULT_LIST_RESPONSE_BYTES : DEFAULT_READ_RESPONSE_BYTES;
+      let operationBudget = boundedReadBytes(operation.maxBytes, fallbackBudget, minimumBudget);
+      let candidate;
+
+      try {
+        if (typeof operation.path !== "string" || operation.path.length === 0) {
+          throw new Error("invalid_path");
+        }
+
+        for (let attempt = 0; attempt < 8; attempt++) {
+          let result;
+          if (op === "stat") {
+            result = await this.stat(operation.path);
+          } else if (op === "read") {
+            result = await this.read(operation.path, operation.offset, operation.length, operationBudget);
+          } else if (op === "list") {
+            result = await this.list(operation.path, operation.depth, operation.offset, operation.limit, operationBudget);
+          } else {
+            throw new Error("invalid_batch_operation");
+          }
+
+          candidate = { ...base, ok: true, result };
+          const projected = {
+            results: [...results, candidate],
+            totalOperations: operations.length,
+            nextIndex: index + 1 < operations.length ? index + 1 : null,
+            truncated: false,
+            maxTotalBytes: totalBudget,
+          };
+          if (byteSize(projected) <= totalBudget) break;
+          if (op === "stat") {
+            candidate = undefined;
+            break;
+          }
+
+          operationBudget = Math.floor(operationBudget * 0.65);
+          candidate = undefined;
+          if (operationBudget < minimumBudget) break;
+        }
+      } catch (error) {
+        candidate = {
+          ...base,
+          ok: false,
+          error: error instanceof Error ? error.message : "batch_operation_failed",
+        };
+      }
+
+      if (!candidate) {
+        nextIndex = index;
+        break;
+      }
+
+      const projected = {
+        results: [...results, candidate],
+        totalOperations: operations.length,
+        nextIndex: index + 1 < operations.length ? index + 1 : null,
+        truncated: false,
+        maxTotalBytes: totalBudget,
+      };
+      if (byteSize(projected) > totalBudget) {
+        nextIndex = index;
+        break;
+      }
+      results.push(candidate);
+    }
+
+    const nestedTruncated = results.some((entry) => entry.ok && entry.result?.truncated === true);
+    return {
+      results,
+      totalOperations: operations.length,
+      nextIndex,
+      truncated: nextIndex !== null || nestedTruncated,
+      maxTotalBytes: totalBudget,
+    };
+  }
+
+
+  async exportArtifact(input, maxBytes = MAX_ARTIFACT_BYTES) {
+    const target = await this.#resolveExisting(input);
+    const info = await fs.stat(target);
+    if (!info.isFile()) throw new Error("not_a_file");
+
+    const requested = Number(maxBytes);
+    const byteLimit = Number.isFinite(requested)
+      ? Math.min(Math.max(Math.trunc(requested), 1024), MAX_ARTIFACT_BYTES)
+      : MAX_ARTIFACT_BYTES;
+    if (info.size <= 0) throw new Error("artifact_empty");
+    if (info.size > byteLimit) throw new Error("artifact_too_large");
+
+    const bytes = await fs.readFile(target);
+    const extension = path.extname(target).toLowerCase();
+    const mimeType = ARTIFACT_MIME_TYPES.get(extension) || "application/octet-stream";
+    return {
+      ok: true,
+      filename: path.basename(target).slice(0, 180),
+      mimeType,
+      byteLength: bytes.byteLength,
+      data: bytes.toString("base64"),
+    };
+  }
+
   async write(input, content, mode = "rewrite") {
     if (typeof content !== "string" || Buffer.byteLength(content, "utf8") > MAX_WRITE_BYTES) {
       throw new Error("content_too_large");

package/agent/lifecycle.mjs

@@ -0,0 +1,101 @@
+const ALLOWED_WHILE_DRAINING = new Set([
+  "ping",
+  "agent.config",
+  "agent.recentCalls",
+  "agent.lifecycle.status",
+  "agent.lifecycle.drain",
+  "agent.lifecycle.resume",
+  "agent.lifecycle.restart",
+  "fs.stat",
+  "fs.list",
+  "fs.read",
+  "fs.readMany",
+  "fs.batch",
+  "fs.artifact",
+  "fs.search.start",
+  "fs.search.results",
+  "process.list",
+  "process.kill",
+  "desktop.screenshot",
+  "desktop.clipboard.read",
+  "desktop.window.list",
+  "terminal.batch.status",
+  "terminal.batch.read",
+  "terminal.batch.cancel",
+  "terminal.read",
+  "terminal.write",
+  "terminal.kill",
+  "terminal.list",
+  "terminal.observability",
+]);
+
+export const AGENT_RESTART_EXIT_CODE = 4;
+
+function normalizeWork(value = {}) {
+  const count = (key) => Math.max(0, Number(value[key]) || 0);
+  const work = {
+    activeSessions: count("activeSessions"),
+    activeBatchJobs: count("activeBatchJobs"),
+    queuedBatchJobs: count("queuedBatchJobs"),
+    activeTerminalExecs: count("activeTerminalExecs"),
+    queuedTerminalExecs: count("queuedTerminalExecs"),
+  };
+  work.total = Object.values(work).reduce((sum, item) => sum + item, 0);
+  return work;
+}
+
+export class AgentLifecycle {
+  constructor(options = {}) {
+    this.state = "running";
+    this.drainStartedAt = null;
+    this.restartRequestedAt = null;
+    this.now = options.now ?? (() => Date.now());
+    this.workSummary = options.workSummary ?? (() => ({}));
+  }
+
+  snapshot() {
+    const work = normalizeWork(this.workSummary());
+    return {
+      state: this.state,
+      drainStartedAt: this.drainStartedAt,
+      restartRequestedAt: this.restartRequestedAt,
+      readyToRestart: this.state === "draining" && work.total === 0,
+      work,
+    };
+  }
+
+  drain() {
+    if (this.state !== "restart-pending") {
+      this.state = "draining";
+      this.drainStartedAt ??= new Date(this.now()).toISOString();
+    }
+    return { ok: true, lifecycle: this.snapshot() };
+  }
+
+  resume() {
+    if (this.state === "restart-pending") {
+      return { ok: false, error: "restart_pending", lifecycle: this.snapshot() };
+    }
+    this.state = "running";
+    this.drainStartedAt = null;
+    return { ok: true, lifecycle: this.snapshot() };
+  }
+
+  guard(action) {
+    if (this.state === "running" || ALLOWED_WHILE_DRAINING.has(String(action))) return null;
+    return { ok: false, error: "agent_draining", lifecycle: this.snapshot() };
+  }
+
+  requestRestart() {
+    if (this.state !== "draining") {
+      return { ok: false, error: "drain_required", lifecycle: this.snapshot() };
+    }
+    const snapshot = this.snapshot();
+    if (snapshot.work.total > 0) {
+      return { ok: false, error: "active_work_remaining", lifecycle: snapshot };
+    }
+    this.state = "restart-pending";
+    this.restartRequestedAt = new Date(this.now()).toISOString();
+    return { ok: true, restart: true, lifecycle: this.snapshot() };
+  }
+}