@intent-systems/nexus 2026.1.5-3

package/dist/auto-reply/reply/bash-command.js

@@ -0,0 +1,314 @@
+import { getFinishedSession, getSession, markExited } from "../../agents/bash-process-registry.js";
+import { createExecTool } from "../../agents/bash-tools.js";
+import { killProcessTree } from "../../agents/shell-utils.js";
+import { logVerbose } from "../../globals.js";
+import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
+const DEFAULT_FOREGROUND_MS = 2000;
+const MAX_FOREGROUND_MS = 30_000;
+let activeJob = null;
+const trackedSessionIds = new Set();
+function clampNumber(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function resolveForegroundMs(cfg) {
+    const raw = cfg.commands?.bashForegroundMs;
+    if (typeof raw !== "number" || Number.isNaN(raw))
+        return DEFAULT_FOREGROUND_MS;
+    return clampNumber(Math.floor(raw), 0, MAX_FOREGROUND_MS);
+}
+function formatSessionSnippet(sessionId) {
+    const trimmed = sessionId.trim();
+    if (trimmed.length <= 12)
+        return trimmed;
+    return `${trimmed.slice(0, 8)}…`;
+}
+function formatOutputBlock(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return "(no output)";
+    return `\`\`\`txt\n${trimmed}\n\`\`\``;
+}
+function parseBashRequest(raw) {
+    const trimmed = raw.trimStart();
+    let restSource = "";
+    if (trimmed.toLowerCase().startsWith("/bash")) {
+        const match = trimmed.match(/^\/bash(?:\s*:\s*|\s+|$)([\s\S]*)$/i);
+        if (!match)
+            return null;
+        restSource = match[1] ?? "";
+    }
+    else if (trimmed.startsWith("!")) {
+        restSource = trimmed.slice(1);
+        if (restSource.trimStart().startsWith(":")) {
+            restSource = restSource.trimStart().slice(1);
+        }
+    }
+    else {
+        return null;
+    }
+    const rest = restSource.trimStart();
+    if (!rest)
+        return { action: "help" };
+    const tokenMatch = rest.match(/^(\S+)(?:\s+([\s\S]+))?$/);
+    const token = tokenMatch?.[1]?.trim() ?? "";
+    const remainder = tokenMatch?.[2]?.trim() ?? "";
+    const lowered = token.toLowerCase();
+    if (lowered === "poll") {
+        return { action: "poll", sessionId: remainder || undefined };
+    }
+    if (lowered === "stop") {
+        return { action: "stop", sessionId: remainder || undefined };
+    }
+    if (lowered === "help") {
+        return { action: "help" };
+    }
+    return { action: "run", command: rest };
+}
+function resolveRawCommandBody(params) {
+    const source = params.ctx.Body ?? "";
+    const stripped = stripStructuralPrefixes(source);
+    return params.isGroup ? stripMentions(stripped, params.ctx, params.cfg) : stripped;
+}
+function getScopedSession(sessionId) {
+    if (!trackedSessionIds.has(sessionId))
+        return {};
+    const running = getSession(sessionId);
+    if (running)
+        return { running };
+    const finished = getFinishedSession(sessionId);
+    if (finished)
+        return { finished };
+    trackedSessionIds.delete(sessionId);
+    return {};
+}
+function ensureActiveJobState() {
+    if (!activeJob)
+        return null;
+    if (activeJob.state === "starting")
+        return activeJob;
+    const { running, finished } = getScopedSession(activeJob.sessionId);
+    if (running)
+        return activeJob;
+    if (finished) {
+        activeJob = null;
+        return null;
+    }
+    activeJob = null;
+    return null;
+}
+function attachActiveWatcher(sessionId) {
+    if (!activeJob || activeJob.state !== "running")
+        return;
+    if (activeJob.sessionId !== sessionId)
+        return;
+    if (activeJob.watcherAttached)
+        return;
+    const { running } = getScopedSession(sessionId);
+    const child = running?.child;
+    if (!child)
+        return;
+    activeJob.watcherAttached = true;
+    child.once("close", () => {
+        if (activeJob?.state === "running" && activeJob.sessionId === sessionId) {
+            activeJob = null;
+        }
+    });
+}
+function buildUsageReply() {
+    return {
+        text: [
+            "⚙️ Usage:",
+            "- ! <command>",
+            "- !poll | ! poll",
+            "- !stop | ! stop",
+            "- /bash ... (alias; same subcommands as !)",
+        ].join("\n"),
+    };
+}
+function formatElevatedUnavailableMessage(params) {
+    const lines = [];
+    lines.push("elevated is not available right now.");
+    if (params.failures?.length) {
+        lines.push(`Failing gates: ${params.failures.map((f) => `${f.gate} (${f.key})`).join(", ")}`);
+    }
+    lines.push("Fix-it keys:");
+    lines.push("- agent.elevated.enabled");
+    lines.push("- agent.elevated.allowFrom.<channel>");
+    return lines.join("\n");
+}
+export async function handleBashChatCommand(params) {
+    if (params.cfg.commands?.bash !== true) {
+        return {
+            text: "⚠️ bash is disabled. Set commands.bash=true to enable.",
+        };
+    }
+    if (!params.elevated.enabled || !params.elevated.allowed) {
+        return {
+            text: formatElevatedUnavailableMessage({
+                failures: params.elevated.failures,
+            }),
+        };
+    }
+    const rawBody = resolveRawCommandBody({
+        ctx: params.ctx,
+        cfg: params.cfg,
+        isGroup: params.isGroup,
+    }).trim();
+    const request = parseBashRequest(rawBody);
+    if (!request) {
+        return { text: "⚠️ Unrecognized bash request." };
+    }
+    const liveJob = ensureActiveJobState();
+    if (request.action === "help") {
+        return buildUsageReply();
+    }
+    if (request.action === "poll") {
+        const sessionId = request.sessionId?.trim() || (liveJob?.state === "running" ? liveJob.sessionId : "");
+        if (!sessionId) {
+            return { text: "⚙️ No active bash job." };
+        }
+        const { running, finished } = getScopedSession(sessionId);
+        if (running) {
+            attachActiveWatcher(sessionId);
+            const runtimeSec = Math.max(0, Math.floor((Date.now() - running.startedAt) / 1000));
+            const tail = running.tail || "(no output yet)";
+            return {
+                text: [
+                    `⚙️ bash still running (session ${formatSessionSnippet(sessionId)}, ${runtimeSec}s).`,
+                    formatOutputBlock(tail),
+                    "Hint: !stop (or /bash stop)",
+                ].join("\n"),
+            };
+        }
+        if (finished) {
+            if (activeJob?.state === "running" && activeJob.sessionId === sessionId) {
+                activeJob = null;
+            }
+            const exitLabel = finished.exitSignal
+                ? `signal ${String(finished.exitSignal)}`
+                : `code ${String(finished.exitCode ?? 0)}`;
+            const prefix = finished.status === "completed" ? "⚙️" : "⚠️";
+            return {
+                text: [
+                    `${prefix} bash finished (session ${formatSessionSnippet(sessionId)}).`,
+                    `Exit: ${exitLabel}`,
+                    formatOutputBlock(finished.aggregated || finished.tail),
+                ].join("\n"),
+            };
+        }
+        if (activeJob?.state === "running" && activeJob.sessionId === sessionId) {
+            activeJob = null;
+        }
+        return {
+            text: `⚙️ No bash session found for ${formatSessionSnippet(sessionId)}.`,
+        };
+    }
+    if (request.action === "stop") {
+        const sessionId = request.sessionId?.trim() || (liveJob?.state === "running" ? liveJob.sessionId : "");
+        if (!sessionId) {
+            return { text: "⚙️ No active bash job." };
+        }
+        const { running } = getScopedSession(sessionId);
+        if (!running) {
+            if (activeJob?.state === "running" && activeJob.sessionId === sessionId) {
+                activeJob = null;
+            }
+            return {
+                text: `⚙️ No running bash job found for ${formatSessionSnippet(sessionId)}.`,
+            };
+        }
+        if (!running.backgrounded) {
+            return {
+                text: `⚠️ Session ${formatSessionSnippet(sessionId)} is not backgrounded.`,
+            };
+        }
+        const pid = running.pid ?? running.child?.pid;
+        if (pid) {
+            killProcessTree(pid);
+        }
+        markExited(running, null, "SIGKILL", "failed");
+        if (activeJob?.state === "running" && activeJob.sessionId === sessionId) {
+            activeJob = null;
+        }
+        return {
+            text: `⚙️ bash stopped (session ${formatSessionSnippet(sessionId)}).`,
+        };
+    }
+    if (liveJob) {
+        const label = liveJob.state === "running" ? formatSessionSnippet(liveJob.sessionId) : "starting";
+        return {
+            text: `⚠️ A bash job is already running (${label}). Use !poll / !stop (or /bash poll / /bash stop).`,
+        };
+    }
+    const commandText = request.command.trim();
+    if (!commandText)
+        return buildUsageReply();
+    activeJob = {
+        state: "starting",
+        startedAt: Date.now(),
+        command: commandText,
+    };
+    try {
+        const foregroundMs = resolveForegroundMs(params.cfg);
+        const shouldBackgroundImmediately = foregroundMs <= 0;
+        const timeoutSec = params.cfg.agent?.exec?.timeoutSec ?? params.cfg.agent?.bash?.timeoutSec;
+        const execTool = createExecTool({
+            ...(params.cfg.agent?.bash ?? {}),
+            ...(params.cfg.agent?.exec ?? {}),
+            backgroundMs: foregroundMs > 0 ? foregroundMs : undefined,
+            timeoutSec,
+            elevated: {
+                enabled: params.elevated.enabled,
+                allowed: params.elevated.allowed,
+                defaultLevel: "on",
+            },
+        });
+        const result = await execTool.execute("chat-bash", {
+            command: commandText,
+            background: shouldBackgroundImmediately,
+            yieldMs: shouldBackgroundImmediately ? undefined : foregroundMs,
+            timeout: timeoutSec,
+            elevated: true,
+        });
+        if (result.details?.status === "running") {
+            const sessionId = result.details.sessionId;
+            trackedSessionIds.add(sessionId);
+            activeJob = {
+                state: "running",
+                sessionId,
+                startedAt: result.details.startedAt,
+                command: commandText,
+                watcherAttached: false,
+            };
+            attachActiveWatcher(sessionId);
+            const snippet = formatSessionSnippet(sessionId);
+            logVerbose(`Started bash session ${snippet}: ${commandText}`);
+            return {
+                text: `⚙️ bash started (session ${sessionId}). Still running; use !poll / !stop (or /bash poll / /bash stop).`,
+            };
+        }
+        activeJob = null;
+        const exitCode = result.details?.status === "completed" ? result.details.exitCode : 0;
+        const output = result.details?.status === "completed"
+            ? result.details.aggregated
+            : result.content.map((chunk) => (chunk.type === "text" ? chunk.text : "")).join("\n");
+        return {
+            text: [
+                `⚙️ bash: ${commandText}`,
+                `Exit: ${exitCode}`,
+                formatOutputBlock(output || "(no output)"),
+            ].join("\n"),
+        };
+    }
+    catch (err) {
+        activeJob = null;
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            text: [`⚠️ bash failed: ${commandText}`, formatOutputBlock(message)].join("\n"),
+        };
+    }
+}
+export function resetBashChatCommandForTests() {
+    activeJob = null;
+    trackedSessionIds.clear();
+}

