myjsbook 1.0.0

package/src/cli.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { exec } from "node:child_process";
+
+import { startServer } from "./server.js";
+
+/**
+ * Opens the given URL in the default system browser.
+ * Works on macOS, Windows, and Linux.
+ */
+function openBrowser(url) {
+  const platform = process.platform;
+  let command;
+
+  if (platform === "darwin") {
+    command = `open "${url}"`;
+  } else if (platform === "win32") {
+    command = `start "" "${url}"`;
+  } else {
+    command = `xdg-open "${url}"`;
+  }
+
+  exec(command, (error) => {
+    if (error) {
+      // Non-fatal: just print a hint so the user can open manually
+      process.stdout.write(`  Tip: Open your browser at: ${url}\n`);
+    }
+  });
+}
+
+function parseArgs(argv) {
+  const options = {
+    workspaceRoot: process.cwd(),
+    port: Number(process.env.PORT || 3113),
+    openBrowser: true
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    // "start" is the primary subcommand — it is the default action, so just skip it
+    if (arg === "start") {
+      continue;
+    }
+
+    if (arg === "--port" || arg === "-p") {
+      const nextValue = argv[index + 1];
+      if (!nextValue) {
+        throw new Error("Missing value for --port");
+      }
+      options.port = Number(nextValue);
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--workspace" || arg === "-w") {
+      const nextValue = argv[index + 1];
+      if (!nextValue) {
+        throw new Error("Missing value for --workspace");
+      }
+      options.workspaceRoot = path.resolve(nextValue);
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--no-open") {
+      options.openBrowser = false;
+      continue;
+    }
+
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+
+    if (!arg.startsWith("-")) {
+      // Positional argument treated as workspace path
+      options.workspaceRoot = path.resolve(arg);
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  if (!Number.isFinite(options.port) || options.port <= 0) {
+    throw new Error("Port must be a positive number");
+  }
+
+  return options;
+}
+
+function printHelp() {
+  process.stdout.write(
+    [
+      "marsbook — local JavaScript/TypeScript notebook server",
+      "",
+      "Usage: marsbook start [options]",
+      "",
+      "Commands:",
+      "  start             Start the notebook server and open the browser (default)",
+      "",
+      "Options:",
+      "  -p, --port        Port to bind the server on (default: 3113)",
+      "  -w, --workspace   Workspace directory — where your .ijsnb files live",
+      "                    (default: current working directory)",
+      "      --no-open     Skip opening the browser automatically",
+      "  -h, --help        Show this help message",
+      "",
+      "Examples:",
+      "  marsbook start",
+      "  marsbook start --port 4000",
+      "  marsbook start --workspace ~/my-notebooks",
+      "  marsbook start --no-open"
+    ].join("\n") + "\n"
+  );
+}
+
+
+function printBanner(serverUrl, workspaceRoot) {
+  // Colors
+  const O  = "\x1b[38;5;208m";  // mars orange
+  const OR = "\x1b[38;5;202m";  // dark orange / red-orange
+  const R  = "\x1b[38;5;196m";  // red
+  const W  = "\x1b[97m";        // bright white
+  const G  = "\x1b[38;5;82m";   // green (for URL)
+  const C  = "\x1b[38;5;117m";  // cyan (for workspace)
+  const D  = "\x1b[2m";         // dim
+  const B  = "\x1b[1m";         // bold
+  const X  = "\x1b[0m";         // reset
+
+  process.stdout.write("\n");
+
+  // Mars planet ASCII art + title side by side
+  process.stdout.write(`${OR}        .  .  .        ${X}   ${B}${O}███╗   ███╗ █████╗ ██████╗ ███████╗${X}\n`);
+  process.stdout.write(`${OR}     . ${O}╭──────────╮${OR} .   ${X}   ${B}${O}████╗ ████║██╔══██╗██╔══██╗██╔════╝${X}\n`);
+  process.stdout.write(`${OR}   .  ${O}│ ${R}●   ╭──╮${O}  │${OR}  .  ${X}   ${B}${O}██╔████╔██║███████║██████╔╝███████╗${X}\n`);
+  process.stdout.write(`${OR}  .  ${O}│  ${R}╰──╯  ●${O}  │${OR}   . ${X}   ${B}${O}██║╚██╔╝██║██╔══██║██╔══██╗╚════██║${X}\n`);
+  process.stdout.write(`${OR}   .  ${O}│  ${R}  ●   ${O}   │${OR}  .  ${X}   ${B}${O}██║ ╚═╝ ██║██║  ██║██║  ██║███████║${X}\n`);
+  process.stdout.write(`${OR}     . ${O}╰──────────╯${OR} .   ${X}   ${B}${O}╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝${X}\n`);
+  process.stdout.write(`${OR}        .  .  .        ${X}   ${D}${W}The JavaScript Notebook for Developers${X}\n`);
+
+  process.stdout.write("\n");
+  process.stdout.write(`${D}  🪐  ${B}${W}Server is running!${X}                \n`);
+  process.stdout.write(`${D} \n`);
+  process.stdout.write(`${D}  ${W}Local    ${X}  ${G}${serverUrl}${X}\n`);
+  process.stdout.write(`${D}  ${W}Workspace${X}  ${C}${workspaceRoot}${X}\n`);
+  process.stdout.write(`${D}  \n`);
+  process.stdout.write(`${D}  ${D}Press Ctrl+C to stop the server${X}\n`);
+  process.stdout.write("\n");
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  const { host, port, workspaceRoot } = await startServer(options);
+  const serverUrl = `http://${host}:${port}`;
+
+  printBanner(serverUrl, workspaceRoot)
+
+  if (options.openBrowser) {
+    // Small delay so the server is fully ready before the browser connects
+    setTimeout(() => openBrowser(serverUrl), 400);
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(`Error: ${error?.message ?? String(error)}\n`);
+  process.exitCode = 1;
+});

package/src/lib/files.js

@@ -0,0 +1,143 @@
+import path from "node:path";
+
+import { NOTEBOOK_EXTENSION } from "./notebook.js";
+
+const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".avif"]);
+const TEXT_EXTENSIONS = new Set([".txt", ".md", ".js", ".ts"]);
+const PDF_EXTENSION = ".pdf";
+
+// The URL prefix used in the browser for all workspace files.
+// e.g. workspaceRoot/my_notebook.ijsnb  →  /notebooks/my_notebook.ijsnb
+//      workspaceRoot/any_folder/basic.ijsnb  →  /notebooks/any_folder/basic.ijsnb
+export const NOTEBOOKS_URL_PREFIX = "notebooks";
+
+export function getOpenableFileKind(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+
+  if (extension === NOTEBOOK_EXTENSION) {
+    return "notebook";
+  }
+
+  if (IMAGE_EXTENSIONS.has(extension)) {
+    return "image";
+  }
+
+  if (TEXT_EXTENSIONS.has(extension)) {
+    return "text";
+  }
+
+  if (extension === PDF_EXTENSION) {
+    return "pdf";
+  }
+
+  return null;
+}
+
+export function isOpenableFile(filePath) {
+  return getOpenableFileKind(filePath) !== null;
+}
+
+export function sanitizeNotebookTitle(title) {
+  const normalized = String(title ?? "")
+    .trim()
+    .replace(/[<>:"/\\|?*\x00-\x1F]+/g, " ")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+
+  return normalized || "untitled";
+}
+
+export function deriveNotebookPathFromTitle(notebookPath, title) {
+  const directory = path.dirname(notebookPath);
+  const fileName = `${sanitizeNotebookTitle(title)}${NOTEBOOK_EXTENSION}`;
+  return path.join(directory, fileName);
+}
+
+/**
+ * Convert an absolute workspace file path to the browser URL path.
+ *
+ * All workspace files are mounted under the /notebooks/ URL prefix so the
+ * browser always shows a clean, predictable path regardless of where the
+ * physical file lives:
+ *
+ *   workspaceRoot/my_notebook.ijsnb          →  /notebooks/my_notebook.ijsnb
+ *   workspaceRoot/any_folder/basic.ijsnb     →  /notebooks/any_folder/basic.ijsnb
+ *   workspaceRoot/demo.jpg                   →  /notebooks/demo.jpg
+ */
+export function getAppPathFromWorkspacePath(projectRoot, notebooksDir, absolutePath) {
+  const relativePath = path.relative(projectRoot, absolutePath).replaceAll(path.sep, "/");
+  return `/${NOTEBOOKS_URL_PREFIX}/${relativePath}`;
+}
+
+/**
+ * Resolve a client-supplied path (which may be a browser URL path like
+ * "/notebooks/any_folder/basic.ijsnb" or an absolute filesystem path) to an
+ * absolute path on disk inside the workspace.
+ *
+ * The /notebooks/ URL prefix is stripped before resolution so that URL paths
+ * map cleanly onto workspace-root-relative file paths.
+ */
+export function resolveWorkspaceOpenPath(projectRoot, notebooksDir, requestedPath, options = {}) {
+  const { allowNotebookCreate = false } = options;
+  const existsSync = options.existsSync ?? (() => false);
+
+  if (!requestedPath) {
+    return null;
+  }
+
+  const requestedStr = String(requestedPath).trim();
+
+  // Absolute filesystem path that lives inside the workspace — return as-is.
+  // We check startsWith(projectRoot) first so that real OS paths are handled
+  // before the URL-prefix stripping logic below.
+  if (path.isAbsolute(requestedStr) && requestedStr.startsWith(projectRoot)) {
+    return requestedStr;
+  }
+
+  // Strip leading slashes, then strip the /notebooks/ URL prefix if present.
+  // This lets the frontend pass browser URL paths like "/notebooks/my_notebook.ijsnb"
+  // and have them resolve correctly to workspaceRoot-relative file paths.
+  let normalized = requestedStr.replace(/^\/+/, "");
+
+  // Strip the URL prefix "notebooks/" → remainder is workspace-root-relative
+  if (normalized.startsWith(`${NOTEBOOKS_URL_PREFIX}/`)) {
+    normalized = normalized.slice(`${NOTEBOOKS_URL_PREFIX}/`.length);
+  }
+
+  if (!normalized) {
+    return null;
+  }
+
+  // Resolve the path relative to the workspace root.
+  const candidate = path.resolve(projectRoot, normalized);
+
+  if (!candidate.startsWith(projectRoot)) {
+    return null;
+  }
+
+  if (existsSync(candidate)) {
+    return candidate;
+  }
+
+  // Try appending the notebook extension if it is missing.
+  const notebookWithExtension = candidate.endsWith(NOTEBOOK_EXTENSION)
+    ? candidate
+    : `${candidate}${NOTEBOOK_EXTENSION}`;
+
+  if (existsSync(notebookWithExtension)) {
+    return notebookWithExtension;
+  }
+
+  if (allowNotebookCreate) {
+    const withExtension = candidate.endsWith(NOTEBOOK_EXTENSION)
+      ? candidate
+      : `${candidate}${NOTEBOOK_EXTENSION}`;
+
+    if (withExtension.startsWith(projectRoot)) {
+      return withExtension;
+    }
+  }
+
+  return null;
+}

package/src/lib/notebook.js

@@ -0,0 +1,141 @@
+import { randomUUID } from "node:crypto";
+
+export const NOTEBOOK_VERSION = 1;
+export const NOTEBOOK_EXTENSION = ".ijsnb";
+
+function createPromptConfig(prompt = {}) {
+  return {
+    provider: typeof prompt.provider === "string" && prompt.provider.trim() ? prompt.provider : "groq",
+    model: typeof prompt.model === "string" && prompt.model.trim() ? prompt.model : "llama-3.3-70b-versatile",
+    system: typeof prompt.system === "string" ? prompt.system : "",
+    temperature: Number.isFinite(prompt.temperature) ? Number(prompt.temperature) : 0.2
+  };
+}
+
+export function createCell(type = "code", source = "", options = {}) {
+  const cell = {
+    id: randomUUID(),
+    type,
+    source,
+    executionCount: null,
+    outputs: [],
+    collapsed: false,
+    outputCollapsed: false,
+    metrics: {
+      aiTokensIn: 0,
+      aiTokensOut: 0,
+      aiTokensTotal: 0,
+      aiTokensUpdatedAt: null
+    }
+  };
+
+  if (type === "code") {
+    cell.language = options.language === "javascript" ? "javascript" : "typescript";
+  }
+
+  if (type === "prompt") {
+    cell.prompt = createPromptConfig(options.prompt);
+  }
+
+  return cell;
+}
+
+export function createNotebook(title = "Untitled Nodebook") {
+  return {
+    format: "ijsnb",
+    version: NOTEBOOK_VERSION,
+    metadata: {
+      title,
+      createdAt: new Date().toISOString(),
+      env: {}
+    },
+    cells: [
+      createCell(
+        "markdown",
+        "# Welcome to Mars Book\n\nRun JavaScript and Node.js code with persistent notebook state."
+      ),
+      createCell(
+        "code",
+        [
+          "console.log('Welcome to Mars Book')",
+        ].join("\n"),
+        { language: "typescript" }
+      )
+    ]
+  };
+}
+
+export function normalizeNotebook(rawNotebook) {
+  const notebook = rawNotebook && typeof rawNotebook === "object" ? rawNotebook : {};
+  const metadata = notebook.metadata && typeof notebook.metadata === "object" ? notebook.metadata : {};
+  const cells = Array.isArray(notebook.cells) ? notebook.cells : [];
+
+  return {
+    format: "ijsnb",
+    version: NOTEBOOK_VERSION,
+    metadata: {
+      title: typeof metadata.title === "string" && metadata.title.trim() ? metadata.title : "Untitled Nodebook",
+      createdAt: typeof metadata.createdAt === "string" ? metadata.createdAt : new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      ai:
+        metadata.ai && typeof metadata.ai === "object"
+          ? {
+              provider:
+                typeof metadata.ai.provider === "string" && metadata.ai.provider.trim()
+                  ? metadata.ai.provider
+                  : "groq",
+              model:
+                typeof metadata.ai.model === "string" && metadata.ai.model.trim()
+                  ? metadata.ai.model
+                  : "llama-3.3-70b-versatile"
+            }
+          : {
+              provider: "groq",
+              model: "llama-3.3-70b-versatile"
+            },
+      env:
+        metadata.env && typeof metadata.env === "object"
+          ? Object.fromEntries(
+              Object.entries(metadata.env)
+                .map(([key, value]) => [String(key).trim(), typeof value === "string" ? value : String(value ?? "")])
+                .filter(([key]) => key)
+            )
+          : {}
+    },
+    cells: cells.length
+      ? cells.map((cell) => {
+          const cellType = cell.type === "markdown" ? "markdown" : cell.type === "prompt" ? "prompt" : "code";
+          const metrics = cell.metrics && typeof cell.metrics === "object" ? cell.metrics : {};
+          const normalizedCell = {
+            id: typeof cell.id === "string" && cell.id ? cell.id : randomUUID(),
+            type: cellType,
+            source: typeof cell.source === "string" ? cell.source : "",
+            executionCount: Number.isInteger(cell.executionCount) ? cell.executionCount : null,
+            outputs: Array.isArray(cell.outputs) ? cell.outputs : [],
+            collapsed: Boolean(cell.collapsed),
+            outputCollapsed: Boolean(cell.outputCollapsed),
+            metrics: {
+              aiTokensIn: Number.isFinite(metrics.aiTokensIn) ? metrics.aiTokensIn : 0,
+              aiTokensOut: Number.isFinite(metrics.aiTokensOut) ? metrics.aiTokensOut : 0,
+              aiTokensTotal: Number.isFinite(metrics.aiTokensTotal)
+                ? metrics.aiTokensTotal
+                : (Number.isFinite(metrics.aiTokensIn) || Number.isFinite(metrics.aiTokensOut)
+                    ? (Number(metrics.aiTokensIn) || 0) + (Number(metrics.aiTokensOut) || 0)
+                    : 0),
+              aiTokensUpdatedAt: typeof metrics.aiTokensUpdatedAt === "string" ? metrics.aiTokensUpdatedAt : null
+            }
+          };
+
+          if (cellType === "code") {
+            normalizedCell.language = cell.language === "javascript" ? "javascript" : "typescript";
+          }
+
+          if (cellType === "prompt") {
+            normalizedCell.prompt = createPromptConfig(cell.prompt);
+          }
+
+          return normalizedCell;
+        })
+      : [createCell("code", "console.log('Nodebook is ready');", { language: "typescript" })]
+  };
+}