@hasna/bridge 0.1.2 → 0.2.0

package/dist/index.js

@@ -32,6 +32,11 @@ function mergeEnv(profile, agent) {
     env["HOME"] = profile.home;
   return Object.keys(env).length ? env : undefined;
 }
+function compatibilityDetail(kind) {
+  if (kind === "shell")
+    return "shell command session; local bridge state is durable";
+  return "compatibility mode: this adapter invokes the current CLI one message at a time until a stable create/send/resume API is wired";
+}
 function resolveAgent(config, agentId) {
   const agent = config.agents[agentId];
   if (!agent)
@@ -50,7 +55,7 @@ function buildAgentCommand(config, agentId, input) {
   const kind = agent.kind;
   const command = agent.command || profile?.command;
   const args = agent.args || profile?.args;
-  const cwd = agent.cwd || profile?.cwd;
+  const cwd = input.session?.cwd || agent.cwd || profile?.cwd;
   const env = mergeEnv(profile, agent);
   if (command) {
     return { command: [command, ...renderCustomArgs(args, prompt)], cwd, env };
@@ -72,6 +77,46 @@ function buildAgentCommand(config, agentId, input) {
   }
   return { command: ["sh", "-lc", prompt], cwd, env };
 }
+function createAgentSessionRef(config, agentId) {
+  const { agent } = resolveAgent(config, agentId);
+  const timestamp = new Date().toISOString();
+  return {
+    kind: agent.kind,
+    mode: "compatibility",
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    detail: compatibilityDetail(agent.kind)
+  };
+}
+function resumeAgentSessionRef(session) {
+  return {
+    supported: session.agentSession?.mode === "durable",
+    ref: session.agentSession,
+    detail: session.agentSession?.mode === "durable" ? "durable agent session ref is available" : "compatibility sessions do not expose agent-side resume; bridge binding state is still durable"
+  };
+}
+function cancelAgentSession(session) {
+  return {
+    supported: false,
+    ref: session.agentSession,
+    detail: `cancel is not implemented for ${session.agentSession?.kind || "unknown"} ${session.agentSession?.mode || "compatibility"} sessions`
+  };
+}
+function closeAgentSession(session) {
+  return {
+    supported: session.agentSession?.mode === "durable",
+    ref: session.agentSession,
+    detail: session.agentSession?.mode === "durable" ? "durable close is adapter-owned" : "compatibility close only updates bridge session state"
+  };
+}
+async function sendAgentSessionMessage(config, session, message, options = {}) {
+  const run = options.run || runAgent;
+  return run(config, session.agentId, {
+    message,
+    route: { id: `session:${session.id}`, fromChannel: message.channelId, toAgent: session.agentId },
+    session
+  });
+}
 async function runAgent(config, agentId, input) {
   const { agent } = resolveAgent(config, agentId);
   const built = buildAgentCommand(config, agentId, input);
@@ -4130,7 +4175,14 @@ var channelSchema = exports_external.discriminatedUnion("kind", [
     kind: exports_external.literal("imessage"),
     label: exports_external.string().optional(),
     enabled: exports_external.boolean().optional(),
-    account: exports_external.string().optional()
+    account: exports_external.string().optional(),
+    serviceName: exports_external.string().optional(),
+    defaultHandle: exports_external.string().optional(),
+    allowedHandles: exports_external.array(exports_external.string()).optional(),
+    allowAllHandles: exports_external.boolean().optional(),
+    receiveMode: exports_external.enum(["disabled", "chat-db"]).optional(),
+    chatDbPath: exports_external.string().optional(),
+    pollLimit: exports_external.number().int().positive().max(500).optional()
   })
 ]);
 var envSchema = exports_external.record(exports_external.string(), exports_external.string());
@@ -4268,19 +4320,35 @@ import { dirname as dirname3, join as join3, resolve } from "path";
 // src/lib/state.ts
 import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname2, join as join2 } from "path";
