@sharpe-jupyter/connect 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 
 // src/index.tsx
-import { useState, useEffect } from "react";
-import { render, Box, Text, useApp } from "ink";
+import { render } from "ink";
+
+// src/app.tsx
+import { useState, useEffect, useRef, useCallback } from "react";
+import { Box, Text, useApp, useInput } from "ink";
 import Spinner from "ink-spinner";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 
 // src/cloudflared.ts
-import { createWriteStream, existsSync, mkdirSync, chmodSync } from "fs";
+import { createWriteStream, existsSync, mkdirSync, chmodSync, unlinkSync } from "fs";
 import { join } from "path";
 import { homedir, platform, arch } from "os";
 import { pipeline } from "stream/promises";
@@ -58,7 +61,7 @@ async function ensureCloudflared() {
       fileStream
     );
     execSync(`tar -xzf "${tgzPath}" -C "${binDir}" cloudflared`, { stdio: "ignore" });
-    execSync(`rm -f "${tgzPath}"`, { stdio: "ignore" });
+    unlinkSync(tgzPath);
   } else {
     const fileStream = createWriteStream(binPath);
     await pipeline(
@@ -72,6 +75,53 @@ async function ensureCloudflared() {
   return { path: binPath, downloaded: true };
 }
 
+// src/ripgrep.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, chmodSync as chmodSync2, unlinkSync as unlinkSync2, createWriteStream as createWriteStream2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2, arch as arch2 } from "os";
+import { pipeline as pipeline2 } from "stream/promises";
+import { Readable as Readable2 } from "stream";
+import { execSync as execSync2 } from "child_process";
+var RIPGREP_VERSION = "15.1.0";
+function getAssetName() {
+  const cpu = arch2();
+  const triple = cpu === "arm64" ? "aarch64-apple-darwin" : "x86_64-apple-darwin";
+  return `ripgrep-${RIPGREP_VERSION}-${triple}.tar.gz`;
+}
+function getBinDir2() {
+  return join2(homedir2(), ".sharpe", "bin");
+}
+function getRipgrepPath() {
+  return join2(getBinDir2(), "rg");
+}
+async function ensureRipgrep() {
+  const binPath = getRipgrepPath();
+  if (existsSync2(binPath)) {
+    return { path: binPath, downloaded: false };
+  }
+  const binDir = getBinDir2();
+  mkdirSync2(binDir, { recursive: true });
+  const assetName = getAssetName();
+  const url = `https://github.com/BurntSushi/ripgrep/releases/download/${RIPGREP_VERSION}/${assetName}`;
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok || !response.body) {
+    throw new Error(`Failed to download ripgrep: ${response.status} ${response.statusText}`);
+  }
+  const tgzPath = join2(binDir, assetName);
+  const fileStream = createWriteStream2(tgzPath);
+  await pipeline2(
+    Readable2.fromWeb(response.body),
+    fileStream
+  );
+  const dirName = assetName.replace(".tar.gz", "");
+  execSync2(`tar -xzf "${tgzPath}" -C "${binDir}" "${dirName}/rg"`, { stdio: "ignore" });
+  execSync2(`mv "${join2(binDir, dirName, "rg")}" "${binPath}"`, { stdio: "ignore" });
+  unlinkSync2(tgzPath);
+  execSync2(`rm -rf "${join2(binDir, dirName)}"`, { stdio: "ignore" });
+  chmodSync2(binPath, 493);
+  return { path: binPath, downloaded: true };
+}
+
 // src/health.ts
 async function checkJupyterHealth(port2) {
   try {
@@ -84,137 +134,665 @@ async function checkJupyterHealth(port2) {
   }
 }
 
-// src/index.tsx
+// src/jupyter.ts
+import { execSync as execSync3, spawn } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3, platform as platform2 } from "os";
+var SHARPE_DIR = join3(homedir3(), ".sharpe");
+var VENV_DIR = join3(SHARPE_DIR, "venv");
+var SHARPE_BIN_DIR = join3(SHARPE_DIR, "bin");
+var IS_WIN = platform2() === "win32";
+var BIN_DIR = IS_WIN ? "Scripts" : "bin";
+function venvBin(name) {
+  return join3(VENV_DIR, BIN_DIR, IS_WIN ? `${name}.exe` : name);
+}
+function findPython() {
+  for (const cmd of ["python3", "python"]) {
+    try {
+      const version = execSync3(`${cmd} --version`, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+      if (version.startsWith("Python 3")) return cmd;
+    } catch {
+    }
+  }
+  return null;
+}
+function venvExists() {
+  return existsSync3(venvBin("python"));
+}
+function createVenv(pythonCmd) {
+  execSync3(`${pythonCmd} -m venv "${VENV_DIR}"`, { stdio: "ignore" });
+}
+function installPackages(packages) {
+  return spawn(venvBin("pip"), ["install", "--quiet", ...packages], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+}
+function startJupyter(port2) {
+  const env = { ...process.env, PATH: `${SHARPE_BIN_DIR}:${process.env.PATH ?? ""}` };
+  return spawn(
+    venvBin("jupyter"),
+    [
+      "notebook",
+      "--port",
+      String(port2),
+      "--no-browser",
+      "--ServerApp.token=",
+      "--ServerApp.password=",
+      "--ServerApp.allow_remote_access=True",
+      "--ServerApp.disable_check_xsrf=True",
+      '--ServerApp.jpserver_extensions={"sharpe_log_handler.handler": true}'
+    ],
+    { stdio: ["ignore", "pipe", "pipe"], env }
+  );
+}
+function parseJupyterLine(line) {
+  if (/Saving file at\s+(\S+)/.test(line)) {
+    const match = line.match(/Saving file at\s+(\S+)/);
+    if (match) {
+      const filename = match[1].split("/").pop() ?? match[1];
+      return `Notebook saved: ${filename}`;
+    }
+  }
+  if (/Kernel started/i.test(line)) {
+    return "Kernel started";
+  }
+  if (/KernelRestarter:\s*restarting/i.test(line)) {
+    return "Kernel restarted";
+  }
+  if (/\b(ERROR|CRITICAL)\b/.test(line)) {
+    const cleaned = line.replace(/^\[.*?\]\s*/, "").replace(/^\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\.\d+\s*/, "").replace(/^(ERROR|CRITICAL)\s*[|:]\s*/i, "").trim();
+    return cleaned || null;
+  }
+  return null;
+}
+
+// src/app.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
-function App({ token: token2, port: port2 }) {
+var MAX_EVENTS = 10;
+var LOGO = `                  ..
+                  .:
+                  .@.
+                  .@*
+                  .@@+.
+                  .@@@=
+                  .@@@@*
+                  .@@@@@@.
+                  .@@@@@@@#.
+                  .@@@@@@@@@@-.
+       .=@@@@@@@@@@.
+          .#@@@@@@@.
+            .@@@@@@.
+              *@@@@.
+               -@@@.
+               .+@@.
+                 *@.
+                 .@.
+                  :.
+                  ..`;
+function useUptime(startedAt) {
+  const [now, setNow] = useState(Date.now());
+  useEffect(() => {
+    if (startedAt === null) return;
+    const id = setInterval(() => setNow(Date.now()), 1e3);
+    return () => clearInterval(id);
+  }, [startedAt]);
+  if (startedAt === null) return "0s";
+  const elapsed = Math.max(0, Math.floor((now - startedAt) / 1e3));
+  const m = Math.floor(elapsed / 60);
+  const s = elapsed % 60;
+  return m > 0 ? `${m}m ${s}s` : `${s}s`;
+}
+function formatTime() {
+  const d = /* @__PURE__ */ new Date();
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+function App({ connectionCode: connectionCode2, port: port2 }) {
   const { exit } = useApp();
-  const [phase, setPhase] = useState({ step: "downloading" });
+  const [phase, setPhase] = useState(connectionCode2 ? "starting" : "prompting");
+  const [setupStep, setSetupStep] = useState(connectionCode2 ? "active" : "pending");
+  const [jupyterStep, setJupyterStep] = useState("pending");
+  const [tunnelStep, setTunnelStep] = useState("pending");
+  const [jupyterRunning, setJupyterRunning] = useState(false);
+  const [tunnelConnected, setTunnelConnected] = useState(false);
+  const [events, setEvents] = useState([]);
+  const [startedAt, setStartedAt] = useState(null);
+  const [error, setError] = useState(null);
+  const [tokenInput, setTokenInput] = useState("");
+  const [activeToken, setActiveToken] = useState(connectionCode2);
+  const didWeSpawnJupyter = useRef(false);
+  const jupyterProc = useRef(null);
+  const tunnelProc = useRef(null);
+  const cleanedUp = useRef(false);
+  const uptime = useUptime(startedAt);
+  const pushEvent = useCallback((message) => {
+    setEvents((prev) => {
+      const next = [...prev, { time: formatTime(), message }];
+      return next.length > MAX_EVENTS ? next.slice(-MAX_EVENTS) : next;
+    });
+  }, []);
+  useInput(
+    (input, key) => {
+      if (key.return) {
+        const trimmed = tokenInput.trim();
+        if (trimmed.length > 0) {
+          setActiveToken(trimmed);
+          setPhase("starting");
+          setSetupStep("active");
+        }
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setTokenInput((prev) => prev.slice(0, -1));
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        setTokenInput((prev) => prev + input.replace(/[\n\r\s]/g, ""));
+      }
+    },
+    { isActive: phase === "prompting" }
+  );
+  const restartJupyter = useCallback(() => {
+    if (jupyterProc.current) {
+      jupyterProc.current.kill("SIGTERM");
+      jupyterProc.current = null;
+    }
+    setJupyterRunning(false);
+    pushEvent("Restarting notebook server...");
+    const proc = startJupyter(port2);
+    jupyterProc.current = proc;
+    didWeSpawnJupyter.current = true;
+    let stderrBuf = "";
+    proc.stderr?.on("data", (data) => {
+      stderrBuf += data.toString();
+      const lines = stderrBuf.split("\n");
+      stderrBuf = lines.pop() ?? "";
+      for (const line of lines) {
+        const msg = parseJupyterLine(line);
+        if (msg) pushEvent(msg);
+      }
+    });
+    proc.on("error", () => {
+      setJupyterRunning(false);
+      pushEvent("Notebook server failed to start");
+    });
+    proc.on("exit", () => {
+      if (!cleanedUp.current) {
+        setJupyterRunning(false);
+        pushEvent("Notebook server stopped");
+      }
+    });
+    let attempts = 0;
+    const poll = setInterval(async () => {
+      attempts++;
+      const healthy = await checkJupyterHealth(port2);
+      if (healthy) {
+        clearInterval(poll);
+        setJupyterRunning(true);
+        pushEvent("Notebook server started");
+      } else if (attempts >= 20) {
+        clearInterval(poll);
+        pushEvent("Notebook server not responding");
+      }
+    }, 1e3);
+  }, [port2, pushEvent]);
+  useInput(
+    (_input, key) => {
+      if (_input === "r" || _input === "R") {
+        if (!key.ctrl && !key.meta) {
+          restartJupyter();
+        }
+      }
+    },
+    { isActive: phase === "ready" && !jupyterRunning }
+  );
+  const resetToPrompt = useCallback(() => {
+    setError(null);
+    setPhase("prompting");
+    setSetupStep("pending");
+    setJupyterStep("pending");
+    setTunnelStep("pending");
+    setTokenInput("");
+    setActiveToken(null);
+    setEvents([]);
+    setStartedAt(null);
+    setJupyterRunning(false);
+    setTunnelConnected(false);
+  }, []);
+  useInput(
+    (_input, key) => {
+      if (key.return) {
+        resetToPrompt();
+      }
+    },
+    { isActive: error !== null }
+  );
   useEffect(() => {
-    let killed = false;
+    if (phase !== "starting" || !activeToken) return;
+    let cancelled = 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], {
+      try {
+        await Promise.all([ensureCloudflared(), ensureRipgrep()]);
+      } catch {
+        if (cancelled) return;
+        setSetupStep("error");
+        setError({
+          message: "Could not set up required tools.",
+          hint: "Check your internet connection and try again."
+        });
+        return;
+      }
+      if (cancelled) return;
+      setSetupStep("done");
+      setJupyterStep("active");
+      const alreadyHealthy = await checkJupyterHealth(port2);
+      if (cancelled) return;
+      if (alreadyHealthy) {
+        setJupyterStep("done");
+        setJupyterRunning(true);
+        didWeSpawnJupyter.current = false;
+        pushEvent("Existing notebook server detected");
+      } else {
+        const pythonCmd = findPython();
+        if (!pythonCmd) {
+          setJupyterStep("error");
+          setError({
+            message: "Python 3 is not installed.",
+            hint: "Install Python 3.11+ from https://python.org and try again."
+          });
+          return;
+        }
+        if (!venvExists()) {
+          pushEvent("Creating Sharpe environment...");
+          try {
+            createVenv(pythonCmd);
+          } catch {
+            if (cancelled) return;
+            setJupyterStep("error");
+            setError({
+              message: "Could not create the Sharpe environment.",
+              hint: "Make sure Python 3.11+ is installed and try again."
+            });
+            return;
+          }
+        }
+        if (cancelled) return;
+        pushEvent("Installing Jupyter...");
+        const installResult = await new Promise((resolve) => {
+          const proc2 = installPackages(["jupyter", "jupyter-resource-usage", "sharpe-log-handler"]);
+          proc2.on("error", (err) => resolve(err.message));
+          proc2.on("exit", (code) => resolve(code === 0 ? null : "install-failed"));
+        });
+        if (cancelled) return;
+        if (installResult) {
+          setJupyterStep("error");
+          setError({
+            message: "Could not install Jupyter.",
+            hint: "Check your internet connection and try again."
+          });
+          return;
+        }
+        pushEvent("Jupyter installed");
+        const proc = startJupyter(port2);
+        jupyterProc.current = proc;
+        didWeSpawnJupyter.current = true;
+        const spawnError = await new Promise((resolve) => {
+          proc.on("error", (err) => resolve(err.message));
+          let stderrBuf = "";
+          proc.stderr?.on("data", (data) => {
+            stderrBuf += data.toString();
+            const lines = stderrBuf.split("\n");
+            stderrBuf = lines.pop() ?? "";
+            for (const line of lines) {
+              if (line.includes("Address already in use")) {
+                resolve("port-conflict");
+                return;
+              }
+              const msg = parseJupyterLine(line);
+              if (msg) pushEvent(msg);
+            }
+          });
+          let attempts = 0;
+          const poll = setInterval(async () => {
+            if (cancelled) {
+              clearInterval(poll);
+              resolve("cancelled");
+              return;
+            }
+            attempts++;
+            const healthy = await checkJupyterHealth(port2);
+            if (healthy) {
+              clearInterval(poll);
+              resolve(null);
+            } else if (attempts >= 20) {
+              clearInterval(poll);
+              resolve("timeout");
+            }
+          }, 1e3);
+        });
+        if (cancelled) return;
+        if (spawnError === "port-conflict") {
+          setJupyterStep("error");
+          setError({
+            message: "Could not start the notebook server.",
+            hint: `Port ${port2} is already in use.
+Close whatever is using it and try again, or use a different port:
+
+  npx @sharpe-jupyter/connect CODE --port ${port2 + 1}`
+          });
+          return;
+        }
+        if (spawnError === "timeout") {
+          setJupyterStep("error");
+          setError({
+            message: "The notebook server isn't responding.",
+            hint: `Try restarting or check if port ${port2} is available.`
+          });
+          return;
+        }
+        if (spawnError && spawnError !== "cancelled") {
+          setJupyterStep("error");
+          setError({
+            message: "Could not start the notebook server.",
+            hint: "Something went wrong starting Jupyter. Try running again."
+          });
+          return;
+        }
+        setJupyterRunning(true);
+        pushEvent("Notebook server started");
+      }
+      if (cancelled) return;
+      setJupyterStep("done");
+      setTunnelStep("active");
+      const binPath = getCloudflaredPath();
+      const tunnelChild = spawn2(binPath, ["tunnel", "run", "--token", activeToken], {
         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 });
-        }
+      tunnelProc.current = tunnelChild;
+      const tunnelResult = await new Promise((resolve) => {
+        let connectionCount = 0;
+        let resolved = false;
+        const timeout = setTimeout(() => {
+          if (!resolved) {
+            resolved = true;
+            resolve("timeout");
+          }
+        }, 3e4);
+        const handleData = (data) => {
+          const text = data.toString();
+          if (text.includes("Registered tunnel connection")) {
+            connectionCount++;
+            if (connectionCount === 1 && !resolved) {
+              resolved = true;
+              clearTimeout(timeout);
+              resolve(null);
+            }
+          }
+        };
+        tunnelChild.stderr?.on("data", handleData);
+        tunnelChild.stdout?.on("data", handleData);
+        tunnelChild.on("error", (err) => {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            resolve(err.message);
+          }
+        });
+        tunnelChild.on("exit", (code) => {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            resolve(code !== 0 ? "exit-nonzero" : null);
+          }
+        });
       });
-      child.stdout?.on("data", (data) => {
+      if (cancelled) return;
+      if (tunnelResult === "timeout") {
+        setTunnelStep("error");
+        setError({
+          message: "Could not connect to Sharpe.",
+          hint: "Check your internet connection and try again."
+        });
+        return;
+      }
+      if (tunnelResult === "exit-nonzero") {
+        setTunnelStep("error");
+        setError({
+          message: "Could not connect to Sharpe.",
+          hint: "Make sure your connection code is correct.\nGet a new code from the Sharpe dashboard."
+        });
+        return;
+      }
+      if (tunnelResult) {
+        setTunnelStep("error");
+        setError({ message: "Could not connect to Sharpe.", hint: tunnelResult });
+        return;
+      }
+      setTunnelStep("done");
+      setTunnelConnected(true);
+      pushEvent("Connected to Sharpe");
+      setPhase("ready");
+      setStartedAt(Date.now());
+      if (jupyterProc.current) {
+        jupyterProc.current.on("exit", () => {
+          if (!cleanedUp.current) {
+            setJupyterRunning(false);
+            pushEvent("Notebook server stopped");
+          }
+        });
+      }
+      let wasDisconnected = false;
+      const monitorTunnel = (data) => {
         const text = data.toString();
-        if (text.includes("Registered tunnel connection")) {
-          setPhase({ step: "connected", warning });
+        if (/Retrying|connection.*failed|ERR/i.test(text) && !wasDisconnected) {
+          wasDisconnected = true;
+          setTunnelConnected(false);
+          pushEvent("Connection interrupted, reconnecting...");
         }
-      });
-      child.on("error", (err) => {
-        if (!killed) {
-          setPhase({ step: "error", message: err.message });
-          exit();
+        if (text.includes("Registered tunnel connection") && wasDisconnected) {
+          wasDisconnected = false;
+          setTunnelConnected(true);
+          pushEvent("Reconnected to Sharpe");
         }
-      });
-      child.on("exit", (code) => {
-        if (!killed) {
-          if (code !== 0 && code !== null) {
-            setPhase({ step: "error", message: `cloudflared exited with code ${code}` });
-          }
-          exit();
+      };
+      tunnelChild.stderr?.on("data", monitorTunnel);
+      tunnelChild.stdout?.on("data", monitorTunnel);
+      tunnelChild.on("exit", () => {
+        if (!cleanedUp.current) {
+          setTunnelConnected(false);
+          pushEvent("Tunnel disconnected");
         }
       });
-      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: [
+    run();
+    const cleanup = () => {
+      cancelled = true;
+      cleanedUp.current = true;
+      setPhase("shutting-down");
+      if (didWeSpawnJupyter.current && jupyterProc.current) {
+        jupyterProc.current.kill("SIGTERM");
+      }
+      if (tunnelProc.current) {
+        tunnelProc.current.kill("SIGTERM");
+      }
+      setTimeout(() => {
+        exit();
+        process.exit(0);
+      }, 1500);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    return () => {
+      cancelled = true;
+      process.removeListener("SIGINT", cleanup);
+      process.removeListener("SIGTERM", cleanup);
+    };
+  }, [phase, activeToken, port2, exit, pushEvent]);
+  const overallStatus = !jupyterRunning && !tunnelConnected ? "offline" : !tunnelConnected ? "reconnecting" : !jupyterRunning ? "notebook-stopped" : "connected";
+  if (phase === "shutting-down") {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+      /* @__PURE__ */ jsx(Header, {}),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Shutting down..." }) })
+    ] });
+  }
+  if (phase === "prompting") {
+    const display = tokenInput.length > 50 ? `${tokenInput.slice(0, 20)}...${tokenInput.slice(-10)}` : tokenInput;
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+      /* @__PURE__ */ jsx(Header, {}),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { children: "Paste your connection code from the Sharpe dashboard:" }) }),
       /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx(Text, { color: "yellow", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
-        /* @__PURE__ */ jsx(Text, { children: " Establishing tunnel connection..." })
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "> " }),
+        tokenInput.length > 0 ? /* @__PURE__ */ jsxs(Text, { children: [
+          display,
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            " (",
+            tokenInput.length,
+            " chars)"
+          ] })
+        ] }) : /* @__PURE__ */ jsx(Text, { dimColor: true, children: "paste here and press Enter" })
+      ] })
+    ] });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+      /* @__PURE__ */ jsx(Header, {}),
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+        setupStep === "done" && /* @__PURE__ */ jsx(Step, { status: "done", label: "Setting up" }),
+        setupStep === "error" && /* @__PURE__ */ jsx(Step, { status: "error", label: "Setting up" }),
+        jupyterStep === "done" && /* @__PURE__ */ jsx(
+          Step,
+          {
+            status: "done",
+            label: "Notebook server running",
+            detail: `http://localhost:${port2}`
+          }
+        ),
+        jupyterStep === "error" && /* @__PURE__ */ jsx(Step, { status: "error", label: "Could not start notebook server" }),
+        tunnelStep === "error" && /* @__PURE__ */ jsx(Step, { status: "error", label: "Connecting to Sharpe" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx(Text, { color: "red", children: error.message }),
+        error.hint && /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: error.hint }) })
       ] }),
