myaiforone 1.0.0

package/src/router.ts

@@ -0,0 +1,230 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import type { InboundMessage } from "./channels/types.js";
+import type { AgentConfig, RouteConfig, AppConfig } from "./config.js";
+import { log } from "./logger.js";
+
+export interface ResolvedRoute {
+  agentId: string;
+  agentConfig: AgentConfig;
+  route: RouteConfig;
+}
+
+// ─── Pairing store ───────────────────────────────────────────────────
+
+const pairedSenders = new Set<string>();
+let pairingStoreLoaded = false;
+let pairingStorePath = "";
+
+function loadPairingStore(baseDir: string): void {
+  if (pairingStoreLoaded) return;
+  pairingStorePath = join(baseDir, "data", "paired-senders.json");
+  try {
+    if (existsSync(pairingStorePath)) {
+      const data = JSON.parse(readFileSync(pairingStorePath, "utf-8")) as string[];
+      for (const s of data) pairedSenders.add(s);
+    }
+  } catch { /* fresh start */ }
+  pairingStoreLoaded = true;
+}
+
+function savePairingStore(): void {
+  try {
+    mkdirSync(join(pairingStorePath, ".."), { recursive: true });
+    writeFileSync(pairingStorePath, JSON.stringify([...pairedSenders], null, 2));
+  } catch (err) {
+    log.warn(`Failed to save pairing store: ${err}`);
+  }
+}
+
+// ─── Sticky routing ──────────────────────────────────────────────────
+
+interface StickyEntry {
+  agentId: string;
+  timestamp: number;
+}
+
+// Key: "channel:chatId:sender" → last agent they talked to
+const stickyMap = new Map<string, StickyEntry>();
+
+const DEFAULT_STICKY_TIMEOUT_MS = 300_000; // 5 minutes
+
+// Sticky routing modes:
+//   "none"   — always require @mention (default)
+//   "sticky" — mention once, then all messages route for stickyTimeoutMs
+//   "prefix" — like sticky, but follow-up messages must start with a trigger character (e.g., ! or @)
+type StickyMode = "none" | "sticky" | "prefix";
+
+function getStickyMode(config: AppConfig, channel: string): { mode: StickyMode; prefix: string; timeoutMs: number } {
+  const channelCfg = config.channels[channel];
+  if (!channelCfg) return { mode: "none", prefix: "!", timeoutMs: DEFAULT_STICKY_TIMEOUT_MS };
+
+  const raw = (channelCfg.config as any).stickyRouting;
+  let mode: StickyMode = "prefix"; // default: prefix mode
+  if (raw === "sticky") mode = "sticky";
+  else if (raw === "none") mode = "none";
+  else if (raw === "prefix") mode = "prefix";
+
+  const prefix = (channelCfg.config as any).stickyPrefix ?? "!";
+  const timeoutMs = (channelCfg.config as any).stickyTimeoutMs ?? DEFAULT_STICKY_TIMEOUT_MS;
+  return { mode, prefix, timeoutMs };
+}
+
+function getStickyAgent(
+  msg: InboundMessage,
+  config: AppConfig,
+): ResolvedRoute | null {
+  const { mode, prefix, timeoutMs } = getStickyMode(config, msg.channel);
+  if (mode === "none") return null;
+
+  const key = `${msg.channel}:${msg.chatId}:${msg.sender}`;
+  const entry = stickyMap.get(key);
+
+  if (!entry) return null;
+
+  // Check if expired
+  if (Date.now() - entry.timestamp > timeoutMs) {
+    stickyMap.delete(key);
+    return null;
+  }
+
+  // Prefix mode: message must start with the trigger character
+  if (mode === "prefix") {
+    const trimmed = msg.text.trim();
+    if (!trimmed.startsWith(prefix)) {
+      return null; // No prefix — don't route via sticky
+    }
+    // Strip the prefix from the message text for the agent
+    msg.text = trimmed.slice(prefix.length).trim();
+  }
+
+  // Verify the agent still exists
+  const agent = config.agents[entry.agentId];
+  if (!agent) {
+    stickyMap.delete(key);
+    return null;
+  }
+
+  // Find the matching route for this channel + chatId
+  const route = agent.routes.find(
+    r => r.channel === msg.channel && String(r.match.value) === msg.chatId
+  );
+  if (!route) return null;
+
+  // Permission check
+  if (!isAllowed(msg, route)) return null;
+
+  log.debug(`Sticky routing (${mode}): ${msg.sender} → ${entry.agentId} (${Math.round((Date.now() - entry.timestamp) / 1000)}s ago)`);
+  return { agentId: entry.agentId, agentConfig: agent, route };
+}
+
+function setStickyAgent(msg: InboundMessage, agentId: string): void {
+  const key = `${msg.channel}:${msg.chatId}:${msg.sender}`;
+  stickyMap.set(key, { agentId, timestamp: Date.now() });
+}
+
+// ─── Route resolver ──────────────────────────────────────────────────
+
+export function resolveRoute(
+  msg: InboundMessage,
+  config: AppConfig,
+  baseDir?: string,
+): ResolvedRoute | null {
+  // Feature 4: DM pairing gate
+  if (config.service.pairingCode && baseDir) {
+    loadPairingStore(baseDir);
+
+    const senderKey = `${msg.channel}:${msg.sender}`;
+    if (!pairedSenders.has(senderKey)) {
+      if (msg.text.trim() === config.service.pairingCode) {
+        pairedSenders.add(senderKey);
+        savePairingStore();
+        log.info(`Paired sender: ${senderKey}`);
+        return null;
+      }
+      log.debug(`Unpaired sender ${senderKey} — ignoring`);
+      return null;
+    }
+  }
+
+  // Try explicit mention routing first
+  for (const [agentId, agent] of Object.entries(config.agents)) {
+    for (const route of agent.routes) {
+      if (route.channel !== msg.channel) continue;
+
+      const matchValue = String(route.match.value);
+      if (msg.chatId !== matchValue) continue;
+
+      if (!isAllowed(msg, route)) {
+        log.debug(`Blocked: ${msg.sender} not in allowFrom for ${agentId}`);
+        return null;
+      }
+
+      if (route.permissions.requireMention) {
+        if (!hasMention(msg.text, agent)) {
+          continue;
+        }
+      }
+
+      // Explicit mention found — update sticky and return
+      setStickyAgent(msg, agentId);
+      return { agentId, agentConfig: agent, route };
+    }
+  }
+
+  // No explicit mention — try sticky routing
+  const sticky = getStickyAgent(msg, config);
+  if (sticky) {
+    // Refresh the timestamp on each sticky hit
+    setStickyAgent(msg, sticky.agentId);
+    return sticky;
+  }
+
+  // Fall back to default agent — only for the web channel
+  if (msg.channel === "web" && config.defaultAgent && config.agents[config.defaultAgent]) {
+    const agent = config.agents[config.defaultAgent];
+    const matchingRoute = agent.routes.find(r => r.channel === msg.channel);
+    if (matchingRoute) {
+      return {
+        agentId: config.defaultAgent,
+        agentConfig: agent,
+        route: matchingRoute,
+      };
+    }
+  }
+
+  log.debug(`No route for ${msg.channel}:${msg.chatId} from ${msg.senderName || msg.sender}`);
+  return null;
+}
+
+// Exported for pairing check in index.ts
+export function isPairingAttempt(msg: InboundMessage, config: AppConfig, baseDir: string): boolean {
+  if (!config.service.pairingCode) return false;
+  loadPairingStore(baseDir);
+  const senderKey = `${msg.channel}:${msg.sender}`;
+  if (pairedSenders.has(senderKey)) return false;
+  return msg.text.trim() === config.service.pairingCode;
+}
+
+export function pairSender(msg: InboundMessage, baseDir: string): void {
+  loadPairingStore(baseDir);
+  const senderKey = `${msg.channel}:${msg.sender}`;
+  pairedSenders.add(senderKey);
+  savePairingStore();
+  log.info(`Paired sender: ${senderKey}`);
+}
+
+function hasMention(text: string, agent: AgentConfig): boolean {
+  const lower = text.toLowerCase();
+  if (agent.mentionAliases?.length) {
+    return agent.mentionAliases.some((alias) => lower.includes(alias.toLowerCase()));
+  }
+  return lower.includes(agent.name.toLowerCase());
+}
+
+function isAllowed(msg: InboundMessage, route: RouteConfig): boolean {
+  const { allowFrom } = route.permissions;
+  if (!allowFrom || allowFrom.length === 0) return true;
+  if (allowFrom.includes("*")) return true;
+  return allowFrom.includes(msg.sender);
+}

