clankie 0.2.2 → 0.2.4

package/src/agent.ts

@@ -1,118 +0,0 @@
-/**
- * clankie agent session wrapper
- *
- * Creates an AgentSession using pi's SDK with full DefaultResourceLoader
- * discovery — skills, extensions, prompt templates, context files all
- * load from the standard pi directories (~/.pi/agent/, .pi/, etc.).
- *
- * Model is resolved from ~/.clankie/clankie.json → agent.model.primary (provider/model format).
- * If not set, falls back to pi's default resolution (settings → first available).
- */
-
-import {
-	AuthStorage,
-	type CreateAgentSessionResult,
-	createAgentSession,
-	DefaultResourceLoader,
-	type ExtensionFactory,
-	ModelRegistry,
-	SessionManager,
-} from "@mariozechner/pi-coding-agent";
-import { getAgentDir, getAuthPath, getWorkspace, loadConfig } from "./config.ts";
-import { createWorkspaceJailExtension } from "./extensions/workspace-jail.ts";
-
-export interface SessionOptions {
-	/**
-	 * Working directory for the agent.
-	 * Defaults to config.workspace, then process.cwd().
-	 */
-	cwd?: string;
-
-	/**
-	 * If true, session is NOT persisted to disk (ephemeral in-memory session).
-	 * Default: false — creates a new persistent session under ~/.pi/agent/sessions/.
-	 */
-	ephemeral?: boolean;
-
-	/**
-	 * If true, continue the most recent session instead of starting a new one.
-	 */
-	continueRecent?: boolean;
-
-	/**
-	 * Path to a specific session file to open.
-	 */
-	sessionFile?: string;
-}
-
-/**
- * Create a pi agent session with the app's configuration.
- *
- * Uses pi's DefaultResourceLoader so the entire pi extension ecosystem
- * (~/.pi/agent/extensions/, ~/.agents/skills/, AGENTS.md, etc.) is
- * automatically available.
- */
-export async function createSession(options: SessionOptions = {}): Promise<CreateAgentSessionResult> {
-	const config = loadConfig();
-	const agentDir = getAgentDir(config);
-	const cwd = options.cwd ?? getWorkspace(config);
-
-	// Auth stored in ~/.clankie/auth.json (separate from pi's ~/.pi/agent/auth.json)
-	const authStorage = AuthStorage.create(getAuthPath());
-	const modelRegistry = new ModelRegistry(authStorage);
-
-	// Build extension factories (workspace jail if enabled)
-	const extensionFactories: ExtensionFactory[] = [];
-	const restrictToWorkspace = config.agent?.restrictToWorkspace ?? true; // default: enabled
-	if (restrictToWorkspace) {
-		const allowedPaths = config.agent?.allowedPaths ?? [];
-		extensionFactories.push(createWorkspaceJailExtension(cwd, allowedPaths));
-	}
-
-	// DefaultResourceLoader with standard pi discovery
-	const loader = new DefaultResourceLoader({
-		cwd,
-		agentDir,
-		extensionFactories,
-	});
-	await loader.reload();
-
-	// Session management
-	let sessionManager: SessionManager;
-	if (options.ephemeral) {
-		sessionManager = SessionManager.inMemory();
-	} else if (options.sessionFile) {
-		sessionManager = SessionManager.open(options.sessionFile);
-	} else if (options.continueRecent) {
-		sessionManager = SessionManager.continueRecent(cwd);
-	} else {
-		sessionManager = SessionManager.create(cwd);
-	}
-
-	// Resolve model from config → pi auto-detection
-	const modelSpec = config.agent?.model?.primary;
-	let model: ReturnType<typeof modelRegistry.find> | undefined;
-	if (modelSpec) {
-		const slash = modelSpec.indexOf("/");
-		if (slash !== -1) {
-			const provider = modelSpec.substring(0, slash);
-			const modelId = modelSpec.substring(slash + 1);
-			model = modelRegistry.find(provider, modelId);
-			if (!model) {
-				console.warn(`Warning: model "${modelSpec}" from config not found in registry, falling back to auto-detection`);
-			}
-		} else {
-			console.warn(`Warning: model should be "provider/model" format (got "${modelSpec}")`);
-		}
-	}
-
-	return createAgentSession({
-		cwd,
-		agentDir,
-		authStorage,
-		modelRegistry,
-		resourceLoader: loader,
-		sessionManager,
-		model,
-	});
-}

package/src/channels/channel.ts

