jeopi-cli 16.5.6 → 16.6.2

package/dist/types/cli/messenger-cli.d.ts

@@ -0,0 +1,10 @@
+export declare const MESSENGER_ACTIONS: readonly ["check", "run"];
+export type MessengerAction = (typeof MESSENGER_ACTIONS)[number];
+export interface MessengerCommandArgs {
+    action: MessengerAction;
+    flags: {
+        config: string;
+    };
+}
+/** Check is deliberately local-only: it never imports the SDK or starts a transport. */
+export declare function runMessengerCommand(cmd: MessengerCommandArgs): Promise<void>;

package/dist/types/commands/messenger.d.ts

@@ -0,0 +1,18 @@
+import { Command } from "jeopi-utils/cli";
+export default class Messenger extends Command {
+    static description: string;
+    static args: {
+        action: import("jeopi-utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            options: ("check" | "run")[];
+        };
+    };
+    static flags: {
+        config: import("jeopi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/types/config/model-registry.d.ts

@@ -2,7 +2,7 @@ import type { Api, Context, Model, ModelSpec, RemoteCompactionConfig, SimpleStre
 import type { AssistantMessageEventStream } from "jeopi-ai/utils/event-stream";
 import { type ModelRefreshStrategy } from "jeopi-catalog/model-manager";
 import type { ApiKeyResolver, FetchImpl } from "jeopi-ai";
-import type { OAuthCredentials, OAuthLoginCallbacks } from "jeopi-ai/oauth/types";
+import type { OAuthCredentials, OAuthLoginCallbacks, OAuthProviderId } from "jeopi-ai/oauth/types";
 import type { AuthStorage } from "../session/auth-storage";
 import { type ApiKeyResolverModel, type ApiKeyResolverOptions } from "./api-key-resolver";
 import type { ConfigError } from "./config-file";
@@ -73,6 +73,8 @@ export declare class ModelRegistry {
     constructor(authStorage: AuthStorage, modelsPath?: string, options?: {
         fetch?: FetchImpl;
     });
+    /** Save login credentials, then bypass the catalog TTL for the authenticated provider. */
+    login(providerId: OAuthProviderId, callbacks: OAuthLoginCallbacks): Promise<void>;
     /**
      * Reload models from disk (built-in + custom config).
      */

package/dist/types/messenger/config.d.ts

@@ -0,0 +1,4 @@
+import type { MessengerConfig } from "./types";
+export declare function parseMessengerConfig(value: unknown, baseDir: string): MessengerConfig;
+export declare function loadMessengerConfig(file: string): Promise<MessengerConfig>;
+export declare function validateMessengerEnvironment(config: MessengerConfig, env?: Record<string, string | undefined>): void;

package/dist/types/messenger/discord.d.ts

@@ -0,0 +1,10 @@
+import type { MessengerAdapter, MessengerPlatformConfig, MessengerTransportDeps } from "./types";
+export interface DiscordClock {
+    /** Schedule once and return an idempotent cancellation function. */
+    schedule(callback: () => void, delayMs: number): () => void;
+    random(): number;
+}
+export interface DiscordTransportDeps extends MessengerTransportDeps {
+    clock?: DiscordClock;
+}
+export declare function createDiscordAdapter(config: MessengerPlatformConfig, env?: Record<string, string | undefined>, deps?: DiscordTransportDeps): MessengerAdapter;

package/dist/types/messenger/gateway.d.ts

@@ -0,0 +1,9 @@
+import type { MessengerAdapter, MessengerConfig, MessengerMessage, MessengerReply } from "./types";
+/** Include the sender even in shared threads: remote histories must not cross users. */
+export declare function messengerConversationKey(message: MessengerMessage): string;
+export declare function isMessengerMessageAllowed(message: MessengerMessage, config: MessengerConfig): boolean;
+export interface MessengerGateway {
+    run(signal: AbortSignal): Promise<void>;
+    handle(message: MessengerMessage, signal?: AbortSignal): Promise<void>;
+}
+export declare function createMessengerGateway(config: MessengerConfig, adapters: MessengerAdapter[], reply: MessengerReply): MessengerGateway;

package/dist/types/messenger/http.d.ts

@@ -0,0 +1,9 @@
+export declare class MessengerHttpError extends Error {
+    readonly status: number;
+    readonly retryAfterMs?: number | undefined;
+    constructor(status: number, retryAfterMs?: number | undefined);
+}
+/** Provider limits count UTF-16 units; do not bisect supplementary characters. */
+export declare function splitMessengerText(text: string, limit: number): string[];
+export declare function messengerFetchJson(url: string, init: RequestInit, signal?: AbortSignal, fetchImpl?: typeof fetch): Promise<unknown>;
+export declare function waitForMessengerRetry(ms: number, signal: AbortSignal): Promise<void>;

package/dist/types/messenger/session.d.ts

@@ -0,0 +1,17 @@
+import type { Model } from "jeopi-ai";
+import type { ModelRegistry } from "../config/model-registry";
+import type { AuthStorage } from "../session/auth-storage";
+import { type MessengerConfig, type MessengerReply } from "./types";
+export interface MessengerSessionBridge {
+    reply: MessengerReply;
+    close(): Promise<void>;
+}
+/** Explicit SDK resources for embedded callers; security policy remains bridge-owned. */
+export interface MessengerSessionDependencies {
+    agentDir: string;
+    authStorage: AuthStorage;
+    modelRegistry: ModelRegistry;
+    model: Model;
+}
+/** One Main session owns the SDK's process-global lifecycle until gateway shutdown. */
+export declare function createMessengerSessionBridge(config: MessengerConfig, dependencies?: MessengerSessionDependencies): MessengerSessionBridge;

package/dist/types/messenger/slack.d.ts

@@ -0,0 +1,2 @@
+import type { MessengerAdapter, MessengerPlatformConfig, MessengerTransportDeps } from "./types";
+export declare function createSlackAdapter(config: MessengerPlatformConfig, env?: Record<string, string | undefined>, deps?: MessengerTransportDeps): MessengerAdapter;

package/dist/types/messenger/telegram.d.ts

@@ -0,0 +1,2 @@
+import type { MessengerAdapter, MessengerPlatformConfig, MessengerTransportDeps } from "./types";
+export declare function createTelegramAdapter(config: MessengerPlatformConfig, env?: Record<string, string | undefined>, deps?: MessengerTransportDeps): MessengerAdapter;

package/dist/types/messenger/types.d.ts

@@ -0,0 +1,38 @@
+export type MessengerPlatform = "discord" | "telegram" | "slack";
+export interface MessengerMessage {
+    platform: MessengerPlatform;
+    accountId: string;
+    channelId: string;
+    senderId: string;
+    messageId: string;
+    text: string;
+    threadId?: string;
+    direct: boolean;
+    mentioned: boolean;
+}
+export interface MessengerAdapter {
+    platform: MessengerPlatform;
+    start(onMessage: (message: MessengerMessage) => Promise<void>, signal: AbortSignal): Promise<void>;
+    send(message: MessengerMessage, text: string, signal?: AbortSignal): Promise<void>;
+}
+export interface MessengerPlatformConfig {
+    tokenEnv: string;
+    appTokenEnv?: string;
+    allowedUserIds: string[];
+    allowedChannelIds?: string[];
+}
+export interface MessengerConfig {
+    cwd: string;
+    sessionDir: string;
+    toolNames: string[];
+    platforms: Partial<Record<MessengerPlatform, MessengerPlatformConfig>>;
+}
+export interface MessengerTransportDeps {
+    fetch?: typeof fetch;
+    WebSocket?: typeof WebSocket;
+}
+export type MessengerReply = (message: MessengerMessage, signal: AbortSignal) => Promise<string>;
+/** A partially initialized SDK must not be retried inside a live gateway. */
+export declare class MessengerFatalError extends Error {
+    constructor();
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-cli",
-	"version": "16.5.6",
+	"version": "16.6.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -57,17 +57,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"jeopi-hashline": "16.5.6",
-		"jeopi-stats": "16.5.6",
-		"jeopi-agent-core": "16.5.6",
-		"jeopi-ai": "16.5.6",
-		"jeopi-catalog": "16.5.6",
-		"jeopi-mnemopi": "16.5.6",
-		"jeopi-natives": "16.5.6",
-		"jeopi-tui": "16.5.6",
-		"jeopi-utils": "16.5.6",
-		"jeopi-wire": "16.5.6",
-		"jeopi-snapcompact": "16.5.6",
+		"jeopi-hashline": "16.6.2",
+		"jeopi-stats": "16.6.2",
+		"jeopi-agent-core": "16.6.2",
+		"jeopi-ai": "16.6.2",
+		"jeopi-catalog": "16.6.2",
+		"jeopi-mnemopi": "16.6.2",
+		"jeopi-natives": "16.6.2",
+		"jeopi-tui": "16.6.2",
+		"jeopi-utils": "16.6.2",
+		"jeopi-wire": "16.6.2",
+		"jeopi-snapcompact": "16.6.2",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/cli/messenger-cli.ts

@@ -0,0 +1,78 @@
+import { loadMessengerConfig, validateMessengerEnvironment } from "../messenger/config";
+import type { MessengerSessionBridge } from "../messenger/session";
+import { type MessengerAdapter, type MessengerConfig, MessengerFatalError } from "../messenger/types";
+
+export const MESSENGER_ACTIONS = ["check", "run"] as const;
+export type MessengerAction = (typeof MESSENGER_ACTIONS)[number];
+export interface MessengerCommandArgs {
+	action: MessengerAction;
+	flags: { config: string };
+}
+
+/** Check is deliberately local-only: it never imports the SDK or starts a transport. */
+export async function runMessengerCommand(cmd: MessengerCommandArgs): Promise<void> {
+	if (!MESSENGER_ACTIONS.includes(cmd.action)) throw new Error("Unknown messenger action");
+	if (!cmd.flags.config) throw new Error("Messenger requires --config <file>");
+	// Do not echo parse errors, paths, configuration values, or environment secrets.
+	let config: MessengerConfig;
+	try {
+		config = await loadMessengerConfig(cmd.flags.config);
+		validateMessengerEnvironment(config);
+	} catch {
+		throw new Error("Messenger configuration or required environment is invalid");
+	}
+	const platforms = Object.keys(config.platforms);
+	if (cmd.action === "check") {
+		process.stdout.write(
+			`Messenger configuration valid: ${platforms.join(", ")}; ${config.toolNames.length} tools enabled. No network checks performed.\n`,
+		);
+		return;
+	}
+	if (config.toolNames.length > 0) {
+		process.stderr.write(
+			"Warning: enabled messenger tools grant authorized remote users local machine authority; this is not a sandbox.\n",
+		);
+	}
+
+	const controller = new AbortController();
+	const stop = (): void => controller.abort();
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+	let bridge: MessengerSessionBridge | undefined;
+	let failure: Error | undefined;
+	try {
+		const [{ createMessengerSessionBridge }, { createMessengerGateway }, telegram, discord, slack] =
+			await Promise.all([
+				import("../messenger/session"),
+				import("../messenger/gateway"),
+				import("../messenger/telegram"),
+				import("../messenger/discord"),
+				import("../messenger/slack"),
+			]);
+		if (controller.signal.aborted) return;
+		bridge = createMessengerSessionBridge(config);
+		const adapters: MessengerAdapter[] = [];
+		if (config.platforms.telegram) adapters.push(telegram.createTelegramAdapter(config.platforms.telegram));
+		if (config.platforms.discord) adapters.push(discord.createDiscordAdapter(config.platforms.discord));
+		if (config.platforms.slack) adapters.push(slack.createSlackAdapter(config.platforms.slack));
+		const gateway = createMessengerGateway(config, adapters, bridge.reply);
+		process.stdout.write(`Starting messenger: ${platforms.join(", ")}. Press Ctrl+C to stop.\n`);
+		await gateway.run(controller.signal);
+	} catch (error) {
+		failure =
+			error instanceof MessengerFatalError
+				? error
+				: new Error("Messenger gateway failed; check local configuration and provider access");
+	} finally {
+		controller.abort();
+		try {
+			await bridge?.close();
+		} catch {
+			failure ??= new Error("Messenger session shutdown failed");
+		} finally {
+			process.off("SIGINT", stop);
+			process.off("SIGTERM", stop);
+		}
+	}
+	if (failure) throw failure;
+}

package/src/cli-commands.ts

@@ -16,6 +16,7 @@ export const commands: CommandEntry[] = [
 	{ name: "acp", load: () => import("./commands/acp").then(m => m.default) },
 	{ name: "auth-broker", load: () => import("./commands/auth-broker").then(m => m.default) },
 	{ name: "auth-gateway", load: () => import("./commands/auth-gateway").then(m => m.default) },
+	{ name: "messenger", load: () => import("./commands/messenger").then(m => m.default) },
 	{ name: "agents", load: () => import("./commands/agents").then(m => m.default) },
 	{ name: "bench", load: () => import("./commands/bench").then(m => m.default) },
 	{ name: "commit", load: () => import("./commands/commit").then(m => m.default) },

package/src/commands/messenger.ts

@@ -0,0 +1,30 @@
+import { APP_NAME } from "jeopi-utils";
+import { Args, Command, Flags, renderCommandHelp } from "jeopi-utils/cli";
+import { MESSENGER_ACTIONS, type MessengerAction, runMessengerCommand } from "../cli/messenger-cli";
+
+export default class Messenger extends Command {
+	static description = "Run authorized Discord, Telegram, and Slack text bots";
+
+	static args = {
+		action: Args.string({ description: "Sub-command", required: false, options: [...MESSENGER_ACTIONS] }),
+	};
+
+	static flags = {
+		config: Flags.string({ description: "Path to messenger JSON configuration" }),
+	};
+
+	static examples = [
+		"jeopi messenger check --config ./messenger.json",
+		"jeopi messenger run --config ./messenger.json",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Messenger);
+		if (!args.action) {
+			renderCommandHelp(APP_NAME, "messenger", Messenger);
+			return;
+		}
+		if (!flags.config) throw new Error("Messenger requires --config <file>");
+		await runMessengerCommand({ action: args.action as MessengerAction, flags: { config: flags.config } });
+	}
+}

package/src/config/model-registry.ts

@@ -50,8 +50,8 @@ const STARTUP_MODEL_CACHE_PROVIDER_IDS: readonly string[] = [
 const LOCAL_PROVIDER_PLACEHOLDERS = new Set<string>(["llama-cpp-local", "lm-studio-local", "vllm-local"]);
 
 import type { ApiKeyResolver, FetchImpl } from "jeopi-ai";
-import { registerOAuthProvider, unregisterOAuthProviders } from "jeopi-ai/oauth";
-import type { OAuthCredentials, OAuthLoginCallbacks } from "jeopi-ai/oauth/types";
+import { getOAuthProviders, registerOAuthProvider, unregisterOAuthProviders } from "jeopi-ai/oauth";
+import type { OAuthCredentials, OAuthLoginCallbacks, OAuthProviderId } from "jeopi-ai/oauth/types";
 import { getBundledModelReferenceIndex, resolveModelReference } from "jeopi-catalog/identity";
 import { isBunTestRuntime, isRecord, logger, wrapFetchForExtraCa } from "jeopi-utils";
 import { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
@@ -788,6 +788,14 @@ export class ModelRegistry {
 		this.#loadModels();
 	}
 
+	/** Save login credentials, then bypass the catalog TTL for the authenticated provider. */
+	async login(providerId: OAuthProviderId, callbacks: OAuthLoginCallbacks): Promise<void> {
+		await this.authStorage.login(providerId, callbacks);
+		const modelProviderId =
+			getOAuthProviders().find(provider => provider.id === providerId)?.storeCredentialsAs ?? providerId;
+		await this.refreshProvider(modelProviderId, "online");
+	}
+
 	/**
 	 * Reload models from disk (built-in + custom config).
 	 */
@@ -1643,13 +1651,40 @@ export class ModelRegistry {
 		}> = [
 			{
 				providerId: "google-antigravity",
-				resolveKey: extractGoogleOAuthToken,
-				createOptions: oauthToken =>
-					googleAntigravityModelManagerOptions({
+				resolveKey: value =>
+					extractGoogleOAuthToken(value) ?? this.authStorage.getOAuthCredential("google-antigravity")?.access,
+				createOptions: oauthToken => {
+					// Pin discovery to one stable account, including when its access token has expired.
+					// Independent peek/getApiKey calls otherwise advance round-robin and poison the cache scope.
+					const account = this.authStorage.listOAuthAccounts("google-antigravity")[0];
+					const cacheScope = account
+						? JSON.stringify([account.credentialId, account.accountId ?? account.email, account.projectId])
+						: undefined;
+					return googleAntigravityModelManagerOptions({
 						oauthToken,
-						endpoint: this.getProviderBaseUrl("google-antigravity"),
+						cacheScope,
+						endpoint:
+							this.#runtimeProviderOverrides.get("google-antigravity")?.baseUrl ??
+							this.#providerOverrides.get("google-antigravity")?.baseUrl ??
+							this.getProviderBaseUrl("google-antigravity"),
 						fetch: this.#fetch,
-					}),
+						resolveOAuthToken: async signal => {
+							if (!account) {
+								return extractGoogleOAuthToken(
+									await this.getApiKeyForProvider("google-antigravity", undefined, { signal }),
+								);
+							}
+							const current = this.authStorage
+								.listOAuthAccounts("google-antigravity")
+								.find(entry => entry.credentialId === account.credentialId);
+							if (!current) return undefined;
+							const access = await this.authStorage.getOAuthAccessAt("google-antigravity", current.position, {
+								signal,
+							});
+							return access?.ok ? access.accessToken : undefined;
+						},
+					});
+				},
 			},
 			{
 				providerId: "google-gemini-cli",
@@ -1747,7 +1782,7 @@ export class ModelRegistry {
 				model.provider === options.providerId ? model : { ...model, provider: options.providerId },
 			);
 			const authoritativeProviders = new Set<string>();
-			if (options.dynamicModelsAuthoritative && !result.stale) {
+			if (options.dynamicModelsAuthoritative && (!result.stale || result.preservedAuthoritativeCache)) {
 				authoritativeProviders.add(options.providerId);
 			}
 			return { models, authoritativeProviders };