devcon-cli 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# devcon-cli
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.8. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/agent-bun.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+// @bun
+import*as O from"fs";import*as Y from"net";function _(B){let w=[],G=new Set,J=B.split(`
+`);for(let z=1;z<J.length;z++){let j=J[z].trim();if(!j)continue;let F=j.split(/\s+/),N=F[1],K=F[3];if(!N||!K)continue;if(K!=="0A")continue;let U=N.split(":")[1];if(!U)continue;let Q=parseInt(U,16);if(Q<=0||G.has(Q))continue;let R=F[9];if(!R)continue;let V=parseInt(R,10);if(isNaN(V))continue;G.add(Q),w.push({port:Q,inode:V})}return w.sort((z,j)=>z.port-j.port)}function $(){let B=new Map,w;try{w=O.readdirSync("/proc").filter((G)=>/^\d+$/.test(G))}catch{return B}for(let G of w){let J=parseInt(G,10),z=`/proc/${J}/fd`,j;try{j=O.readdirSync(z)}catch{continue}for(let F of j)try{let K=O.readlinkSync(`${z}/${F}`).match(/^socket:\[(\d+)\]$/);if(K)B.set(parseInt(K[1],10),J)}catch{continue}}return B}function C(){let B=new Map,w;try{w=O.readdirSync("/proc").filter((G)=>/^\d+$/.test(G))}catch{return B}for(let G of w){let J=parseInt(G,10);try{let z=O.readFileSync(`/proc/${J}/stat`,"utf-8"),j=z.lastIndexOf(")");if(j===-1)continue;let N=z.slice(j+2).split(" "),K=parseInt(N[1],10);if(!isNaN(K))B.set(J,K)}catch{continue}}return B}function I(B){let w=new Map;for(let[z,j]of B){let F=w.get(j);if(!F)F=[],w.set(j,F);F.push(z)}let G=new Set,J=[];for(let[z,j]of B)if(j===0&&z!==1)G.add(z),J.push(z);while(J.length>0){let z=J.shift(),j=w.get(z);if(j){for(let F of j)if(!G.has(F))G.add(F),J.push(F)}}return G}function L(){function B(j){process.stdout.write(JSON.stringify(j)+`
+`)}B({type:"ready",pid:process.pid});let w="";function G(){let j="";try{j+=O.readFileSync("/proc/net/tcp","utf-8")}catch{}try{j+=O.readFileSync("/proc/net/tcp6","utf-8")}catch{}let F=_(j);if(F.length===0){if(w!=="")w="",B({type:"ports",ports:[]});return}let N=$(),K=C(),U=I(K),Q=[];for(let{port:V,inode:Z}of F){let W=N.get(Z);if(W!==void 0&&U.has(W))Q.push(V)}let R=Q.join(",");if(R!==w)w=R,B({type:"ports",ports:Q})}G();let J=setInterval(G,1000),z="";process.stdin.setEncoding("utf-8"),process.stdin.on("data",(j)=>{z+=j;let F=z.split(`
+`);z=F.pop();for(let N of F){if(!N.trim())continue;try{let K=JSON.parse(N);if(K.type==="stop")clearInterval(J),process.exit(0);if(K.type==="ping")B({type:"ready",pid:process.pid})}catch{}}}),process.stdin.on("end",()=>{clearInterval(J),process.exit(0)})}function v(B){let w=Y.createConnection({host:"127.0.0.1",port:B},()=>{process.stdin.pipe(w),w.pipe(process.stdout)});w.on("error",(G)=>{process.stderr.write(`bridge error: ${G.message}
+`),process.exit(1)}),w.on("close",()=>{process.exit(0)}),process.stdin.on("end",()=>{w.end()})}var X=process.argv[2];if(X==="monitor")L();else if(X==="bridge"){let B=parseInt(process.argv[3],10);if(isNaN(B))process.stderr.write(`Usage: agent bridge <port>
+`),process.exit(1);v(B)}else process.stderr.write(`Usage: agent <monitor|bridge> [port]
+`),process.exit(1);

