@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.3

package/src/agent-computer.js

@@ -0,0 +1,88 @@
+import { execFile } from "node:child_process";
+import { mkdir, readFile, rename, rm, stat } from "node:fs/promises";
+import { createHash, randomBytes } from "node:crypto";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CODEFLOW_HOME } from "./config.js";
+let compiling;
+function run(file, args, input, signal) {
+  return new Promise((resolve, reject) => {
+    const child = execFile(file, args, { signal, timeout: 6e4, maxBuffer: 20 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error) {
+        let message = stderr.trim() || error.message;
+        try {
+          message = JSON.parse(stdout).error || message;
+        } catch {
+        }
+        reject(new Error(message));
+      } else resolve(stdout);
+    });
+    child.stdin?.end(input === void 0 ? void 0 : JSON.stringify(input));
+  });
+}
+async function helper() {
+  if (process.platform !== "darwin") throw new Error("Native computer tools currently support macOS. Use browser tools or a configured computer-use MCP server on this platform.");
+  if (!compiling) compiling = (async () => {
+    const packaged = fileURLToPath(new URL("../scripts/computer-use", import.meta.url));
+    if (await stat(packaged).then((info) => info.isFile() && !!(info.mode & 73), () => false)) return packaged;
+    const source = fileURLToPath(new URL("../scripts/computer-use.swift", import.meta.url));
+    const hash = createHash("sha256").update(await readFile(source)).digest("hex").slice(0, 16);
+    const dir = join(CODEFLOW_HOME, "helpers"), binary = join(dir, `computer-${hash}`);
+    if (await stat(binary).then(() => true, () => false)) return binary;
+    await mkdir(dir, { recursive: true, mode: 448 });
+    const temporary = `${binary}-${randomBytes(4).toString("hex")}`;
+    try {
+      await run("/usr/bin/swiftc", [source, "-o", temporary]);
+      await rename(temporary, binary);
+    } catch (error) {
+      await rm(temporary, { force: true });
+      throw new Error(`Computer helper is unavailable: ${error.message}`);
+    }
+    return binary;
+  })().catch((error) => {
+    compiling = void 0;
+    throw error;
+  });
+  return compiling;
+}
+class AgentComputer {
+  constructor(execute = async (input, signal) => JSON.parse(await run(await helper(), [], input, signal))) {
+    this.execute = execute;
+  }
+  screenshot;
+  static generation = 0;
+  static queue = Promise.resolve();
+  call(name, args, signal) {
+    const work = AgentComputer.queue.catch(() => {
+    }).then(async () => {
+      if (signal.aborted) throw new Error("This computer turn has ended");
+      if (name === "computer_screenshot") {
+        const result = await this.execute({ action: "screenshot", ...args.app ? { expectedApp: args.app } : {} }, signal);
+        const id = randomBytes(12).toString("hex");
+        this.screenshot = { id, at: Date.now(), width: result.width, height: result.height, pointWidth: result.pointWidth, pointHeight: result.pointHeight, app: result.app, generation: AgentComputer.generation };
+        return { content: [{ type: "text", text: JSON.stringify({ screenshot: id, width: result.width, height: result.height, app: result.app, note: "Coordinates default to these screenshot pixels. Set coordinateSpace=normalized explicitly for 0\u20131000 coordinates. Capture again after every action." }) }, { type: "image", mimeType: "image/png", data: result.data }] };
+      }
+      if (name !== "computer_action") throw new Error("Unknown computer tool");
+      const seen = this.screenshot;
+      if (!seen || args.screenshot !== seen.id || Date.now() - seen.at > 6e4 || seen.generation !== AgentComputer.generation) throw new Error("Take a fresh computer_screenshot before acting");
+      const request = { ...args };
+      delete request.screenshot;
+      delete request.coordinateSpace;
+      if (args.action === "click") {
+        const width = args.coordinateSpace === "normalized" ? 1e3 : seen.width, height = args.coordinateSpace === "normalized" ? 1e3 : seen.height;
+        if (!Number.isFinite(args.x) || !Number.isFinite(args.y) || args.x < 0 || args.y < 0 || args.x >= width || args.y >= height) throw new Error("Coordinates are outside the screenshot");
+        request.x = args.x * seen.pointWidth / width;
+        request.y = args.y * seen.pointHeight / height;
+      }
+      this.screenshot = void 0;
+      AgentComputer.generation++;
+      request.expectedApp = seen.app;
+      return this.execute(request, signal);
+    });
+    AgentComputer.queue = work;
+    return work;
+  }
+}
+export {
+  AgentComputer
+};

