clawdbot 2026.1.4 → 2026.1.5-1

package/dist/discord/monitor.js

@@ -1,11 +1,11 @@
-import { ApplicationCommandOptionType, ChannelType, Client, Events, GatewayIntentBits, MessageType, Partials, } from "discord.js";
+import { ChannelType, Client, Events, GatewayIntentBits, MessageType, Partials, } from "discord.js";
 import { chunkText, resolveTextChunkLimit } from "../auto-reply/chunk.js";
+import { hasControlCommand } from "../auto-reply/command-detection.js";
 import { formatAgentEnvelope } from "../auto-reply/envelope.js";
 import { getReplyFromConfig } from "../auto-reply/reply.js";
-import { SILENT_REPLY_TOKEN } from "../auto-reply/tokens.js";
 import { loadConfig } from "../config/config.js";
-import { resolveStorePath, updateLastRoute } from "../config/sessions.js";
-import { danger, logVerbose, shouldLogVerbose, warn } from "../globals.js";
+import { resolveSessionKey, resolveStorePath, updateLastRoute, } from "../config/sessions.js";
+import { danger, logVerbose, shouldLogVerbose } from "../globals.js";
 import { enqueueSystemEvent } from "../infra/system-events.js";
 import { getChildLogger } from "../logging.js";
 import { detectMime } from "../media/mime.js";
