jeopi-cli 16.5.6 → 16.6.1

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/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.1",
 	"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.1",
+		"jeopi-stats": "16.6.1",
+		"jeopi-agent-core": "16.6.1",
+		"jeopi-ai": "16.6.1",
+		"jeopi-catalog": "16.6.1",
+		"jeopi-mnemopi": "16.6.1",
+		"jeopi-natives": "16.6.1",
+		"jeopi-tui": "16.6.1",
+		"jeopi-utils": "16.6.1",
+		"jeopi-wire": "16.6.1",
+		"jeopi-snapcompact": "16.6.1",
 		"@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

@@ -1643,13 +1643,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 +1774,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 };

package/src/messenger/config.ts

@@ -0,0 +1,111 @@
+import * as path from "node:path";
+import type { MessengerConfig, MessengerPlatform, MessengerPlatformConfig } from "./types";
+
+const PLATFORMS: MessengerPlatform[] = ["discord", "telegram", "slack"];
+const TOOLS: Record<string, true> = { read: true, grep: true, glob: true, bash: true, edit: true, write: true };
+
+function object(value: unknown, label: string): Record<string, unknown> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		throw new Error(`${label} must be an object`);
+	}
+	return value as Record<string, unknown>;
+}
+
+function keys(value: Record<string, unknown>, allowed: string[], label: string): void {
+	if (Object.keys(value).some(key => !allowed.includes(key))) throw new Error(`${label} contains an unknown setting`);
+}
+
+function string(value: unknown, label: string): string {
+	if (typeof value !== "string" || value.trim() !== value || !value || /[\u0000-\u001f\u007f]/u.test(value)) {
+		throw new Error(`${label} must be a nonempty string without surrounding whitespace or control characters`);
+	}
+	return value;
+}
+
+function ids(value: unknown, label: string): string[] {
+	if (!Array.isArray(value) || value.length === 0) throw new Error(`${label} must be a nonempty list of exact IDs`);
+	const result = value.map(item => string(item, label));
+	if (result.some(id => /[\s*]/u.test(id)) || new Set(result).size !== result.length) {
+		throw new Error(`${label} must contain unique exact IDs, without whitespace or wildcards`);
+	}
+	return result;
+}
+
+function envName(value: unknown, fallback: string, label: string): string {
+	const result = value === undefined ? fallback : string(value, label);
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(result)) throw new Error(`${label} must name an environment variable`);
+	return result;
+}
+
+export function parseMessengerConfig(value: unknown, baseDir: string): MessengerConfig {
+	const input = object(value, "Messenger config");
+	keys(input, ["cwd", "sessionDir", "toolNames", "platforms"], "Messenger config");
+	const platformsInput = object(input.platforms, "platforms");
+	keys(platformsInput, PLATFORMS, "platforms");
+	if (Object.keys(platformsInput).length === 0) throw new Error("At least one messenger platform is required");
+	const platforms: MessengerConfig["platforms"] = {};
+	for (const platform of PLATFORMS) {
+		if (!Object.hasOwn(platformsInput, platform)) continue;
+		const item = object(platformsInput[platform], `${platform} config`);
+		keys(
+			item,
+			platform === "slack"
+				? ["tokenEnv", "appTokenEnv", "allowedUserIds", "allowedChannelIds"]
+				: ["tokenEnv", "allowedUserIds", "allowedChannelIds"],
+			`${platform} config`,
+		);
+		const config: MessengerPlatformConfig = {
+			tokenEnv: envName(item.tokenEnv, `JEOPI_${platform.toUpperCase()}_BOT_TOKEN`, `${platform}.tokenEnv`),
+			allowedUserIds: ids(item.allowedUserIds, `${platform}.allowedUserIds`),
+		};
+		if (platform === "slack")
+			config.appTokenEnv = envName(item.appTokenEnv, "JEOPI_SLACK_APP_TOKEN", "slack.appTokenEnv");
+		if (item.allowedChannelIds !== undefined)
+			config.allowedChannelIds = ids(item.allowedChannelIds, `${platform}.allowedChannelIds`);
+		platforms[platform] = config;
+	}
+	const toolNames = input.toolNames === undefined ? [] : input.toolNames;
+	if (
+		!Array.isArray(toolNames) ||
+		toolNames.some(name => typeof name !== "string" || !Object.hasOwn(TOOLS, name)) ||
+		new Set(toolNames).size !== toolNames.length
+	) {
+		throw new Error("toolNames must be a unique list drawn from read, grep, glob, bash, edit, write");
+	}
+	return {
+		cwd: path.resolve(baseDir, input.cwd === undefined ? "." : string(input.cwd, "cwd")),
+		sessionDir: path.resolve(
+			baseDir,
+			input.sessionDir === undefined ? ".jeopi/messenger-sessions" : string(input.sessionDir, "sessionDir"),
+		),
+		toolNames: [...toolNames] as string[],
+		platforms,
+	};
+}
+
+export async function loadMessengerConfig(file: string): Promise<MessengerConfig> {
+	let value: unknown;
+	try {
+		value = await Bun.file(file).json();
+	} catch {
+		throw new Error("Cannot read messenger configuration as JSON");
+	}
+	return parseMessengerConfig(value, path.dirname(path.resolve(file)));
+}
+
+export function validateMessengerEnvironment(
+	config: MessengerConfig,
+	env: Record<string, string | undefined> = process.env,
+): void {
+	for (const platform of PLATFORMS) {
+		const item = config.platforms[platform];
+		if (!item) continue;
+		for (const name of [item.tokenEnv, item.appTokenEnv]) {
+			if (name === undefined) continue;
+			const token = env[name];
+			if (!token?.trim() || token !== token.trim() || /[\s\u0000-\u001f\u007f]/u.test(token)) {
+				throw new Error(`${platform} requires a nonempty credential in ${name}`);
+			}
+		}
+	}
+}