@@ -1,57 +0,0 @@
-/**
- * Channel abstraction — a messaging surface that can receive and send messages.
- *
- * Each channel (Slack, etc.) implements this interface.
- * The daemon routes inbound messages to the agent and delivers responses back.
- */
-
-export interface Attachment {
-	/** Base64-encoded file content */
-	data: string;
-	/** MIME type (e.g. "image/jpeg", "application/pdf") */
-	mimeType: string;
-	/** Original file name, if available */
-	fileName?: string;
-}
-
-export interface InboundMessage {
-	/** Unique ID for this message (channel-specific) */
-	id: string;
-	/** Channel type (e.g. "slack") */
-	channel: string;
-	/** Sender identifier (channel-specific user ID) */
-	senderId: string;
-	/** Sender display name (if available) */
-	senderName?: string;
-	/** Chat/conversation identifier (for per-chat sessions) */
-	chatId: string;
-	/** Thread/topic ID (e.g., Slack thread) */
-	threadId?: string;
-	/** Message text */
-	text: string;
-	/** File attachments (images, documents, audio, etc.) */
-	attachments?: Attachment[];
-	/** Unix timestamp (ms) */
-	timestamp: number;
-}
-
-export type MessageHandler = (message: InboundMessage) => Promise<void>;
-
-export interface SendOptions {
-	/** Thread/topic ID for sending to a specific thread */
-	threadId?: string;
-}
-
-export interface Channel {
-	/** Channel type identifier */
-	readonly name: string;
-
-	/** Start receiving messages. Calls handler for each inbound message. */
-	start(handler: MessageHandler): Promise<void>;
-
-	/** Send a text message to a chat */
-	send(chatId: string, text: string, options?: SendOptions): Promise<void>;
-
-	/** Gracefully stop the channel */
-	stop(): Promise<void>;
-}

package/src/channels/slack.ts

