paperkite 0.1.0

package/dist/src/extensions/registry.js

@@ -0,0 +1,62 @@
+export class CapabilityRegistry {
+    actions = new Map();
+    triggers = new Map();
+    services = new Map();
+    owners = new Map();
+    controlGrants = new Map();
+    /** 返回拥有该能力的插件日志作用域（未登记时为 undefined）。 */
+    scopeOf(kind, name) {
+        return this.owners.get(`${kind}:${name}`);
+    }
+    /** 该能力是否声明需要运行时控制（未声明时上下文中不注入 RuntimeControl）。 */
+    grantsControl(kind, name) {
+        return this.controlGrants.get(`${kind}:${name}`) === true;
+    }
+    register(kind, name, constructor, scope, options) {
+        const normalized = name.trim();
+        if (!normalized)
+            throw new Error(kind + " capability name cannot be empty");
+        const target = this.mapFor(kind);
+        if (target.has(normalized))
+            throw new Error("duplicate capability: " + normalized);
+        if (this.hasAny(normalized))
+            throw new Error("capability is registered more than once: " + normalized);
+        target.set(normalized, constructor);
+        if (scope)
+            this.owners.set(`${kind}:${normalized}`, scope);
+        if (options?.control === true)
+            this.controlGrants.set(`${kind}:${normalized}`, true);
+    }
+    getAction(name) {
+        const constructor = this.actions.get(name);
+        if (!constructor)
+            throw new Error("unknown action capability: " + name);
+        return constructor;
+    }
+    getTrigger(name) {
+        const constructor = this.triggers.get(name);
+        if (!constructor)
+            throw new Error("unknown trigger capability: " + name);
+        return constructor;
+    }
+    getService(name) {
+        const constructor = this.services.get(name);
+        if (!constructor)
+            throw new Error("unknown service capability: " + name);
+        return constructor;
+    }
+    has(name) {
+        return this.hasAny(name);
+    }
+    hasAny(name) {
+        return this.actions.has(name) || this.triggers.has(name) || this.services.has(name);
+    }
+    mapFor(kind) {
+        if (kind === "action")
+            return this.actions;
+        if (kind === "trigger")
+            return this.triggers;
+        return this.services;
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/src/extensions/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/extensions/registry.ts"],"names":[],"mappings":"AAQA,MAAM,OAAO,kBAAkB;IACpB,OAAO,GAAG,IAAI,GAAG,EAA6B,CAAC;IAC/C,QAAQ,GAAG,IAAI,GAAG,EAA8B,CAAC;IACjD,QAAQ,GAAG,IAAI,GAAG,EAA8B,CAAC;IACzC,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IACnC,aAAa,GAAG,IAAI,GAAG,EAAmB,CAAC;IAE5D,wCAAwC;IACxC,OAAO,CAAC,IAAoB,EAAE,IAAY;QACxC,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,kDAAkD;IAClD,aAAa,CAAC,IAAoB,EAAE,IAAY;QAC9C,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5D,CAAC;IAED,QAAQ,CACN,IAAoB,EACpB,IAAY,EACZ,WAAwE,EACxE,KAAc,EACd,OAA2B;QAE3B,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAC/B,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,IAAI,GAAG,kCAAkC,CAAC,CAAC;QAC5E,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAA6E,CAAC;QAC7G,IAAI,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,GAAG,UAAU,CAAC,CAAC;QACnF,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,GAAG,UAAU,CAAC,CAAC;QACvG,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;QACpC,IAAI,KAAK;YAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,UAAU,EAAE,EAAE,KAAK,CAAC,CAAC;QAC3D,IAAI,OAAO,EAAE,OAAO,KAAK,IAAI;YAAE,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,UAAU,EAAE,EAAE,IAAI,CAAC,CAAC;IACvF,CAAC;IAED,SAAS,CAAC,IAAY;QACpB,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAI,CAAC,WAAW;YAAE,MAAM,IAAI,KAAK,CAAC,6BAA6B,GAAG,IAAI,CAAC,CAAC;QACxE,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,UAAU,CAAC,IAAY;QACrB,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC5C,IAAI,CAAC,WAAW;YAAE,MAAM,IAAI,KAAK,CAAC,8BAA8B,GAAG,IAAI,CAAC,CAAC;QACzE,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,UAAU,CAAC,IAAY;QACrB,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC5C,IAAI,CAAC,WAAW;YAAE,MAAM,IAAI,KAAK,CAAC,8BAA8B,GAAG,IAAI,CAAC,CAAC;QACzE,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAEO,MAAM,CAAC,IAAY;QACzB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACtF,CAAC;IAEO,MAAM,CAAC,IAAoB;QACjC,IAAI,IAAI,KAAK,QAAQ;YAAE,OAAO,IAAI,CAAC,OAAO,CAAC;QAC3C,IAAI,IAAI,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC,QAAQ,CAAC;QAC7C,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;CACF"}

package/dist/src/telegram/client.d.ts

@@ -0,0 +1,20 @@
+import { Logger as GramLogger } from "telegram/extensions/Logger.js";
+import type { RuntimeLogger } from "@paperkite/sdk";
+import type { AppSettings } from "../config/settings.js";
+export interface SessionClient {
+    connect(): Promise<unknown>;
+    disconnect(): Promise<unknown>;
+    session: {
+        save(): string;
+    };
+    invoke(request: unknown): Promise<unknown>;
+    start(options: {
+        phoneNumber: () => Promise<string>;
+        phoneCode: () => Promise<string>;
+        password: () => Promise<string>;
+        onError: (error: unknown) => void;
+    }): Promise<unknown>;
+}
+export declare function createGramClient(sessionName: string, content: string): SessionClient;
+export declare function configureTelegramClientFactory(settings: AppSettings, logger?: RuntimeLogger): void;
+export declare function createGramLogger(logger: RuntimeLogger, level: string): GramLogger;

package/dist/src/telegram/client.js

@@ -0,0 +1,54 @@
+import { join } from "node:path";
+import { TelegramClient } from "telegram";
+import { StringSession } from "telegram/sessions/index.js";
+import { Logger as GramLogger, LogLevel } from "telegram/extensions/Logger.js";
+import { paperkiteHome } from "../config/paths.js";
+export function createGramClient(sessionName, content) {
+    const session = new StringSession(content);
+    return new TelegramClient(session, currentSettings.telegram.apiId, currentSettings.telegram.apiHash, {
+        connectionRetries: 5,
+        autoReconnect: true,
+        ...(currentLogger ? { baseLogger: createGramLogger(currentLogger, currentSettings.logging.level) } : {})
+    });
+}
+let currentSettings = {
+    telegram: { apiId: 0, apiHash: "", sessionsDir: join(paperkiteHome(), "accounts") },
+    logging: { level: "info", directory: join(paperkiteHome(), "logs") }
+};
+let currentLogger;
+export function configureTelegramClientFactory(settings, logger) {
+    currentSettings = settings;
+    currentLogger = logger;
+}
+export function createGramLogger(logger, level) {
+    const gram = new GramLogger(gramLogLevel(level));
+    gram.log = (logLevel, message) => {
+        switch (logLevel) {
+            case LogLevel.ERROR:
+                logger.error(message);
+                break;
+            case LogLevel.WARN:
+                logger.warn(message);
+                break;
+            case LogLevel.DEBUG:
+                logger.debug(message);
+                break;
+            default:
+                logger.info(message);
+        }
+    };
+    return gram;
+}
+function gramLogLevel(level) {
+    switch (level.toLowerCase()) {
+        case "debug":
+            return LogLevel.DEBUG;
+        case "warn":
+            return LogLevel.WARN;
+        case "error":
+            return LogLevel.ERROR;
+        default:
+            return LogLevel.INFO;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/src/telegram/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/telegram/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAG/E,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAenD,MAAM,UAAU,gBAAgB,CAAC,WAAmB,EAAE,OAAe;IACnE,MAAM,OAAO,GAAG,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;IAC3C,OAAO,IAAI,cAAc,CAAC,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC,QAAQ,CAAC,OAAO,EAAE;QACnG,iBAAiB,EAAE,CAAC;QACpB,aAAa,EAAE,IAAI;QACnB,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,gBAAgB,CAAC,aAAa,EAAE,eAAe,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACzG,CAA6B,CAAC;AACjC,CAAC;AAED,IAAI,eAAe,GAAgB;IACjC,QAAQ,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,WAAW,EAAE,IAAI,CAAC,aAAa,EAAE,EAAE,UAAU,CAAC,EAAE;IACnF,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,aAAa,EAAE,EAAE,MAAM,CAAC,EAAE;CACrE,CAAC;AAEF,IAAI,aAAwC,CAAC;AAE7C,MAAM,UAAU,8BAA8B,CAAC,QAAqB,EAAE,MAAsB;IAC1F,eAAe,GAAG,QAAQ,CAAC;IAC3B,aAAa,GAAG,MAAM,CAAC;AACzB,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,MAAqB,EAAE,KAAa;IACnE,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;IACjD,IAAI,CAAC,GAAG,GAAG,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE;QAC/B,QAAQ,QAAQ,EAAE,CAAC;YACjB,KAAK,QAAQ,CAAC,KAAK;gBACjB,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBACtB,MAAM;YACR,KAAK,QAAQ,CAAC,IAAI;gBAChB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACrB,MAAM;YACR,KAAK,QAAQ,CAAC,KAAK;gBACjB,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBACtB,MAAM;YACR;gBACE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACzB,CAAC;IACH,CAAC,CAAC;IACF,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,YAAY,CAAC,KAAa;IACjC,QAAQ,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;QAC5B,KAAK,OAAO;YACV,OAAO,QAAQ,CAAC,KAAK,CAAC;QACxB,KAAK,MAAM;YACT,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,KAAK,OAAO;YACV,OAAO,QAAQ,CAAC,KAAK,CAAC;QACxB;YACE,OAAO,QAAQ,CAAC,IAAI,CAAC;IACzB,CAAC;AACH,CAAC"}

package/dist/src/telegram/failure.d.ts

@@ -0,0 +1,2 @@
+export type SessionFailureKind = "auth" | "account" | "action" | "none";
+export declare function classifySessionFailure(error: unknown): SessionFailureKind;

package/dist/src/telegram/failure.js

@@ -0,0 +1,98 @@
+import { isSessionUnavailable } from "@paperkite/sdk";
+const AUTH_NAMES = [
+    "AUTH_KEY_UNREGISTERED",
+    "AUTH_KEY_INVALID",
+    "AUTH_KEY_DUPLICATED",
+    "AUTH_KEY_PERM_EMPTY",
+    "AUTH_KEY_BANNED",
+    "AUTH_KEY_NOT_FOUND",
+    "AUTH_RESTART",
+    "RESTART_AUTH",
+    "SESSION_REVOKED",
+    "SESSION_EXPIRED",
+    "SESSION_PASSWORD_NEEDED",
+    "ACTIVE_USER_LIMIT",
+    "USER_DEACTIVATED_BAN",
+    "USER_DEACTIVATED",
+    "PHONE_CODE_INVALID",
+    "PHONE_CODE_EXPIRED",
+    "PHONE_NUMBER_INVALID",
+    "PHONE_NUMBER_BANNED"
+];
+const ACCOUNT_NAMES = [
+    "FLOOD_WAIT",
+    "FLOOD_PREMIUM_WAIT",
+    "FLOOD",
+    "MSG_WAIT",
+    "CONNECTION_NOT_INITED",
+    "NETWORK_MIGRATE",
+    "USER_MIGRATE",
+    "PHONE_MIGRATE",
+    "FILE_MIGRATE",
+    "INTERNAL"
+];
+const ACTION_NAMES = ["SLOWMODE_WAIT", "EMAIL_UNCONFIRMED"];
+const NETWORK_PHRASES = [
+    "CONNECTION CLOSED",
+    "CONNECTION LOST",
+    "CONNECTION REFUSED",
+    "CONNECTION ERROR",
+    "SOCKET CLOSED",
+    "SOCKET ERROR",
+    "UNABLE TO CONNECT",
+    "CANNOT CONNECT",
+    "RECONNECT",
+    "UNEXPECTED DATA CENTER",
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "EPIPE",
+    "TIMED OUT",
+    "REQUEST TIMEOUT",
+    "NETWORK ERROR"
+];
+export function classifySessionFailure(error) {
+    if (isSessionUnavailable(error))
+        return "none";
+    const fields = rpcFields(error);
+    if (fields)
+        return classifyRpc(fields.name, fields.code);
+    const text = String(error instanceof Error ? error.message : error).toUpperCase();
+    if (containsAny(text, AUTH_NAMES))
+        return "auth";
+    if (containsAny(text, NETWORK_PHRASES))
+        return "account";
+    return "none";
+}
+function classifyRpc(name, code) {
+    if (containsAny(name, AUTH_NAMES))
+        return "auth";
+    if (containsAny(name, ACCOUNT_NAMES))
+        return "account";
+    if (containsAny(name, ACTION_NAMES))
+        return "action";
+    const absolute = code === undefined ? 0 : Math.abs(code);
+    if (absolute === 401 || absolute === 406)
+        return "auth";
+    if (absolute === 420 || (absolute >= 500 && absolute <= 599))
+        return "account";
+    if (absolute === 400 || absolute === 403 || absolute === 404 || absolute === 409 || absolute === 303) {
+        return "action";
+    }
+    return "none";
+}
+function rpcFields(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const candidate = error;
+    if (typeof candidate.errorMessage !== "string")
+        return undefined;
+    return {
+        name: candidate.errorMessage.toUpperCase(),
+        code: typeof candidate.code === "number" ? candidate.code : undefined
+    };
+}
+function containsAny(text, names) {
+    return names.some((name) => text.includes(name));
+}
+//# sourceMappingURL=failure.js.map

package/dist/src/telegram/failure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure.js","sourceRoot":"","sources":["../../../src/telegram/failure.ts"],"names":[],"mappings":"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"}

package/dist/src/telegram/login.d.ts

@@ -0,0 +1 @@
+export declare function loginSession(name: string, settingsFile: string): Promise<void>;

package/dist/src/telegram/login.js

@@ -0,0 +1,31 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { loadSettings } from "../config/settings.js";
+import { AppLogger } from "../engine/logger.js";
+import { configureTelegramClientFactory, createGramClient } from "./client.js";
+import { normalizeSessionName, sessionFilePath, writeSessionFile } from "./session-files.js";
+export async function loginSession(name, settingsFile) {
+    if (!input.isTTY)
+        throw new Error("session login needs an interactive terminal");
+    const settings = await loadSettings(settingsFile);
+    const session = normalizeSessionName(name);
+    sessionFilePath(settings.telegram.sessionsDir, session);
+    const logger = new AppLogger(settings.logging.level);
+    configureTelegramClientFactory(settings, logger);
+    const client = createGramClient(session, "");
+    const readline = createInterface({ input, output });
+    try {
+        await client.start({
+            phoneNumber: () => readline.question("Phone number: "),
+            phoneCode: () => readline.question("Login code: "),
+            password: () => readline.question("Two-factor password: "),
+            onError: (error) => logger.warn("session login step failed: " + session, error)
+        });
+        await writeSessionFile(settings.telegram.sessionsDir, session, client.session.save());
+    }
+    finally {
+        readline.close();
+        await client.disconnect().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=login.js.map

package/dist/src/telegram/login.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.js","sourceRoot":"","sources":["../../../src/telegram/login.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,KAAK,IAAI,KAAK,EAAE,MAAM,IAAI,MAAM,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,8BAA8B,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE7F,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,IAAY,EAAE,YAAoB;IACnE,IAAI,CAAC,KAAK,CAAC,KAAK;QAAE,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IACjF,MAAM,QAAQ,GAAG,MAAM,YAAY,CAAC,YAAY,CAAC,CAAC;IAClD,MAAM,OAAO,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAC3C,eAAe,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACxD,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACrD,8BAA8B,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACjD,MAAM,MAAM,GAAG,gBAAgB,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAC7C,MAAM,QAAQ,GAAG,eAAe,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;IACpD,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,KAAK,CAAC;YACjB,WAAW,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,CAAC;YACtD,SAAS,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC;YAClD,QAAQ,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,uBAAuB,CAAC;YAC1D,OAAO,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,6BAA6B,GAAG,OAAO,EAAE,KAAK,CAAC;SACzF,CAAC,CAAC;QACH,MAAM,gBAAgB,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACxF,CAAC;YAAS,CAAC;QACT,QAAQ,CAAC,KAAK,EAAE,CAAC;QACjB,MAAM,MAAM,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACnD,CAAC;AACH,CAAC"}

package/dist/src/telegram/pool.d.ts

@@ -0,0 +1,47 @@
+import { type RuntimeLogger, type SessionAccess, type SessionState, type Unsubscribe } from "@paperkite/sdk";
+import type { AppSettings } from "../config/settings.js";
+import { type SessionClient } from "./client.js";
+export interface SessionStateInfo {
+    readonly name: string;
+    readonly state: SessionState;
+    readonly since: number;
+    readonly reason?: string;
+    readonly attempts: number;
+}
+export interface SessionStateChange {
+    readonly name: string;
+    readonly previous: SessionState;
+    readonly state: SessionState;
+    readonly reason?: string;
+}
+export type SessionStateListener = (change: SessionStateChange) => void;
+export declare class SessionPool {
+    private readonly settings;
+    private readonly logger;
+    private readonly createClient;
+    private readonly entries;
+    private readonly listeners;
+    private readonly guard;
+    private closed;
+    constructor(settings: AppSettings, logger: RuntimeLogger, createClient?: (session: string, content: string) => SessionClient);
+    subscribe(listener: SessionStateListener): Unsubscribe;
+    ensure(names: Iterable<string>): Promise<void>;
+    access(name?: string): SessionAccess | undefined;
+    state(name: string): SessionState | undefined;
+    states(): SessionStateInfo[];
+    run<T>(name: string, operation: (client: SessionClient) => T | Promise<T>): Promise<T>;
+    reconnectSession(name: string): Promise<void>;
+    closeAll(): Promise<void>;
+    private createEntry;
+    private attempt;
+    private performAttempt;
+    private failAttempt;
+    private scheduleBackoff;
+    private noteFailure;
+    private noteSuccess;
+    private transition;
+    private unavailable;
+    private disposeClient;
+    private saveSession;
+    private checkAuthorized;
+}

package/dist/src/telegram/pool.js

@@ -0,0 +1,300 @@
+import { Api } from "telegram/tl/api.js";
+import { SessionUnavailableError } from "@paperkite/sdk";
+import { createGramClient } from "./client.js";
+import { classifySessionFailure } from "./failure.js";
+import { normalizeSessionName, readSessionFile, writeSessionFile } from "./session-files.js";
+const DEFAULT_GUARD = { windowMs: 60_000, threshold: 5, backoffMinMs: 30_000, backoffMaxMs: 30 * 60_000 };
+export class SessionPool {
+    settings;
+    logger;
+    createClient;
+    entries = new Map();
+    listeners = new Set();
+    guard;
+    closed = false;
+    constructor(settings, logger, createClient = createGramClient) {
+        this.settings = settings;
+        this.logger = logger;
+        this.createClient = createClient;
+        const configured = settings.telegram.sessionGuard;
+        this.guard = configured
+            ? {
+                windowMs: configured.windowMs,
+                threshold: configured.threshold,
+                backoffMinMs: configured.backoffMinMs,
+                backoffMaxMs: configured.backoffMaxMs
+            }
+            : DEFAULT_GUARD;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async ensure(names) {
+        const pending = [];
+        for (const name of new Set([...names].map((value) => normalizeSessionName(value)))) {
+            const existing = this.entries.get(name);
+            if (!existing) {
+                const created = this.createEntry(name);
+                void this.attempt(created);
+                pending.push(created);
+            }
+            else if (existing.health.state === "starting") {
+                pending.push(existing);
+            }
+        }
+        await Promise.all(pending.map((entry) => entry.ready));
+    }
+    access(name) {
+        if (name === undefined)
+            return undefined;
+        return { run: (operation) => this.run(name, operation) };
+    }
+    state(name) {
+        return this.entries.get(normalizeSessionName(name))?.health.state;
+    }
+    states() {
+        return [...this.entries.values()].map((entry) => ({
+            name: entry.name,
+            state: entry.health.state,
+            since: entry.health.since,
+            reason: entry.health.reason,
+            attempts: entry.health.attempts
+        }));
+    }
+    async run(name, operation) {
+        const entry = this.entries.get(normalizeSessionName(name));
+        if (!entry)
+            throw new Error("session is not initialized: " + name);
+        if (entry.health.state === "starting")
+            await entry.ready;
+        if (entry.health.state !== "connected")
+            throw this.unavailable(entry);
+        const previous = entry.tail;
+        let resolveTail;
+        entry.tail = new Promise((resolvePromise) => {
+            resolveTail = resolvePromise;
+        });
+        await previous;
+        if (entry.health.state !== "connected" || !entry.client) {
+            resolveTail?.();
+            throw this.unavailable(entry);
+        }
+        try {
+            const value = await operation(entry.client);
+            this.noteSuccess(entry);
+            return value;
+        }
+        catch (error) {
+            this.noteFailure(entry, error);
+            throw error;
+        }
+        finally {
+            resolveTail?.();
+        }
+    }
+    async reconnectSession(name) {
+        const entry = this.entries.get(normalizeSessionName(name));
+        if (!entry)
+            throw new Error("unknown session: " + name);
+        if (entry.health.state === "starting" || entry.health.state === "connected")
+            return;
+        await this.attempt(entry);
+    }
+    async closeAll() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const entries = [...this.entries.values()];
+        this.entries.clear();
+        for (const entry of entries) {
+            if (entry.timer)
+                clearTimeout(entry.timer);
+            await entry.ready.catch(() => undefined);
+            await entry.tail;
+            await this.disposeClient(entry);
+        }
+        this.listeners.clear();
+    }
+    createEntry(name) {
+        const health = {
+            state: "isolated",
+            since: Date.now(),
+            reason: "starting",
+            attempts: 0,
+            faultsWindowStart: Date.now(),
+            faults: 0
+        };
+        const entry = { name, ready: Promise.resolve(), tail: Promise.resolve(), health };
+        this.entries.set(name, entry);
+        return entry;
+    }
+    async attempt(entry) {
+        if (this.closed)
+            return;
+        if (entry.health.state === "starting") {
+            await entry.ready.catch(() => undefined);
+            return;
+        }
+        if (entry.health.state === "connected")
+            return;
+        if (entry.timer)
+            clearTimeout(entry.timer);
+        entry.timer = undefined;
+        entry.health.reason = "connecting";
+        entry.health.state = "starting";
+        entry.ready = new Promise((resolvePromise) => {
+            entry.readyResolve = resolvePromise;
+        });
+        try {
+            const outcome = await this.performAttempt(entry);
+            if (this.closed)
+                return;
+            if (outcome.ok) {
+                await this.saveSession(entry);
+                this.transition(entry, "connected");
+                return;
+            }
+            this.failAttempt(entry, outcome.error, outcome.hadContent);
+        }
+        finally {
+            entry.readyResolve?.();
+            entry.readyResolve = undefined;
+        }
+    }
+    async performAttempt(entry) {
+        await this.disposeClient(entry);
+        const content = await readSessionFile(this.settings.telegram.sessionsDir, entry.name).catch((error) => error instanceof Error ? error : new Error(String(error)));
+        if (content instanceof Error)
+            return { ok: false, error: content, hadContent: false };
+        const hadContent = Boolean(content);
+        if (!hadContent) {
+            return { ok: false, error: new Error("session " + entry.name + " has no saved login"), hadContent: false };
+        }
+        try {
+            const client = this.createClient(entry.name, content);
+            entry.client = client;
+            await client.connect();
+            await this.checkAuthorized(client);
+            return { ok: true, hadContent };
+        }
+        catch (error) {
+            return { ok: false, error, hadContent };
+        }
+    }
+    failAttempt(entry, error, hadContent) {
+        const message = messageOf(error);
+        const kind = classifySessionFailure(error);
+        if (kind === "auth" || !hadContent) {
+            this.transition(entry, "waiting-auth", loginHint(entry.name, message));
+            return;
+        }
+        entry.health.attempts += 1;
+        this.transition(entry, "isolated", message);
+        this.scheduleBackoff(entry);
+    }
+    scheduleBackoff(entry) {
+        if (this.closed || entry.health.state !== "isolated")
+            return;
+        const delay = Math.min(this.guard.backoffMaxMs, this.guard.backoffMinMs * 2 ** Math.max(0, entry.health.attempts - 1));
+        const timer = setTimeout(() => void this.attempt(entry), delay);
+        timer.unref();
+        entry.timer = timer;
+    }
+    noteFailure(entry, error) {
+        const kind = classifySessionFailure(error);
+        if (kind === "auth") {
+            this.transition(entry, "waiting-auth", loginHint(entry.name, messageOf(error)));
+            void this.disposeClient(entry);
+            return;
+        }
+        if (kind !== "account")
+            return;
+        const now = Date.now();
+        if (now - entry.health.faultsWindowStart > this.guard.windowMs) {
+            entry.health.faultsWindowStart = now;
+            entry.health.faults = 0;
+        }
+        entry.health.faults += 1;
+        if (entry.health.faults < this.guard.threshold)
+            return;
+        this.transition(entry, "isolated", `${entry.health.faults} session failures within ${this.guard.windowMs / 1_000}s`);
+        void this.disposeClient(entry);
+        entry.health.attempts = 0;
+        this.scheduleBackoff(entry);
+    }
+    noteSuccess(entry) {
+        entry.health.faults = 0;
+        entry.health.faultsWindowStart = Date.now();
+    }
+    transition(entry, state, reason) {
+        if (entry.health.state === state) {
+            if (state === "connected")
+                entry.health.reason = undefined;
+            else if (reason !== undefined)
+                entry.health.reason = reason;
+            return;
+        }
+        const previous = entry.health.state;
+        entry.health.state = state;
+        entry.health.since = Date.now();
+        if (state === "connected")
+            entry.health.reason = undefined;
+        else if (reason !== undefined)
+            entry.health.reason = reason;
+        if (state === "connected" || state === "waiting-auth")
+            entry.health.attempts = 0;
+        if (this.closed)
+            return;
+        this.logger.info(`session ${entry.name} ${previous} -> ${state}` + (reason ? ": " + reason : ""));
+        for (const listener of [...this.listeners]) {
+            try {
+                listener({ name: entry.name, previous, state, reason });
+            }
+            catch (error) {
+                this.logger.error("session state listener failed", error);
+            }
+        }
+    }
+    unavailable(entry) {
+        return new SessionUnavailableError(entry.name, entry.health.state, entry.health.reason);
+    }
+    async disposeClient(entry) {
+        const client = entry.client;
+        entry.client = undefined;
+        if (!client)
+            return;
+        try {
+            const saved = client.session.save();
+            if (saved)
+                await writeSessionFile(this.settings.telegram.sessionsDir, entry.name, saved);
+        }
+        catch (error) {
+            this.logger.warn("could not save session " + entry.name, error);
+        }
+        await client.disconnect().catch((error) => {
+            this.logger.warn("could not disconnect session " + entry.name, error);
+        });
+    }
+    async saveSession(entry) {
+        if (!entry.client)
+            return;
+        try {
+            await writeSessionFile(this.settings.telegram.sessionsDir, entry.name, entry.client.session.save());
+        }
+        catch (error) {
+            this.logger.warn("could not save session " + entry.name, error);
+        }
+    }
+    async checkAuthorized(client) {
+        await client.invoke(new Api.updates.GetState());
+    }
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function loginHint(name, detail) {
+    const base = detail && detail.trim() ? detail : "session login is required";
+    return base + "; run `paperkite session login " + name + "` to log in";
+}
+//# sourceMappingURL=pool.js.map