teleton 0.7.3 → 0.7.5

package/dist/{chunk-RBU6JXD3.js → chunk-2GLHOJ5C.js}

@@ -1,30 +1,159 @@
-import {
-  JOURNAL_SCHEMA
-} from "./chunk-UCN6TI25.js";
 import {
   CachedEmbeddingProvider,
   createEmbeddingProvider,
   hashText,
   serializeEmbedding
-} from "./chunk-FNV5FF35.js";
+} from "./chunk-LCCVZ4D2.js";
 import {
   HYBRID_SEARCH_MIN_SCORE,
   KNOWLEDGE_CHUNK_SIZE,
   SQLITE_CACHE_SIZE_KB,
   SQLITE_MMAP_SIZE
-} from "./chunk-RO62LO6Z.js";
+} from "./chunk-YP25WTQK.js";
+import {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.js";
 import {
   createLogger
 } from "./chunk-RCMD3U65.js";
 
 // src/memory/database.ts
+import Database2 from "better-sqlite3";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+import * as sqliteVec from "sqlite-vec";
+
+// src/utils/module-db.ts
 import Database from "better-sqlite3";
 import { existsSync, mkdirSync, chmodSync } from "fs";
-import { dirname } from "path";
-import * as sqliteVec from "sqlite-vec";
+import { dirname, join } from "path";
+var log = createLogger("Utils");
+var JOURNAL_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS journal (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
+    type TEXT NOT NULL CHECK(type IN ('trade', 'gift', 'middleman', 'kol')),
+    action TEXT NOT NULL,
+    asset_from TEXT,
+    asset_to TEXT,
+    amount_from REAL,
+    amount_to REAL,
+    price_ton REAL,
+    counterparty TEXT,
+    platform TEXT,
+    reasoning TEXT,
+    outcome TEXT CHECK(outcome IN ('pending', 'profit', 'loss', 'neutral', 'cancelled')),
+    pnl_ton REAL,
+    pnl_pct REAL,
+    tx_hash TEXT,
+    tool_used TEXT,
+    chat_id TEXT,
+    user_id INTEGER,
+    closed_at INTEGER,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_journal_type ON journal(type);
+  CREATE INDEX IF NOT EXISTS idx_journal_timestamp ON journal(timestamp DESC);
+  CREATE INDEX IF NOT EXISTS idx_journal_asset_from ON journal(asset_from);
+  CREATE INDEX IF NOT EXISTS idx_journal_outcome ON journal(outcome);
+  CREATE INDEX IF NOT EXISTS idx_journal_type_timestamp ON journal(type, timestamp DESC);
+`;
+var USED_TRANSACTIONS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS used_transactions (
+    tx_hash TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    amount REAL NOT NULL,
+    game_type TEXT NOT NULL,
+    used_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_used_tx_user ON used_transactions(user_id);
+  CREATE INDEX IF NOT EXISTS idx_used_tx_used_at ON used_transactions(used_at);
+`;
+function openModuleDb(path) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(path);
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+  db.pragma("journal_mode = WAL");
+  return db;
+}
+function createDbWrapper(getDb, moduleName) {
+  return function withDb(executor) {
+    return (params, context) => {
+      const moduleDb = getDb();
+      if (!moduleDb) {
+        return Promise.resolve({
+          success: false,
+          error: `${moduleName} module not started`
+        });
+      }
+      return executor(params, { ...context, db: moduleDb });
+    };
+  };
+}
+var MAIN_DB_PATH = join(TELETON_ROOT, "memory.db");
+function migrateFromMainDb(moduleDb, tables) {
+  let totalMigrated = 0;
+  for (const table of tables) {
+    if (!/^[a-z_]+$/.test(table)) {
+      throw new Error(`Invalid table name for migration: "${table}"`);
+    }
+  }
+  for (const table of tables) {
+    try {
+      const row = moduleDb.prepare(`SELECT COUNT(*) as c FROM ${table}`).get();
+      if (row.c > 0) return 0;
+    } catch {
+      continue;
+    }
+  }
+  if (!existsSync(MAIN_DB_PATH)) return 0;
+  try {
+    moduleDb.exec(`ATTACH DATABASE '${MAIN_DB_PATH}' AS main_db`);
+    for (const table of tables) {
+      try {
+        const exists = moduleDb.prepare(`SELECT name FROM main_db.sqlite_master WHERE type='table' AND name=?`).get(table);
+        if (!exists) continue;
+        const src = moduleDb.prepare(`SELECT COUNT(*) as c FROM main_db.${table}`).get();
+        if (src.c === 0) continue;
+        const dstCols = moduleDb.prepare(`PRAGMA table_info(${table})`).all().map((r) => r.name);
+        const srcCols = moduleDb.prepare(`PRAGMA main_db.table_info(${table})`).all().map((r) => r.name);
+        const shared = dstCols.filter((c) => srcCols.includes(c));
+        if (shared.length === 0) continue;
+        const cols = shared.join(", ");
+        moduleDb.exec(
+          `INSERT OR IGNORE INTO ${table} (${cols}) SELECT ${cols} FROM main_db.${table}`
+        );
+        totalMigrated += src.c;
+        try {
+          moduleDb.exec(`DROP TABLE main_db.${table}`);
+        } catch {
+        }
+        log.info(`Migrated ${src.c} rows from memory.db \u2192 ${table} (source dropped)`);
+      } catch (e) {
+        log.warn({ err: e }, `Could not migrate table ${table}`);
+      }
+    }
+    moduleDb.exec(`DETACH DATABASE main_db`);
+  } catch (e) {
+    log.warn({ err: e }, `Migration from memory.db failed`);
+    try {
+      moduleDb.exec(`DETACH DATABASE main_db`);
+    } catch {
+    }
+  }
+  return totalMigrated;
+}
 
 // src/memory/schema.ts
-var log = createLogger("Memory");
+var log2 = createLogger("Memory");
 function compareSemver(a, b) {
   const parseVersion = (v) => {
     const parts = v.split("-")[0].split(".").map(Number);
@@ -119,7 +248,9 @@ function ensureSchema(db) {
       context_tokens INTEGER,            -- Current context size
       model TEXT,                        -- Model used (claude-opus-4-5-20251101)
       provider TEXT,                     -- Provider (anthropic)
-      last_reset_date TEXT               -- YYYY-MM-DD of last daily reset
+      last_reset_date TEXT,              -- YYYY-MM-DD of last daily reset
+      input_tokens INTEGER DEFAULT 0,    -- Accumulated input tokens
+      output_tokens INTEGER DEFAULT 0    -- Accumulated output tokens
     );
 
     CREATE INDEX IF NOT EXISTS idx_sessions_chat ON sessions(chat_id);
@@ -271,6 +402,30 @@ function ensureSchema(db) {
 
     CREATE INDEX IF NOT EXISTS idx_embedding_cache_accessed ON embedding_cache(accessed_at);
 
+    -- =====================================================
+    -- EXEC AUDIT (Command Execution History)
+    -- =====================================================
+
+    CREATE TABLE IF NOT EXISTS exec_audit (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
+      user_id INTEGER NOT NULL,
+      username TEXT,
+      tool TEXT NOT NULL,
+      command TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'running'
+        CHECK(status IN ('running', 'success', 'failed', 'timeout', 'killed')),
+      exit_code INTEGER,
+      signal TEXT,
+      duration_ms INTEGER,
+      stdout TEXT,
+      stderr TEXT,
+      truncated INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_exec_audit_timestamp ON exec_audit(timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_exec_audit_user ON exec_audit(user_id);
+
     -- =====================================================
     -- JOURNAL (Trading & Business Operations)
     -- =====================================================
@@ -313,15 +468,15 @@ function setSchemaVersion(db, version) {
   `
   ).run(version);
 }
-var CURRENT_SCHEMA_VERSION = "1.11.0";
+var CURRENT_SCHEMA_VERSION = "1.13.0";
 function runMigrations(db) {
   const currentVersion = getSchemaVersion(db);
   if (!currentVersion || versionLessThan(currentVersion, "1.1.0")) {
-    log.info("Running migration: Adding scheduled task columns...");
+    log2.info("Running migration: Adding scheduled task columns...");
     try {
       const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='tasks'").get();
       if (!tableExists) {
-        log.info("Tasks table doesn't exist yet, skipping column migration");
+        log2.info("Tasks table doesn't exist yet, skipping column migration");
         setSchemaVersion(db, CURRENT_SCHEMA_VERSION);
         return;
       }
@@ -354,15 +509,15 @@ function runMigrations(db) {
         CREATE INDEX IF NOT EXISTS idx_task_deps_task ON task_dependencies(task_id);
         CREATE INDEX IF NOT EXISTS idx_task_deps_parent ON task_dependencies(depends_on_task_id);
       `);
-      log.info("Migration 1.1.0 complete: Scheduled tasks support added");
+      log2.info("Migration 1.1.0 complete: Scheduled tasks support added");
     } catch (error) {
-      log.error({ err: error }, "Migration 1.1.0 failed");
+      log2.error({ err: error }, "Migration 1.1.0 failed");
       throw error;
     }
   }
   if (!currentVersion || versionLessThan(currentVersion, "1.2.0")) {
     try {
-      log.info("Running migration 1.2.0: Extend sessions table for SQLite backend");
+      log2.info("Running migration 1.2.0: Extend sessions table for SQLite backend");
       const addColumnIfNotExists = (table, column, type) => {
         try {
           db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
@@ -391,14 +546,14 @@ function runMigrations(db) {
         );
       }
       db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC)");
-      log.info("Migration 1.2.0 complete: Sessions table extended");
+      log2.info("Migration 1.2.0 complete: Sessions table extended");
     } catch (error) {
-      log.error({ err: error }, "Migration 1.2.0 failed");
+      log2.error({ err: error }, "Migration 1.2.0 failed");
       throw error;
     }
   }
   if (!currentVersion || versionLessThan(currentVersion, "1.9.0")) {
-    log.info("Running migration 1.9.0: Upgrade embedding_cache to BLOB storage");
+    log2.info("Running migration 1.9.0: Upgrade embedding_cache to BLOB storage");
     try {
       db.exec(`DROP TABLE IF EXISTS embedding_cache`);
       db.exec(`
@@ -414,14 +569,14 @@ function runMigrations(db) {
         );
         CREATE INDEX IF NOT EXISTS idx_embedding_cache_accessed ON embedding_cache(accessed_at);
       `);
-      log.info("Migration 1.9.0 complete: embedding_cache upgraded to BLOB storage");
+      log2.info("Migration 1.9.0 complete: embedding_cache upgraded to BLOB storage");
     } catch (error) {
-      log.error({ err: error }, "Migration 1.9.0 failed");
+      log2.error({ err: error }, "Migration 1.9.0 failed");
       throw error;
     }
   }
   if (!currentVersion || versionLessThan(currentVersion, "1.10.0")) {
-    log.info("Running migration 1.10.0: Add tool_config table for runtime tool management");
+    log2.info("Running migration 1.10.0: Add tool_config table for runtime tool management");
     try {
       db.exec(`
         CREATE TABLE IF NOT EXISTS tool_config (
@@ -432,14 +587,14 @@ function runMigrations(db) {
           updated_by INTEGER
         );
       `);
-      log.info("Migration 1.10.0 complete: tool_config table created");
+      log2.info("Migration 1.10.0 complete: tool_config table created");
     } catch (error) {
-      log.error({ err: error }, "Migration 1.10.0 failed");
+      log2.error({ err: error }, "Migration 1.10.0 failed");
       throw error;
     }
   }
   if (!currentVersion || versionLessThan(currentVersion, "1.10.1")) {
-    log.info("Running migration 1.10.1: Fix tool_config scope CHECK constraint (add admin-only)");
+    log2.info("Running migration 1.10.1: Fix tool_config scope CHECK constraint (add admin-only)");
     try {
       db.transaction(() => {
         db.exec(`
@@ -455,14 +610,14 @@ function runMigrations(db) {
           ALTER TABLE tool_config_new RENAME TO tool_config;
         `);
       })();
-      log.info("Migration 1.10.1 complete: tool_config CHECK constraint updated");
+      log2.info("Migration 1.10.1 complete: tool_config CHECK constraint updated");
     } catch (error) {
-      log.error({ err: error }, "Migration 1.10.1 failed");
+      log2.error({ err: error }, "Migration 1.10.1 failed");
       throw error;
     }
   }
   if (!currentVersion || versionLessThan(currentVersion, "1.11.0")) {
-    log.info("Running migration 1.11.0: Add tool_index tables for Tool RAG");
+    log2.info("Running migration 1.11.0: Add tool_index tables for Tool RAG");
     try {
       db.exec(`
         CREATE TABLE IF NOT EXISTS tool_index (
@@ -494,9 +649,58 @@ function runMigrations(db) {
           VALUES (new.rowid, new.search_text, new.name);
         END;
       `);
-      log.info("Migration 1.11.0 complete: tool_index tables created");
+      log2.info("Migration 1.11.0 complete: tool_index tables created");
+    } catch (error) {
+      log2.error({ err: error }, "Migration 1.11.0 failed");
+      throw error;
+    }
+  }
+  if (!currentVersion || versionLessThan(currentVersion, "1.12.0")) {
+    log2.info("Running migration 1.12.0: Add exec_audit table");
+    try {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS exec_audit (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
+          user_id INTEGER NOT NULL,
+          username TEXT,
+          tool TEXT NOT NULL,
+          command TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'pending',
+          exit_code INTEGER,
+          signal TEXT,
+          duration_ms INTEGER,
+          stdout TEXT,
+          stderr TEXT,
+          truncated INTEGER NOT NULL DEFAULT 0
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_exec_audit_timestamp ON exec_audit(timestamp DESC);
+        CREATE INDEX IF NOT EXISTS idx_exec_audit_user ON exec_audit(user_id);
+      `);
+      log2.info("Migration 1.12.0 complete: exec_audit table created");
+    } catch (error) {
+      log2.error({ err: error }, "Migration 1.12.0 failed");
+      throw error;
+    }
+  }
+  if (!currentVersion || versionLessThan(currentVersion, "1.13.0")) {
+    log2.info("Running migration 1.13.0: Add token usage columns to sessions");
+    try {
+      const addColumnIfNotExists = (table, column, type) => {
+        try {
+          db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+        } catch (e) {
+          if (!e.message.includes("duplicate column name")) {
+            throw e;
+          }
+        }
+      };
+      addColumnIfNotExists("sessions", "input_tokens", "INTEGER DEFAULT 0");
+      addColumnIfNotExists("sessions", "output_tokens", "INTEGER DEFAULT 0");
+      log2.info("Migration 1.13.0 complete: Token usage columns added to sessions");
     } catch (error) {
-      log.error({ err: error }, "Migration 1.11.0 failed");
+      log2.error({ err: error }, "Migration 1.13.0 failed");
       throw error;
     }
   }
@@ -504,22 +708,22 @@ function runMigrations(db) {
 }
 
 // src/memory/database.ts
-var log2 = createLogger("Memory");
+var log3 = createLogger("Memory");
 var MemoryDatabase = class {
   db;
   config;
   vectorReady = false;
   constructor(config) {
     this.config = config;
-    const dir = dirname(config.path);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
+    const dir = dirname2(config.path);
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
     }
-    this.db = new Database(config.path, {
-      verbose: process.env.DEBUG_SQL ? (msg) => log2.debug(String(msg)) : void 0
+    this.db = new Database2(config.path, {
+      verbose: process.env.DEBUG_SQL ? (msg) => log3.debug(String(msg)) : void 0
     });
     try {
-      chmodSync(config.path, 384);
+      chmodSync2(config.path, 384);
     } catch {
     }
     this.db.pragma("journal_mode = WAL");
@@ -556,16 +760,16 @@ var MemoryDatabase = class {
       ensureVectorTables(this.db, dims);
       this.vectorReady = true;
     } catch (error) {
-      log2.warn(`sqlite-vec not available, vector search disabled: ${error.message}`);
-      log2.warn("Falling back to keyword-only search");
+      log3.warn(`sqlite-vec not available, vector search disabled: ${error.message}`);
+      log3.warn("Falling back to keyword-only search");
       this.config.enableVectorSearch = false;
     }
   }
   migrate(from, to) {
-    log2.info(`Migrating database from ${from} to ${to}...`);
+    log3.info(`Migrating database from ${from} to ${to}...`);
     runMigrations(this.db);
     ensureSchema(this.db);
-    log2.info("Migration complete");
+    log3.info("Migration complete");
   }
   getDb() {
     return this.db;
@@ -667,8 +871,8 @@ function closeDatabase() {
 }
 
 // src/memory/agent/knowledge.ts
-import { readFileSync, existsSync as existsSync2, readdirSync, statSync } from "fs";
-import { join } from "path";
+import { readFileSync, existsSync as existsSync3, readdirSync, statSync } from "fs";
+import { join as join2 } from "path";
 var KnowledgeIndexer = class {
   constructor(db, workspaceDir, embedder, vectorEnabled) {
     this.db = db;
@@ -691,7 +895,7 @@ var KnowledgeIndexer = class {
     return { indexed, skipped };
   }
   async indexFile(absPath) {
-    if (!existsSync2(absPath) || !absPath.endsWith(".md")) {
+    if (!existsSync3(absPath) || !absPath.endsWith(".md")) {
       return false;
     }
     const content = readFileSync(absPath, "utf-8");
@@ -739,15 +943,15 @@ var KnowledgeIndexer = class {
   }
   listMemoryFiles() {
     const files = [];
-    const memoryMd = join(this.workspaceDir, "MEMORY.md");
-    if (existsSync2(memoryMd)) {
+    const memoryMd = join2(this.workspaceDir, "MEMORY.md");
+    if (existsSync3(memoryMd)) {
       files.push(memoryMd);
     }
-    const memoryDir = join(this.workspaceDir, "memory");
-    if (existsSync2(memoryDir)) {
+    const memoryDir = join2(this.workspaceDir, "memory");
+    if (existsSync3(memoryDir)) {
       const entries = readdirSync(memoryDir);
       for (const entry of entries) {
-        const absPath = join(memoryDir, entry);
+        const absPath = join2(memoryDir, entry);
         if (statSync(absPath).isFile() && entry.endsWith(".md")) {
           files.push(absPath);
         }
@@ -814,7 +1018,7 @@ var KnowledgeIndexer = class {
 
 // src/memory/agent/sessions.ts
 import { randomUUID } from "crypto";
-var log3 = createLogger("Memory");
+var log4 = createLogger("Memory");
 var SessionStore = class {
   constructor(db, embedder, vectorEnabled) {
     this.db = db;
@@ -938,9 +1142,9 @@ ${session.summary}`;
         this.db.prepare(`DELETE FROM knowledge_vec WHERE id = ?`).run(knowledgeId);
         this.db.prepare(`INSERT INTO knowledge_vec (id, embedding) VALUES (?, ?)`).run(knowledgeId, embeddingBuffer);
       }
-      log3.info(`Indexed session ${sessionId} to knowledge base`);
+      log4.info(`Indexed session ${sessionId} to knowledge base`);
     } catch (error) {
-      log3.error({ err: error }, "Error indexing session");
+      log4.error({ err: error }, "Error indexing session");
     }
   }
   deleteSession(sessionId) {
@@ -1305,7 +1509,7 @@ var UserStore = class {
 };
 
 // src/memory/search/hybrid.ts
-var log4 = createLogger("Memory");
+var log5 = createLogger("Memory");
 function escapeFts5Query(query) {
   return query.replace(/["\*\-\+\(\)\:\^\~\?\.\@\#\$\%\&\!\[\]\{\}\|\\\/<>=,;'`]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -1353,7 +1557,7 @@ var HybridSearch = class {
         vectorScore: 1 - row.distance
       }));
     } catch (error) {
-      log4.error({ err: error }, "Vector search error (knowledge)");
+      log5.error({ err: error }, "Vector search error (knowledge)");
       return [];
     }
   }
@@ -1376,7 +1580,7 @@ var HybridSearch = class {
         keywordScore: this.bm25ToScore(row.score)
       }));
     } catch (error) {
-      log4.error({ err: error }, "FTS5 search error (knowledge)");
+      log5.error({ err: error }, "FTS5 search error (knowledge)");
       return [];
     }
   }
