teleton 0.8.3 → 0.8.5

package/dist/{chunk-OIMAE24Q.js → chunk-7ZXUUDQQ.js}

@@ -5,18 +5,20 @@ import {
   generateWallet,
   getWalletAddress,
   importWallet,
+  readRawConfig,
   saveWallet,
-  walletExists
-} from "./chunk-FUNF6H4W.js";
+  walletExists,
+  writeRawConfig
+} from "./chunk-M6M4DCDU.js";
 import {
   ConfigSchema,
   DealsConfigSchema,
   ensureWorkspace,
   isNewWorkspace
-} from "./chunk-AERHOXGC.js";
+} from "./chunk-FSL2MOYK.js";
 import {
   TELEGRAM_MAX_MESSAGE_LENGTH
-} from "./chunk-C4NKJT2Z.js";
+} from "./chunk-L3LPVF4Z.js";
 import {
   getClaudeCodeApiKey,
   isClaudeCodeTokenValid
@@ -31,7 +33,7 @@ import {
 } from "./chunk-XQUHC3JZ.js";
 import {
   TELETON_ROOT
-} from "./chunk-EYWNOHMJ.js";
+} from "./chunk-L653KKCR.js";
 import {
   createLogger
 } from "./chunk-NQ6FZKCE.js";
@@ -380,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");
   }
 };
 
