@smart-tinker/kayla 0.1.0

package/dist/core/sessions.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrCreateSession = getOrCreateSession;
+exports.createNewSession = createNewSession;
+exports.resetSession = resetSession;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function ensureDir(p) {
+    node_fs_1.default.mkdirSync(p, { recursive: true });
+}
+function safeWorkspaceName(chatId) {
+    // Telegram chat_id may be negative; keep as-is but avoid path separators.
+    return chatId.split("/").join("_");
+}
+function defaultWorkspacePath(cfg, chatId) {
+    return node_path_1.default.join(cfg.runtime.workspaces_dir, safeWorkspaceName(chatId));
+}
+function newWorkspacePath(cfg, chatId) {
+    return node_path_1.default.join(cfg.runtime.workspaces_dir, `${safeWorkspaceName(chatId)}-${Date.now()}`);
+}
+function getOrCreateSession(storage, cfg, chatIdRaw, userIdRaw) {
+    const chatId = String(chatIdRaw);
+    const userId = String(userIdRaw);
+    const existing = storage.getChat(chatId);
+    if (existing) {
+        ensureDir(existing.workspace_path);
+        return { chatId, userId: existing.user_id, workspacePath: existing.workspace_path };
+    }
+    const workspacePath = defaultWorkspacePath(cfg, chatId);
+    ensureDir(workspacePath);
+    const inserted = storage.upsertChat({ chatId, userId, workspacePath, settings: {} });
+    return { chatId, userId: inserted.user_id, workspacePath: inserted.workspace_path };
+}
+function createNewSession(storage, cfg, chatIdRaw, userIdRaw) {
+    const chatId = String(chatIdRaw);
+    const existing = storage.getChat(chatId);
+    if (!existing) {
+        // If no chat yet, "new" is equivalent to create.
+        return getOrCreateSession(storage, cfg, chatIdRaw, userIdRaw);
+    }
+    let workspacePath = newWorkspacePath(cfg, chatId);
+    // Extremely unlikely, but avoid collisions in fast loops.
+    for (let i = 0; i < 5 && node_fs_1.default.existsSync(workspacePath); i++) {
+        workspacePath = newWorkspacePath(cfg, chatId);
+    }
+    ensureDir(workspacePath);
+    const updated = storage.updateChatWorkspace(chatId, workspacePath);
+    return { chatId, userId: updated.user_id, workspacePath: updated.workspace_path };
+}
+function resetSession(storage, cfg, chatIdRaw, userIdRaw) {
+    const session = getOrCreateSession(storage, cfg, chatIdRaw, userIdRaw);
+    node_fs_1.default.rmSync(session.workspacePath, { recursive: true, force: true });
+    ensureDir(session.workspacePath);
+    // Workspace path remains the same; just return current mapping.
+    return getOrCreateSession(storage, cfg, chatIdRaw, userIdRaw);
+}

