@prometheus-ai/agent 0.5.3 → 0.5.8

package/src/slash-commands/helpers/active-oauth-account.ts

@@ -0,0 +1,44 @@
+import type { UsageLimit, UsageReport } from "@prometheus-ai/ai";
+import type { OAuthAccountIdentity } from "../../session/auth-storage";
+
+function normalizeIdentityValue(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim().toLowerCase() : undefined;
+}
+
+/**
+ * True when a single usage-limit column belongs to the given OAuth identity.
+ *
+ * Single definition of the matching rules for both `/usage` renderers:
+ * - `accountId` ↔ report metadata `accountId`/`account_id` or `limit.scope.accountId`
+ * - `email`     ↔ report metadata `email`
+ * - `projectId` ↔ report metadata `projectId` or `limit.scope.projectId`
+ *   (Google-style providers key usage on the GCP project, not an account id)
+ */
+export function limitMatchesActiveAccount(
+	report: UsageReport,
+	limit: UsageLimit,
+	identity: OAuthAccountIdentity | undefined,
+): boolean {
+	if (!identity) return false;
+	const metadata = report.metadata ?? {};
+	const activeAccountId = normalizeIdentityValue(identity.accountId);
+	if (activeAccountId) {
+		const reportAccountId = normalizeIdentityValue(metadata.accountId) ?? normalizeIdentityValue(metadata.account_id);
+		if (reportAccountId === activeAccountId) return true;
+		if (normalizeIdentityValue(limit.scope.accountId) === activeAccountId) return true;
+	}
+	const activeEmail = normalizeIdentityValue(identity.email);
+	if (activeEmail && normalizeIdentityValue(metadata.email) === activeEmail) return true;
+	const activeProjectId = normalizeIdentityValue(identity.projectId);
+	if (activeProjectId) {
+		if (normalizeIdentityValue(metadata.projectId) === activeProjectId) return true;
+		if (normalizeIdentityValue(limit.scope.projectId) === activeProjectId) return true;
+	}
+	return false;
+}
+
+/** True when any limit column in `report` belongs to the given OAuth identity. */
+export function reportMatchesActiveAccount(report: UsageReport, identity: OAuthAccountIdentity | undefined): boolean {
+	if (!identity) return false;
+	return report.limits.some(limit => limitMatchesActiveAccount(report, limit, identity));
+}

package/src/slash-commands/helpers/context-report.ts

