agent-dev-env 0.1.0

package/dist/assets/guest/guest-agent-ubuntu.js

@@ -0,0 +1,481 @@
+#!/usr/bin/env node
+
+// packages/guest-agent-ubuntu/src/index.ts
+import { execFileSync } from "node:child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/bridge-core/src/index.ts
+import { rmSync, writeFileSync } from "node:fs";
+
+// packages/bridge-core/src/endpoints.ts
+var PIPE_PREFIX = "\\\\.\\pipe\\";
+function parseEndpoint(spec) {
+  const sep = spec.indexOf(":");
+  if (sep <= 0) {
+    throw new Error(`invalid endpoint '${spec}' (expected unix:|pipe:|tcp:)`);
+  }
+  const scheme = spec.slice(0, sep);
+  const rest = spec.slice(sep + 1);
+  switch (scheme) {
+    case "unix": {
+      if (!rest) {
+        throw new Error(`invalid unix endpoint '${spec}': missing path`);
+      }
+      return { kind: "unix", path: rest };
+    }
+    case "pipe": {
+      if (!rest) {
+        throw new Error(`invalid pipe endpoint '${spec}': missing name`);
+      }
+      const name = rest.startsWith(PIPE_PREFIX) ? rest : `${PIPE_PREFIX}${rest}`;
+      return { kind: "pipe", name };
+    }
+    case "tcp": {
+      const m = /^([^:]+):(\d+)$/.exec(rest);
+      const port = m ? Number(m[2]) : NaN;
+      if (!m || !Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`invalid tcp endpoint '${spec}' (expected tcp:host:port, port 1-65535)`);
+      }
+      return { kind: "tcp", host: m[1], port };
+    }
+    default:
+      throw new Error(
+        `unknown endpoint scheme '${scheme}' in '${spec}' (expected unix:|pipe:|tcp:)`
+      );
+  }
+}
+function formatEndpoint(endpoint) {
+  switch (endpoint.kind) {
+    case "unix":
+      return `unix:${endpoint.path}`;
+    case "pipe":
+      return `pipe:${endpoint.name}`;
+    case "tcp":
+      return `tcp:${endpoint.host}:${endpoint.port}`;
+  }
+}
+
+// packages/bridge-core/src/forwarder.ts
+import net from "node:net";
+import { existsSync, unlinkSync } from "node:fs";
+function startForwarder(options) {
+  const sockets = /* @__PURE__ */ new Set();
+  const server = net.createServer((client) => {
+    sockets.add(client);
+    client.on("close", () => sockets.delete(client));
+    forwardConnection(client, options.forward, sockets);
+  });
+  return bind(server, options.listen).then(() => {
+    options.log?.(
+      `listening on ${formatEndpoint(options.listen)} \u2192 ${formatEndpoint(options.forward)}`
+    );
+    return {
+      close: () => closeForwarder(server, sockets, options.listen, options.log)
+    };
+  });
+}
+function forwardConnection(client, target, sockets) {
+  const upstream = connectTo(target);
+  sockets.add(upstream);
+  upstream.on("close", () => sockets.delete(upstream));
+  upstream.once("connect", () => {
+    client.pipe(upstream);
+    upstream.pipe(client);
+  });
+  const tearDown = () => {
+    client.destroy();
+    upstream.destroy();
+  };
+  upstream.once("error", tearDown);
+  client.once("error", () => {
+    upstream.destroy();
+  });
+}
+async function bind(server, endpoint) {
+  switch (endpoint.kind) {
+    case "unix":
+      if (existsSync(endpoint.path)) {
+        unlinkSync(endpoint.path);
+      }
+      await listen(server, endpoint.path);
+      break;
+    case "pipe":
+      await listen(server, endpoint.name);
+      break;
+    case "tcp":
+      await listen(server, { port: endpoint.port, host: endpoint.host });
+      break;
+  }
+}
+function listen(server, spec) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(spec, () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+}
+function connectTo(endpoint) {
+  switch (endpoint.kind) {
+    case "unix":
+      return net.connect({ path: endpoint.path });
+    case "pipe":
+      return net.connect({ path: endpoint.name });
+    case "tcp":
+      return net.connect({ port: endpoint.port, host: endpoint.host });
+  }
+}
+function closeForwarder(server, sockets, listen2, log) {
+  return new Promise((resolve) => {
+    for (const socket of sockets) {
+      socket.destroy();
+    }
+    server.close(() => {
+      if (listen2.kind === "unix" && existsSync(listen2.path)) {
+        unlinkSync(listen2.path);
+      }
+      log?.("closed");
+      resolve();
+    });
+  });
+}
+
+// packages/bridge-core/src/index.ts
+async function runBridge(options) {
+  const running = await startForwarder(options);
+  if (options.pidfile) {
+    writeFileSync(options.pidfile, `${process.pid}
+`);
+  }
+  await new Promise((resolve) => {
+    const stop = () => {
+      void running.close().then(() => {
+        if (options.pidfile) {
+          rmSync(options.pidfile, { force: true });
+        }
+        resolve();
+      });
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+  });
+  return 0;
+}
+
+// packages/bridge-core/src/probe.ts
+import net2 from "node:net";
+function canConnect(endpoint, timeoutMs = 500) {
+  return new Promise((resolve) => {
+    const socket = endpoint.kind === "tcp" ? net2.connect({ port: endpoint.port, host: endpoint.host }) : net2.connect({ path: endpoint.kind === "unix" ? endpoint.path : endpoint.name });
+    const done = (ok) => {
+      socket.destroy();
+      resolve(ok);
+    };
+    socket.once("connect", () => done(true));
+    socket.once("error", () => done(false));
+    setTimeout(() => done(false), timeoutMs);
+  });
+}
+
+// packages/guest-rules/src/rules.ts
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join } from "node:path";
+function rulesPaths(home) {
+  return {
+    marker: join(home, ".config", "agent-dev-env", "agent-rules.sha256"),
+    targets: [
+      join(home, ".config", "opencode", "AGENTS.md"),
+      join(home, ".copilot", "copilot-instructions.md")
+    ]
+  };
+}
+function sha256(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function readMaybe(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function rulesAction(home, content) {
+  const { marker, targets } = rulesPaths(home);
+  const newSha = sha256(content);
+  const prevSha = readMaybe(marker)?.trim();
+  let conflict = false;
+  let install2 = false;
+  let update = false;
+  for (const target of targets) {
+    const current = readMaybe(target);
+    if (current === void 0) {
+      install2 = true;
+    } else if (sha256(current) === newSha) {
+    } else if (prevSha !== void 0 && sha256(current) === prevSha) {
+      update = true;
+    } else {
+      conflict = true;
+    }
+  }
+  if (conflict) return "conflict";
+  if (install2) return "install";
+  if (update) return "update";
+  return "uptodate";
+}
+function applyRules(home, content) {
+  const { marker, targets } = rulesPaths(home);
+  for (const target of targets) {
+    mkdirSync(join(target, ".."), { recursive: true });
+    writeFileSync2(target, content);
+  }
+  mkdirSync(join(marker, ".."), { recursive: true });
+  writeFileSync2(marker, `${sha256(content)}
+`);
+}
+
+// packages/guest-agent-ubuntu/src/systemd.ts
+var UBUNTU_SOCKETS = {
+  "ssh-agent": "/tmp/ssh-agent.sock",
+  docker: "/tmp/docker.sock"
+};
+var PROFILE_D_PATH = "/etc/profile.d/agent-sandbox.sh";
+function systemdUnit(bridge) {
+  const args = [
+    "bridge",
+    bridge.role,
+    "--port",
+    String(bridge.port),
+    "--host-alias",
+    bridge.hostAlias,
+    "--listen",
+    `unix:${bridge.socket}`,
+    "--forward",
+    `tcp:${bridge.hostAlias}:${bridge.port}`
+  ];
+  return [
+    "[Unit]",
+    `Description=${bridge.description}`,
+    "After=network.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    `ExecStart=${bridge.nodePath} ${bridge.agentPath} ${args.join(" ")}`,
+    "Restart=on-failure",
+    "",
+    "[Install]",
+    "WantedBy=default.target",
+    ""
+  ].join("\n");
+}
+function profileDScript(gw) {
+  return [
+    "# Agent sandbox bridge env (see docs/ubuntu-vmware.md)",
+    "export SSH_AUTH_SOCK=/tmp/ssh-agent.sock",
+    "export DOCKER_HOST=unix:///tmp/docker.sock",
+    `export TESTCONTAINERS_HOST_OVERRIDE=${gw}`,
+    "",
+    ""
+  ].join("\n");
+}
+
+// packages/guest-agent-ubuntu/src/index.ts
+var AGENT_PATH = fileURLToPath(import.meta.url);
+var NODE_PATH = process.execPath;
+var HOME = homedir();
+var UNIT_DIR = join2(HOME, ".config", "systemd", "user");
+var DEFAULTS = {
+  agentPort: 4400,
+  dockerPort: 4401
+};
+async function main(argv) {
+  const [cmd, ...rest] = argv;
+  try {
+    switch (cmd) {
+      case "install":
+        return install(rest);
+      case "bridge":
+        return bridgeCommand(rest);
+      case "status":
+        return status();
+      case "rules":
+        return rulesCommand(rest);
+      case "uninstall":
+        return uninstall();
+      default:
+        process.stderr.write(usage());
+        return 1;
+    }
+  } catch (err) {
+    process.stderr.write(`guest-agent-ubuntu: ${err.message}
+`);
+    return 1;
+  }
+}
+function usage() {
+  return [
+    "usage: guest-agent-ubuntu <install|bridge|status|rules|uninstall> [options]",
+    "  install [--agent-port N] [--docker-port N] [--host-alias A]",
+    "  bridge <ssh-agent|docker> [--listen EP] [--forward EP] [--port N] [--host-alias A]",
+    "  rules [--force]  (content on stdin)",
+    ""
+  ].join("\n");
+}
+function argValue(argv, flag) {
+  const index = argv.indexOf(flag);
+  return index === -1 ? void 0 : argv[index + 1];
+}
+function bridgeFor(role, port, hostAlias) {
+  return {
+    unitName: `agent-sandbox-${role}.service`,
+    description: role === "ssh-agent" ? "Agent Sandbox SSH agent bridge" : "Agent Sandbox Docker bridge",
+    nodePath: NODE_PATH,
+    agentPath: AGENT_PATH,
+    role,
+    port,
+    hostAlias,
+    socket: UBUNTU_SOCKETS[role]
+  };
+}
+function install(argv) {
+  const hostAlias = argValue(argv, "--host-alias") ?? (() => {
+    throw new Error("--host-alias is required (the NAT router address)");
+  })();
+  const agentPort = Number(argValue(argv, "--agent-port") ?? DEFAULTS.agentPort);
+  const dockerPort = Number(argValue(argv, "--docker-port") ?? DEFAULTS.dockerPort);
+  mkdirSync2(UNIT_DIR, { recursive: true });
+  for (const [role, port] of [
+    ["ssh-agent", agentPort],
+    ["docker", dockerPort]
+  ]) {
+    const bridge = bridgeFor(role, port, hostAlias);
+    writeFileSync3(join2(UNIT_DIR, bridge.unitName), systemdUnit(bridge));
+    process.stdout.write(`installed:${role} (${bridge.unitName}, port ${port})
+`);
+  }
+  execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+  for (const [role] of [["ssh-agent"], ["docker"]]) {
+    execFileSync("systemctl", ["--user", "enable", "--now", `agent-sandbox-${role}.service`], {
+      stdio: "ignore"
+    });
+  }
+  installProfileExports(hostAlias);
+  return 0;
+}
+function installProfileExports(gw) {
+  if (typeof process.getuid === "function" && process.getuid() === 0) {
+    writeFileSync3(PROFILE_D_PATH, profileDScript(gw));
+    process.stdout.write(`installed:profile.d (${PROFILE_D_PATH})
+`);
+    return;
+  }
+  const profile = join2(HOME, ".profile");
+  const content = readMaybe2(profile);
+  if (!content.includes(profileMarker())) {
+    writeFileSync3(profile, `${content}${profileDScript(gw)}`);
+  }
+  process.stdout.write(
+    `installed:profile.d (user ~/.profile; run install via sudo for ${PROFILE_D_PATH})
+`
+  );
+}
+function profileMarker() {
+  return "# Agent sandbox bridge env";
+}
+function bridgeCommand(argv) {
+  const role = argv[0];
+  if (role !== "ssh-agent" && role !== "docker") {
+    throw new Error(`unknown bridge role '${role}' (ssh-agent|docker)`);
+  }
+  const port = Number(
+    argValue(argv, "--port") ?? DEFAULTS[role === "ssh-agent" ? "agentPort" : "dockerPort"]
+  );
+  const hostAlias = argValue(argv, "--host-alias") ?? (() => {
+    throw new Error("--host-alias is required (the NAT router address)");
+  })();
+  const listen2 = argValue(argv, "--listen") ?? `unix:${UBUNTU_SOCKETS[role]}`;
+  const forward = argValue(argv, "--forward") ?? `tcp:${hostAlias}:${port}`;
+  return runBridge({
+    listen: parseEndpoint(listen2),
+    forward: parseEndpoint(forward),
+    log: (message) => process.stderr.write(`${message}
+`)
+  });
+}
+async function status() {
+  const agentUp = await canConnect(parseEndpoint(`unix:${UBUNTU_SOCKETS["ssh-agent"]}`));
+  const dockerUp = await canConnect(parseEndpoint(`unix:${UBUNTU_SOCKETS.docker}`));
+  process.stdout.write(`bridge-status:ssh-agent=${agentUp ? "up" : "down"}
+`);
+  process.stdout.write(`bridge-status:docker=${dockerUp ? "up" : "down"}
+`);
+  return 0;
+}
+function rulesCommand(argv) {
+  const content = readFileSync2(0, "utf8");
+  if (argv.includes("--force")) {
+    applyRules(HOME, content);
+    process.stdout.write("rules:overwritten\n");
+  } else {
+    process.stdout.write(`rules:probe=${rulesAction(HOME, content)}
+`);
+  }
+  return 0;
+}
+function uninstall() {
+  for (const role of ["ssh-agent", "docker"]) {
+    const unit = `agent-sandbox-${role}.service`;
+    try {
+      execFileSync("systemctl", ["--user", "disable", "--now", unit], { stdio: "ignore" });
+    } catch {
+    }
+    rmSync2(join2(UNIT_DIR, unit), { force: true });
+  }
+  if (typeof process.getuid === "function" && process.getuid() === 0) {
+    rmSync2(PROFILE_D_PATH, { force: true });
+  }
+  const profile = join2(HOME, ".profile");
+  if (existsSync2(profile)) {
+    const cleaned = removeProfileBlock(readMaybe2(profile));
+    if (cleaned !== readMaybe2(profile)) {
+      writeFileSync3(profile, cleaned);
+    }
+  }
+  process.stdout.write("uninstalled:ssh-agent,docker\n");
+  return 0;
+}
+function removeProfileBlock(content) {
+  const lines = content.split("\n");
+  const markerIndex = lines.findIndex((line) => line.startsWith(profileMarker()));
+  if (markerIndex === -1) {
+    return content;
+  }
+  const blockStart = markerIndex > 0 && lines[markerIndex - 1] === "" ? markerIndex - 1 : markerIndex;
+  let blockEnd = markerIndex + 1;
+  while (blockEnd < lines.length && lines[blockEnd] !== "") {
+    blockEnd += 1;
+  }
+  if (blockEnd < lines.length) {
+    blockEnd += 1;
+  }
+  return [...lines.slice(0, blockStart), ...lines.slice(blockEnd)].join("\n").replace(/\n{3,}/g, "\n\n");
+}
+function readMaybe2(path) {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  void main(process.argv.slice(2)).then((code) => {
+    process.exit(code);
+  });
+}
+export {
+  removeProfileBlock
+};