march-cli 0.1.32 → 0.1.33

package/src/gateway/platform-registry.mjs

@@ -0,0 +1,38 @@
+import { createTelegramPlatformAdapter } from "./platforms/telegram.mjs";
+
+export class GatewayPlatformRegistry {
+  #factories = new Map();
+
+  register(id, factory) {
+    const key = normalizePlatformId(id);
+    if (typeof factory !== "function") throw new Error(`Gateway platform factory must be a function: ${key}`);
+    this.#factories.set(key, factory);
+  }
+
+  has(id) {
+    return this.#factories.has(normalizePlatformId(id));
+  }
+
+  list() {
+    return [...this.#factories.keys()].sort();
+  }
+
+  create(id, options = {}) {
+    const key = normalizePlatformId(id);
+    const factory = this.#factories.get(key);
+    if (!factory) throw new Error(`Unsupported gateway platform: ${key}`);
+    return factory(options);
+  }
+}
+
+export function createDefaultGatewayPlatformRegistry(options = {}) {
+  const registry = new GatewayPlatformRegistry();
+  registry.register("telegram", (platformOptions = {}) => createTelegramPlatformAdapter({ ...options, ...platformOptions }));
+  return registry;
+}
+
+function normalizePlatformId(id) {
+  const value = String(id ?? "").trim().toLowerCase();
+  if (!/^[a-z0-9_-]+$/.test(value)) throw new Error(`Invalid gateway platform id: ${id}`);
+  return value;
+}

package/src/gateway/platforms/telegram.mjs

@@ -0,0 +1,241 @@
+import { readFileSync } from "node:fs";
+
+const TELEGRAM_API_BASE = "https://api.telegram.org";
+const MAX_TELEGRAM_TEXT = 3900;
+
+export function createTelegramPlatformAdapter({
+  config = {},
+  fetchImpl = globalThis.fetch,
+  env = process.env,
+  sleep = defaultSleep,
+  logger = console,
+} = {}) {
+  return new TelegramPlatformAdapter({ config, fetchImpl, env, sleep, logger });
+}
+
+export class TelegramPlatformAdapter {
+  #config;
+  #fetch;
+  #env;
+  #sleep;
+  #logger;
+  #offset = 0;
+  #running = false;
+
+  constructor({ config, fetchImpl, env, sleep, logger }) {
+    this.id = "telegram";
+    this.#config = config ?? {};
+    this.#fetch = fetchImpl;
+    this.#env = env ?? {};
+    this.#sleep = sleep;
+    this.#logger = logger;
+  }
+
+  get configured() {
+    return Boolean(this.#token());
+  }
+
+  async start({ handleMessage, signal } = {}) {
+    if (typeof handleMessage !== "function") throw new Error("Telegram gateway requires a message handler");
+    this.#assertReady();
+    this.#running = true;
+    await this.#api("deleteWebhook", { drop_pending_updates: false });
+    this.#logger.info?.("[gateway:telegram] polling started");
+    while (this.#running && !signal?.aborted) {
+      try {
+        await this.pollOnce({ handleMessage });
+      } catch (err) {
+        this.#logger.warn?.(`[gateway:telegram] polling error: ${err.message}`);
+        await this.#sleep(this.#retryDelayMs());
+      }
+    }
+  }
+
+  stop() {
+    this.#running = false;
+  }
+
+  async pollOnce({ handleMessage } = {}) {
+    if (typeof handleMessage !== "function") throw new Error("Telegram gateway requires a message handler");
+    this.#assertReady();
+    const response = await this.#api("getUpdates", {
+      offset: this.#offset || undefined,
+      timeout: this.#pollTimeoutSeconds(),
+      allowed_updates: ["message"],
+    });
+    const updates = Array.isArray(response.result) ? response.result : [];
+    for (const update of updates) {
+      if (Number.isInteger(update.update_id)) this.#offset = Math.max(this.#offset, update.update_id + 1);
+      const message = normalizeTelegramUpdate(update, { allowedUsers: this.#allowedUsers(), dmOnly: this.#dmOnly() });
+      if (!message) continue;
+      const result = await handleMessage(message);
+      await this.send({ chatId: message.chatId, lines: result?.lines ?? [], replyToMessageId: message.messageId });
+    }
+    return updates.length;
+  }
+
+  async send({ chatId, lines, replyToMessageId = null }) {
+    const chunks = splitTelegramLines(lines);
+    for (const text of chunks) {
+      await this.#api("sendMessage", {
+        chat_id: chatId,
+        text,
+        disable_web_page_preview: true,
+        ...replyOptions(replyToMessageId),
+      });
+    }
+  }
+
+  async sendBinary({ chatId, binary, replyToMessageId = null }) {
+    const method = telegramBinaryMethod(binary?.type);
+    const field = telegramBinaryField(binary?.type);
+    const payload = {
+      chat_id: chatId,
+      ...replyOptions(replyToMessageId),
+      ...(binary.caption ? { caption: binary.caption } : {}),
+    };
+    if (binary.url) {
+      await this.#api(method, { ...payload, [field]: binary.url });
+      return { target: "telegram", method, source: "url" };
+    }
+    if (!binary.path) throw new Error("Telegram binary send requires path or url");
+    const form = new FormData();
+    for (const [key, value] of Object.entries(payload)) form.append(key, String(value));
+    const data = readFileSync(binary.path);
+    const blob = new Blob([data], { type: binary.mimeType || "application/octet-stream" });
+    form.append(field, blob, binary.filename || binary.path.split(/[\\/]/).at(-1) || "media.bin");
+    await this.#apiForm(method, form);
+    return { target: "telegram", method, source: "path" };
+  }
+
+  #assertReady() {
+    if (!this.#token()) throw new Error("Telegram gateway requires a bot token. Set TELEGRAM_BOT_TOKEN or gateway.platforms.telegram.botTokenEnv.");
+    if (typeof this.#fetch !== "function") throw new Error("Telegram gateway requires fetch support");
+  }
+
+  async #api(method, payload) {
+    return this.#apiRequest(method, {
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(payload ?? {}),
+    });
+  }
+
+  async #apiForm(method, form) {
+    return this.#apiRequest(method, { body: form });
+  }
+
+  async #apiRequest(method, init) {
+    const response = await this.#fetch(`${this.#apiBase()}/bot${this.#token()}/${method}`, {
+      method: "POST",
+      ...init,
+    });
+    const data = await response.json().catch(() => null);
+    if (!response.ok || data?.ok !== true) {
+      const description = data?.description || response.statusText || `HTTP ${response.status}`;
+      throw new Error(`Telegram ${method} failed: ${description}`);
+    }
+    return data;
+  }
+
+  #token() {
+    const tokenEnv = this.#config.botTokenEnv ?? this.#config.bot_token_env ?? this.#config.tokenEnv ?? "TELEGRAM_BOT_TOKEN";
+    return cleanString(this.#config.botToken ?? this.#config.bot_token ?? this.#config.token ?? this.#env[tokenEnv]);
+  }
+
+  #allowedUsers() {
+    const raw = this.#config.allowedUsers ?? this.#config.allowed_users ?? this.#env.MARCH_TELEGRAM_ALLOWED_USERS ?? this.#env.TELEGRAM_ALLOWED_USERS ?? "";
+    if (Array.isArray(raw)) return new Set(raw.map((value) => String(value).trim()).filter(Boolean));
+    return new Set(String(raw).split(",").map((value) => value.trim()).filter(Boolean));
+  }
+
+  #dmOnly() {
+    return this.#config.dmOnly ?? this.#config.dm_only ?? true;
+  }
+
+  #apiBase() {
+    return cleanString(this.#config.apiBase ?? this.#config.api_base) ?? TELEGRAM_API_BASE;
+  }
+
+  #pollTimeoutSeconds() {
+    return positiveInteger(this.#config.pollTimeoutSeconds ?? this.#config.poll_timeout_seconds, 30);
+  }
+
+  #retryDelayMs() {
+    return positiveInteger(this.#config.retryDelayMs ?? this.#config.retry_delay_ms, 2000);
+  }
+}
+
+export function normalizeTelegramUpdate(update, { allowedUsers = new Set(), dmOnly = true } = {}) {
+  const rawMessage = update?.message;
+  const text = typeof rawMessage?.text === "string" ? rawMessage.text.trim() : "";
+  if (!rawMessage || !text) return null;
+
+  const userId = cleanString(rawMessage.from?.id);
+  const chatId = cleanString(rawMessage.chat?.id);
+  if (!userId || !chatId) return null;
+  if (!isAllowedTelegramUser(userId, allowedUsers)) return null;
+  if (dmOnly && rawMessage.chat?.type !== "private") return null;
+
+  return {
+    platform: "telegram",
+    chatId,
+    userId,
+    messageId: cleanString(rawMessage.message_id),
+    text,
+    receivedAt: rawMessage.date ? new Date(rawMessage.date * 1000).toISOString() : new Date().toISOString(),
+  };
+}
+
+export function isAllowedTelegramUser(userId, allowedUsers) {
+  if (!(allowedUsers instanceof Set) || allowedUsers.size === 0) return false;
+  return allowedUsers.has("*") || allowedUsers.has(String(userId));
+}
+
+export function telegramBinaryMethod(type) {
+  if (type === "image") return "sendPhoto";
+  if (type === "video") return "sendVideo";
+  if (type === "audio") return "sendAudio";
+  if (type === "file") return "sendDocument";
+  throw new Error(`Unsupported Telegram binary type: ${type}`);
+}
+
+export function telegramBinaryField(type) {
+  if (type === "image") return "photo";
+  if (type === "video") return "video";
+  if (type === "audio") return "audio";
+  if (type === "file") return "document";
+  throw new Error(`Unsupported Telegram binary type: ${type}`);
+}
+
+export function splitTelegramLines(lines) {
+  const text = (Array.isArray(lines) ? lines : [lines])
+    .map((line) => String(line ?? "").trimEnd())
+    .filter(Boolean)
+    .join("\n");
+  if (!text) return [];
+
+  const chunks = [];
+  for (let index = 0; index < text.length; index += MAX_TELEGRAM_TEXT) {
+    chunks.push(text.slice(index, index + MAX_TELEGRAM_TEXT));
+  }
+  return chunks;
+}
+
+function replyOptions(replyToMessageId) {
+  return replyToMessageId ? { reply_to_message_id: Number(replyToMessageId), allow_sending_without_reply: true } : {};
+}
+
+function cleanString(value) {
+  if (value == null) return null;
+  const clean = String(value).trim();
+  return clean || null;
+}
+
+function positiveInteger(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/gateway/runner-bridge.mjs

@@ -0,0 +1,55 @@
+import { normalize } from "node:path";
+
+export function createGatewayRunnerBridge({ runner, cwd }) {
+  if (!runner) throw new Error("Gateway runner bridge requires a runner");
+  const root = normalize(cwd);
+  let activeGatewaySessionKey = null;
+
+  return {
+    async getRunner(session) {
+      if (normalize(session.workspaceRoot) !== root) {
+        throw new Error(`Gateway workspace '${session.workspaceAlias}' is not served by this process: ${session.workspaceRoot}`);
+      }
+      await activateGatewaySession({ runner, session, activeGatewaySessionKey });
+      activeGatewaySessionKey = session.key;
+      return wrapRunnerForGatewaySession(runner, session, () => { activeGatewaySessionKey = session.key; });
+    },
+  };
+}
+
+async function activateGatewaySession({ runner, session, activeGatewaySessionKey }) {
+  const stats = runner.getSessionStats?.() ?? {};
+  if (!session.piSessionFile) {
+    if (!activeGatewaySessionKey) {
+      bindSessionFile(session, stats);
+      return;
+    }
+    const result = await runner.startNewSession();
+    bindSessionFile(session, result ?? runner.getSessionStats?.() ?? {});
+    return;
+  }
+  if (stats.sessionFile !== session.piSessionFile) {
+    await runner.switchPiSession(session.piSessionFile);
+  }
+}
+
+function wrapRunnerForGatewaySession(runner, session, markActive) {
+  return new Proxy(runner, {
+    get(target, property, receiver) {
+      if (property === "startNewSession") {
+        return async (...args) => {
+          const result = await target.startNewSession(...args);
+          bindSessionFile(session, result ?? target.getSessionStats?.() ?? {});
+          markActive();
+          return result;
+        };
+      }
+      return Reflect.get(target, property, receiver);
+    },
+  });
+}
+
+function bindSessionFile(session, stats) {
+  if (stats?.sessionFile) session.piSessionFile = stats.sessionFile;
+  if (stats?.sessionId) session.piSessionId = stats.sessionId;
+}

package/src/gateway/runtime/queue.mjs

@@ -0,0 +1,46 @@
+export function createGatewayMessageQueue({ handleMessage, send, logger = console } = {}) {
+  if (typeof handleMessage !== "function") throw new Error("Gateway queue requires a message handler");
+  if (typeof send !== "function") throw new Error("Gateway queue requires a send function");
+
+  const pending = [];
+  let processing = false;
+
+  return {
+    enqueue(message) {
+      const ahead = pending.length + (processing ? 1 : 0);
+      pending.push(message);
+      drainSoon();
+      if (ahead <= 0) return { type: "queued", lines: [] };
+      return { type: "queued", lines: [`Queued: ${ahead} message${ahead === 1 ? "" : "s"} ahead.`] };
+    },
+    getStats() {
+      return { processing, pending: pending.length };
+    },
+  };
+
+  function drainSoon() {
+    if (processing) return;
+    processing = true;
+    queueMicrotask(() => {
+      void drain();
+    });
+  }
+
+  async function drain() {
+    try {
+      while (pending.length > 0) {
+        const message = pending.shift();
+        try {
+          const result = await handleMessage(message);
+          await send(message, result);
+        } catch (err) {
+          logger.warn?.(`[gateway:queue] message failed: ${err.message}`);
+          await send(message, { type: "error", lines: [`Error: ${err.message}`] });
+        }
+      }
+    } finally {
+      processing = false;
+      if (pending.length > 0) drainSoon();
+    }
+  }
+}

package/src/gateway/session-store.mjs

@@ -0,0 +1,46 @@
+import { createModeState, MODES } from "../cli/input/mode-state.mjs";
+import { gatewaySessionKey } from "./message.mjs";
+import { resolveGatewayWorkspace } from "./config.mjs";
+
+export class GatewaySessionStore {
+  #gatewayConfig;
+  #sessions = new Map();
+
+  constructor({ gatewayConfig }) {
+    this.#gatewayConfig = gatewayConfig;
+  }
+
+  getOrCreate(message) {
+    const key = gatewaySessionKey(message);
+    const existing = this.#sessions.get(key);
+    if (existing) return existing;
+
+    const workspaceAlias = this.#gatewayConfig?.defaultWorkspace ?? null;
+    const workspace = resolveGatewayWorkspace(this.#gatewayConfig, workspaceAlias);
+    const session = {
+      key,
+      platform: message.platform,
+      chatId: message.chatId,
+      threadId: message.threadId,
+      // Remote social entrypoints default to safe discussion mode.
+      modeState: createModeState({ initial: MODES.DISCUSS }),
+      workspaceAlias,
+      workspaceRoot: workspace?.root ?? null,
+      marchSessionId: `gateway:${key}`,
+    };
+    this.#sessions.set(key, session);
+    return session;
+  }
+
+  setWorkspace(session, alias) {
+    const workspace = resolveGatewayWorkspace(this.#gatewayConfig, alias);
+    if (!workspace) throw new Error(`Unknown gateway workspace: ${alias}`);
+    session.workspaceAlias = workspace.alias;
+    session.workspaceRoot = workspace.root;
+    return session;
+  }
+
+  listWorkspaces() {
+    return Object.values(this.#gatewayConfig?.workspaces ?? {});
+  }
+}

package/src/gateway/setup/command.mjs

@@ -0,0 +1,150 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { createInterface } from "node:readline";
+import { readConfigJson, writeConfigJson } from "../../config/config-json.mjs";
+import { selectWithKeyboard } from "../../cli/input/select-with-keyboard.mjs";
+
+const TELEGRAM_PLATFORM = { id: "telegram", label: "Telegram", tokenEnv: "TELEGRAM_BOT_TOKEN" };
+
+export async function runGatewaySetupCommand({
+  cwd = process.cwd(),
+  input = process.stdin,
+  output = process.stdout,
+  select = selectWithKeyboard,
+  readSecret = readLine,
+  readText = readLine,
+} = {}) {
+  output.write("Gateway setup\n\n");
+  const platform = await select({
+    input,
+    output,
+    message: "Choose gateway platform",
+    items: [{ label: TELEGRAM_PLATFORM.label, value: TELEGRAM_PLATFORM }],
+  });
+  if (!platform) {
+    output.write("Gateway setup cancelled.\n");
+    return 1;
+  }
+
+  const token = String(await readSecret({ input, output, prompt: "Telegram bot token: " }) ?? "").trim();
+  if (!token) {
+    output.write("Telegram bot token is required.\n");
+    return 1;
+  }
+
+  const userId = String(await readText({ input, output, prompt: "Allowed Telegram user id: " }) ?? "").trim();
+  if (!userId) {
+    output.write("Allowed Telegram user id is required.\n");
+    return 1;
+  }
+
+  const workspaceAlias = normalizeAlias(String(await readText({ input, output, prompt: "Workspace alias [current]: " }) ?? "").trim() || "current");
+  if (!workspaceAlias) {
+    output.write("Workspace alias must contain only letters, numbers, _ or -.\n");
+    return 1;
+  }
+
+  const configPath = projectGatewayConfigJsonPath(cwd);
+  upsertGatewayProjectConfig({
+    path: configPath,
+    workspaceAlias,
+    workspaceRoot: ".",
+    platformId: platform.id,
+    tokenEnv: platform.tokenEnv,
+    allowedUsers: [userId],
+  });
+  const envPath = projectEnvPath(cwd);
+  upsertEnvFile({ path: envPath, key: platform.tokenEnv, value: token });
+
+  output.write("\nGateway configured.\n");
+  output.write(`Config: ${relative(cwd, configPath) || configPath}\n`);
+  output.write(`Secret env: ${relative(cwd, envPath) || envPath}\n`);
+  output.write("\nRun:\n  march gateway run\n");
+  return 0;
+}
+
+export function projectGatewayConfigJsonPath(cwd) {
+  return join(cwd, ".march", "config.json");
+}
+
+export function projectEnvPath(cwd) {
+  return join(cwd, ".env");
+}
+
+export function upsertGatewayProjectConfig({ path, workspaceAlias, workspaceRoot = ".", platformId = "telegram", tokenEnv = "TELEGRAM_BOT_TOKEN", allowedUsers = [] }) {
+  const config = readConfigJson(path);
+  const gateway = config.gateway && typeof config.gateway === "object" && !Array.isArray(config.gateway) ? config.gateway : {};
+  const workspaces = gateway.workspaces && typeof gateway.workspaces === "object" && !Array.isArray(gateway.workspaces) ? gateway.workspaces : {};
+  const platforms = gateway.platforms && typeof gateway.platforms === "object" && !Array.isArray(gateway.platforms) ? gateway.platforms : {};
+  const platform = platforms[platformId] && typeof platforms[platformId] === "object" && !Array.isArray(platforms[platformId]) ? platforms[platformId] : {};
+
+  config.gateway = {
+    ...gateway,
+    enabled: true,
+    defaultWorkspace: workspaceAlias,
+    workspaces: {
+      ...workspaces,
+      [workspaceAlias]: workspaceRoot,
+    },
+    platforms: {
+      ...platforms,
+      [platformId]: {
+        ...platform,
+        enabled: true,
+        botTokenEnv: tokenEnv,
+        allowedUsers: mergeUniqueStrings(platform.allowedUsers ?? platform.allowed_users, allowedUsers),
+      },
+    },
+  };
+  writeConfigJson(path, config);
+  return config;
+}
+
+export function upsertEnvFile({ path, key, value }) {
+  const lines = existsSync(path) ? readFileSync(path, "utf8").split(/\r?\n/) : [];
+  const nextLine = `${key}=${escapeEnvValue(value)}`;
+  let replaced = false;
+  const next = lines.map((line) => {
+    const parsed = parseEnvLine(line);
+    if (parsed?.key !== key) return line;
+    replaced = true;
+    return nextLine;
+  });
+  if (!replaced) {
+    if (next.length && next[next.length - 1] !== "") next.push("");
+    next.push(nextLine);
+  }
+  while (next.length > 1 && next[next.length - 1] === "" && next[next.length - 2] === "") next.pop();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${next.join("\n").replace(/\n*$/, "")}\n`, "utf8");
+}
+
+function normalizeAlias(value) {
+  return /^[a-zA-Z0-9_-]+$/.test(value) ? value : null;
+}
+
+function mergeUniqueStrings(current, additions) {
+  const values = Array.isArray(current) ? current : String(current ?? "").split(",");
+  return [...new Set([...values, ...additions].map((value) => String(value).trim()).filter(Boolean))];
+}
+
+function parseEnvLine(line) {
+  const trimmed = String(line ?? "").trim();
+  if (!trimmed || trimmed.startsWith("#")) return null;
+  const eq = trimmed.indexOf("=");
+  if (eq < 1) return null;
+  return { key: trimmed.slice(0, eq).trim() };
+}
+
+function escapeEnvValue(value) {
+  const raw = String(value ?? "");
+  return /^[A-Za-z0-9_./:@-]+$/.test(raw) ? raw : JSON.stringify(raw);
+}
+
+function readLine({ input = process.stdin, output = process.stdout, prompt }) {
+  const rl = createInterface({ input, output });
+  return new Promise((resolve) => rl.question(prompt, (answer) => {
+    rl.close();
+    resolve(answer);
+  }));
+}

package/src/gateway/workspace-command.mjs

@@ -0,0 +1,40 @@
+export function parseWorkspaceCommand(input) {
+  const trimmed = String(input ?? "").trim();
+  if (trimmed === "/workspace") return { type: "show" };
+  if (trimmed === "/workspaces") return { type: "list" };
+  const match = trimmed.match(/^\/workspace\s+set\s+(\S+)$/);
+  if (match) return { type: "set", alias: match[1] };
+  if (trimmed.startsWith("/workspace ")) return { type: "error", message: "Usage: /workspace, /workspaces, or /workspace set <alias>" };
+  return { type: "none" };
+}
+
+export function handleWorkspaceCommand(command, { session, sessionStore }) {
+  if (command.type === "error") return [`Error: ${command.message}`];
+  if (command.type === "show") return [formatCurrentWorkspace(session)];
+  if (command.type === "list") return formatWorkspaceList(sessionStore.listWorkspaces(), session.workspaceAlias);
+  if (command.type === "set") {
+    try {
+      sessionStore.setWorkspace(session, command.alias);
+      return [`Workspace: ${session.workspaceAlias} (${session.workspaceRoot})`];
+    } catch (err) {
+      return [`Error: ${err.message}`];
+    }
+  }
+  return [];
+}
+
+function formatCurrentWorkspace(session) {
+  if (!session.workspaceAlias || !session.workspaceRoot) return "Workspace: not configured";
+  return `Workspace: ${session.workspaceAlias} (${session.workspaceRoot})`;
+}
+
+function formatWorkspaceList(workspaces, currentAlias) {
+  if (workspaces.length === 0) return ["No gateway workspaces configured."];
+  return [
+    "Gateway workspaces:",
+    ...workspaces.map((workspace) => {
+      const marker = workspace.alias === currentAlias ? "*" : " ";
+      return `${marker} ${workspace.alias}: ${workspace.root}`;
+    }),
+  ];
+}

package/src/image-gen/tool.mjs

@@ -1,14 +1,15 @@
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { basename } from "node:path";
+import { sendBinaryOutput } from "../agent/output/binary-output-sink.mjs";
 import { toolText } from "../agent/tool-result.mjs";
-import { openFileWithDefaultApp } from "../platform/open-file.mjs";
 import { generateImage } from "./provider.mjs";
 
 export function createImageGenTool({
   authStorage,
   projectMarchDir,
   generateImageImpl = generateImage,
-  openFileImpl = openFileWithDefaultApp,
+  sendBinary = sendBinaryOutput,
 }) {
   return defineTool({
     name: "image_generate",
@@ -48,7 +49,7 @@ export function createImageGenTool({
       try {
         const { prompt, quality = "medium", aspectRatio = "1:1", auto_open: autoOpen = true } = params;
         const image = await generateImageImpl({ prompt, quality, aspectRatio, authStorage, projectMarchDir });
-        const openResult = autoOpen ? await openGeneratedImage(image.filePath, openFileImpl) : { opened: false };
+        const outputResult = autoOpen ? await deliverGeneratedImage(image, sendBinary) : { opened: false, delivered: false };
         return toolJson({
           success: true,
           image: image.marker,
@@ -57,8 +58,8 @@ export function createImageGenTool({
           prompt,
           aspectRatio,
           quality,
-          ...openResult,
-        }, { ...image, ...openResult });
+          ...outputResult,
+        }, { ...image, ...outputResult });
       } catch (err) {
         return toolJson({
           success: false,
@@ -70,12 +71,18 @@ export function createImageGenTool({
   });
 }
 
-async function openGeneratedImage(filePath, openFileImpl) {
+async function deliverGeneratedImage(image, sendBinary) {
+  const binary = {
+    type: "image",
+    path: image.filePath,
+    filename: basename(image.filePath),
+    mimeType: image.mimeType,
+  };
   try {
-    await openFileImpl(filePath);
-    return { opened: true };
+    const sink = await sendBinary(binary);
+    return { opened: sink?.opened === true, delivered: true, sink };
   } catch (err) {
-    return { opened: false, openError: err.message };
+    return { opened: false, delivered: false, openError: err.message };
   }
 }
 

package/src/lsp/client.mjs

@@ -47,6 +47,7 @@ const LANGUAGE_IDS = {
   ".sass": "sass",
   ".scss": "scss",
   ".sh": "shellscript",
+  ".sql": "sql",
   ".svelte": "svelte",
   ".tf": "terraform",
   ".tfvars": "terraform-vars",