package/src/test-message.ts

@@ -0,0 +1,72 @@
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "./config.js";
+import { configureLogger, log } from "./logger.js";
+import { executeAgent } from "./executor.js";
+import type { InboundMessage } from "./channels/types.js";
+import type { ResolvedRoute } from "./router.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const baseDir = resolve(__dirname, "..");
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  let agentId: string | null = null;
+  let text: string | null = null;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--agent" && args[i + 1]) {
+      agentId = args[++i];
+    } else if (args[i] === "--text" && args[i + 1]) {
+      text = args[++i];
+    }
+  }
+
+  if (!agentId || !text) {
+    console.log("Usage: npm run test-message -- --agent <agentId> --text <message>");
+    console.log('Example: npm run test-message -- --agent fic-show --text "List all episodes"');
+    process.exit(1);
+  }
+
+  const configPath = resolve(baseDir, "config.json");
+  const config = loadConfig(configPath);
+
+  configureLogger("debug");
+
+  const agentConfig = config.agents[agentId];
+  if (!agentConfig) {
+    console.error(`Agent "${agentId}" not found. Available: ${Object.keys(config.agents).join(", ")}`);
+    process.exit(1);
+  }
+
+  const msg: InboundMessage = {
+    id: "test-" + Date.now(),
+    channel: "test",
+    chatId: "test",
+    chatType: "dm",
+    sender: "test-user",
+    text,
+    timestamp: Date.now(),
+    isFromMe: false,
+    isGroup: false,
+    raw: {},
+  };
+
+  const route: ResolvedRoute = {
+    agentId,
+    agentConfig,
+    route: agentConfig.routes[0],
+  };
+
+  log.info(`Testing agent "${agentId}" with message: "${text}"`);
+  const response = await executeAgent(route, msg, baseDir);
+  console.log("\n--- Agent Response ---");
+  console.log(response);
+  console.log("--- End ---\n");
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/src/utils/imsg-db-reader.ts

