teleton 0.8.2 → 0.8.4

package/dist/bootstrap-NNEI3Z5H.js

@@ -0,0 +1,126 @@
+import {
+  AgentLifecycle
+} from "./chunk-NVKBBTI6.js";
+import {
+  configExists,
+  ensureWorkspace,
+  getDefaultConfigPath
+} from "./chunk-NH2CNRKJ.js";
+import "./chunk-C4NKJT2Z.js";
+import "./chunk-6OOHHJ4N.js";
+import {
+  SHUTDOWN_TIMEOUT_MS
+} from "./chunk-R4YSJ4EY.js";
+import "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/api/bootstrap.ts
+var log = createLogger("Bootstrap");
+async function startApiOnly(options) {
+  await ensureWorkspace({ ensureTemplates: false, silent: false });
+  const configPath = options.config ?? getDefaultConfigPath();
+  const lifecycle = new AgentLifecycle();
+  const deps = {
+    agent: null,
+    bridge: null,
+    memory: null,
+    toolRegistry: null,
+    plugins: null,
+    mcpServers: null,
+    config: {
+      enabled: false,
+      port: 7777,
+      host: "127.0.0.1",
+      cors_origins: [],
+      log_requests: false
+    },
+    configPath,
+    lifecycle,
+    marketplace: null,
+    userHookEvaluator: null
+  };
+  const { ApiServer } = await import("./server-WWGVDFPW.js");
+  const apiConfig = {
+    enabled: true,
+    port: parseInt(options.apiPort || process.env.TELETON_API_PORT || "7778"),
+    key_hash: "",
+    allowed_ips: []
+  };
+  const server = new ApiServer(deps, apiConfig);
+  let appInstance = null;
+  lifecycle.registerCallbacks(
+    // startFn — called when POST /v1/agent/start fires
+    async () => {
+      if (!configExists(configPath)) {
+        throw new Error("Configuration not found. Complete setup via /v1/setup endpoints first.");
+      }
+      const { TeletonApp } = await import("./index.js");
+      appInstance = new TeletonApp(configPath);
+      await appInstance.startAgentSubsystems();
+      server.updateDeps({
+        agent: appInstance.getAgent(),
+        bridge: appInstance.getBridge(),
+        memory: appInstance.getMemory(),
+        toolRegistry: appInstance.getToolRegistry(),
+        plugins: appInstance.getPlugins(),
+        config: appInstance.getWebuiConfig()
+      });
+    },
+    // stopFn — called when POST /v1/agent/stop fires
+    async () => {
+      if (appInstance) {
+        await appInstance.stopAgentSubsystems();
+        appInstance = null;
+        server.updateDeps({
+          agent: null,
+          bridge: null,
+          memory: null,
+          toolRegistry: null,
+          plugins: null
+        });
+      }
+    }
+  );
+  await server.start();
+  if (process.env.TELETON_JSON_CREDENTIALS === "true") {
+    const creds = server.getCredentials();
+    process.stdout.write(JSON.stringify(creds) + "\n");
+  }
+  log.info("API-only mode: complete setup via /v1/setup endpoints, then POST /v1/agent/start");
+  let shutdownInProgress = false;
+  const gracefulShutdown = async () => {
+    if (shutdownInProgress) return;
+    shutdownInProgress = true;
+    const forceExit = setTimeout(() => {
+      log.error("Shutdown timed out, forcing exit");
+      process.exit(1);
+    }, SHUTDOWN_TIMEOUT_MS);
+    forceExit.unref();
+    try {
+      if (lifecycle.getState() === "running") {
+        await lifecycle.stop();
+      }
+      await server.stop();
+    } finally {
+      clearTimeout(forceExit);
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", gracefulShutdown);
+  process.on("SIGTERM", gracefulShutdown);
+  process.on("unhandledRejection", (reason) => {
+    log.error({ err: reason }, "Unhandled rejection");
+  });
+  process.on("uncaughtException", (error) => {
+    log.error({ err: error }, "Uncaught exception");
+    process.exit(1);
+  });
+  await new Promise(() => {
+  });
+}
+export {
+  startApiOnly
+};

package/dist/{chunk-HEDJCLA6.js → chunk-35MX4ZUI.js}

@@ -12,8 +12,8 @@ import {
   fetchWithTimeout
 } from "./chunk-XQUHC3JZ.js";
 import {
-  TELETON_ROOT
-} from "./chunk-EYWNOHMJ.js";
+  LocalEmbeddingProvider
+} from "./chunk-CUE4UZXR.js";
 import {
   createLogger
 } from "./chunk-NQ6FZKCE.js";
@@ -88,125 +88,6 @@ var AnthropicEmbeddingProvider = class {
   }
 };
 
