@sharpe-jupyter/connect 0.3.3 → 0.4.0

package/dist/index.js

@@ -130,6 +130,61 @@ async function ensureRipgrep() {
   return { path: binPath, downloaded: true };
 }
 
+// src/uv.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, chmodSync as chmodSync3, unlinkSync as unlinkSync3, createWriteStream as createWriteStream3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3, arch as arch3, platform as platform3 } from "os";
+import { pipeline as pipeline3 } from "stream/promises";
+import { Readable as Readable3 } from "stream";
+import { execSync as execSync3 } from "child_process";
+var UV_VERSION = "0.10.4";
+function getAssetName2() {
+  const os = platform3();
+  const cpu = arch3();
+  if (os === "darwin") {
+    const triple = cpu === "arm64" ? "aarch64-apple-darwin" : "x86_64-apple-darwin";
+    return `uv-${triple}.tar.gz`;
+  }
+  if (os === "linux") {
+    const triple = cpu === "arm64" ? "aarch64-unknown-linux-gnu" : "x86_64-unknown-linux-gnu";
+    return `uv-${triple}.tar.gz`;
+  }
+  throw new Error(`Unsupported platform: ${os}/${cpu}`);
+}
+function getBinDir3() {
+  return join3(homedir3(), ".sharpe", "bin");
+}
+function getUvPath() {
+  return join3(getBinDir3(), "uv");
+}
+async function ensureUv() {
+  const binPath = getUvPath();
+  if (existsSync3(binPath)) {
+    return { path: binPath, downloaded: false };
+  }
+  const binDir = getBinDir3();
+  mkdirSync3(binDir, { recursive: true });
+  const assetName = getAssetName2();
+  const url = `https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/${assetName}`;
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok || !response.body) {
+    throw new Error(`Failed to download uv: ${response.status} ${response.statusText}`);
+  }
+  const tgzPath = join3(binDir, assetName);
+  const fileStream = createWriteStream3(tgzPath);
+  await pipeline3(
+    Readable3.fromWeb(response.body),
+    fileStream
+  );
+  const dirName = assetName.replace(".tar.gz", "");
+  execSync3(`tar -xzf "${tgzPath}" -C "${binDir}" "${dirName}/uv"`, { stdio: "ignore" });
+  execSync3(`mv "${join3(binDir, dirName, "uv")}" "${binPath}"`, { stdio: "ignore" });
+  unlinkSync3(tgzPath);
+  execSync3(`rm -rf "${join3(binDir, dirName)}"`, { stdio: "ignore" });
+  chmodSync3(binPath, 493);
+  return { path: binPath, downloaded: true };
+}
+
 // src/health.ts
 async function checkJupyterHealth(port2) {
   try {
@@ -143,22 +198,22 @@ async function checkJupyterHealth(port2) {
 }
 
 // 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 platform3 } 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 = platform3() === "win32";
+import { execSync as execSync4, spawn } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4, platform as platform4 } from "os";
+var SHARPE_DIR = join4(homedir4(), ".sharpe");
+var VENV_DIR = join4(SHARPE_DIR, "venv");
+var SHARPE_BIN_DIR = join4(SHARPE_DIR, "bin");
+var IS_WIN = platform4() === "win32";
 var BIN_DIR = IS_WIN ? "Scripts" : "bin";
 function venvBin(name) {
-  return join3(VENV_DIR, BIN_DIR, IS_WIN ? `${name}.exe` : name);
+  return join4(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();
+      const version = execSync4(`${cmd} --version`, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
       if (version.startsWith("Python 3")) return cmd;
     } catch {
     }
@@ -166,10 +221,10 @@ function findPython() {
   return null;
 }
 function venvExists() {
-  return existsSync3(venvBin("python"));
+  return existsSync4(venvBin("python"));
 }
 function createVenv(pythonCmd) {
-  execSync3(`${pythonCmd} -m venv "${VENV_DIR}"`, { stdio: "ignore" });
+  execSync4(`${pythonCmd} -m venv "${VENV_DIR}"`, { stdio: "ignore" });
 }
 function installPackages(packages) {
   return spawn(venvBin("pip"), ["install", "--quiet", ...packages], {
@@ -194,6 +249,56 @@ function startJupyter(port2) {
     { stdio: ["ignore", "pipe", "pipe"], env }
   );
 }
+function isUvProject() {
+  return existsSync4(join4(process.cwd(), "uv.lock"));
+}
+function startJupyterWithUv(port2, uvBin) {
+  const env = { ...process.env, PATH: `${SHARPE_BIN_DIR}:${process.env.PATH ?? ""}` };
+  return spawn(
+    uvBin,
+    [
+      "run",
+      "--with",
+      "jupyter",
+      "--with",
+      "jupyter-resource-usage",
+      "--with",
+      "sharpe-log-handler>=0.3.0",
+      "jupyter",
+      "notebook",
+      "--port",
+      String(port2),
+      "--no-browser",
+      "--ServerApp.token=",
+      "--ServerApp.password=",
+      "--ServerApp.allow_remote_access=True",
+      "--ServerApp.disable_check_xsrf=True",
+      `--ServerApp.root_dir=${process.cwd()}`
+    ],
+    { stdio: ["ignore", "pipe", "pipe"], env }
+  );
+}
+function detectProjectDeps() {
+  const cwd = process.cwd();
+  const reqTxt = join4(cwd, "requirements.txt");
+  if (existsSync4(reqTxt)) {
+    return { file: "requirements.txt", installArgs: ["-r", reqTxt] };
+  }
+  const pyproject = join4(cwd, "pyproject.toml");
+  if (existsSync4(pyproject)) {
+    return { file: "pyproject.toml", installArgs: ["-e", cwd] };
+  }
+  const setupPy = join4(cwd, "setup.py");
+  if (existsSync4(setupPy)) {
+    return { file: "setup.py", installArgs: ["-e", cwd] };
+  }
+  return null;
+}
+function installProjectDeps(deps) {
+  return spawn(venvBin("pip"), ["install", ...deps.installArgs], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+}
 function parseJupyterLine(line) {
   if (/Saving file at\s+(\S+)/.test(line)) {
     const match = line.match(/Saving file at\s+(\S+)/);
@@ -268,6 +373,9 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
   const [error, setError] = useState(null);
   const [tokenInput, setTokenInput] = useState("");
   const [activeToken, setActiveToken] = useState(connectionCode2);
+  const [depsPrompt, setDepsPrompt] = useState(null);
+  const [depsStatus, setDepsStatus] = useState(null);
+  const depsResolverRef = useRef(null);
   const didWeSpawnJupyter = useRef(false);
   const jupyterProc = useRef(null);
   const tunnelProc = useRef(null);
@@ -300,6 +408,21 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
     },
     { isActive: phase === "prompting" }
   );
+  useInput(
+    (input, key) => {
+      if (key.return || input === "y" || input === "Y") {
+        depsResolverRef.current?.(true);
+        depsResolverRef.current = null;
+        return;
+      }
+      if (input === "n" || input === "N") {
+        depsResolverRef.current?.(false);
+        depsResolverRef.current = null;
+        return;
+      }
+    },
+    { isActive: depsPrompt !== null }
+  );
   const restartJupyter = useCallback(() => {
     if (jupyterProc.current) {
       jupyterProc.current.kill("SIGTERM");
@@ -307,7 +430,7 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
     }
     setJupyterRunning(false);
     pushEvent("Restarting notebook server...");
-    const proc = startJupyter(port2);
+    const proc = isUvProject() ? startJupyterWithUv(port2, getUvPath()) : startJupyter(port2);
     jupyterProc.current = proc;
     didWeSpawnJupyter.current = true;
     let stderrBuf = "";
@@ -366,6 +489,10 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
     setStartedAt(null);
     setJupyterRunning(false);
     setTunnelConnected(false);
+    setDepsPrompt(null);
+    setDepsStatus(null);
+    depsResolverRef.current?.(false);
+    depsResolverRef.current = null;
   }, []);
   useInput(
     (_input, key) => {
@@ -380,7 +507,7 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
     let cancelled = false;
     async function run() {
       try {
-        await Promise.all([ensureCloudflared(), ensureRipgrep()]);
+        await Promise.all([ensureCloudflared(), ensureRipgrep(), ensureUv()]);
       } catch {
         if (cancelled) return;
         setSetupStep("error");
@@ -400,6 +527,22 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
         setJupyterRunning(true);
         didWeSpawnJupyter.current = false;
         pushEvent("Existing notebook server detected");
+      } else if (isUvProject()) {
+        pushEvent("Installing dependencies and starting notebook...");
+        const uvPath = getUvPath();
+        const proc = startJupyterWithUv(port2, uvPath);
+        jupyterProc.current = proc;
+        didWeSpawnJupyter.current = true;
+        const spawnError = await waitForJupyterHealthy(proc, port2, pushEvent, () => cancelled);
+        if (cancelled) return;
+        const errorInfo = handleJupyterSpawnError(spawnError, port2);
+        if (errorInfo) {
+          setJupyterStep("error");
+          setError(errorInfo);
+          return;
+        }
+        setJupyterRunning(true);
+        pushEvent("Notebook server started");
       } else {
         const pythonCmd = findPython();
         if (!pythonCmd) {
@@ -427,7 +570,11 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
         if (cancelled) return;
         pushEvent("Installing Jupyter...");
         const installResult = await new Promise((resolve) => {
-          const proc2 = installPackages(["jupyter", "jupyter-resource-usage", "sharpe-log-handler>=0.3.0"]);
+          const proc2 = installPackages([
+            "jupyter",
+            "jupyter-resource-usage",
+            "sharpe-log-handler>=0.3.0"
+          ]);
           proc2.on("error", (err) => resolve(err.message));
           proc2.on("exit", (code) => resolve(code === 0 ? null : "install-failed"));
         });
@@ -441,69 +588,43 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
           return;
         }
         pushEvent("Jupyter installed");
+        const detected = detectProjectDeps();
+        if (detected && !cancelled) {
+          setDepsPrompt({ file: detected.file });
+          const shouldInstall = await new Promise((resolve) => {
+            depsResolverRef.current = resolve;
+          });
+          setDepsPrompt(null);
+          if (cancelled) return;
+          if (shouldInstall) {
+            setDepsStatus(`Installing from ${detected.file} using pip...`);
+            pushEvent(`Installing from ${detected.file}...`);
+            const depsResult = await new Promise((resolve) => {
+              const depsProc = installProjectDeps(detected);
+              depsProc.on("error", (err) => resolve(err.message));
+              depsProc.on("exit", (code) => resolve(code === 0 ? null : "deps-install-failed"));
+            });
+            setDepsStatus(null);
+            if (cancelled) return;
+            if (depsResult) {
+              pushEvent(`Warning: failed to install from ${detected.file} (continuing anyway)`);
+            } else {
+              pushEvent(`Installed dependencies from ${detected.file}`);
+            }
+          } else {
+            pushEvent("Skipped dependency installation");
+          }
+        }
+        if (cancelled) return;
         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);
-        });
+        const spawnError = await waitForJupyterHealthy(proc, port2, pushEvent, () => cancelled);
         if (cancelled) return;
-        if (spawnError === "port-conflict") {
+        const errorInfo = handleJupyterSpawnError(spawnError, port2);
+        if (errorInfo) {
           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."
-          });
+          setError(errorInfo);
           return;
         }
         setJupyterRunning(true);
@@ -601,6 +722,8 @@ Close whatever is using it and try again, or use a different port:
       cancelled = true;
       cleanedUp.current = true;
       setPhase("shutting-down");
+      depsResolverRef.current?.(false);
+      depsResolverRef.current = null;
       if (didWeSpawnJupyter.current && jupyterProc.current) {
         jupyterProc.current.kill("SIGTERM");
       }
@@ -616,6 +739,8 @@ Close whatever is using it and try again, or use a different port:
     process.on("SIGTERM", cleanup);
     return () => {
       cancelled = true;
+      depsResolverRef.current?.(false);
+      depsResolverRef.current = null;
       process.removeListener("SIGINT", cleanup);
       process.removeListener("SIGTERM", cleanup);
     };
@@ -683,7 +808,19 @@ Close whatever is using it and try again, or use a different port:
           }
         ),
         /* @__PURE__ */ jsx(Step, { status: tunnelStep, label: "Connecting to Sharpe" })
-      ] })
+      ] }),
+      depsPrompt && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          "Found ",
+          /* @__PURE__ */ jsx(Text, { bold: true, children: depsPrompt.file }),
+          " in this directory."
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          "Install dependencies? ",
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[Y/n]" })
+        ] })
+      ] }),
+      depsStatus && /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: depsStatus }) })
     ] });
   }
   const footerText = !jupyterRunning ? "Press R to restart notebook, or Ctrl+C to quit." : "Press Ctrl+C when you're done.";
@@ -757,6 +894,66 @@ function StatusBadge({ status }) {
       ] });
   }
 }
+function waitForJupyterHealthy(proc, port2, pushEvent, isCancelled) {
+  return 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 (isCancelled()) {
+        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);
+  });
+}
+function handleJupyterSpawnError(spawnError, port2) {
+  if (spawnError === "port-conflict") {
+    return {
+      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}`
+    };
+  }
+  if (spawnError === "timeout") {
+    return {
+      message: "The notebook server isn't responding.",
+      hint: `Try restarting or check if port ${port2} is available.`
+    };
+  }
+  if (spawnError && spawnError !== "cancelled") {
+    return {
+      message: "Could not start the notebook server.",
+      hint: "Something went wrong starting Jupyter. Try running again."
+    };
+  }
+  return null;
+}
 
 // src/index.tsx
 import { jsx as jsx2 } from "react/jsx-runtime";

package/package.json

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