agent-dev-env 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrey Meshkov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/assets/bridge/bridge.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+// packages/bridge-core/src/bin.ts
+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
+function parseBridgeArgs(argv) {
+  const values = /* @__PURE__ */ new Map();
+  for (let i = 0; i < argv.length; i += 2) {
+    const flag = argv[i];
+    if (flag === "--listen" || flag === "--forward" || flag === "--pidfile") {
+      values.set(flag, argv[i + 1] ?? "");
+    } else {
+      throw new Error(`unknown argument: ${flag}`);
+    }
+  }
+  const listenSpec = values.get("--listen");
+  const forwardSpec = values.get("--forward");
+  if (!listenSpec || !forwardSpec) {
+    throw new Error("usage: bridge --listen <endpoint> --forward <endpoint> [--pidfile PATH]");
+  }
+  const pidfile = values.get("--pidfile");
+  return {
+    listen: parseEndpoint(listenSpec),
+    forward: parseEndpoint(forwardSpec),
+    pidfile: pidfile || void 0
+  };
+}
+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;
+}
+async function main(argv) {
+  const args = parseBridgeArgs(argv);
+  return runBridge({
+    listen: args.listen,
+    forward: args.forward,
+    pidfile: args.pidfile,
+    log: (message) => process.stderr.write(`${message}
+`)
+  });
+}
+
+// packages/bridge-core/src/bin.ts
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  void main(process.argv.slice(2)).then((code) => {
+    process.exit(code);
+  });
+}