nothing-browser 0.1.2 → 0.1.4

package/piggy/server/{index.ts → index.js}

@@ -1,55 +1,15 @@
-// piggy/server/index.ts
+// piggy/server/index.js
 import { Elysia } from "elysia";
 import { openapi } from "@elysiajs/openapi";
-import * as cache from "../cache/memory";
-import logger from "../logger";
-
-export type BeforeMiddleware = (ctx: {
-  params: Record<string, string>;
-  query: Record<string, string>;
-  body: any;
-  headers: Record<string, string>;
-  set: any;
-}) => void | Promise<void>;
-
-export type RouteHandler = (
-  params: Record<string, string>,
-  query: Record<string, string>,
-  body: any
-) => Promise<any>;
-
-export interface RouteParameter {
-  name: string;
-  in: "query" | "path" | "header" | "cookie";
-  description?: string;
-  required?: boolean;
-  schema?: Record<string, any>;
-}
-
-export interface RouteDetail {
-  tags?: string[];
-  summary?: string;
-  description?: string;
-  deprecated?: boolean;
-  hide?: boolean;
-  parameters?: RouteParameter[];
-}
+import * as cache from "../cache/memory.js";
+import logger from "../logger.js";
 
-export interface RouteConfig {
-  path: string;
-  method: "GET" | "POST" | "PUT" | "DELETE";
-  handler: RouteHandler;
-  ttl: number;
-  before: BeforeMiddleware[];
-  detail?: RouteDetail;
-}
-
-export const routeRegistry = new Map<string, RouteConfig>();
-export const keepAliveSites = new Set<string>();
+export const routeRegistry = new Map();
+export const keepAliveSites = new Set();
 
 // ── Error mapper ──────────────────────────────────────────────────────────────
 