package/src/agent-container.js

@@ -0,0 +1,155 @@
+import { randomUUID } from "node:crypto";
+import { execFile, spawnSync } from "node:child_process";
+import { lstatSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { childEnv } from "./env.js";
+const filteredContainers = /* @__PURE__ */ new WeakMap();
+function filteredTaskContainer(raw, id, readOnly = []) {
+  if (raw.authVolume || !/^sha256:[a-f0-9]{64}$/.test(raw.image)) throw new Error("Filtered containers require an immutable image and no authentication volume");
+  if (!/^filtered-[a-f0-9]{24}$/.test(id) || readOnly.length > 500 || readOnly.some((path) => !path || path.startsWith("/") || /[\\\x00-\x1f]/.test(path) || path.split("/").some((part) => !part || part === "." || part === ".." || part === ".git"))) throw new Error("Invalid filtered container receipt");
+  const config = validateAgentContainer(raw);
+  filteredContainers.set(config, { id, readOnly: [...readOnly] });
+  return config;
+}
+function validateAgentContainer(raw) {
+  const value = raw;
+  if (!value || typeof value !== "object" || typeof value.image !== "string" || !/^[a-zA-Z0-9][\w./:@-]{0,199}$/.test(value.image)) throw new Error("Agent isolation needs a valid prebuilt Docker image");
+  if (value.authVolume !== void 0 && (typeof value.authVolume !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/.test(value.authVolume))) throw new Error("Agent authentication must use an explicitly named Docker volume, never a host path");
+  if (value.network !== void 0 && typeof value.network !== "boolean") throw new Error("Agent container network must be enabled or disabled explicitly");
+  if (value.memoryMb !== void 0 && (!Number.isInteger(value.memoryMb) || value.memoryMb < 128 || value.memoryMb > 65536)) throw new Error("Agent container memory must be 128\u201365536 MB");
+  if (value.cpus !== void 0 && (!Number.isFinite(value.cpus) || value.cpus < 0.1 || value.cpus > 64)) throw new Error("Agent container CPUs must be 0.1\u201364");
+  return {
+    image: value.image,
+    ...value.authVolume ? { authVolume: value.authVolume } : {},
+    ...value.network === void 0 ? {} : { network: value.network },
+    ...value.memoryMb === void 0 ? {} : { memoryMb: value.memoryMb },
+    ...value.cpus === void 0 ? {} : { cpus: value.cpus }
+  };
+}
+function agentContainerLaunch(command, args, cwd, mode, raw, extraReadOnly = []) {
+  const filtered = filteredContainers.get(raw);
+  const container = validateAgentContainer(raw);
+  if (!["claude", "codex", "agy"].includes(command)) throw new Error("Only supported official agent CLIs can run in an agent container");
+  const root = realpathSync(cwd);
+  if (!lstatSync(root).isDirectory()) throw new Error("Agent workspace must be a directory");
+  const mounts = /* @__PURE__ */ new Map([[root, mode === "read"]]);
+  for (const path of readOnlyGitMetadata(root)) mounts.set(path, true);
+  for (const path of extraReadOnly) mounts.set(realpathSync(path), true);
+  for (const relative of filtered?.readOnly ?? []) {
+    const target = realpathSync(join(root, relative));
+    if (!target.startsWith(`${root}/`) || !lstatSync(target).isFile()) throw new Error("Filtered read-only mounts must be regular files inside the export");
+    mounts.set(target, true);
+  }
+  for (const path of mounts.keys()) if (!isAbsolute(path) || /[,\n\r\0]/.test(path)) throw new Error("Docker isolation cannot mount paths containing commas or line breaks");
+  const name = `codeflow-agent-${randomUUID().replace(/-/g, "")}`;
+  const user = typeof process.getuid === "function" ? ["--user", `${process.getuid()}:${process.getgid()}`] : ["--user", "65532:65532"];
+  return {
+    command: "docker",
+    name,
+    args: [
+      "run",
+      "--rm",
+      "--init",
+      "--interactive",
+      "--pull=never",
+      "--name",
+      name,
+      "--label",
+      "codeflow.managed-agent=true",
+      "--cap-drop=ALL",
+      "--security-opt=no-new-privileges",
+      ...filtered ? ["--label", `codeflow.filtered-task=${filtered.id}`] : [],
+      ...filtered ? ["--read-only", "--tmpfs", `/home/codeflow:rw,nosuid,nodev,size=134217728,uid=${typeof process.getuid === "function" ? process.getuid() : 65532},gid=${typeof process.getgid === "function" ? process.getgid() : 65532},mode=0700`] : [],
+      "--pids-limit",
+      "256",
+      "--memory",
+      `${container.memoryMb ?? 4096}m`,
+      "--cpus",
+      String(container.cpus ?? 2),
+      ...user,
+      "--workdir",
+      root,
+      ...[...mounts].flatMap(([path, readOnly]) => ["--mount", `type=bind,source=${path},target=${path}${readOnly ? ",readonly" : ""}`]),
+      ...container.authVolume ? ["--mount", `type=volume,source=${container.authVolume},target=/home/codeflow`] : [],
+      "--tmpfs",
+      "/tmp:rw,nosuid,nodev,size=268435456",
+      "--env",
+      "HOME=/home/codeflow",
+      "--env",
+      "CODEX_HOME=/home/codeflow/.codex",
+      "--env",
+      "GIT_TERMINAL_PROMPT=0",
+      "--env",
+      "GIT_OPTIONAL_LOCKS=0",
+      "--env",
+      "NO_COLOR=1",
+      "--env",
+      "GIT_CONFIG_GLOBAL=/dev/null",
+      "--env",
+      "GIT_CONFIG_SYSTEM=/dev/null",
+      "--env",
+      "GIT_CONFIG_COUNT=1",
+      "--env",
+      "GIT_CONFIG_KEY_0=core.excludesFile",
+      "--env",
+      "GIT_CONFIG_VALUE_0=/dev/null",
+      ...container.network === false ? ["--network", "none"] : [],
+      "--entrypoint",
+      command,
+      container.image,
+      ...args
+    ]
+  };
+}
+function readOnlyGitMetadata(root) {
+  const marker = join(root, ".git");
+  let info;
+  try {
+    info = lstatSync(marker);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  if (info.isSymbolicLink()) throw new Error("Agent isolation refuses a symlinked .git marker");
+  if (info.isDirectory()) return [marker];
+  if (!info.isFile()) throw new Error("Agent workspace has an invalid .git marker");
+  const gitdir = /^gitdir: (.+)\r?\n?$/.exec(readFileSync(marker, "utf8"));
+  if (!gitdir) throw new Error("Agent workspace has an invalid worktree .git marker");
+  const admin = realpathSync(resolve(root, gitdir[1]));
+  const common = realpathSync(resolve(admin, readFileSync(join(admin, "commondir"), "utf8").trim()));
+  const backlink = realpathSync(resolve(admin, readFileSync(join(admin, "gitdir"), "utf8").trim()));
+  if (backlink !== realpathSync(marker) || dirname(admin) !== join(common, "worktrees") || !lstatSync(join(common, "objects")).isDirectory() || !lstatSync(join(common, "HEAD")).isFile()) throw new Error("Agent worktree metadata does not belong to this workspace");
+  return [marker, common];
+}
+const isAgentContainerName = (name) => typeof name === "string" && /^codeflow-agent-[a-f0-9]{32}$/.test(name);
+function stopAgentContainer(name) {
+  if (!isAgentContainerName(name)) return Promise.resolve();
+  return new Promise((resolve2) => {
+    execFile("docker", ["rm", "--force", name], { env: childEnv(), timeout: 5e3 }, () => resolve2());
+  });
+}
+function stopAgentContainerSync(name) {
+  if (isAgentContainerName(name)) spawnSync("docker", ["rm", "--force", name], { env: childEnv(), timeout: 1500, stdio: "ignore" });
+}
+function agentContainerCapabilities(container) {
+  const configured = validateAgentContainer(container);
+  return {
+    runtime: "docker",
+    image: configured.image,
+    network: configured.network !== false,
+    credentialSource: configured.authVolume ? "named-volume" : "image",
+    liveTeamTools: false,
+    nativeCodexApprovals: true,
+    hostHomeMounted: false
+  };
+}
+export {
+  agentContainerCapabilities,
+  agentContainerLaunch,
+  filteredTaskContainer,
+  isAgentContainerName,
+  readOnlyGitMetadata,
+  stopAgentContainer,
+  stopAgentContainerSync,
+  validateAgentContainer
+};

package/src/agent-team-definitions.js

@@ -0,0 +1,131 @@
+import { constants } from "node:fs";
+import { mkdir, open, readdir, rename, rm } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { join } from "node:path";
+import { closed, digest, text, validateTeamConfiguration, validateTeamSnapshot } from "./project-team-model.js";
+import { ProjectTeamConflict } from "./project-team-store.js";
+const MAX_BYTES = 2 * 1024 * 1024;
+function validate(value) {
+  const r = closed(value, ["version", "id", "revision", "name", "configuration", "createdAt", "updatedAt", "versions", "operations"], "reusable agent team");
+  const snapshot = validateTeamSnapshot({ id: r.id, revision: r.revision, name: r.name, configuration: r.configuration });
+  if (r.version !== 1 || !Number.isSafeInteger(r.createdAt) || r.createdAt < 0 || !Number.isSafeInteger(r.updatedAt) || r.updatedAt < 0 || !Array.isArray(r.versions) || r.versions.length !== r.revision || r.versions.length > 100 || !Array.isArray(r.operations) || r.operations.length !== r.revision) throw new Error("Invalid reusable team history");
+  r.versions.forEach((entry, i) => {
+    const v = validateTeamSnapshot(entry);
+    if (v.id !== r.id || v.revision !== i + 1) throw new Error("Invalid reusable team version sequence");
+  });
+  if (digest(snapshot) !== digest(r.versions.at(-1))) throw new Error("Reusable team differs from its current version");
+  for (const op of r.operations) if (!op || typeof op.id !== "string" || !op.id || op.id.length > 150 || !/^[a-f0-9]{64}$/.test(op.hash)) throw new Error("Invalid reusable team operation");
+  if (new Set(r.operations.map((op) => op.id)).size !== r.operations.length) throw new Error("Duplicate reusable team operation");
+  return r;
+}
+class AgentTeamDefinitions {
+  constructor(directory, changed = () => {
+  }) {
+    this.directory = directory;
+    this.changed = changed;
+  }
+  definitions = /* @__PURE__ */ new Map();
+  queue = Promise.resolve();
+  loaded = false;
+  faults = /* @__PURE__ */ new Map();
+  async load() {
+    this.loaded = false;
+    this.definitions.clear();
+    this.faults.clear();
+    const files = await readdir(this.directory).catch((e) => {
+      if (e.code === "ENOENT") return [];
+      throw e;
+    });
+    for (const name of files.filter((f) => /^at-[a-f0-9]{24}\.json$/.test(f))) {
+      try {
+        const file = await open(join(this.directory, name), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        let value;
+        try {
+          const info = await file.stat();
+          if (!info.isFile() || info.size > MAX_BYTES) throw new Error("Reusable team exceeds its file bound");
+          const buffer = Buffer.alloc(MAX_BYTES + 1), { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+          if (bytesRead > MAX_BYTES) throw new Error("Reusable team grew beyond its bound");
+          value = JSON.parse(buffer.subarray(0, bytesRead).toString());
+        } finally {
+          await file.close();
+        }
+        const definition = validate(value);
+        if (name !== `${definition.id}.json`) throw new Error("Reusable team filename differs from identity");
+        this.definitions.set(definition.id, definition);
+      } catch (error) {
+        this.faults.set(name.slice(0, -5), error.message);
+      }
+    }
+    this.loaded = true;
+  }
+  list() {
+    return [...this.definitions.values()].map(({ id, revision, name, configuration }) => structuredClone({ id, revision, name, configuration }));
+  }
+  snapshot(id, revision) {
+    const definition = this.get(id), snapshot = definition.versions.find((v) => v.revision === revision);
+    if (!snapshot) throw new Error("Choose an existing reusable team version");
+    return structuredClone(snapshot);
+  }
+  get(id) {
+    if (this.faults.has(id)) throw new Error(`Reusable team storage is unavailable: ${this.faults.get(id)}`);
+    const value = this.definitions.get(id);
+    if (!value) throw Object.assign(new Error("Reusable agent team not found"), { status: 404 });
+    return structuredClone(value);
+  }
+  save(input) {
+    const work = this.queue.then(async () => {
+      if (!this.loaded) throw new Error("Load reusable teams before writing");
+      const operationId = text(input.operationId, 150, "operation ID"), name = text(input.name, 80, "team name"), configuration = validateTeamConfiguration(input.configuration);
+      const hash = digest({ name, configuration }), id = input.id ?? `at-${digest(operationId).slice(0, 24)}`;
+      if (this.faults.has(id)) throw new Error("Repair the damaged reusable team before writing");
+      const before = input.id ? this.get(id) : this.definitions.get(id);
+      const prior = before?.operations.find((op) => op.id === operationId);
+      if (prior) {
+        if (prior.hash !== hash) throw new ProjectTeamConflict("Operation ID was reused with different content");
+        return structuredClone(before);
+      }
+      if (before && !input.id) throw new ProjectTeamConflict("Reusable team creation ID collision");
+      if (before && input.revision !== before.revision) throw new ProjectTeamConflict("Reusable team changed. Reload before saving.");
+      if (!before && this.definitions.size >= 100) throw new Error("The reusable team library is full");
+      const revision = (before?.revision ?? 0) + 1, now = Date.now();
+      const snapshot = { id, revision, name, configuration };
+      const next = { ...snapshot, version: 1, createdAt: before?.createdAt ?? now, updatedAt: now, versions: [...before?.versions ?? [], snapshot], operations: [...before?.operations ?? [], { id: operationId, hash }] };
+      validate(next);
+      const data = JSON.stringify(next);
+      if (Buffer.byteLength(data) > MAX_BYTES) throw new Error("Reusable team history is full");
+      await mkdir(this.directory, { recursive: true, mode: 448 });
+      const temp = join(this.directory, `.${id}-${randomBytes(6).toString("hex")}.tmp`);
+      try {
+        const file = await open(temp, "wx", 384);
+        try {
+          await file.writeFile(data);
+          await file.sync();
+        } finally {
+          await file.close();
+        }
+        await rename(temp, join(this.directory, `${id}.json`));
+        if (process.platform !== "win32") {
+          const dir = await open(this.directory, "r");
+          try {
+            await dir.sync();
+          } finally {
+            await dir.close();
+          }
+        }
+        this.definitions.set(id, structuredClone(next));
+        this.changed();
+        return structuredClone(next);
+      } finally {
+        await rm(temp, { force: true }).catch(() => void 0);
+      }
+    });
+    this.queue = work.catch(() => void 0);
+    return work;
+  }
+  async flush() {
+    await this.queue;
+  }
+}
+export {
+  AgentTeamDefinitions
+};

package/src/agent-tool-client.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// Dependency-free stdio MCP transport. Only the parent-created turn capability is used;
+// this process has no file, shell, permission-approval, or identity-selection operations.
+import { createInterface } from "node:readline";
+import { readFileSync, unlinkSync } from "node:fs";
+
+let connection;
+try {
+  if (process.argv[2] === "--connection") {
+    connection = JSON.parse(readFileSync(process.argv[3], "utf8"));
+    // Read once, then gone: every CLI on this machine runs as the same user, so a credential
+    // left on disk could be read by another process's shell for as long as the turn lasts.
+    try { unlinkSync(process.argv[3]); } catch { /* already removed */ }
+  }
+} catch { process.exit(1); }
+const endpoint = connection?.endpoint;
+const token = connection?.token;
+delete process.env.CODEFLOW_TEAM_CAPABILITY;
+delete process.env.CODEFLOW_TOKEN;
+if (!endpoint || !/^http:\/\/127\.0\.0\.1:\d+\/v1\/agent-tools$/.test(endpoint) || !token) process.exit(1);
+
+let initialized = false;
+const send = (value) => process.stdout.write(`${JSON.stringify(value)}\n`);
+async function bridge(body) {
+  const response = await fetch(endpoint, {
+    method: "POST", redirect: "error", signal: AbortSignal.timeout(660_000),
+    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+    body: JSON.stringify(body),
+  });
+  const result = await response.json();
+  if (!response.ok || result.error) throw new Error(result.error ?? "Agent bridge request failed");
+  return result;
+}
+async function request(message) {
+  // JSON can parse successfully without yielding a JSON-RPC object (for example null).
+  // Reject the envelope before dereferencing it so malformed input cannot terminate MCP.
+  const validId = (id) => typeof id === "string" || typeof id === "number" && Number.isFinite(id);
+  if (!message || typeof message !== "object" || Array.isArray(message) || message.jsonrpc !== "2.0" ||
+      typeof message.method !== "string" || (message.id !== undefined && !validId(message.id))) {
+    send({ jsonrpc: "2.0", id: validId(message?.id) ? message.id : null, error: { code: -32600, message: "Invalid request" } }); return;
+  }
+  const id = message.id;
+  if (id === undefined) return;
+  try {
+    let result;
+    if (message.method === "initialize") {
+      initialized = true;
+      const supported = ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"];
+      result = { protocolVersion: supported.includes(message.params?.protocolVersion) ? message.params.protocolVersion : "2025-03-26", capabilities: { tools: {} }, serverInfo: { name: "code-flow-agent", version: "1.0.0" } };
+    } else if (message.method === "ping") result = {};
+    else if (!initialized) throw new Error("Initialize the agent bridge first");
+    else if (message.method === "tools/list") result = await bridge({ method: "tools/list" });
+    else if (message.method === "tools/call") {
+      try {
+        const value = await bridge({ name: message.params?.name, arguments: message.params?.arguments ?? {} });
+        result = value;
+      } catch (error) { result = { content: [{ type: "text", text: error instanceof Error ? error.message : "Agent command failed" }], isError: true }; }
+    } else {
+      send({ jsonrpc: "2.0", id, error: { code: -32601, message: "Method not found" } }); return;
+    }
+    send({ jsonrpc: "2.0", id, result });
+  } catch (error) { send({ jsonrpc: "2.0", id, error: { code: -32603, message: error instanceof Error ? error.message : "Agent bridge failed" } }); }
+}
+
+const input = createInterface({ input: process.stdin, crlfDelay: Infinity });
+let inflight = 0;
+const limit = (id) => send({ jsonrpc: "2.0", id, error: { code: -32600, message: "Request exceeds bridge limits" } });
+/** The id of an envelope too large to parse, so the caller's request still gets its answer instead of hanging. */
+const idOf = (line) => { const match = /"id"\s*:\s*("(?:[^"\\]|\\.)*"|-?\d+)/.exec(line.slice(0, 4_096)); try { return match ? JSON.parse(match[1]) : null; } catch { return null; } };
+for await (const line of input) {
+  if (line.length > 64 * 1024) { limit(idOf(line)); continue; }
+  try {
+    const message = JSON.parse(line);
+    // Answer with the request's own id: an `id: null` error leaves that request waiting until the CLI's tool timeout.
+    if (inflight >= 4) { limit(message && typeof message === "object" && (typeof message.id === "string" || typeof message.id === "number") ? message.id : null); continue; }
+    inflight++;
+    void request(message).finally(() => { inflight--; });
+  } catch { send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } }); }
+}