package/dist/core/setup.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeDefaultSetupPaths = computeDefaultSetupPaths;
+exports.ensureDir = ensureDir;
+exports.ensureXdgDirs = ensureXdgDirs;
+exports.parseCsvNumbersStrict = parseCsvNumbersStrict;
+exports.renderSystemdTemplate = renderSystemdTemplate;
+exports.buildConfigFromBootstrapInputs = buildConfigFromBootstrapInputs;
+exports.parseBootstrapInputsFromEnv = parseBootstrapInputsFromEnv;
+exports.buildConfigFromEnv = buildConfigFromEnv;
+exports.promptBootstrapInputs = promptBootstrapInputs;
+exports.nonInteractiveSetupError = nonInteractiveSetupError;
+exports.bootstrapConfig = bootstrapConfig;
+exports.writeConfigIfMissing = writeConfigIfMissing;
+exports.ensureConfigValidOrThrow = ensureConfigValidOrThrow;
+exports.computeUnitEnvPath = computeUnitEnvPath;
+exports.ensurePathHasLocalBin = ensurePathHasLocalBin;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = __importDefault(require("yaml"));
+function computeDefaultSetupPaths(homeDir = node_os_1.default.homedir()) {
+    const configDir = node_path_1.default.join(homeDir, ".config", "kayla");
+    const configPath = node_path_1.default.join(configDir, "config.yaml");
+    const dataDir = node_path_1.default.join(homeDir, ".local", "share", "kayla");
+    const workspacesDir = node_path_1.default.join(dataDir, "workspaces");
+    const uploadsDir = node_path_1.default.join(dataDir, "uploads");
+    return { homeDir, configDir, configPath, dataDir, workspacesDir, uploadsDir };
+}
+function ensureDir(p) {
+    node_fs_1.default.mkdirSync(p, { recursive: true });
+}
+function ensureXdgDirs(paths) {
+    ensureDir(paths.configDir);
+    ensureDir(paths.dataDir);
+    ensureDir(paths.workspacesDir);
+    ensureDir(paths.uploadsDir);
+}
+function parseCsvNumbersStrict(v) {
+    const raw = v
+        .split(",")
+        .map((x) => x.trim())
+        .filter((x) => x.length > 0);
+    if (raw.length === 0)
+        return [];
+    return raw.map((x) => {
+        const n = Number(x);
+        if (!Number.isFinite(n))
+            throw new Error(`Invalid number in CSV: ${x}`);
+        return n;
+    });
+}
+function renderSystemdTemplate(templateText, vars) {
+    let out = templateText;
+    for (const [k, v] of Object.entries(vars)) {
+        out = out.split(`@${k}@`).join(v);
+    }
+    return out;
+}
+function buildConfigFromBootstrapInputs(paths, inputs) {
+    const token = inputs.telegramToken.trim();
+    if (!token)
+        throw new Error("Missing telegram token");
+    const adminIds = inputs.telegramAdminUserIds;
+    if (adminIds.length === 0)
+        throw new Error("Missing telegram admin user ids");
+    const allowIds = inputs.telegramAllowlistUserIds;
+    return {
+        telegram: {
+            token,
+            mode: "polling",
+            admin_user_ids: adminIds,
+            allowlist: { user_ids: allowIds }
+        },
+        runtime: {
+            data_dir: paths.dataDir,
+            workspaces_dir: paths.workspacesDir,
+            uploads_dir: paths.uploadsDir
+        },
+        claude: {
+            binary: "claude",
+            default_model: "",
+            max_turns: 10,
+            timeout_seconds: 900,
+            streaming: true,
+            output_format: "stream-json",
+            tools: "default",
+            allowed_tools: [],
+            disallowed_tools: [],
+            mcp: { strict: false }
+        },
+        jobs: {
+            per_chat_concurrency: 1,
+            global_concurrency: 2,
+            queue_size_per_chat: 20
+        },
+        logging: {
+            level: "info",
+            json: true
+        }
+    };
+}
+function parseBootstrapInputsFromEnv(env) {
+    const token = (env.KAYLA_TELEGRAM_TOKEN ?? "").trim();
+    if (!token)
+        throw new Error("Missing KAYLA_TELEGRAM_TOKEN (required to create config)");
+    const adminCsv = (env.KAYLA_TELEGRAM_ADMIN_USER_IDS ?? "").trim();
+    if (!adminCsv)
+        throw new Error("Missing KAYLA_TELEGRAM_ADMIN_USER_IDS (required to create config)");
+    const adminIds = parseCsvNumbersStrict(adminCsv);
+    if (adminIds.length === 0)
+        throw new Error("Invalid KAYLA_TELEGRAM_ADMIN_USER_IDS: empty list");
+    const allowCsv = (env.KAYLA_TELEGRAM_ALLOWLIST_USER_IDS ?? "").trim();
+    const allowIds = allowCsv ? parseCsvNumbersStrict(allowCsv) : [];
+    return { telegramToken: token, telegramAdminUserIds: adminIds, telegramAllowlistUserIds: allowIds };
+}
+function buildConfigFromEnv(paths, env) {
+    const inputs = parseBootstrapInputsFromEnv(env);
+    return buildConfigFromBootstrapInputs(paths, inputs);
+}
+async function promptBootstrapInputs(prompt) {
+    const token = (await prompt({ kind: "secret", message: "Telegram bot token: " })).trim();
+    if (!token)
+        throw new Error("Telegram bot token is required");
+    const adminIds = await (async () => {
+        while (true) {
+            const raw = (await prompt({ kind: "text", message: "Telegram admin user ids (CSV): " })).trim();
+            try {
+                const out = parseCsvNumbersStrict(raw);
+                if (out.length === 0)
+                    throw new Error("Empty list");
+                return out;
+            }
+            catch {
+                // Re-prompt; keep message minimal.
+            }
+        }
+    })();
+    const allowIds = await (async () => {
+        while (true) {
+            const raw = (await prompt({ kind: "text", message: "Optional allowlist user ids (CSV, blank = none): " })).trim();
+            if (!raw)
+                return [];
+            try {
+                return parseCsvNumbersStrict(raw);
+            }
+            catch {
+                // Re-prompt
+            }
+        }
+    })();
+    return { telegramToken: token, telegramAdminUserIds: adminIds, telegramAllowlistUserIds: allowIds };
+}
+function nonInteractiveSetupError(configPath) {
+    return [
+        `Missing config file: ${configPath}`,
+        "",
+        "To bootstrap config non-interactively, provide:",
+        "- KAYLA_TELEGRAM_TOKEN",
+        "- KAYLA_TELEGRAM_ADMIN_USER_IDS (CSV)",
+        "",
+        "Or create/edit the config file manually.",
+        "",
+        "If you run in an interactive terminal (TTY), `kayla setup` can prompt for these values."
+    ].join("\n");
+}
+async function bootstrapConfig(paths, env, opts) {
+    try {
+        const cfg = buildConfigFromEnv(paths, env);
+        return { source: "env", config: cfg };
+    }
+    catch {
+        // fallthrough
+    }
+    if (!opts.isTty || !opts.prompt)
+        throw new Error(nonInteractiveSetupError(paths.configPath));
+    const inputs = await promptBootstrapInputs(opts.prompt);
+    const cfg = buildConfigFromBootstrapInputs(paths, inputs);
+    return { source: "prompt", config: cfg };
+}
+function writeConfigIfMissing(configPath, cfg) {
+    if (node_fs_1.default.existsSync(configPath))
+        return { created: false };
+    const raw = yaml_1.default.stringify(cfg);
+    // 0600: token is a secret.
+    node_fs_1.default.writeFileSync(configPath, raw, { mode: 0o600 });
+    return { created: true };
+}
+function ensureConfigValidOrThrow(configPath) {
+    if (!node_fs_1.default.existsSync(configPath))
+        throw new Error(`Missing config file: ${configPath}`);
+    const doc = yaml_1.default.parse(node_fs_1.default.readFileSync(configPath, "utf8"));
+    if (!doc || typeof doc !== "object")
+        throw new Error("Invalid config file: expected YAML object");
+    // Minimal checks so setup does not need full loadConfig validation semantics.
+    const t = doc.telegram;
+    if (!t || typeof t !== "object")
+        throw new Error("Invalid config: missing telegram section");
+    const token = typeof t.token === "string" ? t.token.trim() : "";
+    if (!token)
+        throw new Error("Invalid config: missing telegram.token");
+    const admins = Array.isArray(t.admin_user_ids) ? t.admin_user_ids : [];
+    const allow = t.allowlist && Array.isArray(t.allowlist.user_ids) ? t.allowlist.user_ids : [];
+    if ((admins.length + allow.length) === 0)
+        throw new Error("Invalid config: missing bootstrap allowlist (telegram.admin_user_ids or telegram.allowlist.user_ids)");
+}
+function computeUnitEnvPath(homeDir) {
+    // systemd does not expand ~, so we generate absolute paths.
+    return node_path_1.default.join(homeDir, ".config", "kayla", "config.yaml");
+}
+function ensurePathHasLocalBin(homeDir, currentPath) {
+    const base = (currentPath ?? "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin").trim();
+    const localBin = node_path_1.default.join(homeDir, ".local", "bin");
+    const parts = base.split(":").filter((p) => p.length > 0);
+    if (!parts.includes(localBin))
+        parts.push(localBin);
+    return parts.join(":");
+}