package/dist/auto-reply/reply/block-streaming.js

@@ -0,0 +1,34 @@
+import { resolveTextChunkLimit } from "../chunk.js";
+const DEFAULT_BLOCK_STREAM_MIN = 800;
+const DEFAULT_BLOCK_STREAM_MAX = 1200;
+const BLOCK_CHUNK_PROVIDERS = new Set([
+    "whatsapp",
+    "telegram",
+    "discord",
+    "slack",
+    "signal",
+    "imessage",
+    "webchat",
+]);
+function normalizeChunkProvider(provider) {
+    if (!provider)
+        return undefined;
+    const cleaned = provider.trim().toLowerCase();
+    return BLOCK_CHUNK_PROVIDERS.has(cleaned)
+        ? cleaned
+        : undefined;
+}
+export function resolveBlockStreamingChunking(cfg, provider) {
+    const providerKey = normalizeChunkProvider(provider);
+    const textLimit = resolveTextChunkLimit(cfg, providerKey);
+    const chunkCfg = cfg?.agent?.blockStreamingChunk;
+    const maxRequested = Math.max(1, Math.floor(chunkCfg?.maxChars ?? DEFAULT_BLOCK_STREAM_MAX));
+    const maxChars = Math.max(1, Math.min(maxRequested, textLimit));
+    const minRequested = Math.max(1, Math.floor(chunkCfg?.minChars ?? DEFAULT_BLOCK_STREAM_MIN));
+    const minChars = Math.min(minRequested, maxChars);
+    const breakPreference = chunkCfg?.breakPreference === "newline" ||
+        chunkCfg?.breakPreference === "sentence"
+        ? chunkCfg.breakPreference
+        : "paragraph";
+    return { minChars, maxChars, breakPreference };
+}