@@ -1,376 +0,0 @@
-/**
- * Slack channel — uses Socket Mode (WebSocket-based, no public URL needed).
- *
- * Requires:
- * - Slack app with Socket Mode enabled
- * - App token (xapp-...) for Socket Mode connection
- * - Bot token (xoxb-...) for API calls
- * - Bot scopes: app_mentions:read, chat:write, files:read, im:history, mpim:history,
- *   channels:history, channels:read, groups:history, groups:read
- * - Event subscriptions: app_mention, message.channels, message.groups, message.im, message.mpim
- *
- * Responds to:
- * - @mentions in channels and private channels (starts a conversation thread)
- * - Messages in threads where bot was @mentioned (continues conversation)
- * - Direct messages (1:1 and multi-party DMs)
- *
- * Features:
- * - File attachments (downloads from Slack, converts to base64)
- * - Thread persistence (survives daemon restarts, 7-day TTL)
- * - Channel allowlisting (optional)
- * - User allowlisting (required)
- * - Link unfurling disabled (keeps responses clean)
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { SocketModeClient } from "@slack/socket-mode";
-import { WebClient } from "@slack/web-api";
-import type { Attachment, Channel, InboundMessage, MessageHandler, SendOptions } from "./channel.ts";
-
-const SLACK_MAX_LENGTH = 4000; // Slack's actual limit is ~40k, but chunk conservatively
-const ACTIVE_THREADS_FILE = join(homedir(), ".clankie", "slack-active-threads.json");
-const THREAD_TTL_DAYS = 7; // Threads older than this are cleaned up
-
-export interface SlackChannelOptions {
-	/** App token from Slack app settings (xapp-...) */
-	appToken: string;
-	/** Bot token from Slack app settings (xoxb-...) */
-	botToken: string;
-	/** Allowed Slack user IDs. Empty = deny all. */
-	allowedUsers: string[];
-	/** Allowed Slack channel IDs. Empty = allow all. */
-	allowedChannelIds?: string[];
-}
-
-export class SlackChannel implements Channel {
-	readonly name = "slack";
-	private options: SlackChannelOptions;
-	private socketClient: SocketModeClient;
-	private webClient: WebClient;
-	private allowedUsers: Set<string>;
-	private allowedChannelIds: Set<string> | null;
-	private handler: MessageHandler | undefined;
-	private botUserId: string | null = null;
-	/** Threads where bot has been @mentioned - Map<threadId, timestamp> for TTL cleanup */
-	private activeThreads: Map<string, number> = new Map();
-
-	constructor(options: SlackChannelOptions) {
-		this.options = options;
-		this.socketClient = new SocketModeClient({
-			appToken: options.appToken,
-			// biome-ignore lint/suspicious/noExplicitAny: Slack SDK logLevel type is not exported
-			logLevel: "ERROR" as any, // Suppress noisy internal logging
-		});
-		this.webClient = new WebClient(options.botToken);
-		this.allowedUsers = new Set(options.allowedUsers);
-		// null = allow all channels; Set = filter by channel ID
-		this.allowedChannelIds = options.allowedChannelIds?.length ? new Set(options.allowedChannelIds) : null;
-	}
-
-	async start(handler: MessageHandler): Promise<void> {
-		this.handler = handler;
-
-		// Load persisted active threads
-		this.loadActiveThreads();
-
-		// Get bot user ID
-		const auth = await this.webClient.auth.test();
-		this.botUserId = auth.user_id as string;
-
-		this.setupEventHandlers();
-		await this.socketClient.start();
-
-		console.log(`[slack] Connected as ${auth.user} (${this.botUserId})`);
-	}
-
-	async send(chatId: string, text: string, options?: SendOptions): Promise<void> {
-		if (text.length <= SLACK_MAX_LENGTH) {
-			await this.webClient.chat.postMessage({
-				channel: chatId,
-				text,
-				thread_ts: options?.threadId,
-				unfurl_links: false,
-				unfurl_media: false,
-			});
-			return;
-		}
-
-		// Split long messages
-		const chunks = this.splitMessage(text, SLACK_MAX_LENGTH);
-		for (const chunk of chunks) {
-			await this.webClient.chat.postMessage({
-				channel: chatId,
-				text: chunk,
-				thread_ts: options?.threadId,
-				unfurl_links: false,
-				unfurl_media: false,
-			});
-		}
-	}
-
-	async stop(): Promise<void> {
-		await this.socketClient.disconnect();
-		console.log("[slack] Disconnected");
-	}
-
-	// ─── Private helpers ──────────────────────────────────────────────────
-
-	/** Check if a channel is allowed (null allowedChannelIds = allow all) */
-	private isChannelAllowed(channelId: string): boolean {
-		return this.allowedChannelIds === null || this.allowedChannelIds.has(channelId);
-	}
-
-	/** Load active threads from disk (with TTL cleanup) */
-	private loadActiveThreads(): void {
-		if (!existsSync(ACTIVE_THREADS_FILE)) return;
-
-		try {
-			const raw = readFileSync(ACTIVE_THREADS_FILE, "utf-8");
-			const data = JSON.parse(raw) as Record<string, number>;
-			const now = Date.now();
-			const ttlMs = THREAD_TTL_DAYS * 24 * 60 * 60 * 1000;
-
-			let loaded = 0;
-			let expired = 0;
-
-			for (const [threadId, timestamp] of Object.entries(data)) {
-				if (now - timestamp > ttlMs) {
-					expired++;
-					continue;
-				}
-				this.activeThreads.set(threadId, timestamp);
-				loaded++;
-			}
-
-			if (loaded > 0) {
-				console.log(`[slack] Loaded ${loaded} active thread(s) from disk${expired > 0 ? ` (${expired} expired)` : ""}`);
-			}
-		} catch (err) {
-			console.warn(`[slack] Failed to load active threads: ${err instanceof Error ? err.message : String(err)}`);
-		}
-	}
-
-	/** Save active threads to disk */
-	private saveActiveThreads(): void {
-		try {
-			const dir = join(homedir(), ".clankie");
-			if (!existsSync(dir)) {
-				mkdirSync(dir, { recursive: true, mode: 0o700 });
-			}
-
-			const data: Record<string, number> = {};
-			for (const [threadId, timestamp] of this.activeThreads.entries()) {
-				data[threadId] = timestamp;
-			}
-
-			writeFileSync(ACTIVE_THREADS_FILE, JSON.stringify(data, null, 2), "utf-8");
-		} catch (err) {
-			console.warn(`[slack] Failed to save active threads: ${err instanceof Error ? err.message : String(err)}`);
-		}
-	}
-
-	private setupEventHandlers(): void {
-		// Handle @mentions in channels
-		this.socketClient.on("app_mention", async ({ event, ack }) => {
-			try {
-				await ack();
-
-				const e = event as {
-					text: string;
-					channel: string;
-					user: string;
-					ts: string;
-					thread_ts?: string;
-					files?: Array<{
-						id: string;
-						name?: string;
-						mimetype?: string;
-						url_private_download?: string;
-					}>;
-				};
-
-				// Check channel allowlist
-				if (!this.isChannelAllowed(e.channel)) {
-					console.log(`[slack] Ignoring mention in disallowed channel: ${e.channel}`);
-					return;
-				}
-
-				if (!this.allowedUsers.has(e.user)) {
-					console.log(`[slack] Ignoring mention from unauthorized user: ${e.user}`);
-					return;
-				}
-
-				// Track this thread as active for future conversation
-				const threadId = e.thread_ts || e.ts;
-				this.activeThreads.set(threadId, Date.now());
-				this.saveActiveThreads();
-				console.log(`[slack] Thread ${threadId} is now active (${this.activeThreads.size} total)`);
-
-				// Strip bot mention from text
-				const text = e.text.replace(/<@[A-Z0-9]+>/gi, "").trim();
-
-				const message: InboundMessage = {
-					id: e.ts,
-					channel: this.name,
-					senderId: e.user,
-					chatId: e.channel,
-					threadId: e.thread_ts,
-					text,
-					timestamp: parseFloat(e.ts) * 1000,
-				};
-
-				// Download attachments
-				if (e.files && e.files.length > 0) {
-					message.attachments = await this.downloadFiles(e.files);
-				}
-
-				await this.handler?.(message);
-			} catch (err) {
-				console.error("[slack] Error in app_mention handler:", err);
-			}
-		});
-
-		// Handle direct messages and thread replies
-		this.socketClient.on("message", async ({ event, ack }) => {
-			try {
-				await ack();
-
-				const e = event as {
-					text?: string;
-					channel: string;
-					user?: string;
-					ts: string;
-					channel_type?: string;
-					subtype?: string;
-					bot_id?: string;
-					thread_ts?: string;
-					files?: Array<{
-						id: string;
-						name?: string;
-						mimetype?: string;
-						url_private_download?: string;
-					}>;
-				};
-
-				// Skip bot messages, message edits, etc.
-				if (e.bot_id || !e.user || e.user === this.botUserId) return;
-				if (e.subtype !== undefined && e.subtype !== "file_share") return;
-				if (!e.text && (!e.files || e.files.length === 0)) return;
-
-				// Check channel allowlist
-				if (!this.isChannelAllowed(e.channel)) return;
-
-				const isDM = e.channel_type === "im";
-				const isMpim = e.channel_type === "mpim"; // Multi-party DM
-				const isBotMention = e.text?.includes(`<@${this.botUserId}>`);
-				const isInActiveThread = e.thread_ts && this.activeThreads.has(e.thread_ts);
-
-				// Skip channel/group @mentions (handled by app_mention event)
-				// Note: mpim (multi-party DMs) don't fire app_mention, so we must NOT skip those
-				if (!isDM && !isMpim && isBotMention) return;
-
-				// Only process: DMs, multi-party DMs, OR messages in active threads
-				if (!isDM && !isMpim && !isInActiveThread) return;
-
-				if (!this.allowedUsers.has(e.user)) {
-					console.log(`[slack] Ignoring message from unauthorized user: ${e.user}`);
-					return;
-				}
-
-				const message: InboundMessage = {
-					id: e.ts,
-					channel: this.name,
-					senderId: e.user,
-					chatId: e.channel,
-					threadId: e.thread_ts,
-					text: e.text || "",
-					timestamp: parseFloat(e.ts) * 1000,
-				};
-
-				// Download attachments
-				if (e.files && e.files.length > 0) {
-					message.attachments = await this.downloadFiles(e.files);
-				}
-
-				await this.handler?.(message);
-			} catch (err) {
-				console.error("[slack] Error in message handler:", err);
-			}
-		});
-	}
-
-	/**
-	 * Download files from Slack and convert to base64 attachments.
-	 */
-	private async downloadFiles(
-		files: Array<{
-			id: string;
-			name?: string;
-			mimetype?: string;
-			url_private_download?: string;
-		}>,
-	): Promise<Attachment[]> {
-		const attachments: Attachment[] = [];
-
-		for (const file of files) {
-			const url = file.url_private_download;
-			if (!url) {
-				console.warn(`[slack] File ${file.id} has no download URL, skipping`);
-				continue;
-			}
-
-			try {
-				const response = await fetch(url, {
-					headers: {
-						Authorization: `Bearer ${this.options.botToken}`,
-					},
-				});
-
-				if (!response.ok) {
-					console.warn(`[slack] Failed to download file ${file.id}: ${response.status} ${response.statusText}`);
-					continue;
-				}
-
-				const buffer = Buffer.from(await response.arrayBuffer());
-				attachments.push({
-					data: buffer.toString("base64"),
-					mimeType: file.mimetype || "application/octet-stream",
-					fileName: file.name || file.id,
-				});
-			} catch (err) {
-				console.error(`[slack] Error downloading file ${file.id}:`, err);
-			}
-		}
-
-		return attachments;
-	}
-
-	/**
-	 * Split a long message into chunks, preferring newline boundaries.
-	 */
-	private splitMessage(text: string, maxLen: number): string[] {
-		const chunks: string[] = [];
-		let remaining = text;
-
-		while (remaining.length > 0) {
-			if (remaining.length <= maxLen) {
-				chunks.push(remaining);
-				break;
-			}
-
-			// Find last newline within the limit
-			let splitAt = remaining.lastIndexOf("\n", maxLen);
-			if (splitAt <= 0) {
-				// No good newline — hard-split
-				splitAt = maxLen;
-			}
-
-			chunks.push(remaining.slice(0, splitAt));
-			remaining = remaining.slice(splitAt).replace(/^\n/, ""); // trim leading newline
-		}
-
-		return chunks;
-	}
-}