teleton 0.8.2 → 0.8.3

package/dist/chunk-CUE4UZXR.js

@@ -0,0 +1,129 @@
+import {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+
+// src/memory/embeddings/local.ts
+import { pipeline, env } from "@huggingface/transformers";
+import { join, dirname } from "path";
+import { mkdirSync, writeFileSync, renameSync, statSync, unlinkSync } from "fs";
+var log = createLogger("Memory");
+var modelCacheDir = join(TELETON_ROOT, "models");
+try {
+  mkdirSync(modelCacheDir, { recursive: true });
+} catch {
+}
+env.cacheDir = modelCacheDir;
+var MIN_FILE_SIZES = { "onnx/model.onnx": 1e6 };
+function isCacheFileValid(filePath, fileName) {
+  try {
+    return statSync(filePath).size >= (MIN_FILE_SIZES[fileName] ?? 1);
+  } catch {
+    return false;
+  }
+}
+async function ensureModelCached(model) {
+  const files = ["config.json", "tokenizer_config.json", "tokenizer.json", "onnx/model.onnx"];
+  const baseUrl = `https://huggingface.co/${model}/resolve/main`;
+  for (const file of files) {
+    const localPath = join(modelCacheDir, model, file);
+    if (isCacheFileValid(localPath, file)) continue;
+    try {
+      unlinkSync(localPath);
+    } catch {
+    }
+    log.info(`Downloading ${model}/${file}...`);
+    mkdirSync(dirname(localPath), { recursive: true });
+    const res = await fetch(`${baseUrl}/${file}`, { redirect: "follow" });
+    if (!res.ok) {
+      throw new Error(`Failed to download ${model}/${file}: ${res.status} ${res.statusText}`);
+    }
+    const buffer = Buffer.from(await res.arrayBuffer());
+    const tmpPath = localPath + ".tmp";
+    writeFileSync(tmpPath, buffer);
+    renameSync(tmpPath, localPath);
+  }
+}
+var extractorPromise = null;
+function getExtractor(model) {
+  if (!extractorPromise) {
+    log.info(`Loading local embedding model: ${model} (cache: ${modelCacheDir})`);
+    extractorPromise = pipeline("feature-extraction", model, {
+      dtype: "fp32",
+      // Explicit cache_dir to avoid any env race condition
+      cache_dir: modelCacheDir,
+      // Prevent pthread_setaffinity_np EINVAL on VPS/containers with restricted CPU sets.
+      // ONNX Runtime skips thread affinity when thread counts are explicit.
+      session_options: { intraOpNumThreads: 1, interOpNumThreads: 1 }
+    }).then((ext) => {
+      log.info(`Local embedding model ready`);
+      return ext;
+    }).catch((err) => {
+      log.error(`Failed to load embedding model: ${err.message}`);
+      extractorPromise = null;
+      throw err;
+    });
+  }
+  return extractorPromise;
+}
+var LocalEmbeddingProvider = class {
+  id = "local";
+  model;
+  dimensions;
+  _disabled = false;
+  constructor(config) {
+    this.model = config.model || "Xenova/all-MiniLM-L6-v2";
+    this.dimensions = 384;
+  }
+  /**
+   * Pre-download and load the model at startup.
+   * If loading fails, retries once then marks provider as disabled (FTS5-only).
+   * Call this once during app init — avoids retry spam on every message.
+   */
+  async warmup() {
+    for (let attempt = 1; attempt <= 2; attempt++) {
+      try {
+        await ensureModelCached(this.model);
+        await getExtractor(this.model);
+        return true;
+      } catch {
+        if (attempt === 1) {
+          log.warn(`Embedding model load failed (attempt 1), retrying...`);
+          await new Promise((r) => setTimeout(r, 1e3));
+        } else {
+          log.warn(
+            `Local embedding model unavailable \u2014 falling back to FTS5-only search (no vector embeddings)`
+          );
+          this._disabled = true;
+          return false;
+        }
+      }
+    }
+    return false;
+  }
+  async embedQuery(text) {
+    if (this._disabled) return [];
+    const extractor = await getExtractor(this.model);
+    const output = await extractor(text, { pooling: "mean", normalize: true });
+    return Array.from(output.data);
+  }
+  async embedBatch(texts) {
+    if (this._disabled) return [];
+    if (texts.length === 0) return [];
+    const extractor = await getExtractor(this.model);
+    const output = await extractor(texts, { pooling: "mean", normalize: true });
+    const data = output.data;
+    const dims = this.dimensions;
+    const results = [];
+    for (let i = 0; i < texts.length; i++) {
+      results.push(Array.from(data.slice(i * dims, (i + 1) * dims)));
+    }
+    return results;
+  }
+};
+
+export {
+  LocalEmbeddingProvider
+};

package/dist/chunk-FUNF6H4W.js

@@ -0,0 +1,251 @@
+import {
+  COINGECKO_API_URL,
+  tonapiFetch
+} from "./chunk-VFA7QMCZ.js";
+import {
+  fetchWithTimeout
+} from "./chunk-XQUHC3JZ.js";
+import {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+
+// src/ton/endpoint.ts
+var ENDPOINT_CACHE_TTL_MS = 6e4;
+var ORBS_HOST = "ton.access.orbs.network";
+var ORBS_TOPOLOGY_URL = `https://${ORBS_HOST}/mngr/nodes?npm_version=2.3.3`;
+var TONCENTER_URL = `https://toncenter.com/api/v2/jsonRPC`;
+var _cache = null;
+var _toncenterApiKey;
+function setToncenterApiKey(key) {
+  _toncenterApiKey = key;
+}
+function getToncenterApiKey() {
+  return _toncenterApiKey;
+}
+async function discoverOrbsEndpoint() {
+  const res = await fetch(ORBS_TOPOLOGY_URL, { signal: AbortSignal.timeout(5e3) });
+  const nodes = await res.json();
+  const healthy = nodes.filter(
+    (n) => n.Healthy === "1" && n.Weight > 0 && n.Mngr?.health?.["v2-mainnet"]
+  );
+  if (healthy.length === 0) throw new Error("no healthy orbs nodes");
+  const totalWeight = healthy.reduce((sum, n) => sum + n.Weight, 0);
+  let r = Math.floor(Math.random() * totalWeight);
+  let chosen = healthy[0];
+  for (const node of healthy) {
+    r -= node.Weight;
+    if (r < 0) {
+      chosen = node;
+      break;
+    }
+  }
+  return `https://${ORBS_HOST}/${chosen.NodeId}/1/mainnet/toncenter-api-v2/jsonRPC`;
+}
+async function getCachedHttpEndpoint() {
+  if (_cache && Date.now() - _cache.ts < ENDPOINT_CACHE_TTL_MS) {
+    return _cache.url;
+  }
+  let url;
+  if (_toncenterApiKey) {
+    try {
+      const testUrl = `https://toncenter.com/api/v2/getAddressInformation?address=EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c`;
+      const res = await fetch(testUrl, {
+        headers: { "X-API-Key": _toncenterApiKey },
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) throw new Error(`TonCenter ${res.status}`);
+      url = TONCENTER_URL;
+    } catch {
+      try {
+        url = await discoverOrbsEndpoint();
+      } catch {
+        url = TONCENTER_URL;
+      }
+    }
+  } else {
+    try {
+      url = await discoverOrbsEndpoint();
+    } catch {
+      url = TONCENTER_URL;
+    }
+  }
+  _cache = { url, ts: Date.now() };
+  return url;
+}
+function invalidateEndpointCache() {
+  _cache = null;
+}
+
+// src/ton/wallet-service.ts
+import { mnemonicNew, mnemonicToPrivateKey, mnemonicValidate } from "@ton/crypto";
+import { WalletContractV5R1, TonClient, fromNano } from "@ton/ton";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+var log = createLogger("TON");
+var WALLET_FILE = join(TELETON_ROOT, "wallet.json");
+var _walletCache;
+var _keyPairCache = null;
+var _tonClientCache = null;
+async function generateWallet() {
+  const mnemonic = await mnemonicNew(24);
+  const keyPair = await mnemonicToPrivateKey(mnemonic);
+  const wallet = WalletContractV5R1.create({
+    workchain: 0,
+    publicKey: keyPair.publicKey
+  });
+  const address = wallet.address.toString({ bounceable: true, testOnly: false });
+  return {
+    version: "w5r1",
+    address,
+    publicKey: keyPair.publicKey.toString("hex"),
+    mnemonic,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function saveWallet(wallet) {
+  const dir = dirname(WALLET_FILE);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(WALLET_FILE, JSON.stringify(wallet, null, 2), { encoding: "utf-8", mode: 384 });
+  _walletCache = void 0;
+  _keyPairCache = null;
+}
+function loadWallet() {
+  if (_walletCache !== void 0) return _walletCache;
+  if (!existsSync(WALLET_FILE)) {
+    _walletCache = null;
+    return null;
+  }
+  try {
+    const content = readFileSync(WALLET_FILE, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed.mnemonic || !Array.isArray(parsed.mnemonic) || parsed.mnemonic.length !== 24) {
+      throw new Error("Invalid wallet.json: mnemonic must be a 24-word array");
+    }
+    _walletCache = parsed;
+    return _walletCache;
+  } catch (error) {
+    log.error({ err: error }, "Failed to load wallet");
+    _walletCache = null;
+    return null;
+  }
+}
+function walletExists() {
+  return existsSync(WALLET_FILE);
+}
+async function importWallet(mnemonic) {
+  const valid = await mnemonicValidate(mnemonic);
+  if (!valid) {
+    throw new Error("Invalid mnemonic: words do not form a valid TON seed phrase");
+  }
+  const keyPair = await mnemonicToPrivateKey(mnemonic);
+  const wallet = WalletContractV5R1.create({
+    workchain: 0,
+    publicKey: keyPair.publicKey
+  });
+  const address = wallet.address.toString({ bounceable: true, testOnly: false });
+  return {
+    version: "w5r1",
+    address,
+    publicKey: keyPair.publicKey.toString("hex"),
+    mnemonic,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function getWalletAddress() {
+  const wallet = loadWallet();
+  return wallet?.address || null;
+}
+async function getCachedTonClient() {
+  const endpoint = await getCachedHttpEndpoint();
+  if (_tonClientCache && _tonClientCache.endpoint === endpoint) {
+    return _tonClientCache.client;
+  }
+  const apiKey = getToncenterApiKey();
+  const client = new TonClient({ endpoint, ...apiKey && { apiKey } });
+  _tonClientCache = { client, endpoint };
+  return client;
+}
+function invalidateTonClientCache() {
+  _tonClientCache = null;
+  invalidateEndpointCache();
+}
+async function getKeyPair() {
+  if (_keyPairCache) return _keyPairCache;
+  const wallet = loadWallet();
+  if (!wallet) return null;
+  _keyPairCache = await mnemonicToPrivateKey(wallet.mnemonic);
+  return _keyPairCache;
+}
+async function getWalletBalance(address) {
+  try {
+    const client = await getCachedTonClient();
+    const { Address } = await import("@ton/core");
+    const addressObj = Address.parse(address);
+    const balance = await client.getBalance(addressObj);
+    const balanceFormatted = fromNano(balance);
+    return {
+      balance: balanceFormatted,
+      balanceNano: balance.toString()
+    };
+  } catch (error) {
+    log.error({ err: error }, "Failed to get balance");
+    return null;
+  }
+}
+var TON_PRICE_CACHE_TTL_MS = 3e4;
+var _tonPriceCache = null;
+async function getTonPrice() {
+  if (_tonPriceCache && Date.now() - _tonPriceCache.timestamp < TON_PRICE_CACHE_TTL_MS) {
+    return { ..._tonPriceCache };
+  }
+  try {
+    const response = await tonapiFetch(`/rates?tokens=ton&currencies=usd`);
+    if (response.ok) {
+      const data = await response.json();
+      const price = data?.rates?.TON?.prices?.USD;
+      if (typeof price === "number" && price > 0) {
+        _tonPriceCache = { usd: price, source: "TonAPI", timestamp: Date.now() };
+        return _tonPriceCache;
+      }
+    }
+  } catch {
+  }
+  try {
+    const response = await fetchWithTimeout(
+      `${COINGECKO_API_URL}/simple/price?ids=the-open-network&vs_currencies=usd`
+    );
+    if (!response.ok) {
+      throw new Error(`CoinGecko API error: ${response.status}`);
+    }
+    const data = await response.json();
+    const price = data["the-open-network"]?.usd;
+    if (typeof price === "number" && price > 0) {
+      _tonPriceCache = { usd: price, source: "CoinGecko", timestamp: Date.now() };
+      return _tonPriceCache;
+    }
+  } catch (error) {
+    log.error({ err: error }, "Failed to get TON price");
+  }
+  return null;
+}
+
+export {
+  setToncenterApiKey,
+  invalidateEndpointCache,
+  generateWallet,
+  saveWallet,
+  loadWallet,
+  walletExists,
+  importWallet,
+  getWalletAddress,
+  getCachedTonClient,
+  invalidateTonClientCache,
+  getKeyPair,
+  getWalletBalance,
+  getTonPrice
+};

package/dist/{chunk-VYKW7FMV.js → chunk-GHMXWAXI.js}

@@ -3,7 +3,7 @@ import {
   createEmbeddingProvider,
   hashText,
   serializeEmbedding
-} from "./chunk-HEDJCLA6.js";
+} from "./chunk-35MX4ZUI.js";
 import {
   FEED_MESSAGE_MAX_CHARS,
   HYBRID_SEARCH_MIN_SCORE,

package/dist/{chunk-J73TA3UM.js → chunk-LVTKJQ7O.js}

@@ -1,15 +1,17 @@
 import {
   getClaudeCodeApiKey,
-  getProviderMetadata,
   refreshClaudeCodeApiKey
-} from "./chunk-YOSUPUAJ.js";
+} from "./chunk-WTDAICGT.js";
 import {
-  appendToTranscript,
-  readTranscript
-} from "./chunk-LC4TV3KL.js";
+  getProviderMetadata
+} from "./chunk-6OOHHJ4N.js";
 import {
   fetchWithTimeout
 } from "./chunk-XQUHC3JZ.js";
+import {
+  appendToTranscript,
+  readTranscript
+} from "./chunk-LC4TV3KL.js";
 import {
   createLogger
 } from "./chunk-NQ6FZKCE.js";

package/dist/chunk-NVKBBTI6.js

@@ -0,0 +1,128 @@
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+
+// src/agent/lifecycle.ts
+import { EventEmitter } from "events";
+var log = createLogger("Lifecycle");
+var AgentLifecycle = class extends EventEmitter {
+  state = "stopped";
+  error;
+  startPromise = null;
+  stopPromise = null;
+  runningSince = null;
+  registeredStartFn = null;
+  registeredStopFn = null;
+  getState() {
+    return this.state;
+  }
+  getError() {
+    return this.error;
+  }
+  getUptime() {
+    if (this.state !== "running" || this.runningSince === null) {
+      return null;
+    }
+    return Math.floor((Date.now() - this.runningSince) / 1e3);
+  }
+  /**
+   * Register the start/stop callbacks so start()/stop() can be called without args.
+   */
+  registerCallbacks(startFn, stopFn) {
+    this.registeredStartFn = startFn;
+    this.registeredStopFn = stopFn;
+  }
+  /**
+   * Start the agent. Uses the provided callback or falls back to registered one.
+   * - No-op if already running
+   * - Returns existing promise if already starting
+   * - Throws if currently stopping
+   */
+  async start(startFn) {
+    const fn = startFn ?? this.registeredStartFn;
+    if (!fn) {
+      throw new Error("No start function provided or registered");
+    }
+    if (this.state === "running") {
+      return;
+    }
+    if (this.state === "starting") {
+      return this.startPromise ?? Promise.resolve();
+    }
+    if (this.state === "stopping") {
+      throw new Error("Cannot start while agent is stopping");
+    }
+    this.transition("starting");
+    this.startPromise = (async () => {
+      try {
+        await fn();
+        this.error = void 0;
+        this.runningSince = Date.now();
+        this.transition("running");
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.error = message;
+        this.runningSince = null;
+        this.transition("stopped", message);
+        throw err;
+      } finally {
+        this.startPromise = null;
+      }
+    })();
+    return this.startPromise;
+  }
+  /**
+   * Stop the agent. Uses the provided callback or falls back to registered one.
+   * - No-op if already stopped
+   * - Returns existing promise if already stopping
+   * - If starting, waits for start to complete then stops
+   */
+  async stop(stopFn) {
+    const fn = stopFn ?? this.registeredStopFn;
+    if (!fn) {
+      throw new Error("No stop function provided or registered");
+    }
+    if (this.state === "stopped") {
+      return;
+    }
+    if (this.state === "stopping") {
+      return this.stopPromise ?? Promise.resolve();
+    }
+    if (this.state === "starting" && this.startPromise) {
+      try {
+        await this.startPromise;
+      } catch {
+        return;
+      }
+    }
+    this.transition("stopping");
+    this.stopPromise = (async () => {
+      try {
+        await fn();
+      } catch (err) {
+        log.error({ err }, "Error during agent stop");
+      } finally {
+        this.runningSince = null;
+        this.transition("stopped");
+        this.stopPromise = null;
+      }
+    })();
+    return this.stopPromise;
+  }
+  transition(newState, error) {
+    this.state = newState;
+    const event = {
+      state: newState,
+      timestamp: Date.now()
+    };
+    if (error !== void 0) {
+      event.error = error;
+    }
+    log.info(`Agent state: ${newState}${error ? ` (${error})` : ""}`);
+    this.emit("stateChange", event);
+  }
+};
+
+export {
+  AgentLifecycle
+};

package/dist/{chunk-57URFK6M.js → chunk-OIMAE24Q.js}

@@ -2,26 +2,30 @@ import {
   getModelsForProvider
 } from "./chunk-WFTC3JJW.js";
 import {
-  ConfigSchema,
-  DealsConfigSchema,
-  ensureWorkspace,
   generateWallet,
   getWalletAddress,
   importWallet,
-  isNewWorkspace,
   saveWallet,
   walletExists
-} from "./chunk-7YKSXOQQ.js";
+} from "./chunk-FUNF6H4W.js";
+import {
+  ConfigSchema,
+  DealsConfigSchema,
+  ensureWorkspace,
+  isNewWorkspace
+} from "./chunk-AERHOXGC.js";
+import {
+  TELEGRAM_MAX_MESSAGE_LENGTH
+} from "./chunk-C4NKJT2Z.js";
 import {
   getClaudeCodeApiKey,
+  isClaudeCodeTokenValid
+} from "./chunk-WTDAICGT.js";
+import {
   getProviderMetadata,
   getSupportedProviders,
-  isClaudeCodeTokenValid,
   validateApiKeyFormat
-} from "./chunk-YOSUPUAJ.js";
-import {
-  TELEGRAM_MAX_MESSAGE_LENGTH
-} from "./chunk-C4NKJT2Z.js";
+} from "./chunk-6OOHHJ4N.js";
 import {
   fetchWithTimeout
 } from "./chunk-XQUHC3JZ.js";
@@ -34,7 +38,7 @@ import {
 
 // src/webui/routes/setup.ts
 import { Hono } from "hono";
-import { existsSync as existsSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync, writeFileSync as writeFileSync2, statSync } from "fs";
 import { join as join2 } from "path";
 import YAML from "yaml";
 
@@ -386,7 +390,7 @@ function maskKey(key) {
   if (key.length <= 10) return "***";
   return key.slice(0, 6) + "..." + key.slice(-4);
 }
-function createSetupRoutes() {
+function createSetupRoutes(options) {
   const app = new Hono();
   const authManager = new TelegramAuthManager();
   app.get("/status", async (c) => {
@@ -744,6 +748,33 @@ function createSetupRoutes() {
       );
     }
   });
+  app.post("/embeddings/warmup", async (c) => {
+    try {
+      const { LocalEmbeddingProvider } = await import("./local-IHKJFQJS.js");
+      const provider = new LocalEmbeddingProvider({});
+      const success = await provider.warmup();
+      return c.json({
+        success,
+        model: provider.model,
+        dimensions: provider.dimensions
+      });
+    } catch (error) {
+      return c.json(
+        { success: false, error: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+  app.get("/embeddings/status", (c) => {
+    const model = "Xenova/all-MiniLM-L6-v2";
+    const modelPath = join2(TELETON_ROOT, "models", model, "onnx", "model.onnx");
+    try {
+      const stats = statSync(modelPath);
+      return c.json({ cached: true, model, modelPath, sizeBytes: stats.size });
+    } catch {
+      return c.json({ cached: false, model, modelPath });
+    }
+  });
   app.post("/config/save", async (c) => {
     try {
       const input = await c.req.json();
@@ -840,7 +871,14 @@ function createSetupRoutes() {
         ...input.cocoon ? { cocoon: input.cocoon } : {},
         ...input.tonapi_key ? { tonapi_key: input.tonapi_key } : {},
         ...input.toncenter_api_key ? { toncenter_api_key: input.toncenter_api_key } : {},
-        ...input.tavily_api_key ? { tavily_api_key: input.tavily_api_key } : {}
+        ...input.tavily_api_key ? { tavily_api_key: input.tavily_api_key } : {},
+        // Persist Management API key hash so it survives reboots
+        api: {
+          enabled: true,
+          port: 7778,
+          host: "0.0.0.0",
+          ...options?.keyHash ? { key_hash: options.keyHash } : {}
+        }
       };
       ConfigSchema.parse(config);
       const configPath = workspace.configPath;