@sayknow-cli/coding-agent 0.3.0 → 0.3.2

package/src/notifications/config.ts

@@ -5,6 +5,14 @@ export interface NotificationConfig {
 	enabled: boolean;
 	botToken?: string;
 	chatId?: string;
+	discord: {
+		botToken?: string;
+		channelId?: string;
+	};
+	slack: {
+		botToken?: string;
+		channelId?: string;
+	};
 	redact: boolean;
 	verbosity: "lean" | "verbose";
 	idleTimeoutMs: number;
@@ -16,15 +24,28 @@ export function getNotificationConfig(settings: Settings): NotificationConfig {
 		enabled: settings.get("notifications.enabled"),
 		botToken: settings.get("notifications.telegram.botToken"),
 		chatId: settings.get("notifications.telegram.chatId"),
+		discord: {
+			botToken: settings.get("notifications.discord.botToken"),
+			channelId: settings.get("notifications.discord.channelId"),
+		},
+		slack: {
+			botToken: settings.get("notifications.slack.botToken"),
+			channelId: settings.get("notifications.slack.channelId"),
+		},
 		redact: settings.get("notifications.redact"),
 		verbosity: settings.get("notifications.verbosity") === "verbose" ? "verbose" : "lean",
 		idleTimeoutMs: settings.get("notifications.daemon.idleTimeoutMs"),
 	};
 }
 
-/** Is global config sufficient for auto-on (enabled + botToken + chatId all present)? */
+/** Is global config sufficient for auto-on (enabled + at least one configured adapter)? */
 export function isGloballyConfigured(cfg: NotificationConfig): boolean {
-	return cfg.enabled && Boolean(cfg.botToken) && Boolean(cfg.chatId);
+	return (
+		cfg.enabled &&
+		((Boolean(cfg.botToken) && Boolean(cfg.chatId)) ||
+			(Boolean(cfg.discord.botToken) && Boolean(cfg.discord.channelId)) ||
+			(Boolean(cfg.slack.botToken) && Boolean(cfg.slack.channelId)))
+	);
 }
 
 /** Resolve whether the notifications extension should be registered at SDK startup. */

package/src/notifications/engine.ts