-      phase.warning && /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
-        /* @__PURE__ */ jsx(Text, { color: "yellow", children: "Warning: " }),
-        /* @__PURE__ */ jsx(Text, { dimColor: true, children: phase.warning })
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Press Enter to try again or Ctrl+C to quit." }) })
+    ] });
+  }
+  if (phase === "starting") {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+      /* @__PURE__ */ jsx(Header, {}),
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx(Step, { status: setupStep, label: "Setting up" }),
+        /* @__PURE__ */ jsx(
+          Step,
+          {
+            status: jupyterStep,
+            label: "Notebook server running",
+            detail: jupyterStep === "done" ? `http://localhost:${port2}` : void 0
+          }
+        ),
+        /* @__PURE__ */ jsx(Step, { status: tunnelStep, label: "Connecting to Sharpe" })
       ] })
-    ] }),
-    phase.step === "connected" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    ] });
+  }
+  const footerText = !jupyterRunning ? "Press R to restart notebook, or Ctrl+C to quit." : "Press Ctrl+C when you're done.";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx(Header, {}),
+    /* @__PURE__ */ jsx(Box, { justifyContent: "space-between", marginTop: 1, children: /* @__PURE__ */ jsx(StatusBadge, { status: overallStatus }) }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, 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: "Notebook    " }),
+        jupyterRunning ? /* @__PURE__ */ jsx(Text, { children: `http://localhost:${port2}` }) : /* @__PURE__ */ jsx(Text, { color: "red", children: "Not running" })
       ] }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Press Ctrl+C to disconnect" })
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Uptime      " }),
+        /* @__PURE__ */ jsx(Text, { children: uptime })
+      ] })
     ] }),