@@ -1411,7 +1615,7 @@ var HybridSearch = class {
         vectorScore: 1 - row.distance
       }));
     } catch (error) {
-      log4.error({ err: error }, "Vector search error (messages)");
+      log5.error({ err: error }, "Vector search error (messages)");
       return [];
     }
   }
@@ -1441,7 +1645,7 @@ var HybridSearch = class {
         keywordScore: this.bm25ToScore(row.score)
       }));
     } catch (error) {
-      log4.error({ err: error }, "FTS5 search error (messages)");
+      log5.error({ err: error }, "FTS5 search error (messages)");
       return [];
     }
   }
@@ -1471,7 +1675,7 @@ var HybridSearch = class {
 };
 
 // src/memory/search/context.ts
-var log5 = createLogger("Memory");
+var log6 = createLogger("Memory");
 var ContextBuilder = class {
   constructor(db, embedder, vectorEnabled) {
     this.db = db;
@@ -1505,7 +1709,7 @@ var ContextBuilder = class {
         });
         relevantKnowledge.push(...knowledgeResults.map((r) => r.text));
       } catch (error) {
-        log5.warn({ err: error }, "Knowledge search failed");
+        log6.warn({ err: error }, "Knowledge search failed");
       }
     }
     const recentTextsSet = new Set(
@@ -1535,7 +1739,7 @@ var ContextBuilder = class {
           }
         }
       } catch (error) {
-        log5.warn({ err: error }, "Feed search failed");
+        log6.warn({ err: error }, "Feed search failed");
       }
       if (relevantFeed.length === 0 && recentTgMessages.length > 0) {
         const recentTexts = recentTgMessages.filter((m) => m.text && m.text.length > 0).slice(-maxRelevantChunks).map((m) => {
@@ -1573,6 +1777,11 @@ function initializeMemory(config) {
 }
 
 export {
+  JOURNAL_SCHEMA,
+  USED_TRANSACTIONS_SCHEMA,
+  openModuleDb,
+  createDbWrapper,
+  migrateFromMainDb,
   ensureSchema,
   ensureVectorTables,
   getSchemaVersion,