package/dist/auto-reply/reply/body.js

@@ -0,0 +1,29 @@
+import { saveSessionStore } from "../../config/sessions.js";
+import { setAbortMemory } from "./abort.js";
+export async function applySessionHints(params) {
+    let prefixedBodyBase = params.baseBody;
+    const abortedHint = params.abortedLastRun
+        ? "Note: The previous agent run was aborted by the user. Resume carefully or ask for clarification."
+        : "";
+    if (abortedHint) {
+        prefixedBodyBase = `${abortedHint}\n\n${prefixedBodyBase}`;
+        if (params.sessionEntry && params.sessionStore && params.sessionKey) {
+            params.sessionEntry.abortedLastRun = false;
+            params.sessionEntry.updatedAt = Date.now();
+            params.sessionStore[params.sessionKey] = params.sessionEntry;
+            if (params.storePath) {
+                await saveSessionStore(params.storePath, params.sessionStore);
+            }
+        }
+        else if (params.abortKey) {
+            setAbortMemory(params.abortKey, false);
+        }
+    }
+    const messageIdHint = params.messageId?.trim()
+        ? `[message_id: ${params.messageId.trim()}]`
+        : "";
+    if (messageIdHint) {
+        prefixedBodyBase = `${prefixedBodyBase}\n${messageIdHint}`;
+    }
+    return prefixedBodyBase;
+}