-    phase.step === "error" && /* @__PURE__ */ jsxs(Box, { children: [
-      /* @__PURE__ */ jsxs(Text, { color: "red", bold: true, children: [
-        "Error:",
-        " "
-      ] }),
-      /* @__PURE__ */ jsx(Text, { children: phase.message })
+    events.length > 0 && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\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\u2500\u2500\u2500\u2500\u2500\u2500" }),
+      events.map((evt, i) => /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          evt.time,
+          "  "
+        ] }),
+        /* @__PURE__ */ jsx(Text, { children: evt.message })
+      ] }, i))
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: footerText }) })
+  ] });
+}
+function Header() {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: LOGO }),
+    /* @__PURE__ */ jsx(Text, { bold: true, children: "Sharpe Connect" })
+  ] });
+}
+function Step({ status, label, detail }) {
+  const icon = status === "done" ? /* @__PURE__ */ jsx(Text, { color: "green", children: "v" }) : status === "active" ? /* @__PURE__ */ jsx(Text, { color: "yellow", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }) : status === "error" ? /* @__PURE__ */ jsx(Text, { color: "red", children: "x" }) : status === "skipped" ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "-" }) : /* @__PURE__ */ jsx(Text, { dimColor: true, children: "." });
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    icon,
+    /* @__PURE__ */ jsxs(Text, { children: [
+      " ",
+      label
+    ] }),
+    detail && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "  ",
+      detail
     ] })
   ] });
 }