@@ -9,7 +9,7 @@ import { renderAsciiBar } from "./format";
  */
 export function buildContextReportText(runtime: SlashCommandRuntime): string {
 	try {
-		const breakdown = computeContextBreakdown(runtime.session);
+		const breakdown = computeContextBreakdown(runtime.session, { snapcompactSavings: true });
 		if (breakdown.contextWindow <= 0) {
 			return "Context usage is unavailable: no model is selected for this session.";
 		}
@@ -30,6 +30,33 @@ export function buildContextReportText(runtime: SlashCommandRuntime): string {
 			const fraction = breakdown.freeTokens / breakdown.contextWindow;
 			lines.push(`  ${"Free".padEnd(16)} ${renderAsciiBar(fraction)}  ${breakdown.freeTokens} tokens`);
 		}
+		const snap = breakdown.snapcompact;
+		if (snap) {
+			if (!snap.visionCapable) {
+				lines.push("Snapcompact: inactive (model has no image input)");
+			} else {
+				lines.push("Snapcompact (estimated wire savings):");
+				if (snap.systemPrompt) {
+					const sp = snap.systemPrompt;
+					lines.push(
+						sp.applied
+							? `  System prompt: ${sp.textTokens} text tokens → ${sp.frames} frame${sp.frames === 1 ? "" : "s"} ≈ ${sp.imageTokens} tokens (saves ~${sp.savedTokens})`
+							: "  System prompt: stays text (no net savings)",
+					);
+				}
+				if (snap.toolResults) {
+					const tr = snap.toolResults;
+					lines.push(
+						tr.swapped > 0
+							? `  Tool results: ${tr.swapped} of ${tr.total} imaged, ${tr.textTokens} text tokens → ${tr.frames} frames ≈ ${tr.imageTokens} tokens (saves ~${tr.savedTokens})`
+							: `  Tool results: none imaged (${tr.total} in history)`,
+					);
+				}
+				if (snap.savedTokens > 0) {
+					lines.push(`  Estimated next request: ~${breakdown.usedTokens - snap.savedTokens} tokens on the wire`);
+				}
+			}
+		}
 		return lines.join("\n");
 	} catch {
 		const fallback = runtime.session.getContextUsage();

package/src/slash-commands/helpers/logout.ts

@@ -0,0 +1,88 @@
+import type { OAuthAccountIdentity, StoredAuthCredential } from "../../session/auth-storage";
+
+export interface LogoutAccount {
+	credentialId: number;
+	provider: string;
+	label: string;
+	detail: string;
+	type: "api_key" | "oauth";
+	active: boolean;
+}
+
+interface LogoutAccountOptions {
+	activeIdentity?: OAuthAccountIdentity;
+	activeApiKey?: boolean;
+}
+
+function nonEmpty(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+
+function oauthLabel(row: StoredAuthCredential): string {
+	const credential = row.credential;
+	if (credential.type !== "oauth") return `API key #${row.id}`;
+	return (
+		nonEmpty(credential.email) ??
+		nonEmpty(credential.accountId) ??
+		nonEmpty(credential.projectId) ??
+		nonEmpty(credential.enterpriseUrl) ??
+		`OAuth credential #${row.id}`
+	);
+}
+
+function oauthDetail(row: StoredAuthCredential, label: string): string {
+	const credential = row.credential;
+	if (credential.type === "api_key") return `stored API key #${row.id}`;
+	const parts: string[] = [];
+	const email = nonEmpty(credential.email);
+	const accountId = nonEmpty(credential.accountId);
+	const projectId = nonEmpty(credential.projectId);
+	const enterpriseUrl = nonEmpty(credential.enterpriseUrl);
+	if (email && email !== label) parts.push(email);
+	if (accountId && accountId !== label) parts.push(`account ${accountId}`);
+	if (projectId && projectId !== label) parts.push(`project ${projectId}`);
+	if (enterpriseUrl && enterpriseUrl !== label) parts.push(enterpriseUrl);
+	parts.push(`oauth #${row.id}`);
+	return parts.join(" · ");
+}
+
+function oauthMatchesActiveIdentity(
+	row: StoredAuthCredential,
+	activeIdentity: OAuthAccountIdentity | undefined,
+): boolean {
+	if (!activeIdentity || row.credential.type !== "oauth") return false;
+	const credential = row.credential;
+	return (
+		(activeIdentity.accountId !== undefined && credential.accountId === activeIdentity.accountId) ||
+		(activeIdentity.email !== undefined && credential.email === activeIdentity.email) ||
+		(activeIdentity.projectId !== undefined && credential.projectId === activeIdentity.projectId)
+	);
+}
+
+export function toLogoutAccounts(
+	provider: string,
+	credentials: StoredAuthCredential[],
+	options: LogoutAccountOptions = {},
+): LogoutAccount[] {
+	return credentials
+		.map(row => {
+			const label = oauthLabel(row);
+			const active =
+				row.credential.type === "oauth"
+					? oauthMatchesActiveIdentity(row, options.activeIdentity)
+					: options.activeApiKey === true;
+			return {
+				credentialId: row.id,
+				provider,
+				label,
+				detail: oauthDetail(row, label),
+				type: row.credential.type,
+				active,
+			} satisfies LogoutAccount;
+		})
+		.sort((left, right) => {
+			if (left.active !== right.active) return left.active ? -1 : 1;
+			return left.label.localeCompare(right.label) || left.credentialId - right.credentialId;
+		});
+}

package/src/slash-commands/helpers/reset-usage.ts

@@ -0,0 +1,66 @@
+/**
+ * Shared helpers for the `/usage reset` command (TUI selector + ACP): turn the
+ * live per-account reset-credit status into selector rows, and map a redeem
+ * outcome code to a human message.
+ */
+import type { ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget } from "../../session/auth-storage";
+
+export const CODEX_PROVIDER_ID = "openai-codex";
+
+/** One Codex account row for the reset-usage selector. */
+export interface ResetUsageAccount {
+	/** Display label (email, else account id). */
+	label: string;
+	/** Saved resets redeemable for this account right now. */
+	availableCount: number;
+	/** Identifies the account when redeeming. */
+	target: ResetCreditTarget;
+	/** Whether this is the session's active Codex account. */
+	active: boolean;
+	/** Set when this account could not be reached (token/list failure). */
+	error?: string;
+}
+
+/**
+ * Map live per-account reset status to selector rows. Sorted with the active
+ * account first, then most-credits, then label.
+ */
+export function toResetUsageAccounts(statuses: ResetCreditAccountStatus[]): ResetUsageAccount[] {
+	return statuses
+		.map(status => ({
+			label: status.email ?? status.accountId ?? "account",
+			availableCount: status.availableCount,
+			target: {
+				credentialId: status.credentialId,
+				accountId: status.accountId,
+				email: status.email,
+			} satisfies ResetCreditTarget,
+			active: status.active,
+			error: status.error,
+		}))
+		.sort((a, b) => {
+			if (a.active !== b.active) return a.active ? -1 : 1;
+			if (a.availableCount !== b.availableCount) return b.availableCount - a.availableCount;
+			return a.label.localeCompare(b.label);
+		});
+}
+
+/** Human-facing summary of a redeem outcome for status lines and ACP output. */
+export function describeRedeemOutcome(outcome: ResetCreditRedeemOutcome, label: string): string {
+	switch (outcome.code) {
+		case "reset":
+			return `Reset applied for ${label} — your rate-limit window has been refreshed.`;
+		case "already_redeemed":
+			return `${label}: that reset was already redeemed.`;
+		case "no_credit":
+			return `${label}: no saved resets available to spend.`;
+		case "nothing_to_reset":
+			return `${label}: nothing to reset right now — your limits aren't constrained, so no credit was spent.`;
+		case "no_account":
+			return `Could not find a stored Codex account matching "${label}".`;
+		case "account_unavailable":
+			return `${label}: could not authenticate this account — try /login.`;
+		default:
+			return `${label}: reset did not apply (${outcome.code}).`;
+	}
+}

package/src/slash-commands/helpers/stats-dashboard.ts

@@ -0,0 +1,85 @@
+import * as stats from "@prometheus-ai/stats";
+import * as openUtils from "../../utils/open";
+
+export const DEFAULT_STATS_DASHBOARD_PORT = 3847;
+
+interface StatsDashboardServer {
+	port: number;
+	stop: () => void;
+}
+
+export interface StatsDashboardArgs {
+	port: number;
+}
+
+export interface StatsDashboardLaunchResult {
+	url: string;
+	message: string;
+}
+
+let activeStatsServer: StatsDashboardServer | undefined;
+
+const STATS_DASHBOARD_USAGE = "Usage: /stats [--port <port>]";
+
+function parsePort(value: string | undefined): number | string {
+	if (!value) return `Missing port. ${STATS_DASHBOARD_USAGE}`;
+	if (!/^\d+$/.test(value)) return `Invalid port: ${value}`;
+	const port = Number(value);
+	if (!Number.isInteger(port) || port < 0 || port > 65_535) return `Invalid port: ${value}`;
+	return port;
+}
+
+export function parseStatsDashboardArgs(args: string): StatsDashboardArgs | { error: string } {
+	const tokens = args.split(/\s+/).filter(Boolean);
+	let port = DEFAULT_STATS_DASHBOARD_PORT;
+
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === "--port" || token === "-p") {
+			const parsed = parsePort(tokens[++i]);
+			if (typeof parsed === "string") return { error: parsed };
+			port = parsed;
+			continue;
+		}
+		if (token.startsWith("--port=")) {
+			const parsed = parsePort(token.slice("--port=".length));
+			if (typeof parsed === "string") return { error: parsed };
+			port = parsed;
+			continue;
+		}
+		return { error: `Unknown option: ${token}. ${STATS_DASHBOARD_USAGE}` };
+	}
+
+	return { port };
+}
+
+export async function launchStatsDashboard(args: StatsDashboardArgs): Promise<StatsDashboardLaunchResult> {
+	const { processed, files } = await stats.syncAllSessions();
+	const total = await stats.getTotalMessageCount();
+	let requestedPortIgnored = false;
+
+	if (!activeStatsServer) {
+		activeStatsServer = await stats.startServer(args.port);
+	} else if (args.port !== activeStatsServer.port) {
+		requestedPortIgnored = true;
+	}
+
+	const url = `http://localhost:${activeStatsServer.port}`;
+	openUtils.openPath(url);
+
+	const serverLine = requestedPortIgnored
+		? `Dashboard already running at: ${url} (requested port ${args.port} ignored)`
+		: `Dashboard available at: ${url}`;
+
+	return {
+		url,
+		message: `Synced ${processed} new entries from ${files} files (${total} total)\n${serverLine}`,
+	};
+}
+
+export function stopStatsDashboard(): void {
+	if (!activeStatsServer) return;
+	activeStatsServer.stop();
+	activeStatsServer = undefined;
+	stats.closeDb();
+}

package/src/slash-commands/helpers/usage-report.ts

@@ -1,5 +1,7 @@
 import type { UsageLimit, UsageReport } from "@prometheus-ai/ai";
+import type { OAuthAccountIdentity } from "../../session/auth-storage";
 import type { SlashCommandRuntime } from "../types";
+import { reportMatchesActiveAccount } from "./active-oauth-account";
 import { formatDuration, renderAsciiBar } from "./format";
 
 function formatProviderName(provider: string): string {
@@ -26,10 +28,16 @@ function formatUsageReportAccount(report: UsageReport, limit: UsageLimit, index:
 	if (typeof email === "string" && email) return email;
 	const accountId = report.metadata?.accountId ?? limit.scope.accountId;
 	if (typeof accountId === "string" && accountId) return accountId;
+	const projectId = report.metadata?.projectId ?? limit.scope.projectId;
+	if (typeof projectId === "string" && projectId) return projectId;
 	return `account ${index + 1}`;
 }
 
-function renderUsageReports(reports: UsageReport[], nowMs: number): string {
+function renderUsageReports(
+	reports: UsageReport[],
+	nowMs: number,
+	resolveActiveAccount?: (provider: string) => OAuthAccountIdentity | undefined,
+): string {
 	const latestFetchedAt = Math.max(...reports.map(report => report.fetchedAt ?? 0));
 	const lines = [`Usage${latestFetchedAt ? ` (${formatDuration(nowMs - latestFetchedAt)} ago)` : ""}`];
 	const grouped = new Map<string, UsageReport[]>();
@@ -43,7 +51,21 @@ function renderUsageReports(reports: UsageReport[], nowMs: number): string {
 		left.localeCompare(right),
 	)) {
 		lines.push("", formatProviderName(provider));
+		const activeAccount = resolveActiveAccount?.(provider);
 		for (const report of providerReports) {
+			const inUse = reportMatchesActiveAccount(report, activeAccount);
+			const savedResets = report.resetCredits?.availableCount ?? 0;
+			if (savedResets > 0) {
+				const resetLabel =
+					typeof report.metadata?.email === "string"
+						? report.metadata.email
+						: typeof report.metadata?.accountId === "string"
+							? report.metadata.accountId
+							: "account";
+				lines.push(
+					`- ${resetLabel}: ${savedResets} saved rate-limit reset${savedResets === 1 ? "" : "s"} available — /usage reset to spend`,
+				);
+			}
 			if (report.limits.length === 0) {
 				const email = typeof report.metadata?.email === "string" ? report.metadata.email : "account";
 				lines.push(`- ${email}: no limits reported`);
@@ -54,7 +76,9 @@ function renderUsageReports(reports: UsageReport[], nowMs: number): string {
 				const window = limit.window?.label ?? limit.scope.windowId;
 				const tier = limit.scope.tier ? ` (${limit.scope.tier})` : "";
 				lines.push(`- ${limit.label}${tier}${window ? ` — ${window}` : ""}`);
-				lines.push(`  ${formatUsageReportAccount(report, limit, index)}: ${formatUsageAmount(limit)}`);
+				lines.push(
+					`  ${formatUsageReportAccount(report, limit, index)}: ${formatUsageAmount(limit)}${inUse ? "  ← in use by this session" : ""}`,
+				);
 				lines.push(`  ${renderAsciiBar(limit.amount.usedFraction)}`);
 				if (limit.window?.resetsAt && limit.window.resetsAt > nowMs) {
 					lines.push(`  resets in ${formatDuration(limit.window.resetsAt - nowMs)}`);
@@ -77,7 +101,18 @@ export async function buildUsageReportText(runtime: SlashCommandRuntime): Promis
 	};
 	if (provider.fetchUsageReports) {
 		const reports = await provider.fetchUsageReports();
-		if (reports && reports.length > 0) return renderUsageReports(reports, Date.now());
+		if (reports && reports.length > 0) {
+			const currentProvider = runtime.session.model?.provider;
+			const activeAccount = currentProvider
+				? runtime.session.modelRegistry.authStorage.getOAuthAccountIdentity(
+						currentProvider,
+						runtime.session.sessionId,
+					)
+				: undefined;
+			return renderUsageReports(reports, Date.now(), providerId =>
+				providerId === currentProvider ? activeAccount : undefined,
+			);
+		}
 	}
 
 	const stats = runtime.session.sessionManager.getUsageStatistics();

package/src/slash-commands/types.ts

@@ -14,6 +14,7 @@ export interface SubcommandDef {
 /** Declarative builtin slash command metadata used by autocomplete and help UI. */
 export interface BuiltinSlashCommand {
 	name: string;
+	aliases?: string[];
 	description: string;
 	/** Subcommands for dropdown completion (e.g. /mcp add, /mcp list). */
 	subcommands?: SubcommandDef[];
@@ -71,20 +72,17 @@ export interface SlashCommandRuntime {
 
 /**
  * Runtime visible to TUI-only handlers (`handleTui`). Carries the interactive
- * mode context plus the background-detach hook. Intentionally narrower than
- * `SlashCommandRuntime` so existing callers can keep building it from just
- * `{ ctx, handleBackgroundCommand }`; when the TUI dispatcher needs to invoke
- * a `handle` (no `handleTui` override), it synthesizes a `SlashCommandRuntime`
- * from `ctx`.
+ * mode context. Intentionally narrower than `SlashCommandRuntime` so existing
+ * callers can keep building it from just `{ ctx }`; when the TUI dispatcher
+ * needs to invoke a `handle` (no `handleTui` override), it synthesizes a
+ * `SlashCommandRuntime` from `ctx`.
  */
 export interface TuiSlashCommandRuntime {
 	ctx: InteractiveModeContext;
-	handleBackgroundCommand: () => void;
 }
 
 /** Unified slash-command spec consumed by both TUI and ACP dispatchers. */
 export interface SlashCommandSpec extends BuiltinSlashCommand {
-	aliases?: string[];
 	/** When false, the dispatcher refuses to handle invocations that include arguments. */
 	allowArgs?: boolean;
 	/**
@@ -101,8 +99,6 @@ export interface SlashCommandSpec extends BuiltinSlashCommand {
 	 * not silently drop it from `available_commands_update`.
 	 */
 	acpInputHint?: string;
-	/** When false, text-mode callers may execute the command but ACP does not advertise it in `available_commands_update`. */
-	advertiseInAcp?: boolean;
 	/**
 	 * Text/ACP-mode handler. The same body is invoked from the ACP dispatcher
 	 * and, via the TUI adapter, when no `handleTui` override is provided.

package/src/ssh/connection-manager.ts

@@ -355,6 +355,33 @@ export async function getHostInfoForHost(host: SSHConnectionTarget): Promise<SSH
 	return await loadHostInfoFromDisk(host);
 }
 
+/**
+ * Synchronous, probe-free host info lookup for startup paths.
+ *
+ * Checks the in-memory cache, then falls back to a synchronous read of the
+ * persisted host-info cache file. Never opens a connection or probes the
+ * remote host — callers get `undefined` when nothing is cached yet.
+ */
+export function getCachedHostInfoSync(host: SSHConnectionTarget): SSHHostInfo | undefined {
+	const cached = hostInfoCache.get(host.name);
+	if (cached) {
+		const resolved = applyCompatOverride(host, cached);
+		if (resolved !== cached) hostInfoCache.set(host.name, resolved);
+		return resolved;
+	}
+	try {
+		const parsed = parseHostInfo(JSON.parse(fs.readFileSync(getHostInfoPath(host.name), "utf-8")));
+		if (!parsed) return undefined;
+		const resolved = applyCompatOverride(host, parsed);
+		hostInfoCache.set(host.name, resolved);
+		return resolved;
+	} catch (err) {
+		if (isEnoent(err)) return undefined;
+		logger.warn("Failed to load SSH host info", { host: host.name, error: String(err) });
+		return undefined;
+	}
+}
+
 export async function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
 	const cached = hostInfoCache.get(host.name);
 	if (cached) {

package/src/ssh/ssh-executor.ts

@@ -42,6 +42,42 @@ export interface SSHResult {
 	artifactId?: string;
 }
 
+type SSHExitEvent = { kind: "exit"; exitCode: number } | { kind: "error"; error: unknown };
+
+function sshExitEvent(exitCode: number): SSHExitEvent {
+	return { kind: "exit", exitCode };
+}
+
+function sshErrorEvent(error: unknown): SSHExitEvent {
+	return { kind: "error", error };
+}
+
+function createAbortWaiter(
+	signal: AbortSignal | undefined,
+	streamAbort: AbortController,
+): { promise: Promise<ptree.AbortError> | undefined; cleanup: () => void } {
+	if (!signal) {
+		return { promise: undefined, cleanup: () => {} };
+	}
+
+	const { promise, resolve } = Promise.withResolvers<ptree.AbortError>();
+	const onAbort = () => {
+		const error = new ptree.AbortError(signal.reason, "<cancelled>");
+		if (!streamAbort.signal.aborted) {
+			streamAbort.abort(error);
+		}
+		resolve(error);
+	};
+
+	if (signal.aborted) {
+		onAbort();
+		return { promise, cleanup: () => {} };
+	}
+
+	signal.addEventListener("abort", onAbort, { once: true });
+	return { promise, cleanup: () => signal.removeEventListener("abort", onAbort) };
+}
+
 function quoteForCompatShell(command: string): string {
 	if (command.length === 0) {
 		return "''";
@@ -94,19 +130,37 @@ export async function executeSSH(
 		maxColumns: resolveOutputMaxColumns(settings),
 	});
 
-	const streams = [child.stdout.pipeTo(sink.createInput())];
+	const streamAbort = new AbortController();
+	const abortWaiter = createAbortWaiter(options?.signal, streamAbort);
+	const streamOptions = { signal: streamAbort.signal };
+	const streams = [child.stdout.pipeTo(sink.createInput(), streamOptions)];
 	if (child.stderr) {
-		streams.push(child.stderr.pipeTo(sink.createInput()));
+		streams.push(child.stderr.pipeTo(sink.createInput(), streamOptions));
 	}
-	await Promise.allSettled(streams).catch(() => {});
+	const streamsSettled = Promise.allSettled(streams).then(() => {});
 
 	try {
+		const exitEvent = child.exited.then(sshExitEvent, sshErrorEvent);
+		const abortEvent = abortWaiter.promise?.then(sshErrorEvent);
+		const event = await (abortEvent ? Promise.race([exitEvent, abortEvent]) : exitEvent);
+		if (event.kind === "error") {
+			throw event.error;
+		}
+
+		const streamEvent = await (abortEvent ? Promise.race([streamsSettled, abortEvent]) : streamsSettled);
+		if (streamEvent?.kind === "error") {
+			throw streamEvent.error;
+		}
 		return {
-			exitCode: await child.exited,
+			exitCode: event.exitCode,
 			cancelled: false,
 			...(await sink.dump()),
 		};
 	} catch (err) {
+		if (!streamAbort.signal.aborted) {
+			streamAbort.abort(err);
+		}
+		void streamsSettled;
 		if (err instanceof ptree.Exception) {
 			if (err instanceof ptree.TimeoutError) {
 				return {
@@ -129,5 +183,7 @@ export async function executeSSH(
 			};
 		}
 		throw err;
+	} finally {
+		abortWaiter.cleanup();
 	}
 }