@hoox-sh/hoox-shared 1.2.0

package/dist/wizard/engine.js

@@ -0,0 +1,525 @@
+// @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/wizard/presets.ts
+var PRESETS = [
+  {
+    name: "minimal",
+    label: "Minimal",
+    description: "Gateway + D1 database \u2014 webhook processing only",
+    workers: ["hoox", "d1-worker", "analytics-worker"],
+    integrations: []
+  },
+  {
+    name: "standard",
+    label: "Standard",
+    description: "Trading + analytics + Telegram notifications",
+    workers: [
+      "hoox",
+      "d1-worker",
+      "trade-worker",
+      "analytics-worker",
+      "telegram-worker"
+    ],
+    integrations: ["binance", "telegram"]
+  },
+  {
+    name: "full",
+    label: "Full",
+    description: "All workers + AI agent + DeFi + email + PYNE",
+    workers: [
+      "hoox",
+      "d1-worker",
+      "trade-worker",
+      "agent-worker",
+      "telegram-worker",
+      "analytics-worker",
+      "email-worker",
+      "web3-wallet-worker",
+      "pyne-worker"
+    ],
+    integrations: [
+      "binance",
+      "bybit",
+      "mexc",
+      "telegram",
+      "openai",
+      "wallet",
+      "pyne"
+    ]
+  }
+];
+var WORKER_DEPENDENCIES = {
+  "trade-worker": ["d1-worker"],
+  "agent-worker": ["d1-worker"],
+  "email-worker": ["d1-worker"],
+  "analytics-worker": ["d1-worker"],
+  "web3-wallet-worker": ["d1-worker", "hoox"],
+  "pyne-worker": ["trade-worker"]
+};
+function resolveDependencies(selected) {
+  const result = new Set(selected);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const worker of [...result]) {
+      const deps = WORKER_DEPENDENCIES[worker];
+      if (deps) {
+        for (const dep of deps) {
+          if (!result.has(dep)) {
+            result.add(dep);
+            changed = true;
+          }
+        }
+      }
+    }
+  }
+  return [...result];
+}
+var INTEGRATIONS = [
+  {
+    key: "binance",
+    label: "Binance Exchange",
+    workerName: "trade-worker",
+    secrets: {
+      BINANCE_KEY_BINDING: "Binance API Key",
+      BINANCE_SECRET_BINDING: "Binance API Secret"
+    }
+  },
+  {
+    key: "mexc",
+    label: "MEXC Exchange",
+    workerName: "trade-worker",
+    secrets: {
+      MEXC_KEY_BINDING: "MEXC API Key",
+      MEXC_SECRET_BINDING: "MEXC API Secret"
+    }
+  },
+  {
+    key: "bybit",
+    label: "Bybit Exchange",
+    workerName: "trade-worker",
+    secrets: {
+      BYBIT_KEY_BINDING: "Bybit API Key",
+      BYBIT_SECRET_BINDING: "Bybit API Secret"
+    }
+  },
+  {
+    key: "wallet",
+    label: "Web3 Wallet (on-chain execution)",
+    workerName: "web3-wallet-worker",
+    secrets: {
+      WALLET_MNEMONIC_SECRET: "Wallet Mnemonic Phrase",
+      WALLET_PK_SECRET: "Wallet Private Key"
+    }
+  },
+  {
+    key: "email",
+    label: "Email Signal Parsing",
+    workerName: "email-worker",
+    secrets: {
+      INTERNAL_KEY_BINDING: "Internal Auth Key",
+      EMAIL_HOST_BINDING: "Email Host (IMAP server)",
+      EMAIL_USER_BINDING: "Email Username",
+      EMAIL_PASS_BINDING: "Email Password"
+    },
+    vars: { USE_IMAP: "false" }
+  },
+  {
+    key: "telegram",
+    label: "Telegram Notifications",
+    workerName: "telegram-worker",
+    secrets: {
+      TG_BOT_TOKEN_BINDING: "Telegram Bot Token"
+    }
+  },
+  {
+    key: "openai",
+    label: "OpenAI (AI Agent)",
+    workerName: "agent-worker",
+    secrets: {
+      AGENT_INTERNAL_KEY: "OpenAI API Key"
+    }
+  },
+  {
+    key: "anthropic",
+    label: "Anthropic (AI Agent)",
+    workerName: "agent-worker",
+    secrets: {
+      AGENT_INTERNAL_KEY: "Anthropic API Key"
+    }
+  },
+  {
+    key: "google-ai",
+    label: "Google AI (AI Agent)",
+    workerName: "agent-worker",
+    secrets: {
+      AGENT_INTERNAL_KEY: "Google AI API Key"
+    }
+  },
+  {
+    key: "home-assistant",
+    label: "Home Assistant (Smart Home)",
+    workerName: "hoox",
+    secrets: {
+      HA_TOKEN_BINDING: "Home Assistant Token"
+    }
+  },
+  {
+    key: "pyne",
+    label: "PYNE (Pine Script edge evaluate)",
+    workerName: "pyne-worker",
+    secrets: {
+      API_KEY: "PYNE evaluate API key (X-API-Key)",
+      ALERT_WEBHOOK_URL: "Default alert() webhook URL (optional)"
+    }
+  }
+];
+var BASE_WORKERS = {
+  "d1-worker": {
+    enabled: true,
+    path: "workers/d1-worker",
+    vars: { database_name: "hoox-db" }
+  },
+  hoox: { enabled: true, path: "workers/hoox-worker", vars: {} },
+  "agent-worker": { enabled: true, path: "workers/agent-worker", vars: {} },
+  "analytics-worker": {
+    enabled: true,
+    path: "workers/analytics-worker",
+    vars: {}
+  },
+  "pyne-worker": {
+    enabled: true,
+    path: "workers/pyne-worker",
+    vars: {}
+  }
+};
+var BASE_SECRETS = {
+  hoox: ["WEBHOOK_API_KEY_BINDING"],
+  "agent-worker": ["AGENT_INTERNAL_KEY", "INTERNAL_KEY_BINDING"],
+  "analytics-worker": ["CLOUDFLARE_API_TOKEN"]
+};
+
+// src/wizard/engine.ts
+var STEPS = [
+  {
+    id: "PREREQUISITES",
+    label: "System Prerequisites",
+    canGoBack: false,
+    optional: false,
+    validate: validatePrerequisites
+  },
+  {
+    id: "CLOUDFLARE_CONFIG",
+    label: "Cloudflare Configuration",
+    canGoBack: true,
+    optional: false,
+    validate: validateCloudflareConfig
+  },
+  {
+    id: "WORKER_SELECTION",
+    label: "Worker Selection",
+    canGoBack: true,
+    optional: false,
+    validate: validateWorkerSelection
+  },
+  {
+    id: "PROVISIONING",
+    label: "Infrastructure Provisioning",
+    canGoBack: true,
+    optional: true,
+    validate: () => []
+  },
+  {
+    id: "SECRETS",
+    label: "Secrets Configuration",
+    canGoBack: true,
+    optional: false,
+    validate: validateSecrets
+  },
+  {
+    id: "CONFIG_WRITE",
+    label: "Configuration Write",
+    canGoBack: true,
+    optional: false,
+    validate: () => []
+  },
+  {
+    id: "DEPLOY",
+    label: "Deploy",
+    canGoBack: false,
+    optional: true,
+    validate: () => []
+  },
+  {
+    id: "DONE",
+    label: "Complete",
+    canGoBack: false,
+    optional: false,
+    validate: () => []
+  }
+];
+var STEP_ORDER = STEPS.map((s) => s.id);
+function createInitialState() {
+  return {
+    step: "PREREQUISITES",
+    completedSteps: [],
+    selectedWorkers: [],
+    selectedIntegrations: [],
+    secrets: {},
+    startedAt: Date.now(),
+    updatedAt: Date.now()
+  };
+}
+function validatePrerequisites(_state, input) {
+  const errors = [];
+  if (!input.checksPassed) {
+    errors.push("System prerequisite checks must pass before continuing");
+  }
+  return errors;
+}
+function validateCloudflareConfig(_state, input) {
+  const errors = [];
+  const token = input.apiToken;
+  const accountId = input.accountId;
+  if (!token || String(token).trim().length === 0) {
+    errors.push("Cloudflare API token is required");
+  }
+  if (!accountId || String(accountId).trim().length === 0) {
+    errors.push("Cloudflare Account ID is required");
+  }
+  return errors;
+}
+function validateWorkerSelection(_state, input) {
+  const errors = [];
+  const preset = input.preset;
+  const customWorkers = input.workers;
+  if (preset === "custom" && (!customWorkers || customWorkers.length === 0)) {
+    errors.push("At least one worker must be selected");
+  }
+  return errors;
+}
+function validateSecrets(state, input) {
+  const errors = [];
+  const secrets = input.secrets;
+  if (!secrets || Object.keys(secrets).length === 0) {
+    return [];
+  }
+  for (const integrationKey of state.selectedIntegrations) {
+    const integration = INTEGRATIONS.find((i) => i.key === integrationKey);
+    if (!integration)
+      continue;
+    const integrationSecrets = secrets[integrationKey];
+    if (integrationSecrets) {
+      for (const secretName of Object.keys(integration.secrets)) {
+        const val = integrationSecrets[secretName];
+        if (!val || String(val).trim().length === 0) {
+          errors.push(`Secret "${integration.secrets[secretName]}" is required for ${integration.label}`);
+        }
+      }
+    }
+  }
+  return errors;
+}
+
+class WizardEngine {
+  state;
+  constructor(initialState) {
+    this.state = { ...createInitialState(), ...initialState };
+  }
+  getState() {
+    return { ...this.state };
+  }
+  getCurrentStep() {
+    return STEPS.find((s) => s.id === this.state.step) ?? STEPS[0];
+  }
+  getCompletedSteps() {
+    return [...this.state.completedSteps];
+  }
+  canProceed() {
+    const step = this.getCurrentStep();
+    return step.optional || this.state.completedSteps.includes(step.id);
+  }
+  canGoBack() {
+    return this.getCurrentStep().canGoBack;
+  }
+  execute(input) {
+    const currentStep = this.getCurrentStep();
+    const errors = currentStep.validate(this.state, input);
+    if (errors.length > 0) {
+      return errors;
+    }
+    this.applyInput(input);
+    if (!this.state.completedSteps.includes(this.state.step)) {
+      this.state.completedSteps.push(this.state.step);
+    }
+    const currentIdx = STEP_ORDER.indexOf(this.state.step);
+    if (currentIdx < STEP_ORDER.length - 1) {
+      this.state.step = STEP_ORDER[currentIdx + 1];
+    }
+    this.state.updatedAt = Date.now();
+    return [];
+  }
+  goBack() {
+    if (!this.canGoBack())
+      return;
+    const currentIdx = STEP_ORDER.indexOf(this.state.step);
+    if (currentIdx > 0) {
+      const previousStep = STEP_ORDER[currentIdx - 1];
+      this.state.step = previousStep;
+      this.state.completedSteps = this.state.completedSteps.filter((s) => s !== this.state.step || STEP_ORDER.indexOf(s) <= STEP_ORDER.indexOf(previousStep));
+    }
+    this.state.updatedAt = Date.now();
+  }
+  reset() {
+    this.state = createInitialState();
+  }
+  buildConfig() {
+    const cf = this.state.cloudflareConfig;
+    const workers = {};
+    for (const [name, baseCfg] of Object.entries(BASE_WORKERS)) {
+      workers[name] = {
+        enabled: true,
+        path: baseCfg.path,
+        vars: { ...baseCfg.vars },
+        secrets: [...BASE_SECRETS[name] ?? []]
+      };
+    }
+    for (const key of this.state.selectedIntegrations) {
+      const integration = INTEGRATIONS.find((i) => i.key === key);
+      if (!integration)
+        continue;
+      const workerName = integration.workerName;
+      if (!workers[workerName]) {
+        workers[workerName] = {
+          enabled: true,
+          path: `workers/${workerName}`,
+          vars: {},
+          secrets: []
+        };
+      }
+      if (integration.vars) {
+        Object.assign(workers[workerName].vars, integration.vars);
+      }
+      for (const secretName of Object.keys(integration.secrets)) {
+        if (!workers[workerName].secrets.includes(secretName)) {
+          workers[workerName].secrets.push(secretName);
+        }
+      }
+    }
+    for (const workerName of this.state.selectedWorkers) {
+      if (!workers[workerName]) {
+        workers[workerName] = {
+          enabled: true,
+          path: `workers/${workerName}`,
+          vars: {},
+          secrets: []
+        };
+      }
+    }
+    return {
+      global: {
+        cloudflare_api_token: cf?.apiToken ?? "",
+        cloudflare_account_id: cf?.accountId ?? "",
+        cloudflare_secret_store_id: cf?.secretStoreId ?? "",
+        subdomain_prefix: cf?.subdomain ?? ""
+      },
+      workers
+    };
+  }
+  getProvisioningPlan() {
+    const plan = {
+      d1Databases: [],
+      kvNamespaces: [],
+      r2Buckets: [],
+      queues: []
+    };
+    const allWorkers = [
+      ...Object.keys(BASE_WORKERS),
+      ...this.state.selectedWorkers,
+      ...this.state.selectedIntegrations.map((k) => {
+        const i = INTEGRATIONS.find((i2) => i2.key === k);
+        return i?.workerName ?? "";
+      }).filter(Boolean)
+    ];
+    const workerSet = new Set(allWorkers);
+    if (workerSet.has("d1-worker")) {
+      plan.d1Databases.push("hoox-db");
+    }
+    if (workerSet.has("hoox") || workerSet.has("analytics-worker")) {
+      plan.kvNamespaces.push("CONFIG_KV");
+    }
+    if (workerSet.has("web3-wallet-worker")) {
+      plan.kvNamespaces.push("WEB3_CACHE_KV");
+    }
+    plan.d1Databases = [...new Set(plan.d1Databases)];
+    plan.kvNamespaces = [...new Set(plan.kvNamespaces)];
+    return plan;
+  }
+  applyInput(input) {
+    const step = this.state.step;
+    switch (step) {
+      case "PREREQUISITES":
+        break;
+      case "CLOUDFLARE_CONFIG":
+        this.state.cloudflareConfig = {
+          apiToken: String(input.apiToken ?? ""),
+          accountId: String(input.accountId ?? ""),
+          secretStoreId: String(input.secretStoreId ?? ""),
+          subdomain: String(input.subdomain ?? "cryptolinx")
+        };
+        break;
+      case "WORKER_SELECTION": {
+        const preset = input.preset;
+        this.state.preset = preset;
+        if (preset && preset !== "custom") {
+          const presetDef = PRESETS.find((p) => p.name === preset);
+          if (presetDef) {
+            const resolved = resolveDependencies(presetDef.workers);
+            this.state.selectedWorkers = resolved;
+            this.state.selectedIntegrations = presetDef.integrations;
+          }
+        } else {
+          const workers = input.workers;
+          const integrations = input.integrations;
+          if (workers) {
+            this.state.selectedWorkers = resolveDependencies(workers);
+          }
+          if (integrations) {
+            this.state.selectedIntegrations = integrations;
+          }
+        }
+        break;
+      }
+      case "SECRETS":
+        this.state.secrets = input.secrets ?? {};
+        break;
+      case "PROVISIONING":
+        if (input.provisioningResults) {
+          this.state.provisioningResults = input.provisioningResults;
+        }
+        break;
+      case "CONFIG_WRITE":
+      case "DEPLOY":
+      case "DONE":
+        break;
+    }
+  }
+}
+export {
+  WizardEngine
+};

package/dist/wizard/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export type { StepId, WorkerPresetName, WorkerPreset } from "./types";
+export type { WorkerConfig, WorkersJsonConfig, IntegratedService, ProvisioningPlan, ProvisionResult, WizardCloudflareConfig, WizardState, StepDefinition, } from "./types";
+export type { Provisioner } from "./provisioner";
+export { WizardEngine } from "./engine";
+export { PRESETS, WORKER_DEPENDENCIES, INTEGRATIONS, BASE_WORKERS, BASE_SECRETS, resolveDependencies, } from "./presets";
+export { serializeState, deserializeState, WIZARD_STATE_PATH, } from "./persistence";
+//# sourceMappingURL=index.d.ts.map

package/dist/wizard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wizard/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EAAE,MAAM,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACtE,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,sBAAsB,EACtB,WAAW,EACX,cAAc,GACf,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,mBAAmB,GACpB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,eAAe,CAAC"}