@sharpe-jupyter/connect 0.4.2 → 0.4.4

package/dist/index.js

@@ -2,6 +2,8 @@
 
 // src/index.tsx
 import { render } from "ink";
+import { readFileSync, writeFileSync, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
 
 // src/app.tsx
 import { useState, useEffect, useRef, useCallback } from "react";
@@ -333,6 +335,7 @@ function parseJupyterLine(line) {
 // src/app.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 var MAX_EVENTS = 10;
+var MAX_PROCESS_LOGS = 12;
 var LOGO = `                  ..
                   .:
                   .@.
@@ -386,11 +389,23 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
   const [depsPrompt, setDepsPrompt] = useState(null);
   const [depsStatus, setDepsStatus] = useState(null);
   const depsResolverRef = useRef(null);
+  const [processLogs, setProcessLogs] = useState([]);
   const didWeSpawnJupyter = useRef(false);
   const jupyterProc = useRef(null);
   const tunnelProc = useRef(null);
   const cleanedUp = useRef(false);
+  const processLogsRef = useRef([]);
   const uptime = useUptime(startedAt);
+  const pushProcessLog = useCallback((line) => {
+    const trimmed = line.trimEnd();
+    if (!trimmed) return;
+    setProcessLogs((prev) => {
+      const next = [...prev, trimmed];
+      const sliced = next.length > MAX_PROCESS_LOGS ? next.slice(-MAX_PROCESS_LOGS) : next;
+      processLogsRef.current = sliced;
+      return sliced;
+    });
+  }, []);
   const pushEvent = useCallback((message) => {
     setEvents((prev) => {
       const next = [...prev, { time: formatTime(), message }];
@@ -439,20 +454,15 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
       jupyterProc.current = null;
     }
     setJupyterRunning(false);
+    setProcessLogs([]);
+    processLogsRef.current = [];
     pushEvent("Restarting notebook server...");
     const proc = isUvProject() ? startJupyterWithUv(port2, getUvPath()) : 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);
-      }
-    });
+    const pipeStream = createStreamPiper(pushProcessLog, pushEvent);
+    pipeStream(proc.stderr);
+    pipeStream(proc.stdout);
     proc.on("error", () => {
       setJupyterRunning(false);
       pushEvent("Notebook server failed to start");
@@ -471,12 +481,12 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
         clearInterval(poll);
         setJupyterRunning(true);
         pushEvent("Notebook server started");
-      } else if (attempts >= 20) {
+      } else if (attempts >= 40) {
         clearInterval(poll);
         pushEvent("Notebook server not responding");
       }
     }, 1e3);
-  }, [port2, pushEvent]);
+  }, [port2, pushEvent, pushProcessLog]);
   useInput(
     (_input, key) => {
       if (_input === "r" || _input === "R") {
@@ -501,6 +511,8 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
     setTunnelConnected(false);
     setDepsPrompt(null);
     setDepsStatus(null);
+    setProcessLogs([]);
+    processLogsRef.current = [];
     depsResolverRef.current?.(false);
     depsResolverRef.current = null;
   }, []);
@@ -543,9 +555,15 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
         const proc = startJupyterWithUv(port2, uvPath);
         jupyterProc.current = proc;
         didWeSpawnJupyter.current = true;
-        const spawnError = await waitForJupyterHealthy(proc, port2, pushEvent, () => cancelled);
+        const spawnError = await waitForJupyterHealthy(
+          proc,
+          port2,
+          pushEvent,
+          pushProcessLog,
+          () => cancelled
+        );
         if (cancelled) return;
-        const errorInfo = handleJupyterSpawnError(spawnError, port2);
+        const errorInfo = handleJupyterSpawnError(spawnError, port2, processLogsRef.current);
         if (errorInfo) {
           setJupyterStep("error");
           setError(errorInfo);
@@ -629,9 +647,15 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
         const proc = startJupyter(port2);
         jupyterProc.current = proc;
         didWeSpawnJupyter.current = true;
-        const spawnError = await waitForJupyterHealthy(proc, port2, pushEvent, () => cancelled);
+        const spawnError = await waitForJupyterHealthy(
+          proc,
+          port2,
+          pushEvent,
+          pushProcessLog,
+          () => cancelled
+        );
         if (cancelled) return;
-        const errorInfo = handleJupyterSpawnError(spawnError, port2);
+        const errorInfo = handleJupyterSpawnError(spawnError, port2, processLogsRef.current);
         if (errorInfo) {
           setJupyterStep("error");
           setError(errorInfo);
@@ -819,6 +843,7 @@ function App({ connectionCode: connectionCode2, port: port2 }) {
         ),
         /* @__PURE__ */ jsx(Step, { status: tunnelStep, label: "Connecting to Sharpe" })
       ] }),
+      processLogs.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: processLogs.map((line, i) => /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "truncate", children: line }, i)) }),
       depsPrompt && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
         /* @__PURE__ */ jsxs(Text, { children: [
           "Found ",
@@ -904,43 +929,69 @@ function StatusBadge({ status }) {
       ] });
   }
 }
-function waitForJupyterHealthy(proc, port2, pushEvent, isCancelled) {
+function waitForJupyterHealthy(proc, port2, pushEvent, pushLog, 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 resolved = false;
+    const done = (result) => {
+      if (resolved) return;
+      resolved = true;
+      clearInterval(poll);
+      resolve(result);
+    };
+    proc.on("error", (err) => done(err.message));
+    proc.on("exit", (code, signal) => {
+      if (code !== null && code !== 0) {
+        done(`exit-${code}`);
+      } else if (signal) {
+        done(`signal-${signal}`);
+      }
+    });
+    const pipeOutput = createStreamPiper(pushLog, pushEvent, (line) => {
+      if (line.includes("Address already in use")) {
+        done("port-conflict");
+        return true;
       }
     });
+    pipeOutput(proc.stderr);
+    pipeOutput(proc.stdout);
     let attempts = 0;
     const poll = setInterval(async () => {
       if (isCancelled()) {
-        clearInterval(poll);
-        resolve("cancelled");
+        done("cancelled");
         return;
       }
       attempts++;
       const healthy = await checkJupyterHealth(port2);
       if (healthy) {
-        clearInterval(poll);
-        resolve(null);
-      } else if (attempts >= 20) {
-        clearInterval(poll);
-        resolve("timeout");
+        done(null);
+      } else if (attempts >= 40) {
+        done("timeout");
       }
     }, 1e3);
   });
 }
-function handleJupyterSpawnError(spawnError, port2) {
+function createStreamPiper(pushLog, pushEvent, onLine) {
+  return (stream) => {
+    if (!stream) return;
+    let buf = "";
+    stream.on("data", (data) => {
+      buf += data.toString();
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const line of lines) {
+        pushLog(line);
+        if (onLine?.(line)) return;
+        const msg = parseJupyterLine(line);
+        if (msg) pushEvent(msg);
+      }
+    });
+  };
+}
+function handleJupyterSpawnError(spawnError, port2, lastLogs) {
+  const logTail = lastLogs.length > 0 ? `
+
+Process output:
+${lastLogs.slice(-8).join("\n")}` : "";
   if (spawnError === "port-conflict") {
     return {
       message: "Could not start the notebook server.",
@@ -953,13 +1004,20 @@ Close whatever is using it and try again, or use a different port:
   if (spawnError === "timeout") {
     return {
       message: "The notebook server isn't responding.",
-      hint: `Try restarting or check if port ${port2} is available.`
+      hint: `Waited 40s but http://localhost:${port2}/api/status never returned OK.${logTail}`
+    };
+  }
+  if (spawnError?.startsWith("exit-")) {
+    const code = spawnError.slice(5);
+    return {
+      message: `Notebook server process exited with code ${code}.`,
+      hint: logTail || "No output was captured from the process."
     };
   }
   if (spawnError && spawnError !== "cancelled") {
     return {
       message: "Could not start the notebook server.",
-      hint: "Something went wrong starting Jupyter. Try running again."
+      hint: `${spawnError}${logTail}`
     };
   }
   return null;