+function StatusBadge({ status }) {
+  switch (status) {
+    case "connected":
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "green", children: "\u25CF " }),
+        /* @__PURE__ */ jsx(Text, { color: "green", children: "Connected" })
+      ] });
+    case "reconnecting":
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "yellow", children: "\u25CF " }),
+        /* @__PURE__ */ jsx(Text, { color: "yellow", children: "Reconnecting..." })
+      ] });
+    case "notebook-stopped":
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "yellow", children: "\u25CF " }),
+        /* @__PURE__ */ jsx(Text, { color: "yellow", children: "Notebook stopped" })
+      ] });
+    case "offline":
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "red", children: "\u25CF " }),
+        /* @__PURE__ */ jsx(Text, { color: "red", children: "Offline" })
+      ] });
+  }
+}
+
+// src/index.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
 function parseArgs(argv) {
   const args = argv.slice(2);
-  let token2;
-  let port2 = 8e3;
+  let connectionCode2 = null;
+  let port2 = 8888;
   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") {
+    if (arg === "--help" || arg === "-h") {
       console.log(`
-Usage: sharpe-connect --token <TOKEN> [--port <PORT>]
+Usage: sharpe-connect [connection-code] [options]
 
 Options:
-  --token, -t  Tunnel token from Sharpe dashboard (required)
-  --port, -p   Local JupyterHub port (default: 8000)
-  --help, -h   Show this help message
+  --port, -p   Notebook port (default: 8888)
+  --help, -h   Show help
 `);
       process.exit(0);
     }
+    if ((arg === "--port" || arg === "-p") && args[i + 1]) {
+      port2 = parseInt(args[++i], 10);
+      continue;
+    }
+    if (!arg.startsWith("-") && connectionCode2 === null) {
+      connectionCode2 = arg;
+    }
   }
-  if (!token2) {
-    console.error("Error: --token is required. Run with --help for usage.");
-    process.exit(1);
-  }
-  return { token: token2, port: port2 };
+  return { connectionCode: connectionCode2, port: port2 };
 }
-var { token, port } = parseArgs(process.argv);
-render(/* @__PURE__ */ jsx(App, { token, port }));
+var { connectionCode, port } = parseArgs(process.argv);
+render(/* @__PURE__ */ jsx2(App, { connectionCode, port }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sharpe-jupyter/connect",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Connect a local JupyterHub to Sharpe via Cloudflare Tunnel",
   "type": "module",
   "bin": {