aec-agent 1.0.1 → 1.0.4

package/dist/components/sandbox-hub/docker/sandbox-helper.js

@@ -14,6 +14,23 @@
 //                            held open; closing it kills the command's whole
 //                            process group. stdout starts with "AEC-OK\n" or
 //                            "AEC-ERR {json}\n", followed by the command output.
+//   node helper.js readraw   raw bytes (A-124): one JSON request on stdin; stdout is
+//                            "AEC-OK {json}\n" (path, size, modifiedAt, offset,
+//                            length) followed by exactly `length` file bytes, or
+//                            "AEC-ERR {json}\n".
+//   node helper.js writeraw  raw bytes (A-124): a JSON header line on stdin, then the
+//                            file's bytes until stdin ends; one JSON response line
+//                            on stdout, like a file operation. The bytes go to a temp
+//                            file that is renamed into place only when all arrived.
+//   node helper.js connect   a TCP connection (A-124 phase 2): a JSON header line
+//                            { port } on stdin; stdout is "AEC-OK\n" or "AEC-ERR
+//                            {json}\n", then stdin/stdout are piped to/from
+//                            127.0.0.1:<port> (or ::1) until either side closes.
+//
+// Services (A-124 phase 2) are file operations too (svcstart, svcstop, svclist,
+// svclogs): a service runs detached in its own process group and outlives the call;
+// its record, log and exit code live in /tmp/aec-services/<agent key>/ (tmpfs, so a
+// container restart forgets them, as it ends the processes).
 //
 // Plain JavaScript (no template literals — this file embeds it in one), no
 // dependencies, Node >= 18. Images used for sandboxes must provide `node`.
@@ -26,6 +43,7 @@ const posix = require("path").posix;
 const crypto = require("crypto");
 const cp = require("child_process");
 const os = require("os");
+const net = require("net");
 
 class OpError extends Error {
   constructor(code, message) { super(message); this.code = code; }
@@ -325,24 +343,211 @@ const ops = {
   },
 };
 
