pluresdb 1.0.1

package/src/network/websocket-server.ts

@@ -0,0 +1,115 @@
+import { debugLog } from "../util/debug.ts";
+export interface MeshServer {
+  url: string;
+  broadcast: (obj: unknown, exclude?: WebSocket) => void;
+  close: () => void;
+}
+
+export function startMeshServer(args: {
+  port: number;
+  onMessage: (payload: {
+    msg: unknown;
+    source: WebSocket;
+    send: (obj: unknown) => void;
+    broadcast: (obj: unknown, exclude?: WebSocket) => void;
+  }) => void;
+}): MeshServer {
+  const sockets = new Set<WebSocket>();
+  // Debug logging is gated by env var in util/debug.ts
+
+  const broadcast = (obj: unknown, exclude?: WebSocket) => {
+    const data = JSON.stringify(obj);
+    for (const s of sockets) {
+      if (s === exclude) continue;
+      try {
+        s.send(data);
+      } catch {
+        // ignore
+      }
+    }
+  };
+
+  const server = Deno.serve({ port: args.port, onListen: () => {} }, (req) => {
+    debugLog("ws:incoming request");
+    const upgrade = Deno.upgradeWebSocket(req);
+    const socket = upgrade.socket;
+
+    socket.onopen = () => {
+      debugLog("ws:open");
+      sockets.add(socket);
+    };
+
+    socket.onmessage = (event: MessageEvent<string>) => {
+      try {
+        const msg = JSON.parse(event.data);
+        debugLog("ws:message", { type: (msg as { type?: string }).type });
+        args.onMessage({
+          msg,
+          source: socket,
+          send: (obj: unknown) => {
+            try {
+              socket.send(JSON.stringify(obj));
+            } catch {
+              /* ignore */
+            }
+          },
+          broadcast,
+        });
+      } catch {
+        // ignore malformed message
+      }
+    };
+
+    const cleanup = () => sockets.delete(socket);
+    socket.onclose = cleanup;
+    socket.onerror = cleanup;
+
+    return upgrade.response;
+  });
+
+  return {
+    url: `ws://localhost:${args.port}`,
+    broadcast,
+    close: () => {
+      try {
+        server.shutdown();
+      } catch {
+        /* ignore */
+      }
+      for (const s of sockets) {
+        try {
+          s.close();
+        } catch {
+          /* ignore */
+        }
+      }
+      sockets.clear();
+    },
+  };
+}
+
+export function connectToPeer(
+  url: string,
+  handlers: {
+    onOpen?: (socket: WebSocket) => void;
+    onMessage?: (msg: unknown, socket: WebSocket) => void;
+    onClose?: (socket: WebSocket) => void;
+  },
+): WebSocket {
+  const socket = new WebSocket(url);
+  if (handlers.onOpen) socket.onopen = () => handlers.onOpen?.(socket);
+  if (handlers.onMessage) {
+    socket.onmessage = (e) => {
+      try {
+        handlers.onMessage?.(JSON.parse(e.data), socket);
+      } catch {
+        /* ignore */
+      }
+    };
+  }
+  if (handlers.onClose) socket.onclose = () => handlers.onClose?.(socket);
+  socket.onerror = () => {
+    /* ignore */
+  };
+  return socket;
+}

package/src/node-index.ts