-// 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;
-  }
-};
-
 // src/memory/embeddings/utils.ts
 import { createHash } from "crypto";
 function hashText(text) {
@@ -379,7 +260,6 @@ function createEmbeddingProvider(config) {
 export {
   NoopEmbeddingProvider,
   AnthropicEmbeddingProvider,
-  LocalEmbeddingProvider,
   hashText,
   serializeEmbedding,
   deserializeEmbedding,

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

@@ -2,26 +2,32 @@ import {
   getModelsForProvider
 } from "./chunk-WFTC3JJW.js";
 import {
-  ConfigSchema,
-  DealsConfigSchema,
-  ensureWorkspace,
   generateWallet,
   getWalletAddress,
   importWallet,
-  isNewWorkspace,
+  readRawConfig,
   saveWallet,
-  walletExists
-} from "./chunk-7YKSXOQQ.js";
+  walletExists,
+  writeRawConfig
+} from "./chunk-JROBTXWY.js";
+import {
+  ConfigSchema,
+  DealsConfigSchema,
+  ensureWorkspace,
+  isNewWorkspace
+} from "./chunk-NH2CNRKJ.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 +40,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";
 
@@ -376,7 +382,16 @@ var TelegramAuthManager = class {
       mkdirSync(dir, { recursive: true });
     }
     writeFileSync(sessionPath, sessionString, { mode: 384 });
-    log.info("Telegram session saved");
+    const configPath = join(TELETON_ROOT, "config.yaml");
+    const raw = readRawConfig(configPath);
+    raw.telegram = raw.telegram ?? {};
+    raw.telegram.api_id = session.apiId;
+    raw.telegram.api_hash = session.apiHash;
+    if (session.type === "phone") {
+      raw.telegram.phone = session.phone;
+    }
+    writeRawConfig(raw, configPath);
+    log.info("Telegram session and credentials saved");
   }
 };
 
@@ -386,7 +401,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 +759,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 +882,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;

package/dist/{chunk-YOSUPUAJ.js → chunk-6OOHHJ4N.js}

