teleton 0.8.2 → 0.8.4

package/dist/{chunk-7YKSXOQQ.js → chunk-NH2CNRKJ.js}

@@ -1,13 +1,9 @@
-import {
-  COINGECKO_API_URL,
-  tonapiFetch
-} from "./chunk-VFA7QMCZ.js";
 import {
   TELEGRAM_MAX_MESSAGE_LENGTH
 } from "./chunk-C4NKJT2Z.js";
 import {
-  fetchWithTimeout
-} from "./chunk-XQUHC3JZ.js";
+  getProviderMetadata
+} from "./chunk-6OOHHJ4N.js";
 import {
   TELETON_ROOT,
   WORKSPACE_PATHS,
@@ -17,227 +13,11 @@ 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;
-}
+// src/config/loader.ts
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
+import { parse, stringify } from "yaml";
+import { homedir } from "os";
+import { dirname, join } from "path";
 
 // src/config/schema.ts
 import { z } from "zod";
@@ -429,6 +209,125 @@ var ConfigSchema = z.object({
   tavily_api_key: z.string().optional().describe("Tavily API key for web search & extract (free at https://tavily.com)")
 });
 
+// src/config/loader.ts
+var log = createLogger("Config");
+var DEFAULT_CONFIG_PATH = join(TELETON_ROOT, "config.yaml");
+function expandPath(path) {
+  if (path.startsWith("~")) {
+    return join(homedir(), path.slice(1));
+  }
+  return path;
+}
+function loadConfig(configPath = DEFAULT_CONFIG_PATH) {
+  const fullPath = expandPath(configPath);
+  if (!existsSync(fullPath)) {
+    throw new Error(`Config file not found: ${fullPath}
+Run 'teleton setup' to create one.`);
+  }
+  let content;
+  try {
+    content = readFileSync(fullPath, "utf-8");
+  } catch (error) {
+    throw new Error(`Cannot read config file ${fullPath}: ${error.message}`);
+  }
+  let raw;
+  try {
+    raw = parse(content);
+  } catch (error) {
+    throw new Error(`Invalid YAML in ${fullPath}: ${error.message}`);
+  }
+  if (raw && typeof raw === "object" && "market" in raw) {
+    log.warn("config.market is deprecated and ignored. Use market-api plugin instead.");
+    delete raw.market;
+  }
+  const result = ConfigSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(`Invalid config: ${result.error.message}`);
+  }
+  const config = result.data;
+  const provider = config.agent.provider;
+  if (provider !== "anthropic" && provider !== "claude-code" && !raw.agent?.model) {
+    const meta = getProviderMetadata(provider);
+    config.agent.model = meta.defaultModel;
+  }
+  config.telegram.session_path = expandPath(config.telegram.session_path);
+  config.storage.sessions_file = expandPath(config.storage.sessions_file);
+  config.storage.memory_file = expandPath(config.storage.memory_file);
+  if (process.env.TELETON_API_KEY) {
+    config.agent.api_key = process.env.TELETON_API_KEY;
+  }
+  if (process.env.TELETON_TG_API_ID) {
+    const apiId = parseInt(process.env.TELETON_TG_API_ID, 10);
+    if (isNaN(apiId)) {
+      throw new Error(
+        `Invalid TELETON_TG_API_ID environment variable: "${process.env.TELETON_TG_API_ID}" is not a valid integer`
+      );
+    }
+    config.telegram.api_id = apiId;
+  }
+  if (process.env.TELETON_TG_API_HASH) {
+    config.telegram.api_hash = process.env.TELETON_TG_API_HASH;
+  }
+  if (process.env.TELETON_TG_PHONE) {
+    config.telegram.phone = process.env.TELETON_TG_PHONE;
+  }
+  if (process.env.TELETON_WEBUI_ENABLED) {
+    config.webui.enabled = process.env.TELETON_WEBUI_ENABLED === "true";
+  }
+  if (process.env.TELETON_WEBUI_PORT) {
+    const port = parseInt(process.env.TELETON_WEBUI_PORT, 10);
+    if (!isNaN(port) && port >= 1024 && port <= 65535) {
+      config.webui.port = port;
+    }
+  }
+  if (process.env.TELETON_WEBUI_HOST) {
+    config.webui.host = process.env.TELETON_WEBUI_HOST;
+    if (!["127.0.0.1", "localhost", "::1"].includes(config.webui.host)) {
+      log.warn(
+        { host: config.webui.host },
+        "WebUI bound to non-loopback address \u2014 ensure auth_token is set"
+      );
+    }
+  }
+  if (process.env.TELETON_API_ENABLED) {
+    if (!config.api) config.api = { enabled: false, port: 7778, key_hash: "", allowed_ips: [] };
+    config.api.enabled = process.env.TELETON_API_ENABLED === "true";
+  }
+  if (process.env.TELETON_API_PORT) {
+    const port = parseInt(process.env.TELETON_API_PORT, 10);
+    if (!isNaN(port) && port >= 1024 && port <= 65535) {
+      if (!config.api) config.api = { enabled: false, port: 7778, key_hash: "", allowed_ips: [] };
+      config.api.port = port;
+    }
+  }
+  if (process.env.TELETON_BASE_URL) {
+    try {
+      new URL(process.env.TELETON_BASE_URL);
+      config.agent.base_url = process.env.TELETON_BASE_URL;
+    } catch {
+      throw new Error(
+        `Invalid TELETON_BASE_URL: "${process.env.TELETON_BASE_URL}" is not a valid URL`
+      );
+    }
+  }
+  if (process.env.TELETON_TAVILY_API_KEY) {
+    config.tavily_api_key = process.env.TELETON_TAVILY_API_KEY;
+  }
+  if (process.env.TELETON_TONAPI_KEY) {
+    config.tonapi_key = process.env.TELETON_TONAPI_KEY;
+  }
+  if (process.env.TELETON_TONCENTER_API_KEY) {
+    config.toncenter_api_key = process.env.TELETON_TONCENTER_API_KEY;
+  }
+  return config;
+}
+function configExists(configPath = DEFAULT_CONFIG_PATH) {
+  return existsSync(expandPath(configPath));
+}
+function getDefaultConfigPath() {
+  return DEFAULT_CONFIG_PATH;
+}
+
 // src/workspace/manager.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, copyFileSync } from "fs";
 import { join as join2, dirname as dirname2 } from "path";
@@ -524,20 +423,11 @@ function loadTemplate(name) {
 export {
   DealsConfigSchema,
   ConfigSchema,
+  expandPath,
+  loadConfig,
+  configExists,
+  getDefaultConfigPath,
   ensureWorkspace,
   isNewWorkspace,
-  loadTemplate,
-  setToncenterApiKey,
-  invalidateEndpointCache,
-  generateWallet,
-  saveWallet,
-  loadWallet,
-  walletExists,
-  importWallet,
-  getWalletAddress,
-  getCachedTonClient,
-  invalidateTonClientCache,
-  getKeyPair,
-  getWalletBalance,
-  getTonPrice
+  loadTemplate
 };

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
+};