package/dist/agent-node.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import*as O from"node:fs";import*as Y from"node:net";function _(B){let w=[],G=new Set,J=B.split(`
+`);for(let z=1;z<J.length;z++){let j=J[z].trim();if(!j)continue;let F=j.split(/\s+/),N=F[1],K=F[3];if(!N||!K)continue;if(K!=="0A")continue;let U=N.split(":")[1];if(!U)continue;let Q=parseInt(U,16);if(Q<=0||G.has(Q))continue;let R=F[9];if(!R)continue;let V=parseInt(R,10);if(isNaN(V))continue;G.add(Q),w.push({port:Q,inode:V})}return w.sort((z,j)=>z.port-j.port)}function $(){let B=new Map,w;try{w=O.readdirSync("/proc").filter((G)=>/^\d+$/.test(G))}catch{return B}for(let G of w){let J=parseInt(G,10),z=`/proc/${J}/fd`,j;try{j=O.readdirSync(z)}catch{continue}for(let F of j)try{let K=O.readlinkSync(`${z}/${F}`).match(/^socket:\[(\d+)\]$/);if(K)B.set(parseInt(K[1],10),J)}catch{continue}}return B}function C(){let B=new Map,w;try{w=O.readdirSync("/proc").filter((G)=>/^\d+$/.test(G))}catch{return B}for(let G of w){let J=parseInt(G,10);try{let z=O.readFileSync(`/proc/${J}/stat`,"utf-8"),j=z.lastIndexOf(")");if(j===-1)continue;let N=z.slice(j+2).split(" "),K=parseInt(N[1],10);if(!isNaN(K))B.set(J,K)}catch{continue}}return B}function I(B){let w=new Map;for(let[z,j]of B){let F=w.get(j);if(!F)F=[],w.set(j,F);F.push(z)}let G=new Set,J=[];for(let[z,j]of B)if(j===0&&z!==1)G.add(z),J.push(z);while(J.length>0){let z=J.shift(),j=w.get(z);if(j){for(let F of j)if(!G.has(F))G.add(F),J.push(F)}}return G}function L(){function B(j){process.stdout.write(JSON.stringify(j)+`
+`)}B({type:"ready",pid:process.pid});let w="";function G(){let j="";try{j+=O.readFileSync("/proc/net/tcp","utf-8")}catch{}try{j+=O.readFileSync("/proc/net/tcp6","utf-8")}catch{}let F=_(j);if(F.length===0){if(w!=="")w="",B({type:"ports",ports:[]});return}let N=$(),K=C(),U=I(K),Q=[];for(let{port:V,inode:Z}of F){let W=N.get(Z);if(W!==void 0&&U.has(W))Q.push(V)}let R=Q.join(",");if(R!==w)w=R,B({type:"ports",ports:Q})}G();let J=setInterval(G,1000),z="";process.stdin.setEncoding("utf-8"),process.stdin.on("data",(j)=>{z+=j;let F=z.split(`
+`);z=F.pop();for(let N of F){if(!N.trim())continue;try{let K=JSON.parse(N);if(K.type==="stop")clearInterval(J),process.exit(0);if(K.type==="ping")B({type:"ready",pid:process.pid})}catch{}}}),process.stdin.on("end",()=>{clearInterval(J),process.exit(0)})}function v(B){let w=Y.createConnection({host:"127.0.0.1",port:B},()=>{process.stdin.pipe(w),w.pipe(process.stdout)});w.on("error",(G)=>{process.stderr.write(`bridge error: ${G.message}
+`),process.exit(1)}),w.on("close",()=>{process.exit(0)}),process.stdin.on("end",()=>{w.end()})}var X=process.argv[2];if(X==="monitor")L();else if(X==="bridge"){let B=parseInt(process.argv[3],10);if(isNaN(B))process.stderr.write(`Usage: agent bridge <port>
+`),process.exit(1);v(B)}else process.stderr.write(`Usage: agent <monitor|bridge> [port]
+`),process.exit(1);

package/dist/index.js

