@hoox-sh/hoox-shared 1.2.0

package/dist/schemas/index.js

@@ -0,0 +1,705 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/schemas/registry.ts
+function deriveCalledBy(manifests) {
+  const calledBy = {};
+  for (const [workerName, manifest] of Object.entries(manifests)) {
+    if (!calledBy[workerName])
+      calledBy[workerName] = new Set;
+    for (const svc of manifest.services) {
+      if (!calledBy[svc.service])
+        calledBy[svc.service] = new Set;
+      calledBy[svc.service].add(workerName);
+    }
+  }
+  const result = {};
+  for (const [worker, callers] of Object.entries(calledBy)) {
+    result[worker] = [...callers].sort();
+  }
+  return result;
+}
+var manifests = {
+  hoox: {
+    name: "hoox",
+    path: "workers/hoox-worker",
+    vars: {
+      WEBHOOK_API_KEY_BINDING: {
+        type: "secret",
+        description: "External webhook auth key"
+      },
+      INTERNAL_KEY_BINDING: {
+        type: "secret",
+        description: "Inter-worker auth key"
+      },
+      HA_TOKEN_BINDING: { type: "secret", description: "Home Assistant token" }
+    },
+    services: [
+      {
+        binding: "TRADE_SERVICE",
+        service: "trade-worker",
+        description: "Trading functionality"
+      },
+      {
+        binding: "TELEGRAM_SERVICE",
+        service: "telegram-worker",
+        description: "Notifications"
+      }
+    ],
+    infrastructure: {
+      kv: [
+        { binding: "SESSIONS_KV", description: "Webhook session storage" },
+        {
+          binding: "CONFIG_KV",
+          description: "Configuration + rate limiter state"
+        }
+      ],
+      vectorize: [{ binding: "VECTORIZE_INDEX", index: "my-rag-index" }],
+      ai: true,
+      queues: { producer: ["trade-execution"] },
+      durableObjects: [
+        { name: "IDEMPOTENCY_STORE", className: "IdempotencyStore" }
+      ]
+    },
+    middleware: [
+      "requireAuth",
+      "requireInternalAuth",
+      "cors",
+      "rateLimit",
+      "logger",
+      "validate"
+    ]
+  },
+  "trade-worker": {
+    name: "trade-worker",
+    path: "workers/trade-worker",
+    vars: {
+      INTERNAL_KEY_BINDING: {
+        type: "secret",
+        description: "Inter-worker auth key"
+      },
+      TELEGRAM_INTERNAL_KEY_BINDING: {
+        type: "secret",
+        description: "Telegram outbound auth"
+      },
+      BINANCE_KEY_BINDING: { type: "secret", description: "Binance API key" },
+      BINANCE_SECRET_BINDING: {
+        type: "secret",
+        description: "Binance API secret"
+      },
+      MEXC_KEY_BINDING: { type: "secret", description: "MEXC API key" },
+      MEXC_SECRET_BINDING: { type: "secret", description: "MEXC API secret" },
+      BYBIT_KEY_BINDING: { type: "secret", description: "Bybit API key" },
+      BYBIT_SECRET_BINDING: { type: "secret", description: "Bybit API secret" }
+    },
+    services: [
+      {
+        binding: "D1_SERVICE",
+        service: "d1-worker",
+        description: "Database operations"
+      },
+      {
+        binding: "TELEGRAM_SERVICE",
+        service: "telegram-worker",
+        description: "Notifications"
+      }
+    ],
+    infrastructure: {
+      kv: [{ binding: "CONFIG_KV", description: "Configuration" }],
+      d1: [
+        {
+          binding: "DB",
+          database: "trade-data-db",
+          description: "Trade operations"
+        }
+      ],
+      r2: [
+        {
+          binding: "REPORTS_BUCKET",
+          bucket: "trade-reports",
+          description: "Trade reports"
+        },
+        {
+          binding: "SYSTEM_LOGS_BUCKET",
+          bucket: "hoox-system-logs",
+          description: "Verbose exchange logs"
+        }
+      ],
+      queues: { consumer: ["trade-execution"] }
+    },
+    middleware: ["requireInternalAuth"]
+  },
+  "telegram-worker": {
+    name: "telegram-worker",
+    path: "workers/telegram-worker",
+    vars: {
+      INTERNAL_KEY_BINDING: {
+        type: "secret",
+        description: "Inter-worker auth key"
+      },
+      TG_BOT_TOKEN_BINDING: {
+        type: "secret",
+        description: "Telegram bot token"
+      },
+      TG_CHAT_ID_BINDING: { type: "secret", description: "Default chat ID" },
+      TELEGRAM_SECRET_TOKEN: {
+        type: "secret",
+        description: "Webhook verification token"
+      }
+    },
+    services: [],
+    infrastructure: {
+      kv: [{ binding: "CONFIG_KV", description: "Configuration" }],
+      r2: [
+        {
+          binding: "UPLOADS_BUCKET",
+          bucket: "user-uploads",
+          description: "User uploaded files"
+        }
+      ],
+      vectorize: [{ binding: "VECTORIZE_INDEX", index: "my-rag-index" }],
+      ai: true
+    },
+    middleware: ["requireInternalAuth"]
+  },
+  "d1-worker": {
+    name: "d1-worker",
+    path: "workers/d1-worker",
+    vars: {
+      INTERNAL_KEY_BINDING: {
+        type: "secret",
+        description: "Inter-worker auth key"
+      }
+    },
+    services: [],
+    infrastructure: {
+      kv: [{ binding: "CONFIG_KV", description: "Configuration" }],
+      d1: [
+        {
+          binding: "DB",
+          database: "trade-data-db",
+          description: "Main database"
+        }
+      ]
+    },
+    middleware: ["requireInternalAuth"]
+  },
+  "web3-wallet-worker": {
+    name: "web3-wallet-worker",
+    path: "workers/web3-wallet-worker",
+    vars: {
+      WALLET_PK_SECRET: { type: "secret", description: "Wallet private key" },
+      WALLET_MNEMONIC_SECRET: {
+        type: "secret",
+        description: "Wallet mnemonic phrase"
+      }
+    },
+    services: [
+      {
+        binding: "TELEGRAM_SERVICE",
+        service: "telegram-worker",
+        description: "Notifications"
+      }
+    ],
+    infrastructure: {},
+    middleware: ["requireInternalAuth"]
+  },
+  "agent-worker": {
+    name: "agent-worker",
+    path: "workers/agent-worker",
+    vars: {
+      AGENT_INTERNAL_KEY: { type: "secret", description: "Agent worker auth" },
+      INTERNAL_KEY_BINDING: {
+        type: "secret",
+        description: "Inter-worker auth key"
+      }
+    },
+    services: [
+      {
+        binding: "TRADE_SERVICE",
+        service: "trade-worker",
+        description: "Trading functionality"
+      },
+      {
+        binding: "TELEGRAM_SERVICE",
+        service: "telegram-worker",
+        description: "Notifications"
+      }
+    ],
+    infrastructure: {
+      kv: [{ binding: "CONFIG_KV", description: "Configuration" }],
+      d1: [
+        {
+          binding: "DB",
+          database: "trade-data-db",
+          description: "Portfolio queries"
+        }
+      ],
+      ai: true
+    },
+    middleware: ["requireInternalAuth"],
+    cron: ["*/15 * * * *"]
+  },
+  "email-worker": {
+    name: "email-worker",
+    path: "workers/email-worker",
+    vars: {
+      INTERNAL_KEY_BINDING: {
+        type: "secret",
+        description: "Inter-worker auth key"
+      },
+      EMAIL_HOST_BINDING: { type: "secret", description: "Email IMAP host" },
+      EMAIL_USER_BINDING: { type: "secret", description: "Email username" },
+      EMAIL_PASS_BINDING: { type: "secret", description: "Email password" },
+      TRADE_WORKER_NAME: {
+        type: "plaintext",
+        description: "Trade worker service name",
+        default: "trade-worker"
+      },
+      USE_IMAP: {
+        type: "plaintext",
+        description: "Use IMAP for email",
+        default: "false"
+      },
+      MAILGUN_API_KEY: { type: "secret", description: "Mailgun API key" },
+      EMAIL_SCAN_SUBJECT: { type: "secret", description: "Email scan subject" }
+    },
+    services: [
+      {
+        binding: "TRADE_SERVICE",
+        service: "trade-worker",
+        description: "Trading functionality"
+      }
+    ],
+    infrastructure: {
+      kv: [{ binding: "CONFIG_KV", description: "Configuration" }]
+    },
+    middleware: ["requireInternalAuth"],
+    cron: ["*/5 * * * *"]
+  },
+  "analytics-worker": {
+    name: "analytics-worker",
+    path: "workers/analytics-worker",
+    vars: {
+      CLOUDFLARE_API_TOKEN: {
+        type: "secret",
+        description: "CF API token for Analytics SQL"
+      },
+      CLOUDFLARE_ACCOUNT_ID: {
+        type: "plaintext",
+        description: "CF Account ID"
+      }
+    },
+    services: [],
+    infrastructure: {
+      analyticsEngine: true
+    },
+    middleware: []
+  },
+  "report-worker": {
+    name: "report-worker",
+    path: "workers/report-worker",
+    vars: {
+      CF_API_TOKEN_BINDING: {
+        type: "secret",
+        description: "CF API token for Browser Rendering"
+      },
+      ACCOUNT_ID: { type: "plaintext", description: "CF Account ID" }
+    },
+    services: [
+      {
+        binding: "D1_SERVICE",
+        service: "d1-worker",
+        description: "Database queries"
+      },
+      {
+        binding: "TELEGRAM_SERVICE",
+        service: "telegram-worker",
+        description: "Notifications"
+      }
+    ],
+    infrastructure: {
+      r2: [
+        {
+          binding: "REPORTS_BUCKET",
+          bucket: "trade-reports",
+          description: "PDF reports"
+        }
+      ]
+    },
+    middleware: ["requireInternalAuth"],
+    cron: ["0 8 * * *", "0 18 * * *"]
+  },
+  "pyne-worker": {
+    name: "pyne-worker",
+    path: "workers/pyne-worker",
+    vars: {
+      API_KEY: {
+        type: "secret",
+        description: "X-API-Key for /run and management endpoints"
+      },
+      ALERT_WEBHOOK_URL: {
+        type: "secret",
+        description: "Default HTTPS webhook for alert()/alertcondition()"
+      },
+      TRADE_WORKER_NAME: {
+        type: "plaintext",
+        description: "Trade worker service name",
+        default: "trade-worker"
+      }
+    },
+    services: [
+      {
+        binding: "TRADE_SERVICE",
+        service: "trade-worker",
+        description: "Forward strategy trade events"
+      }
+    ],
+    infrastructure: {
+      r2: [
+        {
+          binding: "OHLCV_DATA",
+          bucket: "pyne-worker-ohlcv",
+          description: "OHLCV klines + script registry"
+        }
+      ]
+    },
+    middleware: [],
+    cron: ["* * * * *"]
+  },
+  dashboard: {
+    name: "dashboard",
+    path: "workers/dashboard",
+    vars: {
+      DASHBOARD_USER: {
+        type: "secret",
+        description: "Dashboard admin username"
+      },
+      DASHBOARD_PASS: {
+        type: "secret",
+        description: "Dashboard admin password"
+      },
+      SESSION_SECRET: { type: "secret", description: "Session encryption key" },
+      PYNE_API_KEY: {
+        type: "secret",
+        description: "Dashboard \u2192 pyne-worker X-API-Key (match API_KEY)"
+      }
+    },
+    services: [
+      {
+        binding: "D1_SERVICE",
+        service: "d1-worker",
+        description: "Database queries"
+      },
+      {
+        binding: "AGENT_SERVICE",
+        service: "agent-worker",
+        description: "AI risk data"
+      },
+      {
+        binding: "PYNE_SERVICE",
+        service: "pyne-worker",
+        description: "PYNE edge evaluate"
+      }
+    ],
+    infrastructure: {
+      kv: [{ binding: "CONFIG_KV", description: "Configuration" }],
+      ai: true
+    },
+    middleware: []
+  }
+};
+var CALLED_BY = deriveCalledBy(manifests);
+var WORKER_MANIFESTS = manifests;
+var WORKER_NAMES = Object.keys(manifests).sort();
+
+// src/schemas/validators.ts
+import { parse } from "jsonc-parser";
+function validateWranglerJsonc(workerName, manifest, jsoncContent) {
+  const errors = [];
+  let parsed;
+  try {
+    parsed = parse(jsoncContent);
+  } catch {
+    errors.push({
+      worker: workerName,
+      severity: "error",
+      message: "Failed to parse wrangler.jsonc",
+      file: "wrangler.jsonc"
+    });
+    return errors;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    errors.push({
+      worker: workerName,
+      severity: "error",
+      message: "Failed to parse wrangler.jsonc \u2014 result is not a valid object",
+      file: "wrangler.jsonc"
+    });
+    return errors;
+  }
+  const wrangler = parsed;
+  const declaredVars = wrangler.vars ?? {};
+  for (const [name, def] of Object.entries(manifest.vars)) {
+    if (!(name in declaredVars)) {
+      errors.push({
+        worker: workerName,
+        severity: "error",
+        message: `Missing var: ${name} (${def.description})`,
+        file: "wrangler.jsonc"
+      });
+    }
+  }
+  for (const [name, def] of Object.entries(manifest.vars)) {
+    if (def.type === "secret" && !name.endsWith("_BINDING") && !name.endsWith("_SECRET") && !name.startsWith("CLOUDFLARE_") && name !== "TELEGRAM_SECRET_TOKEN" && name !== "MAILGUN_API_KEY" && name !== "EMAIL_SCAN_SUBJECT" && name !== "DASHBOARD_USER" && name !== "DASHBOARD_PASS" && name !== "SESSION_SECRET" && name !== "AGENT_INTERNAL_KEY") {
+      errors.push({
+        worker: workerName,
+        severity: "warning",
+        message: `Secret var "${name}" does not end with _BINDING or _SECRET suffix`,
+        file: "wrangler.jsonc"
+      });
+    }
+  }
+  const declaredServices = wrangler.services ?? [];
+  for (const expected of manifest.services) {
+    const match = declaredServices.find((s) => s.binding === expected.binding && s.service === expected.service);
+    if (!match) {
+      const declared = declaredServices.find((s) => s.binding === expected.binding);
+      if (declared) {
+        errors.push({
+          worker: workerName,
+          severity: "error",
+          message: `Service "${expected.binding}" points to "${declared.service}" but manifest expects "${expected.service}"`,
+          file: "wrangler.jsonc"
+        });
+      } else {
+        errors.push({
+          worker: workerName,
+          severity: "error",
+          message: `Missing service binding: ${expected.binding} -> ${expected.service}`,
+          file: "wrangler.jsonc"
+        });
+      }
+    }
+  }
+  for (const declared of declaredServices) {
+    const expected = manifest.services.find((s) => s.binding === declared.binding);
+    if (!expected) {
+      errors.push({
+        worker: workerName,
+        severity: "warning",
+        message: `Unexpected service binding: ${declared.binding}`,
+        file: "wrangler.jsonc"
+      });
+    }
+  }
+  return errors;
+}
+function validateRootSecrets(workerName, manifest, rootJsoncContent) {
+  const errors = [];
+  let parsed;
+  try {
+    parsed = parse(rootJsoncContent);
+  } catch {
+    errors.push({
+      worker: workerName,
+      severity: "error",
+      message: "Failed to parse root wrangler.jsonc"
+    });
+    return errors;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    errors.push({
+      worker: workerName,
+      severity: "error",
+      message: "Failed to parse root wrangler.jsonc \u2014 result is not a valid object"
+    });
+    return errors;
+  }
+  const rootWrangler = parsed;
+  const rootSecrets = rootWrangler.workers?.[workerName]?.secrets ?? [];
+  const expectedSecrets = Object.entries(manifest.vars).filter(([_, def]) => def.type === "secret").map(([name]) => name);
+  for (const expected of expectedSecrets) {
+    if (!rootSecrets.includes(expected)) {
+      errors.push({
+        worker: workerName,
+        severity: "error",
+        message: `Secret "${expected}" missing from root wrangler.jsonc workers.${workerName}.secrets`,
+        file: "wrangler.jsonc (root)"
+      });
+    }
+  }
+  return errors;
+}
+function validateDevVars(workerName, manifest, devVarsContent) {
+  const errors = [];
+  const vars = new Map;
+  for (const line of devVarsContent.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#"))
+      continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx < 1)
+      continue;
+    vars.set(trimmed.substring(0, eqIdx).trim(), trimmed.substring(eqIdx + 1).trim());
+  }
+  for (const [name, def] of Object.entries(manifest.vars)) {
+    if (def.type !== "secret")
+      continue;
+    if (!vars.has(name)) {
+      errors.push({
+        worker: workerName,
+        severity: "error",
+        message: `Missing "${name}" in .dev.vars`,
+        file: ".dev.vars"
+      });
+    }
+  }
+  return errors;
+}
+function generateWranglerJsonc(manifest) {
+  const parts = [];
+  parts.push(`{`);
+  parts.push(`  "name": "${manifest.name}",`);
+  parts.push(`  "main": "src/index.ts",`);
+  const varKeys = Object.keys(manifest.vars);
+  if (varKeys.length > 0) {
+    parts.push(`  "vars": {`);
+    for (const [i, name] of varKeys.entries()) {
+      const def = manifest.vars[name];
+      const comma = i < varKeys.length - 1 ? "," : "";
+      const val = def.type === "secret" ? "__SECRET__" : JSON.stringify(def.default ?? "");
+      parts.push(`    "${name}": ${val}${comma}`);
+    }
+    parts.push(`  },`);
+  }
+  if (manifest.services.length > 0) {
+    parts.push(`  "services": [`);
+    for (const [i, svc] of manifest.services.entries()) {
+      const comma = i < manifest.services.length - 1 ? "," : "";
+      parts.push(`    { "binding": "${svc.binding}", "service": "${svc.service}" }${comma}`);
+    }
+    parts.push(`  ],`);
+  }
+  const infra = manifest.infrastructure;
+  if (infra.kv && infra.kv.length > 0) {
+    parts.push(`  "kv_namespaces": [`);
+    for (const [i, binding] of infra.kv.entries()) {
+      const comma = i < infra.kv.length - 1 ? "," : "";
+      parts.push(`    { "binding": "${binding.binding}", "id": "" }${comma}`);
+    }
+    parts.push(`  ],`);
+  }
+  if (infra.d1 && infra.d1.length > 0) {
+    parts.push(`  "d1_databases": [`);
+    for (const [i, binding] of infra.d1.entries()) {
+      const comma = i < infra.d1.length - 1 ? "," : "";
+      parts.push(`    { "binding": "${binding.binding}", "database_name": "${binding.database}", "database_id": "" }${comma}`);
+    }
+    parts.push(`  ],`);
+  }
+  if (infra.r2 && infra.r2.length > 0) {
+    parts.push(`  "r2_buckets": [`);
+    for (const [i, binding] of infra.r2.entries()) {
+      const comma = i < infra.r2.length - 1 ? "," : "";
+      parts.push(`    { "binding": "${binding.binding}", "bucket_name": "${binding.bucket}" }${comma}`);
+    }
+    parts.push(`  ],`);
+  }
+  if (infra.ai) {
+    parts.push(`  "ai": { "binding": "AI" },`);
+  }
+  if (infra.analyticsEngine) {
+    parts.push(`  "analytics_engine_datasets": [{ "binding": "ANALYTICS_ENGINE", "dataset": "hoox-analytics" }],`);
+  }
+  if (infra.vectorize && infra.vectorize.length > 0) {
+    parts.push(`  "vectorize": [`);
+    for (const [i, binding] of infra.vectorize.entries()) {
+      const comma = i < infra.vectorize.length - 1 ? "," : "";
+      parts.push(`    { "binding": "${binding.binding}", "index_name": "${binding.index}" }${comma}`);
+    }
+    parts.push(`  ],`);
+  }
+  if (infra.queues) {
+    if (infra.queues.producer && infra.queues.producer.length > 0) {
+      parts.push(`  "queues": { "producers": [`);
+      for (const [i, q] of infra.queues.producer.entries()) {
+        const comma = i < infra.queues.producer.length - 1 ? "," : "";
+        parts.push(`    { "queue": "${q}", "binding": "" }${comma}`);
+      }
+      parts.push(`  ] },`);
+    }
+    if (infra.queues.consumer && infra.queues.consumer.length > 0) {
+      parts.push(`  "queues": { "consumers": [`);
+      for (const [i, q] of infra.queues.consumer.entries()) {
+        const comma = i < infra.queues.consumer.length - 1 ? "," : "";
+        parts.push(`    { "queue": "${q}" }${comma}`);
+      }
+      parts.push(`  ] },`);
+    }
+  }
+  if (infra.durableObjects && infra.durableObjects.length > 0) {
+    parts.push(`  "durable_objects": { "bindings": [`);
+    for (const [i, doBinding] of infra.durableObjects.entries()) {
+      const comma = i < infra.durableObjects.length - 1 ? "," : "";
+      parts.push(`    { "name": "${doBinding.name}", "class_name": "${doBinding.className}" }${comma}`);
+    }
+    parts.push(`  ] },`);
+  }
+  parts.push(`}`);
+  return parts.join(`
+`) + `
+`;
+}
+function generateDevVars(manifest) {
+  const lines = [];
+  lines.push(`# ${manifest.name} \u2014 Environment Variables`);
+  lines.push(`# Auto-generated from worker manifest schema`);
+  lines.push(``);
+  for (const [name, def] of Object.entries(manifest.vars)) {
+    if (def.type === "secret") {
+      lines.push(`${name}=placeholder_${name.toLowerCase()}`);
+    }
+  }
+  lines.push(``);
+  return lines.join(`
+`);
+}
+function validateAll(workerName, manifest, files) {
+  const errors = [
+    ...validateWranglerJsonc(workerName, manifest, files.wranglerJsonc),
+    ...validateRootSecrets(workerName, manifest, files.rootWranglerJsonc),
+    ...validateDevVars(workerName, manifest, files.devVars)
+  ];
+  return {
+    worker: workerName,
+    passed: errors.filter((e) => e.severity === "error").length === 0,
+    errors
+  };
+}
+export {
+  validateWranglerJsonc,
+  validateRootSecrets,
+  validateDevVars,
+  validateAll,
+  generateWranglerJsonc,
+  generateDevVars,
+  WORKER_NAMES,
+  WORKER_MANIFESTS,
+  CALLED_BY
+};

package/dist/schemas/registry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { WorkerManifest } from "./types.js";
+/** Map of worker-name -> list-of-workers-that-call-it (computed). */
+export declare const CALLED_BY: Record<string, string[]>;
+/** The canonical registry of all worker manifests. */
+export declare const WORKER_MANIFESTS: Record<string, WorkerManifest>;
+/** List of all worker names in the registry. */
+export declare const WORKER_NAMES: string[];
+//# sourceMappingURL=registry.d.ts.map