@@ -750,7 +761,7 @@ function createSetupRoutes(options) {
   });
   app.post("/embeddings/warmup", async (c) => {
     try {
-      const { LocalEmbeddingProvider } = await import("./local-IHKJFQJS.js");
+      const { LocalEmbeddingProvider } = await import("./local-HQ3UJ7KR.js");
       const provider = new LocalEmbeddingProvider({});
       const success = await provider.warmup();
       return c.json({

package/dist/{chunk-AERHOXGC.js → chunk-FSL2MOYK.js}

@@ -1,106 +1,23 @@
 import {
   TELEGRAM_MAX_MESSAGE_LENGTH
-} from "./chunk-C4NKJT2Z.js";
+} from "./chunk-L3LPVF4Z.js";
+import {
+  getProviderMetadata
+} from "./chunk-6OOHHJ4N.js";
 import {
   TELETON_ROOT,
   WORKSPACE_PATHS,
   WORKSPACE_ROOT
-} from "./chunk-EYWNOHMJ.js";
+} from "./chunk-L653KKCR.js";
 import {
   createLogger
 } from "./chunk-NQ6FZKCE.js";
 
-// src/workspace/manager.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-var log = createLogger("Workspace");
-function findPackageRoot() {
-  let dir = dirname(fileURLToPath(import.meta.url));
-  for (let i = 0; i < 10; i++) {
-    if (existsSync(join(dir, "package.json"))) return dir;
-    dir = dirname(dir);
-  }
-  return process.cwd();
-}
-var TEMPLATES_DIR = join(findPackageRoot(), "src", "templates");
-async function ensureWorkspace(config) {
-  const silent = config?.silent ?? false;
-  if (!existsSync(TELETON_ROOT)) {
-    mkdirSync(TELETON_ROOT, { recursive: true });
-    if (!silent) log.info(`Created Teleton root at ${TELETON_ROOT}`);
-  }
-  if (!existsSync(WORKSPACE_ROOT)) {
-    mkdirSync(WORKSPACE_ROOT, { recursive: true });
-    if (!silent) log.info(`Created workspace at ${WORKSPACE_ROOT}`);
-  }
-  const directories = [
-    WORKSPACE_PATHS.MEMORY_DIR,
-    WORKSPACE_PATHS.DOWNLOADS_DIR,
-    WORKSPACE_PATHS.UPLOADS_DIR,
-    WORKSPACE_PATHS.TEMP_DIR,
-    WORKSPACE_PATHS.MEMES_DIR
-  ];
-  for (const dir of directories) {
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-  }
-  const workspace = {
-    root: TELETON_ROOT,
-    workspace: WORKSPACE_ROOT,
-    // Workspace files
-    soulPath: WORKSPACE_PATHS.SOUL,
-    memoryPath: WORKSPACE_PATHS.MEMORY,
-    identityPath: WORKSPACE_PATHS.IDENTITY,
-    userPath: WORKSPACE_PATHS.USER,
-    strategyPath: WORKSPACE_PATHS.STRATEGY,
-    securityPath: WORKSPACE_PATHS.SECURITY,
-    // Workspace directories
-    memoryDir: WORKSPACE_PATHS.MEMORY_DIR,
-    downloadsDir: WORKSPACE_PATHS.DOWNLOADS_DIR,
-    uploadsDir: WORKSPACE_PATHS.UPLOADS_DIR,
-    tempDir: WORKSPACE_PATHS.TEMP_DIR,
-    memesDir: WORKSPACE_PATHS.MEMES_DIR,
-    // Protected files (outside workspace)
-    sessionPath: join(TELETON_ROOT, "telegram_session.txt"),
-    configPath: join(TELETON_ROOT, "config.yaml"),
-    walletPath: join(TELETON_ROOT, "wallet.json")
-  };
-  if (config?.ensureTemplates) {
-    await bootstrapTemplates(workspace, silent);
-  }
-  return workspace;
-}
-async function bootstrapTemplates(workspace, silent = false) {
-  const templates = [
-    { name: "SOUL.md", path: workspace.soulPath },
-    { name: "MEMORY.md", path: workspace.memoryPath },
-    { name: "IDENTITY.md", path: workspace.identityPath },
-    { name: "USER.md", path: workspace.userPath },
-    { name: "SECURITY.md", path: workspace.securityPath },
-    { name: "STRATEGY.md", path: workspace.strategyPath }
-  ];
-  for (const template of templates) {
-    if (!existsSync(template.path)) {
-      const templateSource = join(TEMPLATES_DIR, template.name);
-      if (existsSync(templateSource)) {
-        copyFileSync(templateSource, template.path);
-        if (!silent) log.info(`Created ${template.name}`);
-      }
-    }
-  }
-}
-function isNewWorkspace(workspace) {
-  return !existsSync(workspace.configPath);
-}
-function loadTemplate(name) {
-  const templatePath = join(TEMPLATES_DIR, name);
-  if (!existsSync(templatePath)) {
-    throw new Error(`Template ${name} not found at ${templatePath}`);
-  }
-  return readFileSync(templatePath, "utf-8");
-}
+// 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";
@@ -268,6 +185,15 @@ var _CapabilitiesObject = z.object({
   exec: _ExecObject.default(_ExecObject.parse({}))
 });
 var CapabilitiesConfigSchema = _CapabilitiesObject.default(_CapabilitiesObject.parse({}));
+var _HeartbeatObject = z.object({
+  enabled: z.boolean().default(true).describe("Enable periodic heartbeat timer"),
+  interval_ms: z.number().min(6e4).default(18e5).describe("Heartbeat interval in milliseconds (min 60s, default 30min)"),
+  prompt: z.string().default(
+    "Read HEARTBEAT.md if it exists. Follow it strictly. If nothing needs attention, reply NO_ACTION."
+  ).describe("Prompt sent to agent on each heartbeat tick"),
+  self_configurable: z.boolean().default(false).describe("Allow agent to modify heartbeat config via config_set")
+});
+var HeartbeatConfigSchema = _HeartbeatObject.default(_HeartbeatObject.parse({}));
 var ConfigSchema = z.object({
   meta: MetaConfigSchema.default(MetaConfigSchema.parse({})),
   agent: AgentConfigSchema,
@@ -282,6 +208,7 @@ var ConfigSchema = z.object({
   capabilities: CapabilitiesConfigSchema,
   api: ApiConfigSchema.optional(),
   ton_proxy: TonProxyConfigSchema,
+  heartbeat: HeartbeatConfigSchema,
   mcp: McpConfigSchema,
   plugins: z.record(z.string(), z.unknown()).default({}).describe("Per-plugin config (key = plugin name with underscores)"),
   cocoon: z.object({
@@ -292,9 +219,225 @@ 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";
+import { fileURLToPath } from "url";
+var log2 = createLogger("Workspace");
+function findPackageRoot() {
+  let dir = dirname2(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 10; i++) {
+    if (existsSync2(join2(dir, "package.json"))) return dir;
+    dir = dirname2(dir);
+  }
+  return process.cwd();
+}
+var TEMPLATES_DIR = join2(findPackageRoot(), "src", "templates");
+async function ensureWorkspace(config) {
+  const silent = config?.silent ?? false;
+  if (!existsSync2(TELETON_ROOT)) {
+    mkdirSync2(TELETON_ROOT, { recursive: true });
+    if (!silent) log2.info(`Created Teleton root at ${TELETON_ROOT}`);
+  }
+  if (!existsSync2(WORKSPACE_ROOT)) {
+    mkdirSync2(WORKSPACE_ROOT, { recursive: true });
+    if (!silent) log2.info(`Created workspace at ${WORKSPACE_ROOT}`);
+  }
+  const directories = [
+    WORKSPACE_PATHS.MEMORY_DIR,
+    WORKSPACE_PATHS.DOWNLOADS_DIR,
+    WORKSPACE_PATHS.UPLOADS_DIR,
+    WORKSPACE_PATHS.TEMP_DIR,
+    WORKSPACE_PATHS.MEMES_DIR
+  ];
+  for (const dir of directories) {
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+  }
+  const workspace = {
+    root: TELETON_ROOT,
+    workspace: WORKSPACE_ROOT,
+    // Workspace files
+    soulPath: WORKSPACE_PATHS.SOUL,
+    memoryPath: WORKSPACE_PATHS.MEMORY,
+    identityPath: WORKSPACE_PATHS.IDENTITY,
+    userPath: WORKSPACE_PATHS.USER,
+    strategyPath: WORKSPACE_PATHS.STRATEGY,
+    securityPath: WORKSPACE_PATHS.SECURITY,
+    // Workspace directories
+    memoryDir: WORKSPACE_PATHS.MEMORY_DIR,
+    downloadsDir: WORKSPACE_PATHS.DOWNLOADS_DIR,
+    uploadsDir: WORKSPACE_PATHS.UPLOADS_DIR,
+    tempDir: WORKSPACE_PATHS.TEMP_DIR,
+    memesDir: WORKSPACE_PATHS.MEMES_DIR,
+    // Protected files (outside workspace)
+    sessionPath: join2(TELETON_ROOT, "telegram_session.txt"),
+    configPath: join2(TELETON_ROOT, "config.yaml"),
+    walletPath: join2(TELETON_ROOT, "wallet.json")
+  };
+  if (config?.ensureTemplates) {
+    await bootstrapTemplates(workspace, silent);
+  }
+  return workspace;
+}
+async function bootstrapTemplates(workspace, silent = false) {
+  const templates = [
+    { name: "SOUL.md", path: workspace.soulPath },
+    { name: "MEMORY.md", path: workspace.memoryPath },
+    { name: "IDENTITY.md", path: workspace.identityPath },
+    { name: "USER.md", path: workspace.userPath },
+    { name: "SECURITY.md", path: workspace.securityPath },
+    { name: "STRATEGY.md", path: workspace.strategyPath },
+    { name: "HEARTBEAT.md", path: WORKSPACE_PATHS.HEARTBEAT }
+  ];
+  for (const template of templates) {
+    if (!existsSync2(template.path)) {
+      const templateSource = join2(TEMPLATES_DIR, template.name);
+      if (existsSync2(templateSource)) {
+        copyFileSync(templateSource, template.path);
+        if (!silent) log2.info(`Created ${template.name}`);
+      }
+    }
+  }
+}
+function isNewWorkspace(workspace) {
+  return !existsSync2(workspace.configPath);
+}
+function loadTemplate(name) {
+  const templatePath = join2(TEMPLATES_DIR, name);
+  if (!existsSync2(templatePath)) {
+    throw new Error(`Template ${name} not found at ${templatePath}`);
+  }
+  return readFileSync2(templatePath, "utf-8");
+}
+
 export {
   DealsConfigSchema,
   ConfigSchema,
+  expandPath,
+  loadConfig,
+  configExists,
+  getDefaultConfigPath,
   ensureWorkspace,
   isNewWorkspace,
   loadTemplate

package/dist/{chunk-LC4TV3KL.js → chunk-GUX6ZFVF.js}

@@ -1,6 +1,6 @@
 import {
   TELETON_ROOT
-} from "./chunk-EYWNOHMJ.js";
+} from "./chunk-L653KKCR.js";
 import {
   createLogger
 } from "./chunk-NQ6FZKCE.js";

package/dist/{chunk-CUE4UZXR.js → chunk-KYSAHDYE.js}

@@ -1,6 +1,6 @@
 import {
   TELETON_ROOT
-} from "./chunk-EYWNOHMJ.js";
+} from "./chunk-L653KKCR.js";
 import {
   createLogger
 } from "./chunk-NQ6FZKCE.js";
@@ -42,7 +42,7 @@ async function ensureModelCached(model) {
     }
     const buffer = Buffer.from(await res.arrayBuffer());
     const tmpPath = localPath + ".tmp";
-    writeFileSync(tmpPath, buffer);
+    writeFileSync(tmpPath, buffer, { mode: 384 });
     renameSync(tmpPath, localPath);
   }
 }

package/dist/{chunk-C4NKJT2Z.js → chunk-L3LPVF4Z.js}

@@ -11,7 +11,7 @@ var SQLITE_CACHE_SIZE_KB = 64e3;
 var SQLITE_MMAP_SIZE = 256e6;
 var SECONDS_PER_DAY = 86400;
 var SECONDS_PER_HOUR = 3600;
-var COMPACTION_MAX_MESSAGES = 200;
+var COMPACTION_MAX_MESSAGES = 1e3;
 var COMPACTION_KEEP_RECENT = 20;
 var COMPACTION_MAX_TOKENS_RATIO = 0.75;
 var COMPACTION_SOFT_THRESHOLD_RATIO = 0.5;

package/dist/{chunk-EYWNOHMJ.js → chunk-L653KKCR.js}

@@ -11,6 +11,7 @@ var WORKSPACE_PATHS = {
   USER: join(WORKSPACE_ROOT, "USER.md"),
   STRATEGY: join(WORKSPACE_ROOT, "STRATEGY.md"),
   SECURITY: join(WORKSPACE_ROOT, "SECURITY.md"),
+  HEARTBEAT: join(WORKSPACE_ROOT, "HEARTBEAT.md"),
   // Directories
   MEMORY_DIR: join(WORKSPACE_ROOT, "memory"),
   DOWNLOADS_DIR: join(WORKSPACE_ROOT, "downloads"),

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

@@ -13,10 +13,10 @@ import {
   SESSION_SLUG_MAX_TOKENS,
   SESSION_SLUG_RECENT_MESSAGES,
   TOKEN_ESTIMATE_SAFETY_MARGIN
-} from "./chunk-C4NKJT2Z.js";
+} from "./chunk-L3LPVF4Z.js";
 import {
   getUtilityModel
-} from "./chunk-LVTKJQ7O.js";
+} from "./chunk-4KURCUWD.js";
 import {
   createLogger
 } from "./chunk-NQ6FZKCE.js";
@@ -352,7 +352,7 @@ Slug:`,
 }
 async function saveSessionMemory(params) {
   try {
-    const { TELETON_ROOT } = await import("./paths-XA2RJH4S.js");
+    const { TELETON_ROOT } = await import("./paths-WMVV7ZAJ.js");
     const memoryDir = join(TELETON_ROOT, "memory");
     await mkdir(memoryDir, { recursive: true });
     const now = /* @__PURE__ */ new Date();
@@ -415,7 +415,7 @@ var CONSOLIDATION_THRESHOLD = 20;
 var CONSOLIDATION_BATCH = 10;
 async function consolidateOldMemoryFiles(params) {
   try {
-    const { TELETON_ROOT } = await import("./paths-XA2RJH4S.js");
+    const { TELETON_ROOT } = await import("./paths-WMVV7ZAJ.js");
     const memoryDir = join(TELETON_ROOT, "memory");
     let entries;
     try {