sshHelper.ts

// @effect-diagnostics nodeBuiltinImport:off
// @effect-diagnostics globalTimers:off
// @effect-diagnostics globalDateInEffect:off
import * as NodeFS from "node:fs";
import * as NodeHttp from "node:http";
import * as NodeNet from "node:net";

import * as Effect from "effect/Effect";
import { Argument, Command } from "effect/cli";

const canBind = (port: number) =>
  new Promise<boolean>((resolve) => {
    const server = NodeNet.createServer();
    server.unref();
    server.once("error", () => resolve(false));
    server.listen(port, "127.0.0.1", () => {
      server.close((error) => resolve(!error));
    });
  });

// macOS permits this bind over a wildcard listener, so also check loopback connectivity.
const answersOnLoopback = (port: number) =>
  new Promise<boolean>((resolve) => {
    const socket = NodeNet.connect({ port, host: "127.0.0.1" });
    socket.setTimeout(1000);
    socket.once("connect", () => {
      socket.destroy();
      resolve(true);
    });
    socket.once("timeout", () => {
      socket.destroy();
      resolve(true);
    });
    socket.once("error", () => resolve(false));
  });

const pickPort = Command.make("pick-port", {
  portFile: Argument.String("port-file"),
  defaultPort: Argument.Int("default-port"),
  scanWindow: Argument.Int("scan-window"),
}).pipe(
  Command.withHandler(({ portFile, defaultPort, scanWindow }) =>
    Effect.promise(async () => {
      const raw = NodeFS.existsSync(portFile) ? NodeFS.readFileSync(portFile, "utf8").trim() : "";
      const preferred = Number.parseInt(raw, 10);
      const start = Number.isInteger(preferred) ? preferred : defaultPort;
      for (let port = start; port < start + scanWindow; port += 1) {
        if ((await canBind(port)) && !(await answersOnLoopback(port))) {
          process.stdout.write(String(port));
          return;
        }
      }
      process.exitCode = 1;
    }),
  ),
);

const probe = (port: number, probeTimeoutMs: number) =>
  new Promise<boolean>((resolve) => {
    const request = NodeHttp.get(
      { hostname: "127.0.0.1", port, path: "/", timeout: probeTimeoutMs },
      (response) => {
        response.resume();
        response.once("end", () => {
          const status = response.statusCode ?? 0;
          resolve(status >= 200 && status < 300);
        });
      },
    );
    request.once("timeout", () => {
      request.destroy();
      resolve(false);
    });
    request.once("error", () => resolve(false));
  });

const waitReady = Command.make("wait-ready", {
  port: Argument.Int("port"),
  timeoutMs: Argument.Int("timeout-ms"),
  probeTimeoutMs: Argument.Int("probe-timeout-ms"),
}).pipe(
  Command.withHandler(({ port, timeoutMs, probeTimeoutMs }) =>
    Effect.promise(async () => {
      const deadline = Date.now() + timeoutMs;
      while (Date.now() < deadline) {
        if (await probe(port, probeTimeoutMs)) return;
        await new Promise((resolve) => setTimeout(resolve, 100));
      }
      process.exitCode = 1;
    }),
  ),
);

/** Prints `<pid> <port>` for a live default-home server, or exits 1. */
const runtimePort = Command.make("runtime-port", {
  runtimeFile: Argument.String("runtime-file"),
}).pipe(
  Command.withHandler(({ runtimeFile }) =>
    Effect.sync(() => {
      try {
        // @effect-diagnostics-next-line globalJsonInEffect:off - mirrors the shell snippet's loose parse.
        const runtime = JSON.parse(NodeFS.readFileSync(runtimeFile, "utf8")) as {
          pid?: unknown;
          port?: unknown;
          origin?: unknown;
        };
        const pid = Number(runtime.pid);
        const port = Number(runtime.port);
        if (!Number.isInteger(pid) || pid <= 0 || !Number.isInteger(port)) {
          process.exitCode = 1;
          return;
        }
        const origin = new URL(String(runtime.origin ?? ""));
        if (origin.protocol !== "http:" || !["127.0.0.1", "localhost"].includes(origin.hostname)) {
          process.exitCode = 1;
          return;
        }
        process.kill(pid, 0);
        process.stdout.write(`${pid} ${port}`);
      } catch {
        process.exitCode = 1;
      }
    }),
  ),
);

export const sshHelperCommand = Command.make("__ssh-helper").pipe(
  Command.unlisted,
  Command.withSubcommands([pickPort, waitReady, runtimePort]),
);