@novastorm-ai/cli 0.0.1 → 0.0.4

package/LICENSE.md

@@ -0,0 +1,100 @@
+# Novastorm License
+
+> **Summary:** Free for individuals and small teams (up to 3 developers). Larger teams require a paid license. After March 20, 2029, the entire codebase becomes MIT-licensed.
+
+---
+
+## Business Source License 1.1
+
+**Licensor:** Uladzimir Pranevich (NIP: PL8992922668)
+
+**Licensed Work:** Novastorm — an ambient development toolkit.
+The Licensed Work is (c) 2026 Uladzimir Pranevich.
+
+**Additional Use Grant:** You may use the Licensed Work for any purpose, including production commercial use, provided that you do not use it in a way that competes with the Licensed Work. A competing use is one that offers the Licensed Work to third parties as a commercial development tool or platform.
+
+**Change Date:** March 20, 2029
+
+**Change License:** MIT
+
+---
+
+## Free License
+
+Copyright (c) 2026 Uladzimir Pranevich
+
+Permission is hereby granted, free of charge, to any person or entity meeting the eligibility criteria below ("Eligible User"), to use, copy, modify, and run the Licensed Work, subject to the conditions of this license.
+
+### Eligibility
+
+You qualify as an Eligible User if **any** of the following apply:
+
+- You are an **individual developer** (sole proprietor, freelancer, hobbyist)
+- You are part of a **team of 3 or fewer developers** (measured by unique git commit authors within a 90-day sliding window)
+- You are using Novastorm for an **open-source project** published under an OSI-approved license
+- You are a **student, educator, or academic researcher**
+- You are **evaluating** Novastorm and have not yet used it in production
+
+### Permitted Use
+
+- Use the Licensed Work to develop, modify, and deploy your own applications
+- Fork and modify the source code for your own use cases
+- Contribute modifications back to the project
+
+### Restrictions
+
+You may **not**:
+
+- Copy or modify the Licensed Work for the purpose of selling, renting, licensing, relicensing, or sublicensing your own derivative of Novastorm as a development tool or platform
+- Remove or alter license validation, license notices, or telemetry attribution
+- Misrepresent the origin of the Licensed Work
+
+---
+
+## Company License
+
+If you do not meet the eligibility criteria above — specifically, if your project has **more than 3 unique human developers** committing within a 90-day window and the project is **not open source** — you must purchase a Company License.
+
+Visit [https://cli.novastorm.ai/#pricing](https://cli.novastorm.ai/#pricing) for pricing and license keys.
+
+### How Developer Count Works
+
+Novastorm counts unique git commit author emails within a 90-day sliding window. Bot accounts (dependabot, renovate, github-actions, etc.) are automatically excluded. Email normalization strips `+tags` and lowercases addresses to avoid counting the same person twice.
+
+### What Happens Without a License
+
+Novastorm continues to work but displays periodic license nudge messages. It does **not** hard-block usage.
+
+---
+
+## Change Date — March 20, 2029
+
+On the Change Date, the Licensed Work will be made available under the MIT License:
+
+> MIT License
+>
+> Copyright (c) 2026 Uladzimir Pranevich
+>
+> 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.
+
+---
+
+## Warranty Disclaimer
+
+THE LICENSED WORK 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 LICENSED WORK OR THE USE OR OTHER DEALINGS IN THE LICENSED WORK.
+
+---
+
+## Contributing
+
+By contributing to Novastorm, you agree that your contributions will be licensed under the same Business Source License 1.1 terms, and will transition to MIT on the Change Date along with the rest of the codebase.
+
+---
+
+## Notice
+
+This license is based on the Business Source License 1.1, available at [https://mariadb.com/bsl11/](https://mariadb.com/bsl11/).
+
+For questions about licensing, see the [License FAQ](docs/license-faq.md).

package/dist/bin/nova.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import {
   run
-} from "../chunk-NFNZMCLQ.js";
-import "../chunk-FYSTZ6K6.js";
+} from "../chunk-CLQXFM4X.js";
+import "../chunk-4AQQAQBM.js";
+import "../chunk-QKD6A4EK.js";
+import "../chunk-KKTDQOQX.js";
 import "../chunk-3RG5ZIWI.js";
 
 // bin/nova.ts

package/dist/chunk-4AQQAQBM.js

@@ -0,0 +1,509 @@
+// ../proxy/dist/index.js
+import http from "http";
+import path from "path";
+import zlib from "zlib";
+import fs from "fs";
+import httpProxy from "http-proxy";
+import { WebSocketServer as WsServer } from "ws";
+import { spawn } from "child_process";
+import http2 from "http";
+import { URL } from "url";
+var SCRIPT_TAG = '<script src="/nova-overlay.js"></script>';
+var ProxyServer = class {
+  server = null;
+  proxy = null;
+  running = false;
+  projectMapApi = null;
+  /** Returns the underlying http.Server (used by WebSocketServer). */
+  getHttpServer() {
+    return this.server;
+  }
+  setProjectMapApi(api) {
+    this.projectMapApi = api;
+  }
+  async start(targetPort, proxyPort, overlayScriptPath) {
+    if (this.running) {
+      return;
+    }
+    this.proxy = httpProxy.createProxyServer({
+      target: `http://127.0.0.1:${targetPort}`,
+      selfHandleResponse: true
+    });
+    this.proxy.on("proxyRes", (proxyRes, req, res) => {
+      const headers = { ...proxyRes.headers };
+      delete headers["content-security-policy"];
+      delete headers["content-security-policy-report-only"];
+      const contentType = proxyRes.headers["content-type"] ?? "";
+      const isHtml = contentType.includes("text/html");
+      if (!isHtml) {
+        for (const [key, value] of Object.entries(headers)) {
+          if (value !== void 0) {
+            res.setHeader(key, value);
+          }
+        }
+        res.writeHead(proxyRes.statusCode ?? 200);
+        proxyRes.pipe(res);
+        return;
+      }
+      const encoding = proxyRes.headers["content-encoding"];
+      let stream = proxyRes;
+      if (encoding === "gzip") {
+        stream = proxyRes.pipe(zlib.createGunzip());
+      } else if (encoding === "br") {
+        stream = proxyRes.pipe(zlib.createBrotliDecompress());
+      } else if (encoding === "deflate") {
+        stream = proxyRes.pipe(zlib.createInflate());
+      }
+      const chunks = [];
+      stream.on("data", (chunk) => {
+        chunks.push(chunk);
+      });
+      stream.on("error", () => {
+        if (!res.headersSent) {
+          res.writeHead(502, { "Content-Type": "text/plain" });
+          res.end("Nova Proxy: failed to decompress response");
+        }
+      });
+      stream.on("end", () => {
+        let body = Buffer.concat(chunks).toString("utf-8");
+        if (body.includes("</body>")) {
+          body = body.replace("</body>", `${SCRIPT_TAG}</body>`);
+        } else if (body.includes("</html>")) {
+          body = body.replace("</html>", `${SCRIPT_TAG}</html>`);
+        } else {
+          body += SCRIPT_TAG;
+        }
+        delete headers["content-length"];
+        delete headers["content-encoding"];
+        delete headers["transfer-encoding"];
+        for (const [key, value] of Object.entries(headers)) {
+          if (value !== void 0) {
+            res.setHeader(key, value);
+          }
+        }
+        res.writeHead(proxyRes.statusCode ?? 200);
+        res.end(body);
+      });
+    });
+    const proxyRef = this.proxy;
+    this.proxy.on("error", (err, req, res) => {
+      if (res instanceof http.ServerResponse && !res.headersSent) {
+        proxyRef.web(req, res, { target: `http://[::1]:${targetPort}` }, (retryErr) => {
+          if (res instanceof http.ServerResponse && !res.headersSent) {
+            res.writeHead(502, { "Content-Type": "text/html" });
+            res.end(`
+              <html><body style="font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0">
+                <div style="text-align:center">
+                  <h2>Nova Proxy</h2>
+                  <p>Waiting for dev server on port ${targetPort}...</p>
+                  <p style="color:#888">This page will auto-refresh.</p>
+                  <script>setTimeout(() => location.reload(), 2000)</script>
+                </div>
+              </body></html>
+            `);
+          }
+        });
+      }
+    });
+    this.server = http.createServer((req, res) => {
+      if (req.url === "/nova-project-map") {
+        const mapPath = path.join(import.meta.dirname, "..", "static", "project-map.html");
+        fs.readFile(mapPath, (err, data) => {
+          if (err) {
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end("project-map.html not found");
+            return;
+          }
+          res.writeHead(200, {
+            "Content-Type": "text/html",
+            "Cache-Control": "no-cache"
+          });
+          res.end(data);
+        });
+        return;
+      }
+      if (req.url?.startsWith("/nova-api/") && this.projectMapApi) {
+        this.projectMapApi.handleRequest(req, res).catch(() => {
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Internal server error" }));
+          }
+        });
+        return;
+      }
+      if (req.url === "/nova-overlay.js") {
+        fs.readFile(overlayScriptPath, (err, data) => {
+          if (err) {
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end("nova-overlay.js not found");
+            return;
+          }
+          res.writeHead(200, {
+            "Content-Type": "application/javascript",
+            "Cache-Control": "no-cache"
+          });
+          res.end(data);
+        });
+        return;
+      }
+      this.proxy.web(req, res);
+    });
+    await new Promise((resolve, reject) => {
+      this.server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          reject(new Error(`Port ${proxyPort} is already in use`));
+        } else {
+          reject(err);
+        }
+      });
+      this.server.listen(proxyPort, () => {
+        this.running = true;
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      this.proxy?.close();
+      this.server?.close((err) => {
+        this.running = false;
+        this.server = null;
+        this.proxy = null;
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  isRunning() {
+    return this.running;
+  }
+};
+var WebSocketServer = class {
+  wss = null;
+  observationHandlers = [];
+  confirmHandlers = [];
+  cancelHandlers = [];
+  appendHandlers = [];
+  browserErrorHandlers = [];
+  secretsSubmitHandlers = [];
+  start(httpServer) {
+    this.wss = new WsServer({
+      server: httpServer,
+      path: "/nova-ws"
+    });
+    this.wss.on("connection", (ws) => {
+      ws.on("message", (data) => {
+        try {
+          const raw = typeof data === "string" ? data : data.toString("utf-8");
+          const parsed = JSON.parse(raw);
+          if (parsed.type === "confirm") {
+            for (const handler of this.confirmHandlers) {
+              handler();
+            }
+            return;
+          }
+          if (parsed.type === "cancel") {
+            for (const handler of this.cancelHandlers) {
+              handler();
+            }
+            return;
+          }
+          if (parsed.type === "append") {
+            const text = parsed.data?.text ?? "";
+            for (const handler of this.appendHandlers) {
+              handler(text);
+            }
+            return;
+          }
+          if (parsed.type === "browser_error") {
+            const error = parsed.data?.error ?? "";
+            for (const handler of this.browserErrorHandlers) {
+              handler(error);
+            }
+            return;
+          }
+          if (parsed.type === "secrets_submit") {
+            const secrets = parsed.data?.secrets ?? {};
+            for (const handler of this.secretsSubmitHandlers) {
+              handler(secrets);
+            }
+            return;
+          }
+          const obsData = parsed.data ?? parsed;
+          const observation = {
+            screenshot: obsData.screenshotBase64 ? Buffer.from(obsData.screenshotBase64, "base64") : obsData.screenshot instanceof Buffer ? obsData.screenshot : Buffer.alloc(0),
+            clickCoords: obsData.clickCoords,
+            domSnapshot: obsData.domSnapshot,
+            transcript: obsData.transcript,
+            currentUrl: obsData.currentUrl ?? "",
+            consoleErrors: obsData.consoleErrors,
+            timestamp: obsData.timestamp ?? Date.now(),
+            gestureContext: obsData.gestureContext
+          };
+          const autoExecute = obsData.autoExecute === true;
+          for (const handler of this.observationHandlers) {
+            handler(observation, autoExecute);
+          }
+        } catch {
+        }
+      });
+    });
+  }
+  onObservation(handler) {
+    this.observationHandlers.push(handler);
+  }
+  onConfirm(handler) {
+    this.confirmHandlers.push(handler);
+  }
+  onCancel(handler) {
+    this.cancelHandlers.push(handler);
+  }
+  onAppend(handler) {
+    this.appendHandlers.push(handler);
+  }
+  onBrowserError(handler) {
+    this.browserErrorHandlers.push(handler);
+  }
+  onSecretsSubmit(handler) {
+    this.secretsSubmitHandlers.push(handler);
+  }
+  sendEvent(event) {
+    if (!this.wss) return;
+    const payload = JSON.stringify(event);
+    for (const client of this.wss.clients) {
+      if (client.readyState === 1) {
+        client.send(payload);
+      }
+    }
+  }
+  getClientCount() {
+    return this.wss?.clients.size ?? 0;
+  }
+};
+var POLL_INTERVAL_MS = 500;
+var MAX_WAIT_MS = 3e4;
+var DevServerRunner = class {
+  process = null;
+  logs = [];
+  running = false;
+  readyHandler = null;
+  errorHandler = null;
+  outputHandlers = [];
+  async spawn(command, cwd, port) {
+    const [cmd, ...args] = command.split(" ");
+    this.process = spawn(cmd, args, {
+      cwd,
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    this.running = true;
+    this.logs = [];
+    this.process.stdout?.on("data", (data) => {
+      const text = data.toString();
+      this.logs.push(text);
+      for (const handler of this.outputHandlers) {
+        handler(text);
+      }
+    });
+    this.process.stderr?.on("data", (data) => {
+      const text = data.toString();
+      this.logs.push(text);
+      for (const handler of this.outputHandlers) {
+        handler(text);
+      }
+    });
+    this.process.on("exit", (code, signal) => {
+      this.running = false;
+      if (code !== 0 && code !== null) {
+        this.errorHandler?.(
+          `Dev server exited with code ${code}${signal ? ` (${signal})` : ""}`
+        );
+      } else if (signal) {
+        this.errorHandler?.(`Dev server killed by signal ${signal}`);
+      }
+    });
+    this.process.on("error", (err) => {
+      this.running = false;
+      this.errorHandler?.(err.message);
+    });
+    await this.pollUntilReady(port);
+  }
+  onReady(handler) {
+    this.readyHandler = handler;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  onOutput(handler) {
+    this.outputHandlers.push(handler);
+  }
+  getLogs() {
+    return this.logs.join("");
+  }
+  async kill() {
+    if (!this.process || !this.running) {
+      return;
+    }
+    const proc = this.process;
+    await new Promise((resolve) => {
+      const killTimer = setTimeout(() => {
+        proc.kill("SIGKILL");
+      }, 5e3);
+      proc.on("exit", () => {
+        clearTimeout(killTimer);
+        this.running = false;
+        this.process = null;
+        resolve();
+      });
+      proc.kill("SIGTERM");
+    });
+  }
+  isRunning() {
+    return this.running;
+  }
+  pollUntilReady(port) {
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      const check = () => {
+        if (!this.running) {
+          reject(
+            new Error(
+              `Dev server process exited before becoming ready. Logs:
+${this.getLogs()}`
+            )
+          );
+          return;
+        }
+        const tryConnect = (host, fallback) => {
+          const req = http2.get(
+            `http://${host}:${port}`,
+            (res) => {
+              res.resume();
+              this.readyHandler?.();
+              resolve();
+            }
+          );
+          req.on("error", () => {
+            if (fallback) {
+              tryConnect(fallback);
+              return;
+            }
+            if (Date.now() - startTime >= MAX_WAIT_MS) {
+              reject(
+                new Error(
+                  `Dev server did not become ready within ${MAX_WAIT_MS / 1e3}s. Logs:
+${this.getLogs()}`
+                )
+              );
+              return;
+            }
+            setTimeout(check, POLL_INTERVAL_MS);
+          });
+          req.end();
+        };
+        tryConnect("127.0.0.1", "[::1]");
+      };
+      check();
+    });
+  }
+};
+var ProjectMapApi = class {
+  graphStore = null;
+  searchRouter = null;
+  analysis = null;
+  activeFiles = [];
+  setGraphStore(store) {
+    this.graphStore = store;
+  }
+  setSearchRouter(router) {
+    this.searchRouter = router;
+  }
+  setAnalysis(analysis) {
+    this.analysis = analysis;
+  }
+  setActiveFiles(files) {
+    this.activeFiles = files;
+  }
+  async handleRequest(req, res) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (url.pathname === "/nova-api/project-map" && req.method === "GET") {
+      await this.handleGetMap(res);
+      return true;
+    }
+    if (url.pathname === "/nova-api/project-map/search" && req.method === "GET") {
+      const query = url.searchParams.get("q") ?? "";
+      await this.handleSearch(res, query);
+      return true;
+    }
+    return false;
+  }
+  async handleGetMap(res) {
+    if (!this.graphStore) {
+      this.sendJson(res, 503, { error: "Graph store not initialized" });
+      return;
+    }
+    const nodes = await this.graphStore.load();
+    const mapNodes = nodes.map((n) => {
+      const methods = this.analysis?.methods.filter((m) => m.filePath === n.filePath).map((m) => ({ name: m.name, signature: m.signature, purpose: m.purpose })) ?? [];
+      return {
+        id: n.filePath,
+        label: n.filePath.split("/").pop() ?? n.filePath,
+        type: n.type,
+        exports: n.exports,
+        keywords: n.keywords,
+        route: n.route,
+        methods
+      };
+    });
+    const mapEdges = [];
+    for (const node of nodes) {
+      for (const imp of node.imports) {
+        if (nodes.some((n) => n.filePath === imp)) {
+          mapEdges.push({ source: node.filePath, target: imp });
+        }
+      }
+    }
+    const data = {
+      nodes: mapNodes,
+      edges: mapEdges,
+      analysis: this.analysis,
+      activeFiles: this.activeFiles
+    };
+    this.sendJson(res, 200, data);
+  }
+  async handleSearch(res, query) {
+    if (!query) {
+      this.sendJson(res, 400, { error: 'Missing query parameter "q"' });
+      return;
+    }
+    if (!this.searchRouter) {
+      this.sendJson(res, 503, { error: "Search router not initialized" });
+      return;
+    }
+    const results = await this.searchRouter.search(query, 20);
+    this.sendJson(res, 200, { results });
+  }
+  sendJson(res, status, data) {
+    const body = JSON.stringify(data);
+    res.writeHead(status, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "no-cache"
+    });
+    res.end(body);
+  }
+};
+
+export {
+  ProxyServer,
+  WebSocketServer,
+  DevServerRunner,
+  ProjectMapApi
+};