+var STATE_SCHEMA_VERSION = 2;
 function defaultStatePath() {
   return process.env["BRIDGE_STATE"] || join2(bridgeHome(), "state.json");
 }
 function emptyState() {
-  return { telegramOffsets: {} };
+  return {
+    schemaVersion: STATE_SCHEMA_VERSION,
+    telegramOffsets: {},
+    sessions: {},
+    bindings: {},
+    messageLedger: {},
+    cursors: {}
+  };
+}
+function normalizeState(value) {
+  return {
+    schemaVersion: STATE_SCHEMA_VERSION,
+    telegramOffsets: value.telegramOffsets && typeof value.telegramOffsets === "object" ? value.telegramOffsets : {},
+    sessions: value.sessions && typeof value.sessions === "object" ? value.sessions : {},
+    bindings: value.bindings && typeof value.bindings === "object" ? value.bindings : {},
+    messageLedger: value.messageLedger && typeof value.messageLedger === "object" ? value.messageLedger : {},
+    cursors: value.cursors && typeof value.cursors === "object" ? value.cursors : {}
+  };
 }
 async function loadState(statePath = defaultStatePath()) {
   try {
     const raw = await readFile2(statePath, "utf-8");
     const parsed = JSON.parse(raw);
-    return {
-      telegramOffsets: parsed.telegramOffsets && typeof parsed.telegramOffsets === "object" ? parsed.telegramOffsets : {}
-    };
+    return normalizeState(parsed);
   } catch (err) {
     if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
       return emptyState();
@@ -4289,8 +4357,9 @@ async function loadState(statePath = defaultStatePath()) {
   }
 }
 async function saveState(state, statePath = defaultStatePath()) {
+  const normalized = normalizeState(state);
   await mkdir2(dirname2(statePath), { recursive: true, mode: 448 });
-  await writeFile2(statePath, `${JSON.stringify(state, null, 2)}
+  await writeFile2(statePath, `${JSON.stringify(normalized, null, 2)}
 `, { encoding: "utf-8", mode: 384 });
   await chmod2(statePath, 384);
 }
@@ -4377,6 +4446,7 @@ function telegramUpdateToMessage(channelId, update) {
     channelId,
     text,
     chatId: String(chatId),
+    threadId: update.message?.message_thread_id !== undefined ? String(update.message.message_thread_id) : undefined,
     from: update.message?.from?.username || (update.message?.from?.id !== undefined ? String(update.message.from.id) : undefined),
     receivedAt: update.message?.date ? new Date(update.message.date * 1000).toISOString() : new Date().toISOString(),
     raw: update
@@ -4555,14 +4625,17 @@ function startCommand(options) {
 function telegramChannels(config) {
   return Object.values(config.channels).filter((channel) => channel.kind === "telegram" && channel.enabled !== false);
 }
+function imessagePollChannels(config) {
+  return Object.values(config.channels).filter((channel) => channel.kind === "imessage" && channel.enabled !== false && channel.receiveMode === "chat-db");
+}
 function requiredTelegramEnvVars(config) {
   return [...new Set(telegramChannels(config).map((channel) => channel.botTokenEnv || "TELEGRAM_BOT_TOKEN"))];
 }
 async function validateStartConfig(configPath) {
   const config = await loadConfig(configPath);
-  const channels = telegramChannels(config);
+  const channels = [...telegramChannels(config), ...imessagePollChannels(config)];
   if (!channels.length)
-    throw new Error("No enabled Telegram channels configured; add one before starting the daemon");
+    throw new Error("No enabled pollable channels configured; add Telegram or iMessage receive before starting the daemon");
   for (const envName of requiredTelegramEnvVars(config)) {
     if (!process.env[envName])
       throw new Error(`Missing Telegram bot token env var for daemon start: ${envName}`);
@@ -4964,6 +5037,167 @@ async function daemonLogs(options = {}) {
 }
 // src/lib/doctor.ts
 import { stat as stat2 } from "fs/promises";
+
+// src/lib/imessage.ts
+import { access } from "fs/promises";
+import { join as join4 } from "path";
+import { Database } from "bun:sqlite";
+function defaultMessagesDbPath() {
+  return join4(homeDir(), "Library", "Messages", "chat.db");
+}
+function imessageHandleAllowed(channel, handle) {
+  if (channel.allowAllHandles)
+    return true;
+  if (!channel.allowedHandles?.length)
+    return false;
+  return Boolean(handle && channel.allowedHandles.includes(handle));
+}
+function appleScriptString(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function renderSendIMessageScript(channel, handle, text) {
+  const service = channel.serviceName || "iMessage";
+  const serviceSelector = channel.account ? `1st service whose name = ${appleScriptString(service)} and account = ${appleScriptString(channel.account)}` : `1st service whose name = ${appleScriptString(service)}`;
+  const targetLines = handle.startsWith("chat:") ? [
+    `set targetChat to 1st chat whose id = ${appleScriptString(handle.slice("chat:".length))}`,
+    `send ${appleScriptString(text)} to targetChat`
+  ] : [
+    `set targetBuddy to buddy ${appleScriptString(handle)} of targetService`,
+    `send ${appleScriptString(text)} to targetBuddy`
+  ];
+  return [
+    'tell application "Messages"',
+    `set targetService to ${serviceSelector}`,
+    ...targetLines,
+    "end tell"
+  ].join(`
+`);
+}
+async function defaultRun(command) {
+  const proc = Bun.spawn(command, { stdout: "pipe", stderr: "pipe" });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  return { exitCode, stdout, stderr };
+}
+async function sendIMessage(channel, handle, text, options = {}) {
+  if (!(options.allowChatTarget && handle.startsWith("chat:")) && !imessageHandleAllowed(channel, handle)) {
+    throw new Error(`iMessage handle is not allowed for channel ${channel.id}: ${handle}`);
+  }
+  const script = renderSendIMessageScript(channel, handle, text);
+  const result = await (options.run || defaultRun)(["osascript", "-e", script]);
+  if (result.exitCode !== 0) {
+    throw new Error(`iMessage send failed: ${result.stderr || result.stdout || `exit ${result.exitCode}`}`);
+  }
+  return { ok: true };
+}
+function imessageDateToIso(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+    return new Date().toISOString();
+  const appleEpochMs = Date.UTC(2001, 0, 1);
+  if (value > 1000000000000000)
+    return new Date(appleEpochMs + Math.floor(value / 1e6)).toISOString();
+  if (value > 1e9)
+    return new Date(appleEpochMs + value * 1000).toISOString();
+  return new Date(appleEpochMs + value).toISOString();
+}
+function getIMessageDbPath(channel) {
+  return channel.chatDbPath || defaultMessagesDbPath();
+}
+function getIMessageMessages(channel, options = {}) {
+  if ((channel.receiveMode || "disabled") !== "chat-db")
+    return [];
+  const db = new Database(getIMessageDbPath(channel), { readonly: true });
+  try {
+    const limit = options.limit || channel.pollLimit || 50;
+    const scanLimit = Math.max(limit * 10, limit);
+    const rows = db.query(`
+      select
+        message.ROWID as rowId,
+        handle.id as handle,
+        chat.guid as chatGuid,
+        chat.display_name as displayName,
+        message.text as text,
+        message.date as date
+      from message
+      left join handle on message.handle_id = handle.ROWID
+      left join chat_message_join on chat_message_join.message_id = message.ROWID
+      left join chat on chat.ROWID = chat_message_join.chat_id
+      where message.ROWID > ?
+        and message.is_from_me = 0
+        and message.text is not null
+      order by message.ROWID asc
+      limit ?
+    `).all(options.afterRowId || 0, scanLimit);
+    return rows.filter((row) => row.handle && row.text && imessageHandleAllowed(channel, row.handle)).slice(0, limit).map((row) => {
+      const item = { rowId: row.rowId, handle: row.handle, text: row.text, date: row.date };
+      if (row.chatGuid)
+        item.chatGuid = row.chatGuid;
+      if (row.displayName)
+        item.displayName = row.displayName;
+      return item;
+    });
+  } finally {
+    db.close();
+  }
+}
+function imessageRowToMessage(channelId, row) {
+  return {
+    id: `imessage:${row.rowId}`,
+    channelId,
+    chatId: row.chatGuid ? `chat:${row.chatGuid}` : row.handle,
+    responseTargetId: row.chatGuid ? `chat:${row.chatGuid}` : row.handle,
+    from: row.handle,
+    text: row.text,
+    receivedAt: imessageDateToIso(row.date),
+    raw: row
+  };
+}
+async function commandExists(command) {
+  const proc = Bun.spawn(["sh", "-lc", `command -v ${command} >/dev/null 2>&1`], {
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  return await proc.exited === 0;
+}
+async function diagnoseIMessage(channel) {
+  const checks = [];
+  checks.push({
+    name: `imessage-platform:${channel.id}`,
+    ok: process.platform === "darwin",
+    detail: process.platform === "darwin" ? "macOS" : `unsupported platform: ${process.platform}`
+  });
+  checks.push({
+    name: `imessage-osascript:${channel.id}`,
+    ok: await commandExists("osascript"),
+    detail: "required for Messages send automation"
+  });
+  checks.push({
+    name: `imessage-allowlist:${channel.id}`,
+    ok: Boolean(channel.allowAllHandles || channel.allowedHandles?.length),
+    detail: channel.allowAllHandles ? "allowAllHandles=true" : `${channel.allowedHandles?.length || 0} handle(s)`
+  });
+  if ((channel.receiveMode || "disabled") === "chat-db") {
+    const path = getIMessageDbPath(channel);
+    try {
+      await access(path);
+      checks.push({ name: `imessage-chat-db:${channel.id}`, ok: true, detail: path });
+    } catch (err) {
+      checks.push({
+        name: `imessage-chat-db:${channel.id}`,
+        ok: false,
+        detail: `${path}: ${err instanceof Error ? err.message : String(err)}. Grant Full Disk Access to the terminal/daemon host or disable receive mode.`
+      });
+    }
+  } else {
+    checks.push({ name: `imessage-receive:${channel.id}`, ok: true, detail: "receiveMode=disabled" });
+  }
+  return checks;
+}
+
+// src/lib/doctor.ts
 function isNotFound2(err) {
   return Boolean(err && typeof err === "object" && "code" in err && err.code === "ENOENT");
 }
@@ -4991,7 +5225,7 @@ async function privateDirCheck(name, path) {
     return { name, ok: false, detail: `${path}: ${err instanceof Error ? err.message : String(err)}` };
   }
 }
-async function commandExists(command) {
+async function commandExists2(command) {
   const proc = Bun.spawn(["sh", "-lc", `command -v ${command} >/dev/null 2>&1`], {
     stdout: "ignore",
     stderr: "ignore"
@@ -5029,7 +5263,7 @@ async function doctor(configPath = defaultConfigPath(), statePath = defaultState
   for (const command of ["bridge", "codewith", "claude", "aicopilot"]) {
     checks.push({
       name: `command:${command}`,
-      ok: command === "bridge" ? true : await commandExists(command),
+      ok: command === "bridge" ? true : await commandExists2(command),
       detail: command === "bridge" ? "current package" : undefined
     });
   }
@@ -5054,6 +5288,10 @@ async function doctor(configPath = defaultConfigPath(), statePath = defaultState
       detail: `${route.fromChannel} -> ${route.toAgent}`
     });
   }
+  const imessageChannels = Object.values(config.channels).filter((channel) => channel.kind === "imessage");
+  for (const channel of imessageChannels) {
+    checks.push(...await diagnoseIMessage(channel));
+  }
   return { ok: checks.every((check) => check.ok), configPath, checks };
 }
 // src/lib/router.ts
@@ -5064,6 +5302,9 @@ function matchingRoutes(config, message) {
   if (channel?.kind === "telegram" && !telegramChatAllowed(channel, message.chatId)) {
     return [];
   }
+  if (channel?.kind === "imessage" && !imessageHandleAllowed(channel, message.from || (message.chatId?.startsWith("chat:") ? undefined : message.chatId))) {
+    return [];
+  }
   return config.routes.filter((route) => {
     if (route.enabled === false)
       return false;
@@ -5103,16 +5344,367 @@ async function routeMessage(config, message, options = {}) {
       if (options.writeConsole !== false)
         (options.writeConsole || console.log)(responseText);
       deliveredResponse = true;
+    } else if (responseText && channel?.kind === "imessage") {
+      const handle = message.responseTargetId || message.chatId || message.from;
+      const allowedIdentity = message.from || (handle?.startsWith("chat:") ? undefined : handle);
+      if (handle && imessageHandleAllowed(channel, allowedIdentity)) {
+        await sendIMessage(channel, handle, responseText, { allowChatTarget: handle.startsWith("chat:") });
+        deliveredResponse = true;
+      }
     }
     results.push({ route, agent, deliveredResponse });
   }
   return results;
 }
+// src/lib/sessions.ts
+import { randomUUID } from "crypto";
+function nowIso() {
+  return new Date().toISOString();
+}
+function newSessionId() {
+  return `ses_${randomUUID()}`;
+}
+function normalizeConversationId(channel, conversation) {
+  if (conversation.includes(":") && conversation.startsWith(`${channel.kind}:`))
+    return conversation;
+  if (channel.kind === "telegram")
+    return `telegram:${channel.id}:${conversation}`;
+  if (channel.kind === "imessage")
+    return `imessage:${channel.id}:${conversation}`;
+  return `${channel.kind}:${channel.id}:${conversation || "default"}`;
+}
+function messageConversationId(config, message) {
+  const channel = config.channels[message.channelId];
+  if (!channel)
+    return;
+  if (channel.kind === "telegram") {
+    if (!message.chatId)
+      return;
+    return normalizeConversationId(channel, message.threadId ? `${message.chatId}:${message.threadId}` : message.chatId);
+  }
+  if (channel.kind === "imessage") {
+    const conversation = message.chatId || message.from;
+    return conversation ? normalizeConversationId(channel, conversation) : undefined;
+  }
+  return normalizeConversationId(channel, message.chatId || message.from || "default");
+}
+function bindingId(channelId, conversationId) {
+  return `${channelId}::${conversationId}`;
+}
+function ledgerId(message) {
+  return `${message.channelId}::${message.id}`;
+}
+function createBridgeSession(config, state, input) {
+  const { agent, profile } = resolveAgent(config, input.agentId);
+  const timestamp = nowIso();
+  const session = {
+    id: input.id || newSessionId(),
+    agentId: agent.id,
+    profileId: agent.profileId,
+    cwd: input.cwd || agent.cwd || profile?.cwd,
+    title: input.title,
+    status: "active",
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    agentSession: createAgentSessionRef(config, agent.id)
+  };
+  state.sessions[session.id] = session;
+  return session;
+}
+function getBridgeSession(state, sessionId) {
+  const session = state.sessions[sessionId];
+  if (!session)
+    throw new Error(`Session not found: ${sessionId}`);
+  return session;
+}
+function listBridgeSessions(state) {
+  return Object.values(state.sessions).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function updateBridgeSessionStatus(state, sessionId, status) {
+  const session = getBridgeSession(state, sessionId);
+  if (status === "closed")
+    closeAgentSession(session);
+  session.status = status;
+  session.updatedAt = nowIso();
+  return session;
+}
+function attachBridgeSession(config, state, input) {
+  const channel = config.channels[input.channelId];
+  if (!channel)
+    throw new Error(`Channel not found: ${input.channelId}`);
+  const session = getBridgeSession(state, input.sessionId);
+  if (session.status === "closed")
+    throw new Error(`Cannot attach closed session: ${session.id}`);
+  const conversationId = normalizeConversationId(channel, input.conversation);
+  const id = bindingId(channel.id, conversationId);
+  const existing = state.bindings[id];
+  const timestamp = nowIso();
+  const binding = {
+    id,
+    channelId: channel.id,
+    conversationId,
+    activeSessionId: session.id,
+    defaultSessionId: input.makeDefault ? session.id : existing?.defaultSessionId,
+    createdAt: existing?.createdAt || timestamp,
+    updatedAt: timestamp,
+    authorization: input.authorization || existing?.authorization || (channel.kind === "telegram" ? { chatId: input.conversation.split(":")[0] } : undefined)
+  };
+  state.bindings[id] = binding;
+  return binding;
+}
+function detachBridgeBinding(config, state, channelId, conversation) {
+  const channel = config.channels[channelId];
+  if (!channel)
+    throw new Error(`Channel not found: ${channelId}`);
+  const conversationId = normalizeConversationId(channel, conversation);
+  const id = bindingId(channel.id, conversationId);
+  const existing = state.bindings[id];
+  delete state.bindings[id];
+  return existing;
+}
+function findBridgeBinding(config, state, message) {
+  const conversationId = messageConversationId(config, message);
+  if (!conversationId)
+    return;
+  return state.bindings[bindingId(message.channelId, conversationId)];
+}
+function noSessionText(channelId, conversationId) {
+  return [
+    "No bridge session is attached to this conversation.",
+    "Create and attach one locally:",
+    "bridge sessions create --agent <agent-id>",
+    `bridge sessions attach <session-id> --channel ${channelId}${conversationId ? ` --conversation ${conversationId}` : " --conversation <conversation-id>"}`
+  ].join(`
+`);
+}
+async function deliverResponse(config, message, text, options) {
+  const channel = config.channels[message.channelId];
+  if (!text || !channel || channel.enabled === false)
+    return false;
+  if (channel.kind === "telegram" && message.chatId) {
+    if (!telegramChatAllowed(channel, message.chatId))
+      return false;
+    await (options.sendTelegram || sendTelegramMessage)(telegramToken(channel), message.chatId, text);
+    return true;
+  }
+  if (channel.kind === "console") {
+    if (options.writeConsole !== false)
+      (options.writeConsole || console.log)(text);
+    return true;
+  }
+  if (channel.kind === "imessage" && message.chatId) {
+    const allowedIdentity = message.from || (message.chatId.startsWith("chat:") ? undefined : message.chatId);
+    if (!imessageHandleAllowed(channel, allowedIdentity))
+      return false;
+    await sendIMessage(channel, message.responseTargetId || message.chatId, text, { allowChatTarget: Boolean(message.responseTargetId?.startsWith("chat:") || message.chatId.startsWith("chat:")) });
+    return true;
+  }
+  return false;
+}
+async function deliverStoredResponse(config, state, binding, message, entry, options) {
+  const session = getBridgeSession(state, binding.activeSessionId);
+  const responseText = entry.responseText || "";
+  const deliveredResponse = responseText ? await deliverResponse(config, message, responseText, options) : false;
+  completeLedger(entry, "delivered", session.id);
+  entry.deliveredResponse = deliveredResponse;
+  return {
+    kind: "session",
+    session,
+    binding,
+    conversationId: binding.conversationId,
+    deliveredResponse,
+    status: responseText ? "delivered" : "no_output"
+  };
+}
+function channelAuthorized(config, message) {
+  const channel = config.channels[message.channelId];
+  if (!channel || channel.enabled === false)
+    return false;
+  if (channel.kind === "telegram")
+    return telegramChatAllowed(channel, message.chatId);
+  if (channel.kind === "imessage")
+    return imessageHandleAllowed(channel, message.from || (message.chatId?.startsWith("chat:") ? undefined : message.chatId));
+  return true;
+}
+function bindingAuthorized(binding, message) {
+  if (binding.authorization?.chatId && binding.authorization.chatId !== message.chatId)
+    return false;
+  if (binding.authorization?.from && binding.authorization.from !== message.from)
+    return false;
+  return true;
+}
+async function sendBridgeSessionMessage(config, state, sessionId, message, options = {}) {
+  const session = getBridgeSession(state, sessionId);
+  if (session.status === "paused")
+    return { kind: "session", session, status: "paused", message: "Session is paused" };
+  if (session.status === "closed")
+    return { kind: "session", session, status: "closed", message: "Session is closed" };
+  const agent = await sendAgentSessionMessage(config, session, message, { run: options.run });
+  const timestamp = nowIso();
+  session.lastMessageAt = timestamp;
+  session.updatedAt = timestamp;
+  if (session.agentSession)
+    session.agentSession.updatedAt = timestamp;
+  if (agent.timedOut || agent.exitCode !== null && agent.exitCode !== 0) {
+    return {
+      kind: "session",
+      session,
+      agent,
+      deliveredResponse: false,
+      status: "failed",
+      message: agent.stderr.trim() || agent.stdout.trim() || (agent.timedOut ? "Agent timed out" : `Agent exited ${agent.exitCode}`)
+    };
+  }
+  const responseText = agent.stdout.trim();
+  await options.beforeDeliver?.(agent, responseText);
+  const deliveredResponse = responseText ? await deliverResponse(config, message, responseText, options) : false;
+  return {
+    kind: "session",
+    session,
+    agent,
+    deliveredResponse,
+    status: responseText ? "delivered" : "no_output"
+  };
+}
+async function routeSessionMessage(config, state, message, options = {}) {
+  const channel = config.channels[message.channelId];
+  if (!channel || channel.enabled === false) {
+    return { kind: "session", status: "unauthorized", message: `Channel not enabled: ${message.channelId}` };
+  }
+  if (!channelAuthorized(config, message)) {
+    return { kind: "session", status: "unauthorized", message: "Message is not authorized for this channel" };
+  }
+  const conversationId = messageConversationId(config, message);
+  const binding = conversationId ? state.bindings[bindingId(message.channelId, conversationId)] : undefined;
+  if (!binding) {
+    const text = noSessionText(message.channelId, conversationId);
+    if (options.respondOnNoSession !== false)
+      await deliverResponse(config, message, text, options);
+    return { kind: "session", conversationId, status: "no_session", message: text };
+  }
+  if (!bindingAuthorized(binding, message)) {
+    return { kind: "session", binding, conversationId, status: "unauthorized", message: "Message does not match binding authorization" };
+  }
+  const result = await sendBridgeSessionMessage(config, state, binding.activeSessionId, message, options);
+  return { ...result, binding, conversationId };
+}
+function beginLedger(state, message, conversationId) {
+  const id = ledgerId(message);
+  const existing = state.messageLedger[id];
+  if (existing && ["delivered", "skipped", "unauthorized"].includes(existing.status)) {
+    return { entry: existing, shouldProcess: false };
+  }
+  const timestamp = nowIso();
+  const entry = existing || {
+    id,
+    channelId: message.channelId,
+    messageId: message.id,
+    conversationId,
+    status: "processing",
+    attempts: 0,
+    firstSeenAt: timestamp,
+    updatedAt: timestamp
+  };
+  if (entry.status !== "agent_completed")
+    entry.status = "processing";
+  entry.attempts += 1;
+  entry.conversationId = conversationId || entry.conversationId;
+  entry.updatedAt = timestamp;
+  delete entry.error;
+  state.messageLedger[id] = entry;
+  return { entry, shouldProcess: true };
+}
+function completeLedger(entry, status, sessionId, error) {
+  const timestamp = nowIso();
+  entry.status = status;
+  entry.sessionId = sessionId || entry.sessionId;
+  entry.updatedAt = timestamp;
+  if (["delivered", "skipped", "unauthorized"].includes(status))
+    entry.terminalAt = timestamp;
+  if (error)
+    entry.error = error;
+  return entry;
+}
+function recordAgentCompleted(entry, sessionId, agent, responseText) {
+  const timestamp = nowIso();
+  entry.status = "agent_completed";
+  entry.sessionId = sessionId || entry.sessionId;
+  entry.responseText = responseText;
+  entry.agentExitCode = agent.exitCode;
+  entry.agentTimedOut = agent.timedOut;
+  entry.updatedAt = timestamp;
+  delete entry.error;
+  return entry;
+}
+async function dispatchMessageWithSessions(config, state, message, options = {}) {
+  const conversationId = messageConversationId(config, message);
+  const { entry, shouldProcess } = beginLedger(state, message, conversationId);
+  if (!shouldProcess)
+    return { message, ledger: entry };
+  await options.persistState?.(state);
+  try {
+    const binding = conversationId ? state.bindings[bindingId(message.channelId, conversationId)] : undefined;
+    if (binding) {
+      if (!bindingAuthorized(binding, message)) {
+        const session3 = {
+          kind: "session",
+          binding,
+          conversationId,
+          status: "unauthorized",
+          message: "Message does not match binding authorization"
+        };
+        completeLedger(entry, "unauthorized");
+        return { message, session: session3, ledger: entry };
+      }
+      if (entry.status === "agent_completed") {
+        const session3 = await deliverStoredResponse(config, state, binding, message, entry, options);
+        return { message, session: session3, ledger: entry };
+      }
+      const session2 = await routeSessionMessage(config, state, message, {
+        ...options,
+        beforeDeliver: async (agent, responseText) => {
+          recordAgentCompleted(entry, binding.activeSessionId, agent, responseText);
+          await options.persistState?.(state);
+          await options.beforeDeliver?.(agent, responseText);
+        }
+      });
+      if (session2.status === "failed") {
+        completeLedger(entry, "failed", session2.session?.id, session2.message);
+        throw new Error(session2.message || "Agent session failed");
+      }
+      const terminal = session2.status === "unauthorized" ? "unauthorized" : session2.status === "delivered" || session2.status === "no_output" ? "delivered" : "skipped";
+      completeLedger(entry, terminal, session2.session?.id);
+      entry.deliveredResponse = session2.deliveredResponse;
+      return { message, session: session2, ledger: entry };
+    }
+    if (options.fallbackToRoutes) {
+      const routes = await routeMessage(config, message, options);
+      if (routes.length) {
+        completeLedger(entry, "delivered");
+        return { message, routes, ledger: entry };
+      }
+    }
+    const session = await routeSessionMessage(config, state, message, options);
+    const status = session.status === "unauthorized" ? "unauthorized" : "skipped";
+    completeLedger(entry, status, session.session?.id);
+    return { message, session, ledger: entry };
+  } catch (err) {
+    const messageText = err instanceof Error ? err.message : String(err);
+    if (entry.status === "agent_completed") {
+      entry.error = messageText;
+      entry.updatedAt = nowIso();
+    } else {
+      completeLedger(entry, "failed", undefined, messageText);
+    }
+    throw err;
+  }
+}
 export {
   upsertRoute,
   upsertProfile,
   upsertChannel,
   upsertAgent,
+  updateBridgeSessionStatus,
   uninstallDaemon,
   telegramUpdateToMessage,
   telegramToken,
@@ -5124,38 +5716,65 @@ export {
   startProcessDaemon,
   startInstalledDaemon,
   sendTelegramMessage,
+  sendIMessage,
+  sendBridgeSessionMessage,
+  sendAgentSessionMessage,
   saveState,
   saveConfig,
   runAgent,
+  routeSessionMessage,
   routeMessage,
+  resumeAgentSessionRef,
   restartProcessDaemon,
   restartInstalledDaemon,
   resolveSupervisor,
   resolveAgent,
   requiredTelegramEnvVars,
   renderSystemdUnit,
+  renderSendIMessageScript,
   renderLaunchdPlist,
   redactConfig,
   parseConfig,
+  normalizeConversationId,
+  messageConversationId,
   matchingRoutes,
   loadState,
   loadConfig,
+  listBridgeSessions,
+  ledgerId,
   installDaemon,
+  imessageRowToMessage,
+  imessageHandleAllowed,
   homeDir,
   getTelegramUpdates,
+  getIMessageMessages,
+  getIMessageDbPath,
+  getBridgeSession,
+  findBridgeBinding,
   ensureDaemonDir,
   ensureConfig,
   emptyState,
   emptyConfig,
   doctor,
+  dispatchMessageWithSessions,
+  diagnoseIMessage,
+  detachBridgeBinding,
   defaultStatePath,
+  defaultMessagesDbPath,
   defaultDaemonDir,
   defaultConfigPath,
   daemonStatus,
   daemonPaths,
   daemonLogs,
+  createBridgeSession,
+  createAgentSessionRef,
+  closeAgentSession,
+  cancelAgentSession,
   buildAgentCommand,
   bridgeHome,
+  bindingId,
+  attachBridgeSession,
+  STATE_SCHEMA_VERSION,
   CONFIG_VERSION,
   CHANNEL_KINDS,
   AGENT_KINDS