@sharpe-jupyter/connect 0.3.4 → 0.4.1

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], {
@@ -189,41 +244,59 @@ function startJupyter(port2) {
       "--ServerApp.password=",
       "--ServerApp.allow_remote_access=True",
       "--ServerApp.disable_check_xsrf=True",
+      "--ContentsManager.allow_hidden=True",
       `--ServerApp.root_dir=${process.cwd()}`
     ],
     { stdio: ["ignore", "pipe", "pipe"], env }
   );
 }
-function findUv() {
-  try {
-    execSync3("uv --version", { stdio: ["ignore", "pipe", "ignore"] });
-    return true;
-  } catch {
-    return false;
-  }
+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",
+      "--ContentsManager.allow_hidden=True",
+      `--ServerApp.root_dir=${process.cwd()}`
+    ],
+    { stdio: ["ignore", "pipe", "pipe"], env }
+  );
 }
 function detectProjectDeps() {
   const cwd = process.cwd();
-  const reqTxt = join3(cwd, "requirements.txt");
-  if (existsSync3(reqTxt)) {
+  const reqTxt = join4(cwd, "requirements.txt");
+  if (existsSync4(reqTxt)) {
     return { file: "requirements.txt", installArgs: ["-r", reqTxt] };
   }
-  const pyproject = join3(cwd, "pyproject.toml");
-  if (existsSync3(pyproject)) {
+  const pyproject = join4(cwd, "pyproject.toml");
+  if (existsSync4(pyproject)) {
     return { file: "pyproject.toml", installArgs: ["-e", cwd] };
   }
-  const setupPy = join3(cwd, "setup.py");
-  if (existsSync3(setupPy)) {
+  const setupPy = join4(cwd, "setup.py");
+  if (existsSync4(setupPy)) {
     return { file: "setup.py", installArgs: ["-e", cwd] };
   }
   return null;
 }
-function installProjectDeps(deps, useUv) {
-  if (useUv) {
-    return spawn("uv", ["pip", "install", "--python", venvBin("python"), ...deps.installArgs], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-  }
+function installProjectDeps(deps) {
   return spawn(venvBin("pip"), ["install", ...deps.installArgs], {
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -359,7 +432,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 = "";
@@ -436,7 +509,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");
@@ -456,6 +529,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) {
@@ -503,19 +592,17 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
         pushEvent("Jupyter installed");
         const detected = detectProjectDeps();
         if (detected && !cancelled) {
-          const useUv = findUv();
-          setDepsPrompt({ file: detected.file, useUv });
+          setDepsPrompt({ file: detected.file });
           const shouldInstall = await new Promise((resolve) => {
             depsResolverRef.current = resolve;
           });
           setDepsPrompt(null);
           if (cancelled) return;
           if (shouldInstall) {
-            const toolLabel = useUv ? "uv" : "pip";
-            setDepsStatus(`Installing from ${detected.file} using ${toolLabel}...`);
+            setDepsStatus(`Installing from ${detected.file} using pip...`);
             pushEvent(`Installing from ${detected.file}...`);
             const depsResult = await new Promise((resolve) => {
-              const depsProc = installProjectDeps(detected, useUv);
+              const depsProc = installProjectDeps(detected);
               depsProc.on("error", (err) => resolve(err.message));
               depsProc.on("exit", (code) => resolve(code === 0 ? null : "deps-install-failed"));
             });
@@ -534,66 +621,12 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
         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") {
-          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") {
+        const errorInfo = handleJupyterSpawnError(spawnError, port2);
+        if (errorInfo) {
           setJupyterStep("error");
-          setError({
-            message: "Could not start the notebook server.",
-            hint: "Something went wrong starting Jupyter. Try running again."
-          });
+          setError(errorInfo);
           return;
         }
         setJupyterRunning(true);
@@ -785,9 +818,7 @@ Close whatever is using it and try again, or use a different port:
           " in this directory."
         ] }),
         /* @__PURE__ */ jsxs(Text, { children: [
-          "Install dependencies",
-          depsPrompt.useUv ? " using uv" : "",
-          "? ",
+          "Install dependencies? ",
           /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[Y/n]" })
         ] })
       ] }),
@@ -865,6 +896,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.4",
+  "version": "0.4.1",
   "description": "Connect a local JupyterHub to Sharpe via Cloudflare Tunnel",
   "type": "module",
   "bin": {