@@ -0,0 +1,100 @@
+import { buildRedactedAction, type RedactableAction } from "./config";
+
+export type NotificationEvent =
+	| ({ type: "action_needed" } & RedactableAction)
+	| { type: "action_resolved"; id: string; sessionId: string; resolvedBy?: string }
+	| { type: "frame"; sessionId: string; frame: Record<string, unknown> };
+
+export interface NotificationReplyRoute {
+	sessionId: string;
+	actionId: string;
+	answer: number | string | { selected?: Array<number | string>; custom?: string };
+}
+
+export interface NotificationAdapterPayload {
+	adapter: string;
+	channelKey?: string;
+	body: unknown;
+	route?: Omit<NotificationReplyRoute, "answer">;
+}
+
+export interface NotificationPresentationAdapter {
+	readonly kind: "telegram" | "discord" | "slack";
+	render(event: NotificationEvent): NotificationAdapterPayload[];
+	mapInbound(input: unknown): NotificationReplyRoute | undefined;
+}
+
+export interface EngineSessionSink {
+	sendReply(route: NotificationReplyRoute): void;
+}
+
+export interface NotificationEngineOptions {
+	redact: boolean;
+	sessionTag: (sessionId: string) => string;
+}
+
+/**
+ * Shared presentation engine for managed notification clients.
+ *
+ * It owns fanout, redaction boundaries, pending-action routing, and reply
+ * delivery into session sinks. Transport adapters stay pure: render an internal
+ * event into a public-safe payload and map an inbound transport interaction
+ * back into a session/action answer.
+ */
+export class NotificationPresentationEngine {
+	readonly adapters: readonly NotificationPresentationAdapter[];
+	private readonly sessions = new Map<string, EngineSessionSink>();
+	private readonly pending = new Map<string, { sessionId: string; actionId: string }>();
+
+	constructor(
+		adapters: readonly NotificationPresentationAdapter[],
+		private readonly opts: NotificationEngineOptions,
+	) {
+		this.adapters = adapters;
+	}
+
+	connectSession(sessionId: string, sink: EngineSessionSink): void {
+		this.sessions.set(sessionId, sink);
+	}
+
+	dropSession(sessionId: string): void {
+		this.sessions.delete(sessionId);
+		for (const [key, route] of this.pending) {
+			if (route.sessionId === sessionId) this.pending.delete(key);
+		}
+	}
+
+	fanout(event: NotificationEvent): NotificationAdapterPayload[] {
+		const safeEvent = this.redactEvent(event);
+		if (safeEvent.type === "action_needed" && safeEvent.kind === "ask") {
+			this.pending.set(safeEvent.id, { sessionId: safeEvent.sessionId, actionId: safeEvent.id });
+		}
+		if (safeEvent.type === "action_resolved") {
+			this.pending.delete(safeEvent.id);
+		}
+		return this.adapters.flatMap(adapter => adapter.render(safeEvent));
+	}
+
+	routeInbound(adapterKind: NotificationPresentationAdapter["kind"], input: unknown): boolean {
+		const adapter = this.adapters.find(candidate => candidate.kind === adapterKind);
+		const route = adapter?.mapInbound(input);
+		if (!route) return false;
+		const pending = this.pending.get(route.actionId);
+		if (!pending || pending.sessionId !== route.sessionId) return false;
+		const sink = this.sessions.get(route.sessionId);
+		if (!sink) return false;
+		sink.sendReply(route);
+		return true;
+	}
+
+	private redactEvent(event: NotificationEvent): NotificationEvent {
+		if (event.type !== "action_needed") return event;
+		return {
+			...buildRedactedAction(event, {
+				redact: this.opts.redact,
+				sessionTag: this.opts.sessionTag(event.sessionId),
+			}),
+			type: "action_needed",
+		};
+	}
+}

package/src/notifications/html-format.ts

@@ -349,16 +349,54 @@ export function buttonLabel(label: string, index: number): string {
 	return `${index + 1}. ${stripped}`;
 }
 
+/** Numbered, escaped option list for the Telegram message body. */
+export function numberedOptionList(labels: string[]): string {
+	return labels.map((label, i) => `${i + 1}. ${escapeHtml(label.replace(/^\s*\d+[.)]\s+/, ""))}`).join("\n");
+}
+
+/** Compact numeric button label; full option text belongs in the message body. */
+export function choiceButtonLabel(index: number): string {
+	return String(index + 1);
+}
+
 export interface InlineButton {
 	text: string;
 	callback_data: string;
 }
 
+const COMPACT_BUTTONS_PER_ROW = 5;
+
 /** A prefixed button label is "long" when it is wide or contains a newline. */
 function isLongLabel(label: string): boolean {
 	return label.length > 18 || /[\r\n]/.test(label);
 }
 
+/**
+ * Lay out option callbacks as compact numeric buttons. Telegram mobile clients
+ * ellipsize long inline-keyboard labels and tall keyboards can be obscured by
+ * the composer, so the full choice text is rendered in the message body while
+ * the keyboard keeps only stable one-based tap targets.
+ */
+export function buildCompactChoiceGrid(
+	labels: string[],
+	callbackForIndex: (index: number) => string,
+): InlineButton[][] {
+	const rows: InlineButton[][] = [];
+	let run: InlineButton[] = [];
+	const flush = () => {
+		if (run.length) {
+			rows.push(run);
+			run = [];
+		}
+	};
+	labels.forEach((_label, i) => {
+		run.push({ text: choiceButtonLabel(i), callback_data: callbackForIndex(i) });
+		if (run.length === COMPACT_BUTTONS_PER_ROW) flush();
+	});
+	flush();
+	return rows;
+}
+
 /**
  * Lay out option labels as a numbered button grid. Long buttons take a
  * full-width row; runs of short buttons are packed into rows of up to 3. The