@gajae-code/coding-agent 0.7.1 → 0.7.3

package/src/notifications/chat-adapters.ts

@@ -0,0 +1,147 @@
+import type {
+	NotificationAdapterPayload,
+	NotificationEvent,
+	NotificationPresentationAdapter,
+	NotificationReplyRoute,
+} from "./engine";
+import { truncate } from "./helpers";
+
+type AdapterKind = "discord" | "slack";
+
+interface ChatAdapterOptions {
+	kind: AdapterKind;
+	channelId?: string;
+}
+
+interface InboundShape {
+	sessionId?: unknown;
+	actionId?: unknown;
+	answer?: unknown;
+	text?: unknown;
+	value?: unknown;
+}
+
+function text(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function publicLine(label: string, value: unknown): string | undefined {
+	const v = text(value);
+	return v ? `${label}: ${truncate(v, 280)}` : undefined;
+}
+
+function actionText(event: Extract<NotificationEvent, { type: "action_needed" }>, format: "discord" | "slack"): string {
+	if (event.kind === "idle") {
+		const summary = text(event.summary);
+		return summary ? `Agent idle\n${truncate(summary, 1200)}` : "Agent idle";
+	}
+	const question = truncate(text(event.question) ?? "Question", 1200);
+	const options = Array.isArray(event.options) ? event.options.map(option => String(option)) : [];
+	const lines = [`Question: ${question}`];
+	if (options.length > 0) {
+		lines.push(
+			...options.map((option, index) => {
+				const label = truncate(option, 180);
+				return format === "slack" ? `${index + 1}. ${label}` : `**${index + 1}.** ${label}`;
+			}),
+		);
+	} else {
+		lines.push("Reply with text.");
+	}
+	return lines.join("\n");
+}
+
+function frameText(event: Extract<NotificationEvent, { type: "frame" }>): string | undefined {
+	const frame = event.frame;
+	const kind = text(frame.type);
+	if (!kind) return undefined;
+	const lines = [`GJC ${kind.replace(/_/g, " ")}`];
+	for (const line of [
+		publicLine("title", frame.title),
+		publicLine("repo", frame.repo),
+		publicLine("branch", frame.branch),
+		publicLine("task", frame.task),
+		publicLine("goal", frame.goal),
+		publicLine("model", frame.model),
+	]) {
+		if (line) lines.push(line);
+	}
+	const body = text(frame.text) ?? text(frame.lastMessage) ?? text(frame.caption);
+	if (body) lines.push(truncate(body, 1800));
+	return lines.join("\n");
+}
+
+function routeFromInbound(input: unknown): NotificationReplyRoute | undefined {
+	const raw = input as InboundShape;
+	if (!raw || typeof raw !== "object") return undefined;
+	const sessionId = text(raw.sessionId);
+	const actionId = text(raw.actionId);
+	if (!sessionId || !actionId) return undefined;
+	const answer = raw.answer ?? raw.value ?? raw.text;
+	if (typeof answer !== "string" && typeof answer !== "number" && typeof answer !== "object") return undefined;
+	return { sessionId, actionId, answer: answer as NotificationReplyRoute["answer"] };
+}
+
+class DiscordNotificationAdapter implements NotificationPresentationAdapter {
+	readonly kind = "discord" as const;
+	constructor(private readonly opts: ChatAdapterOptions) {}
+
+	render(event: NotificationEvent): NotificationAdapterPayload[] {
+		if (event.type === "action_resolved") return [];
+		const content = event.type === "action_needed" ? actionText(event, "discord") : frameText(event);
+		if (!content) return [];
+		const payload: Record<string, unknown> = {
+			content,
+			allowed_mentions: { parse: [] },
+		};
+		if (this.opts.channelId) payload.channel_id = this.opts.channelId;
+		return [
+			{
+				adapter: this.kind,
+				channelKey: this.opts.channelId,
+				body: payload,
+				route: event.type === "action_needed" ? { sessionId: event.sessionId, actionId: event.id } : undefined,
+			},
+		];
+	}
+
+	mapInbound(input: unknown): NotificationReplyRoute | undefined {
+		return routeFromInbound(input);
+	}
+}
+
+class SlackNotificationAdapter implements NotificationPresentationAdapter {
+	readonly kind = "slack" as const;
+	constructor(private readonly opts: ChatAdapterOptions) {}
+
+	render(event: NotificationEvent): NotificationAdapterPayload[] {
+		if (event.type === "action_resolved") return [];
+		const textValue = event.type === "action_needed" ? actionText(event, "slack") : frameText(event);
+		if (!textValue) return [];
+		const payload: Record<string, unknown> = {
+			text: textValue,
+			mrkdwn: true,
+		};
+		if (this.opts.channelId) payload.channel = this.opts.channelId;
+		return [
+			{
+				adapter: this.kind,
+				channelKey: this.opts.channelId,
+				body: payload,
+				route: event.type === "action_needed" ? { sessionId: event.sessionId, actionId: event.id } : undefined,
+			},
+		];
+	}
+
+	mapInbound(input: unknown): NotificationReplyRoute | undefined {
+		return routeFromInbound(input);
+	}
+}
+
+export function createDiscordAdapter(opts: Omit<ChatAdapterOptions, "kind"> = {}): NotificationPresentationAdapter {
+	return new DiscordNotificationAdapter({ ...opts, kind: "discord" });
+}
+
+export function createSlackAdapter(opts: Omit<ChatAdapterOptions, "kind"> = {}): NotificationPresentationAdapter {
+	return new SlackNotificationAdapter({ ...opts, kind: "slack" });
+}

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/index.ts

@@ -24,11 +24,13 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
+import type { ImageContent, TextContent } from "@gajae-code/ai";
 import { NotificationServer } from "@gajae-code/natives";
 import { logger } from "@gajae-code/utils";
 import { Settings } from "../config/settings";
 import type { ExtensionCommandContext, ExtensionContext, ExtensionFactory } from "../extensibility/extensions";
 import { registerAskAnswerSource } from "../tools/ask-answer-registry";
+import { registerTelegramFileSink } from "./attachment-registry";
 import {
 	getNotificationConfig,
 	isGloballyConfigured,
@@ -136,6 +138,8 @@ interface SessionRuntime {
 	pendingInteractive: Map<string, PendingInteractiveAsk>;
 	/** Deregisters this session's ask answer source. */
 	disposeAnswerSource: () => void;
+	/** Deregisters this session's Telegram file sink. */
+	disposeFileSink: () => void;
 	redact: boolean;
 	sessionTag: string;
 	/** Whether the agent loop is currently running (drives the typing indicator). */
@@ -157,6 +161,16 @@ interface ResolvedSettings {
 
 const defaultConfig: NotificationConfig = {
 	enabled: false,
+	botToken: undefined,
+	chatId: undefined,
+	discord: {
+		botToken: undefined,
+		channelId: undefined,
+	},
+	slack: {
+		botToken: undefined,
+		channelId: undefined,
+	},
 	redact: false,
 	verbosity: "lean",
 	idleTimeoutMs: 60_000,
@@ -228,6 +242,56 @@ function mapAnswerToGate(
 	return { selected: [] };
 }
 
+/** Register the interactive `ask` answer source for a session (the ask tool
+ * races the local UI against a remote reply). Returns the deregister disposer. */
+function registerInteractiveAnswerSource(
+	id: string,
+	server: NotificationServer,
+	pendingInteractive: Map<string, PendingInteractiveAsk>,
+	redact: boolean,
+	tag: string,
+): () => void {
+	return registerAskAnswerSource(id, {
+		awaitAnswer(question, options, signal) {
+			if (signal?.aborted) return Promise.resolve(undefined);
+			const askId = `ask:${crypto.randomUUID()}`;
+			try {
+				server.registerAsk(
+					JSON.stringify(
+						notificationActionPayload(
+							{ id: askId, kind: "ask", sessionId: id, question, options },
+							{ redact, sessionTag: tag },
+						),
+					),
+					true,
+				);
+			} catch (e) {
+				logger.warn(`notifications: registerAsk failed: ${String(e)}`);
+				return Promise.resolve(undefined);
+			}
+			return new Promise<string | undefined>(resolve => {
+				pendingInteractive.set(askId, { resolve, options });
+				signal?.addEventListener("abort", () => {
+					if (!pendingInteractive.delete(askId)) return;
+					// Local UI answered: mark the remote action resolved-locally.
+					try {
+						server.resolveLocal(askId, undefined);
+					} catch {}
+					resolve(undefined);
+				});
+			});
+		},
+	});
+}
+
+/** Extract the session id from a `<timestamp>_<uuid>.jsonl` session file path. */
+function sessionIdFromFile(file: string | undefined): string | undefined {
+	if (!file) return undefined;
+	const base = path.basename(file).replace(/\.jsonl$/, "");
+	const underscore = base.indexOf("_");
+	return underscore >= 0 ? base.slice(underscore + 1) : undefined;
+}
+
 export const createNotificationsExtension: ExtensionFactory = api => {
 	const runtimes = new Map<string, SessionRuntime>();
 	const disabledSessions = new Set<string>();
@@ -239,6 +303,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		runtimes.delete(id);
 		try {
 			rt.disposeAnswerSource();
+			rt.disposeFileSink();
 		} catch {}
 		// Resolve any still-pending interactive asks so the ask tool is not left hanging.
 		for (const pending of rt.pendingInteractive.values()) pending.resolve(undefined);
@@ -271,6 +336,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		const pendingInteractive = new Map<string, PendingInteractiveAsk>();
 		const tag = sessionTag(id);
 		const redact = cfg.redact;
+		let runtime: SessionRuntime | undefined;
 
 		// The SDK can always answer now (interactive via the answer source, or the
 		// unattended gate), so the endpoint advertises a resolver.
@@ -317,23 +383,34 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		// thread (forwarded by the daemon over the WS, fail-closed at the daemon).
 		server.onInbound((err, inbound) => {
 			if (err || !inbound) return;
-			if (inbound.kind === "user_message" && inbound.text) {
+			if (inbound.kind === "user_message") {
 				// Inject as a user turn (steers/continues the agent; the resulting
 				// turn streams back via the turn_end handler even when not idle).
 				// Record the update id so it can be acked as "consumed" on the next
 				// turn_start, and steer (vs start a fresh turn) when already busy.
-				const rt = runtimes.get(id);
-				if (rt && typeof inbound.updateId === "number") rt.pendingInbound.add(inbound.updateId);
+				const text = inbound.text ?? "";
+				const images = inbound.images ?? [];
+				if (!text && images.length === 0) return;
+				if (runtime && typeof inbound.updateId === "number") runtime.pendingInbound.add(inbound.updateId);
+				const content: string | (TextContent | ImageContent)[] =
+					images.length > 0
+						? [
+								...(text ? [{ type: "text", text } as TextContent] : []),
+								...images.map(
+									img =>
+										({ type: "image", data: img.data, mimeType: img.mime ?? "image/jpeg" }) as ImageContent,
+								),
+							]
+						: text;
 				try {
-					api.sendUserMessage(inbound.text, rt?.busy ? { deliverAs: "steer" } : undefined);
+					api.sendUserMessage(content, runtime?.busy ? { deliverAs: "steer" } : undefined);
 				} catch (e) {
 					logger.warn(`notifications: sendUserMessage failed: ${String(e)}`);
 				}
 				return;
 			}
 			if (inbound.kind === "config_command") {
-				const rt = runtimes.get(id);
-				if (rt && typeof inbound.redact === "boolean") rt.redact = inbound.redact;
+				if (runtime && typeof inbound.redact === "boolean") runtime.redact = inbound.redact;
 			}
 		});
 
@@ -341,48 +418,37 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 			const endpoint = await server.start();
 
 			// Interactive answer source: the ask tool races the local UI against this.
-			const disposeAnswerSource = registerAskAnswerSource(id, {
-				awaitAnswer(question, options, signal) {
-					if (signal?.aborted) return Promise.resolve(undefined);
-					const askId = `ask:${crypto.randomUUID()}`;
-					try {
-						server.registerAsk(
-							JSON.stringify(
-								notificationActionPayload(
-									{ id: askId, kind: "ask", sessionId: id, question, options },
-									{ redact, sessionTag: tag },
-								),
-							),
-							true,
-						);
-					} catch (e) {
-						logger.warn(`notifications: registerAsk failed: ${String(e)}`);
-						return Promise.resolve(undefined);
-					}
-					return new Promise<string | undefined>(resolve => {
-						pendingInteractive.set(askId, { resolve, options });
-						signal?.addEventListener("abort", () => {
-							if (!pendingInteractive.delete(askId)) return;
-							// Local UI answered: mark the remote action resolved-locally.
-							try {
-								server.resolveLocal(askId, undefined);
-							} catch {}
-							resolve(undefined);
-						});
-					});
-				},
+			const disposeAnswerSource = registerInteractiveAnswerSource(id, server, pendingInteractive, redact, tag);
+			const disposeFileSink = registerTelegramFileSink(id, async file => {
+				try {
+					const data = await fs.promises.readFile(file.path);
+					server.pushFrame(
+						JSON.stringify({
+							type: "file_attachment",
+							sessionId: id,
+							name: path.basename(file.path),
+							data: data.toString("base64"),
+							caption: file.caption,
+						}),
+					);
+					return { ok: true };
+				} catch (e) {
+					return { ok: false, error: e instanceof Error ? e.message : String(e) };
+				}
 			});
 
-			runtimes.set(id, {
+			runtime = {
 				server,
 				idleSeq: 0,
 				pendingInteractive,
 				disposeAnswerSource,
+				disposeFileSink,
 				redact,
 				sessionTag: tag,
 				busy: false,
 				pendingInbound: new Set<number>(),
-			});
+			};
+			runtimes.set(id, runtime);
 			logger.info(`notifications: serving session ${id} at ${endpoint.url} (unattended=${unattended})`);
 
 			if (settingsAvailable && settings && isGloballyConfigured(cfg)) {
@@ -512,6 +578,82 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		await startSession(ctx);
 	});
 
+	// A session id change within the same process needs reason-aware handling.
+	// `/new` and fork CONTINUE the same terminal thread (e.g. plan "approve and
+	// execute" clears into a fresh session), so re-key the existing runtime
+	// old→new WITHOUT recreating the NotificationServer: the server, its endpoint
+	// discovery file, and the daemon's forum topic are all keyed by the original
+	// session id and the daemon routes by socket, so the existing topic is reused
+	// and the next identity frame renames it in place instead of spawning a new
+	// thread. `resume`, by contrast, loads a DIFFERENT, already-persisted session
+	// that owns its own topic — tear the previous runtime down and start fresh
+	// under the resumed id so the daemon attaches to (or recreates) that
+	// session's own discovery + topic rather than hijacking this terminal's.
+	api.on("session_switch", async (event, ctx) => {
+		const newId = sessionId(ctx);
+		const prevId = sessionIdFromFile(event.previousSessionFile);
+		if (!prevId || prevId === newId) return;
+
+		if (event.reason === "resume") {
+			stopSession(prevId);
+			await startSession(ctx);
+			return;
+		}
+
+		// `/new` / fork: re-key in place and rename the existing topic.
+		if (disabledSessions.delete(prevId)) disabledSessions.add(newId);
+		const rt = runtimes.get(prevId);
+		if (!rt || runtimes.has(newId)) return;
+		runtimes.delete(prevId);
+		runtimes.set(newId, rt);
+		// Re-bind the interactive ask answer source: the ask tool resolves the
+		// source by the current session id, which just changed.
+		try {
+			rt.disposeAnswerSource();
+			rt.disposeFileSink();
+		} catch {}
+		rt.disposeAnswerSource = registerInteractiveAnswerSource(
+			newId,
+			rt.server,
+			rt.pendingInteractive,
+			rt.redact,
+			rt.sessionTag,
+		);
+		rt.disposeFileSink = registerTelegramFileSink(newId, async file => {
+			try {
+				const data = await fs.promises.readFile(file.path);
+				rt.server.pushFrame(
+					JSON.stringify({
+						type: "file_attachment",
+						sessionId: newId,
+						name: path.basename(file.path),
+						data: data.toString("base64"),
+						caption: file.caption,
+					}),
+				);
+				return { ok: true };
+			} catch (e) {
+				return { ok: false, error: e instanceof Error ? e.message : String(e) };
+			}
+		});
+		// Rename the existing topic now when the new session already has a name; a
+		// fresh unnamed session is renamed on its next agent_end re-assert, which
+		// avoids a transient rename to bare "repo/branch".
+		if (ctx.sessionManager.getSessionName()) {
+			try {
+				rt.server.pushFrame(
+					JSON.stringify({
+						type: "identity_header",
+						sessionId: newId,
+						...buildIdentity(ctx.cwd, ctx.sessionManager.getSessionName()),
+					}),
+				);
+			} catch (e) {
+				logger.warn(`notifications: identity_header (switch) failed: ${String(e)}`);
+			}
+		}
+	});
+
 	// Drive the live typing indicator: mark busy when the agent loop starts so
 	// the daemon shows "typing…" in the thread while the agent is thinking,
 	// before any turn output exists. Cleared on `agent_end` below.