@@ -967,6 +1025,70 @@ Close whatever is using it and try again, or use a different port:
 
 // src/index.tsx
 import { jsx as jsx2 } from "react/jsx-runtime";
+function getConfigDir() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return join5(home, ".sharpe");
+}
+function getConfigPath() {
+  return join5(getConfigDir(), "config.json");
+}
+function loadSavedToken() {
+  try {
+    const raw = readFileSync(getConfigPath(), "utf-8");
+    const config = JSON.parse(raw);
+    return config.connectionCode ?? null;
+  } catch {
+    return null;
+  }
+}
+function saveToken(token) {
+  try {
+    mkdirSync4(getConfigDir(), { recursive: true });
+    const config = { connectionCode: token };
+    writeFileSync(getConfigPath(), JSON.stringify(config, null, 2) + "\n");
+  } catch {
+  }
+}
+function ensureShellAlias() {
+  const home = process.env.HOME;
+  if (!home) return;
+  const shell = process.env.SHELL ?? "";
+  let rcFile;
+  if (shell.endsWith("/zsh")) {
+    rcFile = join5(home, ".zshrc");
+  } else if (shell.endsWith("/bash")) {
+    const bashrc = join5(home, ".bashrc");
+    rcFile = existsSync5(bashrc) ? bashrc : join5(home, ".bash_profile");
+  } else {
+    return;
+  }
+  const aliasLine = 'alias sharpe="npx @sharpe-jupyter/connect@latest"';
+  try {
+    const contents = readFileSync(rcFile, "utf-8");
+    if (contents.includes("alias sharpe=")) return;
+  } catch {
+  }
+  try {
+    writeFileSync(rcFile, readFileSync(rcFile, "utf-8").trimEnd() + `
+
+# Sharpe CLI
+${aliasLine}
+`, "utf-8");
+    console.log(`Added "sharpe" alias to ${rcFile}`);
+    console.log(`Restart your terminal or run: source ${rcFile}
+`);
+  } catch {
+    try {
+      writeFileSync(rcFile, `# Sharpe CLI
+${aliasLine}
+`, "utf-8");
+      console.log(`Added "sharpe" alias to ${rcFile}`);
+      console.log(`Restart your terminal or run: source ${rcFile}
+`);
+    } catch {
+    }
+  }
+}
 function parseArgs(argv) {
   const args = argv.slice(2);
   let connectionCode2 = null;
@@ -975,7 +1097,10 @@ function parseArgs(argv) {
     const arg = args[i];
     if (arg === "--help" || arg === "-h") {
       console.log(`
-Usage: sharpe-connect [connection-code] [options]
+Usage: sharpe [connection-code] [options]
+
+  If a connection code is provided, it is saved to ~/.sharpe/config.json
+  for future use. Run "sharpe" with no arguments to reuse the saved code.
 
 Options:
   --port, -p   Notebook port (default: 8888)
@@ -993,5 +1118,12 @@ Options:
   }
   return { connectionCode: connectionCode2, port: port2 };
 }
-var { connectionCode, port } = parseArgs(process.argv);
+var { connectionCode: cliToken, port } = parseArgs(process.argv);
+var connectionCode = cliToken;
+if (connectionCode) {
+  saveToken(connectionCode);
+  ensureShellAlias();
+} else {
+  connectionCode = loadSavedToken();
+}
 render(/* @__PURE__ */ jsx2(App, { connectionCode, port }));

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@sharpe-jupyter/connect",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Connect a local JupyterHub to Sharpe via Cloudflare Tunnel",
   "type": "module",
   "bin": {
+    "sharpe": "dist/index.js",
     "sharpe-connect": "dist/index.js"
   },
   "files": [