@sharpe-jupyter/connect 0.1.0

package/dist/index.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { useState, useEffect } from "react";
+import { render, Box, Text, useApp } from "ink";
+import Spinner from "ink-spinner";
+import { spawn } from "child_process";
+
+// src/cloudflared.ts
+import { createWriteStream, existsSync, mkdirSync, chmodSync } from "fs";
+import { join } from "path";
+import { homedir, platform, arch } from "os";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+import { execSync } from "child_process";
+var CLOUDFLARED_VERSION = "2026.2.0";
+function getAssetInfo() {
+  const os = platform();
+  const cpu = arch();
+  if (os === "darwin") {
+    const base = cpu === "arm64" ? "cloudflared-darwin-arm64" : "cloudflared-darwin-amd64";
+    return { name: `${base}.tgz`, isTarball: true };
+  }
+  if (os === "linux") {
+    const base = cpu === "arm64" ? "cloudflared-linux-arm64" : "cloudflared-linux-amd64";
+    return { name: base, isTarball: false };
+  }
+  if (os === "win32") {
+    return { name: "cloudflared-windows-amd64.exe", isTarball: false };
+  }
+  throw new Error(`Unsupported platform: ${os}/${cpu}`);
+}
+function getBinDir() {
+  return join(homedir(), ".sharpe", "bin");
+}
+function getCloudflaredPath() {
+  const binName = platform() === "win32" ? "cloudflared.exe" : "cloudflared";
+  return join(getBinDir(), binName);
+}
+async function ensureCloudflared() {
+  const binPath = getCloudflaredPath();
+  if (existsSync(binPath)) {
+    return { path: binPath, downloaded: false };
+  }
+  const binDir = getBinDir();
+  mkdirSync(binDir, { recursive: true });
+  const asset = getAssetInfo();
+  const url = `https://github.com/cloudflare/cloudflared/releases/download/${CLOUDFLARED_VERSION}/${asset.name}`;
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok || !response.body) {
+    throw new Error(`Failed to download cloudflared: ${response.status} ${response.statusText}`);
+  }
+  if (asset.isTarball) {
+    const tgzPath = join(binDir, asset.name);
+    const fileStream = createWriteStream(tgzPath);
+    await pipeline(
+      Readable.fromWeb(response.body),
+      fileStream
+    );
+    execSync(`tar -xzf "${tgzPath}" -C "${binDir}" cloudflared`, { stdio: "ignore" });
+    execSync(`rm -f "${tgzPath}"`, { stdio: "ignore" });
+  } else {
+    const fileStream = createWriteStream(binPath);
+    await pipeline(
+      Readable.fromWeb(response.body),
+      fileStream
+    );
+  }
+  if (platform() !== "win32") {
+    chmodSync(binPath, 493);
+  }
+  return { path: binPath, downloaded: true };
+}
+
+// src/health.ts
+async function checkJupyterHealth(port2) {
+  try {
+    const response = await fetch(`http://localhost:${port2}/api/status`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/index.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function App({ token: token2, port: port2 }) {
+  const { exit } = useApp();
+  const [phase, setPhase] = useState({ step: "downloading" });
+  useEffect(() => {
+    let killed = false;
+    async function run() {
+      const { path: binPath } = await ensureCloudflared();
+      if (killed) return;
+      setPhase({ step: "health-check" });
+      const healthy = await checkJupyterHealth(port2);
+      if (killed) return;
+      const warning = healthy ? void 0 : `No JupyterHub at localhost:${port2} -- tunnel will connect but won't proxy traffic until JupyterHub is running.`;
+      setPhase({ step: "connecting", warning });
+      const child = spawn(binPath, ["tunnel", "run", "--token", token2], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      child.stderr?.on("data", (data) => {
+        const text = data.toString();
+        if (text.includes("Registered tunnel connection") || text.includes("INF")) {
+          setPhase({ step: "connected", warning });
+        }
+      });
+      child.stdout?.on("data", (data) => {
+        const text = data.toString();
+        if (text.includes("Registered tunnel connection")) {
+          setPhase({ step: "connected", warning });
+        }
+      });
+      child.on("error", (err) => {
+        if (!killed) {
+          setPhase({ step: "error", message: err.message });
+          exit();
+        }
+      });
+      child.on("exit", (code) => {
+        if (!killed) {
+          if (code !== 0 && code !== null) {
+            setPhase({ step: "error", message: `cloudflared exited with code ${code}` });
+          }
+          exit();
+        }
+      });
+      const cleanup = () => {
+        killed = true;
+        child.kill("SIGTERM");
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+    }
+    run().catch((err) => {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      setPhase({ step: "error", message });
+      exit();
+    });
+  }, [token2, port2, exit]);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "sharpe-connect" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " - Cloudflare Tunnel for JupyterHub" })
+    ] }),
+    phase.step === "downloading" && /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
+      /* @__PURE__ */ jsx(Text, { children: " Downloading cloudflared..." })
+    ] }),
+    phase.step === "health-check" && /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        " Checking JupyterHub at localhost:",
+        port2,
+        "..."
+      ] })
+    ] }),
+    phase.step === "connecting" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "yellow", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
+        /* @__PURE__ */ jsx(Text, { children: " Establishing tunnel connection..." })
+      ] }),
+      phase.warning && /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx(Text, { color: "yellow", children: "Warning: " }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: phase.warning })
+      ] })
+    ] }),
+    phase.step === "connected" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "green", bold: true, children: "Connected" }),
+        /* @__PURE__ */ jsx(Text, { children: " - Tunnel is active" })
+      ] }),
+      phase.warning && /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "yellow", children: "Warning: " }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: phase.warning })
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Press Ctrl+C to disconnect" })
+    ] }),
+    phase.step === "error" && /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: "red", bold: true, children: [
+        "Error:",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { children: phase.message })
+    ] })
+  ] });
+}
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  let token2;
+  let port2 = 8e3;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if ((arg === "--token" || arg === "-t") && args[i + 1]) {
+      token2 = args[++i];
+    } else if ((arg === "--port" || arg === "-p") && args[i + 1]) {
+      port2 = parseInt(args[++i], 10);
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(`
+Usage: sharpe-connect --token <TOKEN> [--port <PORT>]
+
+Options:
+  --token, -t  Tunnel token from Sharpe dashboard (required)
+  --port, -p   Local JupyterHub port (default: 8000)
+  --help, -h   Show this help message
+`);
+      process.exit(0);
+    }
+  }
+  if (!token2) {
+    console.error("Error: --token is required. Run with --help for usage.");
+    process.exit(1);
+  }
+  return { token: token2, port: port2 };
+}
+var { token, port } = parseArgs(process.argv);
+render(/* @__PURE__ */ jsx(App, { token, port }));

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@sharpe-jupyter/connect",
+  "version": "0.1.0",
+  "description": "Connect a local JupyterHub to Sharpe via Cloudflare Tunnel",
+  "type": "module",
+  "bin": {
+    "sharpe-connect": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.tsx --format esm --clean",
+    "start": "tsx src/index.tsx"
+  },
+  "dependencies": {
+    "ink": "^6.0.0",
+    "ink-spinner": "^5.0.0",
+    "react": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.8.3"
+  }
+}