@anusornneal/chat-relay 0.7.1 → 0.8.0

package/agent/file-manager.mjs

@@ -5,11 +5,32 @@ 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;
 const MAX_SEARCH_FILES = 5000;
+const DEFAULT_LIST_LIMIT = 200;
+const MAX_LIST_LIMIT = 500;
+const DEFAULT_LIST_RESPONSE_BYTES = 48 * 1024;
 const SKIP_DIRS = new Set([".git", "node_modules", ".gradle", ".idea", ".wrangler"]);
+const ALLOWED_DOT_DIRS = new Set([".github"]);
+
+function skipWalkDirectory(name) {
+  return SKIP_DIRS.has(name) || (name.startsWith(".") && !ALLOWED_DOT_DIRS.has(name));
+}
 
 function splitRoots(spec) {
   if (!spec) return [process.cwd()];
@@ -82,31 +103,48 @@ export class FileManager {
     };
   }
 
-  async list(input, depth = 1) {
+  async list(input, depth = 1, offset = 0, limit = DEFAULT_LIST_LIMIT, maxBytes = DEFAULT_LIST_RESPONSE_BYTES) {
     const target = await this.#resolveExisting(input);
-    const maxDepth = Math.min(Math.max(Number(depth) || 1, 0), 3);
+    const numericDepth = Number(depth);
+    const maxDepth = Number.isFinite(numericDepth) ? Math.min(Math.max(Math.trunc(numericDepth), 0), 3) : 1;
+    const start = Math.max(Math.trunc(Number(offset) || 0), 0);
+    const pageLimit = Math.min(Math.max(Math.trunc(Number(limit) || DEFAULT_LIST_LIMIT), 1), MAX_LIST_LIMIT);
+    const responseBudget = boundedReadBytes(maxBytes, DEFAULT_LIST_RESPONSE_BYTES, 4 * 1024);
     const entries = [];
-    await this.#walkList(target, 0, maxDepth, entries);
-    return { path: target, entries };
+    await this.#walkList(target, 0, maxDepth, entries, start + pageLimit + 1);
+
+    const selected = entries.slice(start, start + pageLimit);
+    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");
+
+    return payloadFor(selected);
   }
 
-  async #walkList(current, level, maxDepth, output) {
+  async #walkList(current, level, maxDepth, output, stopAfter = 1001) {
     const items = await fs.readdir(current, { withFileTypes: true });
     items.sort((a, b) => a.name.localeCompare(b.name));
     for (const item of items) {
       const fullPath = path.join(current, item.name);
       let size = null;
       if (item.isFile()) size = (await fs.stat(fullPath)).size;
-      output.push({
-        path: fullPath,
-        name: item.name,
-        type: item.isDirectory() ? "directory" : item.isFile() ? "file" : "other",
-        size,
-      });
-      if (output.length >= 1000) return;
-      if (item.isDirectory() && level < maxDepth && !SKIP_DIRS.has(item.name)) {
-        await this.#walkList(fullPath, level + 1, maxDepth, output);
-        if (output.length >= 1000) return;
+      output.push({ path: fullPath, name: item.name, type: item.isDirectory() ? "directory" : item.isFile() ? "file" : "other", size });
+      if (output.length >= stopAfter) return;
+      if (item.isDirectory() && level < maxDepth && !skipWalkDirectory(item.name)) {
+        await this.#walkList(fullPath, level + 1, maxDepth, output, stopAfter);
+        if (output.length >= stopAfter) return;
       }
     }
   }
@@ -230,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");
@@ -305,12 +464,14 @@ export class FileManager {
       const needle = pattern.toLowerCase();
       let scanned = 0;
 
-      const walk = async (current) => {
-        if (session.results.length >= limit || scanned >= MAX_SEARCH_FILES) return;
+      const queue = [target];
+      while (queue.length > 0 && session.results.length < limit && scanned < MAX_SEARCH_FILES) {
+        const current = queue.shift();
         const items = await fs.readdir(current, { withFileTypes: true }).catch(() => []);
+        items.sort((a, b) => a.name.localeCompare(b.name));
         for (const item of items) {
           if (session.results.length >= limit || scanned >= MAX_SEARCH_FILES) break;
-          if (item.isDirectory() && SKIP_DIRS.has(item.name)) continue;
+          if (item.isDirectory() && skipWalkDirectory(item.name)) continue;
           const fullPath = path.join(current, item.name);
           scanned++;
 
@@ -330,12 +491,9 @@ export class FileManager {
               }
             }
           }
-
-          if (item.isDirectory()) await walk(fullPath);
+          if (item.isDirectory()) queue.push(fullPath);
         }
-      };
-
-      await walk(target);
+      }
       session.status = "COMPLETED";
       session.scanned = scanned;
     } catch (error) {

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() };
+  }
+}