+// --- Services (A-124 phase 2) ---
+
+const SERVICE_NAME = /^[a-z0-9][a-z0-9-]{0,39}$/;
+
+function serviceDir(workingDir) {
+  return "/tmp/aec-services/" + crypto.createHash("sha256").update(workingDir).digest("hex").slice(0, 16);
+}
+
+function sleep(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+
+function alive(pid) {
+  try { process.kill(pid, 0); return true; } catch (e) { return e.code === "EPERM"; }
+}
+
+// Can a TCP connection be made to the port (IPv4 loopback, then IPv6)?
+function probe(port) {
+  const tryHost = (host) => new Promise((resolve) => {
+    const s = net.connect({ host: host, port: port });
+    const done = (ok) => { s.destroy(); resolve(ok); };
+    s.setTimeout(500, () => done(false));
+    s.once("connect", () => done(true));
+    s.once("error", () => done(false));
+  });
+  return tryHost("127.0.0.1").then((ok) => ok || tryHost("::1"));
+}
+
+function portFree(port) {
+  return new Promise((resolve) => {
+    const srv = net.createServer();
+    srv.once("error", () => resolve(false));
+    srv.listen(port, "127.0.0.1", () => srv.close(() => resolve(true)));
+  });
+}
+
+// The name of a service request: it is joined into file names, so only the plain form passes.
+function serviceName(q) {
+  if (!SERVICE_NAME.test(q.name || "")) fail("invalid_argument", "Service names are lower-case letters, digits and dashes (at most 40)");
+  return q.name;
+}
+
+function readRecord(dir, name) {
+  try { return JSON.parse(fs.readFileSync(posix.join(dir, name + ".json"), "utf8")); } catch (_) { return null; }
+}
+
+async function describe(dir, rec) {
+  let status = "exited";
+  let exitCode;
+  if (alive(rec.pid)) {
+    status = (await probe(rec.port)) ? "listening" : "starting";
+  } else {
+    try {
+      const text = fs.readFileSync(posix.join(dir, rec.name + ".exit"), "utf8").trim();
+      exitCode = text === "" ? null : Number(text);
+    } catch (_) { exitCode = null; }
+  }
+  const out = { name: rec.name, command: rec.command, cwd: rec.cwd, port: rec.port, status: status, startedAt: rec.startedAt };
+  if (status === "exited") out.exitCode = exitCode;
+  return out;
+}
+
+function listRecords(dir) {
+  let names = [];
+  try { names = fs.readdirSync(dir); } catch (_) { return []; }
+  return names.filter((n) => n.endsWith(".json")).sort().map((n) => readRecord(dir, n.slice(0, -5))).filter(Boolean);
+}
+
+const serviceOps = {
+  async svcstart(q) {
+    serviceName(q);
+    if (typeof q.command !== "string" || q.command.trim() === "") fail("invalid_argument", "command must be a non-empty string");
+    const cwd = realPath(q.cwd, q.roots);
+    let st;
+    try { st = fs.statSync(cwd); } catch (e) { throw fsError(e, q.cwd); }
+    if (!st.isDirectory()) fail("invalid_path", "\"" + q.cwd + "\" is not a directory");
+    const dir = serviceDir(q.workingDir);
+    fs.mkdirSync(dir, { recursive: true });
+    const records = listRecords(dir);
+    const running = records.filter((r) => alive(r.pid));
+    if (running.some((r) => r.name === q.name)) fail("conflict", "A service named \"" + q.name + "\" is already running \u2014 stop it first");
+    if (running.length >= q.maxServices) {
+      fail("policy_denied", "At most " + q.maxServices + " services may run at once \u2014 stop one first (" + running.map((r) => r.name).join(", ") + ")");
+    }
+    let port = q.port;
+    if (port != null) {
+      if (!(await portFree(port))) fail("conflict", "Port " + port + " is already in use in the sandbox");
+    } else {
+      for (let i = 0; i < 50 && port == null; i++) {
+        const candidate = 20000 + Math.floor(Math.random() * 10000);
+        if (await portFree(candidate)) port = candidate;
+      }
+      if (port == null) fail("environment_unavailable", "No free port found in the sandbox");
+    }
+    const log = posix.join(dir, q.name + ".log");
+    const exitFile = posix.join(dir, q.name + ".exit");
+    try { fs.unlinkSync(exitFile); } catch (_) {}
+    const fd = fs.openSync(log, "w");
+    const env = {
+      PATH: process.env.PATH || "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+      HOME: process.env.HOME || "/tmp",
+      LANG: "C.UTF-8",
+    };
+    Object.assign(env, q.env || {});
+    env.PORT = String(port);
+    env.AEC_CMD = q.command;
+    env.AEC_EXIT = exitFile;
+    // The wrapper records the exit code; the service gets its own process group (detached)
+    // and outlives this helper (the container's init reaps it).
+    const child = cp.spawn("/bin/sh", ["-c", "eval \"$AEC_CMD\"; echo $? > \"$AEC_EXIT\""], {
+      cwd: cwd, env: env, detached: true, stdio: ["ignore", fd, fd],
+    });
+    child.unref();
+    fs.closeSync(fd);
+    const rec = { name: q.name, command: q.command, cwd: cwd, port: port, pid: child.pid, startedAt: Date.now() };
+    fs.writeFileSync(posix.join(dir, q.name + ".json"), JSON.stringify(rec));
+    return describe(dir, rec);
+  },
+
+  async svcstop(q) {
+    const dir = serviceDir(q.workingDir);
+    const rec = readRecord(dir, serviceName(q));
+    if (!rec) return null;
+    if (alive(rec.pid)) {
+      try { process.kill(-rec.pid, "SIGTERM"); } catch (_) {}
+      for (let i = 0; i < 30 && alive(rec.pid); i++) await sleep(100);
+      if (alive(rec.pid)) { try { process.kill(-rec.pid, "SIGKILL"); } catch (_) {} await sleep(100); }
+    }
+    return describe(dir, rec);
+  },
+
+  async svclist(q) {
+    const dir = serviceDir(q.workingDir);
+    const out = [];
+    for (const rec of listRecords(dir)) out.push(await describe(dir, rec));
+    return out;
+  },
+
+  svclogs(q) {
+    const dir = serviceDir(q.workingDir);
+    if (!readRecord(dir, serviceName(q))) fail("not_found", "There is no service named \"" + q.name + "\"");
+    const p = posix.join(dir, q.name + ".log");
+    let size = 0;
+    try { size = fs.statSync(p).size; } catch (_) { return { name: q.name, text: "", truncated: false }; }
+    const start = Math.max(0, size - q.maxBytes);
+    const buf = Buffer.alloc(size - start);
+    const fd = fs.openSync(p, "r");
+    try { fs.readSync(fd, buf, 0, buf.length, start); } finally { fs.closeSync(fd); }
+    return { name: q.name, text: buf.toString("utf8"), truncated: start > 0 };
+  },
+};
+Object.assign(ops, serviceOps);
+
 function runOperation() {
   const chunks = [];
   process.stdin.on("data", (c) => chunks.push(c));
   process.stdin.on("end", () => {
-    let response;
+    const answer = (response) => process.stdout.write(JSON.stringify(response) + "\n", () => process.exit(0));
+    const failed = (e) => {
+      const err = fsError(e, "operation");
+      answer({ ok: false, code: err.code, message: err.message });
+    };
     try {
       const q = JSON.parse(Buffer.concat(chunks).toString("utf8"));
       const op = Object.prototype.hasOwnProperty.call(ops, q.op) ? ops[q.op] : null;
       if (!op) fail("invalid_argument", "Unknown operation " + q.op);
-      response = { ok: true, result: op(q) };
+      // A-124 phase 2: service operations are async.
+      Promise.resolve(op(q)).then((result) => answer({ ok: true, result: result }), failed);
     } catch (e) {
-      const err = fsError(e, "operation");
-      response = { ok: false, code: err.code, message: err.message };
+      failed(e);
     }
-    process.stdout.write(JSON.stringify(response) + "\n", () => process.exit(0));
   });
 }
 
+function runConnect() {
+  let header = Buffer.alloc(0);
+  let socket = null;
+  process.stdin.on("data", (chunk) => {
+    if (socket) { socket.write(chunk); return; }
+    header = Buffer.concat([header, chunk]);
+    const nl = header.indexOf(10);
+    if (nl === -1) return;
+    const q = JSON.parse(header.subarray(0, nl).toString("utf8"));
+    const rest = header.subarray(nl + 1);
+    process.stdin.pause();
+    const open = (host, fallback) => {
+      const s = net.connect({ host: host, port: q.port });
+      s.once("connect", () => {
+        socket = s;
+        process.stdout.write("AEC-OK\n");
+        if (rest.length) s.write(rest);
+        s.on("data", (d) => { if (!process.stdout.write(d)) { s.pause(); process.stdout.once("drain", () => s.resume()); } });
+        s.on("end", () => process.stdout.write("", () => process.exit(0)));
+        s.on("error", () => process.exit(0));
+        process.stdin.resume();
+      });
+      s.once("error", (e) => {
+        if (socket) return;
+        if (fallback) { open(fallback, null); return; }
+        process.stdout.write("AEC-ERR " + JSON.stringify({ code: "not_found", message: "Nothing listens on port " + q.port + " in the sandbox (" + (e.code || e.message) + ")" }) + "\n", () => process.exit(0));
+      });
+    };
+    open("127.0.0.1", "::1");
+  });
+  process.stdin.on("end", () => { if (socket) socket.end(); else process.exit(0); });
+}
+
 function runExec() {
   let header = "";
   let started = false;
@@ -436,7 +641,183 @@ function runExec() {
   }
 }
 
+// Parent folder of a file about to be written: created when missing (unless createDirs is false).
+function ensureParent(parent, createDirs) {
+  let parentStat = null;
+  try { parentStat = fs.statSync(parent); } catch (e) {
+    if (e.code !== "ENOENT") throw fsError(e, parent);
+  }
+  if (!parentStat) {
+    if (createDirs === false) fail("not_found", "Directory \"" + parent + "\" does not exist");
+    try { fs.mkdirSync(parent, { recursive: true }); } catch (e) { throw fsError(e, parent); }
+  } else if (!parentStat.isDirectory()) {
+    fail("invalid_path", "\"" + parent + "\" is not a directory");
+  }
+}
+
+function runReadRaw() {
+  const chunks = [];
+  process.stdin.on("data", (c) => chunks.push(c));
+  process.stdin.on("end", () => {
+    let q;
+    let real;
+    let st;
+    try {
+      q = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+      real = realPath(q.path, q.roots);
+      try { st = fs.statSync(real); } catch (e) { throw fsError(e, q.path); }
+      if (!st.isFile()) fail("invalid_path", "\"" + q.path + "\" is a " + typeOf(st) + ", not a file");
+    } catch (e) {
+      const err = fsError(e, q && q.path ? q.path : "operation");
+      process.stdout.write("AEC-ERR " + JSON.stringify({ code: err.code, message: err.message }) + "\n", () => process.exit(0));
+      return;
+    }
+    const offset = Math.min(Math.max(0, Math.floor(q.offset || 0)), st.size);
+    const rest = st.size - offset;
+    const length = q.length == null ? rest : Math.min(Math.max(0, Math.floor(q.length)), rest);
+    const head = { path: real, size: st.size, modifiedAt: Math.round(st.mtimeMs), offset: offset, length: length };
+    process.stdout.write("AEC-OK " + JSON.stringify(head) + "\n");
+    if (length === 0) {
+      process.stdout.write("", () => process.exit(0));
+      return;
+    }
+    const src = fs.createReadStream(real, { start: offset, end: offset + length - 1 });
+    src.on("error", () => process.exit(1));
+    src.on("data", (d) => {
+      if (!process.stdout.write(d)) {
+        src.pause();
+        process.stdout.once("drain", () => src.resume());
+      }
+    });
+    src.on("end", () => process.stdout.write("", () => process.exit(0)));
+  });
+}
+
+// writeraw: a JSON header line on stdin, then the file's bytes as frames - a 4-byte
+// big-endian length and that many bytes; a zero-length frame ends the upload and puts
+// the file in place (temp file renamed). stdin closing before that end frame (the client
+// was killed, the upload broke off) discards the temp file: a partial file never goes
+// into place. The answer is one JSON line on stdout.
+function runWriteRaw() {
+  let header = Buffer.alloc(0);
+  let q = null;
+  let real = null;
+  let existing = null;
+  let tmp = null;
+  let fd = null;
+  let bytes = 0;
+  let answered = false;
+  // What is left of the current frame, and the bytes of a length not complete yet.
+  let remaining = 0;
+  let prefix = Buffer.alloc(0);
+  const hash = crypto.createHash("sha256");
+
+  const answer = (response) => {
+    if (answered) return;
+    answered = true;
+    process.stdout.write(JSON.stringify(response) + "\n", () => process.exit(0));
+  };
+  const abort = (e) => {
+    if (fd !== null) { try { fs.closeSync(fd); } catch (_) {} fd = null; }
+    if (tmp) { try { fs.unlinkSync(tmp); } catch (_) {} tmp = null; }
+    const err = fsError(e, q && q.path ? q.path : "operation");
+    answer({ ok: false, code: err.code, message: err.message });
+  };
+  const begin = () => {
+    real = realPath(q.path, q.roots);
+    try { existing = fs.lstatSync(real); } catch (e) {
+      if (e.code !== "ENOENT" && e.code !== "ENOTDIR") throw fsError(e, q.path);
+    }
+    if (existing && !existing.isFile()) fail("invalid_path", "\"" + q.path + "\" is a " + typeOf(existing));
+    if (existing && q.exclusive) fail("conflict", "\"" + q.path + "\" already exists");
+    const parent = posix.dirname(real);
+    ensureParent(parent, q.createDirs);
+    tmp = posix.join(parent, ".aec-write-" + process.pid + "-" + crypto.randomBytes(4).toString("hex"));
+    try { fd = fs.openSync(tmp, "wx", existing ? existing.mode & 0o7777 : 0o644); } catch (e) { tmp = null; throw fsError(e, q.path); }
+  };
+  const take = (chunk) => {
+    if (chunk.length === 0) return;
+    bytes += chunk.length;
+    if (bytes > q.maxBytes) fail("too_large", "\"" + q.path + "\" is larger than the limit of " + q.maxBytes + " bytes");
+    hash.update(chunk);
+    let done = 0;
+    try {
+      while (done < chunk.length) done += fs.writeSync(fd, chunk, done, chunk.length - done);
+    } catch (e) { throw fsError(e, q.path); }
+  };
+
+  // The upload is complete: the temp file goes into place.
+  const commit = () => {
+    fs.closeSync(fd);
+    fd = null;
+    if (q.exclusive) {
+      let exists = false;
+      try { fs.lstatSync(real); exists = true; } catch (_) {}
+      if (exists) fail("conflict", "\"" + q.path + "\" already exists");
+    }
+    try { fs.renameSync(tmp, real); } catch (e) { throw fsError(e, q.path); }
+    tmp = null;
+    answer({ ok: true, result: { path: real, bytes: bytes, sha256: hash.digest("hex"), created: !existing } });
+  };
+  // Frames: the bytes of a frame go to take(); the zero-length frame commits.
+  const feed = (buf) => {
+    let i = 0;
+    while (i < buf.length) {
+      if (remaining > 0) {
+        const n = Math.min(remaining, buf.length - i);
+        take(buf.subarray(i, i + n));
+        remaining -= n;
+        i += n;
+        continue;
+      }
+      const got = Math.min(4 - prefix.length, buf.length - i);
+      prefix = Buffer.concat([prefix, buf.subarray(i, i + got)]);
+      i += got;
+      if (prefix.length < 4) return;
+      remaining = prefix.readUInt32BE(0);
+      prefix = Buffer.alloc(0);
+      if (remaining === 0) {
+        commit();
+        return;
+      }
+    }
+  };
+
+  process.stdin.on("data", (chunk) => {
+    if (answered) return;
+    try {
+      if (q) {
+        feed(chunk);
+        return;
+      }
+      header = Buffer.concat([header, chunk]);
+      const nl = header.indexOf(10);
+      if (nl === -1) {
+        if (header.length > 1048576) fail("invalid_argument", "Request header too long");
+        return;
+      }
+      q = JSON.parse(header.subarray(0, nl).toString("utf8"));
+      const rest = header.subarray(nl + 1);
+      header = null;
+      begin();
+      feed(rest);
+    } catch (e) { abort(e); }
+  });
+  // stdin closed before the end frame: the upload broke off (the client was killed, the
+  // body failed), so nothing goes into place.
+  process.stdin.on("end", () => {
+    if (answered) return;
+    try {
+      if (!q) fail("invalid_argument", "Missing request header");
+      fail("cancelled", "The upload ended before it was complete (" + bytes + " bytes received)");
+    } catch (e) { abort(e); }
+  });
+}
+
 if (process.argv[2] === "exec") runExec();
+else if (process.argv[2] === "readraw") runReadRaw();
+else if (process.argv[2] === "writeraw") runWriteRaw();
+else if (process.argv[2] === "connect") runConnect();
 else runOperation();
 `;
 //# sourceMappingURL=sandbox-helper.js.map

package/dist/components/sandbox-hub/docker/sandbox-helper.js.map

@@ -1 +1 @@
-{"version":3,"file":"sandbox-helper.js","sourceRoot":"","sources":["../../../../src/components/sandbox-hub/docker/sandbox-helper.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,+EAA+E;AAC/E,gFAAgF;AAChF,2CAA2C;AAC3C,EAAE;AACF,8EAA8E;AAC9E,8EAA8E;AAC9E,6EAA6E;AAC7E,2EAA2E;AAC3E,EAAE;AACF,wEAAwE;AACxE,8DAA8D;AAC9D,+EAA+E;AAC/E,6EAA6E;AAC7E,6EAA6E;AAC7E,iFAAiF;AACjF,EAAE;AACF,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAE9E,mDAAmD;AACnD,MAAM,CAAC,MAAM,WAAW,GAAG,qBAAqB,CAAC;AAEjD,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkatC,CAAC"}
+{"version":3,"file":"sandbox-helper.js","sourceRoot":"","sources":["../../../../src/components/sandbox-hub/docker/sandbox-helper.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,+EAA+E;AAC/E,gFAAgF;AAChF,2CAA2C;AAC3C,EAAE;AACF,8EAA8E;AAC9E,8EAA8E;AAC9E,6EAA6E;AAC7E,2EAA2E;AAC3E,EAAE;AACF,wEAAwE;AACxE,8DAA8D;AAC9D,+EAA+E;AAC/E,6EAA6E;AAC7E,6EAA6E;AAC7E,iFAAiF;AACjF,qFAAqF;AACrF,gFAAgF;AAChF,iFAAiF;AACjF,iDAAiD;AACjD,sFAAsF;AACtF,mFAAmF;AACnF,sFAAsF;AACtF,oFAAoF;AACpF,kFAAkF;AAClF,iFAAiF;AACjF,4EAA4E;AAC5E,iFAAiF;AACjF,EAAE;AACF,gFAAgF;AAChF,oFAAoF;AACpF,oFAAoF;AACpF,6DAA6D;AAC7D,EAAE;AACF,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAE9E,mDAAmD;AACnD,MAAM,CAAC,MAAM,WAAW,GAAG,qBAAqB,CAAC;AAEjD,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8wBtC,CAAC"}

package/dist/components/sandbox-hub/host/host-sandbox.d.ts

@@ -1,4 +1,17 @@
+import type { ChildProcess } from "node:child_process";
 import type { Sandbox, SandboxCapability, SandboxLimits, SandboxTraits, SandboxView } from "../types/sandbox.js";
+/** A-124 phase 2: one service of a host sandbox (in server memory; it ends with the server). */
+interface HostService {
+    name: string;
+    command: string;
+    cwd: string;
+    port: number;
+    child: ChildProcess;
+    startedAt: number;
+    log: string;
+    exited: boolean;
+    exitCode: number | null;
+}
 export declare class HostSandbox implements Sandbox {
     readonly id: string;
     readonly traits: SandboxTraits;
@@ -18,5 +31,8 @@ export declare class HostSandbox implements Sandbox {
     dispose(opts?: {
         removeData?: boolean;
     }): Promise<void>;
+    /** A-124 phase 2: the services of every agent, keyed "<workingDir>\n<name>". */
+    readonly services: Map<string, HostService>;
 }
+export {};
 //# sourceMappingURL=host-sandbox.d.ts.map

package/dist/components/sandbox-hub/host/host-sandbox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"host-sandbox.d.ts","sourceRoot":"","sources":["../../../../src/components/sandbox-hub/host/host-sandbox.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAYV,OAAO,EACP,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,WAAW,EAKZ,MAAM,qBAAqB,CAAC;AA4F7B,qBAAa,WAAY,YAAW,OAAO;IAKvC,QAAQ,CAAC,EAAE,EAAE,MAAM;IACnB,QAAQ,CAAC,MAAM,EAAE,aAAa;IAC9B,QAAQ,CAAC,MAAM,EAAE,aAAa;IAC9B,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM;IARvB,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAA6B;IAClF,QAAQ,UAAS;IAEjB,YACW,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,aAAa;IAC9B,mDAAmD;IAC1C,IAAI,EAAE,MAAM,EACnB;IAEJ,gEAAgE;IAChE,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAG9B;IAEK,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CASpD;IAEK,MAAM,IAAI,OAAO,CAAC,OAAO,GAAG,aAAa,CAAC,CAG/C;IAEK,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpD;IAEK,OAAO,CAAC,IAAI,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAG5D;CACF"}
+{"version":3,"file":"host-sandbox.d.ts","sourceRoot":"","sources":["../../../../src/components/sandbox-hub/host/host-sandbox.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAevD,OAAO,KAAK,EAcV,OAAO,EACP,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,WAAW,EASZ,MAAM,qBAAqB,CAAC;AAiC7B,gGAAgG;AAChG,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAmID,qBAAa,WAAY,YAAW,OAAO;IAKvC,QAAQ,CAAC,EAAE,EAAE,MAAM;IACnB,QAAQ,CAAC,MAAM,EAAE,aAAa;IAC9B,QAAQ,CAAC,MAAM,EAAE,aAAa;IAC9B,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM;IARvB,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAA6B;IAClF,QAAQ,UAAS;IAEjB,YACW,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,aAAa;IAC9B,mDAAmD;IAC1C,IAAI,EAAE,MAAM,EACnB;IAEJ,gEAAgE;IAChE,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAG9B;IAEK,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CASpD;IAEK,MAAM,IAAI,OAAO,CAAC,OAAO,GAAG,aAAa,CAAC,CAG/C;IAEK,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpD;IAEK,OAAO,CAAC,IAAI,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAM5D;IAED,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,2BAAkC;CACpD"}