@sentropic/remote-cli 0.0.3

package/dist/chunk-VRTZ23J3.js

@@ -0,0 +1,541 @@
+import {
+  DEFAULT_SESSION_TARGET,
+  authHeaders,
+  getTunnel,
+  resolveConfigPath
+} from "./chunk-E3GXAKJ3.js";
+
+// src/tunnel.ts
+import { spawn } from "child_process";
+import {
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+function runtimeDir() {
+  return join(dirname(resolveConfigPath()), "run");
+}
+function pidFile() {
+  return join(runtimeDir(), "tunnel.pid");
+}
+function logFile() {
+  return join(runtimeDir(), "tunnel.log");
+}
+function expandHome(p) {
+  return p.startsWith("~") ? join(homedir(), p.slice(1)) : p;
+}
+async function isReachable(url, timeoutMs = 1500) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    await fetch(`${url.replace(/\/$/, "")}/sessions`, {
+      signal: controller.signal,
+      headers: authHeaders()
+    });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function tunnelPid() {
+  if (!existsSync(pidFile())) return void 0;
+  const pid = Number(readFileSync(pidFile(), "utf8").trim());
+  return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+}
+function tunnelAlive() {
+  const pid = tunnelPid();
+  if (pid === void 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function startTunnelProcess(tunnel) {
+  mkdirSync(runtimeDir(), { recursive: true });
+  const env = { ...process.env };
+  if (tunnel.kubeconfig) env.KUBECONFIG = expandHome(tunnel.kubeconfig);
+  const out = openSync(logFile(), "a");
+  const child = spawn(
+    "kubectl",
+    [
+      "-n",
+      tunnel.namespace,
+      "port-forward",
+      `svc/${tunnel.service}`,
+      `${tunnel.localPort}:${tunnel.remotePort}`
+    ],
+    { detached: true, stdio: ["ignore", out, out], env }
+  );
+  if (child.pid !== void 0) writeFileSync(pidFile(), String(child.pid));
+  child.unref();
+}
+function stopTunnel() {
+  const pid = tunnelPid();
+  rmSync(pidFile(), { force: true });
+  if (pid === void 0) return false;
+  try {
+    process.kill(pid);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureConnected(url, stderr = process.stderr) {
+  const tunnel = getTunnel();
+  if (!tunnel) return;
+  if (await isReachable(url)) return;
+  const reopening = tunnelAlive();
+  stopTunnel();
+  stderr.write(
+    `[remote] control-plane unreachable \u2014 ${reopening ? "tunnel stale, reopening" : "opening tunnel"} (kubectl port-forward ${tunnel.service} :${tunnel.localPort})
+`
+  );
+  startTunnelProcess(tunnel);
+  for (let attempt = 0; attempt < 30; attempt++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (await isReachable(url)) {
+      stderr.write(`[remote] tunnel up
+`);
+      return;
+    }
+  }
+  throw new Error(
+    `tunnel started but ${url} is still unreachable after 15s \u2014 check the kubeconfig/namespace/service (logs: ${logFile()})`
+  );
+}
+
+// src/attach.ts
+var DEFAULT_INPUT_RETRY = {
+  maxAttempts: 6,
+  baseDelayMs: 200,
+  maxDelayMs: 1600
+};
+function joinUrl(base, path) {
+  return `${base.replace(/\/$/, "")}${path}`;
+}
+function parseSseEvents(buffer) {
+  const events = [];
+  const chunks = buffer.split("\n\n");
+  const rest = chunks.pop() ?? "";
+  for (const chunk of chunks) {
+    if (!chunk.trim()) continue;
+    let eventName;
+    const dataLines = [];
+    for (const line of chunk.split("\n")) {
+      if (line.startsWith("event:")) eventName = line.slice(6).trim();
+      else if (line.startsWith("data:")) dataLines.push(line.slice(5).trim());
+    }
+    if (dataLines.length === 0) continue;
+    const entry = {
+      data: dataLines.join("\n")
+    };
+    if (eventName !== void 0) entry.event = eventName;
+    events.push(entry);
+  }
+  return { events, rest };
+}
+async function attach(options) {
+  const baseUrl = options.baseUrl;
+  const sessionId = options.sessionId;
+  const stdin = options.stdin ?? process.stdin;
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const doFetch = options.fetchImpl ?? fetch;
+  const controller = new AbortController();
+  const sseResponse = await doFetch(
+    joinUrl(baseUrl, `/sessions/${sessionId}/events`),
+    {
+      headers: { accept: "text/event-stream", ...authHeaders() },
+      signal: controller.signal
+    }
+  );
+  if (!sseResponse.ok || !sseResponse.body) {
+    throw new Error(
+      `attach: SSE stream returned ${sseResponse.status} ${sseResponse.statusText}`
+    );
+  }
+  let reader = sseResponse.body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let finishedResolve;
+  const finished = new Promise((resolve) => {
+    finishedResolve = resolve;
+  });
+  const wasRaw = stdin.isTTY ? Boolean(stdin.isRaw) : false;
+  if (stdin.isTTY) stdin.setRawMode?.(true);
+  stdin.resume();
+  if (stdin.isTTY) {
+    stderr.write(
+      "[remote] press Ctrl+P Ctrl+Q to detach (session keeps running)\n"
+    );
+  }
+  const retry = { ...DEFAULT_INPUT_RETRY, ...options.inputRetry ?? {} };
+  let aborted = false;
+  let queueTail = Promise.resolve();
+  const postInput = async (data) => {
+    for (let attempt = 1; attempt <= retry.maxAttempts; attempt++) {
+      if (aborted) return;
+      try {
+        const response = await doFetch(
+          joinUrl(baseUrl, `/sessions/${sessionId}/terminal/input`),
+          {
+            method: "POST",
+            headers: { "content-type": "application/json", ...authHeaders() },
+            body: JSON.stringify({
+              terminalId: "operator",
+              data,
+              encoding: "utf8"
+            })
+          }
+        );
+        if (response.ok) return;
+        if (response.status < 500) {
+          stderr.write(
+            `[remote] input rejected (${response.status} ${response.statusText}); not retried
+`
+          );
+          return;
+        }
+      } catch (error) {
+        if (aborted) return;
+        if (attempt === retry.maxAttempts) {
+          stderr.write(
+            `[remote] input abandoned after ${retry.maxAttempts} attempts: ${String(error)}
+`
+          );
+          return;
+        }
+      }
+      if (attempt < retry.maxAttempts) {
+        const delay = Math.min(
+          retry.maxDelayMs,
+          retry.baseDelayMs * 2 ** (attempt - 1)
+        );
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    stderr.write(
+      `[remote] input abandoned after ${retry.maxAttempts} attempts
+`
+    );
+  };
+  const enqueueInput = (data) => {
+    queueTail = queueTail.then(() => postInput(data));
+  };
+  const sendResize = async () => {
+    const columns = Math.max(1, stdout.columns ?? 80);
+    const rows = Math.max(1, stdout.rows ?? 24);
+    try {
+      await doFetch(
+        joinUrl(baseUrl, `/sessions/${sessionId}/terminal/resize`),
+        {
+          method: "POST",
+          headers: { "content-type": "application/json", ...authHeaders() },
+          body: JSON.stringify({
+            terminalId: "operator",
+            columns,
+            rows
+          })
+        }
+      );
+    } catch (error) {
+      stderr.write(`[remote] resize failed: ${String(error)}
+`);
+    }
+  };
+  const CTRL_P = 16;
+  const CTRL_Q = 17;
+  const DETACH_TIMEOUT_MS = 1500;
+  let detachPending = false;
+  let detachTimer = null;
+  const onStdin = (chunk) => {
+    const bytes = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+    const passthrough = [];
+    const flushPassthrough = () => {
+      if (passthrough.length === 0) return;
+      enqueueInput(Buffer.from(passthrough).toString("utf8"));
+      passthrough.length = 0;
+    };
+    for (let i = 0; i < bytes.length; i++) {
+      const byte = bytes[i];
+      if (detachPending) {
+        if (byte === CTRL_Q) {
+          detachPending = false;
+          if (detachTimer) {
+            clearTimeout(detachTimer);
+            detachTimer = null;
+          }
+          flushPassthrough();
+          if (stdin.isTTY) stderr.write("\n[remote] detached\n");
+          void close();
+          return;
+        }
+        detachPending = false;
+        if (detachTimer) {
+          clearTimeout(detachTimer);
+          detachTimer = null;
+        }
+        passthrough.push(CTRL_P, byte);
+        continue;
+      }
+      if (byte === CTRL_P) {
+        flushPassthrough();
+        detachPending = true;
+        detachTimer = setTimeout(() => {
+          if (!detachPending) return;
+          detachPending = false;
+          detachTimer = null;
+          enqueueInput("");
+        }, DETACH_TIMEOUT_MS);
+        continue;
+      }
+      passthrough.push(byte);
+    }
+    flushPassthrough();
+  };
+  const onResize = () => {
+    void sendResize();
+  };
+  stdin.on("data", onStdin);
+  stdout.on?.("resize", onResize);
+  let closed = false;
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    if (detachTimer) {
+      clearTimeout(detachTimer);
+      detachTimer = null;
+    }
+    stdin.off?.("data", onStdin);
+    await Promise.race([
+      queueTail.catch(() => {
+      }),
+      new Promise((resolve) => setTimeout(resolve, 500).unref?.())
+    ]);
+    aborted = true;
+    controller.abort();
+    stdout.off?.("resize", onResize);
+    if (stdin.isTTY) stdin.setRawMode?.(wasRaw);
+    stdin.pause();
+    finishedResolve();
+  };
+  (async () => {
+    let buffer = "";
+    for (; ; ) {
+      try {
+        for (; ; ) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const { events, rest } = parseSseEvents(buffer);
+          buffer = rest;
+          for (const ev of events) {
+            if (ev.event && ev.event !== "terminal.output" && ev.event !== "terminal.exited")
+              continue;
+            try {
+              const envelope = JSON.parse(ev.data);
+              if (envelope.type === "terminal.output") {
+                const payload = envelope.payload;
+                if (typeof payload.data === "string")
+                  stdout.write(payload.data);
+              } else if (envelope.type === "terminal.exited") {
+                await close();
+                return;
+              }
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+      if (closed) return;
+      stderr.write("\r\n[remote] connection lost \u2014 reconnecting\u2026\r\n");
+      buffer = "";
+      let reopened = false;
+      for (let attempt = 0; attempt < 120 && !closed; attempt++) {
+        try {
+          await ensureConnected(baseUrl, stderr);
+          const resp = await doFetch(
+            joinUrl(baseUrl, `/sessions/${sessionId}/events`),
+            {
+              headers: { accept: "text/event-stream", ...authHeaders() },
+              signal: controller.signal
+            }
+          );
+          if (resp.status === 404) {
+            stderr.write("[remote] session ended\r\n");
+            await close();
+            return;
+          }
+          if (resp.ok && resp.body) {
+            reader = resp.body.getReader();
+            reopened = true;
+            stderr.write("[remote] reconnected\r\n");
+            break;
+          }
+        } catch {
+        }
+        if (closed) return;
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+      if (!reopened) {
+        await close();
+        return;
+      }
+    }
+  })();
+  return { close, finished };
+}
+async function listRemoteSessions(baseUrl, fetchImpl = fetch) {
+  const response = await fetchImpl(joinUrl(baseUrl, "/sessions"), {
+    headers: { ...authHeaders() }
+  });
+  if (!response.ok) {
+    throw new Error(
+      `listRemoteSessions: ${response.status} ${response.statusText}`
+    );
+  }
+  const json = await response.json();
+  return json.sessions;
+}
+async function stopRemoteSession(baseUrl, sessionId, reason, fetchImpl = fetch) {
+  const body = {};
+  if (reason) body.reason = reason;
+  const response = await fetchImpl(
+    joinUrl(baseUrl, `/sessions/${sessionId}/stop`),
+    {
+      method: "POST",
+      headers: { "content-type": "application/json", ...authHeaders() },
+      body: JSON.stringify(body)
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `stopRemoteSession: ${response.status} ${response.statusText}`
+    );
+  }
+  const json = await response.json();
+  return { accepted: json.accepted };
+}
+async function getRemoteSession(baseUrl, sessionId, fetchImpl = fetch) {
+  const response = await fetchImpl(joinUrl(baseUrl, `/sessions/${sessionId}`), {
+    headers: { ...authHeaders() }
+  });
+  if (!response.ok) {
+    throw new Error(
+      `getRemoteSession: ${response.status} ${response.statusText}`
+    );
+  }
+  return await response.json();
+}
+async function refreshRemoteSession(baseUrl, sessionId, credentials, fetchImpl = fetch, displayName) {
+  const path = `/sessions/${sessionId}/credentials`;
+  const url = displayName && displayName.length > 0 ? `${joinUrl(baseUrl, path)}?displayName=${encodeURIComponent(displayName)}` : joinUrl(baseUrl, path);
+  const response = await fetchImpl(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...authHeaders() },
+    body: JSON.stringify(credentials)
+  });
+  if (!response.ok) {
+    throw new Error(
+      `refreshRemoteSession: ${response.status} ${response.statusText}`
+    );
+  }
+  const json = await response.json();
+  return { sessionId: json.sessionId, accepted: json.accepted };
+}
+async function renameRemoteSession(baseUrl, sessionId, displayName, fetchImpl = fetch) {
+  const response = await fetchImpl(joinUrl(baseUrl, `/sessions/${sessionId}`), {
+    method: "PATCH",
+    headers: { "content-type": "application/json", ...authHeaders() },
+    body: JSON.stringify({ displayName })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `renameRemoteSession: ${response.status} ${response.statusText}`
+    );
+  }
+  const json = await response.json();
+  return {
+    sessionId: json.sessionId,
+    displayName: json.displayName,
+    accepted: json.accepted
+  };
+}
+async function sessionTerminalHealth(baseUrl, sessionId, fetchImpl = fetch) {
+  try {
+    const response = await fetchImpl(
+      joinUrl(baseUrl, `/sessions/${sessionId}/terminal/input`),
+      {
+        method: "POST",
+        headers: { "content-type": "application/json", ...authHeaders() },
+        body: JSON.stringify({
+          terminalId: sessionId,
+          data: "",
+          encoding: "utf8"
+        })
+      }
+    );
+    if (response.status === 202) return "ready";
+    if (response.status === 503) return "agent-down";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function createRemoteSession(baseUrl, body, fetchImpl = fetch) {
+  const payload = {
+    profile: body.profile,
+    target: body.target ?? DEFAULT_SESSION_TARGET
+  };
+  if (body.displayName) payload.displayName = body.displayName;
+  if (body.workspaceSync) payload.workspaceSync = true;
+  if (body.workspaceExport) payload.workspaceExport = true;
+  if (body.workspaceId) payload.workspaceId = body.workspaceId;
+  if (body.workspacePath) payload.workspacePath = body.workspacePath;
+  if (body.home) payload.home = body.home;
+  if (body.agentImage) payload.agentImage = body.agentImage;
+  if (body.resume !== void 0 || (body.startupArgs?.length ?? 0) > 0 || body.metadata !== void 0) {
+    const metadata = {
+      ...body.metadata ?? {},
+      ...body.resume !== void 0 ? { resume: body.resume } : {},
+      ...body.startupArgs?.length ? { startup: { args: body.startupArgs } } : {}
+    };
+    payload.metadata = metadata;
+  }
+  if (body.credentials && Object.keys(body.credentials).length > 0)
+    payload.credentials = body.credentials;
+  const response = await fetchImpl(joinUrl(baseUrl, "/sessions"), {
+    method: "POST",
+    headers: { "content-type": "application/json", ...authHeaders() },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    throw new Error(
+      `createRemoteSession: ${response.status} ${response.statusText}`
+    );
+  }
+  const json = await response.json();
+  return { id: json.session.id };
+}
+
+export {
+  stopTunnel,
+  ensureConnected,
+  attach,
+  listRemoteSessions,
+  stopRemoteSession,
+  getRemoteSession,
+  refreshRemoteSession,
+  renameRemoteSession,
+  sessionTerminalHealth,
+  createRemoteSession
+};