@absolutejs/absolute 0.15.11 → 0.15.13

package/README.md

@@ -4,7 +4,7 @@ Full‑stack, **type‑safe** batteries‑included platform that lets you **serv
 
 [![bun-required](https://img.shields.io/badge/runtime-bun%401.x-yellowgreen?logo=bun)](https://bun.sh)
 [![elysia-required](https://img.shields.io/badge/server-elysia%40latest-blue?logo=elysia)](https://elysiajs.com)
-![license](https://img.shields.io/badge/license-CC%20BY--NC%204.0-lightgrey)
+![license](https://img.shields.io/badge/license-BSL--1.1-lightgrey)
 
 ---
 
@@ -160,4 +160,4 @@ Pull requests and issues are welcome! Whether it’s a new plugin, framework han
 
 ## License
 
-Creative Commons **CC BY‑NC 4.0** – see [`LICENSE`](./LICENSE) for details.
+**Business Source License 1.1 (BSL-1.1)** – see [`LICENSE`](./LICENSE) for details.

package/dist/cli/index.js

@@ -1,10 +1,250 @@
 #!/usr/bin/env bun
 // @bun
 
-// src/cli/index.ts
+// src/cli/scripts/dev.ts
+var {$: $2 } = globalThis.Bun;
+var {env } = globalThis.Bun;
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/constants.ts
+var SECONDS_IN_A_MINUTE = 60;
+var MILLISECONDS_IN_A_SECOND = 1000;
+var MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
+var MINUTES_IN_AN_HOUR = 60;
+var HOURS_IN_DAY = 24;
+var MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
+var TWO_THIRDS = 2 / 3;
+var DEFAULT_PORT = 3000;
+
+// src/cli/interactive.ts
+import { openSync } from "fs";
+import { ReadStream } from "tty";
+var SHORTCUTS = {
+  c: "clear",
+  h: "help",
+  o: "open",
+  p: "pause",
+  q: "quit",
+  r: "restart"
+};
+var WORD_COMMANDS = {
+  clear: "clear",
+  help: "help",
+  open: "open",
+  pause: "pause",
+  quit: "quit",
+  restart: "restart",
+  resume: "pause"
+};
+var openTtyStream = () => {
+  if (typeof process.stdin.setRawMode === "function") {
+    try {
+      process.stdin.setRawMode(true);
+      return process.stdin;
+    } catch {}
+  }
+  try {
+    const ttyStream = new ReadStream(openSync("/dev/tty", "r"));
+    ttyStream.setRawMode(true);
+    return ttyStream;
+  } catch {
+    return null;
+  }
+};
+var createInteractiveHandler = (actions) => {
+  let buffer = "";
+  let shellMode = false;
+  let needsPrompt = true;
+  let escapeSeq = "";
+  const history = [];
+  let historyIndex = -1;
+  const renderLine = (value) => {
+    const prefix = shellMode ? "\x1B[33m$ \x1B[0m" : "\x1B[90m> \x1B[0m";
+    process.stdout.write(`\r\x1B[2K${prefix}${value}`);
+    buffer = value;
+    needsPrompt = false;
+  };
+  const handleLine = async (line) => {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      needsPrompt = true;
+      return;
+    }
+    if (trimmed === "$") {
+      shellMode = true;
+      needsPrompt = true;
+      return;
+    }
+    if (trimmed.startsWith("$")) {
+      const cmd = trimmed.slice(1).trim();
+      if (cmd.length > 0) {
+        try {
+          await actions.shell(cmd);
+        } catch {}
+        needsPrompt = true;
+        return;
+      }
+    }
+    const wordAction = WORD_COMMANDS[trimmed.toLowerCase()];
+    if (wordAction) {
+      await actions[wordAction]();
+      needsPrompt = true;
+      return;
+    }
+    if (trimmed.length === 1) {
+      const shortcutAction = SHORTCUTS[trimmed];
+      if (shortcutAction) {
+        await actions[shortcutAction]();
+        needsPrompt = true;
+        return;
+      }
+    }
+    console.log(`\x1B[31mUnknown command: ${trimmed}\x1B[0m (press h + enter for help)`);
+    needsPrompt = true;
+  };
+  const handleShellLine = async (line) => {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      shellMode = false;
+      needsPrompt = true;
+      return;
+    }
+    try {
+      await actions.shell(trimmed);
+    } catch {}
+    shellMode = false;
+    needsPrompt = true;
+  };
+  const handleArrow = (arrow) => {
+    if (arrow === "A" && history.length > 0) {
+      if (historyIndex < history.length - 1) {
+        historyIndex++;
+      }
+      const entry = history[history.length - 1 - historyIndex];
+      if (entry)
+        renderLine(entry);
+    }
+    if (arrow === "B") {
+      if (historyIndex > 0) {
+        historyIndex--;
+        const entry = history[history.length - 1 - historyIndex];
+        if (entry)
+          renderLine(entry);
+      } else {
+        historyIndex = -1;
+        renderLine("");
+      }
+    }
+  };
+  const handleChar = (char) => {
+    if (char === "\x03") {
+      if (shellMode) {
+        shellMode = false;
+        buffer = "";
+        historyIndex = -1;
+        needsPrompt = true;
+        process.stdout.write(`
+`);
+      } else {
+        buffer = "";
+        historyIndex = -1;
+        process.stdout.write(`
+`);
+        actions.quit();
+      }
+      return;
+    }
+    if (char === "\x7F" || char === "\b") {
+      if (buffer.length > 0) {
+        renderLine(buffer.slice(0, -1));
+      }
+      return;
+    }
+    if (char === "\r" || char === `
+`) {
+      process.stdout.write(`
+`);
+      const line = buffer;
+      buffer = "";
+      historyIndex = -1;
+      if (line.trim().length > 0) {
+        history.push(line);
+      }
+      if (shellMode) {
+        handleShellLine(line);
+      } else {
+        handleLine(line);
+      }
+      return;
+    }
+    if (char.charCodeAt(0) < 32) {
+      return;
+    }
+    if (needsPrompt) {
+      process.stdout.write(`
+`);
+    }
+    renderLine(buffer + char);
+  };
+  const onData = (data) => {
+    const str = data.toString();
+    for (let idx = 0;idx < str.length; idx++) {
+      const char = str.charAt(idx);
+      if (escapeSeq.length > 0) {
+        escapeSeq += char;
+        if (escapeSeq.length === 2) {
+          if (char !== "[") {
+            escapeSeq = "";
+          }
+          continue;
+        }
+        if (escapeSeq.length === 3) {
+          handleArrow(char);
+          escapeSeq = "";
+          continue;
+        }
+        continue;
+      }
+      if (char === "\x1B") {
+        escapeSeq = "\x1B";
+        continue;
+      }
+      handleChar(char);
+    }
+  };
+  const ttyStream = openTtyStream();
+  const input = ttyStream ?? process.stdin;
+  input.resume();
+  input.on("data", onData);
+  const dispose = () => {
+    input.removeListener("data", onData);
+    if (ttyStream) {
+      try {
+        ttyStream.setRawMode(false);
+      } catch {}
+    }
+    if (ttyStream && ttyStream !== process.stdin) {
+      ttyStream.destroy();
+    }
+    process.stdin.pause();
+  };
+  return { dispose };
+};
+
+// src/cli/utils.ts
 var {$ } = globalThis.Bun;
-import { existsSync } from "fs";
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
+var isWSLEnvironment = () => {
+  try {
+    const release = readFileSync("/proc/version", "utf-8");
+    return /microsoft|wsl/i.test(release);
+  } catch {
+    return false;
+  }
+};
 var COMPOSE_PATH = "db/docker-compose.db.yml";
 var DEFAULT_SERVER_ENTRY = "src/backend/server.ts";
 var readDbScripts = async () => {
@@ -38,27 +278,88 @@ var stopDatabase = async (scripts) => {
 Stopping database container...`);
   await $`${{ raw: scripts.downCommand }}`.quiet().nothrow();
 };
+var printHelp = () => {
+  console.log("");
+  console.log("\x1B[1mShortcuts:\x1B[0m");
+  console.log("  \x1B[36mr\x1B[0m / restart  \u2014 Restart server");
+  console.log("  \x1B[36mp\x1B[0m / pause    \u2014 Pause/resume server");
+  console.log("  \x1B[36mo\x1B[0m / open     \u2014 Open in browser");
+  console.log("  \x1B[36mc\x1B[0m / clear    \u2014 Clear terminal");
+  console.log("  \x1B[36mq\x1B[0m / quit     \u2014 Graceful shutdown");
+  console.log("  \x1B[36mh\x1B[0m / help     \u2014 Show this help");
+  console.log("  \x1B[36m$\x1B[0m            \u2014 Run a shell command");
+  console.log("  \x1B[36m\u2191\x1B[0m / \x1B[36m\u2193\x1B[0m        \u2014 Command history");
+  console.log("");
+};
+var printHint = () => {
+  console.log("\x1B[90mpress h + enter to show shortcuts\x1B[0m");
+};
+var killStaleProcesses = (port) => {
+  try {
+    const output = execSync(`lsof -ti tcp:${port} -sTCP:LISTEN 2>/dev/null`, { encoding: "utf-8" }).trim();
+    if (!output)
+      return;
+    const pids = output.split(`
+`).map(Number).filter((pid) => pid !== process.pid && pid > 0);
+    if (pids.length === 0)
+      return;
+    for (const pid of pids) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {}
+    }
+    console.log(`\x1B[33m[cli] Killed ${pids.length} stale process(es) on port ${port}.\x1B[0m`);
+  } catch {}
+};
+
+// src/cli/scripts/dev.ts
 var dev = async (serverEntry) => {
-  const usesDocker = existsSync(resolve(COMPOSE_PATH));
+  const port = Number(env.PORT) || DEFAULT_PORT;
+  killStaleProcesses(port);
+  const usesDocker = existsSync2(resolve2(COMPOSE_PATH));
   const scripts = usesDocker ? await readDbScripts() : null;
   if (scripts)
     await startDatabase(scripts);
-  const spawnServer = () => Bun.spawn(["bun", "--hot", "--no-clear-screen", serverEntry], {
-    cwd: process.cwd(),
-    env: {
-      ...process.env,
-      NODE_ENV: "development"
-    },
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit"
-  });
-  let serverProcess = spawnServer();
+  let paused = false;
   let cleaning = false;
+  let interactive = null;
+  const spawnServer = () => {
+    const proc = Bun.spawn(["bun", "--hot", "--no-clear-screen", serverEntry], {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        FORCE_COLOR: "1",
+        NODE_ENV: "development"
+      },
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const forward = (stream, dest) => {
+      const reader = stream.getReader();
+      const pump = () => {
+        reader.read().then(({ done, value }) => {
+          if (done)
+            return;
+          dest.write(value);
+          pump();
+        }).catch(() => {});
+      };
+      pump();
+    };
+    forward(proc.stdout, process.stdout);
+    forward(proc.stderr, process.stderr);
+    return proc;
+  };
+  let serverProcess = spawnServer();
   const cleanup = async (exitCode = 0) => {
     if (cleaning)
       return;
     cleaning = true;
+    if (interactive)
+      interactive.dispose();
+    if (paused)
+      sendSignal("SIGCONT");
     try {
       serverProcess.kill();
     } catch {}
@@ -67,12 +368,84 @@ var dev = async (serverEntry) => {
       await stopDatabase(scripts);
     process.exit(exitCode);
   };
+  const restartServer = async () => {
+    console.log("\x1B[36m[cli] Restarting server...\x1B[0m");
+    const old = serverProcess;
+    if (paused) {
+      sendSignal("SIGCONT");
+      paused = false;
+    }
+    try {
+      old.kill();
+    } catch {}
+    serverProcess = spawnServer();
+    await old.exited;
+    console.log("\x1B[32m[cli] Server restarted.\x1B[0m");
+  };
+  const sendSignal = (signal) => {
+    try {
+      process.kill(-serverProcess.pid, signal);
+    } catch {
+      try {
+        process.kill(serverProcess.pid, signal);
+      } catch {}
+    }
+  };
+  const togglePause = () => {
+    if (paused) {
+      sendSignal("SIGCONT");
+      paused = false;
+      console.log("\x1B[32m[cli] Server resumed.\x1B[0m");
+    } else {
+      sendSignal("SIGSTOP");
+      paused = true;
+      console.log("\x1B[33m[cli] Server paused.\x1B[0m \x1B[90m[paused]\x1B[0m");
+    }
+  };
+  const runShellCommand = async (command) => {
+    await $2`${{ raw: command }}`.env({ ...process.env, FORCE_COLOR: "1" }).nothrow();
+  };
+  const openInBrowser = async () => {
+    const url = `http://localhost:${port}`;
+    const { platform } = process;
+    const isWSL = platform === "linux" && isWSLEnvironment();
+    const cmd = isWSL ? "cmd.exe" : platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+    const args = isWSL ? ["/c", "start", url] : [url];
+    try {
+      Bun.spawn([cmd, ...args], {
+        stdout: "ignore",
+        stderr: "ignore"
+      });
+      console.log(`\x1B[36m[cli] Opening ${url}\x1B[0m`);
+    } catch {
+      console.log(`\x1B[33m[cli] Could not open browser. Visit ${url}\x1B[0m`);
+    }
+  };
+  interactive = createInteractiveHandler({
+    clear: () => {
+      process.stdout.write("\x1Bc");
+    },
+    help: () => {
+      printHelp();
+    },
+    open: () => openInBrowser(),
+    pause: () => {
+      togglePause();
+    },
+    quit: () => {
+      cleanup(0);
+    },
+    restart: () => restartServer(),
+    shell: runShellCommand
+  });
   process.on("SIGINT", () => cleanup(0));
   process.on("SIGTERM", () => cleanup(0));
+  printHint();
   const monitorServer = async () => {
     while (!cleaning) {
-      const exitCode = await serverProcess.exited;
-      if (cleaning)
+      const current = serverProcess;
+      const exitCode = await current.exited;
+      if (cleaning || serverProcess !== current)
         continue;
       if (exitCode === 130 || exitCode === 143) {
         await cleanup(0);
@@ -84,6 +457,8 @@ var dev = async (serverEntry) => {
   };
   await monitorServer();
 };
+
+// src/cli/index.ts
 var command = process.argv[2];
 if (command === "dev") {
   const serverEntry = process.argv[3] ?? DEFAULT_SERVER_ENTRY;