@@ -56,7 +56,6 @@ export async function monitorDiscordProvider(opts = {}) {
     const dmConfig = cfg.discord?.dm;
     const guildEntries = cfg.discord?.guilds;
     const allowFrom = dmConfig?.allowFrom;
-    const slashCommand = resolveSlashCommandConfig(opts.slashCommand ?? cfg.discord?.slashCommand);
     const mediaMaxBytes = (opts.mediaMaxMb ?? cfg.discord?.mediaMaxMb ?? 8) * 1024 * 1024;
     const textLimit = resolveTextChunkLimit(cfg, "discord");
     const historyLimit = Math.max(0, opts.historyLimit ?? cfg.discord?.historyLimit ?? 20);
@@ -87,9 +86,6 @@ export async function monitorDiscordProvider(opts = {}) {
     const guildHistories = new Map();
     client.once(Events.ClientReady, () => {
         runtime.log?.(`logged in as ${client.user?.tag ?? "unknown"}`);
-        if (slashCommand.enabled) {
-            void ensureSlashCommand(client, slashCommand, runtime);
-        }
     });
     client.on(Events.Error, (err) => {
         runtime.error?.(danger(`client error: ${String(err)}`));
@@ -182,8 +178,24 @@ export async function monitorDiscordProvider(opts = {}) {
                 guildHistories.set(message.channelId, history);
             }
             const resolvedRequireMention = channelConfig?.requireMention ?? guildInfo?.requireMention ?? true;
+            const hasAnyMention = Boolean(!isDirectMessage &&
+                (message.mentions?.everyone ||
+                    (message.mentions?.users?.size ?? 0) > 0 ||
+                    (message.mentions?.roles?.size ?? 0) > 0));
+            const commandAuthorized = resolveDiscordCommandAuthorized({
+                isDirectMessage,
+                allowFrom,
+                guildInfo,
+                author: message.author,
+            });
+            const shouldBypassMention = isGuildMessage &&
+                resolvedRequireMention &&
+                !wasMentioned &&
+                !hasAnyMention &&
+                commandAuthorized &&
+                hasControlCommand(baseText);
             if (isGuildMessage && resolvedRequireMention) {
-                if (botId && !wasMentioned) {
+                if (botId && !wasMentioned && !shouldBypassMention) {
                     logVerbose(`discord: drop guild message (mention required, botId=${botId})`);
                     logger.info({
                         channelId: message.channelId,
@@ -229,7 +241,18 @@ export async function monitorDiscordProvider(opts = {}) {
             }
             const systemText = resolveDiscordSystemEvent(message);
             if (systemText) {
+                const sessionCfg = cfg.session;
+                const sessionScope = sessionCfg?.scope ?? "per-sender";
+                const mainKey = (sessionCfg?.mainKey ?? "main").trim() || "main";
+                const sessionKey = resolveSessionKey(sessionScope, {
+                    From: isDirectMessage
+                        ? `discord:${message.author.id}`
+                        : `group:${message.channelId}`,
+                    ChatType: isDirectMessage ? "direct" : "group",
+                    Surface: "discord",
+                }, mainKey);
                 enqueueSystemEvent(systemText, {
+                    sessionKey,
                     contextKey: `discord:system:${message.channelId}:${message.id}`,
                 });
                 return;
@@ -323,11 +346,14 @@ export async function monitorDiscordProvider(opts = {}) {
                     : `channel:${message.channelId}`,
                 ChatType: isDirectMessage ? "direct" : "group",
                 SenderName: message.member?.displayName ?? message.author.tag,
+                SenderId: message.author.id,
                 SenderUsername: message.author.username,
                 SenderTag: message.author.tag,
                 GroupSubject: groupSubject,
                 GroupRoom: groupRoom,
-                GroupSpace: isGuildMessage ? guildSlug || undefined : undefined,
+                GroupSpace: isGuildMessage
+                    ? (guildInfo?.id ?? guildSlug) || undefined
+                    : undefined,
                 Surface: "discord",
                 WasMentioned: wasMentioned,
                 MessageSid: message.id,
@@ -335,6 +361,7 @@ export async function monitorDiscordProvider(opts = {}) {
                 MediaPath: media?.path,
                 MediaType: media?.contentType,
                 MediaUrl: media?.path,
+                CommandAuthorized: commandAuthorized,
             };
             const replyTarget = ctxPayload.To ?? undefined;
             if (!replyTarget) {
@@ -482,7 +509,16 @@ export async function monitorDiscordProvider(opts = {}) {
             const authorLabel = message.author?.tag ?? message.author?.username;
             const baseText = `Discord reaction ${action}: ${emojiLabel} by ${actorLabel} on ${guildSlug} ${channelLabel} msg ${message.id}`;
             const text = authorLabel ? `${baseText} from ${authorLabel}` : baseText;
+            const sessionCfg = cfg.session;
+            const sessionScope = sessionCfg?.scope ?? "per-sender";
+            const mainKey = (sessionCfg?.mainKey ?? "main").trim() || "main";
+            const sessionKey = resolveSessionKey(sessionScope, {
+                From: `group:${message.channelId}`,
+                ChatType: "group",
+                Surface: "discord",
+            }, mainKey);
             enqueueSystemEvent(text, {
+                sessionKey,
                 contextKey: `discord:reaction:${action}:${message.id}:${user.id}:${emojiLabel}`,
             });
         }
@@ -496,162 +532,6 @@ export async function monitorDiscordProvider(opts = {}) {
     client.on(Events.MessageReactionRemove, async (reaction, user) => {
         await handleReactionEvent(reaction, user, "removed");
     });
-    client.on(Events.InteractionCreate, async (interaction) => {
-        try {
-            if (!slashCommand.enabled)
-                return;
-            if (!interaction.isChatInputCommand())
-                return;
-            if (interaction.commandName !== slashCommand.name)
-                return;
-            if (interaction.user?.bot)
-                return;
-            const channelType = interaction.channel?.type;
-            const isGroupDm = channelType === ChannelType.GroupDM;
-            const isDirectMessage = !interaction.inGuild() && channelType === ChannelType.DM;
-            const isGuildMessage = interaction.inGuild();
-            if (isGroupDm && !groupDmEnabled) {
-                logVerbose("discord: drop slash (group dms disabled)");
-                return;
-            }
-            if (isDirectMessage && !dmEnabled) {
-                logVerbose("discord: drop slash (dms disabled)");
-                return;
-            }
-            if (shouldLogVerbose()) {
-                logVerbose(`discord: slash inbound guild=${interaction.guildId ?? "dm"} channel=${interaction.channelId} type=${isDirectMessage ? "dm" : isGroupDm ? "group-dm" : "guild"}`);
-            }
-            if (isGuildMessage) {
-                const guildInfo = resolveDiscordGuildEntry({
-                    guild: interaction.guild ?? null,
-                    guildEntries,
-                });
-                if (guildEntries &&
-                    Object.keys(guildEntries).length > 0 &&
-                    !guildInfo) {
-                    logVerbose(`Blocked discord guild ${interaction.guildId ?? "unknown"} (not in discord.guilds)`);
-                    return;
-                }
-                const channelName = interaction.channel &&
-                    "name" in interaction.channel &&
-                    typeof interaction.channel.name === "string"
-                    ? interaction.channel.name
-                    : undefined;
-                const channelSlug = channelName
-                    ? normalizeDiscordSlug(channelName)
-                    : "";
-                const channelConfig = resolveDiscordChannelConfig({
-                    guildInfo,
-                    channelId: interaction.channelId,
-                    channelName,
-                    channelSlug,
-                });
-                if (channelConfig?.allowed === false) {
-                    logVerbose(`Blocked discord channel ${interaction.channelId} not in guild channel allowlist`);
-                    return;
-                }
-                const userAllow = guildInfo?.users;
-                if (Array.isArray(userAllow) && userAllow.length > 0) {
-                    const users = normalizeDiscordAllowList(userAllow, [
-                        "discord:",
-                        "user:",
-                    ]);
-                    const userOk = !users ||
-                        allowListMatches(users, {
-                            id: interaction.user.id,
-                            name: interaction.user.username,
-                            tag: interaction.user.tag,
-                        });
-                    if (!userOk) {
-                        logVerbose(`Blocked discord guild sender ${interaction.user.id} (not in guild users allowlist)`);
-                        return;
-                    }
-                }
-            }
-            else if (isGroupDm) {
-                const channelName = interaction.channel &&
-                    "name" in interaction.channel &&
-                    typeof interaction.channel.name === "string"
-                    ? interaction.channel.name
-                    : undefined;
-                const channelSlug = channelName
-                    ? normalizeDiscordSlug(channelName)
-                    : "";
-                const groupDmAllowed = resolveGroupDmAllow({
-                    channels: groupDmChannels,
-                    channelId: interaction.channelId,
-                    channelName,
-                    channelSlug,
-                });
-                if (!groupDmAllowed)
-                    return;
-            }
-            else if (isDirectMessage) {
-                if (Array.isArray(allowFrom) && allowFrom.length > 0) {
-                    const allowList = normalizeDiscordAllowList(allowFrom, [
-                        "discord:",
-                        "user:",
-                    ]);
-                    const permitted = allowList &&
-                        allowListMatches(allowList, {
-                            id: interaction.user.id,
-                            name: interaction.user.username,
-                            tag: interaction.user.tag,
-                        });
-                    if (!permitted) {
-                        logVerbose(`Blocked unauthorized discord sender ${interaction.user.id} (not in allowFrom)`);
-                        return;
-                    }
-                }
-            }
-            const prompt = resolveSlashPrompt(interaction.options.data);
-            if (!prompt) {
-                await interaction.reply({
-                    content: "Message required.",
-                    ephemeral: true,
-                });
-                return;
-            }
-            await interaction.deferReply({ ephemeral: slashCommand.ephemeral });
-            const userId = interaction.user.id;
-            const ctxPayload = {
-                Body: prompt,
-                From: `discord:${userId}`,
-                To: `slash:${userId}`,
-                ChatType: "direct",
-                SenderName: interaction.user.username,
-                Surface: "discord",
-                WasMentioned: true,
-                MessageSid: interaction.id,
-                Timestamp: interaction.createdTimestamp,
-                SessionKey: `${slashCommand.sessionPrefix}:${userId}`,
-            };
-            const replyResult = await getReplyFromConfig(ctxPayload, undefined, cfg);
-            const replies = replyResult
-                ? Array.isArray(replyResult)
-                    ? replyResult
-                    : [replyResult]
-                : [];
-            await deliverSlashReplies({
-                replies,
-                interaction,
-                ephemeral: slashCommand.ephemeral,
-                textLimit,
-            });
-        }
-        catch (err) {
-            runtime.error?.(danger(`slash handler failed: ${String(err)}`));
-            if (interaction.isRepliable()) {
-                const content = "Sorry, something went wrong handling that command.";
-                if (interaction.deferred || interaction.replied) {
-                    await interaction.followUp({ content, ephemeral: true });
-                }
-                else {
-                    await interaction.reply({ content, ephemeral: true });
-                }
-            }
-        }
-    });
     await client.login(token);
     await new Promise((resolve, reject) => {
         const onAbort = () => {
@@ -914,6 +794,35 @@ export function allowListMatches(allowList, candidates) {
         return true;
     return false;
 }
+function resolveDiscordCommandAuthorized(params) {
+    const { isDirectMessage, allowFrom, guildInfo, author } = params;
+    if (isDirectMessage) {
+        if (!Array.isArray(allowFrom) || allowFrom.length === 0)
+            return true;
+        const allowList = normalizeDiscordAllowList(allowFrom, [
+            "discord:",
+            "user:",
+        ]);
+        if (!allowList)
+            return true;
+        return allowListMatches(allowList, {
+            id: author.id,
+            name: author.username,
+            tag: author.tag,
+        });
+    }
+    const users = guildInfo?.users;
+    if (!Array.isArray(users) || users.length === 0)
+        return true;
+    const allowList = normalizeDiscordAllowList(users, ["discord:", "user:"]);
+    if (!allowList)
+        return true;
+    return allowListMatches(allowList, {
+        id: author.id,
+        name: author.username,
+        tag: author.tag,
+    });
+}
 export function shouldEmitDiscordReactionNotification(params) {
     const { mode, botId, messageAuthorId, userId, userName, userTag, allowlist } = params;
     const effectiveMode = mode ?? "own";
@@ -1027,75 +936,6 @@ export function resolveGroupDmAllow(params) {
         name: channelSlug || channelName,
     });
 }
-async function ensureSlashCommand(client, slashCommand, runtime) {
-    try {
-        const appCommands = client.application?.commands;
-        if (!appCommands) {
-            runtime.error?.(danger("discord slash commands unavailable"));
-            return;
-        }
-        const existing = await appCommands.fetch();
-        const hasCommand = Array.from(existing.values()).some((entry) => entry.name === slashCommand.name);
-        if (hasCommand)
-            return;
-        await appCommands.create({
-            name: slashCommand.name,
-            description: "Ask Clawdbot a question",
-            options: [
-                {
-                    name: "prompt",
-                    description: "What should Clawdbot help with?",
-                    type: ApplicationCommandOptionType.String,
-                    required: true,
-                },
-            ],
-        });
-        runtime.log?.(`registered discord slash command /${slashCommand.name}`);
-    }
-    catch (err) {
-        const status = err?.status;
-        const code = err?.code;
-        const message = String(err);
-        const isRateLimit = status === 429 || code === 429 || /rate ?limit/i.test(message);
-        const text = `discord slash command setup failed: ${message}`;
-        if (isRateLimit) {
-            logVerbose(text);
-            runtime.error?.(warn(text));
-        }
-        else {
-            runtime.error?.(danger(text));
-        }
-    }
-}
-function resolveSlashCommandConfig(raw) {
-    return {
-        enabled: raw ? raw.enabled !== false : false,
-        name: raw?.name?.trim() || "clawd",
-        sessionPrefix: raw?.sessionPrefix?.trim() || "discord:slash",
-        ephemeral: raw?.ephemeral !== false,
-    };
-}
-function resolveSlashPrompt(options) {
-    const direct = findFirstStringOption(options);
-    if (direct)
-        return direct;
-    return undefined;
-}
-function findFirstStringOption(options) {
-    for (const option of options) {
-        if (typeof option.value === "string") {
-            const trimmed = option.value.trim();
-            if (trimmed)
-                return trimmed;
-        }
-        if (option.options && option.options.length > 0) {
-            const nested = findFirstStringOption(option.options);
-            if (nested)
-                return nested;
-        }
-    }
-    return undefined;
-}
 async function sendTyping(message) {
     try {
         const channel = message.channel;
@@ -1155,34 +995,3 @@ async function deliverReplies({ replies, target, token, runtime, replyToMode, te
         runtime.log?.(`delivered reply to ${target}`);
     }
 }
-async function deliverSlashReplies({ replies, interaction, ephemeral, textLimit, }) {
-    const messages = [];
-    const chunkLimit = Math.min(textLimit, 2000);
-    for (const payload of replies) {
-        const textRaw = payload.text?.trim() ?? "";
-        const text = textRaw && textRaw !== SILENT_REPLY_TOKEN ? textRaw : undefined;
-        const mediaList = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
-        const combined = [
-            text ?? "",
-            ...mediaList.map((url) => url.trim()).filter(Boolean),
-        ]
-            .filter(Boolean)
-            .join("\n");
-        if (!combined)
-            continue;
-        for (const chunk of chunkText(combined, chunkLimit)) {
-            messages.push(chunk);
-        }
-    }
-    if (messages.length === 0) {
-        await interaction.editReply({
-            content: "No response was generated for that command.",
-        });
-        return;
-    }
-    const [first, ...rest] = messages;
-    await interaction.editReply({ content: first });
-    for (const message of rest) {
-        await interaction.followUp({ content: message, ephemeral });
-    }
-}

package/dist/entry.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { applyCliProfileEnv, parseCliProfileArgs } from "./cli/profile.js";
+const parsed = parseCliProfileArgs(process.argv);
+if (!parsed.ok) {
+    // Keep it simple; Commander will handle rich help/errors after we strip flags.
+    console.error(`[clawdbot] ${parsed.error}`);
+    process.exit(2);
+}
+if (parsed.profile) {
+    applyCliProfileEnv({ profile: parsed.profile });
+    // Keep Commander and ad-hoc argv checks consistent.
+    process.argv = parsed.argv;
+}
+const { runCli } = await import("./cli/run-main.js");
+await runCli(process.argv);

package/dist/gateway/call.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { loadConfig, resolveGatewayPort } from "../config/config.js";
+import { pickPrimaryTailnetIPv4 } from "../infra/tailnet.js";
 import { GatewayClient } from "./client.js";
 import { PROTOCOL_VERSION } from "./protocol/index.js";
 export async function callGateway(opts) {
@@ -9,13 +10,19 @@ export async function callGateway(opts) {
     const remote = isRemoteMode ? config.gateway?.remote : undefined;
     const authToken = config.gateway?.auth?.token;
     const localPort = resolveGatewayPort(config);
+    const tailnetIPv4 = pickPrimaryTailnetIPv4();
+    const bindMode = config.gateway?.bind ?? "loopback";
+    const preferTailnet = bindMode === "tailnet" || (bindMode === "auto" && !!tailnetIPv4);
+    const localUrl = preferTailnet && tailnetIPv4
+        ? `ws://${tailnetIPv4}:${localPort}`
+        : `ws://127.0.0.1:${localPort}`;
     const url = (typeof opts.url === "string" && opts.url.trim().length > 0
         ? opts.url.trim()
         : undefined) ||
         (typeof remote?.url === "string" && remote.url.trim().length > 0
             ? remote.url.trim()
             : undefined) ||
-        `ws://127.0.0.1:${localPort}`;
+        localUrl;
     const token = (typeof opts.token === "string" && opts.token.trim().length > 0
         ? opts.token.trim()
         : undefined) ||

package/dist/gateway/server-methods/chat.js

@@ -79,7 +79,7 @@ export const chatHandlers = {
         context.bridgeSendToSession(sessionKey, "chat", payload);
         respond(true, { ok: true, aborted: true });
     },
-    "chat.send": async ({ params, respond, context, client: _client, isWebchatConnect: _isWebchatConnect, }) => {
+    "chat.send": async ({ params, respond, context }) => {
         if (!validateChatSendParams(params)) {
             respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid chat.send params: ${formatValidationErrors(validateChatSendParams.errors)}`));
             return;

package/dist/gateway/server.js

@@ -10,6 +10,7 @@ import { createCanvasHostHandler, startCanvasHost, } from "../canvas-host/server
 import { createDefaultDeps } from "../cli/deps.js";
 import { getHealthSnapshot } from "../commands/health.js";
 import { CONFIG_PATH_CLAWDBOT, isNixMode, loadConfig, migrateLegacyConfig, readConfigFileSnapshot, STATE_DIR_CLAWDBOT, writeConfigFile, } from "../config/config.js";
+import { deriveDefaultBridgePort, deriveDefaultCanvasHostPort, } from "../config/port-defaults.js";
 import { loadSessionStore, resolveStorePath } from "../config/sessions.js";
 import { runCronIsolatedAgentTurn } from "../cron/isolated-agent.js";
 import { appendCronRunLog, resolveCronRunLogPath } from "../cron/run-log.js";
@@ -195,6 +196,8 @@ async function refreshHealthSnapshot(_opts) {
     return healthRefresh;
 }
 export async function startGatewayServer(port = 18789, opts = {}) {
+    // Ensure all default port derivations (browser/bridge/canvas) see the actual runtime port.
+    process.env.CLAWDBOT_GATEWAY_PORT = String(port);
     const configSnapshot = await readConfigFileSnapshot();
     if (configSnapshot.legacyIssues.length > 0) {
         if (isNixMode) {
@@ -559,9 +562,11 @@ export async function startGatewayServer(port = 18789, opts = {}) {
         }
         if (process.env.CLAWDBOT_BRIDGE_PORT !== undefined) {
             const parsed = Number.parseInt(process.env.CLAWDBOT_BRIDGE_PORT, 10);
-            return Number.isFinite(parsed) && parsed > 0 ? parsed : 18790;
+            return Number.isFinite(parsed) && parsed > 0
+                ? parsed
+                : deriveDefaultBridgePort(port);
         }
-        return 18790;
+        return deriveDefaultBridgePort(port);
     })();
     const bridgeHost = (() => {
         // Back-compat: allow an env var override when no bind policy is configured.
@@ -586,10 +591,16 @@ export async function startGatewayServer(port = 18789, opts = {}) {
         return "0.0.0.0";
     })();
     const canvasHostPort = (() => {
+        if (process.env.CLAWDBOT_CANVAS_HOST_PORT !== undefined) {
+            const parsed = Number.parseInt(process.env.CLAWDBOT_CANVAS_HOST_PORT, 10);
+            if (Number.isFinite(parsed) && parsed > 0)
+                return parsed;
+            return deriveDefaultCanvasHostPort(port);
+        }
         const configured = cfgAtStart.canvasHost?.port;
         if (typeof configured === "number" && configured > 0)
             return configured;
-        return 18793;
+        return deriveDefaultCanvasHostPort(port);
     })();
     if (canvasHostEnabled && bridgeEnabled && bridgeHost) {
         try {

package/dist/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import dotenv from "dotenv";
 import { getReplyFromConfig } from "./auto-reply/reply.js";
 import { applyTemplate } from "./auto-reply/templating.js";
 import { createDefaultDeps } from "./cli/deps.js";
@@ -10,6 +9,7 @@ import { waitForever } from "./cli/wait.js";
 import { loadConfig } from "./config/config.js";
 import { deriveSessionKey, loadSessionStore, resolveSessionKey, resolveStorePath, saveSessionStore, } from "./config/sessions.js";
 import { ensureBinary } from "./infra/binaries.js";
+import { loadDotEnv } from "./infra/dotenv.js";
 import { normalizeEnv } from "./infra/env.js";
 import { isMainModule } from "./infra/is-main.js";
 import { ensureClawdbotCliOnPath } from "./infra/path-env.js";
@@ -19,7 +19,7 @@ import { enableConsoleCapture } from "./logging.js";
 import { runCommandWithTimeout, runExec } from "./process/exec.js";
 import { monitorWebProvider } from "./provider-web.js";
 import { assertProvider, normalizeE164, toWhatsappJid } from "./utils.js";
-dotenv.config({ quiet: true });
+loadDotEnv({ quiet: true });
 normalizeEnv();
 ensureClawdbotCliOnPath();
 // Capture all console output into structured logs while keeping stdout/stderr behavior.

package/dist/infra/control-ui-assets.js

@@ -0,0 +1,118 @@
+import fs from "node:fs";
+import path from "node:path";
+import { runCommandWithTimeout, runExec } from "../process/exec.js";
+import { defaultRuntime } from "../runtime.js";
+export function resolveControlUiRepoRoot(argv1 = process.argv[1]) {
+    if (!argv1)
+        return null;
+    const normalized = path.resolve(argv1);
+    const parts = normalized.split(path.sep);
+    const srcIndex = parts.lastIndexOf("src");
+    if (srcIndex !== -1) {
+        const root = parts.slice(0, srcIndex).join(path.sep);
+        if (fs.existsSync(path.join(root, "ui", "vite.config.ts")))
+            return root;
+    }
+    let dir = path.dirname(normalized);
+    for (let i = 0; i < 8; i++) {
+        if (fs.existsSync(path.join(dir, "package.json")) &&
+            fs.existsSync(path.join(dir, "ui", "vite.config.ts"))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+export function resolveControlUiDistIndexPath(argv1 = process.argv[1]) {
+    if (!argv1)
+        return null;
+    const normalized = path.resolve(argv1);
+    const distDir = path.dirname(normalized);
+    if (path.basename(distDir) !== "dist")
+        return null;
+    return path.join(distDir, "control-ui", "index.html");
+}
+function summarizeCommandOutput(text) {
+    const lines = text
+        .split(/\r?\n/g)
+        .map((l) => l.trim())
+        .filter(Boolean);
+    if (!lines.length)
+        return undefined;
+    const last = lines.at(-1);
+    if (!last)
+        return undefined;
+    return last.length > 240 ? `${last.slice(0, 239)}…` : last;
+}
+export async function ensureControlUiAssetsBuilt(runtime = defaultRuntime, opts) {
+    const indexFromDist = resolveControlUiDistIndexPath(process.argv[1]);
+    if (indexFromDist && fs.existsSync(indexFromDist)) {
+        return { ok: true, built: false };
+    }
+    const repoRoot = resolveControlUiRepoRoot(process.argv[1]);
+    if (!repoRoot) {
+        const hint = indexFromDist
+            ? `Missing Control UI assets at ${indexFromDist}`
+            : "Missing Control UI assets";
+        return {
+            ok: false,
+            built: false,
+            message: `${hint}. Build them with \`pnpm ui:build\`.`,
+        };
+    }
+    const indexPath = path.join(repoRoot, "dist", "control-ui", "index.html");
+    if (fs.existsSync(indexPath)) {
+        return { ok: true, built: false };
+    }
+    const pnpmWhich = process.platform === "win32" ? "where" : "which";
+    const pnpm = await runExec(pnpmWhich, ["pnpm"])
+        .then((r) => r.stdout
+        .split(/\r?\n/g)
+        .map((l) => l.trim())
+        .find(Boolean) ?? "")
+        .catch(() => "");
+    if (!pnpm) {
+        return {
+            ok: false,
+            built: false,
+            message: "Control UI assets not found and pnpm missing. Install pnpm, then run `pnpm ui:build`.",
+        };
+    }
+    runtime.log("Control UI assets missing; building (pnpm ui:build)…");
+    const ensureInstalled = !fs.existsSync(path.join(repoRoot, "ui", "node_modules"));
+    if (ensureInstalled) {
+        const install = await runCommandWithTimeout([pnpm, "ui:install"], {
+            cwd: repoRoot,
+            timeoutMs: opts?.timeoutMs ?? 10 * 60_000,
+        });
+        if (install.code !== 0) {
+            return {
+                ok: false,
+                built: false,
+                message: `Control UI install failed: ${summarizeCommandOutput(install.stderr) ?? `exit ${install.code}`}`,
+            };
+        }
+    }
+    const build = await runCommandWithTimeout([pnpm, "ui:build"], {
+        cwd: repoRoot,
+        timeoutMs: opts?.timeoutMs ?? 10 * 60_000,
+    });
+    if (build.code !== 0) {
+        return {
+            ok: false,
+            built: false,
+            message: `Control UI build failed: ${summarizeCommandOutput(build.stderr) ?? `exit ${build.code}`}`,
+        };
+    }
+    if (!fs.existsSync(indexPath)) {
+        return {
+            ok: false,
+            built: true,
+            message: `Control UI build completed but ${indexPath} is still missing.`,
+        };
+    }
+    return { ok: true, built: true };
+}