@supanadit/morse-web 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 supanadit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# @supanadit/morse-web
+
+**Morse in your browser, as one npm package.** It serves the same Angular frontend and drives the same
+[Pi](https://github.com/earendil-works/pi) coding agent as the VS Code extension — no VS Code required.
+
+```bash
+npm install -g @supanadit/morse-web
+morse start
+```
+
+```
+  ▲  Morse started
+  │
+  ◆  port 4399 (PID: 20880)
+  │
+  ●  visit: http://127.0.0.1:4399/
+  ●  logs:  morse logs
+  │
+  └  daemon running — the terminal can be closed
+```
+
+Then open <http://127.0.0.1:4399/>. The server keeps running in the background; stop it with `morse stop`.
+
+## Requirements
+
+- Node.js 20+ (developed on 24).
+- The `pi` CLI on your `PATH` and already authenticated (`pi --version`), or a path via `MORSE_PI_PATH`.
+  Morse reuses your existing pi configuration: models, credentials, tools and sessions under `~/.pi`.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `morse` / `morse start` | Start the server as a background daemon and print the URL |
+| `morse start -f` | Run in the foreground (systemd `Type=simple`, Docker) |
+| `morse stop` | Stop the running server |
+| `morse restart` | Stop, then start |
+| `morse status` | Show PID, URL, workspace and uptime (`--json` for scripts) |
+| `morse logs` | Print the server log (`--follow` to tail) |
+| `morse help`, `morse version` | Help / version |
+
+### Options
+
+```
+-p, --port <n>       Web server port (default: 4399, next free if taken)
+--host <addr>        Bind address (default: 127.0.0.1)
+--lan                Bind 0.0.0.0 so the LAN can reach it
+-f, --foreground     Run in the foreground
+--workspace <dir>    Directory the agent works in (default: the current one)
+--projects <list>    Comma/colon separated roots the agent may open
+--open               Open the browser once healthy
+--force              Replace a server this CLI already started
+```
+
+### Environment
+
+```
+MORSE_HOME             Data directory (default: ~/.morse)
+MORSE_PORT             Default port
+MORSE_HOST             Default bind address
+MORSE_WORKSPACE        Workspace the agent runs in
+MORSE_PROJECTS         Roots the agent may open
+MORSE_HOT_SESSIONS     How many pi processes stay alive (default: 4)
+MORSE_PI_PATH          Path to the pi executable (default: pi on PATH)
+MORSE_PI_ENTRY         Run a pi RPC entry with node instead of the binary
+MORSE_UI_DIR           Override the served frontend directory
+```
+
+## Security
+
+`morse start` binds `127.0.0.1` by default. `--lan` exposes an **unauthenticated** chat UI to your network:
+only do it on a trusted network, or put a TLS reverse proxy with auth in front of it.
+
+## How the single package is built
+
+Everything lives in one tarball:
+
+```
+dist/server.mjs   NestJS host, with every @morse/* workspace package inlined
+dist/cli.mjs      the `morse` lifecycle CLI
+dist/ui/          the built Angular frontend, served as static assets
+```
+
+The `@morse/*` packages are private workspace libraries, so they cannot be installed from npm — bundling
+them into `server.mjs` is what makes a single publishable artifact possible. The NestJS runtime
+(`@nestjs/*`, `rxjs`, `ws`, `reflect-metadata`) stays external and is installed normally from
+`dependencies`.
+
+## Uninstall
+
+```bash
+morse stop
+npm uninstall -g @supanadit/morse-web
+rm -rf ~/.morse      # state and logs
+```

package/dist/cli.mjs

@@ -0,0 +1,539 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawn } from "node:child_process";
+import { createServer } from "node:net";
+import {
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var CLI_DIR = dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT = join(CLI_DIR, "..");
+var SERVER_ENTRY = join(CLI_DIR, "server.mjs");
+var UI_DIR = join(CLI_DIR, "ui");
+var PACKAGE_JSON = join(PACKAGE_ROOT, "package.json");
+var MORSE_HOME = process.env.MORSE_HOME?.trim() || join(homedir(), ".morse");
+var STATE_FILE = join(MORSE_HOME, "server.json");
+var LOG_DIR = join(MORSE_HOME, "logs");
+var LOG_FILE = join(LOG_DIR, "server.log");
+var DEFAULT_PORT = 4399;
+var DEFAULT_HOST = "127.0.0.1";
+var HEALTH_PATH = "/api/health";
+var colorEnabled = process.stdout.isTTY === true && process.env.NO_COLOR === void 0;
+var paint = (code) => (text) => colorEnabled ? `\x1B[${code}m${text}\x1B[0m` : text;
+var dim = paint(2);
+var bold = paint(1);
+var cyan = paint(36);
+var green = paint(32);
+var yellow = paint(33);
+var red = paint(31);
+var COMMANDS = /* @__PURE__ */ new Set([
+  "start",
+  "serve",
+  "stop",
+  "restart",
+  "status",
+  "logs",
+  "help",
+  "version"
+]);
+function parseArgs(argv) {
+  const options = {
+    command: "start",
+    lan: false,
+    foreground: false,
+    open: false,
+    follow: false,
+    force: false,
+    json: false,
+    help: false,
+    version: false
+  };
+  let commandSeen = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const [flag, inline] = splitFlag(arg);
+    const takeValue = () => {
+      if (inline !== void 0) return inline;
+      const next = argv[index + 1];
+      if (next === void 0 || next.startsWith("-")) {
+        throw new Error(`${flag} needs a value`);
+      }
+      index += 1;
+      return next;
+    };
+    switch (flag) {
+      case "start":
+      case "serve":
+      case "stop":
+      case "restart":
+      case "status":
+      case "logs":
+      case "help":
+      case "version":
+        options.command = flag;
+        commandSeen = true;
+        break;
+      case "-p":
+      case "--port":
+        options.port = parsePort(takeValue(), flag);
+        break;
+      case "--host":
+      case "--hostname":
+        options.host = takeValue();
+        break;
+      case "--workspace":
+      case "--cwd":
+        options.workspace = takeValue();
+        break;
+      case "--projects":
+        options.projects = takeValue();
+        break;
+      case "--lan":
+        options.lan = true;
+        break;
+      case "-f":
+      case "--foreground":
+      case "--no-daemon":
+        options.foreground = true;
+        break;
+      case "--open":
+        options.open = true;
+        break;
+      case "--follow":
+        options.follow = true;
+        break;
+      case "--force":
+        options.force = true;
+        break;
+      case "--json":
+        options.json = true;
+        break;
+      case "-h":
+      case "--help":
+        options.help = true;
+        break;
+      case "-v":
+      case "--version":
+        options.version = true;
+        break;
+      default:
+        if (!arg.startsWith("-") && !commandSeen) {
+          options.command = arg;
+          commandSeen = true;
+          break;
+        }
+        throw new Error(`Unknown option "${arg}". Run \`morse help\`.`);
+    }
+  }
+  if (!COMMANDS.has(options.command)) {
+    throw new Error(`Unknown command "${options.command}". Run \`morse help\`.`);
+  }
+  return options;
+}
+function splitFlag(arg) {
+  if (!arg.startsWith("--")) return [arg, void 0];
+  const equals = arg.indexOf("=");
+  return equals === -1 ? [arg, void 0] : [arg.slice(0, equals), arg.slice(equals + 1)];
+}
+function parsePort(value, flag) {
+  const port = Number.parseInt(value, 10);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`${flag} expects a port between 1 and 65535`);
+  }
+  return port;
+}
+function readState() {
+  try {
+    const parsed = JSON.parse(readFileSync(STATE_FILE, "utf8"));
+    if (typeof parsed.pid !== "number" || typeof parsed.port !== "number") return void 0;
+    return {
+      pid: parsed.pid,
+      port: parsed.port,
+      host: parsed.host ?? DEFAULT_HOST,
+      url: parsed.url ?? `http://${DEFAULT_HOST}:${parsed.port}/`,
+      workspace: parsed.workspace ?? process.cwd(),
+      startedAt: parsed.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      logFile: parsed.logFile ?? LOG_FILE
+    };
+  } catch {
+    return void 0;
+  }
+}
+function writeState(state) {
+  mkdirSync(MORSE_HOME, { recursive: true });
+  writeFileSync(STATE_FILE, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+function clearState() {
+  rmSync(STATE_FILE, { force: true });
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function displayHost(host) {
+  return host === "0.0.0.0" || host === "::" ? DEFAULT_HOST : host;
+}
+function healthUrl(state) {
+  return `http://${displayHost(state.host)}:${state.port}${HEALTH_PATH}`;
+}
+async function probe(url) {
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(1500) });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function waitForHealth(url, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    if (await probe(url)) return true;
+    if (Date.now() >= deadline) return false;
+    await sleep(250);
+  }
+}
+async function isPortFree(port) {
+  return new Promise((resolvePort) => {
+    const server = createServer();
+    server.once("error", () => resolvePort(false));
+    server.once("listening", () => server.close(() => resolvePort(true)));
+    server.listen(port, DEFAULT_HOST);
+  });
+}
+async function findFreePort(start2) {
+  for (let port = start2; port < start2 + 100; port += 1) {
+    if (await isPortFree(port)) return port;
+  }
+  throw new Error(`No free port found in ${start2}..${start2 + 99}`);
+}
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+async function start(options) {
+  const existing = readState();
+  if (existing && isAlive(existing.pid)) {
+    if (!options.force) {
+      console.log(`${yellow("Morse is already running")} (PID ${existing.pid})`);
+      console.log(`  visit: ${cyan(existing.url)}`);
+      console.log(`  stop:  ${dim(`morse stop`)}`);
+      return 0;
+    }
+    await stop({ quiet: true });
+  }
+  clearState();
+  const workspace = options.workspace ? resolve(options.workspace) : process.cwd();
+  if (!existsSync(workspace)) {
+    throw new Error(`Workspace does not exist: ${workspace}`);
+  }
+  const envPort = process.env.MORSE_PORT ? Number.parseInt(process.env.MORSE_PORT, 10) : NaN;
+  let port = options.port ?? (Number.isInteger(envPort) ? envPort : void 0) ?? DEFAULT_PORT;
+  if (options.port === void 0 && !Number.isInteger(envPort)) {
+    port = await findFreePort(DEFAULT_PORT);
+  } else if (!await isPortFree(port)) {
+    throw new Error(`Port ${port} is already in use. Pass --port to pick another one.`);
+  }
+  const host = options.lan ? "0.0.0.0" : options.host ?? process.env.MORSE_HOST ?? DEFAULT_HOST;
+  const env = buildEnv(options, port, host, workspace);
+  if (options.foreground) {
+    return startForeground(env, port, host, workspace);
+  }
+  return startDaemon(env, port, host, workspace, options);
+}
+function buildEnv(options, port, host, workspace) {
+  const env = {
+    ...process.env,
+    MORSE_HOST: host,
+    MORSE_PORT: String(port),
+    MORSE_UI_DIR: UI_DIR,
+    MORSE_WORKSPACE: workspace
+  };
+  if (options.projects) env.MORSE_PROJECTS = options.projects;
+  return env;
+}
+async function startDaemon(env, port, host, workspace, options) {
+  mkdirSync(LOG_DIR, { recursive: true });
+  writeFileSync(
+    LOG_FILE,
+    `
+=== morse start ${(/* @__PURE__ */ new Date()).toISOString()} (port ${port}) ===
+`,
+    { flag: "a" }
+  );
+  const logFd = openSync(LOG_FILE, "a");
+  const child = spawn(process.execPath, [SERVER_ENTRY], {
+    cwd: workspace,
+    env,
+    detached: true,
+    // The daemon owns no terminal: closing the shell must not send it SIGHUP.
+    stdio: ["ignore", logFd, logFd]
+  });
+  child.unref();
+  const state = {
+    pid: child.pid ?? -1,
+    port,
+    host,
+    url: `http://${displayHost(host)}:${port}/`,
+    workspace,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    logFile: LOG_FILE
+  };
+  writeState(state);
+  const healthy = await waitForHealth(healthUrl(state), 25e3);
+  if (!healthy) {
+    console.error(red("Morse failed to start."));
+    if (!isAlive(state.pid)) {
+      clearState();
+      console.error(dim(`Last lines of ${LOG_FILE}:`));
+      console.error(tailLog(40));
+      return 1;
+    }
+    console.error(dim("The process is alive but did not answer the health probe."));
+    console.error(dim(`Logs: morse logs`));
+    return 1;
+  }
+  console.log();
+  console.log(`  ${green("\u25B2")}  ${bold("Morse started")}`);
+  console.log(`  \u2502`);
+  console.log(`  \u25C6  port ${port} (PID: ${state.pid})`);
+  console.log(`  \u2502`);
+  console.log(`  \u25CF  visit: ${cyan(state.url)}`);
+  console.log(`  \u25CF  logs:  ${dim("morse logs")}`);
+  console.log(`  \u2502`);
+  console.log(`  \u2514  daemon running \u2014 the terminal can be closed`);
+  console.log();
+  if (options.open) openBrowser(state.url);
+  return 0;
+}
+async function startForeground(env, port, host, workspace) {
+  const child = spawn(process.execPath, [SERVER_ENTRY], { cwd: workspace, env, stdio: "inherit" });
+  writeState({
+    pid: child.pid ?? -1,
+    port,
+    host,
+    url: `http://${displayHost(host)}:${port}/`,
+    workspace,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    logFile: LOG_FILE
+  });
+  const forward = (signal) => {
+    if (child.pid !== void 0) child.kill(signal);
+  };
+  process.on("SIGINT", () => forward("SIGINT"));
+  process.on("SIGTERM", () => forward("SIGTERM"));
+  const code = await new Promise((resolveExit) => {
+    child.on("exit", (exitCode) => resolveExit(exitCode ?? 0));
+  });
+  clearState();
+  return code;
+}
+async function stop(options = {}) {
+  const state = readState();
+  if (!state || !isAlive(state.pid)) {
+    clearState();
+    if (!options.quiet) console.log(dim("Morse is not running."));
+    return 0;
+  }
+  const { pid } = state;
+  process.kill(pid, "SIGTERM");
+  if (!await waitForExit(pid, 5e3)) {
+    process.kill(pid, "SIGKILL");
+    await waitForExit(pid, 2e3);
+  }
+  clearState();
+  if (!options.quiet) {
+    console.log(`${green("\u25CF")} Morse stopped (PID ${pid}).`);
+  }
+  return 0;
+}
+async function waitForExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid)) return true;
+    await sleep(100);
+  }
+  return !isAlive(pid);
+}
+function status(options) {
+  const state = readState();
+  if (!state || !isAlive(state.pid)) {
+    clearState();
+    if (options.json) {
+      console.log(JSON.stringify({ running: false }));
+    } else {
+      console.log(dim("Morse is not running."));
+    }
+    return 1;
+  }
+  const uptimeMs = Date.now() - new Date(state.startedAt).getTime();
+  if (options.json) {
+    console.log(JSON.stringify({ running: true, ...state, uptimeMs }));
+    return 0;
+  }
+  console.log(`${green("\u25CF")} Morse is running (PID ${state.pid})`);
+  console.log(`  visit:     ${cyan(state.url)}`);
+  console.log(`  workspace: ${state.workspace}`);
+  console.log(`  uptime:    ${formatUptime(uptimeMs)}`);
+  console.log(`  logs:      ${dim(state.logFile)}`);
+  return 0;
+}
+function formatUptime(uptimeMs) {
+  const seconds = Math.max(0, Math.floor(uptimeMs / 1e3));
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+function tailLog(linesToShow) {
+  if (!existsSync(LOG_FILE)) return "(no log yet)";
+  const lines = readFileSync(LOG_FILE, "utf8").split("\n");
+  return lines.slice(-linesToShow).join("\n");
+}
+async function logs(options) {
+  if (!existsSync(LOG_FILE)) {
+    console.log(dim(`No log file yet (${LOG_FILE}).`));
+    return 0;
+  }
+  process.stdout.write(tailLog(200));
+  if (!options.follow) return 0;
+  let seen = readFileSync(LOG_FILE, "utf8").length;
+  await new Promise((resolveFollow) => {
+    const timer = setInterval(() => {
+      try {
+        const current = readFileSync(LOG_FILE, "utf8");
+        if (current.length > seen) {
+          process.stdout.write(current.slice(seen));
+          seen = current.length;
+        } else if (current.length < seen) {
+          seen = current.length;
+        }
+      } catch {
+      }
+    }, 400);
+    const stopFollowing = () => {
+      clearInterval(timer);
+      resolveFollow();
+    };
+    process.on("SIGINT", stopFollowing);
+    process.on("SIGTERM", stopFollowing);
+  });
+  return 0;
+}
+function openBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
+    child.unref();
+  } catch {
+  }
+}
+function readVersion() {
+  try {
+    return JSON.parse(readFileSync(PACKAGE_JSON, "utf8")).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function printHelp() {
+  const name = `@supanadit/morse-web`;
+  console.log(`
+ ${bold("Morse")} \u2014 the Comfortable Pi Interface, in your browser (${name})
+
+ ${bold("USAGE")}
+   morse [COMMAND] [OPTIONS]
+
+ ${bold("COMMANDS")}
+   start            Start the web server in the background (default)
+   stop             Stop the running server
+   restart          Stop, then start the server
+   status           Show whether the server is running
+   logs             Print the server log (--follow to tail)
+   help             Show this help
+   version          Print the version
+
+ ${bold("OPTIONS")}
+   -p, --port <n>       Web server port (default: ${DEFAULT_PORT}, next free if taken)
+   --host <addr>        Bind address (default: ${DEFAULT_HOST})
+   --lan                Bind 0.0.0.0 so the LAN can reach it
+   -f, --foreground     Run in the foreground (systemd Type=simple)
+   --workspace <dir>    Directory the agent works in (default: the current one)
+   --projects <list>    Comma/colon separated list of roots the agent may open
+   --open               Open the browser once the server is healthy
+   --force              Replace a server this CLI already started
+   --json               Machine-readable output (status)
+   --follow             Follow the log file (logs)
+   -h, --help           Show this help
+   -v, --version        Print the version
+
+ ${bold("ENVIRONMENT")}
+   MORSE_HOME             Data directory (default: ~/.morse)
+   MORSE_PORT             Default port
+   MORSE_HOST             Default bind address
+   MORSE_WORKSPACE        Workspace the agent runs in
+   MORSE_PROJECTS         Roots the agent may open
+   MORSE_HOT_SESSIONS     How many pi processes stay alive (default: 4)
+   MORSE_PI_PATH          Path to the pi executable (default: pi on PATH)
+   MORSE_PI_ENTRY         Run a pi RPC entry with node instead of the binary
+
+ ${bold("EXAMPLES")}
+   morse                          # start the daemon on ${DEFAULT_PORT}
+   morse start --port 8080        # a specific port
+   morse --lan --port 3002        # reachable on the LAN
+   morse start --open             # start and open the browser
+   morse logs --follow            # tail the server log
+   morse stop                     # stop the daemon
+`);
+}
+async function run(argv) {
+  const options = parseArgs(argv);
+  if (options.version || options.command === "version") {
+    console.log(readVersion());
+    return 0;
+  }
+  if (options.help || options.command === "help") {
+    printHelp();
+    return 0;
+  }
+  switch (options.command) {
+    case "start":
+    case "serve":
+      return start(options);
+    case "stop":
+      return stop();
+    case "restart":
+      await stop({ quiet: true });
+      return start(options);
+    case "status":
+      return status(options);
+    case "logs":
+      return logs(options);
+    default:
+      printHelp();
+      return 0;
+  }
+}
+run(process.argv.slice(2)).then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`${red("morse:")} ${message}`);
+  process.exitCode = 1;
+});
+export {
+  run
+};
+//# sourceMappingURL=cli.mjs.map