@elizaos/agent 2.0.0-alpha.173 → 2.0.0-alpha.192

package/apps/app-lifeops/src/lifeops/telegram-auth.js

@@ -0,0 +1,496 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveOAuthDir } from "@elizaos/agent/config/paths";
+// Re-export the real GramJS auth session from plugin-telegram.
+// The plugin's TelegramAccountAuthSession handles the full MTProto flow:
+//   provisioning → code → 2FA → session persistence.
+// LifeOps wraps it with its own session management and token storage.
+import { TelegramAccountAuthSession, } from "@elizaos/plugin-telegram/account-auth-service";
+// ---------------------------------------------------------------------------
+// In-memory session store
+// ---------------------------------------------------------------------------
+const pendingTelegramAuthSessions = new Map();
+const TELEGRAM_AUTH_SESSION_TTL_MS = 10 * 60 * 1000;
+// ---------------------------------------------------------------------------
+// Default API credentials
+// ---------------------------------------------------------------------------
+function resolveApiId(explicit, env = process.env) {
+    if (explicit !== undefined && explicit > 0)
+        return explicit;
+    const envValue = env.ELIZA_TELEGRAM_API_ID;
+    if (envValue) {
+        const parsed = Number.parseInt(envValue, 10);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    // Return null to trigger provisioning flow (my.telegram.org).
+    return null;
+}
+function resolveApiHash(explicit, env = process.env) {
+    if (explicit && explicit.length > 0)
+        return explicit;
+    const envValue = env.ELIZA_TELEGRAM_API_HASH;
+    if (envValue && envValue.length > 0)
+        return envValue;
+    return null;
+}
+export function hasManagedTelegramCredentials(env = process.env) {
+    return resolveApiId(undefined, env) !== null && resolveApiHash(undefined, env) !== null;
+}
+// ---------------------------------------------------------------------------
+// Storage helpers
+// ---------------------------------------------------------------------------
+function telegramStorageRoot(env = process.env) {
+    return path.join(resolveOAuthDir(env), "lifeops", "telegram");
+}
+function telegramPendingSessionDir(env = process.env) {
+    return path.join(telegramStorageRoot(env), "pending");
+}
+function sanitizePathSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function buildTelegramTokenRef(agentId, side) {
+    return path.join(sanitizePathSegment(agentId), sanitizePathSegment(side), "local.json");
+}
+function resolveTokenPath(tokenRef, env = process.env) {
+    return path.join(telegramStorageRoot(env), tokenRef);
+}
+function resolvePendingSessionPath(sessionId, env = process.env) {
+    return path.join(telegramPendingSessionDir(env), `${sanitizePathSegment(sessionId)}.json`);
+}
+function ensureTokenStorageDir(dir) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+function writePendingTelegramSession(session, env = process.env) {
+    const stored = {
+        sessionId: session.sessionId,
+        agentId: session.agentId,
+        side: session.side,
+        phone: session.phone,
+        apiId: session.apiId,
+        apiHash: session.apiHash,
+        createdAt: session.createdAt,
+    };
+    const filePath = resolvePendingSessionPath(session.sessionId, env);
+    ensureTokenStorageDir(path.dirname(filePath));
+    fs.writeFileSync(filePath, JSON.stringify(stored, null, 2), {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+}
+function deletePendingTelegramSession(sessionId, env = process.env) {
+    fs.rmSync(resolvePendingSessionPath(sessionId, env), { force: true });
+}
+function readPendingTelegramSession(sessionId, env = process.env) {
+    const filePath = resolvePendingSessionPath(sessionId, env);
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        if (parsed &&
+            typeof parsed === "object" &&
+            parsed.sessionId === sessionId &&
+            typeof parsed.agentId === "string" &&
+            (parsed.side === "owner" || parsed.side === "agent") &&
+            typeof parsed.phone === "string" &&
+            typeof parsed.createdAt === "string") {
+            return parsed;
+        }
+    }
+    catch {
+        // Invalid files are discarded below.
+    }
+    fs.rmSync(filePath, { force: true });
+    return null;
+}
+function listPendingTelegramSessions(env = process.env) {
+    const dir = telegramPendingSessionDir(env);
+    if (!fs.existsSync(dir)) {
+        return [];
+    }
+    const sessions = [];
+    for (const entry of fs.readdirSync(dir)) {
+        const sessionId = entry.replace(/\.json$/i, "");
+        const session = readPendingTelegramSession(sessionId, env);
+        if (session) {
+            sessions.push(session);
+        }
+    }
+    return sessions;
+}
+// ---------------------------------------------------------------------------
+// Session lifecycle helpers
+// ---------------------------------------------------------------------------
+function cleanupExpiredSessions() {
+    const now = Date.now();
+    for (const [sessionId, session] of pendingTelegramAuthSessions) {
+        if (now - new Date(session.createdAt).getTime() >
+            TELEGRAM_AUTH_SESSION_TTL_MS) {
+            // Stop the GramJS client before evicting.
+            session.authSession.stop().catch(() => { });
+            pendingTelegramAuthSessions.delete(sessionId);
+            deletePendingTelegramSession(sessionId);
+        }
+    }
+    for (const session of listPendingTelegramSessions()) {
+        if (now - new Date(session.createdAt).getTime() > TELEGRAM_AUTH_SESSION_TTL_MS) {
+            deletePendingTelegramSession(session.sessionId);
+        }
+    }
+}
+function clearPendingSessionsForSide(agentId, side) {
+    for (const [sessionId, session] of pendingTelegramAuthSessions) {
+        if (session.agentId === agentId && session.side === side) {
+            session.authSession.stop().catch(() => { });
+            pendingTelegramAuthSessions.delete(sessionId);
+            deletePendingTelegramSession(sessionId);
+        }
+    }
+    for (const session of listPendingTelegramSessions()) {
+        if (session.agentId === agentId && session.side === side) {
+            deletePendingTelegramSession(session.sessionId);
+        }
+    }
+}
+/** Map plugin-telegram's status names to LifeOps auth state names. */
+function mapSnapshotStatus(snapshot) {
+    switch (snapshot.status) {
+        case "idle":
+            return "idle";
+        case "waiting_for_provisioning_code":
+            return "waiting_for_provisioning_code";
+        case "waiting_for_telegram_code":
+            return "waiting_for_code";
+        case "waiting_for_password":
+            return "waiting_for_password";
+        case "configured":
+        case "connected":
+            return "connected";
+        case "error":
+            return "error";
+        default:
+            return "error";
+    }
+}
+function pluginStatusForRetryState(state) {
+    switch (state) {
+        case "waiting_for_provisioning_code":
+            return "waiting_for_provisioning_code";
+        case "waiting_for_code":
+            return "waiting_for_telegram_code";
+        case "waiting_for_password":
+            return "waiting_for_password";
+    }
+}
+export function inferRetryableTelegramAuthState(args) {
+    if (args.state === "waiting_for_provisioning_code" ||
+        args.state === "waiting_for_code" ||
+        args.state === "waiting_for_password") {
+        return args.state;
+    }
+    if (args.state !== "error") {
+        return null;
+    }
+    const message = (args.error ?? "").trim().toUpperCase();
+    if (!message) {
+        return null;
+    }
+    if (message.includes("PASSWORD_HASH_INVALID") ||
+        message.includes("AUTH.CHECKPASSWORD") ||
+        message.includes("TWO-FACTOR PASSWORD")) {
+        return "waiting_for_password";
+    }
+    if (message.includes("PHONE_CODE_INVALID") ||
+        message.includes("PHONE_CODE_EXPIRED") ||
+        message.includes("LOGIN CODE")) {
+        return "waiting_for_code";
+    }
+    if (message.includes("PROVISIONING CODE")) {
+        return "waiting_for_provisioning_code";
+    }
+    return null;
+}
+function persistRetryableTelegramAuthState(session, nextState, error) {
+    session.state = nextState;
+    session.error = error;
+    const authSessionInternal = session.authSession;
+    if (authSessionInternal.snapshot) {
+        authSessionInternal.snapshot.status = pluginStatusForRetryState(nextState);
+        authSessionInternal.snapshot.error = error;
+    }
+    authSessionInternal.persistAuthState?.();
+}
+function recoverRetryableTelegramAuthSession(session) {
+    const retryableState = inferRetryableTelegramAuthState({
+        state: session.state,
+        error: session.error,
+    });
+    if (retryableState && session.state !== retryableState) {
+        persistRetryableTelegramAuthState(session, retryableState, session.error);
+    }
+    return session;
+}
+function mapSnapshotIdentity(snapshot) {
+    if (!snapshot.account)
+        return null;
+    return {
+        id: snapshot.account.id,
+        username: snapshot.account.username ?? "",
+        firstName: snapshot.account.firstName ?? "",
+    };
+}
+function restorePendingTelegramAuthSession(stored) {
+    const authSession = new TelegramAccountAuthSession();
+    const snapshot = authSession.getSnapshot();
+    const connectorConfig = authSession.getResolvedConnectorConfig();
+    const hasRecoverableState = snapshot.status !== "idle" ||
+        Boolean(snapshot.phone) ||
+        Boolean(snapshot.error) ||
+        connectorConfig !== null;
+    if (!hasRecoverableState) {
+        deletePendingTelegramSession(stored.sessionId);
+        return null;
+    }
+    const session = {
+        sessionId: stored.sessionId,
+        agentId: stored.agentId,
+        side: stored.side,
+        phone: snapshot.phone ?? stored.phone,
+        apiId: stored.apiId,
+        apiHash: stored.apiHash,
+        state: mapSnapshotStatus(snapshot),
+        error: snapshot.error,
+        identity: mapSnapshotIdentity(snapshot),
+        createdAt: stored.createdAt,
+        authSession,
+    };
+    pendingTelegramAuthSessions.set(session.sessionId, session);
+    return recoverRetryableTelegramAuthSession(session);
+}
+// ---------------------------------------------------------------------------
+// Auth flow
+// ---------------------------------------------------------------------------
+export async function startTelegramAuth(args) {
+    cleanupExpiredSessions();
+    clearPendingSessionsForSide(args.agentId, args.side);
+    const sessionId = crypto.randomUUID();
+    const apiId = resolveApiId(args.apiId);
+    const apiHash = resolveApiHash(args.apiHash);
+    // Create the real GramJS auth session.
+    const authSession = new TelegramAccountAuthSession();
+    const session = {
+        sessionId,
+        agentId: args.agentId,
+        side: args.side,
+        phone: args.phone,
+        apiId,
+        apiHash,
+        state: "idle",
+        error: null,
+        identity: null,
+        createdAt: new Date().toISOString(),
+        authSession,
+    };
+    pendingTelegramAuthSessions.set(sessionId, session);
+    writePendingTelegramSession(session);
+    // Start the real auth flow. If credentials are provided, it goes straight
+    // to Telegram code. If not, it starts provisioning via my.telegram.org.
+    const credentials = apiId && apiHash ? { apiId, apiHash } : null;
+    try {
+        const snapshot = await authSession.start({
+            phone: args.phone,
+            credentials,
+        });
+        session.state = mapSnapshotStatus(snapshot);
+        session.error = snapshot.error;
+        session.identity = mapSnapshotIdentity(snapshot);
+    }
+    catch (error) {
+        session.state = "error";
+        session.error =
+            error instanceof Error ? error.message : String(error);
+    }
+    return session;
+}
+export async function submitTelegramAuthCode(sessionId, code) {
+    cleanupExpiredSessions();
+    const session = pendingTelegramAuthSessions.get(sessionId) ??
+        (() => {
+            const stored = readPendingTelegramSession(sessionId);
+            return stored ? restorePendingTelegramAuthSession(stored) : null;
+        })();
+    if (!session) {
+        return {
+            sessionId,
+            agentId: "",
+            side: "owner",
+            phone: "",
+            apiId: null,
+            apiHash: null,
+            state: "error",
+            error: "Auth session not found or expired",
+            identity: null,
+            createdAt: new Date().toISOString(),
+            authSession: new TelegramAccountAuthSession(),
+        };
+    }
+    const retryableState = inferRetryableTelegramAuthState({
+        state: session.state,
+        error: session.error,
+    });
+    if (retryableState && retryableState !== "waiting_for_password") {
+        persistRetryableTelegramAuthState(session, retryableState, session.error);
+    }
+    const expectedRetryState = session.state === "waiting_for_provisioning_code"
+        ? "waiting_for_provisioning_code"
+        : "waiting_for_code";
+    try {
+        // Determine which type of code to submit based on current state.
+        const submitInput = session.state === "waiting_for_provisioning_code"
+            ? { provisioningCode: code }
+            : { telegramCode: code };
+        const snapshot = await session.authSession.submit(submitInput);
+        session.state = mapSnapshotStatus(snapshot);
+        session.error = snapshot.error;
+        session.identity = mapSnapshotIdentity(snapshot);
+        // If connected, persist the token.
+        if (session.state === "connected") {
+            persistTelegramToken(session);
+        }
+    }
+    catch (error) {
+        persistRetryableTelegramAuthState(session, expectedRetryState, error instanceof Error ? error.message : String(error));
+    }
+    return session;
+}
+export async function submitTelegramAuthPassword(sessionId, password) {
+    cleanupExpiredSessions();
+    const session = pendingTelegramAuthSessions.get(sessionId) ??
+        (() => {
+            const stored = readPendingTelegramSession(sessionId);
+            return stored ? restorePendingTelegramAuthSession(stored) : null;
+        })();
+    if (!session) {
+        return {
+            sessionId,
+            agentId: "",
+            side: "owner",
+            phone: "",
+            apiId: null,
+            apiHash: null,
+            state: "error",
+            error: "Auth session not found or expired",
+            identity: null,
+            createdAt: new Date().toISOString(),
+            authSession: new TelegramAccountAuthSession(),
+        };
+    }
+    const retryableState = inferRetryableTelegramAuthState({
+        state: session.state,
+        error: session.error,
+    });
+    if (retryableState === "waiting_for_password") {
+        persistRetryableTelegramAuthState(session, retryableState, session.error);
+    }
+    if (session.state !== "waiting_for_password") {
+        session.state = "error";
+        session.error = `Cannot submit password in state "${session.state}"`;
+        return session;
+    }
+    try {
+        const snapshot = await session.authSession.submit({ password });
+        session.state = mapSnapshotStatus(snapshot);
+        session.error = snapshot.error;
+        session.identity = mapSnapshotIdentity(snapshot);
+        if (session.state === "connected") {
+            persistTelegramToken(session);
+        }
+    }
+    catch (error) {
+        persistRetryableTelegramAuthState(session, "waiting_for_password", error instanceof Error ? error.message : String(error));
+    }
+    return session;
+}
+function persistTelegramToken(session) {
+    const snapshot = session.authSession.getSnapshot();
+    const connectorConfig = session.authSession.getResolvedConnectorConfig();
+    const now = new Date().toISOString();
+    const token = {
+        provider: "telegram",
+        agentId: session.agentId,
+        side: session.side,
+        // The session string is persisted by TelegramAccountAuthSession
+        // in ~/.eliza/telegram-account/session.txt — we store the path reference.
+        sessionString: connectorConfig?.appId ? "persisted" : "",
+        apiId: connectorConfig ? Number(connectorConfig.appId) : (session.apiId ?? 0),
+        apiHash: connectorConfig?.appHash ?? session.apiHash ?? "",
+        phone: session.phone,
+        identity: session.identity ?? { id: "", username: "", firstName: "" },
+        connectorConfig,
+        createdAt: now,
+        updatedAt: now,
+    };
+    const tokenRef = buildTelegramTokenRef(session.agentId, session.side);
+    const tokenPath = resolveTokenPath(tokenRef);
+    ensureTokenStorageDir(path.dirname(tokenPath));
+    fs.writeFileSync(tokenPath, JSON.stringify(token, null, 2), {
+        mode: 0o600,
+    });
+}
+export function getTelegramAuthStatus(sessionId) {
+    cleanupExpiredSessions();
+    const existing = pendingTelegramAuthSessions.get(sessionId);
+    if (existing) {
+        return existing;
+    }
+    const stored = readPendingTelegramSession(sessionId);
+    return stored ? restorePendingTelegramAuthSession(stored) : null;
+}
+export async function cancelTelegramAuth(sessionId) {
+    const session = pendingTelegramAuthSessions.get(sessionId);
+    if (session) {
+        await session.authSession.stop().catch(() => { });
+        pendingTelegramAuthSessions.delete(sessionId);
+    }
+    deletePendingTelegramSession(sessionId);
+}
+// ---------------------------------------------------------------------------
+// Token ref builder (exported for service mixin)
+// ---------------------------------------------------------------------------
+export { buildTelegramTokenRef };
+// ---------------------------------------------------------------------------
+// Session lookup
+// ---------------------------------------------------------------------------
+export function findPendingTelegramAuthSession(agentId, side) {
+    cleanupExpiredSessions();
+    for (const session of pendingTelegramAuthSessions.values()) {
+        if (session.agentId === agentId && session.side === side) {
+            return recoverRetryableTelegramAuthSession(session);
+        }
+    }
+    const stored = listPendingTelegramSessions().find((session) => session.agentId === agentId && session.side === side);
+    return stored ? restorePendingTelegramAuthSession(stored) : null;
+}
+// ---------------------------------------------------------------------------
+// Credential management
+// ---------------------------------------------------------------------------
+export function readStoredTelegramToken(tokenRef) {
+    const filePath = resolveTokenPath(tokenRef);
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || parsed.provider !== "telegram") {
+        return null;
+    }
+    return parsed;
+}
+export function deleteStoredTelegramToken(tokenRef) {
+    const filePath = resolveTokenPath(tokenRef);
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+}

package/apps/app-lifeops/src/lifeops/telegram-local-client.d.ts

@@ -0,0 +1,118 @@
+import type { LifeOpsTelegramDialogSummary, VerifyLifeOpsTelegramConnectorResponse } from "@elizaos/shared/contracts/lifeops";
+import type { StoredTelegramConnectorToken } from "./telegram-auth.js";
+export interface TelegramLocalClientLike {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getDialogs(args: {
+        limit: number;
+    }): Promise<ReadonlyArray<TelegramDialogLike>>;
+    getEntity(target: unknown): Promise<unknown>;
+    sendMessage(entity: unknown, args: {
+        message: string;
+    }): Promise<{
+        id?: unknown;
+    } | null | undefined>;
+    getMessages(entity: unknown, args: {
+        search?: string;
+        ids?: number | number[];
+        limit?: number;
+    }): Promise<ReadonlyArray<TelegramMessageLike | null | undefined>>;
+}
+export interface TelegramMessageLike {
+    id?: unknown;
+    message?: string;
+    date?: Date | number | string;
+    out?: boolean;
+    fromId?: {
+        userId?: unknown;
+    } | null;
+    peerId?: {
+        userId?: unknown;
+        chatId?: unknown;
+        channelId?: unknown;
+    } | null;
+    /** Whether the current account was mentioned in this message. */
+    mentioned?: boolean;
+    /** Optional group/channel read count when present on the returned message. */
+    readCount?: number | null;
+}
+export type TelegramDeliveryStatus = "delivered_read" | "sent" | "unknown";
+export interface TelegramMessageSearchResult {
+    id: string | null;
+    dialogId: string | null;
+    dialogTitle: string | null;
+    username: string | null;
+    content: string;
+    timestamp: string | null;
+    outgoing: boolean;
+}
+export interface TelegramReadReceiptResult {
+    messageId: string;
+    status: TelegramDeliveryStatus;
+    isRead: boolean | null;
+    timestamp: string | null;
+    content: string | null;
+    outgoing: boolean | null;
+}
+export interface TelegramDialogLike {
+    id?: unknown;
+    name?: string;
+    title?: string;
+    unreadCount?: number;
+    dialog?: {
+        readOutboxMaxId?: unknown;
+    } | null;
+    message?: {
+        message?: string;
+        date?: Date | number | string;
+    } | null;
+    entity?: Record<string, unknown> | null;
+    inputEntity?: unknown;
+}
+export interface TelegramLocalClientDeps {
+    loadSessionString?: () => string;
+    readStoredToken?: (tokenRef: string) => StoredTelegramConnectorToken | null;
+    createClient?: (args: {
+        sessionString: string;
+        apiId: number;
+        apiHash: string;
+        deviceModel: string;
+        systemVersion: string;
+    }) => TelegramLocalClientLike;
+    now?: () => Date;
+}
+export declare function telegramLocalSessionAvailable(deps?: Pick<TelegramLocalClientDeps, "loadSessionString">): boolean;
+export declare function listRecentTelegramDialogs(args: {
+    tokenRef: string;
+    limit?: number;
+    deps?: TelegramLocalClientDeps;
+}): Promise<LifeOpsTelegramDialogSummary[]>;
+export declare function sendTelegramAccountMessage(args: {
+    tokenRef: string;
+    target: string;
+    message: string;
+    deps?: TelegramLocalClientDeps;
+}): Promise<{
+    messageId: string | null;
+}>;
+export declare function searchTelegramMessages(args: {
+    tokenRef: string;
+    query: string;
+    scope?: string;
+    limit?: number;
+    deps?: TelegramLocalClientDeps;
+}): Promise<TelegramMessageSearchResult[]>;
+export declare function getTelegramReadReceipts(args: {
+    tokenRef: string;
+    target: string;
+    messageIds: string[];
+    deps?: TelegramLocalClientDeps;
+}): Promise<TelegramReadReceiptResult[]>;
+export declare function verifyTelegramLocalConnector(args: {
+    tokenRef: string;
+    recentLimit?: number;
+    sendTarget?: string;
+    sendMessage?: string;
+    deps?: TelegramLocalClientDeps;
+}): Promise<Omit<VerifyLifeOpsTelegramConnectorResponse, "provider" | "side">>;
+//# sourceMappingURL=telegram-local-client.d.ts.map

package/apps/app-lifeops/src/lifeops/telegram-local-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram-local-client.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/telegram-local-client.ts"],"names":[],"mappings":"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"}