@botcord/daemon 0.2.91 → 0.2.93

package/dist/gateway/channels/botcord.d.ts

@@ -1,5 +1,5 @@
 import WebSocket from "ws";
-import { type InboxMessage } from "@botcord/protocol-core";
+import { type InboxMessage, type MessageAttachment } from "@botcord/protocol-core";
 import type { ChannelAdapter, GatewayInboundMessage, GatewayLogger } from "../index.js";
 /** Minimal surface the adapter needs from `BotCordClient`. Matches the subset used at runtime. */
 export interface BotCordChannelClient {
@@ -16,9 +16,16 @@ export interface BotCordChannelClient {
         has_more: boolean;
     }>;
     ackMessages(messageIds: string[]): Promise<void>;
+    uploadFile?(filePath: string, filename: string, contentType?: string): Promise<{
+        original_filename: string;
+        url: string;
+        content_type?: string;
+        size_bytes?: number;
+    }>;
     sendMessage(to: string, text: string, options?: {
         replyTo?: string;
         topic?: string;
+        attachments?: MessageAttachment[];
     }): Promise<{
         hub_msg_id?: string;
         message_id?: string;
@@ -26,6 +33,7 @@ export interface BotCordChannelClient {
     sendTypedMessage?(to: string, type: "result" | "error", text: string, options?: {
         replyTo?: string;
         topic?: string;
+        attachments?: MessageAttachment[];
     }): Promise<{
         hub_msg_id?: string;
         message_id?: string;

package/dist/gateway/channels/botcord.js

@@ -1,3 +1,4 @@
+import { basename } from "node:path";
 import WebSocket from "ws";
 import { BotCordClient, buildHubWebSocketUrl, defaultCredentialsFile, loadStoredCredentials, updateCredentialsToken, } from "@botcord/protocol-core";
 import { sanitizeUntrustedContent } from "./sanitize.js";
@@ -25,6 +26,54 @@ function isUnclaimedAgentError(err) {
         message.includes("agent_not_claimed_generic") ||
         message.includes("agent_not_claimed"));
 }
+async function uploadOutboundAttachments(client, attachments, log) {
+    if (attachments.length === 0)
+        return { attachments: [], replacements: [] };
+    if (!client.uploadFile) {
+        log.warn("botcord send: outbound attachments skipped because uploadFile is unavailable", {
+            count: attachments.length,
+        });
+        return { attachments: [], replacements: [] };
+    }
+    const uploaded = [];
+    const replacements = [];
+    for (const attachment of attachments) {
+        if (!attachment.filePath) {
+            log.warn("botcord send: attachment without filePath skipped", {
+                filename: attachment.filename ?? null,
+            });
+            continue;
+        }
+        try {
+            const resp = await client.uploadFile(attachment.filePath, attachment.filename ?? basename(attachment.filePath), attachment.contentType);
+            if (attachment.sourcePath) {
+                replacements.push({ sourcePath: attachment.sourcePath, url: resp.url });
+            }
+            uploaded.push({
+                filename: resp.original_filename,
+                url: resp.url,
+                ...(resp.content_type ? { content_type: resp.content_type } : {}),
+                ...(typeof resp.size_bytes === "number" ? { size_bytes: resp.size_bytes } : {}),
+            });
+        }
+        catch (err) {
+            log.warn("botcord send: attachment upload failed; continuing without it", {
+                filename: attachment.filename ?? attachment.filePath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return { attachments: uploaded, replacements };
+}
+function rewriteUploadedAttachmentPaths(text, replacements) {
+    let out = text;
+    for (const { sourcePath, url } of replacements) {
+        if (!sourcePath || !url)
+            continue;
+        out = out.replaceAll(sourcePath, url);
+    }
+    return out;
+}
 /** Default factory: wrap `loadStoredCredentials` + `new BotCordClient`. */
 function defaultClientFactory(input) {
     const credFile = input.credentialsPath ?? defaultCredentialsFile(input.agentId);
@@ -774,9 +823,13 @@ export function createBotCordChannel(options) {
                 options.replyTo = message.replyTo;
             if (message.threadId)
                 options.topic = message.threadId;
+            const upload = await uploadOutboundAttachments(client, message.attachments ?? [], ctx.log);
+            if (upload.attachments.length > 0)
+                options.attachments = upload.attachments;
+            const text = rewriteUploadedAttachmentPaths(message.text, upload.replacements);
             const resp = message.type === "error" && client.sendTypedMessage
-                ? await client.sendTypedMessage(message.conversationId, "error", message.text, options)
-                : await client.sendMessage(message.conversationId, message.text, options);
+                ? await client.sendTypedMessage(message.conversationId, "error", text, options)
+                : await client.sendMessage(message.conversationId, text, options);
             const providerMessageId = (resp && typeof resp.hub_msg_id === "string" && resp.hub_msg_id) ||
                 (resp && typeof resp.message_id === "string"
                     ? resp.message_id

package/dist/gateway/channels/feishu.d.ts

@@ -13,4 +13,60 @@ export interface FeishuChannelOptions {
     stateFile?: string;
     stateDebounceMs?: number;
 }
+interface FeishuEventSender {
+    sender_id?: {
+        open_id?: string;
+        user_id?: string;
+        union_id?: string;
+    };
+    sender_type?: string;
+    tenant_key?: string;
+}
+interface FeishuEventMessage {
+    message_id?: string;
+    root_id?: string;
+    parent_id?: string;
+    create_time?: string;
+    chat_id?: string;
+    chat_type?: string;
+    message_type?: string;
+    content?: string;
+    mentions?: Array<{
+        id?: {
+            open_id?: string;
+            user_id?: string;
+        };
+        name?: string;
+    }>;
+}
+interface FeishuMessageEvent {
+    sender?: FeishuEventSender;
+    message?: FeishuEventMessage;
+}
+export interface FeishuDiscoveredChat {
+    chatId: string;
+    senderOpenId: string;
+    kind: "direct" | "group";
+    label?: string | null;
+    lastSeenAt: number;
+}
+export interface FeishuChatDiscoveryOptions {
+    appId: string;
+    appSecret: string;
+    domain?: FeishuDomain;
+    userOpenId: string;
+    timeoutSeconds?: number;
+    sdkOverride?: {
+        createWsClient(args: Record<string, unknown>): {
+            start(opts: unknown): unknown;
+            close(opts?: unknown): unknown;
+        };
+        createDispatcher(): {
+            register(handlers: Record<string, (data: unknown) => unknown>): void;
+        };
+    };
+}
+export declare function feishuDiscoveryChatFromEvent(event: FeishuMessageEvent, allowedSenderOpenId: string, now?: () => number): FeishuDiscoveredChat | null;
+export declare function discoverFeishuChats(opts: FeishuChatDiscoveryOptions): Promise<FeishuDiscoveredChat[]>;
 export declare function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter;
+export {};

package/dist/gateway/channels/feishu.js

@@ -54,6 +54,82 @@ function senderLabel(event) {
     const hit = mentions.find((m) => m.id?.open_id && m.id.open_id === senderOpenId);
     return typeof hit?.name === "string" && hit.name ? hit.name : undefined;
 }
+export function feishuDiscoveryChatFromEvent(event, allowedSenderOpenId, now = () => Date.now()) {
+    const message = event.message;
+    const senderOpenId = event.sender?.sender_id?.open_id;
+    const chatId = message?.chat_id;
+    if (!message || !senderOpenId || !chatId)
+        return null;
+    if (senderOpenId !== allowedSenderOpenId)
+        return null;
+    const chatType = message.chat_type ?? "";
+    const kind = chatType === "p2p" ? "direct" : "group";
+    const label = senderLabel(event) ?? null;
+    return {
+        chatId,
+        senderOpenId,
+        kind,
+        label,
+        lastSeenAt: Number(message.create_time) || now(),
+    };
+}
+export async function discoverFeishuChats(opts) {
+    const timeoutSeconds = typeof opts.timeoutSeconds === "number"
+        ? Math.min(Math.max(Math.floor(opts.timeoutSeconds), 0), 10)
+        : 0;
+    const chats = new Map();
+    const sdk = Lark;
+    const dispatcher = opts.sdkOverride
+        ? opts.sdkOverride.createDispatcher()
+        : new sdk.EventDispatcher({});
+    dispatcher.register({
+        "im.message.receive_v1": (data) => {
+            const discovered = feishuDiscoveryChatFromEvent(data, opts.userOpenId);
+            if (!discovered)
+                return;
+            const previous = chats.get(discovered.chatId);
+            chats.set(discovered.chatId, {
+                ...previous,
+                ...discovered,
+                label: discovered.label ?? previous?.label ?? null,
+                lastSeenAt: Math.max(previous?.lastSeenAt ?? 0, discovered.lastSeenAt),
+            });
+        },
+    });
+    const wsClientArgs = {
+        appId: opts.appId,
+        appSecret: opts.appSecret,
+        domain: sdkDomain(opts.domain),
+        loggerLevel: sdk.LoggerLevel?.info,
+    };
+    const wsClient = opts.sdkOverride
+        ? opts.sdkOverride.createWsClient(wsClientArgs)
+        : new sdk.WSClient(wsClientArgs);
+    try {
+        const startFailure = Promise.resolve()
+            .then(() => wsClient.start({ eventDispatcher: dispatcher }))
+            .then(() => new Promise(() => { }), (err) => Promise.reject(err));
+        const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+        await Promise.race([startFailure, delay(0)]);
+        await Promise.race([startFailure, delay(timeoutSeconds * 1000)]);
+    }
+    finally {
+        try {
+            const closeResult = wsClient.close({ force: true });
+            if (closeResult &&
+                (typeof closeResult === "object" || typeof closeResult === "function") &&
+                typeof closeResult.then === "function") {
+                void Promise.resolve(closeResult).catch(() => {
+                    // best effort
+                });
+            }
+        }
+        catch {
+            // best effort
+        }
+    }
+    return [...chats.values()].sort((a, b) => b.lastSeenAt - a.lastSeenAt);
+}
 export function createFeishuChannel(opts) {
     const splitAt = opts.splitAt && opts.splitAt > 0 ? opts.splitAt : DEFAULT_SPLIT_AT;
     const allowedSenderIds = new Set((opts.allowedSenderIds ?? []).map(String));

package/dist/gateway/cli-resolver.d.ts

@@ -31,4 +31,5 @@ export declare function buildCliEnv(opts: {
     hubUrl?: string;
     accountId?: string;
     basePath?: string | undefined;
+    waitMarkerFile?: string;
 }): NodeJS.ProcessEnv;

package/dist/gateway/cli-resolver.js

@@ -63,6 +63,8 @@ export function buildCliEnv(opts) {
         env.BOTCORD_HUB = opts.hubUrl;
     if (opts.accountId)
         env.BOTCORD_AGENT_ID = opts.accountId;
+    if (opts.waitMarkerFile)
+        env.BOTCORD_WAIT_FILE = opts.waitMarkerFile;
     const cli = resolveBundledCliBin();
     if (cli) {
         const existing = opts.basePath ?? "";

package/dist/gateway/dispatcher.d.ts

@@ -211,6 +211,26 @@ export declare class Dispatcher {
      */
     private recomposeUserTurn;
     private runTurn;
+    /**
+     * Clear a pending re-wake timer because an external message just arrived on
+     * the queue (it supersedes the scheduled re-wake and restarts the dithering
+     * budget). No-op when the timer-fire path already nulled `q.park` — so a
+     * re-wake does NOT reset the consecutive-park counters, keeping the caps
+     * effective across re-wakes.
+     */
+    private supersedePendingPark;
+    /**
+     * Read the park marker a group-room turn may have written via `botcord wait`
+     * and, if present and within the per-queue caps ({@link MAX_PARKS} /
+     * {@link MAX_WAIT_MS} total), schedule a re-wake that re-dispatches the same
+     * message after the (clamped) wait. A turn that ends without a marker — or in
+     * a non-deferrable room (`waitMarkerFile` unset), or aborted/timed-out —
+     * resets the consecutive-park counters. New messages arriving during the wait
+     * cancel it via {@link supersedePendingPark} (the agent then re-decides with
+     * fresh context). `waitMarkerFile` is the per-queue marker path resolved at
+     * dispatch (undefined when the room is not park-eligible).
+     */
+    private maybeSchedulePark;
     private sendReply;
     private providerReplyTo;
     private emitInbound;

package/dist/gateway/dispatcher.js

@@ -1,7 +1,10 @@
 import { randomUUID } from "node:crypto";
+import { realpathSync, statSync } from "node:fs";
+import path from "node:path";
 import { looksLikeRuntimeAuthFailure } from "./runtime-errors.js";
 import { resolveRoute } from "./router.js";
 import { sessionKey } from "./session-store.js";
+import { clearWaitMarker, consumeWaitMarker, resolveWaitMarkerPath, MAX_WAIT_MS } from "./wait-marker.js";
 import { truncateTextField, } from "./transcript.js";
 const DEFAULT_TURN_TIMEOUT_MS = 30 * 60 * 1000;
 const DEFAULT_RUNTIME_AUTH_FAILURE_THRESHOLD = 3;
@@ -17,6 +20,10 @@ const TRANSCRIPT_BLOCK_RAW_LIMIT = 16 * 1024;
 const SECRET_KEY_RE = /token|secret|private.?key|api.?key|authorization|password/i;
 /** Maximum number of buffered serial entries per queue. Excess entries drop oldest. */
 const MAX_BATCH_BUFFER_ENTRIES = 40;
+/** Max consecutive agent-driven `botcord wait` parks on one queue before the
+ *  next turn is forced to produce a real decision. Total accumulated wait is
+ *  separately bounded by {@link MAX_WAIT_MS}. */
+const MAX_PARKS = 3;
 /**
  * Soft cap on the total characters across raw.batch members in a merged
  * turn. When exceeded, oldest entries are dropped (with a warn log) so the
@@ -38,6 +45,30 @@ const TYPING_DEBOUNCE_MS = 2000;
 const TYPING_REFRESH_MS = 4000;
 /** LRU cap on the typing-recency map so long-running daemons don't grow unbounded. */
 const TYPING_RECENCY_CAP = 1024;
+const AUTO_ATTACHMENT_LIMIT = 10;
+const AUTO_ATTACHMENT_MAX_BYTES = 25 * 1024 * 1024;
+const AUTO_ATTACHMENT_EXTENSIONS = new Set([
+    ".avif",
+    ".bmp",
+    ".csv",
+    ".doc",
+    ".docx",
+    ".gif",
+    ".htm",
+    ".html",
+    ".jpeg",
+    ".jpg",
+    ".pdf",
+    ".png",
+    ".ppt",
+    ".pptx",
+    ".svg",
+    ".webp",
+    ".xls",
+    ".xlsx",
+    ".zip",
+]);
+const REPLY_LOCAL_PATH_RE = /(^|[\s([{"'`])((?:\/|\.{1,2}\/)?(?:[\w@+.-]+\/)+[\w@+.-]+\.(?:avif|bmp|csv|docx?|gif|html?|jpe?g|pdf|png|pptx?|svg|webp|xlsx?|zip))(?=$|[\s)\]}"'`,.!?:;])/gi;
 function transcriptBlocksVerbose() {
     return process.env.BOTCORD_TRANSCRIPT_BLOCKS === "verbose" ||
         process.env.BOTCORD_TRACE_VERBOSE === "1";
@@ -502,6 +533,9 @@ export class Dispatcher {
                 cancelGen: 0,
                 serialBuffer: [],
                 serialWorkerActive: false,
+                park: null,
+                parkCount: 0,
+                parkAccumMs: 0,
             };
             this.queues.set(key, q);
         }
@@ -680,6 +714,7 @@ export class Dispatcher {
     }
     async runCancelPrevious(queueKey, route, text, msg, channel, turnId, mergedFromTurnIds = []) {
         const q = this.getQueue(queueKey);
+        this.supersedePendingPark(q);
         // Bump the generation on every arrival. Older arrivals still awaiting
         // the prior turn's teardown will observe `myGen !== q.cancelGen` when
         // they resume and drop out, so only the newest message reaches runTurn.
@@ -759,6 +794,7 @@ export class Dispatcher {
      */
     async runSerial(queueKey, route, _text, msg, channel, turnId, mergedFromTurnIds = []) {
         const q = this.getQueue(queueKey);
+        this.supersedePendingPark(q);
         q.serialBuffer.push({ route, msg, channel, turnId });
         while (q.serialBuffer.length > MAX_BATCH_BUFFER_ENTRIES) {
             const dropped = q.serialBuffer.shift();
@@ -944,6 +980,20 @@ export class Dispatcher {
             blocks: [],
         };
         q.current = slot;
+        // Agent-driven `botcord wait` is offered only in non-owner BotCord group
+        // rooms (kind === "group"). When eligible, scope the park marker per queue
+        // (concurrent group-room turns share one agent workspace) and expose its
+        // path to the CLI subprocess via `BOTCORD_WAIT_FILE`.
+        const parkEligible = isBotCordChannel(channel) &&
+            !isOwnerChatRoom(msg) &&
+            msg.conversation.kind === "group";
+        const waitMarkerFile = parkEligible
+            ? resolveWaitMarkerPath(route.cwd, queueKey)
+            : undefined;
+        // Drop any stale marker so that whatever `botcord wait` writes during this
+        // turn is unambiguously from this turn (read back in `finally`).
+        if (waitMarkerFile)
+            clearWaitMarker(waitMarkerFile);
         // Dispatched record — marks "this turn entered runtime".
         {
             const composedField = truncateTextField(text);
@@ -1324,6 +1374,7 @@ export class Dispatcher {
                     cwd: route.cwd,
                     accountId: msg.accountId,
                     hubUrl: this.resolveHubUrl?.(msg.accountId),
+                    ...(waitMarkerFile ? { waitMarkerFile } : {}),
                     extraArgs: route.extraArgs,
                     signal: controller.signal,
                     trustLevel,
@@ -1727,12 +1778,25 @@ export class Dispatcher {
             if (controller.signal.aborted && !slot.timedOut) {
                 return;
             }
+            const attachments = (isOwnerChat && isBotCordChannel(channel)
+                ? collectOwnerChatReplyAttachments(replyText, route.cwd)
+                : undefined) ?? [];
+            if (attachments.length > 0) {
+                this.log.info("dispatcher: attaching owner-chat reply artifacts", {
+                    agentId: msg.accountId,
+                    roomId: msg.conversation.id,
+                    topicId: msg.conversation.threadId ?? null,
+                    turnId,
+                    count: attachments.length,
+                });
+            }
             const sendResult = await this.sendReply(channel, {
                 channel: msg.channel,
                 accountId: msg.accountId,
                 conversationId: msg.conversation.id,
                 threadId: msg.conversation.threadId ?? null,
                 text: replyText,
+                attachments: attachments.length > 0 ? attachments : undefined,
                 replyTo: this.providerReplyTo(msg),
                 traceId: msg.trace?.id ?? null,
             }, turnId);
@@ -1763,9 +1827,106 @@ export class Dispatcher {
             // let our abort-checks above drop this turn silently.
             if (q.current === slot)
                 q.current = null;
+            // Agent-driven defer: a group-room turn may have run `botcord wait` to
+            // park its decision. Honor it now (timer lives here, not in the runtime).
+            this.maybeSchedulePark(queueKey, route, msg, channel, slot, controller, waitMarkerFile);
             resolveDone();
         }
     }
+    /**
+     * Clear a pending re-wake timer because an external message just arrived on
+     * the queue (it supersedes the scheduled re-wake and restarts the dithering
+     * budget). No-op when the timer-fire path already nulled `q.park` — so a
+     * re-wake does NOT reset the consecutive-park counters, keeping the caps
+     * effective across re-wakes.
+     */
+    supersedePendingPark(q) {
+        if (!q.park)
+            return;
+        clearTimeout(q.park);
+        q.park = null;
+        q.parkCount = 0;
+        q.parkAccumMs = 0;
+    }
+    /**
+     * Read the park marker a group-room turn may have written via `botcord wait`
+     * and, if present and within the per-queue caps ({@link MAX_PARKS} /
+     * {@link MAX_WAIT_MS} total), schedule a re-wake that re-dispatches the same
+     * message after the (clamped) wait. A turn that ends without a marker — or in
+     * a non-deferrable room (`waitMarkerFile` unset), or aborted/timed-out —
+     * resets the consecutive-park counters. New messages arriving during the wait
+     * cancel it via {@link supersedePendingPark} (the agent then re-decides with
+     * fresh context). `waitMarkerFile` is the per-queue marker path resolved at
+     * dispatch (undefined when the room is not park-eligible).
+     */
+    maybeSchedulePark(queueKey, route, msg, channel, slot, controller, waitMarkerFile) {
+        const q = this.queues.get(queueKey);
+        if (!q)
+            return;
+        if (!waitMarkerFile || slot.timedOut || controller.signal.aborted) {
+            // Not eligible / unclean completion — never honor a marker here.
+            if (waitMarkerFile)
+                clearWaitMarker(waitMarkerFile);
+            q.parkCount = 0;
+            q.parkAccumMs = 0;
+            return;
+        }
+        const marker = consumeWaitMarker(waitMarkerFile);
+        if (!marker) {
+            q.parkCount = 0;
+            q.parkAccumMs = 0;
+            return;
+        }
+        if (q.parkCount >= MAX_PARKS || q.parkAccumMs >= MAX_WAIT_MS) {
+            this.log.info("dispatcher: park request ignored — cap reached", {
+                agentId: msg.accountId,
+                roomId: msg.conversation.id,
+                topicId: msg.conversation.threadId ?? null,
+                queueKey,
+                parkCount: q.parkCount,
+                parkAccumMs: q.parkAccumMs,
+            });
+            q.parkCount = 0;
+            q.parkAccumMs = 0;
+            return;
+        }
+        const remainingBudget = MAX_WAIT_MS - q.parkAccumMs;
+        const waitMs = Math.max(0, Math.min(marker.deadlineMs - Date.now(), remainingBudget));
+        if (waitMs <= 0) {
+            q.parkCount = 0;
+            q.parkAccumMs = 0;
+            return;
+        }
+        q.parkCount += 1;
+        q.parkAccumMs += waitMs;
+        this.log.info("dispatcher: parking group-room turn (botcord wait)", {
+            agentId: msg.accountId,
+            roomId: msg.conversation.id,
+            topicId: msg.conversation.threadId ?? null,
+            queueKey,
+            waitMs,
+            parkCount: q.parkCount,
+            reason: marker.reason ?? null,
+        });
+        const timer = setTimeout(() => {
+            q.park = null;
+            this.log.info("dispatcher: park elapsed — re-waking", {
+                agentId: msg.accountId,
+                roomId: msg.conversation.id,
+                topicId: msg.conversation.threadId ?? null,
+                queueKey,
+            });
+            void this.runSerial(queueKey, route, this.recomposeUserTurn(msg), msg, channel, randomUUID()).catch((err) => {
+                this.log.warn("dispatcher: park re-wake failed", {
+                    queueKey,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            });
+        }, waitMs);
+        if (typeof timer.unref === "function")
+            timer.unref();
+        q.park = timer;
+    }
     async sendReply(channel, outbound, turnId) {
         try {
             await channel.send({ message: outbound, log: this.log });
@@ -1872,6 +2033,97 @@ export class Dispatcher {
 function nowIso() {
     return new Date().toISOString();
 }
+function collectOwnerChatReplyAttachments(text, cwd) {
+    const baseDir = safeRealpath(cwd);
+    if (!baseDir)
+        return undefined;
+    const out = [];
+    const seen = new Set();
+    REPLY_LOCAL_PATH_RE.lastIndex = 0;
+    for (const match of text.matchAll(REPLY_LOCAL_PATH_RE)) {
+        const rawPath = match[2];
+        if (!rawPath || looksLikeUrl(rawPath))
+            continue;
+        const resolved = path.isAbsolute(rawPath)
+            ? path.resolve(rawPath)
+            : path.resolve(baseDir, rawPath);
+        const realPath = safeRealpath(resolved);
+        if (!realPath || seen.has(realPath) || !isPathInside(baseDir, realPath))
+            continue;
+        const ext = path.extname(realPath).toLowerCase();
+        if (!AUTO_ATTACHMENT_EXTENSIONS.has(ext))
+            continue;
+        let size = 0;
+        try {
+            const stat = statSync(realPath);
+            if (!stat.isFile())
+                continue;
+            size = stat.size;
+        }
+        catch {
+            continue;
+        }
+        if (size <= 0 || size > AUTO_ATTACHMENT_MAX_BYTES)
+            continue;
+        const contentType = contentTypeForExtension(ext);
+        out.push({
+            filePath: realPath,
+            filename: path.basename(realPath),
+            sourcePath: rawPath,
+            ...(contentType ? { contentType } : {}),
+            ...(contentType?.startsWith("image/") ? { kind: "image" } : { kind: "file" }),
+        });
+        seen.add(realPath);
+        if (out.length >= AUTO_ATTACHMENT_LIMIT)
+            break;
+    }
+    return out.length > 0 ? out : undefined;
+}
+function safeRealpath(input) {
+    try {
+        return realpathSync(input);
+    }
+    catch {
+        return null;
+    }
+}
+function isPathInside(baseDir, candidate) {
+    const rel = path.relative(baseDir, candidate);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+function looksLikeUrl(value) {
+    return /^[a-z][a-z0-9+.-]*:/i.test(value) || value.startsWith("//");
+}
+function contentTypeForExtension(ext) {
+    switch (ext) {
+        case ".avif":
+            return "image/avif";
+        case ".bmp":
+            return "image/bmp";
+        case ".csv":
+            return "text/csv";
+        case ".gif":
+            return "image/gif";
+        case ".htm":
+        case ".html":
+            return "text/html";
+        case ".jpeg":
+        case ".jpg":
+            return "image/jpeg";
+        case ".pdf":
+            return "application/pdf";
+        case ".png":
+            return "image/png";
+        case ".svg":
+            return "image/svg+xml";
+        case ".webp":
+            return "image/webp";
+        case ".zip":
+            return "application/zip";
+        default:
+            return undefined;
+    }
+}
 function buildQueueKey(msg) {
     const thread = msg.conversation.threadId ?? "";
     return `${msg.channel}:${msg.accountId}:${msg.conversation.id}:${thread}`;

package/dist/gateway/runtimes/codex.js

@@ -251,6 +251,7 @@ export class CodexAdapter extends NdjsonStreamAdapter {
             hubUrl: opts.hubUrl,
             accountId: opts.accountId,
             basePath: process.env.PATH,
+            waitMarkerFile: opts.waitMarkerFile,
         });
         const env = {
             ...process.env,

package/dist/gateway/runtimes/deepseek-tui.js

@@ -184,6 +184,7 @@ export class DeepseekTuiAdapter {
                 hubUrl: opts.hubUrl,
                 accountId: opts.accountId,
                 basePath: process.env.PATH,
+                waitMarkerFile: opts.waitMarkerFile,
             }),
             FORCE_COLOR: "0",
             NO_COLOR: "1",

package/dist/gateway/runtimes/hermes-agent.js

@@ -223,6 +223,7 @@ export class HermesAgentAdapter extends AcpRuntimeAdapter {
             hubUrl: opts.hubUrl,
             accountId: opts.accountId,
             basePath: process.env.PATH,
+            waitMarkerFile: opts.waitMarkerFile,
         });
         const env = {
             ...process.env,

package/dist/gateway/runtimes/kimi.js

@@ -194,6 +194,7 @@ export class KimiAdapter extends NdjsonStreamAdapter {
             hubUrl: opts.hubUrl,
             accountId: opts.accountId,
             basePath: process.env.PATH,
+            waitMarkerFile: opts.waitMarkerFile,
         });
         return {
             ...process.env,

package/dist/gateway/runtimes/ndjson-stream.js

@@ -36,6 +36,7 @@ export class NdjsonStreamAdapter {
                 hubUrl: opts.hubUrl,
                 accountId: opts.accountId,
                 basePath: process.env.PATH,
+                waitMarkerFile: opts.waitMarkerFile,
             }),
         };
     }