-function mapError(err: Error, site: string) {
+function mapError(err, site) {
   const msg = err.message.toLowerCase();
   if (msg.includes("selector") || msg.includes("not found") || msg.includes("null"))
     return { status: 404, error: "Not found", site, details: err.message };
@@ -62,18 +22,9 @@ function mapError(err: Error, site: string) {
 
 // ── Server factory ────────────────────────────────────────────────────────────
 
-let _app: Elysia | null = null;
+let _app = null;
 
-export async function startServer(
-  port: number,
-  hostname = "0.0.0.0",
-  openapiOpts?: {
-    title?: string;
-    version?: string;
-    description?: string;
-    path?: string;
-  }
-): Promise<Elysia> {
+export async function startServer(port, hostname = "0.0.0.0", openapiOpts) {
   _app = new Elysia();
 
   // ── OpenAPI ───────────────────────────────────────────────────────────────
@@ -117,15 +68,15 @@ export async function startServer(
     const colonIdx = registryKey.indexOf(":");
     const siteName = registryKey.substring(0, colonIdx);
     const fullPath = `/${siteName}${config.path}`;
-    const method = config.method.toLowerCase() as "get" | "post" | "put" | "delete";
+    const method = config.method.toLowerCase();
 
     logger.info(`[server] mounting ${config.method} ${fullPath} (ttl=${config.ttl}ms)`);
 
-    const routeHandler = async ({ params, query, body, headers, set }: any) => {
+    const routeHandler = async ({ params, query, body, headers, set }) => {
       for (const mw of config.before) {
         try {
           await mw({ params, query, body, headers, set });
-        } catch (e: any) {
+        } catch (e) {
           set.status = set.status ?? 400;
           return { error: e.message };
         }
@@ -139,10 +90,10 @@ export async function startServer(
         return hit;
       }
 
-      let result: any;
+      let result;
       try {
         result = await config.handler(params, query, body);
-      } catch (e: any) {
+      } catch (e) {
         const mapped = mapError(e, siteName);
         set.status = mapped.status;
         return mapped;
@@ -173,8 +124,9 @@ export async function startServer(
 
   _app.listen({ port, hostname });
 
-  logger.success(`🚀 Piggy API server → http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}`);
-  logger.success(`📖 OpenAPI docs     → http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}/openapi`);
+  const host = hostname === "0.0.0.0" ? "localhost" : hostname;
+  logger.success(`🚀 Piggy API server → http://${host}:${port}`);
+  logger.success(`📖 OpenAPI docs     → http://${host}:${port}/openapi`);
   logger.info(`   Routes mounted: ${routeRegistry.size}`);
   routeRegistry.forEach((cfg, key) => {
     const siteName = key.substring(0, key.indexOf(":"));

package/piggy/session/index.js

@@ -0,0 +1,69 @@
+// piggy/session/index.js
+import { PiggyClient } from "../client.js";
+
+export class SessionClient {
+  constructor(client) {
+    this.client = client;
+  }
+
+  // Session lifecycle
+  reload(tabId = "default") {
+    return this.client.send("session.reload", { tabId });
+  }
+
+  // Paths
+  paths() {
+    return this.client.send("session.paths", {});
+  }
+
+  cookiesPath() {
+    return this.client.send("session.cookies.path", {});
+  }
+
+  profilePath() {
+    return this.client.send("session.profile.path", {});
+  }
+
+  wsPath() {
+    return this.client.send("session.ws.path", {});
+  }
+
+  pingsPath() {
+    return this.client.send("session.pings.path", {});
+  }
+
+  // Opt-in persistence
+  setWsSave(enabled) {
+    return this.client.send("session.ws.save", { enabled });
+  }
+
+  setPingsSave(enabled) {
+    return this.client.send("session.pings.save", { enabled });
+  }
+
+  // Export / import
+  async export(tabId = "default") {
+    const raw = await this.client.send("session.export", { tabId });
+    return typeof raw === "string" ? JSON.parse(raw) : raw;
+  }
+
+  import(data, tabId = "default") {
+    return this.client.send("session.import", {
+      data: JSON.stringify(data),
+      tabId,
+    });
+  }
+
+  // Cookies
+  setCookie(opts, tabId = "default") {
+    return this.client.send("cookie.set", { ...opts, tabId });
+  }
+
+  deleteCookie(opts, tabId = "default") {
+    return this.client.send("cookie.delete", { ...opts, tabId });
+  }
+}
+
+export function createSessionAPI(client) {
+  return new SessionClient(client);
+}

package/piggy/store/{index.ts → index.js}

@@ -1,33 +1,13 @@
-// piggy/store/index.ts
+// piggy/store/index.js
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { dirname, resolve } from "path";
-import logger from "../logger";
-
-// ── Types ─────────────────────────────────────────────────────────────────────
-
-export type FieldType = "string" | "number" | "boolean" | "object" | "array";
-
-export interface FieldSchema {
-  type: FieldType;
-  required?: boolean;        // default false — missing = NULL not error
-  default?: any;             // fallback if missing (overrides NULL)
-}
-
-export interface StoreSchema {
-  name: string;              // store identifier (matches site name or custom)
-  destination: string;       // "./data.json" or "./data.db"
-  fields: Record<string, FieldSchema>;
-}
-
-export interface PiggyStoreConfig {
-  stores: StoreSchema[];
-}
+import logger from "../logger.js";
 
 // ── Load piggy.store.json ─────────────────────────────────────────────────────
 
-let _config: PiggyStoreConfig | null = null;
+let _config = null;
 
-export function loadStoreConfig(configPath = "./piggy.store.json"): PiggyStoreConfig {
+export function loadStoreConfig(configPath = "./piggy.store.json") {
   if (_config) return _config;
 
   const abs = resolve(configPath);
@@ -37,39 +17,33 @@ export function loadStoreConfig(configPath = "./piggy.store.json"): PiggyStoreCo
   }
 
   try {
-    _config = JSON.parse(readFileSync(abs, "utf8")) as PiggyStoreConfig;
+    _config = JSON.parse(readFileSync(abs, "utf8"));
     logger.success(`[store] loaded ${_config.stores.length} schema(s) from ${abs}`);
     return _config;
-  } catch (e: any) {
+  } catch (e) {
     logger.error(`[store] failed to parse piggy.store.json: ${e.message}`);
     return { stores: [] };
   }
 }
 
-export function getSchema(storeName: string): StoreSchema | null {
+export function getSchema(storeName) {
   const config = loadStoreConfig();
   return config.stores.find(s => s.name === storeName) ?? null;
 }
 
 // ── Validate & shape one record against schema ────────────────────────────────
 
-export function shapeRecord(data: Record<string, any>, schema: StoreSchema): Record<string, any> {
-  const shaped: Record<string, any> = {};
+export function shapeRecord(data, schema) {
+  const shaped = {};
 
   for (const [field, def] of Object.entries(schema.fields)) {
     const raw = data[field];
 
-    // Missing field
     if (raw === undefined || raw === null) {
-      if (def.default !== undefined) {
-        shaped[field] = def.default;
-      } else {
-        shaped[field] = null;  // NULL — not an error, just absent
-      }
+      shaped[field] = def.default !== undefined ? def.default : null;
       continue;
     }
 
-    // Type coercion / validation
     switch (def.type) {
       case "string":
         shaped[field] = String(raw);
@@ -92,17 +66,16 @@ export function shapeRecord(data: Record<string, any>, schema: StoreSchema): Rec
     }
   }
 
-  // Extra fields on incoming data are silently dropped — not in schema = ignored
   return shaped;
 }
 
 // ── JSON backend ──────────────────────────────────────────────────────────────
 
-function appendToJson(destination: string, record: Record<string, any>): void {
+function appendToJson(destination, record) {
   const abs = resolve(destination);
   mkdirSync(dirname(abs), { recursive: true });
 
-  let existing: any[] = [];
+  let existing = [];
   if (existsSync(abs)) {
     try {
       existing = JSON.parse(readFileSync(abs, "utf8"));
@@ -118,15 +91,14 @@ function appendToJson(destination: string, record: Record<string, any>): void {
 
 // ── SQLite backend ────────────────────────────────────────────────────────────
 
-function appendToSqlite(destination: string, record: Record<string, any>, schema: StoreSchema): void {
-  // Use bun:sqlite if available, else require better-sqlite3
+function appendToSqlite(destination, record, schema) {
   const abs = resolve(destination);
   mkdirSync(dirname(abs), { recursive: true });
 
-  const isBun = typeof (globalThis as any).Bun !== "undefined";
+  const isBun = typeof globalThis.Bun !== "undefined";
 
   if (isBun) {
-    const { Database } = require("bun:sqlite") as typeof import("bun:sqlite");
+    const { Database } = require("bun:sqlite");
     const db = new Database(abs);
     ensureTable(db, schema, "bun");
     insertRecord(db, schema, record, "bun");
@@ -140,12 +112,12 @@ function appendToSqlite(destination: string, record: Record<string, any>, schema
   }
 }
 
-function ensureTable(db: any, schema: StoreSchema, runtime: "bun" | "node"): void {
+function ensureTable(db, schema, runtime) {
   const tableName = schema.name.replace(/[^a-zA-Z0-9_]/g, "_");
   const cols = Object.entries(schema.fields).map(([name, def]) => {
     const sqlType = def.type === "number" ? "REAL"
       : def.type === "boolean" ? "INTEGER"
-      : def.type === "object" || def.type === "array" ? "TEXT"  // JSON stringified
+      : def.type === "object" || def.type === "array" ? "TEXT"
       : "TEXT";
     return `  ${name} ${sqlType}`;
   });
@@ -153,20 +125,15 @@ function ensureTable(db: any, schema: StoreSchema, runtime: "bun" | "node"): voi
 
   const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n${cols.join(",\n")}\n)`;
 
-  if (runtime === "bun") {
-    db.run(sql);
-  } else {
-    db.prepare(sql).run();
-  }
+  runtime === "bun" ? db.run(sql) : db.prepare(sql).run();
 }
 
-function insertRecord(db: any, schema: StoreSchema, record: Record<string, any>, runtime: "bun" | "node"): void {
+function insertRecord(db, schema, record, runtime) {
   const tableName = schema.name.replace(/[^a-zA-Z0-9_]/g, "_");
   const fields = [...Object.keys(schema.fields), "_storedAt"];
   const values = fields.map(f => {
     if (f === "_storedAt") return new Date().toISOString();
     const v = record[f];
-    // Serialize objects/arrays as JSON strings for SQLite
     if (v !== null && (typeof v === "object" || Array.isArray(v))) return JSON.stringify(v);
     return v ?? null;
   });
@@ -177,19 +144,12 @@ function insertRecord(db: any, schema: StoreSchema, record: Record<string, any>,
 
   const sql = `INSERT INTO ${tableName} (${fields.join(", ")}) VALUES (${placeholders})`;
 
-  if (runtime === "bun") {
-    db.run(sql, values);
-  } else {
-    db.prepare(sql).run(values);
-  }
+  runtime === "bun" ? db.run(sql, values) : db.prepare(sql).run(values);
 }
 
 // ── Main store function ───────────────────────────────────────────────────────
 
-export async function storeRecord(
-  storeName: string,
-  data: Record<string, any> | Record<string, any>[]
-): Promise<{ stored: number; skipped: number }> {
+export async function storeRecord(storeName, data) {
   const schema = getSchema(storeName);
 
   if (!schema) {
@@ -220,7 +180,7 @@ export async function storeRecord(
 
       stored++;
       logger.success(`[store][${storeName}] stored record → ${schema.destination}`);
-    } catch (e: any) {
+    } catch (e) {
       logger.error(`[store][${storeName}] failed to store record: ${e.message}`);
       skipped++;
     }

package/piggy/tabs/index.js

@@ -0,0 +1,24 @@
+// piggy/tabs/index.js
+
+export class TabsClient {
+  constructor(client) {
+    this.client = client;
+  }
+
+  new() {
+    return this.client.send("tab.new", {});
+  }
+
+  close(opts) {
+    const tabId = typeof opts === "string" ? opts : opts.tabId;
+    return this.client.send("tab.close", { tabId });
+  }
+
+  list() {
+    return this.client.send("tab.list", {});
+  }
+}
+
+export function createTabsAPI(client) {
+  return new TabsClient(client);
+}

package/piggy/wait/index.js

@@ -0,0 +1,77 @@
+'use strict';
+
+// ─── WaitClient ───────────────────────────────────────────────────────────────
+
+class WaitClient {
+  constructor(client) {
+    this.client = client;
+  }
+
+  function(js, timeout = 10000, tabId = "default") {
+    return this.client.send("wait.function", { js, timeout, tabId });
+  }
+
+  selector(selector, state = "attached", timeout = 10000, tabId = "default") {
+    return this.client.send("wait.selector", { selector, state, timeout, tabId });
+  }
+}
+
+// ─── EvaluateClient ───────────────────────────────────────────────────────────
+
+class EvaluateClient {
+  constructor(client) {
+    this.client = client;
+  }
+
+  run(js, timeout, tabId = "default") {
+    return this.client.send("evaluate", {
+      js,
+      tabId,
+      ...(timeout !== undefined ? { timeout } : {}),
+    });
+  }
+}
+
+// ─── FetchClient ──────────────────────────────────────────────────────────────
+
+class FetchClient {
+  constructor(client) {
+    this.client = client;
+  }
+
+  text(selector, tabId = "default") {
+    return this.client.send("fetch.text", { query: selector, tabId });
+  }
+
+  textAll(selector, tabId = "default") {
+    return this.client.send("fetch.textAll", { selector, tabId });
+  }
+
+  attr(selector, attr, tabId = "default") {
+    return this.client.send("fetch.attr", { selector, attr, tabId });
+  }
+
+  attrAll(selector, attr, tabId = "default") {
+    return this.client.send("fetch.attrAll", { selector, attr, tabId });
+  }
+
+  links(selector, tabId = "default") {
+    return this.client.send("fetch.links", { query: selector, tabId });
+  }
+
+  linksAll(tabId = "default") {
+    return this.client.send("fetch.links.all", { tabId });
+  }
+
+  images(selector, tabId = "default") {
+    return this.client.send("fetch.image", { query: selector, tabId });
+  }
+}
+
+// ─── Factories ────────────────────────────────────────────────────────────────
+
+function createWaitAPI(client)     { return new WaitClient(client);     }
+function createEvaluateAPI(client) { return new EvaluateClient(client); }
+function createFetchAPI(client)    { return new FetchClient(client);    }
+
+module.exports = { WaitClient, EvaluateClient, FetchClient, createWaitAPI, createEvaluateAPI, createFetchAPI };