replicas-engine 0.1.632 → 0.1.634

package/dist/src/{chunk-2WNJA3MT.js → chunk-GT5CS5BI.js}

@@ -226,14 +226,43 @@ function gitIdentityConfigCommands(identity, scope = "global") {
 
 // ../shared/src/headless-agent.ts
 import { z } from "zod";
-var headlessAgentRequestSchema = z.object({
+var headlessAgentRequestBaseSchema = z.object({
   agent: z.custom(
     (value) => typeof value === "string" && isValidCodingAgentProvider(value)
   ),
   model: z.string().min(1),
   prompt: z.string(),
-  outputSchema: z.record(z.string(), z.json()),
-  workingDirectory: z.string().min(1)
+  workingDirectory: z.string().min(1),
+  timeoutSeconds: z.number().int().min(1).max(1800).default(300)
+});
+var headlessAgentInputFileSchema = z.object({
+  path: z.string().min(1),
+  downloadUrl: z.url()
+});
+var headlessAgentOutputFileSchema = z.object({
+  path: z.string().min(1),
+  uploadUrl: z.url(),
+  contentType: z.string().min(1),
+  maxChars: z.number().int().positive().optional()
+});
+var headlessAgentRequestSchema = z.discriminatedUnion("mode", [
+  headlessAgentRequestBaseSchema.extend({
+    mode: z.literal("structured"),
+    outputSchema: z.record(z.string(), z.json())
+  }),
+  headlessAgentRequestBaseSchema.extend({
+    mode: z.literal("filesystem"),
+    inputFiles: z.array(headlessAgentInputFileSchema),
+    outputFiles: z.array(headlessAgentOutputFileSchema),
+    sensitiveValues: z.array(z.string())
+  })
+]);
+var headlessFilesystemAgentResultSchema = z.object({
+  message: z.string(),
+  files: z.record(z.string(), z.object({
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    sizeBytes: z.number().int().nonnegative()
+  }))
 });
 
 // ../shared/src/engine/environment.ts
@@ -876,6 +905,53 @@ function paginateChatHistory(full, params) {
   };
 }
 
+// ../shared/src/memory-safety.ts
+var SECRET_PATTERNS = [
+  /sk-[A-Za-z0-9_-]{10,}/g,
+  /ghp_[A-Za-z0-9]{20,}/g,
+  /github_pat_[A-Za-z0-9_]{20,}/g,
+  /xox[abps]-[A-Za-z0-9-]{10,}/g,
+  /AKIA[0-9A-Z]{16}/g,
+  /eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}/g,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----/g,
+  /\b(?:authorization\s*:\s*bearer|bearer)\s+[a-z0-9._~+/=-]{16,}/gi,
+  /\b(?:api[_-]?key|token|secret|password|passwd)\s*[:=]\s*["']?[a-z0-9._~+/=-]{12,}["']?/gi,
+  /\b[A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD)\s*=\s*[^\s]{12,}/g
+];
+var MIN_SECRET_MATCH_CHARS = 16;
+var flatten = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+function containsSecret(value) {
+  return SECRET_PATTERNS.some((pattern) => {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+  });
+}
+function secretEncodings(secret) {
+  const bytes = new TextEncoder().encode(secret);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  const base64 = btoa(binary);
+  return [
+    secret,
+    base64,
+    base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, ""),
+    [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join(""),
+    [...secret].reverse().join("")
+  ];
+}
+function containsKnownSecret(value, secrets) {
+  const haystack = flatten(value);
+  if (!haystack) return false;
+  return secrets.some((secret) => secretEncodings(secret).some((needle) => {
+    const flattened = flatten(needle);
+    return flattened.length >= MIN_SECRET_MATCH_CHARS && haystack.includes(flattened);
+  }));
+}
+function isUnsafeMemoryOutput(value, secrets, maxChars) {
+  return maxChars !== void 0 && value.length > maxChars || containsSecret(value) || containsKnownSecret(value, secrets);
+}
+
 // ../shared/src/async.ts
 var TIMEOUT = /* @__PURE__ */ Symbol("timeout");
 async function raceWithTimeout(promise, ms) {
@@ -5514,6 +5590,39 @@ function isSkillRegistryManifest(value) {
   );
 }
 
+// src/utils/presigned-upload.ts
+import { createReadStream } from "fs";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+async function putPresignedFile(urlValue, filePath, size, contentType) {
+  await new Promise((resolve, reject) => {
+    const url = new URL(urlValue);
+    const request = (url.protocol === "https:" ? httpsRequest : httpRequest)(url, {
+      method: "PUT",
+      headers: {
+        "content-length": String(size),
+        "content-type": contentType
+      }
+    }, (response) => {
+      response.setEncoding("utf8");
+      let body = "";
+      response.on("data", (chunk) => {
+        body += chunk;
+      });
+      response.on("end", () => {
+        const status = response.statusCode ?? 0;
+        if (status >= 200 && status < 300) resolve();
+        else reject(new Error(`upload failed: ${status} ${body}`));
+      });
+      response.on("error", reject);
+    });
+    request.on("error", reject);
+    const file = size > 0 ? createReadStream(filePath, { start: 0, end: size - 1 }) : createReadStream(filePath);
+    file.on("error", (error) => request.destroy(error));
+    file.pipe(request);
+  });
+}
+
 // src/engine-env.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
@@ -5930,7 +6039,7 @@ var DEFAULT_CODEX_ARGS = [
 var MIN_CODEX_CLI_VERSION = "0.144.6";
 var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
 var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.632";
+var ENGINE_PACKAGE_VERSION = "0.1.634";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -6247,7 +6356,9 @@ export {
   parseAgentEvents,
   parseDisplayMessages,
   parseChatTranscriptArtifact,
+  isUnsafeMemoryOutput,
   isSkillRegistryManifest,
+  putPresignedFile,
   isRecord4 as isRecord2,
   IS_WARMING_MODE,
   ENGINE_ENV,

package/dist/src/headless-agent.js

@@ -2,24 +2,106 @@
 import {
   AGENT,
   AppServerProcess,
-  headlessAgentRequestSchema
-} from "./chunk-2WNJA3MT.js";
+  headlessAgentRequestSchema,
+  isUnsafeMemoryOutput,
+  putPresignedFile
+} from "./chunk-GT5CS5BI.js";
 
 // src/headless-agent.ts
-import { readFile, writeFile } from "fs/promises";
+import { createHash } from "crypto";
+import { createWriteStream } from "fs";
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+import path from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
-var TURN_TIMEOUT_MS = 3e5;
+var FILESYSTEM_TOOLS = ["Read", "Write", "Edit", "Glob", "Grep"];
+function resolveFile(root, relativePath) {
+  if (path.isAbsolute(relativePath)) throw new Error("Headless agent file paths must be relative");
+  const resolved = path.resolve(root, relativePath);
+  if (resolved === root || !resolved.startsWith(`${root}${path.sep}`)) {
+    throw new Error("Headless agent file path escapes its working directory");
+  }
+  return resolved;
+}
+async function downloadFile(urlValue, destination) {
+  await mkdir(path.dirname(destination), { recursive: true, mode: 448 });
+  await new Promise((resolve, reject) => {
+    const url = new URL(urlValue);
+    const request = (url.protocol === "https:" ? httpsRequest : httpRequest)(url, (response) => {
+      const status = response.statusCode ?? 0;
+      if (status < 200 || status >= 300) {
+        response.resume();
+        reject(new Error(`File download failed with status ${status}`));
+        return;
+      }
+      const file = createWriteStream(destination, { mode: 384 });
+      response.on("error", (error) => file.destroy(error));
+      file.on("error", reject);
+      file.on("finish", resolve);
+      response.pipe(file);
+    });
+    request.on("error", reject);
+    request.end();
+  });
+}
+async function stageFilesystemInputs(request) {
+  await Promise.all(request.inputFiles.map((file) => downloadFile(
+    file.downloadUrl,
+    resolveFile(request.workingDirectory, file.path)
+  )));
+}
+async function publishFilesystemOutputs(request) {
+  const files = {};
+  const uploads = [];
+  for (const output of request.outputFiles) {
+    const filePath = resolveFile(request.workingDirectory, output.path);
+    const content = (await readFile(filePath, "utf8")).trim();
+    if (isUnsafeMemoryOutput(content, request.sensitiveValues, output.maxChars)) {
+      throw new Error(`Headless agent output failed validation: ${output.path}`);
+    }
+    await writeFile(filePath, content, { mode: 384 });
+    const { size } = await stat(filePath);
+    files[output.path] = { sha256: createHash("sha256").update(content).digest("hex"), sizeBytes: size };
+    uploads.push({ url: output.uploadUrl, path: filePath, contentType: output.contentType, size });
+  }
+  await Promise.all(uploads.map((upload) => putPresignedFile(
+    upload.url,
+    upload.path,
+    upload.size,
+    upload.contentType
+  )));
+  return files;
+}
+function filesystemPermission(root) {
+  return async (toolName, input) => {
+    const candidate = input.file_path ?? input.path;
+    if (typeof candidate === "string") {
+      const resolved = path.resolve(root, candidate);
+      if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`)) {
+        return { behavior: "deny", message: "Memory maintenance is restricted to its working directory." };
+      }
+    }
+    if (toolName === "Glob" && typeof input.pattern === "string") {
+      if (path.isAbsolute(input.pattern) || input.pattern.split(/[\\/]/).includes("..")) {
+        return { behavior: "deny", message: "Memory maintenance is restricted to its working directory." };
+      }
+    }
+    return { behavior: "allow", updatedInput: input };
+  };
+}
 async function runClaude(request) {
   const response = query({
     prompt: request.prompt,
     options: {
       cwd: request.workingDirectory,
       model: request.model,
-      tools: [],
-      permissionMode: "dontAsk",
+      tools: request.mode === "filesystem" ? FILESYSTEM_TOOLS : [],
+      permissionMode: request.mode === "filesystem" ? "default" : "dontAsk",
+      ...request.mode === "filesystem" ? { canUseTool: filesystemPermission(request.workingDirectory) } : {},
       settingSources: [],
       persistSession: false,
-      outputFormat: { type: "json_schema", schema: request.outputSchema },
+      ...request.mode === "structured" ? { outputFormat: { type: "json_schema", schema: request.outputSchema } } : {},
       env: { ...process.env, CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1" }
     }
   });
@@ -33,9 +115,10 @@ async function runClaude(request) {
   }
   if (!result) throw new Error("Claude Agent SDK returned no result");
   if (result.subtype !== "success") throw new Error(result.errors.join("\n") || result.subtype);
+  if (request.mode === "filesystem") return result.result;
   return result.structured_output ?? JSON.parse(result.result);
 }
-function runCodexTurn(client, params) {
+function runCodexTurn(client, params, timeoutMs) {
   return new Promise((resolve, reject) => {
     const cleanup = () => {
       clearTimeout(timeout);
@@ -54,7 +137,7 @@ function runCodexTurn(client, params) {
     const timeout = setTimeout(() => {
       cleanup();
       reject(new Error("Codex ASP turn timed out"));
-    }, TURN_TIMEOUT_MS);
+    }, timeoutMs);
     client.on("notification", onNotification);
     client.on("dispose", onDispose);
     void client.request("turn/start", params).catch((error) => {
@@ -78,7 +161,7 @@ async function runCodex(request) {
       cwd: request.workingDirectory,
       approvalPolicy: "never",
       approvalsReviewer: "user",
-      sandbox: "read-only",
+      sandbox: request.mode === "filesystem" ? "workspace-write" : "read-only",
       ephemeral: true,
       environments: [],
       dynamicTools: [],
@@ -87,14 +170,15 @@ async function runCodex(request) {
     const turn = await runCodexTurn(client, {
       threadId: thread.thread.id,
       input: [{ type: "text", text: request.prompt, text_elements: [] }],
-      outputSchema: request.outputSchema,
+      ...request.mode === "structured" ? { outputSchema: request.outputSchema } : {},
       approvalPolicy: "never",
       approvalsReviewer: "user",
       environments: []
-    });
+    }, request.timeoutSeconds * 1e3);
     if (turn.status === "failed") throw new Error(turn.error?.message ?? "Codex ASP turn failed");
     const message = turn.items.findLast((item) => item.type === "agentMessage");
     if (!message || message.type !== "agentMessage") throw new Error("Codex ASP returned no final message");
+    if (request.mode === "filesystem") return message.text;
     return JSON.parse(message.text);
   } finally {
     await appServer.stop();
@@ -104,6 +188,7 @@ async function main() {
   const [requestPath, outputPath] = process.argv.slice(2);
   if (!requestPath || !outputPath) throw new Error("Usage: replicas-headless-agent <request.json> <output.json>");
   const request = headlessAgentRequestSchema.parse(JSON.parse(await readFile(requestPath, "utf8")));
+  if (request.mode === "filesystem") await stageFilesystemInputs(request);
   let result;
   switch (request.agent) {
     case AGENT.CLAUDE:
@@ -115,6 +200,10 @@ async function main() {
     default:
       throw new Error(`Unsupported headless agent: ${request.agent}`);
   }
+  if (request.mode === "filesystem") {
+    if (typeof result !== "string") throw new Error("Filesystem agent returned an invalid result");
+    result = { message: result, files: await publishFilesystemOutputs(request) };
+  }
   await writeFile(outputPath, JSON.stringify(result), { mode: 384 });
 }
 main().catch((error) => {

package/dist/src/index.js

@@ -140,6 +140,7 @@ import {
   parseMcpToolName,
   parseReplicasConfigString,
   percentage,
+  putPresignedFile,
   raceWithTimeout,
   resolveClaudeAuthMethodForMessage,
   resolveWarmHookConfig,
@@ -148,7 +149,7 @@ import {
   setAgentCredentialSnapshot,
   shellQuotePosix,
   stripAgentDiagnosticErrors
-} from "./chunk-2WNJA3MT.js";
+} from "./chunk-GT5CS5BI.js";
 
 // src/index.ts
 import { serve } from "@hono/node-server";
@@ -10099,8 +10100,6 @@ async function reconcileCanvasItems(filenames) {
 import { createReadStream } from "fs";
 import { createHash as createHash2 } from "crypto";
 import { readdir as readdir8, readFile as readFile14, stat as stat4 } from "fs/promises";
-import { request as httpRequest } from "http";
-import { request as httpsRequest } from "https";
 import { basename as basename2, join as join23 } from "path";
 
 // src/services/chat/chat-senders.ts
@@ -10127,34 +10126,6 @@ var HISTORY_DIRS = [
   join23(ENGINE_DIR2, "relay-histories"),
   join23(ENGINE_DIR2, "codex-histories")
 ];
-async function putTranscript(uploadUrl, filePath, size) {
-  await new Promise((resolve5, reject) => {
-    const url = new URL(uploadUrl);
-    const request = (url.protocol === "https:" ? httpsRequest : httpRequest)(url, {
-      method: "PUT",
-      headers: {
-        "content-length": String(size),
-        "content-type": "application/x-ndjson"
-      }
-    }, (response) => {
-      response.setEncoding("utf8");
-      let body = "";
-      response.on("data", (chunk) => {
-        body += chunk;
-      });
-      response.on("end", () => {
-        const status = response.statusCode ?? 0;
-        if (status >= 200 && status < 300) resolve5();
-        else reject(new Error(`upload failed: ${status} ${body}`));
-      });
-      response.on("error", reject);
-    });
-    request.on("error", reject);
-    const file = createReadStream(filePath, { start: 0, end: size - 1 });
-    file.on("error", (error) => request.destroy(error));
-    file.pipe(request);
-  });
-}
 async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map(), capture) {
   let flushed = 0;
   let failed = 0;
@@ -10222,7 +10193,7 @@ async function uploadChatTranscript(chatId, filePath, chat, capture) {
     throw new Error("prepare failed: invalid response");
   }
   if (prepareBody.uploadUrl === null) return null;
-  await putTranscript(prepareBody.uploadUrl, filePath, size);
+  await putPresignedFile(prepareBody.uploadUrl, filePath, size, "application/x-ndjson");
   const finalizeResponse = await monolithRequest("/v1/engine/chat-transcripts/finalize", {
     body: uploadRequest
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.632",
+  "version": "0.1.634",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",