@inline-openclaw/inline 0.0.36 → 0.0.38

package/dist/channel-plugin-api.js

@@ -11324,7 +11324,8 @@ class UpdateDialogOrderInput$Type extends import_runtime4.MessageType {
     super("UpdateDialogOrderInput", [
       { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
       { no: 2, name: "order", kind: "scalar", opt: true, T: 9 },
-      { no: 3, name: "pinned_order", kind: "scalar", opt: true, T: 9 }
+      { no: 3, name: "pinned_order", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "pinned", kind: "scalar", opt: true, T: 8 }
     ]);
   }
   create(value) {
@@ -11347,6 +11348,9 @@ class UpdateDialogOrderInput$Type extends import_runtime4.MessageType {
         case 3:
           message.pinnedOrder = reader.string();
           break;
+        case 4:
+          message.pinned = reader.bool();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -11365,6 +11369,8 @@ class UpdateDialogOrderInput$Type extends import_runtime4.MessageType {
       writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.order);
     if (message.pinnedOrder !== undefined)
       writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.pinnedOrder);
+    if (message.pinned !== undefined)
+      writer.tag(4, import_runtime.WireType.Varint).bool(message.pinned);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -35756,6 +35762,7 @@ import {
   buildCommandTextFromArgs,
   findCommandByNativeName,
   formatCommandArgMenuTitle,
+  listNativeCommandSpecsForConfig as listNativeCommandSpecsForConfig2,
   parseCommandArgs,
   resolveCommandArgMenu
 } from "openclaw/plugin-sdk/native-command-registry";
@@ -35789,7 +35796,8 @@ import {
   updateSessionStore
 } from "openclaw/plugin-sdk/config-runtime";
 import { buildModelsProviderData } from "openclaw/plugin-sdk/models-provider-runtime";
-import { listSkillCommandsForAgents } from "openclaw/plugin-sdk/skill-commands-runtime";
+import { listSkillCommandsForAgents as listSkillCommandsForAgents2 } from "openclaw/plugin-sdk/skill-commands-runtime";
+import { getPluginCommandSpecs as getPluginCommandSpecs2 } from "openclaw/plugin-sdk/plugin-runtime";
 import { isReasoningReplyPayload } from "openclaw/plugin-sdk/reply-payload";
 import {
   findCodeRegions,
@@ -39063,9 +39071,231 @@ function buildInlineModelBrowseChannelData() {
   return inlineChannelData([[{ text: "Browse providers", callback_data: "mdl_prov" }]]);
 }
 
+// src/inline/bot-commands-sync.ts
+import { listNativeCommandSpecsForConfig } from "openclaw/plugin-sdk/native-command-registry";
+import { getPluginCommandSpecs } from "openclaw/plugin-sdk/plugin-runtime";
+import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
+import { listSkillCommandsForAgents } from "openclaw/plugin-sdk/skill-commands-runtime";
+
+// src/inline/bot-commands-api.ts
+function normalizeInlineBotBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function normalizeInlineBotCommandName(raw) {
+  return raw.trim().replace(/^\/+/, "");
+}
+async function callInlineBotApi(params) {
+  const baseUrl = normalizeInlineBotBaseUrl(params.baseUrl);
+  const invoke = async (authMode) => {
+    const url2 = authMode === "header" ? `${baseUrl}/bot/${params.methodName}` : `${baseUrl}/bot${encodeURIComponent(params.token)}/${params.methodName}`;
+    const request = {
+      method: params.method,
+      headers: {
+        ...authMode === "header" ? { authorization: `Bearer ${params.token}` } : {},
+        ...params.body !== undefined ? { "content-type": "application/json" } : {}
+      }
+    };
+    if (params.body !== undefined) {
+      request.body = JSON.stringify(params.body);
+    }
+    let response;
+    try {
+      response = await fetch(url2, request);
+    } catch (error51) {
+      throw new Error(`inline_bot_commands: ${params.method} ${redactInlineBotApiUrl(url2)} fetch failed: ${summarizeInlineBotApiError(error51)}`);
+    }
+    const payload = await response.json().catch(() => null);
+    return { response, payload };
+  };
+  const resolve = (result) => {
+    if (!result.response.ok) {
+      const message = result.payload?.description ?? `HTTP ${result.response.status}`;
+      throw new Error(`inline_bot_commands: ${message}`);
+    }
+    if (!result.payload || result.payload.ok !== true) {
+      const message = result.payload?.description ?? "bot api call failed";
+      throw new Error(`inline_bot_commands: ${message}`);
+    }
+    return result.payload.result ?? {};
+  };
+  const shouldRetryWithPathToken = (result) => {
+    if (result.response.status === 401)
+      return true;
+    if (result.payload?.error_code === 401)
+      return true;
+    const description = result.payload?.description?.toLowerCase() ?? "";
+    return description.includes("unauthorized");
+  };
+  const headerResult = await invoke("header");
+  if (shouldRetryWithPathToken(headerResult)) {
+    const pathResult = await invoke("path");
+    return resolve(pathResult);
+  }
+  return resolve(headerResult);
+}
+function summarizeInlineBotApiError(error51) {
+  if (error51 instanceof Error) {
+    return `${error51.name}: ${error51.message}`;
+  }
+  return String(error51);
+}
+function redactInlineBotApiUrl(raw) {
+  try {
+    const url2 = new URL(raw);
+    return `${url2.protocol}//${url2.host}${url2.pathname.replace(/\/bot[^/]*\//, "/bot<redacted>/")}`;
+  } catch {
+    return raw.replace(/\/bot[^/]*\//, "/bot<redacted>/");
+  }
+}
+
+// src/inline/bot-commands-sync.ts
+var INLINE_COMMAND_NAME_RE = /^[a-z0-9_]{1,32}$/;
+var INLINE_COMMAND_LIMIT = 100;
+var INLINE_COMMAND_DESCRIPTION_LIMIT = 256;
+var INLINE_NATIVE_COMMAND_PROVIDER = "inline";
+function normalizeDynamicCommandName(raw) {
+  const trimmed = raw.trim().toLowerCase();
+  const withoutSlash = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
+  return withoutSlash.trim();
+}
+function appendUniqueCommand(out, seen, command, description, logger) {
+  const normalized = normalizeDynamicCommandName(command);
+  if (!INLINE_COMMAND_NAME_RE.test(normalized) || seen.has(normalized))
+    return;
+  const rawDescription = adaptInlineVisibleCopy(description).trim();
+  const trimmedDescription = rawDescription.length > INLINE_COMMAND_DESCRIPTION_LIMIT ? rawDescription.slice(0, INLINE_COMMAND_DESCRIPTION_LIMIT).trimEnd() : rawDescription;
+  if (!trimmedDescription)
+    return;
+  if (trimmedDescription.length !== rawDescription.length) {
+    logger?.warn?.(`[inline] bot command sync truncated description for /${normalized} to ${INLINE_COMMAND_DESCRIPTION_LIMIT} characters`);
+  }
+  seen.add(normalized);
+  out.push({ command: normalized, description: trimmedDescription });
+}
+function shouldSyncInlineNativeCommandsForAccount(params) {
+  const effective = params.account.config.commands?.native ?? params.cfg.commands?.native ?? "auto";
+  return effective !== false;
+}
+function shouldSyncInlineNativeSkillsForAccount(params) {
+  const effective = params.account.config.commands?.nativeSkills ?? params.cfg.commands?.nativeSkills ?? "auto";
+  return effective !== false;
+}
+async function buildInlineNativeCommandsForConfig(params) {
+  const route = shouldSyncInlineNativeSkillsForAccount({ cfg: params.cfg, account: params.account }) ? resolveAgentRoute({
+    cfg: params.cfg,
+    channel: INLINE_NATIVE_COMMAND_PROVIDER,
+    accountId: params.account.accountId
+  }) : null;
+  const skillCommands = route ? listSkillCommandsForAgents({
+    cfg: params.cfg,
+    agentIds: [route.agentId]
+  }) : [];
+  const nativeSpecs = listNativeCommandSpecsForConfig(params.cfg, {
+    skillCommands,
+    provider: INLINE_NATIVE_COMMAND_PROVIDER
+  });
+  const pluginSpecs = getPluginCommandSpecs("inline", { config: params.cfg });
+  const seen = new Set;
+  const resolved = [];
+  for (const spec of nativeSpecs) {
+    appendUniqueCommand(resolved, seen, spec.name, spec.description, params.logger);
+  }
+  for (const spec of pluginSpecs) {
+    appendUniqueCommand(resolved, seen, spec.name, spec.description, params.logger);
+  }
+  return resolved;
+}
+async function syncInlineNativeCommands(params) {
+  const accountIds = listInlineAccountIds(params.cfg);
+  if (!accountIds.length) {
+    params.logger?.info?.("[inline] bot command sync disabled");
+    return { attempted: 0, synced: 0, failed: 0 };
+  }
+  let attempted = 0;
+  let synced = 0;
+  let failed = 0;
+  for (const accountId of accountIds) {
+    const account = resolveInlineAccount({ cfg: params.cfg, accountId });
+    const nativeEnabled = shouldSyncInlineNativeCommandsForAccount({ cfg: params.cfg, account });
+    attempted += 1;
+    if (!account.enabled || !account.configured || !account.baseUrl) {
+      continue;
+    }
+    const ownerAccountId = findInlineTokenOwnerAccountId({
+      cfg: params.cfg,
+      accountId: account.accountId
+    });
+    if (ownerAccountId) {
+      failed += 1;
+      params.logger?.warn?.(`[inline] bot command sync skipped for account "${account.accountId}": ${formatDuplicateInlineTokenReason({
+        accountId: account.accountId,
+        ownerAccountId
+      })}`);
+      continue;
+    }
+    let token;
+    try {
+      token = await resolveInlineToken(account);
+    } catch (err) {
+      failed += 1;
+      params.logger?.warn?.(`[inline] bot command sync skipped for account "${account.accountId}": ${String(err)}`);
+      continue;
+    }
+    if (!nativeEnabled) {
+      try {
+        await callInlineBotApi({
+          baseUrl: account.baseUrl,
+          token,
+          methodName: "deleteMyCommands",
+          method: "POST"
+        });
+        synced += 1;
+        params.logger?.info?.(`[inline] bot commands cleared for account "${account.accountId}"`);
+      } catch (err) {
+        failed += 1;
+        params.logger?.warn?.(`[inline] bot command clear failed for account "${account.accountId}": ${String(err)}`);
+      }
+      continue;
+    }
+    const allCommands = await buildInlineNativeCommandsForConfig({
+      cfg: params.cfg,
+      account,
+      ...params.logger ? { logger: params.logger } : {}
+    });
+    const commands = allCommands.slice(0, INLINE_COMMAND_LIMIT);
+    if (allCommands.length > INLINE_COMMAND_LIMIT) {
+      params.logger?.warn?.(`[inline] bot command sync truncating ${allCommands.length} commands to ${INLINE_COMMAND_LIMIT}`);
+    }
+    if (commands.length === 0) {
+      params.logger?.warn?.(`[inline] bot command sync skipped for account "${account.accountId}": no valid commands resolved`);
+      continue;
+    }
+    try {
+      await callInlineBotApi({
+        baseUrl: account.baseUrl,
+        token,
+        methodName: "setMyCommands",
+        method: "POST",
+        body: { commands }
+      });
+      synced += 1;
+      params.logger?.info?.(`[inline] bot commands synced for account "${account.accountId}" (${commands.length} command${commands.length === 1 ? "" : "s"})`);
+    } catch (err) {
+      failed += 1;
+      params.logger?.warn?.(`[inline] bot command sync failed for account "${account.accountId}": ${String(err)}`);
+    }
+  }
+  return {
+    attempted,
+    synced,
+    failed
+  };
+}
+
 // src/inline/monitor.ts
 var CHANNEL_ID = "inline";
-var INLINE_NATIVE_COMMAND_PROVIDER = CHANNEL_ID;
+var INLINE_NATIVE_COMMAND_PROVIDER2 = CHANNEL_ID;
+var INLINE_NATIVE_COMMAND_CALLBACK_PREFIX = "icmd:";
 var INLINE_REQUEST_ERROR_FALLBACK = "OpenClaw could not process that request. Please try again.";
 var INLINE_DEBOUNCE_ERROR_FALLBACK = "OpenClaw could not process those messages. Please try again.";
 function summarizeSdkMeta(meta3) {
@@ -39348,6 +39578,57 @@ function normalizeInlineCommandBody(raw, botUsername) {
   }
   return normalized;
 }
+function findInlineNativeCommandFromBody(commandBody) {
+  const match = commandBody.trim().match(/^\/([^\s]+)(?:\s+[\s\S]*)?$/);
+  if (!match?.[1])
+    return null;
+  return findCommandByNativeName(match[1], INLINE_NATIVE_COMMAND_PROVIDER2) ?? null;
+}
+function resolveInlineCommandNameFromBody(commandBody) {
+  const match = commandBody.trim().match(/^\/([^\s]+)(?:\s+[\s\S]*)?$/);
+  const raw = match?.[1]?.trim().toLowerCase();
+  return raw || null;
+}
+function buildInlineNativeCommandCallbackData(commandText) {
+  return `${INLINE_NATIVE_COMMAND_CALLBACK_PREFIX}${commandText}`;
+}
+function parseInlineNativeCommandCallbackData(raw) {
+  if (!raw)
+    return null;
+  const trimmed = raw.trim();
+  if (!trimmed.startsWith(INLINE_NATIVE_COMMAND_CALLBACK_PREFIX))
+    return null;
+  const commandText = trimmed.slice(INLINE_NATIVE_COMMAND_CALLBACK_PREFIX.length).trim();
+  return commandText.startsWith("/") ? commandText : null;
+}
+function isInlineNativeCommandBody(params) {
+  if (!shouldSyncInlineNativeCommandsForAccount({ cfg: params.cfg, account: params.account })) {
+    return false;
+  }
+  const commandName = resolveInlineCommandNameFromBody(params.commandBody);
+  if (!commandName)
+    return false;
+  const skillCommands = shouldSyncInlineNativeSkillsForAccount({
+    cfg: params.cfg,
+    account: params.account
+  }) ? listSkillCommandsForAgents2({
+    cfg: params.cfg,
+    agentIds: [params.agentId]
+  }) : [];
+  const commandSpecs = listNativeCommandSpecsForConfig2(params.cfg, {
+    skillCommands,
+    provider: INLINE_NATIVE_COMMAND_PROVIDER2
+  });
+  for (const spec of commandSpecs) {
+    if (spec.name.trim().toLowerCase() === commandName)
+      return true;
+  }
+  for (const spec of getPluginCommandSpecs2("inline", { config: params.cfg })) {
+    if (spec.name.trim().toLowerCase() === commandName)
+      return true;
+  }
+  return false;
+}
 function escapeInlineRegExp(raw) {
   return raw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -39540,7 +39821,7 @@ function resolveInlineNativeCommandMenu(params) {
   const match = normalized.match(/^\/([^\s]+)(?:\s+([\s\S]+))?$/);
   if (!match?.[1])
     return null;
-  const command = findCommandByNativeName(match[1], INLINE_NATIVE_COMMAND_PROVIDER);
+  const command = findInlineNativeCommandFromBody(normalized);
   if (!command)
     return null;
   const args = parseCommandArgs(command, match[2]);
@@ -39573,9 +39854,9 @@ function resolveInlineNativeCommandMenu(params) {
     const slice = menu.choices.slice(index, index + 2);
     rows.push(slice.map((choice) => ({
       text: choice.label,
-      callback_data: buildCommandTextFromArgs(command, {
+      callback_data: buildInlineNativeCommandCallbackData(buildCommandTextFromArgs(command, {
         values: { [menu.arg.name]: choice.value }
-      })
+      }))
     })));
   }
   return { title, buttons: rows };
@@ -39653,6 +39934,9 @@ function normalizeInlineActionCallbackData(raw) {
   const trimmed = raw.trim();
   if (!trimmed)
     return "";
+  const nativeCommandText = parseInlineNativeCommandCallbackData(trimmed);
+  if (nativeCommandText)
+    return nativeCommandText;
   return mapInlineModelPickerCallbackToCommand(trimmed) ?? trimmed;
 }
 function normalizeCompatibleButtonCallbackData(raw) {
@@ -40743,6 +41027,7 @@ ${JSON.stringify(payload)}`;
     const storeAllowList = normalizeAllowlist(storeAllowFrom);
     const effectiveAllowFrom = [...configAllowFrom, ...storeAllowList].filter(Boolean);
     const effectiveGroupAllowFrom = groupSenderAllowlist.expanded.filter(Boolean);
+    const effectiveGroupCommandAllowFrom = groupSenderAllowlist.raw.length > 0 ? effectiveGroupAllowFrom : effectiveAllowFrom;
     const callbackCommandBody = callbackActionEvent ? resolveCallbackCommandBodyFromActionData({
       data: callbackActionEvent.data,
       ...botUsername ? { botUsername } : {}
@@ -40761,14 +41046,31 @@ ${JSON.stringify(payload)}`;
     }
     const shouldEditCallbackTargetInPlace = callbackActionEvent != null;
     const normalizedCommandBody = callbackCommandBody ?? normalizeInlineCommandBody(rawBody, botUsername);
+    const route = core3.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      peer: {
+        kind: isGroup ? "group" : "direct",
+        id: isGroup ? String(effectiveChatId) : senderId
+      }
+    });
+    const nativeCallbackCommandBody = callbackActionEvent ? parseInlineNativeCommandCallbackData(callbackDataToUtf8(callbackActionEvent.data)) : null;
+    const hasControlCommand = core3.channel.text.hasControlCommand(callbackCommandBody ?? rawBody, cfg, botUsername ? { botUsername } : undefined);
+    const commandSource = hasControlCommand ? (nativeCallbackCommandBody != null || !callbackActionEvent) && isInlineNativeCommandBody({
+      cfg,
+      account,
+      commandBody: normalizedCommandBody,
+      agentId: route.agentId
+    }) ? "native" : "text" : undefined;
     const allowTextCommands = core3.channel.commands.shouldHandleTextCommands({
       cfg,
-      surface: CHANNEL_ID
+      surface: CHANNEL_ID,
+      ...commandSource ? { commandSource } : {}
     });
     const useAccessGroups = cfg.commands?.useAccessGroups !== false;
-    const allowForCommands = isGroup ? effectiveGroupAllowFrom : effectiveAllowFrom;
+    const allowForCommands = isGroup ? effectiveGroupCommandAllowFrom : effectiveAllowFrom;
     const senderAllowedForCommands = allowlistMatch({ allowFrom: allowForCommands, senderId });
-    const hasControlCommand = core3.channel.text.hasControlCommand(callbackCommandBody ?? rawBody, cfg, botUsername ? { botUsername } : undefined);
     const commandGate = resolveControlCommandGate({
       useAccessGroups,
       authorizers: [{ configured: allowForCommands.length > 0, allowed: senderAllowedForCommands }],
@@ -40871,15 +41173,6 @@ ${JSON.stringify(payload)}`;
       });
       return;
     }
-    const route = core3.channel.routing.resolveAgentRoute({
-      cfg,
-      channel: CHANNEL_ID,
-      accountId: account.accountId,
-      peer: {
-        kind: isGroup ? "group" : "direct",
-        id: isGroup ? String(effectiveChatId) : senderId
-      }
-    });
     const mentionRegexes = core3.channel.mentions.buildMentionRegexes(cfg, route.agentId);
     const nativeMentioned = typeof msg.mentioned === "boolean" ? msg.mentioned : false;
     const patternMentioned = mentionRegexes.length ? core3.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) : false;
@@ -40979,7 +41272,7 @@ ${JSON.stringify(payload)}`;
       if (commandsPageCallback.page === "noop")
         return;
       const agentId = commandsPageCallback.agentId ?? route.agentId;
-      const paginated = buildCommandsMessagePaginated(cfg, listSkillCommandsForAgents({
+      const paginated = buildCommandsMessagePaginated(cfg, listSkillCommandsForAgents2({
         cfg,
         agentIds: [agentId]
       }), {
@@ -41304,6 +41597,18 @@ This model will be used for your next message.`, []);
       Provider: CHANNEL_ID,
       Surface: effectiveSurface,
       MessageSid: messageSid,
+      ...commandSource ? { CommandSource: commandSource } : {},
+      CommandTurn: commandSource ? {
+        kind: commandSource === "native" ? "native" : "text-slash",
+        source: commandSource,
+        authorized: commandAuthorized,
+        body: normalizedCommandBody
+      } : {
+        kind: "normal",
+        source: "message",
+        authorized: false,
+        body: normalizedCommandBody
+      },
       ...replyThreadContext ? { MessageThreadId: String(replyThreadContext.childChatId) } : {},
       ...replyThreadContext?.threadLabel ? { ThreadLabel: replyThreadContext.threadLabel } : {},
       ...msg.replyToMsgId != null ? { ReplyToId: String(msg.replyToMsgId) } : {},
@@ -44550,5 +44855,5 @@ export {
   inlineChannelPlugin
 };
 
-//# debugId=7BA9283EE42CF7D464756E2164756E21
+//# debugId=F677CBD78FB5C51A64756E2164756E21
 //# sourceMappingURL=channel-plugin-api.js.map