@@ -0,0 +1,790 @@
+#!/usr/bin/env bun
+// @bun
+var __require = import.meta.require;
+
+// src/cli/parser.ts
+import { resolve } from "path";
+var HELP = `devcon - devcontainer CLI with port forwarding
+
+Usage: devcon-cli [options] <command> [args...]
+
+Options:
+  --workspace-folder <path>  Path to workspace (default: current directory)
+  --verbose, -v              Enable verbose logging
+  --help, -h                 Show this help
+
+Commands:
+  up                Start container and port forwarding
+  down              Stop container and port forwarding
+  exec -- <cmd>     Execute command in container
+  shell             Open interactive shell in container
+  forward [host:]container  Forward a port manually
+  ports             List forwarded ports
+  <other>           Passed through to devcontainer CLI`;
+function parseArgs(argv) {
+  let workspaceFolder = process.cwd();
+  let verbose = false;
+  let command = "";
+  const args = [];
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      console.log(HELP);
+      process.exit(0);
+    }
+    if (arg === "--verbose" || arg === "-v") {
+      verbose = true;
+      i++;
+      continue;
+    }
+    if (arg === "--workspace-folder") {
+      workspaceFolder = resolve(argv[++i] ?? workspaceFolder);
+      i++;
+      continue;
+    }
+    if (!command) {
+      command = arg;
+    } else {
+      args.push(arg);
+    }
+    i++;
+  }
+  return { workspaceFolder, verbose, command, args };
+}
+
+// src/cli/commands.ts
+var commands = new Map;
+function registerCommand(name, handler) {
+  commands.set(name, handler);
+}
+function getCommand(name) {
+  return commands.get(name);
+}
+
+// src/util/log.ts
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var GREEN = "\x1B[32m";
+var CYAN = "\x1B[36m";
+var BOLD = "\x1B[1m";
+var verbose = false;
+function setVerbose(v) {
+  verbose = v;
+}
+function debug(...args) {
+  if (verbose) {
+    console.error(`${DIM}[debug]${RESET}`, ...args);
+  }
+}
+function info(...args) {
+  console.error(`${CYAN}[devcon]${RESET}`, ...args);
+}
+function success(...args) {
+  console.error(`${GREEN}[devcon]${RESET}`, ...args);
+}
+function warn(...args) {
+  console.error(`${YELLOW}[warn]${RESET}`, ...args);
+}
+function error(...args) {
+  console.error(`${RED}${BOLD}[error]${RESET}`, ...args);
+}
+function portLog(hostPort, containerPort, action) {
+  info(`${GREEN}${hostPort}${RESET} -> ${CYAN}${containerPort}${RESET} ${DIM}(${action})${RESET}`);
+}
+
+// src/core/devcontainer.ts
+async function devcontainerUp(workspaceFolder) {
+  const args = [
+    "up",
+    "--workspace-folder",
+    workspaceFolder
+  ];
+  debug("devcontainer", ...args);
+  const proc = Bun.spawn(["devcontainer", ...args], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+  if (stderr.trim()) {
+    for (const line of stderr.trim().split(`
+`)) {
+      debug("[devcontainer]", line);
+    }
+  }
+  if (exitCode !== 0) {
+    throw new Error(`devcontainer up failed (exit ${exitCode}):
+${stderr}`);
+  }
+  const lines = stdout.trim().split(`
+`);
+  const jsonLine = lines[lines.length - 1];
+  try {
+    const result = JSON.parse(jsonLine);
+    if (result.outcome === "error") {
+      throw new Error(`devcontainer up error: ${result.message ?? result.description ?? "unknown"}`);
+    }
+    return {
+      outcome: result.outcome,
+      containerId: result.containerId,
+      remoteUser: result.remoteUser,
+      remoteWorkspaceFolder: result.remoteWorkspaceFolder
+    };
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      error("Failed to parse devcontainer output:", jsonLine);
+      throw new Error("devcontainer up did not return valid JSON");
+    }
+    throw e;
+  }
+}
+async function devcontainerExec(workspaceFolder, cmd) {
+  const args = [
+    "exec",
+    "--workspace-folder",
+    workspaceFolder,
+    ...cmd
+  ];
+  debug("devcontainer", ...args);
+  const proc = Bun.spawn(["devcontainer", ...args], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  return await proc.exited;
+}
+async function devcontainerPassthrough(args) {
+  debug("devcontainer", ...args);
+  const proc = Bun.spawn(["devcontainer", ...args], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  return await proc.exited;
+}
+
+// src/core/docker.ts
+function dockerExec(containerId, cmd, opts = {}) {
+  const args = ["exec"];
+  if (opts.interactive)
+    args.push("-i");
+  if (opts.tty)
+    args.push("-t");
+  args.push(containerId, ...cmd);
+  debug("docker", ...args);
+  return Bun.spawn(["docker", ...args], {
+    stdin: opts.stdin ?? "pipe",
+    stdout: opts.stdout ?? "pipe",
+    stderr: opts.stderr ?? "pipe"
+  });
+}
+async function dockerWriteFile(containerId, destPath, content) {
+  debug("docker write", destPath, `(${content.length} bytes)`);
+  const proc = Bun.spawn(["docker", "exec", "-i", containerId, "tee", destPath], {
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  proc.stdin.write(content);
+  proc.stdin.end();
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`docker write failed (exit ${exitCode}): ${stderr}`);
+  }
+}
+async function dockerWhich(containerId, command) {
+  const proc = Bun.spawn(["docker", "exec", containerId, "which", command], { stdout: "pipe", stderr: "pipe" });
+  return await proc.exited === 0;
+}
+async function dockerChmod(containerId, path, mode = "+x") {
+  const proc = Bun.spawn(["docker", "exec", containerId, "chmod", mode, path], { stdout: "pipe", stderr: "pipe" });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(`docker chmod failed (exit ${exitCode})`);
+  }
+}
+
+// src/core/config.ts
+var CONFIG_FILES = [
+  ".devcontainer/devcontainer.json",
+  ".devcontainer.json"
+];
+async function readDevcontainerConfig(workspaceFolder) {
+  for (const rel of CONFIG_FILES) {
+    const path = `${workspaceFolder}/${rel}`;
+    const file = Bun.file(path);
+    if (await file.exists()) {
+      debug("Reading config from", path);
+      try {
+        const text = await file.text();
+        const cleaned = text.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,(\s*[}\]])/g, "$1");
+        return JSON.parse(cleaned);
+      } catch (e) {
+        warn(`Failed to parse ${path}: ${e}`);
+        return {};
+      }
+    }
+  }
+  debug("No devcontainer.json found");
+  return {};
+}
+
+// src/core/tcp-proxy.ts
+var AGENT_PATH = "/tmp/devcon-agent.js";
+function bridgeConnection(containerId, containerPort, hostSocket, runtime) {
+  const proc = dockerExec(containerId, [runtime, AGENT_PATH, "bridge", String(containerPort)], {
+    interactive: true,
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  let closing = false;
+  function cleanup() {
+    if (closing)
+      return;
+    closing = true;
+    try {
+      hostSocket.end();
+    } catch {}
+    try {
+      proc.kill();
+    } catch {}
+  }
+  const stdout = proc.stdout;
+  if (stdout && typeof stdout !== "number") {
+    (async () => {
+      try {
+        const reader = stdout.getReader();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          hostSocket.write(value);
+        }
+      } catch (e) {
+        debug("bridge stdout pipe ended:", e);
+      }
+      cleanup();
+    })();
+  }
+  const stderr = proc.stderr;
+  if (stderr && typeof stderr !== "number") {
+    (async () => {
+      try {
+        const text = await new Response(stderr).text();
+        if (text.trim()) {
+          debug(`bridge stderr (port ${containerPort}):`, text.trim());
+        }
+      } catch {}
+    })();
+  }
+  hostSocket.__bridgeProc = proc;
+  hostSocket.__bridgeCleanup = cleanup;
+}
+function bridgeWrite(hostSocket, data) {
+  const proc = hostSocket.__bridgeProc;
+  if (proc?.stdin) {
+    proc.stdin.write(data);
+  }
+}
+function bridgeClose(hostSocket) {
+  const cleanup = hostSocket.__bridgeCleanup;
+  if (cleanup)
+    cleanup();
+}
+
+// src/core/port-manager.ts
+class PortManager {
+  ports = new Map;
+  containerId;
+  runtime;
+  constructor(containerId, runtime) {
+    this.containerId = containerId;
+    this.runtime = runtime;
+  }
+  getForwardedPorts() {
+    return [...this.ports.values()].map((p) => p.info);
+  }
+  isForwarded(containerPort) {
+    return this.ports.has(containerPort);
+  }
+  async forward(containerPort, hostPort = containerPort, source = "auto") {
+    if (this.ports.has(containerPort)) {
+      debug(`Port ${containerPort} already forwarded`);
+      return false;
+    }
+    const portInfo = {
+      containerPort,
+      hostPort,
+      source,
+      status: "starting"
+    };
+    try {
+      const containerId = this.containerId;
+      const runtime = this.runtime;
+      const listener = Bun.listen({
+        hostname: "127.0.0.1",
+        port: hostPort,
+        socket: {
+          open(socket) {
+            debug(`New connection on host port ${hostPort} -> container port ${containerPort}`);
+            bridgeConnection(containerId, containerPort, socket, runtime);
+          },
+          data(socket, data) {
+            bridgeWrite(socket, Buffer.from(data));
+          },
+          close(socket) {
+            bridgeClose(socket);
+          },
+          error(socket, err) {
+            debug(`Socket error on port ${hostPort}:`, err.message);
+            bridgeClose(socket);
+          }
+        }
+      });
+      portInfo.status = "forwarding";
+      this.ports.set(containerPort, { info: portInfo, listener });
+      portLog(hostPort, containerPort, source);
+      return true;
+    } catch (e) {
+      if (e.code === "EADDRINUSE") {
+        if (source === "manual") {
+          throw new Error(`Host port ${hostPort} is already in use`);
+        }
+        warn(`Port ${hostPort} already in use, skipping auto-forward for container port ${containerPort}`);
+        return false;
+      }
+      portInfo.status = "error";
+      error(`Failed to forward port ${containerPort}:`, e.message);
+      return false;
+    }
+  }
+  remove(containerPort) {
+    const managed = this.ports.get(containerPort);
+    if (!managed)
+      return false;
+    try {
+      managed.listener.stop();
+    } catch {}
+    this.ports.delete(containerPort);
+    info(`Stopped forwarding port ${containerPort}`);
+    return true;
+  }
+  async syncAutoDetected(detectedPorts) {
+    const detected = new Set(detectedPorts);
+    for (const [containerPort, managed] of this.ports) {
+      if (managed.info.source === "auto" && !detected.has(containerPort)) {
+        this.remove(containerPort);
+      }
+    }
+    for (const port of detectedPorts) {
+      if (!this.ports.has(port)) {
+        await this.forward(port, port, "auto");
+      }
+    }
+  }
+  shutdown() {
+    for (const [, managed] of this.ports) {
+      try {
+        managed.listener.stop();
+      } catch {}
+      debug(`Stopped listener on port ${managed.info.hostPort}`);
+    }
+    this.ports.clear();
+  }
+}
+
+// src/core/port-monitor.ts
+var AGENT_PATH2 = "/tmp/devcon-agent.js";
+var MAX_RETRIES = 3;
+var RETRY_DELAY_MS = 2000;
+async function startPortMonitor(containerId, runtime, onPortChange) {
+  let retries = 0;
+  let stopped = false;
+  let currentProc = null;
+  async function start() {
+    const proc2 = dockerExec(containerId, [runtime, AGENT_PATH2, "monitor"], {
+      interactive: true,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    currentProc = proc2;
+    const stderr = proc2.stderr;
+    if (stderr && typeof stderr !== "number") {
+      (async () => {
+        try {
+          const text = await new Response(stderr).text();
+          if (text.trim()) {
+            debug("[agent stderr]", text.trim());
+          }
+        } catch {}
+      })();
+    }
+    const stdout = proc2.stdout;
+    if (stdout && typeof stdout !== "number") {
+      (async () => {
+        try {
+          const decoder = new TextDecoder;
+          let buf = "";
+          const reader = stdout.getReader();
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buf += decoder.decode(value, { stream: true });
+            const lines = buf.split(`
+`);
+            buf = lines.pop();
+            for (const line of lines) {
+              if (!line.trim())
+                continue;
+              try {
+                const msg = JSON.parse(line);
+                debug("[agent]", msg);
+                if (msg.type === "ready") {
+                  info("Agent ready (pid:", msg.pid + ")");
+                  retries = 0;
+                } else if (msg.type === "ports") {
+                  onPortChange(msg.ports);
+                }
+              } catch {
+                debug("[agent] unparseable line:", line);
+              }
+            }
+          }
+        } catch (e) {
+          debug("Agent stdout reader ended:", e);
+        }
+        if (!stopped && retries < MAX_RETRIES) {
+          retries++;
+          warn(`Agent exited, retrying (${retries}/${MAX_RETRIES}) in ${RETRY_DELAY_MS}ms...`);
+          await Bun.sleep(RETRY_DELAY_MS);
+          if (!stopped) {
+            await start();
+          }
+        } else if (!stopped) {
+          error("Agent exited and max retries reached");
+        }
+      })();
+    }
+    return proc2;
+  }
+  const proc = await start();
+  return {
+    proc,
+    stop() {
+      stopped = true;
+      if (currentProc) {
+        try {
+          const stdin = currentProc.stdin;
+          stdin?.write?.(JSON.stringify({ type: "stop" }) + `
+`);
+        } catch {}
+        setTimeout(() => {
+          try {
+            currentProc?.kill();
+          } catch {}
+        }, 1000);
+      }
+    }
+  };
+}
+
+// src/core/state.ts
+import { createHash } from "crypto";
+function stateFilePath(workspaceFolder) {
+  const hash = createHash("sha256").update(workspaceFolder).digest("hex").slice(0, 12);
+  return `/tmp/devcon-${hash}.json`;
+}
+async function writeState(workspaceFolder, containerId, ports) {
+  const path = stateFilePath(workspaceFolder);
+  const state = {
+    containerId,
+    workspaceFolder,
+    ports,
+    pid: process.pid
+  };
+  debug("Writing state to", path);
+  await Bun.write(path, JSON.stringify(state, null, 2));
+}
+async function readState(workspaceFolder) {
+  const path = stateFilePath(workspaceFolder);
+  const file = Bun.file(path);
+  if (!await file.exists()) {
+    return null;
+  }
+  try {
+    return await file.json();
+  } catch {
+    return null;
+  }
+}
+async function removeState(workspaceFolder) {
+  const path = stateFilePath(workspaceFolder);
+  try {
+    const { unlink } = await import("fs/promises");
+    await unlink(path);
+    debug("Removed state file", path);
+  } catch {}
+}
+
+// src/commands/up.ts
+var AGENT_PATH3 = "/tmp/devcon-agent.js";
+async function commandUp(opts) {
+  const { workspaceFolder } = opts;
+  info("Starting devcontainer...");
+  const result = await devcontainerUp(workspaceFolder);
+  success(`Container started (${result.containerId.slice(0, 12)})`);
+  debug("Remote user:", result.remoteUser);
+  debug("Workspace folder:", result.remoteWorkspaceFolder);
+  const containerId = result.containerId;
+  let runtime = "node";
+  if (await dockerWhich(containerId, "node")) {
+    runtime = "node";
+  } else if (await dockerWhich(containerId, "bun")) {
+    runtime = "bun";
+  } else {
+    error("No Node.js or Bun runtime found in container.");
+    error("The devcon agent requires Node.js or Bun to run.");
+    process.exit(1);
+  }
+  debug("Using runtime:", runtime);
+  info("Deploying agent...");
+  const agentFile = runtime === "bun" ? "agent-bun.js" : "agent-node.js";
+  const agentPath = new URL(`../../dist/${agentFile}`, import.meta.url).pathname;
+  const agentCode = await Bun.file(agentPath).text();
+  await dockerWriteFile(containerId, AGENT_PATH3, agentCode);
+  await dockerChmod(containerId, AGENT_PATH3);
+  success("Agent deployed");
+  const config = await readDevcontainerConfig(workspaceFolder);
+  const configPorts = config.forwardPorts ?? [];
+  if (configPorts.length > 0) {
+    debug("Config forwardPorts:", configPorts);
+  }
+  const portManager = new PortManager(containerId, runtime);
+  for (const port of configPorts) {
+    const onAutoForward = config.portsAttributes?.[String(port)]?.onAutoForward;
+    if (onAutoForward === "ignore") {
+      debug(`Skipping port ${port} (onAutoForward: ignore)`);
+      continue;
+    }
+    await portManager.forward(port, port, "config");
+  }
+  const ignoreSet = new Set;
+  if (config.portsAttributes) {
+    for (const [portStr, attrs] of Object.entries(config.portsAttributes)) {
+      if (attrs.onAutoForward === "ignore") {
+        ignoreSet.add(parseInt(portStr, 10));
+      }
+    }
+  }
+  const monitor = await startPortMonitor(containerId, runtime, async (ports) => {
+    const filtered = ports.filter((p) => !ignoreSet.has(p));
+    await portManager.syncAutoDetected(filtered);
+    await writeState(workspaceFolder, containerId, portManager.getForwardedPorts());
+  });
+  await writeState(workspaceFolder, containerId, portManager.getForwardedPorts());
+  let shuttingDown = false;
+  async function shutdown() {
+    if (shuttingDown)
+      return;
+    shuttingDown = true;
+    info("Shutting down...");
+    monitor.stop();
+    portManager.shutdown();
+    info("Stopping container...");
+    const stopProc = Bun.spawn(["docker", "stop", containerId], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stopExit = await stopProc.exited;
+    if (stopExit === 0) {
+      success("Container stopped");
+    } else {
+      error("Failed to stop container", containerId.slice(0, 12));
+    }
+    await removeState(workspaceFolder);
+    process.exit(0);
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  info("Port forwarding active. Press Ctrl+C to stop.");
+  await new Promise(() => {});
+}
+
+// src/commands/down.ts
+async function commandDown(opts) {
+  const { workspaceFolder } = opts;
+  const state = await readState(workspaceFolder);
+  if (state?.pid) {
+    try {
+      process.kill(state.pid, "SIGTERM");
+      info("Sent SIGTERM to devcon process (pid:", state.pid + ")");
+    } catch {
+      debug("devcon process already exited");
+    }
+  }
+  info("Stopping devcontainer...");
+  const proc = Bun.spawn(["devcontainer", "down", "--workspace-folder", workspaceFolder], { stdout: "inherit", stderr: "inherit" });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0 && state?.containerId) {
+    debug("devcontainer down failed, trying docker stop");
+    const dockerProc = Bun.spawn(["docker", "stop", state.containerId], { stdout: "pipe", stderr: "pipe" });
+    const dockerExit = await dockerProc.exited;
+    if (dockerExit === 0) {
+      success("Container stopped");
+    } else {
+      warn("Could not stop container", state.containerId);
+    }
+  } else if (exitCode === 0) {
+    success("Container stopped");
+  }
+  await removeState(workspaceFolder);
+}
+
+// src/commands/exec.ts
+async function commandExec(opts) {
+  const { workspaceFolder, args } = opts;
+  const cmd = args[0] === "--" ? args.slice(1) : args;
+  if (cmd.length === 0) {
+    error("Usage: devcon exec -- <command> [args...]");
+    process.exit(1);
+  }
+  const exitCode = await devcontainerExec(workspaceFolder, cmd);
+  process.exit(exitCode);
+}
+
+// src/commands/shell.ts
+async function commandShell(opts) {
+  const { workspaceFolder } = opts;
+  const state = await readState(workspaceFolder);
+  if (!state?.containerId) {
+    error("No running container found. Run `devcon up` first.");
+    process.exit(1);
+  }
+  const shell = opts.args[0] ?? "/bin/sh";
+  debug("Opening shell:", shell, "in container:", state.containerId.slice(0, 12));
+  const proc = Bun.spawn(["docker", "exec", "-it", state.containerId, shell], { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+  const exitCode = await proc.exited;
+  process.exit(exitCode);
+}
+
+// src/commands/forward.ts
+function parsePortSpec(spec) {
+  const parts = spec.split(":");
+  if (parts.length === 2) {
+    return {
+      hostPort: parseInt(parts[0], 10),
+      containerPort: parseInt(parts[1], 10)
+    };
+  }
+  const port = parseInt(parts[0], 10);
+  return { hostPort: port, containerPort: port };
+}
+async function commandForward(opts) {
+  const { workspaceFolder, args } = opts;
+  if (args.length === 0) {
+    error("Usage: devcon forward [host_port:]container_port");
+    process.exit(1);
+  }
+  const state = await readState(workspaceFolder);
+  if (!state?.containerId) {
+    error("No running container found. Run `devcon up` first.");
+    process.exit(1);
+  }
+  const { hostPort, containerPort } = parsePortSpec(args[0]);
+  if (isNaN(hostPort) || isNaN(containerPort)) {
+    error("Invalid port specification:", args[0]);
+    process.exit(1);
+  }
+  let runtime = "node";
+  if (await dockerWhich(state.containerId, "node")) {
+    runtime = "node";
+  } else if (await dockerWhich(state.containerId, "bun")) {
+    runtime = "bun";
+  } else {
+    error("No runtime found in container");
+    process.exit(1);
+  }
+  const portManager = new PortManager(state.containerId, runtime);
+  try {
+    await portManager.forward(containerPort, hostPort, "manual");
+    success(`Forwarding localhost:${hostPort} -> container:${containerPort}`);
+  } catch (e) {
+    error(e.message);
+    process.exit(1);
+  }
+  const currentState = await readState(workspaceFolder);
+  if (currentState) {
+    const ports = [...currentState.ports, ...portManager.getForwardedPorts()];
+    await writeState(workspaceFolder, state.containerId, ports);
+  }
+  info("Press Ctrl+C to stop forwarding.");
+  process.on("SIGINT", () => {
+    portManager.shutdown();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    portManager.shutdown();
+    process.exit(0);
+  });
+  await new Promise(() => {});
+}
+
+// src/commands/ports.ts
+async function commandPorts(opts) {
+  const state = await readState(opts.workspaceFolder);
+  if (!state) {
+    warn("No running devcon instance found.");
+    return;
+  }
+  if (state.ports.length === 0) {
+    info("No ports currently forwarded.");
+    return;
+  }
+  console.log("Forwarded ports:");
+  console.log("");
+  console.log("  HOST       CONTAINER  SOURCE  STATUS");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const port of state.ports) {
+    const host = String(port.hostPort).padEnd(9);
+    const container = String(port.containerPort).padEnd(9);
+    const source = port.source.padEnd(6);
+    console.log(`  ${host}  ${container}  ${source}  ${port.status}`);
+  }
+  console.log("");
+}
+
+// src/commands/passthrough.ts
+async function commandPassthrough(opts) {
+  const allArgs = [opts.command, ...opts.args];
+  debug("Passing through to devcontainer:", allArgs);
+  const exitCode = await devcontainerPassthrough(allArgs);
+  process.exit(exitCode);
+}
+
+// index.ts
+registerCommand("up", commandUp);
+registerCommand("down", commandDown);
+registerCommand("exec", commandExec);
+registerCommand("shell", commandShell);
+registerCommand("forward", commandForward);
+registerCommand("ports", commandPorts);
+var opts = parseArgs(process.argv.slice(2));
+setVerbose(opts.verbose);
+if (!opts.command) {
+  parseArgs(["--help"]);
+  process.exit(0);
+}
+var handler = getCommand(opts.command);
+if (handler) {
+  await handler(opts);
+} else {
+  await commandPassthrough(opts);
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "devcon-cli",
+  "version": "0.1.0",
+  "description": "Devcontainer CLI with automatic port forwarding",
+  "type": "module",
+  "scripts": {
+    "build": "bun scripts/build.ts"
+  },
+  "bin": {
+    "devcon": "dist/index.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "dependencies": {
+    "@devcontainers/cli": "^0.83.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.9.3"
+  }
+}