@@ -1,7 +1,3 @@
-import {
-  createLogger
-} from "./chunk-NQ6FZKCE.js";
-
 // src/config/providers.ts
 var PROVIDER_REGISTRY = {
   anthropic: {
@@ -206,177 +202,8 @@ function validateApiKeyFormat(provider, key) {
   return void 0;
 }
 
-// src/providers/claude-code-credentials.ts
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { execSync } from "child_process";
-import { homedir } from "os";
-import { join } from "path";
-var log = createLogger("ClaudeCodeCreds");
-var OAUTH_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
-var OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-var OAUTH_SCOPES = "user:profile user:inference user:sessions:claude_code user:mcp_servers";
-var cachedToken = null;
-var cachedExpiresAt = 0;
-var cachedRefreshToken = null;
-function getClaudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
-}
-function getCredentialsFilePath() {
-  return join(getClaudeConfigDir(), ".credentials.json");
-}
-function readCredentialsFile() {
-  const filePath = getCredentialsFilePath();
-  if (!existsSync(filePath)) return null;
-  try {
-    const raw = readFileSync(filePath, "utf-8");
-    return JSON.parse(raw);
-  } catch (e) {
-    log.warn({ err: e, path: filePath }, "Failed to parse Claude Code credentials file");
-    return null;
-  }
-}
-function readKeychainCredentials() {
-  const serviceNames = ["Claude Code-credentials", "Claude Code"];
-  for (const service of serviceNames) {
-    try {
-      const raw = execSync(`security find-generic-password -s "${service}" -w`, {
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      return JSON.parse(raw);
-    } catch {
-    }
-  }
-  return null;
-}
-function readCredentials() {
-  if (process.platform === "darwin") {
-    const keychainCreds = readKeychainCredentials();
-    if (keychainCreds) return keychainCreds;
-    log.debug("Keychain read failed, falling back to credentials file");
-  }
-  return readCredentialsFile();
-}
-function extractToken(creds) {
-  const oauth = creds.claudeAiOauth;
-  if (!oauth?.accessToken) {
-    log.warn("Claude Code credentials found but missing accessToken");
-    return null;
-  }
-  return {
-    token: oauth.accessToken,
-    expiresAt: oauth.expiresAt ?? 0,
-    refreshToken: oauth.refreshToken
-  };
-}
-function getClaudeCodeApiKey(fallbackKey) {
-  if (cachedToken && Date.now() < cachedExpiresAt) {
-    return cachedToken;
-  }
-  const creds = readCredentials();
-  if (creds) {
-    const extracted = extractToken(creds);
-    if (extracted) {
-      cachedToken = extracted.token;
-      cachedExpiresAt = extracted.expiresAt;
-      cachedRefreshToken = extracted.refreshToken ?? null;
-      log.debug("Claude Code credentials loaded successfully");
-      return cachedToken;
-    }
-  }
-  if (fallbackKey && fallbackKey.length > 0) {
-    log.warn("Claude Code credentials not found, using fallback api_key from config");
-    return fallbackKey;
-  }
-  throw new Error("No Claude Code credentials found. Run 'claude login' or set api_key in config.");
-}
-async function performOAuthRefresh(refreshToken) {
-  try {
-    const res = await fetch(OAUTH_TOKEN_URL, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        grant_type: "refresh_token",
-        refresh_token: refreshToken,
-        client_id: OAUTH_CLIENT_ID,
-        scope: OAUTH_SCOPES
-      })
-    });
-    if (!res.ok) {
-      log.warn(`OAuth token refresh failed: ${res.status} ${res.statusText}`);
-      return null;
-    }
-    const data = await res.json();
-    if (!data.access_token || !data.expires_in) {
-      log.warn("OAuth token refresh: unexpected response shape");
-      return null;
-    }
-    const newExpiresAt = Date.now() + data.expires_in * 1e3;
-    const newRefreshToken = data.refresh_token ?? refreshToken;
-    const filePath = getCredentialsFilePath();
-    try {
-      const existing = existsSync(filePath) ? JSON.parse(readFileSync(filePath, "utf-8")) : {};
-      const updated = {
-        ...existing,
-        claudeAiOauth: {
-          ...existing.claudeAiOauth,
-          accessToken: data.access_token,
-          refreshToken: newRefreshToken,
-          expiresAt: newExpiresAt
-        }
-      };
-      writeFileSync(filePath, JSON.stringify(updated, null, 2), { mode: 384 });
-    } catch (e) {
-      log.warn({ err: e }, "Failed to persist refreshed OAuth credentials to disk");
-    }
-    cachedToken = data.access_token;
-    cachedExpiresAt = newExpiresAt;
-    cachedRefreshToken = newRefreshToken;
-    log.info("Claude Code OAuth token refreshed successfully");
-    return cachedToken;
-  } catch (e) {
-    log.warn({ err: e }, "OAuth token refresh request failed");
-    return null;
-  }
-}
-async function refreshClaudeCodeApiKey() {
-  cachedToken = null;
-  cachedExpiresAt = 0;
-  if (!cachedRefreshToken) {
-    const creds2 = readCredentials();
-    if (creds2) {
-      const extracted = extractToken(creds2);
-      cachedRefreshToken = extracted?.refreshToken ?? null;
-    }
-  }
-  if (cachedRefreshToken) {
-    const refreshed = await performOAuthRefresh(cachedRefreshToken);
-    if (refreshed) return refreshed;
-    log.warn("OAuth refresh failed, falling back to disk read");
-  }
-  const creds = readCredentials();
-  if (creds) {
-    const extracted = extractToken(creds);
-    if (extracted) {
-      cachedToken = extracted.token;
-      cachedExpiresAt = extracted.expiresAt;
-      cachedRefreshToken = extracted.refreshToken ?? null;
-      log.info("Claude Code credentials refreshed from disk");
-      return cachedToken;
-    }
-  }
-  log.warn("Failed to refresh Claude Code credentials");
-  return null;
-}
-function isClaudeCodeTokenValid() {
-  return cachedToken !== null && Date.now() < cachedExpiresAt;
-}
-
 export {
   getProviderMetadata,
   getSupportedProviders,
-  validateApiKeyFormat,
-  getClaudeCodeApiKey,
-  refreshClaudeCodeApiKey,
-  isClaudeCodeTokenValid
+  validateApiKeyFormat
 };

package/dist/{chunk-W25Z7CM6.js → chunk-ALKAAG4O.js}

@@ -1,9 +1,6 @@
 import {
   getErrorMessage
 } from "./chunk-3UFPFWYP.js";
-import {
-  getUtilityModel
-} from "./chunk-J73TA3UM.js";
 import {
   ADAPTIVE_CHUNK_RATIO_BASE,
   ADAPTIVE_CHUNK_RATIO_MIN,
@@ -17,6 +14,9 @@ import {
   SESSION_SLUG_RECENT_MESSAGES,
   TOKEN_ESTIMATE_SAFETY_MARGIN
 } from "./chunk-C4NKJT2Z.js";
+import {
+  getUtilityModel
+} from "./chunk-LVTKJQ7O.js";
 import {
   createLogger
 } from "./chunk-NQ6FZKCE.js";