agent-dev-env 0.1.0

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

@@ -0,0 +1,466 @@
+#!/usr/bin/env node
+
+// packages/guest-agent-windows/src/index.ts
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdirSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } 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-agent-windows/src/schtasks.ts
+var WINDOWS_PIPES = {
+  "ssh-agent": "\\\\.\\pipe\\openssh-ssh-agent",
+  docker: "\\\\.\\pipe\\docker_engine"
+};
+var WINDOWS_TASK_NAMES = {
+  "ssh-agent": "agent-sandbox-ssh-agent",
+  docker: "agent-sandbox-docker",
+  /** the SYSTEM ONCE task that starts both relays right after install. */
+  relays: "agent-sandbox-relays"
+};
+var DOCKER_CONTEXT = "host";
+function schtasksXml(task) {
+  const args = [
+    "bridge",
+    task.role,
+    "--port",
+    String(task.port),
+    "--host-alias",
+    task.hostAlias,
+    "--listen",
+    `pipe:${task.pipe}`,
+    "--forward",
+    `tcp:${task.hostAlias}:${task.port}`
+  ].join(" ");
+  return [
+    '<?xml version="1.0" encoding="UTF-16"?>',
+    '<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">',
+    "  <RegistrationInfo>",
+    `    <Description>${escapeXml(task.description)}</Description>`,
+    "    <Author>agent-dev-env</Author>",
+    "  </RegistrationInfo>",
+    "  <Triggers>",
+    "    <LogonTrigger>",
+    "      <Enabled>true</Enabled>",
+    "    </LogonTrigger>",
+    "  </Triggers>",
+    "  <Principals>",
+    '    <Principal id="Author">',
+    "      <LogonType>InteractiveToken</LogonType>",
+    "      <RunLevel>LeastPrivilege</RunLevel>",
+    "    </Principal>",
+    "  </Principals>",
+    "  <Settings>",
+    "    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>",
+    "    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>",
+    "    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>",
+    "    <StartWhenAvailable>true</StartWhenAvailable>",
+    "    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>",
+    "    <Enabled>true</Enabled>",
+    "  </Settings>",
+    '  <Actions Context="Author">',
+    "    <Exec>",
+    `      <Command>${escapeXml(task.nodePath)}</Command>`,
+    `      <Arguments>${escapeXml(`"${task.agentPath}" ${args}`)}</Arguments>`,
+    "    </Exec>",
+    "  </Actions>",
+    "</Task>",
+    ""
+  ].join("\n");
+}
+function userEnvCommand(name, value) {
+  return `[Environment]::SetEnvironmentVariable('${name}','${value}','User')`;
+}
+function dockerContextCommands() {
+  const endpoint = `npipe:////./pipe/docker_engine`;
+  return [
+    `docker context create ${DOCKER_CONTEXT} --docker "host=${endpoint}"`,
+    `docker context update ${DOCKER_CONTEXT} --docker "host=${endpoint}"`,
+    `docker context use ${DOCKER_CONTEXT}`
+  ];
+}
+function relayStartCommand(nodePath, agentPath, tasks) {
+  const lines = ["@echo off"];
+  for (const task of tasks) {
+    lines.push(
+      `start "" /b "${nodePath}" "${agentPath}" bridge ${task.role} --port ${task.port} --host-alias ${task.hostAlias} --listen pipe:${task.pipe} --forward tcp:${task.hostAlias}:${task.port}`
+    );
+  }
+  return lines.join("\r\n") + "\r\n";
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// packages/guest-agent-windows/src/index.ts
+var AGENT_PATH = fileURLToPath(import.meta.url);
+var NODE_PATH = process.execPath;
+var DEFAULTS = {
+  agentPort: 4300,
+  dockerPort: 4301
+};
+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 "uninstall":
+        return uninstall();
+      default:
+        process.stderr.write(usage());
+        return 1;
+    }
+  } catch (err) {
+    process.stderr.write(`guest-agent-windows: ${err.message}
+`);
+    return 1;
+  }
+}
+function usage() {
+  return [
+    "usage: guest-agent-windows <install|bridge|status|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]",
+    ""
+  ].join("\n");
+}
+function argValue(argv, flag) {
+  const index = argv.indexOf(flag);
+  return index === -1 ? void 0 : argv[index + 1];
+}
+function taskFor(role, port, hostAlias) {
+  return {
+    taskName: WINDOWS_TASK_NAMES[role],
+    description: role === "ssh-agent" ? "Agent Sandbox SSH agent bridge" : "Agent Sandbox Docker bridge",
+    nodePath: NODE_PATH,
+    agentPath: AGENT_PATH,
+    role,
+    pipe: WINDOWS_PIPES[role],
+    port,
+    hostAlias
+  };
+}
+function install(argv) {
+  const hostAlias = argValue(argv, "--host-alias");
+  if (!hostAlias) {
+    throw new Error("--host-alias is required (10.0.2.2 for QEMU, the NAT router otherwise)");
+  }
+  const agentPort = Number(argValue(argv, "--agent-port") ?? DEFAULTS.agentPort);
+  const dockerPort = Number(argValue(argv, "--docker-port") ?? DEFAULTS.dockerPort);
+  const tasks = [];
+  for (const [role, port] of [
+    ["ssh-agent", agentPort],
+    ["docker", dockerPort]
+  ]) {
+    const task = taskFor(role, port, hostAlias);
+    tasks.push(task);
+    const xmlPath = join(tmpdir(), `${task.taskName}.xml`);
+    writeFileSync2(xmlPath, schtasksXml(task), "utf16le");
+    try {
+      execFileSync("schtasks", ["/Create", "/TN", task.taskName, "/XML", xmlPath, "/F"], {
+        stdio: "ignore"
+      });
+      process.stdout.write(`installed:${role} (task ${task.taskName}, port ${port})
+`);
+    } finally {
+      rmSync2(xmlPath, { force: true });
+    }
+  }
+  startRelays(tasks);
+  setUserEnv("SSH_AUTH_SOCK", WINDOWS_PIPES["ssh-agent"]);
+  setupDockerContext();
+  return 0;
+}
+function startRelays(tasks) {
+  const dir = dirname(AGENT_PATH);
+  const cmdPath = join(dir, "start-relays.cmd");
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync2(cmdPath, relayStartCommand(NODE_PATH, AGENT_PATH, tasks));
+    execFileSync(
+      "schtasks",
+      [
+        "/Create",
+        "/TN",
+        WINDOWS_TASK_NAMES.relays,
+        "/SC",
+        "ONCE",
+        "/ST",
+        "00:00",
+        "/RU",
+        "SYSTEM",
+        "/RL",
+        "HIGHEST",
+        "/F",
+        "/TR",
+        cmdPath
+      ],
+      { stdio: "ignore" }
+    );
+    execFileSync("schtasks", ["/Run", "/TN", WINDOWS_TASK_NAMES.relays], { stdio: "ignore" });
+    process.stdout.write("installed:relays (started via a system task)\n");
+  } catch (err) {
+    process.stderr.write(
+      `warning: could not start the relays right away (${err.message}) \u2014 they start at the next logon
+`
+    );
+  }
+}
+function setUserEnv(name, value) {
+  const cmd = userEnvCommand(name, value);
+  execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", cmd], {
+    stdio: "ignore"
+  });
+  process.stdout.write(`installed:env ${name}
+`);
+}
+function setupDockerContext() {
+  const docker = spawnSync("where.exe", ["docker"], { encoding: "utf8" });
+  if (docker.status !== 0) {
+    process.stderr.write("warning: docker CLI not found \u2014 skipping the docker context\n");
+    return;
+  }
+  for (const command of dockerContextCommands()) {
+    spawnSync("cmd.exe", ["/c", command], { stdio: "ignore" });
+  }
+  process.stdout.write("installed:docker context host\n");
+}
+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");
+  if (!hostAlias) {
+    throw new Error("--host-alias is required");
+  }
+  const listen2 = argValue(argv, "--listen") ?? `pipe:${WINDOWS_PIPES[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(`pipe:${WINDOWS_PIPES["ssh-agent"]}`));
+  const dockerUp = await canConnect(parseEndpoint(`pipe:${WINDOWS_PIPES.docker}`));
+  process.stdout.write(`bridge-status:ssh-agent=${agentUp ? "up" : "down"}
+`);
+  process.stdout.write(`bridge-status:docker=${dockerUp ? "up" : "down"}
+`);
+  return 0;
+}
+function uninstall() {
+  for (const role of ["ssh-agent", "docker"]) {
+    const taskName = WINDOWS_TASK_NAMES[role];
+    try {
+      execFileSync("schtasks", ["/Delete", "/TN", taskName, "/F"], { stdio: "ignore" });
+    } catch {
+    }
+  }
+  try {
+    execFileSync("schtasks", ["/Delete", "/TN", WINDOWS_TASK_NAMES.relays, "/F"], {
+      stdio: "ignore"
+    });
+  } catch {
+  }
+  rmSync2(join(dirname(AGENT_PATH), "start-relays.cmd"), { force: true });
+  const cmd = userEnvCommand("SSH_AUTH_SOCK", "");
+  try {
+    execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", cmd], {
+      stdio: "ignore"
+    });
+  } catch {
+  }
+  process.stdout.write("uninstalled:ssh-agent,docker\n");
+  return 0;
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  void main(process.argv.slice(2)).then((code) => {
+    process.exit(code);
+  });
+}