@@ -0,0 +1,385 @@
+/**
+ * Node.js Entry Point for PluresDB
+ * This provides a clean API for VSCode extensions and other Node.js applications
+ */
+
+import { EventEmitter } from "node:events";
+import { spawn, ChildProcess } from "node:child_process";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import process from "node:process";
+import { PluresDBConfig, PluresDBOptions } from "./types/node-types";
+
+const packageRoot =
+  typeof __dirname !== "undefined" ? path.resolve(__dirname, "..") : process.cwd();
+
+export class PluresNode extends EventEmitter {
+  private process: ChildProcess | null = null;
+  private config: PluresDBConfig;
+  private denoPath: string;
+  private isRunning = false;
+  private apiUrl: string = "";
+
+  constructor(options: PluresDBOptions = {}) {
+    super();
+
+    this.config = {
+      port: 34567,
+      host: "localhost",
+      dataDir: path.join(os.homedir(), ".pluresdb"),
+      webPort: 34568,
+      logLevel: "info",
+      ...options.config,
+    };
+
+    this.denoPath = options.denoPath || this.findDenoPath();
+
+    if (options.autoStart !== false) {
+      this.start();
+    }
+  }
+
+  private findDenoPath(): string {
+    // Try to find Deno in common locations
+    const possiblePaths = [
+      "deno", // In PATH
+      path.join(os.homedir(), ".deno", "bin", "deno"),
+      path.join(os.homedir(), ".local", "bin", "deno"),
+      "/usr/local/bin/deno",
+      "/opt/homebrew/bin/deno",
+      "C:\\Users\\" + os.userInfo().username + "\\.deno\\bin\\deno.exe",
+      "C:\\Program Files\\deno\\deno.exe",
+    ];
+
+    for (const denoPath of possiblePaths) {
+      try {
+        if (fs.existsSync(denoPath) || this.isCommandAvailable(denoPath)) {
+          return denoPath;
+        }
+      } catch (error) {
+        // Continue to next path
+      }
+    }
+
+    throw new Error("Deno not found. Please install Deno from https://deno.land/");
+  }
+
+  private isCommandAvailable(command: string): boolean {
+    try {
+      require("child_process").execSync(`"${command}" --version`, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async start(): Promise<void> {
+    if (this.isRunning) {
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      try {
+        // Ensure data directory exists
+        if (!fs.existsSync(this.config.dataDir!)) {
+          fs.mkdirSync(this.config.dataDir!, { recursive: true });
+        }
+
+        const kvPath = path.join(this.config.dataDir!, "pluresdb.kv");
+
+        // Find the main.ts file
+        const mainTsPath = path.join(packageRoot, "src", "main.ts");
+        if (!fs.existsSync(mainTsPath)) {
+          throw new Error(
+            "PluresDB main.ts not found. Please ensure the package is properly installed.",
+          );
+        }
+
+        // Start the Deno process
+        const args = [
+          "run",
+          "-A",
+          "--unstable-kv",
+          "--no-lock",
+          mainTsPath,
+          "serve",
+          "--port",
+          this.config.port!.toString(),
+          "--host",
+          this.config.host!,
+          "--kv",
+          kvPath,
+        ];
+
+        this.process = spawn(this.denoPath, args, {
+          stdio: ["pipe", "pipe", "pipe"],
+          cwd: packageRoot,
+        });
+
+        this.apiUrl = `http://${this.config.host}:${this.config.port}`;
+
+        // Handle process events
+        this.process.on("error", (error) => {
+          this.emit("error", error);
+          reject(error);
+        });
+
+        this.process.on("exit", (code) => {
+          this.isRunning = false;
+          this.emit("exit", code);
+        });
+
+        // Wait for server to start
+        this.waitForServer()
+          .then(() => {
+            this.isRunning = true;
+            this.emit("started");
+            resolve();
+          })
+          .catch(reject);
+
+        // Handle stdout/stderr
+        this.process.stdout?.on("data", (data) => {
+          const output = data.toString();
+          this.emit("stdout", output);
+        });
+
+        this.process.stderr?.on("data", (data) => {
+          const output = data.toString();
+          this.emit("stderr", output);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  private async waitForServer(timeout = 20000): Promise<void> {
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < timeout) {
+      try {
+        const response = await fetch(`${this.apiUrl}/api/config`);
+        if (response.ok) {
+          return;
+        }
+      } catch (error) {
+        // Server not ready yet
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+
+    throw new Error("Server failed to start within timeout");
+  }
+
+  async stop(): Promise<void> {
+    if (!this.isRunning || !this.process) {
+      return;
+    }
+
+    return new Promise((resolve) => {
+      this.process!.kill("SIGTERM");
+
+      this.process!.on("exit", () => {
+        this.isRunning = false;
+        this.emit("stopped");
+        resolve();
+      });
+
+      // Force kill after 5 seconds
+      setTimeout(() => {
+        if (this.process && this.isRunning) {
+          this.process.kill("SIGKILL");
+        }
+        resolve();
+      }, 5000);
+    });
+  }
+
+  getApiUrl(): string {
+    return this.apiUrl;
+  }
+
+  getWebUrl(): string {
+    return `http://${this.config.host}:${this.config.webPort}`;
+  }
+
+  isServerRunning(): boolean {
+    return this.isRunning;
+  }
+
+  // SQLite-compatible API methods
+  async query(sql: string, params: any[] = []): Promise<any> {
+    const response = await fetch(`${this.apiUrl}/api/query`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sql, params }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Query failed: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async put(key: string, value: any): Promise<void> {
+    const response = await fetch(`${this.apiUrl}/api/data`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ key, value }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Put failed: ${response.statusText}`);
+    }
+  }
+
+  async get(key: string): Promise<any> {
+    const response = await fetch(`${this.apiUrl}/api/data/${encodeURIComponent(key)}`);
+
+    if (!response.ok) {
+      if (response.status === 404) {
+        return null;
+      }
+      throw new Error(`Get failed: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async delete(key: string): Promise<void> {
+    const response = await fetch(`${this.apiUrl}/api/data/${encodeURIComponent(key)}`, {
+      method: "DELETE",
+    });
+
+    if (!response.ok) {
+      throw new Error(`Delete failed: ${response.statusText}`);
+    }
+  }
+
+  async vectorSearch(query: string, limit = 10): Promise<any[]> {
+    const response = await fetch(`${this.apiUrl}/api/vsearch`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query, limit }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Vector search failed: ${response.statusText}`);
+    }
+
+    return response.json() as Promise<any[]>;
+  }
+
+  async list(prefix?: string): Promise<string[]> {
+    const url = prefix
+      ? `${this.apiUrl}/api/list?prefix=${encodeURIComponent(prefix)}`
+      : `${this.apiUrl}/api/list`;
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(`List failed: ${response.statusText}`);
+    }
+
+    return response.json() as Promise<string[]>;
+  }
+
+  async getConfig(): Promise<any> {
+    const response = await fetch(`${this.apiUrl}/api/config`);
+
+    if (!response.ok) {
+      throw new Error(`Get config failed: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async setConfig(config: any): Promise<void> {
+    const response = await fetch(`${this.apiUrl}/api/config`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(config),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Set config failed: ${response.statusText}`);
+    }
+  }
+}
+
+// SQLite-compatible API for easy migration
+export class SQLiteCompatibleAPI {
+  private plures: PluresNode;
+
+  constructor(options?: PluresDBOptions) {
+    this.plures = new PluresNode(options);
+  }
+
+  async start() {
+    await this.plures.start();
+  }
+
+  async stop() {
+    await this.plures.stop();
+  }
+
+  // SQLite-compatible methods
+  async run(sql: string, params: any[] = []) {
+    return this.plures.query(sql, params);
+  }
+
+  async get(sql: string, params: any[] = []) {
+    const result = await this.plures.query(sql, params);
+    return result.rows?.[0] || null;
+  }
+
+  async all(sql: string, params: any[] = []) {
+    const result = await this.plures.query(sql, params);
+    return result.rows || [];
+  }
+
+  async exec(sql: string) {
+    return this.plures.query(sql);
+  }
+
+  // Additional PluresDB specific methods
+  async put(key: string, value: any) {
+    return this.plures.put(key, value);
+  }
+
+  async getValue(key: string) {
+    return this.plures.get(key);
+  }
+
+  async delete(key: string) {
+    return this.plures.delete(key);
+  }
+
+  async vectorSearch(query: string, limit = 10) {
+    return this.plures.vectorSearch(query, limit);
+  }
+
+  async list(prefix?: string) {
+    return this.plures.list(prefix);
+  }
+
+  getApiUrl() {
+    return this.plures.getApiUrl();
+  }
+
+  getWebUrl() {
+    return this.plures.getWebUrl();
+  }
+
+  isRunning() {
+    return this.plures.isServerRunning();
+  }
+}
+
+// Export the main class and types
+export { PluresNode as default };
+export * from "./types/node-types";
+export { PluresVSCodeExtension, createPluresExtension } from "./vscode/extension";