@@ -0,0 +1,109 @@
+/**
+ * Direct iMessage database reader.
+ * Reads from ~/Library/Messages/chat.db to get message text from attributedBody
+ * when the text column is empty (macOS 15+ behavior).
+ */
+
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const DB_PATH = join(homedir(), "Library", "Messages", "chat.db");
+
+interface DBMessage {
+  rowid: number;
+  text: string;
+  chatId: number;
+  isFromMe: boolean;
+  sender: string;
+  createdAt: string;
+  guid: string;
+}
+
+/**
+ * Extract plain text from NSAttributedString binary blob (NSArchiver/typedstream format).
+ * The text is stored after a \x01\x2B marker followed by a length byte, then raw UTF-8 bytes.
+ */
+function extractTextFromAttributedBody(hexData: string): string {
+  try {
+    const buf = Buffer.from(hexData, "hex");
+
+    // Search for the \x01\x2B (NSArchiver string marker "+") pattern
+    for (let i = 0; i < buf.length - 2; i++) {
+      if (buf[i] === 0x01 && buf[i + 1] === 0x2b) {
+        const len = buf[i + 2];
+        if (len > 0 && i + 3 + len <= buf.length) {
+          const text = buf.toString("utf-8", i + 3, i + 3 + len);
+          // Sanity check: should contain at least some printable chars
+          if (/[\x20-\x7E]/.test(text)) {
+            return text.trim();
+          }
+        }
+      }
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Get recent messages from a specific chat, with attributedBody fallback.
+ */
+export function getRecentMessages(chatId: number, sinceRowId: number, limit: number = 20): DBMessage[] {
+  try {
+    const query = `
+      SELECT m.ROWID, m.text, m.is_from_me, m.handle_id,
+             datetime(m.date/1000000000 + 978307200, 'unixepoch', 'localtime') as created_at,
+             m.guid, hex(m.attributedBody) as attr_hex,
+             h.id as sender_id
+      FROM message m
+      JOIN chat_message_join cmj ON m.ROWID = cmj.message_id
+      LEFT JOIN handle h ON m.handle_id = h.ROWID
+      WHERE cmj.chat_id = ${chatId}
+        AND m.ROWID > ${sinceRowId}
+        AND m.associated_message_type = 0
+      ORDER BY m.date ASC
+      LIMIT ${limit};
+    `;
+
+    const result = execSync(`sqlite3 -json "${DB_PATH}" "${query.replace(/"/g, '\\"')}"`, {
+      timeout: 5000,
+      encoding: "utf-8",
+    });
+
+    const rows = JSON.parse(result || "[]");
+    return rows.map((row: any) => {
+      let text = row.text || "";
+      if (!text && row.attr_hex) {
+        text = extractTextFromAttributedBody(row.attr_hex);
+      }
+      return {
+        rowid: row.ROWID,
+        text,
+        chatId,
+        isFromMe: row.is_from_me === 1,
+        sender: row.sender_id || (row.is_from_me === 1 ? "me" : "unknown"),
+        createdAt: row.created_at,
+        guid: row.guid,
+      };
+    }).filter((m: DBMessage) => m.text.trim().length > 0);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get the latest ROWID for a chat (for polling).
+ */
+export function getLatestRowId(chatId: number): number {
+  try {
+    const result = execSync(
+      `sqlite3 "${DB_PATH}" "SELECT MAX(m.ROWID) FROM message m JOIN chat_message_join cmj ON m.ROWID = cmj.message_id WHERE cmj.chat_id = ${chatId};"`,
+      { timeout: 5000, encoding: "utf-8" }
+    );
+    return parseInt(result.trim()) || 0;
+  } catch {
+    return 0;
+  }
+}

package/src/utils/imsg-rpc.ts

@@ -0,0 +1,178 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { createInterface, type Interface } from "node:readline";
+import { log } from "../logger.js";
+
+interface PendingRequest {
+  resolve: (value: unknown) => void;
+  reject: (reason: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+interface JsonRpcNotification {
+  jsonrpc: "2.0";
+  method: string;
+  params: unknown;
+}
+
+export class ImsgRpcClient {
+  private proc: ChildProcess | null = null;
+  private rl: Interface | null = null;
+  private nextId = 1;
+  private pending = new Map<number, PendingRequest>();
+  private notificationHandler: ((notification: JsonRpcNotification) => void) | null = null;
+  private cliPath: string;
+  private stopping = false;
+  private restartTimer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(cliPath = "imsg") {
+    this.cliPath = cliPath;
+  }
+
+  async start(): Promise<void> {
+    // Verify imsg exists
+    try {
+      const probe = spawn(this.cliPath, ["rpc", "--help"], { stdio: "pipe" });
+      await new Promise<void>((resolve, reject) => {
+        probe.on("close", () => resolve());
+        probe.on("error", (err) => reject(err));
+      });
+    } catch {
+      const hint = process.platform === "darwin"
+        ? `Install with: brew install steipete/tap/imsg`
+        : `iMessage is only available on macOS`;
+      throw new Error(
+        `"${this.cliPath}" not found. ${hint}`
+      );
+    }
+
+    await this.startProcess();
+    log.info("imsg RPC client started");
+  }
+
+  private handleLine(line: string): void {
+    if (!line.trim()) return;
+
+    let parsed: Record<string, unknown>;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      log.warn(`imsg: unparseable line: ${line.slice(0, 200)}`);
+      return;
+    }
+
+    // Response to a request (has "id")
+    if ("id" in parsed && typeof parsed.id === "number") {
+      const req = this.pending.get(parsed.id);
+      if (req) {
+        clearTimeout(req.timer);
+        this.pending.delete(parsed.id);
+
+        if ("error" in parsed) {
+          req.reject(new Error(JSON.stringify(parsed.error)));
+        } else {
+          req.resolve(parsed.result);
+        }
+      }
+      return;
+    }
+
+    // Notification (has "method" but no "id")
+    if ("method" in parsed && !("id" in parsed)) {
+      this.notificationHandler?.(parsed as unknown as JsonRpcNotification);
+      return;
+    }
+
+    log.debug(`imsg: unhandled message: ${line.slice(0, 200)}`);
+  }
+
+  async request<T>(method: string, params?: object, timeoutMs = 10_000): Promise<T> {
+    if (!this.proc?.stdin?.writable) {
+      throw new Error("imsg RPC client not started");
+    }
+
+    const id = this.nextId++;
+    const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+
+    return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`imsg RPC timeout: ${method} (${timeoutMs}ms)`));
+      }, timeoutMs);
+
+      this.pending.set(id, {
+        resolve: resolve as (value: unknown) => void,
+        reject,
+        timer,
+      });
+
+      this.proc!.stdin!.write(payload + "\n");
+    });
+  }
+
+  onNotification(handler: (notification: JsonRpcNotification) => void): void {
+    this.notificationHandler = handler;
+  }
+
+  private async restart(): Promise<void> {
+    try {
+      this.rl?.close();
+      this.proc = null;
+      await this.startProcess();
+      // Re-subscribe to watch
+      await this.request("watch.subscribe", { attachments: false });
+      log.info("imsg RPC client restarted successfully");
+    } catch (err) {
+      log.error(`imsg restart failed: ${err} — retrying in 10s`);
+      this.restartTimer = setTimeout(() => this.restart(), 10_000);
+    }
+  }
+
+  private async startProcess(): Promise<void> {
+    this.proc = spawn(this.cliPath, ["rpc"], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    this.proc.on("error", (err) => {
+      log.error(`imsg process error: ${err.message}`);
+    });
+
+    this.proc.on("close", (code) => {
+      log.warn(`imsg process exited with code ${code}`);
+      for (const [id, req] of this.pending) {
+        clearTimeout(req.timer);
+        req.reject(new Error("imsg process exited"));
+        this.pending.delete(id);
+      }
+      if (!this.stopping) {
+        log.info("imsg process died — restarting in 3s...");
+        this.restartTimer = setTimeout(() => this.restart(), 3000);
+      }
+    });
+
+    if (this.proc.stderr) {
+      const stderrRl = createInterface({ input: this.proc.stderr });
+      stderrRl.on("line", (line) => {
+        if (line.trim()) log.warn(`imsg stderr: ${line}`);
+      });
+    }
+
+    if (this.proc.stdout) {
+      this.rl = createInterface({ input: this.proc.stdout });
+      this.rl.on("line", (line) => this.handleLine(line));
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.stopping = true;
+    if (this.restartTimer) clearTimeout(this.restartTimer);
+    for (const [id, req] of this.pending) {
+      clearTimeout(req.timer);
+      req.reject(new Error("Client stopping"));
+      this.pending.delete(id);
+    }
+    this.rl?.close();
+    this.proc?.kill("SIGTERM");
+    this.proc = null;
+    log.info("imsg RPC client stopped");
+  }
+}

package/src/utils/message-formatter.ts

@@ -0,0 +1,90 @@
+import { readFileSync } from "node:fs";
+import type { InboundMessage } from "../channels/types.js";
+
+interface ConversationEntry {
+  ts: string;
+  from: string;
+  text: string;
+  response: string;
+}
+
+export function formatMessage(
+  msg: InboundMessage,
+  memoryContextPath?: string,
+  conversationLogPath?: string,
+  historyLimit = 5,
+): string {
+  const parts: string[] = [];
+
+  // 1. Memory context
+  if (memoryContextPath) {
+    try {
+      const context = readFileSync(memoryContextPath, "utf-8").trim();
+      if (context) {
+        parts.push(`[Agent Memory]\n${context}\n[/Agent Memory]`);
+      }
+    } catch {
+      // no memory file yet, that's fine
+    }
+  }
+
+  // 2. Conversation history
+  if (conversationLogPath) {
+    try {
+      const raw = readFileSync(conversationLogPath, "utf-8").trim();
+      if (raw) {
+        const lines = raw.split("\n").filter(Boolean);
+        const recent = lines.slice(-historyLimit);
+        const entries: string[] = [];
+
+        for (const line of recent) {
+          try {
+            const entry = JSON.parse(line) as ConversationEntry;
+            entries.push(`  ${entry.from}: ${entry.text}`);
+            entries.push(`  Agent: ${entry.response}`);
+          } catch {
+            // skip malformed lines
+          }
+        }
+
+        if (entries.length > 0) {
+          parts.push(
+            `[Conversation History - last ${recent.length} exchanges]\n${entries.join("\n")}\n[/Conversation History]`
+          );
+        }
+      }
+    } catch {
+      // no log file yet
+    }
+  }
+
+  // 3. The message itself
+  const ts = new Date(msg.timestamp).toISOString();
+  const sender = msg.senderName || msg.sender;
+
+  let header: string;
+  if (msg.isGroup && msg.groupName) {
+    header = `[${msg.channel} group '${msg.groupName}' from ${sender} at ${ts}]`;
+  } else if (msg.isGroup) {
+    header = `[${msg.channel} group from ${sender} at ${ts}]`;
+  } else {
+    header = `[${msg.channel} DM from ${sender} at ${ts}]`;
+  }
+
+  let body = msg.text;
+
+  // Reply context
+  if (msg.replyTo) {
+    const replySender = msg.replyTo.sender || "unknown";
+    body += `\n\n[Replying to ${replySender}]\n${msg.replyTo.text}\n[/Replying]`;
+  }
+
+  // Attachment note
+  if (msg.attachments?.length) {
+    body += `\n\n[${msg.attachments.length} image(s) attached — visible in this message. Save them to the appropriate episode folder and reference in the episode JSON.]`;
+  }
+
+  parts.push(`${header}\n${body}\n[/${msg.channel}]`);
+
+  return parts.join("\n\n");
+}