package/dist/core/storage.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = void 0;
+exports.openStorage = openStorage;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const uuid_1 = require("uuid");
+function nowMs() {
+    return Date.now();
+}
+function ensureDir(p) {
+    node_fs_1.default.mkdirSync(p, { recursive: true });
+}
+function parseSettings(settingsJson) {
+    try {
+        const v = JSON.parse(settingsJson);
+        if (!v || typeof v !== "object")
+            return {};
+        return v;
+    }
+    catch {
+        return {};
+    }
+}
+function stringifySettings(settings) {
+    return JSON.stringify(settings ?? {});
+}
+class Storage {
+    constructor(db) {
+        this.db = db;
+        this.migrate();
+    }
+    migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS chats (
+        chat_id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        workspace_path TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        settings_json TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS jobs (
+        job_id TEXT PRIMARY KEY,
+        chat_id TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        started_at INTEGER,
+        finished_at INTEGER,
+        telegram_message_id INTEGER,
+        exit_code INTEGER,
+        error TEXT,
+        request_text TEXT NOT NULL,
+        response_text TEXT,
+        meta_json TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS allowed_users (
+        channel TEXT NOT NULL,
+        user_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        added_by TEXT,
+        meta_json TEXT,
+        PRIMARY KEY (channel, user_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS onboarding_codes (
+        channel TEXT NOT NULL,
+        code TEXT NOT NULL,
+        user_id TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL,
+        used_at INTEGER,
+        used_by TEXT,
+        PRIMARY KEY (channel, code)
+      );
+    `);
+    }
+    getChat(chatId) {
+        const row = this.db.prepare("SELECT * FROM chats WHERE chat_id = ?").get(chatId);
+        if (!row)
+            return undefined;
+        return { ...row, settings: parseSettings(row.settings_json) };
+    }
+    upsertChat(opts) {
+        const now = nowMs();
+        const settingsJson = stringifySettings(opts.settings ?? {});
+        this.db
+            .prepare(`
+          INSERT INTO chats (chat_id, user_id, workspace_path, created_at, updated_at, settings_json)
+          VALUES (?, ?, ?, ?, ?, ?)
+          ON CONFLICT(chat_id) DO UPDATE SET
+            user_id = excluded.user_id,
+            workspace_path = excluded.workspace_path,
+            updated_at = excluded.updated_at,
+            settings_json = excluded.settings_json
+        `)
+            .run(opts.chatId, opts.userId, opts.workspacePath, now, now, settingsJson);
+        return this.getChat(opts.chatId);
+    }
+    updateChatWorkspace(chatId, workspacePath) {
+        this.db.prepare("UPDATE chats SET workspace_path = ?, updated_at = ? WHERE chat_id = ?").run(workspacePath, nowMs(), chatId);
+        return this.getChat(chatId);
+    }
+    insertJob(opts) {
+        const jobId = (0, uuid_1.v4)();
+        const createdAt = nowMs();
+        const telegramMessageId = opts.telegramMessageId ?? null;
+        this.db
+            .prepare(`
+        INSERT INTO jobs (job_id, chat_id, status, created_at, started_at, finished_at, telegram_message_id, exit_code, error, request_text, response_text, meta_json)
+        VALUES (?, ?, 'queued', ?, NULL, NULL, ?, NULL, NULL, ?, NULL, NULL)
+      `)
+            .run(jobId, opts.chatId, createdAt, telegramMessageId, opts.requestText);
+        return this.getJob(jobId);
+    }
+    getJob(jobId) {
+        return this.db.prepare("SELECT * FROM jobs WHERE job_id = ?").get(jobId);
+    }
+    setJobRunning(jobId) {
+        this.db.prepare("UPDATE jobs SET status = 'running', started_at = ? WHERE job_id = ?").run(nowMs(), jobId);
+    }
+    setJobFinished(opts) {
+        this.db
+            .prepare("UPDATE jobs SET status = ?, finished_at = ?, response_text = ?, error = ?, exit_code = ? WHERE job_id = ?")
+            .run(opts.status, nowMs(), opts.responseText ?? null, opts.error ?? null, opts.exitCode ?? null, opts.jobId);
+    }
+    setJobTelegramMessageId(jobId, messageId) {
+        this.db.prepare("UPDATE jobs SET telegram_message_id = ? WHERE job_id = ?").run(messageId, jobId);
+    }
+    getRunningJob(chatId) {
+        return this.db.prepare("SELECT * FROM jobs WHERE chat_id = ? AND status = 'running' ORDER BY created_at DESC LIMIT 1").get(chatId);
+    }
+    countQueuedJobs(chatId) {
+        const row = this.db.prepare("SELECT COUNT(1) AS cnt FROM jobs WHERE chat_id = ? AND status = 'queued'").get(chatId);
+        return row?.cnt ?? 0;
+    }
+    isAllowedUser(channel, userId) {
+        const row = this.db.prepare("SELECT 1 AS ok FROM allowed_users WHERE channel = ? AND user_id = ? LIMIT 1").get(channel, userId);
+        return !!row;
+    }
+    bootstrapAllowedUsers(channel, userIds, addedBy = "bootstrap") {
+        const now = nowMs();
+        const stmt = this.db.prepare("INSERT OR IGNORE INTO allowed_users (channel, user_id, created_at, added_by, meta_json) VALUES (?, ?, ?, ?, NULL)");
+        const tx = this.db.transaction(() => {
+            for (const id of userIds) {
+                stmt.run(channel, String(id), now, addedBy);
+            }
+        });
+        tx();
+    }
+    generateSixDigitCode() {
+        const n = node_crypto_1.default.randomInt(0, 1000000);
+        return String(n).padStart(6, "0");
+    }
+    getOrCreateOnboardingCode(channel, chatId, userId, ttlMs = 24 * 60 * 60 * 1000) {
+        const now = nowMs();
+        const existing = this.db
+            .prepare(`
+        SELECT code, expires_at
+        FROM onboarding_codes
+        WHERE channel = ? AND user_id = ? AND used_at IS NULL AND expires_at > ?
+        ORDER BY created_at DESC
+        LIMIT 1
+      `)
+            .get(channel, userId, now);
+        if (existing)
+            return { code: existing.code, expiresAt: existing.expires_at };
+        const insert = this.db.prepare(`
+      INSERT INTO onboarding_codes (channel, code, user_id, chat_id, created_at, expires_at, used_at, used_by)
+      VALUES (?, ?, ?, ?, ?, ?, NULL, NULL)
+    `);
+        // Retry on collision (very unlikely).
+        for (let i = 0; i < 20; i++) {
+            const code = this.generateSixDigitCode();
+            const expiresAt = now + ttlMs;
+            try {
+                insert.run(channel, code, userId, chatId, now, expiresAt);
+                return { code, expiresAt };
+            }
+            catch {
+                // collision on PRIMARY KEY(channel, code) or other transient insert errors
+            }
+        }
+        throw new Error("Failed to allocate onboarding code (too many collisions)");
+    }
+    approveOnboardingCode(channel, code, usedBy = "cli") {
+        const now = nowMs();
+        const row = this.db
+            .prepare(`
+        SELECT user_id, chat_id, expires_at, used_at
+        FROM onboarding_codes
+        WHERE channel = ? AND code = ?
+        LIMIT 1
+      `)
+            .get(channel, code);
+        if (!row)
+            throw new Error("Code not found");
+        if (row.used_at !== null)
+            throw new Error("Code already used");
+        if (row.expires_at <= now)
+            throw new Error("Code expired");
+        const tx = this.db.transaction(() => {
+            this.db.prepare("UPDATE onboarding_codes SET used_at = ?, used_by = ? WHERE channel = ? AND code = ?").run(now, usedBy, channel, code);
+            this.db
+                .prepare("INSERT OR IGNORE INTO allowed_users (channel, user_id, created_at, added_by, meta_json) VALUES (?, ?, ?, ?, NULL)")
+                .run(channel, row.user_id, now, usedBy);
+        });
+        tx();
+        return { userId: row.user_id, chatId: row.chat_id };
+    }
+    listPendingCodes(channel) {
+        const now = nowMs();
+        const rows = this.db
+            .prepare(`
+        SELECT code, user_id, chat_id, expires_at
+        FROM onboarding_codes
+        WHERE channel = ? AND used_at IS NULL AND expires_at > ?
+        ORDER BY expires_at ASC
+      `)
+            .all(channel, now);
+        return rows.map((r) => ({ code: r.code, userId: r.user_id, chatId: r.chat_id, expiresAt: r.expires_at }));
+    }
+    listAllowedUsers(channel) {
+        const rows = this.db
+            .prepare(`
+        SELECT user_id, created_at, added_by
+        FROM allowed_users
+        WHERE channel = ?
+        ORDER BY created_at ASC
+      `)
+            .all(channel);
+        return rows.map((r) => ({ userId: r.user_id, createdAt: r.created_at, addedBy: r.added_by }));
+    }
+    dbPath() {
+        // best-effort: better-sqlite3 exposes name for file db.
+        try {
+            const candidate = this.db;
+            return typeof candidate.name === "string" ? candidate.name : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+exports.Storage = Storage;
+function openStorage(dataDir) {
+    ensureDir(dataDir);
+    const dbPath = node_path_1.default.join(dataDir, "kayla.sqlite");
+    const db = new better_sqlite3_1.default(dbPath);
+    return new Storage(db);
+}

package/dist/core/telegram.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThrottledTelegramEditor = void 0;
+exports.splitTelegramText = splitTelegramText;
+exports.truncateForEdit = truncateForEdit;
+const TELEGRAM_TEXT_LIMIT = 4096;
+function splitTelegramText(text, limit = TELEGRAM_TEXT_LIMIT) {
+    if (text.length <= limit)
+        return [text];
+    const parts = [];
+    let remaining = text;
+    while (remaining.length > limit) {
+        // Prefer splitting on newline within limit.
+        const slice = remaining.slice(0, limit);
+        const nl = slice.lastIndexOf("\n");
+        if (nl > 0 && nl >= limit * 0.5) {
+            parts.push(remaining.slice(0, nl));
+            remaining = remaining.slice(nl + 1);
+            continue;
+        }
+        parts.push(remaining.slice(0, limit));
+        remaining = remaining.slice(limit);
+    }
+    if (remaining.length)
+        parts.push(remaining);
+    return parts;
+}
+function truncateForEdit(text, limit = TELEGRAM_TEXT_LIMIT) {
+    if (text.length <= limit)
+        return text;
+    if (limit <= 3)
+        return text.slice(0, limit);
+    // For streaming, showing the tail is often more useful (latest tokens).
+    return `...${text.slice(text.length - (limit - 3))}`;
+}
+class ThrottledTelegramEditor {
+    constructor(api, chatId, messageId, minIntervalMs, logger) {
+        this.api = api;
+        this.chatId = chatId;
+        this.messageId = messageId;
+        this.minIntervalMs = minIntervalMs;
+        this.logger = logger;
+        this.lastEditAtMs = 0;
+    }
+    request(text) {
+        this.pendingText = text;
+        this.schedule();
+    }
+    async flush() {
+        // Ensure any pending delayed edit is applied before returning.
+        while (this.pendingText !== undefined || this.timer !== undefined) {
+            if (this.timer) {
+                clearTimeout(this.timer);
+                this.timer = undefined;
+                this.inFlight = this.doEdit().catch((err) => {
+                    this.logger?.warn({ err, msg: "editMessageText failed" });
+                });
+            }
+            await this.inFlight;
+        }
+    }
+    schedule() {
+        if (this.timer)
+            return;
+        const delay = Math.max(0, this.lastEditAtMs + this.minIntervalMs - Date.now());
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            this.inFlight = this.doEdit().catch((err) => {
+                this.logger?.warn({ err, msg: "editMessageText failed" });
+            });
+        }, delay);
+    }
+    async doEdit() {
+        const text = this.pendingText ?? "";
+        this.pendingText = undefined;
+        try {
+            await this.api.editMessageText(this.chatId, this.messageId, truncateForEdit(text));
+        }
+        catch (err) {
+            // Telegram may throw on "message is not modified" or similar; treat as non-fatal for streaming.
+            this.logger?.debug({ err, msg: "editMessageText error (ignored)" });
+        }
+        this.lastEditAtMs = Date.now();
+        // If new text arrived while editing, schedule again.
+        if (this.pendingText !== undefined)
+            this.schedule();
+    }
+}
+exports.ThrottledTelegramEditor = ThrottledTelegramEditor;

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const service_1 = require("./service");
+(0, service_1.runService)().catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});

package/dist/service.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runService = runService;
+const bot_1 = require("./bot/bot");
+const config_1 = require("./core/config");
+const logging_1 = require("./core/logging");
+const storage_1 = require("./core/storage");
+async function runService() {
+    const config = (0, config_1.loadConfig)();
+    const logger = (0, logging_1.createLogger)(config.logging);
+    logger.info({ msg: "starting", mode: config.telegram.mode });
+    const storage = (0, storage_1.openStorage)(config.runtime.data_dir);
+    // Bootstrap allowlist into DB (required for first admin).
+    storage.bootstrapAllowedUsers("telegram", [...config.telegram.admin_user_ids, ...config.telegram.allowlist.user_ids]);
+    const bot = (0, bot_1.buildBot)({ config, logger, storage });
+    // MVP: polling only.
+    if (config.telegram.mode !== "polling") {
+        throw new Error(`telegram.mode=${config.telegram.mode} is not supported yet (MVP supports polling only)`);
+    }
+    await bot.start();
+    logger.info({ msg: "bot started" });
+}