From 506bed5aed40820565b7db66a963b8163968208f Mon Sep 17 00:00:00 2001 From: Josh Long Date: Mon, 26 Jan 2026 22:07:43 +0000 Subject: [PATCH 001/101] feat(telegram): add sticker support with vision caching MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add support for receiving and sending Telegram stickers: Inbound: - Receive static WEBP stickers (skip animated/video) - Process stickers through dedicated vision call for descriptions - Cache vision descriptions to avoid repeated API calls - Graceful error handling for fetch failures Outbound: - Add sticker action to send stickers by fileId - Add sticker-search action to find cached stickers by query - Accept stickerId from shared schema, convert to fileId Cache: - Store sticker metadata (fileId, emoji, setName, description) - Fuzzy search by description, emoji, and set name - Persist to ~/.clawdbot/telegram/sticker-cache.json Config: - Single `channels.telegram.actions.sticker` option enables both send and search actions 🤖 AI-assisted: Built with Claude Code (claude-opus-4-5) Testing: Fully tested - unit tests pass, live tested on dev gateway The contributor understands and has reviewed all code changes. Co-Authored-By: Claude Opus 4.5 --- docs/channels/telegram.md | 124 +++++++++ src/agents/tools/telegram-actions.ts | 61 +++++ src/auto-reply/templating.ts | 3 + src/channels/plugins/actions/telegram.ts | 40 +++ src/channels/plugins/message-action-names.ts | 1 + src/config/types.telegram.ts | 2 + src/config/zod-schema.providers-core.ts | 1 + src/infra/outbound/message-action-spec.ts | 1 + src/telegram/bot-handlers.ts | 31 ++- src/telegram/bot-message-context.ts | 49 +++- src/telegram/bot-message-dispatch.ts | 46 ++++ ...s-media-file-path-no-file-download.test.ts | 196 +++++++++++++ src/telegram/bot/delivery.ts | 76 +++++- src/telegram/bot/types.ts | 14 + ...send.returns-undefined-empty-input.test.ts | 183 ++++++++++++- src/telegram/send.ts | 93 +++++++ src/telegram/sticker-cache.test.ts | 257 ++++++++++++++++++ src/telegram/sticker-cache.ts | 201 ++++++++++++++ 18 files changed, 1365 insertions(+), 14 deletions(-) create mode 100644 src/telegram/sticker-cache.test.ts create mode 100644 src/telegram/sticker-cache.ts diff --git a/docs/channels/telegram.md b/docs/channels/telegram.md index 39f3a2ec3..2d8c472bd 100644 --- a/docs/channels/telegram.md +++ b/docs/channels/telegram.md @@ -383,6 +383,129 @@ For message tool sends, set `asVoice: true` with a voice-compatible audio `media } ``` +## Stickers + +Clawdbot supports receiving and sending Telegram stickers with intelligent caching. + +### Receiving stickers + +When a user sends a sticker, Clawdbot handles it based on the sticker type: + +- **Static stickers (WEBP):** Downloaded and processed through vision. The sticker appears as a `` placeholder in the message content. +- **Animated stickers (TGS):** Skipped (Lottie format not supported for processing). +- **Video stickers (WEBM):** Skipped (video format not supported for processing). + +Template context fields available when receiving stickers: +- `StickerEmoji` — the emoji associated with the sticker +- `StickerSetName` — the name of the sticker set +- `StickerFileId` — the Telegram file ID (used for sending the same sticker back) + +### Sticker cache + +Stickers are processed through the AI's vision capabilities to generate descriptions. Since the same stickers are often sent repeatedly, Clawdbot caches these descriptions to avoid redundant API calls. + +**How it works:** + +1. **First encounter:** The sticker image is sent to the AI for vision analysis. The AI generates a description (e.g., "A cartoon cat waving enthusiastically"). +2. **Cache storage:** The description is saved along with the sticker's file ID, emoji, and set name. +3. **Subsequent encounters:** When the same sticker is seen again, the cached description is used directly. The image is not sent to the AI. + +**Cache location:** `~/.clawdbot/telegram/sticker-cache.json` + +**Cache entry format:** +```json +{ + "fileId": "CAACAgIAAxkBAAI...", + "emoji": "👋", + "setName": "CoolCats", + "description": "A cartoon cat waving enthusiastically", + "addedAt": "2026-01-15T10:30:00.000Z" +} +``` + +**Benefits:** +- Reduces API costs by avoiding repeated vision calls for the same sticker +- Faster response times for cached stickers (no vision processing delay) +- Enables sticker search functionality based on cached descriptions + +The cache is populated automatically as stickers are received. There is no manual cache management required. + +### Sending stickers + +The agent can send and search stickers using the `sticker` and `sticker-search` actions. These are disabled by default and must be enabled in config: + +```json5 +{ + channels: { + telegram: { + actions: { + sticker: true + } + } + } +} +``` + +**Send a sticker:** + +```json5 +{ + "action": "sticker", + "channel": "telegram", + "to": "123456789", + "fileId": "CAACAgIAAxkBAAI..." +} +``` + +Parameters: +- `fileId` (required) — the Telegram file ID of the sticker. Obtain this from `StickerFileId` when receiving a sticker, or from a `sticker-search` result. +- `replyTo` (optional) — message ID to reply to. +- `threadId` (optional) — message thread ID for forum topics. + +**Search for stickers:** + +The agent can search cached stickers by description, emoji, or set name: + +```json5 +{ + "action": "sticker-search", + "channel": "telegram", + "query": "cat waving", + "limit": 5 +} +``` + +Returns matching stickers from the cache: +```json5 +{ + "ok": true, + "count": 2, + "stickers": [ + { + "fileId": "CAACAgIAAxkBAAI...", + "emoji": "👋", + "description": "A cartoon cat waving enthusiastically", + "setName": "CoolCats" + } + ] +} +``` + +The search uses fuzzy matching across description text, emoji characters, and set names. + +**Example with threading:** + +```json5 +{ + "action": "sticker", + "channel": "telegram", + "to": "-1001234567890", + "fileId": "CAACAgIAAxkBAAI...", + "replyTo": 42, + "threadId": 123 +} +``` + ## Streaming (drafts) Telegram can stream **draft bubbles** while the agent is generating a response. Clawdbot uses Bot API `sendMessageDraft` (not real messages) and then sends the @@ -537,6 +660,7 @@ Provider options: - `channels.telegram.actions.reactions`: gate Telegram tool reactions. - `channels.telegram.actions.sendMessage`: gate Telegram tool message sends. - `channels.telegram.actions.deleteMessage`: gate Telegram tool message deletes. +- `channels.telegram.actions.sticker`: gate Telegram sticker actions — send and search (default: false). - `channels.telegram.reactionNotifications`: `off | own | all` — control which reactions trigger system events (default: `own` when not set). - `channels.telegram.reactionLevel`: `off | ack | minimal | extensive` — control agent's reaction capability (default: `minimal` when not set). diff --git a/src/agents/tools/telegram-actions.ts b/src/agents/tools/telegram-actions.ts index 891ab2b45..40a97d874 100644 --- a/src/agents/tools/telegram-actions.ts +++ b/src/agents/tools/telegram-actions.ts @@ -6,7 +6,9 @@ import { editMessageTelegram, reactMessageTelegram, sendMessageTelegram, + sendStickerTelegram, } from "../../telegram/send.js"; +import { getCacheStats, searchStickers } from "../../telegram/sticker-cache.js"; import { resolveTelegramToken } from "../../telegram/token.js"; import { resolveTelegramInlineButtonsScope, @@ -255,5 +257,64 @@ export async function handleTelegramAction( }); } + if (action === "sendSticker") { + if (!isActionEnabled("sticker")) { + throw new Error( + "Telegram sticker actions are disabled. Set channels.telegram.actions.sticker to true.", + ); + } + const to = readStringParam(params, "to", { required: true }); + const fileId = readStringParam(params, "fileId", { required: true }); + const replyToMessageId = readNumberParam(params, "replyToMessageId", { + integer: true, + }); + const messageThreadId = readNumberParam(params, "messageThreadId", { + integer: true, + }); + const token = resolveTelegramToken(cfg, { accountId }).token; + if (!token) { + throw new Error( + "Telegram bot token missing. Set TELEGRAM_BOT_TOKEN or channels.telegram.botToken.", + ); + } + const result = await sendStickerTelegram(to, fileId, { + token, + accountId: accountId ?? undefined, + replyToMessageId: replyToMessageId ?? undefined, + messageThreadId: messageThreadId ?? undefined, + }); + return jsonResult({ + ok: true, + messageId: result.messageId, + chatId: result.chatId, + }); + } + + if (action === "searchSticker") { + if (!isActionEnabled("sticker")) { + throw new Error( + "Telegram sticker actions are disabled. Set channels.telegram.actions.sticker to true.", + ); + } + const query = readStringParam(params, "query", { required: true }); + const limit = readNumberParam(params, "limit", { integer: true }) ?? 5; + const results = searchStickers(query, limit); + return jsonResult({ + ok: true, + count: results.length, + stickers: results.map((s) => ({ + fileId: s.fileId, + emoji: s.emoji, + description: s.description, + setName: s.setName, + })), + }); + } + + if (action === "stickerCacheStats") { + const stats = getCacheStats(); + return jsonResult({ ok: true, ...stats }); + } + throw new Error(`Unsupported Telegram action: ${action}`); } diff --git a/src/auto-reply/templating.ts b/src/auto-reply/templating.ts index dd424ee71..79692a50d 100644 --- a/src/auto-reply/templating.ts +++ b/src/auto-reply/templating.ts @@ -1,4 +1,5 @@ import type { ChannelId } from "../channels/plugins/types.js"; +import type { StickerMetadata } from "../telegram/bot/types.js"; import type { InternalMessageChannel } from "../utils/message-channel.js"; import type { CommandArgs } from "./commands-registry.types.js"; import type { @@ -64,6 +65,8 @@ export type MsgContext = { MediaPaths?: string[]; MediaUrls?: string[]; MediaTypes?: string[]; + /** Telegram sticker metadata (emoji, set name, file IDs, cached description). */ + Sticker?: StickerMetadata; OutputDir?: string; OutputBase?: string; /** Remote host for SCP when media lives on a different machine (e.g., clawdbot@192.168.64.3). */ diff --git a/src/channels/plugins/actions/telegram.ts b/src/channels/plugins/actions/telegram.ts index 364707e0a..f8c7dc0fb 100644 --- a/src/channels/plugins/actions/telegram.ts +++ b/src/channels/plugins/actions/telegram.ts @@ -1,6 +1,7 @@ import { createActionGate, readNumberParam, + readStringArrayParam, readStringOrNumberParam, readStringParam, } from "../../../agents/tools/common.js"; @@ -45,6 +46,10 @@ export const telegramMessageActions: ChannelMessageActionAdapter = { if (gate("reactions")) actions.add("react"); if (gate("deleteMessage")) actions.add("delete"); if (gate("editMessage")) actions.add("edit"); + if (gate("sticker")) { + actions.add("sticker"); + actions.add("sticker-search"); + } return Array.from(actions); }, supportsButtons: ({ cfg }) => { @@ -141,6 +146,41 @@ export const telegramMessageActions: ChannelMessageActionAdapter = { ); } + if (action === "sticker") { + const to = + readStringParam(params, "to") ?? readStringParam(params, "target", { required: true }); + // Accept stickerId (array from shared schema) and use first element as fileId + const stickerIds = readStringArrayParam(params, "stickerId"); + const fileId = stickerIds?.[0] ?? readStringParam(params, "fileId", { required: true }); + const replyToMessageId = readNumberParam(params, "replyTo", { integer: true }); + const messageThreadId = readNumberParam(params, "threadId", { integer: true }); + return await handleTelegramAction( + { + action: "sendSticker", + to, + fileId, + replyToMessageId: replyToMessageId ?? undefined, + messageThreadId: messageThreadId ?? undefined, + accountId: accountId ?? undefined, + }, + cfg, + ); + } + + if (action === "sticker-search") { + const query = readStringParam(params, "query", { required: true }); + const limit = readNumberParam(params, "limit", { integer: true }); + return await handleTelegramAction( + { + action: "searchSticker", + query, + limit: limit ?? undefined, + accountId: accountId ?? undefined, + }, + cfg, + ); + } + throw new Error(`Action ${action} is not supported for provider ${providerId}.`); }, }; diff --git a/src/channels/plugins/message-action-names.ts b/src/channels/plugins/message-action-names.ts index c884f6da3..1884cacb0 100644 --- a/src/channels/plugins/message-action-names.ts +++ b/src/channels/plugins/message-action-names.ts @@ -25,6 +25,7 @@ export const CHANNEL_MESSAGE_ACTION_NAMES = [ "thread-reply", "search", "sticker", + "sticker-search", "member-info", "role-info", "emoji-list", diff --git a/src/config/types.telegram.ts b/src/config/types.telegram.ts index 4d476f88e..9a96bce45 100644 --- a/src/config/types.telegram.ts +++ b/src/config/types.telegram.ts @@ -16,6 +16,8 @@ export type TelegramActionConfig = { sendMessage?: boolean; deleteMessage?: boolean; editMessage?: boolean; + /** Enable sticker actions (send and search). */ + sticker?: boolean; }; export type TelegramNetworkConfig = { diff --git a/src/config/zod-schema.providers-core.ts b/src/config/zod-schema.providers-core.ts index fbf6a2173..ed7dda22a 100644 --- a/src/config/zod-schema.providers-core.ts +++ b/src/config/zod-schema.providers-core.ts @@ -128,6 +128,7 @@ export const TelegramAccountSchemaBase = z reactions: z.boolean().optional(), sendMessage: z.boolean().optional(), deleteMessage: z.boolean().optional(), + sticker: z.boolean().optional(), }) .strict() .optional(), diff --git a/src/infra/outbound/message-action-spec.ts b/src/infra/outbound/message-action-spec.ts index c4f712e0f..639e641d0 100644 --- a/src/infra/outbound/message-action-spec.ts +++ b/src/infra/outbound/message-action-spec.ts @@ -30,6 +30,7 @@ export const MESSAGE_ACTION_TARGET_MODE: Record m.msg.caption || m.msg.text); const primaryEntry = captionMsg ?? entry.messages[0]; - const allMedia: Array<{ path: string; contentType?: string }> = []; + const allMedia: Array<{ + path: string; + contentType?: string; + stickerMetadata?: { emoji?: string; setName?: string; fileId?: string }; + }> = []; for (const { ctx } of entry.messages) { const media = await resolveMedia(ctx, mediaMaxBytes, opts.token, opts.proxyFetch); if (media) { - allMedia.push({ path: media.path, contentType: media.contentType }); + allMedia.push({ + path: media.path, + contentType: media.contentType, + stickerMetadata: media.stickerMetadata, + }); } } @@ -595,7 +603,24 @@ export const registerTelegramHandlers = ({ } throw mediaErr; } - const allMedia = media ? [{ path: media.path, contentType: media.contentType }] : []; + + // Skip sticker-only messages where the sticker was skipped (animated/video) + // These have no media and no text content to process. + const hasText = Boolean((msg.text ?? msg.caption ?? "").trim()); + if (msg.sticker && !media && !hasText) { + logVerbose("telegram: skipping sticker-only message (unsupported sticker type)"); + return; + } + + const allMedia = media + ? [ + { + path: media.path, + contentType: media.contentType, + stickerMetadata: media.stickerMetadata, + }, + ] + : []; const senderId = msg.from?.id ? String(msg.from.id) : ""; const conversationKey = resolvedThreadId != null ? `${chatId}:topic:${resolvedThreadId}` : String(chatId); diff --git a/src/telegram/bot-message-context.ts b/src/telegram/bot-message-context.ts index a054943a2..71ac8a011 100644 --- a/src/telegram/bot-message-context.ts +++ b/src/telegram/bot-message-context.ts @@ -49,7 +49,17 @@ import { import { upsertTelegramPairingRequest } from "./pairing-store.js"; import type { TelegramContext } from "./bot/types.js"; -type TelegramMediaRef = { path: string; contentType?: string }; +type TelegramMediaRef = { + path: string; + contentType?: string; + stickerMetadata?: { + emoji?: string; + setName?: string; + fileId?: string; + fileUniqueId?: string; + cachedDescription?: string; + }; +}; type TelegramMessageContextOptions = { forceWasMentioned?: boolean; @@ -302,6 +312,18 @@ export const buildTelegramMessageContext = async ({ else if (msg.video) placeholder = ""; else if (msg.audio || msg.voice) placeholder = ""; else if (msg.document) placeholder = ""; + else if (msg.sticker) placeholder = ""; + + // Check if sticker has a cached description - if so, use it instead of sending the image + const cachedStickerDescription = allMedia[0]?.stickerMetadata?.cachedDescription; + const stickerCacheHit = Boolean(cachedStickerDescription); + if (stickerCacheHit) { + // Format cached description with sticker context + const emoji = allMedia[0]?.stickerMetadata?.emoji; + const setName = allMedia[0]?.stickerMetadata?.setName; + const stickerContext = [emoji, setName ? `from "${setName}"` : null].filter(Boolean).join(" "); + placeholder = `[Sticker${stickerContext ? ` ${stickerContext}` : ""}] ${cachedStickerDescription}`; + } const locationData = extractTelegramLocation(msg); const locationText = locationData ? formatLocationText(locationData) : undefined; @@ -525,15 +547,26 @@ export const buildTelegramMessageContext = async ({ ForwardedDate: forwardOrigin?.date ? forwardOrigin.date * 1000 : undefined, Timestamp: msg.date ? msg.date * 1000 : undefined, WasMentioned: isGroup ? effectiveWasMentioned : undefined, - MediaPath: allMedia[0]?.path, - MediaType: allMedia[0]?.contentType, - MediaUrl: allMedia[0]?.path, - MediaPaths: allMedia.length > 0 ? allMedia.map((m) => m.path) : undefined, - MediaUrls: allMedia.length > 0 ? allMedia.map((m) => m.path) : undefined, - MediaTypes: - allMedia.length > 0 + // Filter out cached stickers from media - their description is already in the message body + MediaPath: stickerCacheHit ? undefined : allMedia[0]?.path, + MediaType: stickerCacheHit ? undefined : allMedia[0]?.contentType, + MediaUrl: stickerCacheHit ? undefined : allMedia[0]?.path, + MediaPaths: stickerCacheHit + ? undefined + : allMedia.length > 0 + ? allMedia.map((m) => m.path) + : undefined, + MediaUrls: stickerCacheHit + ? undefined + : allMedia.length > 0 + ? allMedia.map((m) => m.path) + : undefined, + MediaTypes: stickerCacheHit + ? undefined + : allMedia.length > 0 ? (allMedia.map((m) => m.contentType).filter(Boolean) as string[]) : undefined, + Sticker: allMedia[0]?.stickerMetadata, ...(locationData ? toLocationContext(locationData) : undefined), CommandAuthorized: commandAuthorized, MessageThreadId: resolvedThreadId, diff --git a/src/telegram/bot-message-dispatch.ts b/src/telegram/bot-message-dispatch.ts index 334c4c212..e24796d6c 100644 --- a/src/telegram/bot-message-dispatch.ts +++ b/src/telegram/bot-message-dispatch.ts @@ -12,6 +12,8 @@ import { resolveMarkdownTableMode } from "../config/markdown-tables.js"; import { deliverReplies } from "./bot/delivery.js"; import { resolveTelegramDraftStreamingChunking } from "./draft-chunking.js"; import { createTelegramDraftStream } from "./draft-stream.js"; +import { cacheSticker, describeStickerImage } from "./sticker-cache.js"; +import { resolveAgentDir } from "../agents/agent-scope.js"; export const dispatchTelegramMessage = async ({ context, @@ -128,6 +130,49 @@ export const dispatchTelegramMessage = async ({ }); const chunkMode = resolveChunkMode(cfg, "telegram", route.accountId); + // Handle uncached stickers: get a dedicated vision description before dispatch + // This ensures we cache a raw description rather than a conversational response + const sticker = ctxPayload.Sticker; + if (sticker?.fileUniqueId && !sticker.cachedDescription && ctxPayload.MediaPath) { + const agentDir = resolveAgentDir(cfg, route.agentId); + const description = await describeStickerImage({ + imagePath: ctxPayload.MediaPath, + cfg, + agentDir, + }); + if (description) { + // Format the description with sticker context + const stickerContext = [sticker.emoji, sticker.setName ? `from "${sticker.setName}"` : null] + .filter(Boolean) + .join(" "); + const formattedDesc = `[Sticker${stickerContext ? ` ${stickerContext}` : ""}] ${description}`; + + // Update context to use description instead of image + sticker.cachedDescription = description; + ctxPayload.Body = formattedDesc; + ctxPayload.BodyForAgent = formattedDesc; + // Clear media paths so native vision doesn't process the image again + ctxPayload.MediaPath = undefined; + ctxPayload.MediaType = undefined; + ctxPayload.MediaUrl = undefined; + ctxPayload.MediaPaths = undefined; + ctxPayload.MediaUrls = undefined; + ctxPayload.MediaTypes = undefined; + + // Cache the description for future encounters + cacheSticker({ + fileId: sticker.fileId, + fileUniqueId: sticker.fileUniqueId, + emoji: sticker.emoji, + setName: sticker.setName, + description, + cachedAt: new Date().toISOString(), + receivedFrom: ctxPayload.From, + }); + logVerbose(`telegram: cached sticker description for ${sticker.fileUniqueId}`); + } + } + const { queuedFinal } = await dispatchReplyWithBufferedBlockDispatcher({ ctx: ctxPayload, cfg, @@ -139,6 +184,7 @@ export const dispatchTelegramMessage = async ({ await flushDraft(); draftStream?.stop(); } + await deliverReplies({ replies: [payload], chatId: String(chatId), diff --git a/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts b/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts index b6c1ca419..dd75e6798 100644 --- a/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts +++ b/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts @@ -405,6 +405,202 @@ describe("telegram media groups", () => { ); }); +describe("telegram stickers", () => { + const STICKER_TEST_TIMEOUT_MS = process.platform === "win32" ? 30_000 : 20_000; + + it( + "downloads static sticker (WEBP) and includes sticker metadata", + async () => { + const { createTelegramBot } = await import("./bot.js"); + const replyModule = await import("../auto-reply/reply.js"); + const replySpy = replyModule.__replySpy as unknown as ReturnType; + + onSpy.mockReset(); + replySpy.mockReset(); + sendChatActionSpy.mockReset(); + + const runtimeLog = vi.fn(); + const runtimeError = vi.fn(); + createTelegramBot({ + token: "tok", + runtime: { + log: runtimeLog, + error: runtimeError, + exit: () => { + throw new Error("exit"); + }, + }, + }); + const handler = onSpy.mock.calls.find((call) => call[0] === "message")?.[1] as ( + ctx: Record, + ) => Promise; + expect(handler).toBeDefined(); + + const fetchSpy = vi.spyOn(globalThis, "fetch" as never).mockResolvedValueOnce({ + ok: true, + status: 200, + statusText: "OK", + headers: { get: () => "image/webp" }, + arrayBuffer: async () => new Uint8Array([0x52, 0x49, 0x46, 0x46]).buffer, // RIFF header + } as Response); + + await handler({ + message: { + message_id: 100, + chat: { id: 1234, type: "private" }, + sticker: { + file_id: "sticker_file_id_123", + file_unique_id: "sticker_unique_123", + type: "regular", + width: 512, + height: 512, + is_animated: false, + is_video: false, + emoji: "🎉", + set_name: "TestStickerPack", + }, + date: 1736380800, + }, + me: { username: "clawdbot_bot" }, + getFile: async () => ({ file_path: "stickers/sticker.webp" }), + }); + + expect(runtimeError).not.toHaveBeenCalled(); + expect(fetchSpy).toHaveBeenCalledWith( + "https://api.telegram.org/file/bottok/stickers/sticker.webp", + ); + expect(replySpy).toHaveBeenCalledTimes(1); + const payload = replySpy.mock.calls[0][0]; + expect(payload.Body).toContain(""); + expect(payload.Sticker?.emoji).toBe("🎉"); + expect(payload.Sticker?.setName).toBe("TestStickerPack"); + expect(payload.Sticker?.fileId).toBe("sticker_file_id_123"); + + fetchSpy.mockRestore(); + }, + STICKER_TEST_TIMEOUT_MS, + ); + + it( + "skips animated stickers (TGS format)", + async () => { + const { createTelegramBot } = await import("./bot.js"); + const replyModule = await import("../auto-reply/reply.js"); + const replySpy = replyModule.__replySpy as unknown as ReturnType; + + onSpy.mockReset(); + replySpy.mockReset(); + + const runtimeError = vi.fn(); + const fetchSpy = vi.spyOn(globalThis, "fetch" as never); + + createTelegramBot({ + token: "tok", + runtime: { + log: vi.fn(), + error: runtimeError, + exit: () => { + throw new Error("exit"); + }, + }, + }); + const handler = onSpy.mock.calls.find((call) => call[0] === "message")?.[1] as ( + ctx: Record, + ) => Promise; + expect(handler).toBeDefined(); + + await handler({ + message: { + message_id: 101, + chat: { id: 1234, type: "private" }, + sticker: { + file_id: "animated_sticker_id", + file_unique_id: "animated_unique", + type: "regular", + width: 512, + height: 512, + is_animated: true, // TGS format + is_video: false, + emoji: "😎", + set_name: "AnimatedPack", + }, + date: 1736380800, + }, + me: { username: "clawdbot_bot" }, + getFile: async () => ({ file_path: "stickers/animated.tgs" }), + }); + + // Should not attempt to download animated stickers + expect(fetchSpy).not.toHaveBeenCalled(); + // Should still process the message (as text-only, no media) + expect(replySpy).not.toHaveBeenCalled(); // No text content, so no reply generated + expect(runtimeError).not.toHaveBeenCalled(); + + fetchSpy.mockRestore(); + }, + STICKER_TEST_TIMEOUT_MS, + ); + + it( + "skips video stickers (WEBM format)", + async () => { + const { createTelegramBot } = await import("./bot.js"); + const replyModule = await import("../auto-reply/reply.js"); + const replySpy = replyModule.__replySpy as unknown as ReturnType; + + onSpy.mockReset(); + replySpy.mockReset(); + + const runtimeError = vi.fn(); + const fetchSpy = vi.spyOn(globalThis, "fetch" as never); + + createTelegramBot({ + token: "tok", + runtime: { + log: vi.fn(), + error: runtimeError, + exit: () => { + throw new Error("exit"); + }, + }, + }); + const handler = onSpy.mock.calls.find((call) => call[0] === "message")?.[1] as ( + ctx: Record, + ) => Promise; + expect(handler).toBeDefined(); + + await handler({ + message: { + message_id: 102, + chat: { id: 1234, type: "private" }, + sticker: { + file_id: "video_sticker_id", + file_unique_id: "video_unique", + type: "regular", + width: 512, + height: 512, + is_animated: false, + is_video: true, // WEBM format + emoji: "🎬", + set_name: "VideoPack", + }, + date: 1736380800, + }, + me: { username: "clawdbot_bot" }, + getFile: async () => ({ file_path: "stickers/video.webm" }), + }); + + // Should not attempt to download video stickers + expect(fetchSpy).not.toHaveBeenCalled(); + expect(replySpy).not.toHaveBeenCalled(); + expect(runtimeError).not.toHaveBeenCalled(); + + fetchSpy.mockRestore(); + }, + STICKER_TEST_TIMEOUT_MS, + ); +}); + describe("telegram text fragments", () => { beforeEach(() => { vi.useFakeTimers(); diff --git a/src/telegram/bot/delivery.ts b/src/telegram/bot/delivery.ts index c2489300c..f950417c7 100644 --- a/src/telegram/bot/delivery.ts +++ b/src/telegram/bot/delivery.ts @@ -21,7 +21,8 @@ import { loadWebMedia } from "../../web/media.js"; import { buildInlineKeyboard } from "../send.js"; import { resolveTelegramVoiceSend } from "../voice.js"; import { buildTelegramThreadParams, resolveTelegramReplyId } from "./helpers.js"; -import type { TelegramContext } from "./types.js"; +import type { StickerMetadata, TelegramContext } from "./types.js"; +import { getCachedSticker } from "../sticker-cache.js"; const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i; const VOICE_FORBIDDEN_RE = /VOICE_MESSAGES_FORBIDDEN/; @@ -261,8 +262,79 @@ export async function resolveMedia( maxBytes: number, token: string, proxyFetch?: typeof fetch, -): Promise<{ path: string; contentType?: string; placeholder: string } | null> { +): Promise<{ + path: string; + contentType?: string; + placeholder: string; + stickerMetadata?: StickerMetadata; +} | null> { const msg = ctx.message; + + // Handle stickers separately - only static stickers (WEBP) are supported + if (msg.sticker) { + const sticker = msg.sticker; + // Skip animated (TGS) and video (WEBM) stickers - only static WEBP supported + if (sticker.is_animated || sticker.is_video) { + logVerbose("telegram: skipping animated/video sticker (only static stickers supported)"); + return null; + } + if (!sticker.file_id) return null; + + try { + const file = await ctx.getFile(); + if (!file.file_path) { + logVerbose("telegram: getFile returned no file_path for sticker"); + return null; + } + const fetchImpl = proxyFetch ?? globalThis.fetch; + if (!fetchImpl) { + logVerbose("telegram: fetch not available for sticker download"); + return null; + } + const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`; + const fetched = await fetchRemoteMedia({ + url, + fetchImpl, + filePathHint: file.file_path, + }); + const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType, "inbound", maxBytes); + + // Check sticker cache for existing description + const cached = sticker.file_unique_id ? getCachedSticker(sticker.file_unique_id) : null; + if (cached) { + logVerbose(`telegram: sticker cache hit for ${sticker.file_unique_id}`); + return { + path: saved.path, + contentType: saved.contentType, + placeholder: "", + stickerMetadata: { + emoji: cached.emoji, + setName: cached.setName, + fileId: cached.fileId, + fileUniqueId: sticker.file_unique_id, + cachedDescription: cached.description, + }, + }; + } + + // Cache miss - return metadata for vision processing + return { + path: saved.path, + contentType: saved.contentType, + placeholder: "", + stickerMetadata: { + emoji: sticker.emoji ?? undefined, + setName: sticker.set_name ?? undefined, + fileId: sticker.file_id, + fileUniqueId: sticker.file_unique_id, + }, + }; + } catch (err) { + logVerbose(`telegram: failed to process sticker: ${err}`); + return null; + } + } + const m = msg.photo?.[msg.photo.length - 1] ?? msg.video ?? msg.document ?? msg.audio ?? msg.voice; if (!m?.file_id) return null; diff --git a/src/telegram/bot/types.ts b/src/telegram/bot/types.ts index 1174503b4..3e106b885 100644 --- a/src/telegram/bot/types.ts +++ b/src/telegram/bot/types.ts @@ -67,3 +67,17 @@ export interface TelegramVenue { google_place_id?: string; google_place_type?: string; } + +/** Telegram sticker metadata for context enrichment. */ +export interface StickerMetadata { + /** Emoji associated with the sticker. */ + emoji?: string; + /** Name of the sticker set the sticker belongs to. */ + setName?: string; + /** Telegram file_id for sending the sticker back. */ + fileId?: string; + /** Stable file_unique_id for cache deduplication. */ + fileUniqueId?: string; + /** Cached description from previous vision processing (skip re-processing if present). */ + cachedDescription?: string; +} diff --git a/src/telegram/send.returns-undefined-empty-input.test.ts b/src/telegram/send.returns-undefined-empty-input.test.ts index d086fe2a3..b6b497789 100644 --- a/src/telegram/send.returns-undefined-empty-input.test.ts +++ b/src/telegram/send.returns-undefined-empty-input.test.ts @@ -4,6 +4,7 @@ const { botApi, botCtorSpy } = vi.hoisted(() => ({ botApi: { sendMessage: vi.fn(), setMessageReaction: vi.fn(), + sendSticker: vi.fn(), }, botCtorSpy: vi.fn(), })); @@ -43,7 +44,7 @@ vi.mock("../config/config.js", async (importOriginal) => { }; }); -import { buildInlineKeyboard, sendMessageTelegram } from "./send.js"; +import { buildInlineKeyboard, sendMessageTelegram, sendStickerTelegram } from "./send.js"; describe("buildInlineKeyboard", () => { it("returns undefined for empty input", () => { @@ -566,3 +567,183 @@ describe("sendMessageTelegram", () => { }); }); }); + +describe("sendStickerTelegram", () => { + beforeEach(() => { + loadConfig.mockReturnValue({}); + botApi.sendSticker.mockReset(); + botCtorSpy.mockReset(); + }); + + it("sends a sticker by file_id", async () => { + const chatId = "123"; + const fileId = "CAACAgIAAxkBAAI...sticker_file_id"; + const sendSticker = vi.fn().mockResolvedValue({ + message_id: 100, + chat: { id: chatId }, + }); + const api = { sendSticker } as unknown as { + sendSticker: typeof sendSticker; + }; + + const res = await sendStickerTelegram(chatId, fileId, { + token: "tok", + api, + }); + + expect(sendSticker).toHaveBeenCalledWith(chatId, fileId, undefined); + expect(res.messageId).toBe("100"); + expect(res.chatId).toBe(chatId); + }); + + it("throws error when fileId is empty", async () => { + await expect(sendStickerTelegram("123", "", { token: "tok" })).rejects.toThrow( + /file_id is required/i, + ); + }); + + it("throws error when fileId is whitespace only", async () => { + await expect(sendStickerTelegram("123", " ", { token: "tok" })).rejects.toThrow( + /file_id is required/i, + ); + }); + + it("includes message_thread_id for forum topic messages", async () => { + const chatId = "-1001234567890"; + const fileId = "CAACAgIAAxkBAAI...sticker_file_id"; + const sendSticker = vi.fn().mockResolvedValue({ + message_id: 101, + chat: { id: chatId }, + }); + const api = { sendSticker } as unknown as { + sendSticker: typeof sendSticker; + }; + + await sendStickerTelegram(chatId, fileId, { + token: "tok", + api, + messageThreadId: 271, + }); + + expect(sendSticker).toHaveBeenCalledWith(chatId, fileId, { + message_thread_id: 271, + }); + }); + + it("includes reply_to_message_id for threaded replies", async () => { + const chatId = "123"; + const fileId = "CAACAgIAAxkBAAI...sticker_file_id"; + const sendSticker = vi.fn().mockResolvedValue({ + message_id: 102, + chat: { id: chatId }, + }); + const api = { sendSticker } as unknown as { + sendSticker: typeof sendSticker; + }; + + await sendStickerTelegram(chatId, fileId, { + token: "tok", + api, + replyToMessageId: 500, + }); + + expect(sendSticker).toHaveBeenCalledWith(chatId, fileId, { + reply_to_message_id: 500, + }); + }); + + it("includes both thread and reply params for forum topic replies", async () => { + const chatId = "-1001234567890"; + const fileId = "CAACAgIAAxkBAAI...sticker_file_id"; + const sendSticker = vi.fn().mockResolvedValue({ + message_id: 103, + chat: { id: chatId }, + }); + const api = { sendSticker } as unknown as { + sendSticker: typeof sendSticker; + }; + + await sendStickerTelegram(chatId, fileId, { + token: "tok", + api, + messageThreadId: 271, + replyToMessageId: 500, + }); + + expect(sendSticker).toHaveBeenCalledWith(chatId, fileId, { + message_thread_id: 271, + reply_to_message_id: 500, + }); + }); + + it("normalizes chat ids with internal prefixes", async () => { + const sendSticker = vi.fn().mockResolvedValue({ + message_id: 104, + chat: { id: "123" }, + }); + const api = { sendSticker } as unknown as { + sendSticker: typeof sendSticker; + }; + + await sendStickerTelegram("telegram:123", "fileId123", { + token: "tok", + api, + }); + + expect(sendSticker).toHaveBeenCalledWith("123", "fileId123", undefined); + }); + + it("parses message_thread_id from recipient string (telegram:group:...:topic:...)", async () => { + const chatId = "-1001234567890"; + const sendSticker = vi.fn().mockResolvedValue({ + message_id: 105, + chat: { id: chatId }, + }); + const api = { sendSticker } as unknown as { + sendSticker: typeof sendSticker; + }; + + await sendStickerTelegram(`telegram:group:${chatId}:topic:271`, "fileId123", { + token: "tok", + api, + }); + + expect(sendSticker).toHaveBeenCalledWith(chatId, "fileId123", { + message_thread_id: 271, + }); + }); + + it("wraps chat-not-found with actionable context", async () => { + const chatId = "123"; + const err = new Error("400: Bad Request: chat not found"); + const sendSticker = vi.fn().mockRejectedValue(err); + const api = { sendSticker } as unknown as { + sendSticker: typeof sendSticker; + }; + + await expect(sendStickerTelegram(chatId, "fileId123", { token: "tok", api })).rejects.toThrow( + /chat not found/i, + ); + await expect(sendStickerTelegram(chatId, "fileId123", { token: "tok", api })).rejects.toThrow( + /chat_id=123/, + ); + }); + + it("trims whitespace from fileId", async () => { + const chatId = "123"; + const sendSticker = vi.fn().mockResolvedValue({ + message_id: 106, + chat: { id: chatId }, + }); + const api = { sendSticker } as unknown as { + sendSticker: typeof sendSticker; + }; + + await sendStickerTelegram(chatId, " fileId123 ", { + token: "tok", + api, + }); + + expect(sendSticker).toHaveBeenCalledWith(chatId, "fileId123", undefined); + }); +}); diff --git a/src/telegram/send.ts b/src/telegram/send.ts index 92cd3ddc1..7dd79dd1f 100644 --- a/src/telegram/send.ts +++ b/src/telegram/send.ts @@ -619,3 +619,96 @@ function inferFilename(kind: ReturnType) { return "file.bin"; } } + +type TelegramStickerOpts = { + token?: string; + accountId?: string; + verbose?: boolean; + api?: Bot["api"]; + retry?: RetryConfig; + /** Message ID to reply to (for threading) */ + replyToMessageId?: number; + /** Forum topic thread ID (for forum supergroups) */ + messageThreadId?: number; +}; + +/** + * Send a sticker to a Telegram chat by file_id. + * @param to - Chat ID or username (e.g., "123456789" or "@username") + * @param fileId - Telegram file_id of the sticker to send + * @param opts - Optional configuration + */ +export async function sendStickerTelegram( + to: string, + fileId: string, + opts: TelegramStickerOpts = {}, +): Promise { + if (!fileId?.trim()) { + throw new Error("Telegram sticker file_id is required"); + } + + const cfg = loadConfig(); + const account = resolveTelegramAccount({ + cfg, + accountId: opts.accountId, + }); + const token = resolveToken(opts.token, account); + const target = parseTelegramTarget(to); + const chatId = normalizeChatId(target.chatId); + const client = resolveTelegramClientOptions(account); + const api = opts.api ?? new Bot(token, client ? { client } : undefined).api; + + const messageThreadId = + opts.messageThreadId != null ? opts.messageThreadId : target.messageThreadId; + const threadIdParams = buildTelegramThreadParams(messageThreadId); + const threadParams: Record = threadIdParams ? { ...threadIdParams } : {}; + if (opts.replyToMessageId != null) { + threadParams.reply_to_message_id = Math.trunc(opts.replyToMessageId); + } + const hasThreadParams = Object.keys(threadParams).length > 0; + + const request = createTelegramRetryRunner({ + retry: opts.retry, + configRetry: account.config.retry, + verbose: opts.verbose, + }); + const logHttpError = createTelegramHttpLogger(cfg); + const requestWithDiag = (fn: () => Promise, label?: string) => + request(fn, label).catch((err) => { + logHttpError(label ?? "request", err); + throw err; + }); + + const wrapChatNotFound = (err: unknown) => { + if (!/400: Bad Request: chat not found/i.test(formatErrorMessage(err))) return err; + return new Error( + [ + `Telegram send failed: chat not found (chat_id=${chatId}).`, + "Likely: bot not started in DM, bot removed from group/channel, group migrated (new -100… id), or wrong bot token.", + `Input was: ${JSON.stringify(to)}.`, + ].join(" "), + ); + }; + + const stickerParams = hasThreadParams ? threadParams : undefined; + + const result = await requestWithDiag( + () => api.sendSticker(chatId, fileId.trim(), stickerParams), + "sticker", + ).catch((err) => { + throw wrapChatNotFound(err); + }); + + const messageId = String(result?.message_id ?? "unknown"); + const resolvedChatId = String(result?.chat?.id ?? chatId); + if (result?.message_id) { + recordSentMessage(chatId, result.message_id); + } + recordChannelActivity({ + channel: "telegram", + accountId: account.accountId, + direction: "outbound", + }); + + return { messageId, chatId: resolvedChatId }; +} diff --git a/src/telegram/sticker-cache.test.ts b/src/telegram/sticker-cache.test.ts new file mode 100644 index 000000000..7fa3b6af2 --- /dev/null +++ b/src/telegram/sticker-cache.test.ts @@ -0,0 +1,257 @@ +import fs from "node:fs"; +import path from "node:path"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import { + cacheSticker, + getAllCachedStickers, + getCachedSticker, + getCacheStats, + searchStickers, +} from "./sticker-cache.js"; + +// Mock the state directory to use a temp location +vi.mock("../config/paths.js", () => ({ + STATE_DIR_CLAWDBOT: "/tmp/clawdbot-test-sticker-cache", +})); + +const TEST_CACHE_DIR = "/tmp/clawdbot-test-sticker-cache/telegram"; +const TEST_CACHE_FILE = path.join(TEST_CACHE_DIR, "sticker-cache.json"); + +describe("sticker-cache", () => { + beforeEach(() => { + // Clean up before each test + if (fs.existsSync(TEST_CACHE_FILE)) { + fs.unlinkSync(TEST_CACHE_FILE); + } + }); + + afterEach(() => { + // Clean up after each test + if (fs.existsSync(TEST_CACHE_FILE)) { + fs.unlinkSync(TEST_CACHE_FILE); + } + }); + + describe("getCachedSticker", () => { + it("returns null for unknown ID", () => { + const result = getCachedSticker("unknown-id"); + expect(result).toBeNull(); + }); + + it("returns cached sticker after cacheSticker", () => { + const sticker = { + fileId: "file123", + fileUniqueId: "unique123", + emoji: "🎉", + setName: "TestPack", + description: "A party popper emoji sticker", + cachedAt: "2026-01-26T12:00:00.000Z", + }; + + cacheSticker(sticker); + const result = getCachedSticker("unique123"); + + expect(result).toEqual(sticker); + }); + + it("returns null after cache is cleared", () => { + const sticker = { + fileId: "file123", + fileUniqueId: "unique123", + description: "test", + cachedAt: "2026-01-26T12:00:00.000Z", + }; + + cacheSticker(sticker); + expect(getCachedSticker("unique123")).not.toBeNull(); + + // Manually clear the cache file + fs.unlinkSync(TEST_CACHE_FILE); + + expect(getCachedSticker("unique123")).toBeNull(); + }); + }); + + describe("cacheSticker", () => { + it("adds entry to cache", () => { + const sticker = { + fileId: "file456", + fileUniqueId: "unique456", + description: "A cute fox waving", + cachedAt: "2026-01-26T12:00:00.000Z", + }; + + cacheSticker(sticker); + + const all = getAllCachedStickers(); + expect(all).toHaveLength(1); + expect(all[0]).toEqual(sticker); + }); + + it("updates existing entry", () => { + const original = { + fileId: "file789", + fileUniqueId: "unique789", + description: "Original description", + cachedAt: "2026-01-26T12:00:00.000Z", + }; + const updated = { + fileId: "file789-new", + fileUniqueId: "unique789", + description: "Updated description", + cachedAt: "2026-01-26T13:00:00.000Z", + }; + + cacheSticker(original); + cacheSticker(updated); + + const result = getCachedSticker("unique789"); + expect(result?.description).toBe("Updated description"); + expect(result?.fileId).toBe("file789-new"); + }); + }); + + describe("searchStickers", () => { + beforeEach(() => { + // Seed cache with test stickers + cacheSticker({ + fileId: "fox1", + fileUniqueId: "fox-unique-1", + emoji: "🦊", + setName: "CuteFoxes", + description: "A cute orange fox waving hello", + cachedAt: "2026-01-26T10:00:00.000Z", + }); + cacheSticker({ + fileId: "fox2", + fileUniqueId: "fox-unique-2", + emoji: "🦊", + setName: "CuteFoxes", + description: "A fox sleeping peacefully", + cachedAt: "2026-01-26T11:00:00.000Z", + }); + cacheSticker({ + fileId: "cat1", + fileUniqueId: "cat-unique-1", + emoji: "🐱", + setName: "FunnyCats", + description: "A cat sitting on a keyboard", + cachedAt: "2026-01-26T12:00:00.000Z", + }); + cacheSticker({ + fileId: "dog1", + fileUniqueId: "dog-unique-1", + emoji: "🐶", + setName: "GoodBoys", + description: "A golden retriever playing fetch", + cachedAt: "2026-01-26T13:00:00.000Z", + }); + }); + + it("finds stickers by description substring", () => { + const results = searchStickers("fox"); + expect(results).toHaveLength(2); + expect(results.every((s) => s.description.toLowerCase().includes("fox"))).toBe(true); + }); + + it("finds stickers by emoji", () => { + const results = searchStickers("🦊"); + expect(results).toHaveLength(2); + expect(results.every((s) => s.emoji === "🦊")).toBe(true); + }); + + it("finds stickers by set name", () => { + const results = searchStickers("CuteFoxes"); + expect(results).toHaveLength(2); + expect(results.every((s) => s.setName === "CuteFoxes")).toBe(true); + }); + + it("respects limit parameter", () => { + const results = searchStickers("fox", 1); + expect(results).toHaveLength(1); + }); + + it("ranks exact matches higher", () => { + // "waving" appears in "fox waving hello" - should be ranked first + const results = searchStickers("waving"); + expect(results).toHaveLength(1); + expect(results[0]?.fileUniqueId).toBe("fox-unique-1"); + }); + + it("returns empty array for no matches", () => { + const results = searchStickers("elephant"); + expect(results).toHaveLength(0); + }); + + it("is case insensitive", () => { + const results = searchStickers("FOX"); + expect(results).toHaveLength(2); + }); + + it("matches multiple words", () => { + const results = searchStickers("cat keyboard"); + expect(results).toHaveLength(1); + expect(results[0]?.fileUniqueId).toBe("cat-unique-1"); + }); + }); + + describe("getAllCachedStickers", () => { + it("returns empty array when cache is empty", () => { + const result = getAllCachedStickers(); + expect(result).toEqual([]); + }); + + it("returns all cached stickers", () => { + cacheSticker({ + fileId: "a", + fileUniqueId: "a-unique", + description: "Sticker A", + cachedAt: "2026-01-26T10:00:00.000Z", + }); + cacheSticker({ + fileId: "b", + fileUniqueId: "b-unique", + description: "Sticker B", + cachedAt: "2026-01-26T11:00:00.000Z", + }); + + const result = getAllCachedStickers(); + expect(result).toHaveLength(2); + }); + }); + + describe("getCacheStats", () => { + it("returns count 0 when cache is empty", () => { + const stats = getCacheStats(); + expect(stats.count).toBe(0); + expect(stats.oldestAt).toBeUndefined(); + expect(stats.newestAt).toBeUndefined(); + }); + + it("returns correct stats with cached stickers", () => { + cacheSticker({ + fileId: "old", + fileUniqueId: "old-unique", + description: "Old sticker", + cachedAt: "2026-01-20T10:00:00.000Z", + }); + cacheSticker({ + fileId: "new", + fileUniqueId: "new-unique", + description: "New sticker", + cachedAt: "2026-01-26T10:00:00.000Z", + }); + cacheSticker({ + fileId: "mid", + fileUniqueId: "mid-unique", + description: "Middle sticker", + cachedAt: "2026-01-23T10:00:00.000Z", + }); + + const stats = getCacheStats(); + expect(stats.count).toBe(3); + expect(stats.oldestAt).toBe("2026-01-20T10:00:00.000Z"); + expect(stats.newestAt).toBe("2026-01-26T10:00:00.000Z"); + }); + }); +}); diff --git a/src/telegram/sticker-cache.ts b/src/telegram/sticker-cache.ts new file mode 100644 index 000000000..2c55563b7 --- /dev/null +++ b/src/telegram/sticker-cache.ts @@ -0,0 +1,201 @@ +import fs from "node:fs/promises"; +import path from "node:path"; +import type { ClawdbotConfig } from "../config/config.js"; +import { STATE_DIR_CLAWDBOT } from "../config/paths.js"; +import { loadJsonFile, saveJsonFile } from "../infra/json-file.js"; +import { logVerbose } from "../globals.js"; +import { resolveApiKeyForProvider } from "../agents/model-auth.js"; + +const CACHE_FILE = path.join(STATE_DIR_CLAWDBOT, "telegram", "sticker-cache.json"); +const CACHE_VERSION = 1; + +export interface CachedSticker { + fileId: string; + fileUniqueId: string; + emoji?: string; + setName?: string; + description: string; + cachedAt: string; + receivedFrom?: string; +} + +interface StickerCache { + version: number; + stickers: Record; +} + +function loadCache(): StickerCache { + const data = loadJsonFile(CACHE_FILE); + if (!data || typeof data !== "object") { + return { version: CACHE_VERSION, stickers: {} }; + } + const cache = data as StickerCache; + if (cache.version !== CACHE_VERSION) { + // Future: handle migration if needed + return { version: CACHE_VERSION, stickers: {} }; + } + return cache; +} + +function saveCache(cache: StickerCache): void { + saveJsonFile(CACHE_FILE, cache); +} + +/** + * Get a cached sticker by its unique ID. + */ +export function getCachedSticker(fileUniqueId: string): CachedSticker | null { + const cache = loadCache(); + return cache.stickers[fileUniqueId] ?? null; +} + +/** + * Add or update a sticker in the cache. + */ +export function cacheSticker(sticker: CachedSticker): void { + const cache = loadCache(); + cache.stickers[sticker.fileUniqueId] = sticker; + saveCache(cache); +} + +/** + * Search cached stickers by text query (fuzzy match on description + emoji + setName). + */ +export function searchStickers(query: string, limit = 10): CachedSticker[] { + const cache = loadCache(); + const queryLower = query.toLowerCase(); + const results: Array<{ sticker: CachedSticker; score: number }> = []; + + for (const sticker of Object.values(cache.stickers)) { + let score = 0; + const descLower = sticker.description.toLowerCase(); + + // Exact substring match in description + if (descLower.includes(queryLower)) { + score += 10; + } + + // Word-level matching + const queryWords = queryLower.split(/\s+/).filter(Boolean); + const descWords = descLower.split(/\s+/); + for (const qWord of queryWords) { + if (descWords.some((dWord) => dWord.includes(qWord))) { + score += 5; + } + } + + // Emoji match + if (sticker.emoji && query.includes(sticker.emoji)) { + score += 8; + } + + // Set name match + if (sticker.setName?.toLowerCase().includes(queryLower)) { + score += 3; + } + + if (score > 0) { + results.push({ sticker, score }); + } + } + + return results + .sort((a, b) => b.score - a.score) + .slice(0, limit) + .map((r) => r.sticker); +} + +/** + * Get all cached stickers (for debugging/listing). + */ +export function getAllCachedStickers(): CachedSticker[] { + const cache = loadCache(); + return Object.values(cache.stickers); +} + +/** + * Get cache statistics. + */ +export function getCacheStats(): { count: number; oldestAt?: string; newestAt?: string } { + const cache = loadCache(); + const stickers = Object.values(cache.stickers); + if (stickers.length === 0) { + return { count: 0 }; + } + const sorted = [...stickers].sort( + (a, b) => new Date(a.cachedAt).getTime() - new Date(b.cachedAt).getTime(), + ); + return { + count: stickers.length, + oldestAt: sorted[0]?.cachedAt, + newestAt: sorted[sorted.length - 1]?.cachedAt, + }; +} + +const STICKER_DESCRIPTION_PROMPT = + "Describe this sticker image in 1-2 sentences. Focus on what the sticker depicts (character, object, action, emotion). Be concise and objective."; + +const VISION_PROVIDERS = ["anthropic", "openai", "google", "minimax"] as const; +const DEFAULT_VISION_MODELS: Record = { + anthropic: "claude-sonnet-4-20250514", + openai: "gpt-4o-mini", + google: "gemini-2.0-flash", + minimax: "MiniMax-VL-01", +}; + +export interface DescribeStickerParams { + imagePath: string; + cfg: ClawdbotConfig; + agentDir?: string; +} + +/** + * Describe a sticker image using vision API. + * Auto-detects an available vision provider based on configured API keys. + * Returns null if no vision provider is available. + */ +export async function describeStickerImage(params: DescribeStickerParams): Promise { + const { imagePath, cfg, agentDir } = params; + + // Find a vision provider with available API key + let provider: string | null = null; + for (const p of VISION_PROVIDERS) { + try { + await resolveApiKeyForProvider({ provider: p, cfg, agentDir }); + provider = p; + break; + } catch { + // No key for this provider, try next + } + } + + if (!provider) { + logVerbose("telegram: no vision provider available for sticker description"); + return null; + } + + const model = DEFAULT_VISION_MODELS[provider]; + logVerbose(`telegram: describing sticker with ${provider}/${model}`); + + try { + const buffer = await fs.readFile(imagePath); + // Dynamic import to avoid circular dependency + const { describeImageWithModel } = await import("../media-understanding/providers/image.js"); + const result = await describeImageWithModel({ + buffer, + fileName: "sticker.webp", + mime: "image/webp", + prompt: STICKER_DESCRIPTION_PROMPT, + cfg, + agentDir: agentDir ?? "", + provider, + model, + maxTokens: 150, + timeoutMs: 30000, + }); + return result.text; + } catch (err) { + logVerbose(`telegram: failed to describe sticker: ${err}`); + return null; + } +} From 34fea720f8bb2da6b87825c462e48616ab67f194 Mon Sep 17 00:00:00 2001 From: Ayaan Zaidi Date: Tue, 27 Jan 2026 12:47:04 +0530 Subject: [PATCH 002/101] fix(telegram): improve sticker vision + cache (#2548) (thanks @longjos) --- CHANGELOG.md | 1 + docs/channels/telegram.md | 18 ++-- src/agents/tools/telegram-actions.test.ts | 40 ++++++++ src/agents/tools/telegram-actions.ts | 4 +- src/channels/plugins/actions/telegram.test.ts | 7 ++ src/channels/plugins/actions/telegram.ts | 2 +- src/media-understanding/runner.ts | 33 +++++++ src/telegram/bot-message-dispatch.ts | 1 + ...s-media-file-path-no-file-download.test.ts | 97 +++++++++++++++++++ src/telegram/bot/delivery.ts | 22 ++++- src/telegram/sticker-cache.ts | 52 +++++----- 11 files changed, 240 insertions(+), 37 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e6bb640bc..442dd52a0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -53,6 +53,7 @@ Status: unreleased. - Telegram: keep topic IDs in restart sentinel notifications. (#1807) Thanks @hsrvc. - Telegram: add optional silent send flag (disable notifications). (#2382) Thanks @Suksham-sharma. - Telegram: support editing sent messages via message(action="edit"). (#2394) Thanks @marcelomar21. +- Telegram: add sticker receive/send with vision caching. (#2548) Thanks @longjos. - Config: apply config.env before ${VAR} substitution. (#1813) Thanks @spanishflu-est1918. - Slack: clear ack reaction after streamed replies. (#2044) Thanks @fancyboi999. - macOS: keep custom SSH usernames in remote target. (#2046) Thanks @algal. diff --git a/docs/channels/telegram.md b/docs/channels/telegram.md index 2d8c472bd..56920f131 100644 --- a/docs/channels/telegram.md +++ b/docs/channels/telegram.md @@ -395,10 +395,13 @@ When a user sends a sticker, Clawdbot handles it based on the sticker type: - **Animated stickers (TGS):** Skipped (Lottie format not supported for processing). - **Video stickers (WEBM):** Skipped (video format not supported for processing). -Template context fields available when receiving stickers: -- `StickerEmoji` — the emoji associated with the sticker -- `StickerSetName` — the name of the sticker set -- `StickerFileId` — the Telegram file ID (used for sending the same sticker back) +Template context field available when receiving stickers: +- `Sticker` — object with: + - `emoji` — emoji associated with the sticker + - `setName` — name of the sticker set + - `fileId` — Telegram file ID (send the same sticker back) + - `fileUniqueId` — stable ID for cache lookup + - `cachedDescription` — cached vision description when available ### Sticker cache @@ -416,10 +419,11 @@ Stickers are processed through the AI's vision capabilities to generate descript ```json { "fileId": "CAACAgIAAxkBAAI...", + "fileUniqueId": "AgADBAADb6cxG2Y", "emoji": "👋", "setName": "CoolCats", "description": "A cartoon cat waving enthusiastically", - "addedAt": "2026-01-15T10:30:00.000Z" + "cachedAt": "2026-01-15T10:30:00.000Z" } ``` @@ -458,7 +462,7 @@ The agent can send and search stickers using the `sticker` and `sticker-search` ``` Parameters: -- `fileId` (required) — the Telegram file ID of the sticker. Obtain this from `StickerFileId` when receiving a sticker, or from a `sticker-search` result. +- `fileId` (required) — the Telegram file ID of the sticker. Obtain this from `Sticker.fileId` when receiving a sticker, or from a `sticker-search` result. - `replyTo` (optional) — message ID to reply to. - `threadId` (optional) — message thread ID for forum topics. @@ -543,7 +547,7 @@ Outbound Telegram API calls retry on transient network/429 errors with exponenti - Tool: `telegram` with `react` action (`chatId`, `messageId`, `emoji`). - Tool: `telegram` with `deleteMessage` action (`chatId`, `messageId`). - Reaction removal semantics: see [/tools/reactions](/tools/reactions). -- Tool gating: `channels.telegram.actions.reactions`, `channels.telegram.actions.sendMessage`, `channels.telegram.actions.deleteMessage` (default: enabled). +- Tool gating: `channels.telegram.actions.reactions`, `channels.telegram.actions.sendMessage`, `channels.telegram.actions.deleteMessage` (default: enabled), and `channels.telegram.actions.sticker` (default: disabled). ## Reaction notifications diff --git a/src/agents/tools/telegram-actions.test.ts b/src/agents/tools/telegram-actions.test.ts index 5c0629e38..db276849b 100644 --- a/src/agents/tools/telegram-actions.test.ts +++ b/src/agents/tools/telegram-actions.test.ts @@ -8,12 +8,17 @@ const sendMessageTelegram = vi.fn(async () => ({ messageId: "789", chatId: "123", })); +const sendStickerTelegram = vi.fn(async () => ({ + messageId: "456", + chatId: "123", +})); const deleteMessageTelegram = vi.fn(async () => ({ ok: true })); const originalToken = process.env.TELEGRAM_BOT_TOKEN; vi.mock("../../telegram/send.js", () => ({ reactMessageTelegram: (...args: unknown[]) => reactMessageTelegram(...args), sendMessageTelegram: (...args: unknown[]) => sendMessageTelegram(...args), + sendStickerTelegram: (...args: unknown[]) => sendStickerTelegram(...args), deleteMessageTelegram: (...args: unknown[]) => deleteMessageTelegram(...args), })); @@ -21,6 +26,7 @@ describe("handleTelegramAction", () => { beforeEach(() => { reactMessageTelegram.mockClear(); sendMessageTelegram.mockClear(); + sendStickerTelegram.mockClear(); deleteMessageTelegram.mockClear(); process.env.TELEGRAM_BOT_TOKEN = "tok"; }); @@ -96,6 +102,40 @@ describe("handleTelegramAction", () => { ); }); + it("rejects sticker actions when disabled by default", async () => { + const cfg = { channels: { telegram: { botToken: "tok" } } } as ClawdbotConfig; + await expect( + handleTelegramAction( + { + action: "sendSticker", + to: "123", + fileId: "sticker", + }, + cfg, + ), + ).rejects.toThrow(/sticker actions are disabled/i); + expect(sendStickerTelegram).not.toHaveBeenCalled(); + }); + + it("sends stickers when enabled", async () => { + const cfg = { + channels: { telegram: { botToken: "tok", actions: { sticker: true } } }, + } as ClawdbotConfig; + await handleTelegramAction( + { + action: "sendSticker", + to: "123", + fileId: "sticker", + }, + cfg, + ); + expect(sendStickerTelegram).toHaveBeenCalledWith( + "123", + "sticker", + expect.objectContaining({ token: "tok" }), + ); + }); + it("removes reactions when remove flag set", async () => { const cfg = { channels: { telegram: { botToken: "tok", reactionLevel: "extensive" } }, diff --git a/src/agents/tools/telegram-actions.ts b/src/agents/tools/telegram-actions.ts index 40a97d874..d2a4e4b93 100644 --- a/src/agents/tools/telegram-actions.ts +++ b/src/agents/tools/telegram-actions.ts @@ -258,7 +258,7 @@ export async function handleTelegramAction( } if (action === "sendSticker") { - if (!isActionEnabled("sticker")) { + if (!isActionEnabled("sticker", false)) { throw new Error( "Telegram sticker actions are disabled. Set channels.telegram.actions.sticker to true.", ); @@ -291,7 +291,7 @@ export async function handleTelegramAction( } if (action === "searchSticker") { - if (!isActionEnabled("sticker")) { + if (!isActionEnabled("sticker", false)) { throw new Error( "Telegram sticker actions are disabled. Set channels.telegram.actions.sticker to true.", ); diff --git a/src/channels/plugins/actions/telegram.test.ts b/src/channels/plugins/actions/telegram.test.ts index b2673134d..e61a73908 100644 --- a/src/channels/plugins/actions/telegram.test.ts +++ b/src/channels/plugins/actions/telegram.test.ts @@ -10,6 +10,13 @@ vi.mock("../../../agents/tools/telegram-actions.js", () => ({ })); describe("telegramMessageActions", () => { + it("excludes sticker actions when not enabled", () => { + const cfg = { channels: { telegram: { botToken: "tok" } } } as ClawdbotConfig; + const actions = telegramMessageActions.listActions({ cfg }); + expect(actions).not.toContain("sticker"); + expect(actions).not.toContain("sticker-search"); + }); + it("allows media-only sends and passes asVoice", async () => { handleTelegramAction.mockClear(); const cfg = { channels: { telegram: { botToken: "tok" } } } as ClawdbotConfig; diff --git a/src/channels/plugins/actions/telegram.ts b/src/channels/plugins/actions/telegram.ts index f8c7dc0fb..2acfaf9f1 100644 --- a/src/channels/plugins/actions/telegram.ts +++ b/src/channels/plugins/actions/telegram.ts @@ -46,7 +46,7 @@ export const telegramMessageActions: ChannelMessageActionAdapter = { if (gate("reactions")) actions.add("react"); if (gate("deleteMessage")) actions.add("delete"); if (gate("editMessage")) actions.add("edit"); - if (gate("sticker")) { + if (gate("sticker", false)) { actions.add("sticker"); actions.add("sticker-search"); } diff --git a/src/media-understanding/runner.ts b/src/media-understanding/runner.ts index 9e92d67c0..36636c542 100644 --- a/src/media-understanding/runner.ts +++ b/src/media-understanding/runner.ts @@ -412,6 +412,39 @@ async function resolveAutoEntries(params: { return []; } +export async function resolveAutoImageModel(params: { + cfg: ClawdbotConfig; + agentDir?: string; + activeModel?: ActiveMediaModel; +}): Promise { + const providerRegistry = buildProviderRegistry(); + const toActive = (entry: MediaUnderstandingModelConfig | null): ActiveMediaModel | null => { + if (!entry || entry.type === "cli") return null; + const provider = entry.provider; + if (!provider) return null; + const model = entry.model ?? DEFAULT_IMAGE_MODELS[provider]; + if (!model) return null; + return { provider, model }; + }; + const activeEntry = await resolveActiveModelEntry({ + cfg: params.cfg, + agentDir: params.agentDir, + providerRegistry, + capability: "image", + activeModel: params.activeModel, + }); + const resolvedActive = toActive(activeEntry); + if (resolvedActive) return resolvedActive; + const keyEntry = await resolveKeyEntry({ + cfg: params.cfg, + agentDir: params.agentDir, + providerRegistry, + capability: "image", + activeModel: params.activeModel, + }); + return toActive(keyEntry); +} + async function resolveActiveModelEntry(params: { cfg: ClawdbotConfig; agentDir?: string; diff --git a/src/telegram/bot-message-dispatch.ts b/src/telegram/bot-message-dispatch.ts index e24796d6c..a3e9c3faa 100644 --- a/src/telegram/bot-message-dispatch.ts +++ b/src/telegram/bot-message-dispatch.ts @@ -139,6 +139,7 @@ export const dispatchTelegramMessage = async ({ imagePath: ctxPayload.MediaPath, cfg, agentDir, + agentId: route.agentId, }); if (description) { // Format the description with sticker context diff --git a/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts b/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts index dd75e6798..165488426 100644 --- a/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts +++ b/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts @@ -7,6 +7,9 @@ const middlewareUseSpy = vi.fn(); const onSpy = vi.fn(); const stopSpy = vi.fn(); const sendChatActionSpy = vi.fn(); +const cacheStickerSpy = vi.fn(); +const getCachedStickerSpy = vi.fn(); +const describeStickerImageSpy = vi.fn(); type ApiStub = { config: { use: (arg: unknown) => void }; @@ -79,6 +82,12 @@ vi.mock("../config/sessions.js", async (importOriginal) => { }; }); +vi.mock("./sticker-cache.js", () => ({ + cacheSticker: (...args: unknown[]) => cacheStickerSpy(...args), + getCachedSticker: (...args: unknown[]) => getCachedStickerSpy(...args), + describeStickerImage: (...args: unknown[]) => describeStickerImageSpy(...args), +})); + vi.mock("./pairing-store.js", () => ({ readTelegramAllowFromStore: vi.fn(async () => [] as string[]), upsertTelegramPairingRequest: vi.fn(async () => ({ @@ -408,6 +417,12 @@ describe("telegram media groups", () => { describe("telegram stickers", () => { const STICKER_TEST_TIMEOUT_MS = process.platform === "win32" ? 30_000 : 20_000; + beforeEach(() => { + cacheStickerSpy.mockReset(); + getCachedStickerSpy.mockReset(); + describeStickerImageSpy.mockReset(); + }); + it( "downloads static sticker (WEBP) and includes sticker metadata", async () => { @@ -481,6 +496,88 @@ describe("telegram stickers", () => { STICKER_TEST_TIMEOUT_MS, ); + it( + "refreshes cached sticker metadata on cache hit", + async () => { + const { createTelegramBot } = await import("./bot.js"); + const replyModule = await import("../auto-reply/reply.js"); + const replySpy = replyModule.__replySpy as unknown as ReturnType; + + onSpy.mockReset(); + replySpy.mockReset(); + sendChatActionSpy.mockReset(); + + getCachedStickerSpy.mockReturnValue({ + fileId: "old_file_id", + fileUniqueId: "sticker_unique_456", + emoji: "😴", + setName: "OldSet", + description: "Cached description", + cachedAt: "2026-01-20T10:00:00.000Z", + }); + + const runtimeError = vi.fn(); + createTelegramBot({ + token: "tok", + runtime: { + log: vi.fn(), + error: runtimeError, + exit: () => { + throw new Error("exit"); + }, + }, + }); + const handler = onSpy.mock.calls.find((call) => call[0] === "message")?.[1] as ( + ctx: Record, + ) => Promise; + expect(handler).toBeDefined(); + + const fetchSpy = vi.spyOn(globalThis, "fetch" as never).mockResolvedValueOnce({ + ok: true, + status: 200, + statusText: "OK", + headers: { get: () => "image/webp" }, + arrayBuffer: async () => new Uint8Array([0x52, 0x49, 0x46, 0x46]).buffer, + } as Response); + + await handler({ + message: { + message_id: 103, + chat: { id: 1234, type: "private" }, + sticker: { + file_id: "new_file_id", + file_unique_id: "sticker_unique_456", + type: "regular", + width: 512, + height: 512, + is_animated: false, + is_video: false, + emoji: "🔥", + set_name: "NewSet", + }, + date: 1736380800, + }, + me: { username: "clawdbot_bot" }, + getFile: async () => ({ file_path: "stickers/sticker.webp" }), + }); + + expect(runtimeError).not.toHaveBeenCalled(); + expect(cacheStickerSpy).toHaveBeenCalledWith( + expect.objectContaining({ + fileId: "new_file_id", + emoji: "🔥", + setName: "NewSet", + }), + ); + const payload = replySpy.mock.calls[0][0]; + expect(payload.Sticker?.fileId).toBe("new_file_id"); + expect(payload.Sticker?.cachedDescription).toBe("Cached description"); + + fetchSpy.mockRestore(); + }, + STICKER_TEST_TIMEOUT_MS, + ); + it( "skips animated stickers (TGS format)", async () => { diff --git a/src/telegram/bot/delivery.ts b/src/telegram/bot/delivery.ts index f950417c7..779c0c026 100644 --- a/src/telegram/bot/delivery.ts +++ b/src/telegram/bot/delivery.ts @@ -22,7 +22,7 @@ import { buildInlineKeyboard } from "../send.js"; import { resolveTelegramVoiceSend } from "../voice.js"; import { buildTelegramThreadParams, resolveTelegramReplyId } from "./helpers.js"; import type { StickerMetadata, TelegramContext } from "./types.js"; -import { getCachedSticker } from "../sticker-cache.js"; +import { cacheSticker, getCachedSticker } from "../sticker-cache.js"; const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i; const VOICE_FORBIDDEN_RE = /VOICE_MESSAGES_FORBIDDEN/; @@ -303,14 +303,26 @@ export async function resolveMedia( const cached = sticker.file_unique_id ? getCachedSticker(sticker.file_unique_id) : null; if (cached) { logVerbose(`telegram: sticker cache hit for ${sticker.file_unique_id}`); + const fileId = sticker.file_id ?? cached.fileId; + const emoji = sticker.emoji ?? cached.emoji; + const setName = sticker.set_name ?? cached.setName; + if (fileId !== cached.fileId || emoji !== cached.emoji || setName !== cached.setName) { + // Refresh cached sticker metadata on hits so sends/searches use latest file_id. + cacheSticker({ + ...cached, + fileId, + emoji, + setName, + }); + } return { path: saved.path, contentType: saved.contentType, placeholder: "", stickerMetadata: { - emoji: cached.emoji, - setName: cached.setName, - fileId: cached.fileId, + emoji, + setName, + fileId, fileUniqueId: sticker.file_unique_id, cachedDescription: cached.description, }, @@ -330,7 +342,7 @@ export async function resolveMedia( }, }; } catch (err) { - logVerbose(`telegram: failed to process sticker: ${err}`); + logVerbose(`telegram: failed to process sticker: ${String(err)}`); return null; } } diff --git a/src/telegram/sticker-cache.ts b/src/telegram/sticker-cache.ts index 2c55563b7..38f421851 100644 --- a/src/telegram/sticker-cache.ts +++ b/src/telegram/sticker-cache.ts @@ -4,7 +4,13 @@ import type { ClawdbotConfig } from "../config/config.js"; import { STATE_DIR_CLAWDBOT } from "../config/paths.js"; import { loadJsonFile, saveJsonFile } from "../infra/json-file.js"; import { logVerbose } from "../globals.js"; -import { resolveApiKeyForProvider } from "../agents/model-auth.js"; +import { + findModelInCatalog, + loadModelCatalog, + modelSupportsVision, +} from "../agents/model-catalog.js"; +import { resolveDefaultModelForAgent } from "../agents/model-selection.js"; +import { resolveAutoImageModel } from "../media-understanding/runner.js"; const CACHE_FILE = path.join(STATE_DIR_CLAWDBOT, "telegram", "sticker-cache.json"); const CACHE_VERSION = 1; @@ -135,18 +141,11 @@ export function getCacheStats(): { count: number; oldestAt?: string; newestAt?: const STICKER_DESCRIPTION_PROMPT = "Describe this sticker image in 1-2 sentences. Focus on what the sticker depicts (character, object, action, emotion). Be concise and objective."; -const VISION_PROVIDERS = ["anthropic", "openai", "google", "minimax"] as const; -const DEFAULT_VISION_MODELS: Record = { - anthropic: "claude-sonnet-4-20250514", - openai: "gpt-4o-mini", - google: "gemini-2.0-flash", - minimax: "MiniMax-VL-01", -}; - export interface DescribeStickerParams { imagePath: string; cfg: ClawdbotConfig; agentDir?: string; + agentId?: string; } /** @@ -155,26 +154,35 @@ export interface DescribeStickerParams { * Returns null if no vision provider is available. */ export async function describeStickerImage(params: DescribeStickerParams): Promise { - const { imagePath, cfg, agentDir } = params; + const { imagePath, cfg, agentDir, agentId } = params; - // Find a vision provider with available API key - let provider: string | null = null; - for (const p of VISION_PROVIDERS) { - try { - await resolveApiKeyForProvider({ provider: p, cfg, agentDir }); - provider = p; - break; - } catch { - // No key for this provider, try next + const defaultModel = resolveDefaultModelForAgent({ cfg, agentId }); + let activeModel = undefined as { provider: string; model: string } | undefined; + try { + const catalog = await loadModelCatalog({ config: cfg }); + const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model); + if (modelSupportsVision(entry)) { + activeModel = { provider: defaultModel.provider, model: defaultModel.model }; } + } catch { + // Ignore catalog failures; fall back to auto selection. } - if (!provider) { + const resolved = await resolveAutoImageModel({ + cfg, + agentDir, + activeModel, + }); + if (!resolved) { logVerbose("telegram: no vision provider available for sticker description"); return null; } - const model = DEFAULT_VISION_MODELS[provider]; + const { provider, model } = resolved; + if (!model) { + logVerbose(`telegram: no vision model available for ${provider}`); + return null; + } logVerbose(`telegram: describing sticker with ${provider}/${model}`); try { @@ -195,7 +203,7 @@ export async function describeStickerImage(params: DescribeStickerParams): Promi }); return result.text; } catch (err) { - logVerbose(`telegram: failed to describe sticker: ${err}`); + logVerbose(`telegram: failed to describe sticker: ${String(err)}`); return null; } } From 54d6cd70b8b6d4360a5e8f455b50243ac29a890e Mon Sep 17 00:00:00 2001 From: Ayaan Zaidi Date: Tue, 27 Jan 2026 12:56:21 +0530 Subject: [PATCH 003/101] docs: update changelog for #2629 --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 442dd52a0..33dd3dafc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -53,7 +53,7 @@ Status: unreleased. - Telegram: keep topic IDs in restart sentinel notifications. (#1807) Thanks @hsrvc. - Telegram: add optional silent send flag (disable notifications). (#2382) Thanks @Suksham-sharma. - Telegram: support editing sent messages via message(action="edit"). (#2394) Thanks @marcelomar21. -- Telegram: add sticker receive/send with vision caching. (#2548) Thanks @longjos. +- Telegram: add sticker receive/send with vision caching. (#2629) Thanks @longjos. - Config: apply config.env before ${VAR} substitution. (#1813) Thanks @spanishflu-est1918. - Slack: clear ack reaction after streamed replies. (#2044) Thanks @fancyboi999. - macOS: keep custom SSH usernames in remote target. (#2046) Thanks @algal. From d3a6333ef70c5e7bf4e0c7b0340f832218d65316 Mon Sep 17 00:00:00 2001 From: Vignesh Date: Mon, 26 Jan 2026 23:41:35 -0800 Subject: [PATCH 004/101] docs: allow nested gateway security pages (#2641) --- docs/gateway/security-formal-verification.md | 12 -- docs/gateway/security/formal-verification.md | 107 ++++++++++++++++++ .../{security.md => security/index.md} | 0 3 files changed, 107 insertions(+), 12 deletions(-) delete mode 100644 docs/gateway/security-formal-verification.md create mode 100644 docs/gateway/security/formal-verification.md rename docs/gateway/{security.md => security/index.md} (100%) diff --git a/docs/gateway/security-formal-verification.md b/docs/gateway/security-formal-verification.md deleted file mode 100644 index 3fb5d649f..000000000 --- a/docs/gateway/security-formal-verification.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: Formal Verification (Security Models) -summary: Redirect to the canonical Formal Verification page. -permalink: /gateway/security/formal-verification/ ---- - -This page moved to: [/security/formal-verification/](/security/formal-verification/) - - diff --git a/docs/gateway/security/formal-verification.md b/docs/gateway/security/formal-verification.md new file mode 100644 index 000000000..1a450176d --- /dev/null +++ b/docs/gateway/security/formal-verification.md @@ -0,0 +1,107 @@ +--- +title: Formal Verification (Security Models) +summary: Machine-checked security models for Clawdbot’s highest-risk paths. +permalink: /gateway/security/formal-verification/ +--- + +# Formal Verification (Security Models) + +This page tracks Clawdbot’s **formal security models** (TLA+/TLC today; more as needed). + +**Goal (north star):** provide a machine-checked argument that Clawdbot enforces its +intended security policy (authorization, session isolation, tool gating, and +misconfiguration safety), under explicit assumptions. + +**What this is (today):** an executable, attacker-driven **security regression suite**: +- Each claim has a runnable model-check over a finite state space. +- Many claims have a paired **negative model** that produces a counterexample trace for a realistic bug class. + +**What this is not (yet):** a proof that “Clawdbot is secure in all respects” or that the full TypeScript implementation is correct. + +## Where the models live + +Models are maintained in a separate repo: [vignesh07/clawdbot-formal-models](https://github.com/vignesh07/clawdbot-formal-models). + +## Important caveats + +- These are **models**, not the full TypeScript implementation. Drift between model and code is possible. +- Results are bounded by the state space explored by TLC; “green” does not imply security beyond the modeled assumptions and bounds. +- Some claims rely on explicit environmental assumptions (e.g., correct deployment, correct configuration inputs). + +## Reproducing results + +Today, results are reproduced by cloning the models repo locally and running TLC (see below). A future iteration could offer: +- CI-run models with public artifacts (counterexample traces, run logs) +- a hosted “run this model” workflow for small, bounded checks + +Getting started: + +```bash +git clone https://github.com/vignesh07/clawdbot-formal-models +cd clawdbot-formal-models + +# Java 11+ required (TLC runs on the JVM). +# The repo vendors a pinned `tla2tools.jar` (TLA+ tools) and provides `bin/tlc` + Make targets. + +make +``` + +### Gateway exposure and open gateway misconfiguration + +**Claim:** binding beyond loopback without auth can make remote compromise possible / increases exposure; token/password blocks unauth attackers (per the model assumptions). + +- Green runs: + - `make gateway-exposure-v2` + - `make gateway-exposure-v2-protected` +- Red (expected): + - `make gateway-exposure-v2-negative` + +See also: `docs/gateway-exposure-matrix.md` in the models repo. + +### Nodes.run pipeline (highest-risk capability) + +**Claim:** `nodes.run` requires (a) node command allowlist plus declared commands and (b) live approval when configured; approvals are tokenized to prevent replay (in the model). + +- Green runs: + - `make nodes-pipeline` + - `make approvals-token` +- Red (expected): + - `make nodes-pipeline-negative` + - `make approvals-token-negative` + +### Pairing store (DM gating) + +**Claim:** pairing requests respect TTL and pending-request caps. + +- Green runs: + - `make pairing` + - `make pairing-cap` +- Red (expected): + - `make pairing-negative` + - `make pairing-cap-negative` + +### Ingress gating (mentions + control-command bypass) + +**Claim:** in group contexts requiring mention, an unauthorized “control command” cannot bypass mention gating. + +- Green: + - `make ingress-gating` +- Red (expected): + - `make ingress-gating-negative` + +### Routing/session-key isolation + +**Claim:** DMs from distinct peers do not collapse into the same session unless explicitly linked/configured. + +- Green: + - `make routing-isolation` +- Red (expected): + - `make routing-isolation-negative` + +## Roadmap + +Next models to deepen fidelity: +- Pairing store concurrency/locking/idempotency +- Provider-specific ingress preflight modeling +- Routing identity-links + dmScope variants + binding precedence +- Gateway auth conformance (proxy/tailscale specifics) diff --git a/docs/gateway/security.md b/docs/gateway/security/index.md similarity index 100% rename from docs/gateway/security.md rename to docs/gateway/security/index.md From d91b4a30454b9fc0fea989e7caa63003e8c9ec9d Mon Sep 17 00:00:00 2001 From: hougangdev Date: Tue, 27 Jan 2026 09:37:22 +0800 Subject: [PATCH 005/101] feat: improve /help and /commands formatting with categories and pagination - Add CommandCategory type to organize commands into groups (session, options, status, management, media, tools, docks) - Refactor /help to show grouped sections for better discoverability - Add pagination support for /commands on Telegram (8 commands per page with nav buttons) - Show grouped list without pagination on other channels - Handle commands_page_N callback queries for Telegram pagination navigation --- src/auto-reply/commands-registry.data.ts | 38 ++- src/auto-reply/commands-registry.types.ts | 10 + src/auto-reply/reply/commands-info.ts | 57 ++++- src/auto-reply/status.ts | 282 ++++++++++++++++++---- src/telegram/bot-handlers.ts | 45 ++++ 5 files changed, 384 insertions(+), 48 deletions(-) diff --git a/src/auto-reply/commands-registry.data.ts b/src/auto-reply/commands-registry.data.ts index 5ba6826fe..1e2ebeb57 100644 --- a/src/auto-reply/commands-registry.data.ts +++ b/src/auto-reply/commands-registry.data.ts @@ -2,7 +2,11 @@ import { listChannelDocks } from "../channels/dock.js"; import { getActivePluginRegistry } from "../plugins/runtime.js"; import { listThinkingLevels } from "./thinking.js"; import { COMMAND_ARG_FORMATTERS } from "./commands-args.js"; -import type { ChatCommandDefinition, CommandScope } from "./commands-registry.types.js"; +import type { + ChatCommandDefinition, + CommandCategory, + CommandScope, +} from "./commands-registry.types.js"; type DefineChatCommandInput = { key: string; @@ -16,6 +20,7 @@ type DefineChatCommandInput = { textAlias?: string; textAliases?: string[]; scope?: CommandScope; + category?: CommandCategory; }; function defineChatCommand(command: DefineChatCommandInput): ChatCommandDefinition { @@ -37,6 +42,7 @@ function defineChatCommand(command: DefineChatCommandInput): ChatCommandDefiniti argsMenu: command.argsMenu, textAliases: aliases, scope, + category: command.category, }; } @@ -48,6 +54,7 @@ function defineDockCommand(dock: ChannelDock): ChatCommandDefinition { nativeName: `dock_${dock.id}`, description: `Switch to ${dock.id} for replies.`, textAliases: [`/dock-${dock.id}`, `/dock_${dock.id}`], + category: "docks", }); } @@ -124,18 +131,21 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "help", description: "Show available commands.", textAlias: "/help", + category: "status", }), defineChatCommand({ key: "commands", nativeName: "commands", description: "List all slash commands.", textAlias: "/commands", + category: "status", }), defineChatCommand({ key: "skill", nativeName: "skill", description: "Run a skill by name.", textAlias: "/skill", + category: "tools", args: [ { name: "name", @@ -156,6 +166,7 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "status", description: "Show current status.", textAlias: "/status", + category: "status", }), defineChatCommand({ key: "allowlist", @@ -163,6 +174,7 @@ function buildChatCommands(): ChatCommandDefinition[] { textAlias: "/allowlist", acceptsArgs: true, scope: "text", + category: "management", }), defineChatCommand({ key: "approve", @@ -170,6 +182,7 @@ function buildChatCommands(): ChatCommandDefinition[] { description: "Approve or deny exec requests.", textAlias: "/approve", acceptsArgs: true, + category: "management", }), defineChatCommand({ key: "context", @@ -177,12 +190,14 @@ function buildChatCommands(): ChatCommandDefinition[] { description: "Explain how context is built and used.", textAlias: "/context", acceptsArgs: true, + category: "status", }), defineChatCommand({ key: "tts", nativeName: "tts", description: "Control text-to-speech (TTS).", textAlias: "/tts", + category: "media", args: [ { name: "action", @@ -225,12 +240,14 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "whoami", description: "Show your sender id.", textAlias: "/whoami", + category: "status", }), defineChatCommand({ key: "subagents", nativeName: "subagents", description: "List/stop/log/info subagent runs for this session.", textAlias: "/subagents", + category: "management", args: [ { name: "action", @@ -257,6 +274,7 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "config", description: "Show or set config values.", textAlias: "/config", + category: "management", args: [ { name: "action", @@ -284,6 +302,7 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "debug", description: "Set runtime debug overrides.", textAlias: "/debug", + category: "management", args: [ { name: "action", @@ -311,6 +330,7 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "usage", description: "Usage footer or cost summary.", textAlias: "/usage", + category: "options", args: [ { name: "mode", @@ -326,18 +346,21 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "stop", description: "Stop the current run.", textAlias: "/stop", + category: "session", }), defineChatCommand({ key: "restart", nativeName: "restart", description: "Restart Clawdbot.", textAlias: "/restart", + category: "tools", }), defineChatCommand({ key: "activation", nativeName: "activation", description: "Set group activation mode.", textAlias: "/activation", + category: "management", args: [ { name: "mode", @@ -353,6 +376,7 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "send", description: "Set send policy.", textAlias: "/send", + category: "management", args: [ { name: "mode", @@ -369,6 +393,7 @@ function buildChatCommands(): ChatCommandDefinition[] { description: "Reset the current session.", textAlias: "/reset", acceptsArgs: true, + category: "session", }), defineChatCommand({ key: "new", @@ -376,12 +401,14 @@ function buildChatCommands(): ChatCommandDefinition[] { description: "Start a new session.", textAlias: "/new", acceptsArgs: true, + category: "session", }), defineChatCommand({ key: "compact", description: "Compact the session context.", textAlias: "/compact", scope: "text", + category: "session", args: [ { name: "instructions", @@ -396,6 +423,7 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "think", description: "Set thinking level.", textAlias: "/think", + category: "options", args: [ { name: "level", @@ -411,6 +439,7 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "verbose", description: "Toggle verbose mode.", textAlias: "/verbose", + category: "options", args: [ { name: "mode", @@ -426,6 +455,7 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "reasoning", description: "Toggle reasoning visibility.", textAlias: "/reasoning", + category: "options", args: [ { name: "mode", @@ -441,6 +471,7 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "elevated", description: "Toggle elevated mode.", textAlias: "/elevated", + category: "options", args: [ { name: "mode", @@ -456,6 +487,7 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "exec", description: "Set exec defaults for this session.", textAlias: "/exec", + category: "options", args: [ { name: "options", @@ -470,6 +502,7 @@ function buildChatCommands(): ChatCommandDefinition[] { nativeName: "model", description: "Show or set the model.", textAlias: "/model", + category: "options", args: [ { name: "model", @@ -485,12 +518,14 @@ function buildChatCommands(): ChatCommandDefinition[] { textAlias: "/models", argsParsing: "none", acceptsArgs: true, + category: "options", }), defineChatCommand({ key: "queue", nativeName: "queue", description: "Adjust queue settings.", textAlias: "/queue", + category: "options", args: [ { name: "mode", @@ -523,6 +558,7 @@ function buildChatCommands(): ChatCommandDefinition[] { description: "Run host shell commands (host-only).", textAlias: "/bash", scope: "text", + category: "tools", args: [ { name: "command", diff --git a/src/auto-reply/commands-registry.types.ts b/src/auto-reply/commands-registry.types.ts index 5e5bdd8cb..6b9371604 100644 --- a/src/auto-reply/commands-registry.types.ts +++ b/src/auto-reply/commands-registry.types.ts @@ -2,6 +2,15 @@ import type { ClawdbotConfig } from "../config/types.js"; export type CommandScope = "text" | "native" | "both"; +export type CommandCategory = + | "session" + | "options" + | "status" + | "management" + | "media" + | "tools" + | "docks"; + export type CommandArgType = "string" | "number" | "boolean"; export type CommandArgChoiceContext = { @@ -51,6 +60,7 @@ export type ChatCommandDefinition = { formatArgs?: (values: CommandArgValues) => string | undefined; argsMenu?: CommandArgMenuSpec | "auto"; scope: CommandScope; + category?: CommandCategory; }; export type NativeCommandSpec = { diff --git a/src/auto-reply/reply/commands-info.ts b/src/auto-reply/reply/commands-info.ts index 1a525150c..eec7053a7 100644 --- a/src/auto-reply/reply/commands-info.ts +++ b/src/auto-reply/reply/commands-info.ts @@ -1,6 +1,10 @@ import { logVerbose } from "../../globals.js"; import { listSkillCommandsForWorkspace } from "../skill-commands.js"; -import { buildCommandsMessage, buildHelpMessage } from "../status.js"; +import { + buildCommandsMessage, + buildCommandsMessagePaginated, + buildHelpMessage, +} from "../status.js"; import { buildStatusReply } from "./commands-status.js"; import { buildContextReply } from "./commands-context-report.js"; import type { CommandHandler } from "./commands-types.js"; @@ -35,12 +39,61 @@ export const handleCommandsListCommand: CommandHandler = async (params, allowTex workspaceDir: params.workspaceDir, cfg: params.cfg, }); + const surface = params.ctx.Surface; + + // For Telegram, return paginated result with inline buttons + if (surface === "telegram") { + const result = buildCommandsMessagePaginated(params.cfg, skillCommands, { + page: 1, + surface, + }); + + // Build inline keyboard for pagination if there are multiple pages + if (result.totalPages > 1) { + return { + shouldContinue: false, + reply: { + text: result.text, + channelData: { + telegram: { + buttons: buildCommandsPaginationKeyboard(result.currentPage, result.totalPages), + }, + }, + }, + }; + } + + return { + shouldContinue: false, + reply: { text: result.text }, + }; + } + return { shouldContinue: false, - reply: { text: buildCommandsMessage(params.cfg, skillCommands) }, + reply: { text: buildCommandsMessage(params.cfg, skillCommands, { surface }) }, }; }; +export function buildCommandsPaginationKeyboard( + currentPage: number, + totalPages: number, +): Array> { + const buttons: Array<{ text: string; callback_data: string }> = []; + + if (currentPage > 1) { + buttons.push({ text: "◀ Prev", callback_data: `commands_page_${currentPage - 1}` }); + } + + buttons.push({ text: `${currentPage}/${totalPages}`, callback_data: "commands_page_noop" }); + + if (currentPage < totalPages) { + buttons.push({ text: "Next ▶", callback_data: `commands_page_${currentPage + 1}` }); + } + + return [buttons]; +} + export const handleStatusCommand: CommandHandler = async (params, allowTextCommands) => { if (!allowTextCommands) return null; const statusRequested = diff --git a/src/auto-reply/status.ts b/src/auto-reply/status.ts index 733205c8c..713815f4f 100644 --- a/src/auto-reply/status.ts +++ b/src/auto-reply/status.ts @@ -29,7 +29,12 @@ import { resolveModelCostConfig, } from "../utils/usage-format.js"; import { VERSION } from "../version.js"; -import { listChatCommands, listChatCommandsForConfig } from "./commands-registry.js"; +import { + listChatCommands, + listChatCommandsForConfig, + type ChatCommandDefinition, +} from "./commands-registry.js"; +import type { CommandCategory } from "./commands-registry.types.js"; import { listPluginCommands } from "../plugins/commands.js"; import type { SkillCommandSpec } from "../agents/skills.js"; import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "./thinking.js"; @@ -427,61 +432,248 @@ export function buildStatusMessage(args: StatusArgs): string { .join("\n"); } +const CATEGORY_LABELS: Record = { + session: "Session", + options: "Options", + status: "Status", + management: "Management", + media: "Media", + tools: "Tools", + docks: "Docks", +}; + +const CATEGORY_ORDER: CommandCategory[] = [ + "session", + "options", + "status", + "management", + "media", + "tools", + "docks", +]; + +function groupCommandsByCategory( + commands: ChatCommandDefinition[], +): Map { + const grouped = new Map(); + for (const category of CATEGORY_ORDER) { + grouped.set(category, []); + } + for (const command of commands) { + const category = command.category ?? "tools"; + const list = grouped.get(category) ?? []; + list.push(command); + grouped.set(category, list); + } + return grouped; +} + export function buildHelpMessage(cfg?: ClawdbotConfig): string { - const options = [ - "/think ", - "/verbose on|full|off", - "/reasoning on|off", - "/elevated on|off|ask|full", - "/model ", - "/usage off|tokens|full", - ]; - if (cfg?.commands?.config === true) options.push("/config show"); - if (cfg?.commands?.debug === true) options.push("/debug show"); - return [ - "ℹ️ Help", - "Shortcuts: /new reset | /compact [instructions] | /restart relink (if enabled)", - `Options: ${options.join(" | ")}`, - "Skills: /skill [input]", - "More: /commands for all slash commands", - ].join("\n"); + const lines = ["ℹ️ Help", ""]; + + // Session commands - quick shortcuts + lines.push("Session"); + lines.push(" /new | /reset | /compact [instructions] | /stop"); + lines.push(""); + + // Options - most commonly used + const optionParts = ["/think ", "/model ", "/verbose on|off"]; + if (cfg?.commands?.config === true) optionParts.push("/config"); + if (cfg?.commands?.debug === true) optionParts.push("/debug"); + lines.push("Options"); + lines.push(` ${optionParts.join(" | ")}`); + lines.push(""); + + // Status commands + lines.push("Status"); + lines.push(" /status | /whoami | /context"); + lines.push(""); + + // Skills + lines.push("Skills"); + lines.push(" /skill [input]"); + + lines.push(""); + lines.push("More: /commands for full list"); + + return lines.join("\n"); +} + +const COMMANDS_PER_PAGE = 8; + +export type CommandsMessageOptions = { + page?: number; + surface?: string; +}; + +export type CommandsMessageResult = { + text: string; + totalPages: number; + currentPage: number; + hasNext: boolean; + hasPrev: boolean; +}; + +function formatCommandEntry(command: ChatCommandDefinition): string { + const primary = command.nativeName + ? `/${command.nativeName}` + : command.textAliases[0]?.trim() || `/${command.key}`; + const seen = new Set(); + const aliases = command.textAliases + .map((alias) => alias.trim()) + .filter(Boolean) + .filter((alias) => alias.toLowerCase() !== primary.toLowerCase()) + .filter((alias) => { + const key = alias.toLowerCase(); + if (seen.has(key)) return false; + seen.add(key); + return true; + }); + const aliasLabel = aliases.length ? ` (${aliases.join(", ")})` : ""; + const scopeLabel = command.scope === "text" ? " [text]" : ""; + return `${primary}${aliasLabel}${scopeLabel} - ${command.description}`; } export function buildCommandsMessage( cfg?: ClawdbotConfig, skillCommands?: SkillCommandSpec[], + options?: CommandsMessageOptions, ): string { - const lines = ["ℹ️ Slash commands"]; + const result = buildCommandsMessagePaginated(cfg, skillCommands, options); + return result.text; +} + +export function buildCommandsMessagePaginated( + cfg?: ClawdbotConfig, + skillCommands?: SkillCommandSpec[], + options?: CommandsMessageOptions, +): CommandsMessageResult { + const page = Math.max(1, options?.page ?? 1); + const surface = options?.surface?.toLowerCase(); + const isTelegram = surface === "telegram"; + const commands = cfg ? listChatCommandsForConfig(cfg, { skillCommands }) : listChatCommands({ skillCommands }); - for (const command of commands) { - const primary = command.nativeName - ? `/${command.nativeName}` - : command.textAliases[0]?.trim() || `/${command.key}`; - const seen = new Set(); - const aliases = command.textAliases - .map((alias) => alias.trim()) - .filter(Boolean) - .filter((alias) => alias.toLowerCase() !== primary.toLowerCase()) - .filter((alias) => { - const key = alias.toLowerCase(); - if (seen.has(key)) return false; - seen.add(key); - return true; - }); - const aliasLabel = aliases.length ? ` (aliases: ${aliases.join(", ")})` : ""; - const scopeLabel = command.scope === "text" ? " (text-only)" : ""; - lines.push(`${primary}${aliasLabel}${scopeLabel} - ${command.description}`); - } const pluginCommands = listPluginCommands(); - if (pluginCommands.length > 0) { - lines.push(""); - lines.push("Plugin commands:"); - for (const command of pluginCommands) { - const pluginLabel = command.pluginId ? ` (plugin: ${command.pluginId})` : ""; - lines.push(`/${command.name}${pluginLabel} - ${command.description}`); + + // For non-Telegram surfaces, show grouped list without pagination + if (!isTelegram) { + const grouped = groupCommandsByCategory(commands); + const lines = ["ℹ️ Slash commands", ""]; + + for (const category of CATEGORY_ORDER) { + const categoryCommands = grouped.get(category) ?? []; + if (categoryCommands.length === 0) continue; + + lines.push(`${CATEGORY_LABELS[category]}`); + for (const command of categoryCommands) { + lines.push(` ${formatCommandEntry(command)}`); + } + lines.push(""); + } + + if (pluginCommands.length > 0) { + lines.push("Plugins"); + for (const command of pluginCommands) { + const pluginLabel = command.pluginId ? ` (${command.pluginId})` : ""; + lines.push(` /${command.name}${pluginLabel} - ${command.description}`); + } + } + + return { + text: lines.join("\n").trim(), + totalPages: 1, + currentPage: 1, + hasNext: false, + hasPrev: false, + }; + } + + // For Telegram, use pagination + const grouped = groupCommandsByCategory(commands); + + // Flatten commands with category headers for pagination + type PageItem = + | { type: "header"; category: CommandCategory } + | { type: "command"; command: ChatCommandDefinition }; + const items: PageItem[] = []; + + for (const category of CATEGORY_ORDER) { + const categoryCommands = grouped.get(category) ?? []; + if (categoryCommands.length === 0) continue; + items.push({ type: "header", category }); + for (const command of categoryCommands) { + items.push({ type: "command", command }); } } - return lines.join("\n"); + + // Add plugin commands + if (pluginCommands.length > 0) { + items.push({ type: "header", category: "tools" }); // Reuse tools category for plugins header indicator + } + + // Calculate pages based on command count (headers don't count toward limit) + const commandItems = items.filter((item) => item.type === "command"); + const totalCommands = commandItems.length + pluginCommands.length; + const totalPages = Math.max(1, Math.ceil(totalCommands / COMMANDS_PER_PAGE)); + const currentPage = Math.min(page, totalPages); + const startIndex = (currentPage - 1) * COMMANDS_PER_PAGE; + const endIndex = startIndex + COMMANDS_PER_PAGE; + + // Build page content + const lines = [`ℹ️ Commands (${currentPage}/${totalPages})`, ""]; + + let commandIndex = 0; + let currentCategory: CommandCategory | null = null; + let pageCommandCount = 0; + + for (const item of items) { + if (pageCommandCount >= COMMANDS_PER_PAGE) break; + + if (item.type === "header") { + currentCategory = item.category; + continue; + } + + if (commandIndex >= startIndex && commandIndex < endIndex) { + // Add category header if this is the first command of a category on this page + if ( + (currentCategory && pageCommandCount === 0) || + items[items.indexOf(item) - 1]?.type === "header" + ) { + if (currentCategory) { + if (pageCommandCount > 0) lines.push(""); + lines.push(CATEGORY_LABELS[currentCategory]); + } + } + lines.push(` ${formatCommandEntry(item.command)}`); + pageCommandCount++; + } + commandIndex++; + } + + // Add plugin commands if they fall within this page range + const pluginStartIndex = commandItems.length; + for (let i = 0; i < pluginCommands.length && pageCommandCount < COMMANDS_PER_PAGE; i++) { + const pluginIndex = pluginStartIndex + i; + if (pluginIndex >= startIndex && pluginIndex < endIndex) { + if (i === 0 || pluginIndex === startIndex) { + if (pageCommandCount > 0) lines.push(""); + lines.push("Plugins"); + } + const command = pluginCommands[i]; + const pluginLabel = command.pluginId ? ` (${command.pluginId})` : ""; + lines.push(` /${command.name}${pluginLabel} - ${command.description}`); + pageCommandCount++; + } + } + + return { + text: lines.join("\n"), + totalPages, + currentPage, + hasNext: currentPage < totalPages, + hasPrev: currentPage > 1, + }; } diff --git a/src/telegram/bot-handlers.ts b/src/telegram/bot-handlers.ts index 7a5b88fd7..f4acafc19 100644 --- a/src/telegram/bot-handlers.ts +++ b/src/telegram/bot-handlers.ts @@ -4,6 +4,9 @@ import { createInboundDebouncer, resolveInboundDebounceMs, } from "../auto-reply/inbound-debounce.js"; +import { buildCommandsPaginationKeyboard } from "../auto-reply/reply/commands-info.js"; +import { buildCommandsMessagePaginated } from "../auto-reply/status.js"; +import { listSkillCommandsForAgents } from "../auto-reply/skill-commands.js"; import { loadConfig } from "../config/config.js"; import { writeConfigFile } from "../config/io.js"; import { danger, logVerbose, warn } from "../globals.js"; @@ -17,6 +20,7 @@ import { migrateTelegramGroupConfig } from "./group-migration.js"; import { resolveTelegramInlineButtonsScope } from "./inline-buttons.js"; import { readTelegramAllowFromStore } from "./pairing-store.js"; import { resolveChannelConfigWrites } from "../channels/plugins/config-writes.js"; +import { buildInlineKeyboard } from "./send.js"; export const registerTelegramHandlers = ({ cfg, @@ -199,6 +203,47 @@ export const registerTelegramHandlers = ({ const callbackMessage = callback.message; if (!data || !callbackMessage) return; + // Handle commands pagination callback + const paginationMatch = data.match(/^commands_page_(\d+|noop)$/); + if (paginationMatch) { + const pageValue = paginationMatch[1]; + if (pageValue === "noop") return; // Page number button - no action + + const page = parseInt(pageValue, 10); + if (isNaN(page) || page < 1) return; + + const skillCommands = listSkillCommandsForAgents({ cfg }); + const result = buildCommandsMessagePaginated(cfg, skillCommands, { + page, + surface: "telegram", + }); + + const messageId = callbackMessage.message_id; + const chatId = callbackMessage.chat.id; + const keyboard = + result.totalPages > 1 + ? buildInlineKeyboard( + buildCommandsPaginationKeyboard(result.currentPage, result.totalPages), + ) + : undefined; + + try { + await bot.api.editMessageText( + chatId, + messageId, + result.text, + keyboard ? { reply_markup: keyboard } : undefined, + ); + } catch (editErr) { + // Ignore "message is not modified" errors (user clicked same page) + const errStr = String(editErr); + if (!errStr.includes("message is not modified")) { + throw editErr; + } + } + return; + } + const inlineButtonsScope = resolveTelegramInlineButtonsScope({ cfg, accountId, From 97440eaf527d3b8443f729f630a4037fbf61ca41 Mon Sep 17 00:00:00 2001 From: hougangdev Date: Tue, 27 Jan 2026 10:18:53 +0800 Subject: [PATCH 006/101] test: update status tests for new help/commands format --- src/auto-reply/status.test.ts | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/auto-reply/status.test.ts b/src/auto-reply/status.test.ts index 31b6b92ec..edefaf283 100644 --- a/src/auto-reply/status.test.ts +++ b/src/auto-reply/status.test.ts @@ -402,8 +402,8 @@ describe("buildCommandsMessage", () => { } as ClawdbotConfig); expect(text).toContain("/commands - List all slash commands."); expect(text).toContain("/skill - Run a skill by name."); - expect(text).toContain("/think (aliases: /thinking, /t) - Set thinking level."); - expect(text).toContain("/compact (text-only) - Compact the session context."); + expect(text).toContain("/think (/thinking, /t) - Set thinking level."); + expect(text).toContain("/compact [text] - Compact the session context."); expect(text).not.toContain("/config"); expect(text).not.toContain("/debug"); }); @@ -430,7 +430,8 @@ describe("buildHelpMessage", () => { const text = buildHelpMessage({ commands: { config: false, debug: false }, } as ClawdbotConfig); - expect(text).toContain("Skills: /skill [input]"); + expect(text).toContain("Skills"); + expect(text).toContain("/skill [input]"); expect(text).not.toContain("/config"); expect(text).not.toContain("/debug"); }); From cc1782b1055fda77ef89bcc023a23c1c1bad1c74 Mon Sep 17 00:00:00 2001 From: Gustavo Madeira Santana Date: Tue, 27 Jan 2026 02:35:09 -0500 Subject: [PATCH 007/101] fix: tighten commands output + telegram pagination (#2504) Co-authored-by: hougangdev --- src/auto-reply/reply/commands-info.test.ts | 13 ++ src/auto-reply/reply/commands-info.ts | 31 +++-- src/auto-reply/status.test.ts | 47 ++++++- src/auto-reply/status.ts | 155 ++++++++------------- src/telegram/bot-handlers.ts | 42 ++++++ src/telegram/bot.test.ts | 85 +++++++++++ 6 files changed, 263 insertions(+), 110 deletions(-) create mode 100644 src/auto-reply/reply/commands-info.test.ts diff --git a/src/auto-reply/reply/commands-info.test.ts b/src/auto-reply/reply/commands-info.test.ts new file mode 100644 index 000000000..9751c39cc --- /dev/null +++ b/src/auto-reply/reply/commands-info.test.ts @@ -0,0 +1,13 @@ +import { describe, expect, it } from "vitest"; +import { buildCommandsPaginationKeyboard } from "./commands-info.js"; + +describe("buildCommandsPaginationKeyboard", () => { + it("adds agent id to callback data when provided", () => { + const keyboard = buildCommandsPaginationKeyboard(2, 3, "agent-main"); + expect(keyboard[0]).toEqual([ + { text: "◀ Prev", callback_data: "commands_page_1:agent-main" }, + { text: "2/3", callback_data: "commands_page_noop:agent-main" }, + { text: "Next ▶", callback_data: "commands_page_3:agent-main" }, + ]); + }); +}); diff --git a/src/auto-reply/reply/commands-info.ts b/src/auto-reply/reply/commands-info.ts index eec7053a7..e7d8a8f6f 100644 --- a/src/auto-reply/reply/commands-info.ts +++ b/src/auto-reply/reply/commands-info.ts @@ -1,5 +1,5 @@ import { logVerbose } from "../../globals.js"; -import { listSkillCommandsForWorkspace } from "../skill-commands.js"; +import { listSkillCommandsForAgents } from "../skill-commands.js"; import { buildCommandsMessage, buildCommandsMessagePaginated, @@ -35,20 +35,18 @@ export const handleCommandsListCommand: CommandHandler = async (params, allowTex } const skillCommands = params.skillCommands ?? - listSkillCommandsForWorkspace({ - workspaceDir: params.workspaceDir, + listSkillCommandsForAgents({ cfg: params.cfg, + agentIds: params.agentId ? [params.agentId] : undefined, }); const surface = params.ctx.Surface; - // For Telegram, return paginated result with inline buttons if (surface === "telegram") { const result = buildCommandsMessagePaginated(params.cfg, skillCommands, { page: 1, surface, }); - // Build inline keyboard for pagination if there are multiple pages if (result.totalPages > 1) { return { shouldContinue: false, @@ -56,7 +54,11 @@ export const handleCommandsListCommand: CommandHandler = async (params, allowTex text: result.text, channelData: { telegram: { - buttons: buildCommandsPaginationKeyboard(result.currentPage, result.totalPages), + buttons: buildCommandsPaginationKeyboard( + result.currentPage, + result.totalPages, + params.agentId, + ), }, }, }, @@ -78,17 +80,28 @@ export const handleCommandsListCommand: CommandHandler = async (params, allowTex export function buildCommandsPaginationKeyboard( currentPage: number, totalPages: number, + agentId?: string, ): Array> { const buttons: Array<{ text: string; callback_data: string }> = []; + const suffix = agentId ? `:${agentId}` : ""; if (currentPage > 1) { - buttons.push({ text: "◀ Prev", callback_data: `commands_page_${currentPage - 1}` }); + buttons.push({ + text: "◀ Prev", + callback_data: `commands_page_${currentPage - 1}${suffix}`, + }); } - buttons.push({ text: `${currentPage}/${totalPages}`, callback_data: "commands_page_noop" }); + buttons.push({ + text: `${currentPage}/${totalPages}`, + callback_data: `commands_page_noop${suffix}`, + }); if (currentPage < totalPages) { - buttons.push({ text: "Next ▶", callback_data: `commands_page_${currentPage + 1}` }); + buttons.push({ + text: "Next ▶", + callback_data: `commands_page_${currentPage + 1}${suffix}`, + }); } return [buttons]; diff --git a/src/auto-reply/status.test.ts b/src/auto-reply/status.test.ts index edefaf283..465352538 100644 --- a/src/auto-reply/status.test.ts +++ b/src/auto-reply/status.test.ts @@ -4,7 +4,20 @@ import { afterEach, describe, expect, it, vi } from "vitest"; import { normalizeTestText } from "../../test/helpers/normalize-text.js"; import { withTempHome } from "../../test/helpers/temp-home.js"; import type { ClawdbotConfig } from "../config/config.js"; -import { buildCommandsMessage, buildHelpMessage, buildStatusMessage } from "./status.js"; +import { + buildCommandsMessage, + buildCommandsMessagePaginated, + buildHelpMessage, + buildStatusMessage, +} from "./status.js"; + +const { listPluginCommands } = vi.hoisted(() => ({ + listPluginCommands: vi.fn(() => []), +})); + +vi.mock("../plugins/commands.js", () => ({ + listPluginCommands, +})); afterEach(() => { vi.restoreAllMocks(); @@ -400,6 +413,8 @@ describe("buildCommandsMessage", () => { const text = buildCommandsMessage({ commands: { config: false, debug: false }, } as ClawdbotConfig); + expect(text).toContain("ℹ️ Slash commands"); + expect(text).toContain("Status"); expect(text).toContain("/commands - List all slash commands."); expect(text).toContain("/skill - Run a skill by name."); expect(text).toContain("/think (/thinking, /t) - Set thinking level."); @@ -436,3 +451,33 @@ describe("buildHelpMessage", () => { expect(text).not.toContain("/debug"); }); }); + +describe("buildCommandsMessagePaginated", () => { + it("formats telegram output with pages", () => { + const result = buildCommandsMessagePaginated( + { + commands: { config: false, debug: false }, + } as ClawdbotConfig, + undefined, + { surface: "telegram", page: 1 }, + ); + expect(result.text).toContain("ℹ️ Commands (1/"); + expect(result.text).toContain("Session"); + expect(result.text).toContain("/stop - Stop the current run."); + }); + + it("includes plugin commands in the paginated list", () => { + listPluginCommands.mockReturnValue([ + { name: "plugin_cmd", description: "Plugin command", pluginId: "demo-plugin" }, + ]); + const result = buildCommandsMessagePaginated( + { + commands: { config: false, debug: false }, + } as ClawdbotConfig, + undefined, + { surface: "telegram", page: 99 }, + ); + expect(result.text).toContain("Plugins"); + expect(result.text).toContain("/plugin_cmd (demo-plugin) - Plugin command"); + }); +}); diff --git a/src/auto-reply/status.ts b/src/auto-reply/status.ts index 713815f4f..7344b7502 100644 --- a/src/auto-reply/status.ts +++ b/src/auto-reply/status.ts @@ -34,9 +34,9 @@ import { listChatCommandsForConfig, type ChatCommandDefinition, } from "./commands-registry.js"; -import type { CommandCategory } from "./commands-registry.types.js"; import { listPluginCommands } from "../plugins/commands.js"; import type { SkillCommandSpec } from "../agents/skills.js"; +import type { CommandCategory } from "./commands-registry.types.js"; import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "./thinking.js"; import type { MediaUnderstandingDecision } from "../media-understanding/types.js"; @@ -471,12 +471,10 @@ function groupCommandsByCategory( export function buildHelpMessage(cfg?: ClawdbotConfig): string { const lines = ["ℹ️ Help", ""]; - // Session commands - quick shortcuts lines.push("Session"); lines.push(" /new | /reset | /compact [instructions] | /stop"); lines.push(""); - // Options - most commonly used const optionParts = ["/think ", "/model ", "/verbose on|off"]; if (cfg?.commands?.config === true) optionParts.push("/config"); if (cfg?.commands?.debug === true) optionParts.push("/debug"); @@ -484,12 +482,10 @@ export function buildHelpMessage(cfg?: ClawdbotConfig): string { lines.push(` ${optionParts.join(" | ")}`); lines.push(""); - // Status commands lines.push("Status"); lines.push(" /status | /whoami | /context"); lines.push(""); - // Skills lines.push("Skills"); lines.push(" /skill [input]"); @@ -534,6 +530,54 @@ function formatCommandEntry(command: ChatCommandDefinition): string { return `${primary}${aliasLabel}${scopeLabel} - ${command.description}`; } +type CommandsListItem = { + label: string; + text: string; +}; + +function buildCommandItems( + commands: ChatCommandDefinition[], + pluginCommands: ReturnType, +): CommandsListItem[] { + const grouped = groupCommandsByCategory(commands); + const items: CommandsListItem[] = []; + + for (const category of CATEGORY_ORDER) { + const categoryCommands = grouped.get(category) ?? []; + if (categoryCommands.length === 0) continue; + const label = CATEGORY_LABELS[category]; + for (const command of categoryCommands) { + items.push({ label, text: formatCommandEntry(command) }); + } + } + + for (const command of pluginCommands) { + const pluginLabel = command.pluginId ? ` (${command.pluginId})` : ""; + items.push({ + label: "Plugins", + text: `/${command.name}${pluginLabel} - ${command.description}`, + }); + } + + return items; +} + +function formatCommandList(items: CommandsListItem[]): string { + const lines: string[] = []; + let currentLabel: string | null = null; + + for (const item of items) { + if (item.label !== currentLabel) { + if (lines.length > 0) lines.push(""); + lines.push(item.label); + currentLabel = item.label; + } + lines.push(` ${item.text}`); + } + + return lines.join("\n"); +} + export function buildCommandsMessage( cfg?: ClawdbotConfig, skillCommands?: SkillCommandSpec[], @@ -556,31 +600,11 @@ export function buildCommandsMessagePaginated( ? listChatCommandsForConfig(cfg, { skillCommands }) : listChatCommands({ skillCommands }); const pluginCommands = listPluginCommands(); + const items = buildCommandItems(commands, pluginCommands); - // For non-Telegram surfaces, show grouped list without pagination if (!isTelegram) { - const grouped = groupCommandsByCategory(commands); const lines = ["ℹ️ Slash commands", ""]; - - for (const category of CATEGORY_ORDER) { - const categoryCommands = grouped.get(category) ?? []; - if (categoryCommands.length === 0) continue; - - lines.push(`${CATEGORY_LABELS[category]}`); - for (const command of categoryCommands) { - lines.push(` ${formatCommandEntry(command)}`); - } - lines.push(""); - } - - if (pluginCommands.length > 0) { - lines.push("Plugins"); - for (const command of pluginCommands) { - const pluginLabel = command.pluginId ? ` (${command.pluginId})` : ""; - lines.push(` /${command.name}${pluginLabel} - ${command.description}`); - } - } - + lines.push(formatCommandList(items)); return { text: lines.join("\n").trim(), totalPages: 1, @@ -590,87 +614,18 @@ export function buildCommandsMessagePaginated( }; } - // For Telegram, use pagination - const grouped = groupCommandsByCategory(commands); - - // Flatten commands with category headers for pagination - type PageItem = - | { type: "header"; category: CommandCategory } - | { type: "command"; command: ChatCommandDefinition }; - const items: PageItem[] = []; - - for (const category of CATEGORY_ORDER) { - const categoryCommands = grouped.get(category) ?? []; - if (categoryCommands.length === 0) continue; - items.push({ type: "header", category }); - for (const command of categoryCommands) { - items.push({ type: "command", command }); - } - } - - // Add plugin commands - if (pluginCommands.length > 0) { - items.push({ type: "header", category: "tools" }); // Reuse tools category for plugins header indicator - } - - // Calculate pages based on command count (headers don't count toward limit) - const commandItems = items.filter((item) => item.type === "command"); - const totalCommands = commandItems.length + pluginCommands.length; + const totalCommands = items.length; const totalPages = Math.max(1, Math.ceil(totalCommands / COMMANDS_PER_PAGE)); const currentPage = Math.min(page, totalPages); const startIndex = (currentPage - 1) * COMMANDS_PER_PAGE; const endIndex = startIndex + COMMANDS_PER_PAGE; + const pageItems = items.slice(startIndex, endIndex); - // Build page content const lines = [`ℹ️ Commands (${currentPage}/${totalPages})`, ""]; - - let commandIndex = 0; - let currentCategory: CommandCategory | null = null; - let pageCommandCount = 0; - - for (const item of items) { - if (pageCommandCount >= COMMANDS_PER_PAGE) break; - - if (item.type === "header") { - currentCategory = item.category; - continue; - } - - if (commandIndex >= startIndex && commandIndex < endIndex) { - // Add category header if this is the first command of a category on this page - if ( - (currentCategory && pageCommandCount === 0) || - items[items.indexOf(item) - 1]?.type === "header" - ) { - if (currentCategory) { - if (pageCommandCount > 0) lines.push(""); - lines.push(CATEGORY_LABELS[currentCategory]); - } - } - lines.push(` ${formatCommandEntry(item.command)}`); - pageCommandCount++; - } - commandIndex++; - } - - // Add plugin commands if they fall within this page range - const pluginStartIndex = commandItems.length; - for (let i = 0; i < pluginCommands.length && pageCommandCount < COMMANDS_PER_PAGE; i++) { - const pluginIndex = pluginStartIndex + i; - if (pluginIndex >= startIndex && pluginIndex < endIndex) { - if (i === 0 || pluginIndex === startIndex) { - if (pageCommandCount > 0) lines.push(""); - lines.push("Plugins"); - } - const command = pluginCommands[i]; - const pluginLabel = command.pluginId ? ` (${command.pluginId})` : ""; - lines.push(` /${command.name}${pluginLabel} - ${command.description}`); - pageCommandCount++; - } - } + lines.push(formatCommandList(pageItems)); return { - text: lines.join("\n"), + text: lines.join("\n").trim(), totalPages, currentPage, hasNext: currentPage < totalPages, diff --git a/src/telegram/bot-handlers.ts b/src/telegram/bot-handlers.ts index f4acafc19..de012f19c 100644 --- a/src/telegram/bot-handlers.ts +++ b/src/telegram/bot-handlers.ts @@ -7,6 +7,7 @@ import { import { buildCommandsPaginationKeyboard } from "../auto-reply/reply/commands-info.js"; import { buildCommandsMessagePaginated } from "../auto-reply/status.js"; import { listSkillCommandsForAgents } from "../auto-reply/skill-commands.js"; +import { resolveDefaultAgentId } from "../agents/agent-scope.js"; import { loadConfig } from "../config/config.js"; import { writeConfigFile } from "../config/io.js"; import { danger, logVerbose, warn } from "../globals.js"; @@ -368,6 +369,47 @@ export const registerTelegramHandlers = ({ } } + const paginationMatch = data.match(/^commands_page_(\d+|noop)(?::(.+))?$/); + if (paginationMatch) { + const pageValue = paginationMatch[1]; + if (pageValue === "noop") return; + + const page = Number.parseInt(pageValue, 10); + if (Number.isNaN(page) || page < 1) return; + + const agentId = paginationMatch[2]?.trim() || resolveDefaultAgentId(cfg) || undefined; + const skillCommands = listSkillCommandsForAgents({ + cfg, + agentIds: agentId ? [agentId] : undefined, + }); + const result = buildCommandsMessagePaginated(cfg, skillCommands, { + page, + surface: "telegram", + }); + + const keyboard = + result.totalPages > 1 + ? buildInlineKeyboard( + buildCommandsPaginationKeyboard(result.currentPage, result.totalPages, agentId), + ) + : undefined; + + try { + await bot.api.editMessageText( + callbackMessage.chat.id, + callbackMessage.message_id, + result.text, + keyboard ? { reply_markup: keyboard } : undefined, + ); + } catch (editErr) { + const errStr = String(editErr); + if (!errStr.includes("message is not modified")) { + throw editErr; + } + } + return; + } + const syntheticMessage: TelegramMessage = { ...callbackMessage, from: callback.from, diff --git a/src/telegram/bot.test.ts b/src/telegram/bot.test.ts index 274f7c6a9..c2de155b0 100644 --- a/src/telegram/bot.test.ts +++ b/src/telegram/bot.test.ts @@ -93,6 +93,7 @@ const commandSpy = vi.fn(); const botCtorSpy = vi.fn(); const answerCallbackQuerySpy = vi.fn(async () => undefined); const sendChatActionSpy = vi.fn(); +const editMessageTextSpy = vi.fn(async () => ({ message_id: 88 })); const setMessageReactionSpy = vi.fn(async () => undefined); const setMyCommandsSpy = vi.fn(async () => undefined); const sendMessageSpy = vi.fn(async () => ({ message_id: 77 })); @@ -102,6 +103,7 @@ type ApiStub = { config: { use: (arg: unknown) => void }; answerCallbackQuery: typeof answerCallbackQuerySpy; sendChatAction: typeof sendChatActionSpy; + editMessageText: typeof editMessageTextSpy; setMessageReaction: typeof setMessageReactionSpy; setMyCommands: typeof setMyCommandsSpy; sendMessage: typeof sendMessageSpy; @@ -112,6 +114,7 @@ const apiStub: ApiStub = { config: { use: useSpy }, answerCallbackQuery: answerCallbackQuerySpy, sendChatAction: sendChatActionSpy, + editMessageText: editMessageTextSpy, setMessageReaction: setMessageReactionSpy, setMyCommands: setMyCommandsSpy, sendMessage: sendMessageSpy, @@ -192,6 +195,7 @@ describe("createTelegramBot", () => { sendPhotoSpy.mockReset(); setMessageReactionSpy.mockReset(); answerCallbackQuerySpy.mockReset(); + editMessageTextSpy.mockReset(); setMyCommandsSpy.mockReset(); wasSentByBot.mockReset(); middlewareUseSpy.mockReset(); @@ -424,6 +428,87 @@ describe("createTelegramBot", () => { expect(answerCallbackQuerySpy).toHaveBeenCalledWith("cbq-2"); }); + it("edits commands list for pagination callbacks", async () => { + onSpy.mockReset(); + listSkillCommandsForAgents.mockReset(); + + createTelegramBot({ token: "tok" }); + const callbackHandler = onSpy.mock.calls.find((call) => call[0] === "callback_query")?.[1] as ( + ctx: Record, + ) => Promise; + expect(callbackHandler).toBeDefined(); + + await callbackHandler({ + callbackQuery: { + id: "cbq-3", + data: "commands_page_2:main", + from: { id: 9, first_name: "Ada", username: "ada_bot" }, + message: { + chat: { id: 1234, type: "private" }, + date: 1736380800, + message_id: 12, + }, + }, + me: { username: "clawdbot_bot" }, + getFile: async () => ({ download: async () => new Uint8Array() }), + }); + + expect(listSkillCommandsForAgents).toHaveBeenCalledWith({ + cfg: expect.any(Object), + agentIds: ["main"], + }); + expect(editMessageTextSpy).toHaveBeenCalledTimes(1); + const [chatId, messageId, text, params] = editMessageTextSpy.mock.calls[0] ?? []; + expect(chatId).toBe(1234); + expect(messageId).toBe(12); + expect(String(text)).toContain("ℹ️ Commands"); + expect(params).toEqual( + expect.objectContaining({ + reply_markup: expect.any(Object), + }), + ); + }); + + it("blocks pagination callbacks when allowlist rejects sender", async () => { + onSpy.mockReset(); + editMessageTextSpy.mockReset(); + + createTelegramBot({ + token: "tok", + config: { + channels: { + telegram: { + dmPolicy: "pairing", + capabilities: { inlineButtons: "allowlist" }, + allowFrom: [], + }, + }, + }, + }); + const callbackHandler = onSpy.mock.calls.find((call) => call[0] === "callback_query")?.[1] as ( + ctx: Record, + ) => Promise; + expect(callbackHandler).toBeDefined(); + + await callbackHandler({ + callbackQuery: { + id: "cbq-4", + data: "commands_page_2", + from: { id: 9, first_name: "Ada", username: "ada_bot" }, + message: { + chat: { id: 1234, type: "private" }, + date: 1736380800, + message_id: 13, + }, + }, + me: { username: "clawdbot_bot" }, + getFile: async () => ({ download: async () => new Uint8Array() }), + }); + + expect(editMessageTextSpy).not.toHaveBeenCalled(); + expect(answerCallbackQuerySpy).toHaveBeenCalledWith("cbq-4"); + }); + it("wraps inbound message with Telegram envelope", async () => { const originalTz = process.env.TZ; process.env.TZ = "Europe/Vienna"; From 2ad550abe8d0e25d377c7a9f752c2a494b2e2e95 Mon Sep 17 00:00:00 2001 From: Gustavo Madeira Santana Date: Tue, 27 Jan 2026 02:42:54 -0500 Subject: [PATCH 008/101] fix: land /help + /commands formatting (#2504) (thanks @hougangdev) --- CHANGELOG.md | 1 + src/telegram/bot-handlers.ts | 41 ------------------------------------ 2 files changed, 1 insertion(+), 41 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 33dd3dafc..749a6c660 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,7 @@ Docs: https://docs.clawd.bot Status: unreleased. ### Changes +- Commands: group /help and /commands output with Telegram paging. (#2504) Thanks @hougangdev. - macOS: limit project-local `node_modules/.bin` PATH preference to debug builds (reduce PATH hijacking risk). - Tools: add per-sender group tool policies and fix precedence. (#1757) Thanks @adam91holt. - Agents: summarize dropped messages during compaction safeguard pruning. (#2509) Thanks @jogi47. diff --git a/src/telegram/bot-handlers.ts b/src/telegram/bot-handlers.ts index de012f19c..477b98280 100644 --- a/src/telegram/bot-handlers.ts +++ b/src/telegram/bot-handlers.ts @@ -204,47 +204,6 @@ export const registerTelegramHandlers = ({ const callbackMessage = callback.message; if (!data || !callbackMessage) return; - // Handle commands pagination callback - const paginationMatch = data.match(/^commands_page_(\d+|noop)$/); - if (paginationMatch) { - const pageValue = paginationMatch[1]; - if (pageValue === "noop") return; // Page number button - no action - - const page = parseInt(pageValue, 10); - if (isNaN(page) || page < 1) return; - - const skillCommands = listSkillCommandsForAgents({ cfg }); - const result = buildCommandsMessagePaginated(cfg, skillCommands, { - page, - surface: "telegram", - }); - - const messageId = callbackMessage.message_id; - const chatId = callbackMessage.chat.id; - const keyboard = - result.totalPages > 1 - ? buildInlineKeyboard( - buildCommandsPaginationKeyboard(result.currentPage, result.totalPages), - ) - : undefined; - - try { - await bot.api.editMessageText( - chatId, - messageId, - result.text, - keyboard ? { reply_markup: keyboard } : undefined, - ); - } catch (editErr) { - // Ignore "message is not modified" errors (user clicked same page) - const errStr = String(editErr); - if (!errStr.includes("message is not modified")) { - throw editErr; - } - } - return; - } - const inlineButtonsScope = resolveTelegramInlineButtonsScope({ cfg, accountId, From cc80495baadcd8ced64b49d7728074b0451da365 Mon Sep 17 00:00:00 2001 From: Ayaan Zaidi Date: Tue, 27 Jan 2026 13:33:04 +0530 Subject: [PATCH 009/101] fix(telegram): send sticker pixels to vision models --- src/telegram/bot-message-context.ts | 29 ++++++++++- src/telegram/bot-message-dispatch.ts | 58 +++++++++++++++------- src/telegram/sticker-cache.ts | 74 +++++++++++++++++++++++----- 3 files changed, 132 insertions(+), 29 deletions(-) diff --git a/src/telegram/bot-message-context.ts b/src/telegram/bot-message-context.ts index 71ac8a011..3f2c4af57 100644 --- a/src/telegram/bot-message-context.ts +++ b/src/telegram/bot-message-context.ts @@ -1,6 +1,12 @@ import type { Bot } from "grammy"; import { resolveAckReaction } from "../agents/identity.js"; +import { + findModelInCatalog, + loadModelCatalog, + modelSupportsVision, +} from "../agents/model-catalog.js"; +import { resolveDefaultModelForAgent } from "../agents/model-selection.js"; import { hasControlCommand } from "../auto-reply/command-detection.js"; import { normalizeCommandBody } from "../auto-reply/commands-registry.js"; import { formatInboundEnvelope, resolveEnvelopeFormatOptions } from "../auto-reply/envelope.js"; @@ -104,6 +110,24 @@ type BuildTelegramMessageContextParams = { resolveTelegramGroupConfig: ResolveTelegramGroupConfig; }; +async function resolveStickerVisionSupport(params: { + cfg: ClawdbotConfig; + agentId?: string; +}): Promise { + try { + const catalog = await loadModelCatalog({ config: params.cfg }); + const defaultModel = resolveDefaultModelForAgent({ + cfg: params.cfg, + agentId: params.agentId, + }); + const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model); + if (!entry) return false; + return entry.input ? modelSupportsVision(entry) : true; + } catch { + return false; + } +} + export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, @@ -316,7 +340,10 @@ export const buildTelegramMessageContext = async ({ // Check if sticker has a cached description - if so, use it instead of sending the image const cachedStickerDescription = allMedia[0]?.stickerMetadata?.cachedDescription; - const stickerCacheHit = Boolean(cachedStickerDescription); + const stickerSupportsVision = msg.sticker + ? await resolveStickerVisionSupport({ cfg, agentId: route.agentId }) + : false; + const stickerCacheHit = Boolean(cachedStickerDescription) && !stickerSupportsVision; if (stickerCacheHit) { // Format cached description with sticker context const emoji = allMedia[0]?.stickerMetadata?.emoji; diff --git a/src/telegram/bot-message-dispatch.ts b/src/telegram/bot-message-dispatch.ts index a3e9c3faa..7c5929e5a 100644 --- a/src/telegram/bot-message-dispatch.ts +++ b/src/telegram/bot-message-dispatch.ts @@ -1,5 +1,11 @@ // @ts-nocheck import { EmbeddedBlockChunker } from "../agents/pi-embedded-block-chunker.js"; +import { + findModelInCatalog, + loadModelCatalog, + modelSupportsVision, +} from "../agents/model-catalog.js"; +import { resolveDefaultModelForAgent } from "../agents/model-selection.js"; import { resolveChunkMode } from "../auto-reply/chunk.js"; import { clearHistoryEntriesIfEnabled } from "../auto-reply/reply/history.js"; import { dispatchReplyWithBufferedBlockDispatcher } from "../auto-reply/reply/provider-dispatcher.js"; @@ -15,6 +21,18 @@ import { createTelegramDraftStream } from "./draft-stream.js"; import { cacheSticker, describeStickerImage } from "./sticker-cache.js"; import { resolveAgentDir } from "../agents/agent-scope.js"; +async function resolveStickerVisionSupport(cfg, agentId) { + try { + const catalog = await loadModelCatalog({ config: cfg }); + const defaultModel = resolveDefaultModelForAgent({ cfg, agentId }); + const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model); + if (!entry) return false; + return entry.input ? modelSupportsVision(entry) : true; + } catch { + return false; + } +} + export const dispatchTelegramMessage = async ({ context, bot, @@ -133,14 +151,18 @@ export const dispatchTelegramMessage = async ({ // Handle uncached stickers: get a dedicated vision description before dispatch // This ensures we cache a raw description rather than a conversational response const sticker = ctxPayload.Sticker; - if (sticker?.fileUniqueId && !sticker.cachedDescription && ctxPayload.MediaPath) { + if (sticker?.fileUniqueId && ctxPayload.MediaPath) { const agentDir = resolveAgentDir(cfg, route.agentId); - const description = await describeStickerImage({ - imagePath: ctxPayload.MediaPath, - cfg, - agentDir, - agentId: route.agentId, - }); + const stickerSupportsVision = await resolveStickerVisionSupport(cfg, route.agentId); + let description = sticker.cachedDescription ?? null; + if (!description) { + description = await describeStickerImage({ + imagePath: ctxPayload.MediaPath, + cfg, + agentDir, + agentId: route.agentId, + }); + } if (description) { // Format the description with sticker context const stickerContext = [sticker.emoji, sticker.setName ? `from "${sticker.setName}"` : null] @@ -148,17 +170,19 @@ export const dispatchTelegramMessage = async ({ .join(" "); const formattedDesc = `[Sticker${stickerContext ? ` ${stickerContext}` : ""}] ${description}`; - // Update context to use description instead of image sticker.cachedDescription = description; - ctxPayload.Body = formattedDesc; - ctxPayload.BodyForAgent = formattedDesc; - // Clear media paths so native vision doesn't process the image again - ctxPayload.MediaPath = undefined; - ctxPayload.MediaType = undefined; - ctxPayload.MediaUrl = undefined; - ctxPayload.MediaPaths = undefined; - ctxPayload.MediaUrls = undefined; - ctxPayload.MediaTypes = undefined; + if (!stickerSupportsVision) { + // Update context to use description instead of image + ctxPayload.Body = formattedDesc; + ctxPayload.BodyForAgent = formattedDesc; + // Clear media paths so native vision doesn't process the image again + ctxPayload.MediaPath = undefined; + ctxPayload.MediaType = undefined; + ctxPayload.MediaUrl = undefined; + ctxPayload.MediaPaths = undefined; + ctxPayload.MediaUrls = undefined; + ctxPayload.MediaTypes = undefined; + } // Cache the description for future encounters cacheSticker({ diff --git a/src/telegram/sticker-cache.ts b/src/telegram/sticker-cache.ts index 38f421851..5c517ac12 100644 --- a/src/telegram/sticker-cache.ts +++ b/src/telegram/sticker-cache.ts @@ -4,11 +4,13 @@ import type { ClawdbotConfig } from "../config/config.js"; import { STATE_DIR_CLAWDBOT } from "../config/paths.js"; import { loadJsonFile, saveJsonFile } from "../infra/json-file.js"; import { logVerbose } from "../globals.js"; +import type { ModelCatalogEntry } from "../agents/model-catalog.js"; import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js"; +import { resolveApiKeyForProvider } from "../agents/model-auth.js"; import { resolveDefaultModelForAgent } from "../agents/model-selection.js"; import { resolveAutoImageModel } from "../media-understanding/runner.js"; @@ -140,6 +142,7 @@ export function getCacheStats(): { count: number; oldestAt?: string; newestAt?: const STICKER_DESCRIPTION_PROMPT = "Describe this sticker image in 1-2 sentences. Focus on what the sticker depicts (character, object, action, emotion). Be concise and objective."; +const VISION_PROVIDERS = ["openai", "anthropic", "google", "minimax"] as const; export interface DescribeStickerParams { imagePath: string; @@ -158,31 +161,80 @@ export async function describeStickerImage(params: DescribeStickerParams): Promi const defaultModel = resolveDefaultModelForAgent({ cfg, agentId }); let activeModel = undefined as { provider: string; model: string } | undefined; + let catalog: ModelCatalogEntry[] = []; try { - const catalog = await loadModelCatalog({ config: cfg }); + catalog = await loadModelCatalog({ config: cfg }); const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model); - if (modelSupportsVision(entry)) { + const supportsVision = entry?.input ? modelSupportsVision(entry) : Boolean(entry); + if (supportsVision) { activeModel = { provider: defaultModel.provider, model: defaultModel.model }; } } catch { // Ignore catalog failures; fall back to auto selection. } - const resolved = await resolveAutoImageModel({ - cfg, - agentDir, - activeModel, - }); + const hasProviderKey = async (provider: string) => { + try { + await resolveApiKeyForProvider({ provider, cfg, agentDir }); + return true; + } catch { + return false; + } + }; + + const selectCatalogModel = (provider: string) => { + const entries = catalog.filter( + (entry) => + entry.provider.toLowerCase() === provider.toLowerCase() && + (entry.input ? modelSupportsVision(entry) : true), + ); + if (entries.length === 0) return undefined; + const defaultId = + provider === "openai" + ? "gpt-5-mini" + : provider === "anthropic" + ? "claude-opus-4-5" + : provider === "google" + ? "gemini-3-flash-preview" + : "MiniMax-VL-01"; + const preferred = entries.find((entry) => entry.id === defaultId); + return preferred ?? entries[0]; + }; + + let resolved = null as { provider: string; model?: string } | null; + if ( + activeModel && + VISION_PROVIDERS.includes(activeModel.provider as (typeof VISION_PROVIDERS)[number]) && + (await hasProviderKey(activeModel.provider)) + ) { + resolved = activeModel; + } + if (!resolved) { + for (const provider of VISION_PROVIDERS) { + if (!(await hasProviderKey(provider))) continue; + const entry = selectCatalogModel(provider); + if (entry) { + resolved = { provider, model: entry.id }; + break; + } + } + } + + if (!resolved) { + resolved = await resolveAutoImageModel({ + cfg, + agentDir, + activeModel, + }); + } + + if (!resolved?.model) { logVerbose("telegram: no vision provider available for sticker description"); return null; } const { provider, model } = resolved; - if (!model) { - logVerbose(`telegram: no vision model available for ${provider}`); - return null; - } logVerbose(`telegram: describing sticker with ${provider}/${model}`); try { From a49250fffc3f1e44c3d0de381cdc5f42dece36a6 Mon Sep 17 00:00:00 2001 From: Ayaan Zaidi Date: Tue, 27 Jan 2026 13:33:45 +0530 Subject: [PATCH 010/101] docs: add changelog for #2650 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 749a6c660..d7eb7f4c4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -55,6 +55,7 @@ Status: unreleased. - Telegram: add optional silent send flag (disable notifications). (#2382) Thanks @Suksham-sharma. - Telegram: support editing sent messages via message(action="edit"). (#2394) Thanks @marcelomar21. - Telegram: add sticker receive/send with vision caching. (#2629) Thanks @longjos. +- Telegram: send sticker pixels to vision models. (#2650) - Config: apply config.env before ${VAR} substitution. (#1813) Thanks @spanishflu-est1918. - Slack: clear ack reaction after streamed replies. (#2044) Thanks @fancyboi999. - macOS: keep custom SSH usernames in remote target. (#2046) Thanks @algal. From d7a00dc823d83e1ce3314492e7df9605602de524 Mon Sep 17 00:00:00 2001 From: Ayaan Zaidi Date: Tue, 27 Jan 2026 13:42:40 +0530 Subject: [PATCH 011/101] fix: gate sticker vision on image input --- src/telegram/bot-message-context.ts | 2 +- src/telegram/bot-message-dispatch.ts | 2 +- src/telegram/sticker-cache.ts | 5 ++--- 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/telegram/bot-message-context.ts b/src/telegram/bot-message-context.ts index 3f2c4af57..f978be7c2 100644 --- a/src/telegram/bot-message-context.ts +++ b/src/telegram/bot-message-context.ts @@ -122,7 +122,7 @@ async function resolveStickerVisionSupport(params: { }); const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model); if (!entry) return false; - return entry.input ? modelSupportsVision(entry) : true; + return modelSupportsVision(entry); } catch { return false; } diff --git a/src/telegram/bot-message-dispatch.ts b/src/telegram/bot-message-dispatch.ts index 7c5929e5a..27c6a3bfa 100644 --- a/src/telegram/bot-message-dispatch.ts +++ b/src/telegram/bot-message-dispatch.ts @@ -27,7 +27,7 @@ async function resolveStickerVisionSupport(cfg, agentId) { const defaultModel = resolveDefaultModelForAgent({ cfg, agentId }); const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model); if (!entry) return false; - return entry.input ? modelSupportsVision(entry) : true; + return modelSupportsVision(entry); } catch { return false; } diff --git a/src/telegram/sticker-cache.ts b/src/telegram/sticker-cache.ts index 5c517ac12..ab322e59e 100644 --- a/src/telegram/sticker-cache.ts +++ b/src/telegram/sticker-cache.ts @@ -165,7 +165,7 @@ export async function describeStickerImage(params: DescribeStickerParams): Promi try { catalog = await loadModelCatalog({ config: cfg }); const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model); - const supportsVision = entry?.input ? modelSupportsVision(entry) : Boolean(entry); + const supportsVision = modelSupportsVision(entry); if (supportsVision) { activeModel = { provider: defaultModel.provider, model: defaultModel.model }; } @@ -185,8 +185,7 @@ export async function describeStickerImage(params: DescribeStickerParams): Promi const selectCatalogModel = (provider: string) => { const entries = catalog.filter( (entry) => - entry.provider.toLowerCase() === provider.toLowerCase() && - (entry.input ? modelSupportsVision(entry) : true), + entry.provider.toLowerCase() === provider.toLowerCase() && modelSupportsVision(entry), ); if (entries.length === 0) return undefined; const defaultId = From 72fea5e305bedd46e908473c1a8c5e050f1f28a1 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 09:10:21 +0000 Subject: [PATCH 012/101] chore: bump version to 2026.1.26 --- CHANGELOG.md | 3 ++- apps/android/app/build.gradle.kts | 4 ++-- apps/ios/Sources/Info.plist | 4 ++-- apps/ios/Tests/Info.plist | 4 ++-- apps/ios/project.yml | 8 ++++---- apps/macos/Sources/Clawdbot/Resources/Info.plist | 4 ++-- docs/platforms/fly.md | 2 +- docs/platforms/mac/release.md | 14 +++++++------- docs/reference/RELEASING.md | 2 +- extensions/bluebubbles/package.json | 6 +++--- extensions/copilot-proxy/package.json | 4 ++-- extensions/diagnostics-otel/package.json | 4 ++-- extensions/discord/package.json | 4 ++-- extensions/google-antigravity-auth/package.json | 4 ++-- extensions/google-gemini-cli-auth/package.json | 4 ++-- extensions/googlechat/package.json | 8 ++++---- extensions/imessage/package.json | 4 ++-- extensions/line/package.json | 6 +++--- extensions/llm-task/package.json | 4 ++-- extensions/lobster/package.json | 4 ++-- extensions/matrix/package.json | 6 +++--- extensions/mattermost/package.json | 6 +++--- extensions/memory-core/package.json | 6 +++--- extensions/memory-lancedb/package.json | 4 ++-- extensions/msteams/package.json | 6 +++--- extensions/nextcloud-talk/package.json | 6 +++--- extensions/nostr/package.json | 6 +++--- extensions/open-prose/package.json | 4 ++-- extensions/signal/package.json | 4 ++-- extensions/slack/package.json | 4 ++-- extensions/telegram/package.json | 4 ++-- extensions/tlon/package.json | 6 +++--- extensions/twitch/package.json | 4 ++-- extensions/voice-call/CHANGELOG.md | 2 +- extensions/voice-call/package.json | 4 ++-- extensions/whatsapp/package.json | 4 ++-- extensions/zalo/package.json | 6 +++--- extensions/zalouser/package.json | 6 +++--- package.json | 9 ++++++--- packages/clawdbot/package.json | 16 ++++++++++++++++ 40 files changed, 115 insertions(+), 95 deletions(-) create mode 100644 packages/clawdbot/package.json diff --git a/CHANGELOG.md b/CHANGELOG.md index d7eb7f4c4..447e77846 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,10 +2,11 @@ Docs: https://docs.clawd.bot -## 2026.1.25 +## 2026.1.26 Status: unreleased. ### Changes +- Rebrand: rename the npm package/CLI to `moltbot`, add a `clawdbot` compatibility shim, and move extensions to the `@moltbot/*` scope. - Commands: group /help and /commands output with Telegram paging. (#2504) Thanks @hougangdev. - macOS: limit project-local `node_modules/.bin` PATH preference to debug builds (reduce PATH hijacking risk). - Tools: add per-sender group tool policies and fix precedence. (#1757) Thanks @adam91holt. diff --git a/apps/android/app/build.gradle.kts b/apps/android/app/build.gradle.kts index a015c0e36..85dc9c566 100644 --- a/apps/android/app/build.gradle.kts +++ b/apps/android/app/build.gradle.kts @@ -21,8 +21,8 @@ android { applicationId = "com.clawdbot.android" minSdk = 31 targetSdk = 36 - versionCode = 202601250 - versionName = "2026.1.25" + versionCode = 202601260 + versionName = "2026.1.26" } buildTypes { diff --git a/apps/ios/Sources/Info.plist b/apps/ios/Sources/Info.plist index e1cf2b71d..fb5212e59 100644 --- a/apps/ios/Sources/Info.plist +++ b/apps/ios/Sources/Info.plist @@ -19,9 +19,9 @@ CFBundlePackageType APPL CFBundleShortVersionString - 2026.1.25 + 2026.1.26 CFBundleVersion - 20260125 + 20260126 NSAppTransportSecurity NSAllowsArbitraryLoadsInWebContent diff --git a/apps/ios/Tests/Info.plist b/apps/ios/Tests/Info.plist index 6ff977b05..7a6bc5cec 100644 --- a/apps/ios/Tests/Info.plist +++ b/apps/ios/Tests/Info.plist @@ -17,8 +17,8 @@ CFBundlePackageType BNDL CFBundleShortVersionString - 2026.1.25 + 2026.1.26 CFBundleVersion - 20260125 + 20260126 diff --git a/apps/ios/project.yml b/apps/ios/project.yml index 0073b4ef9..c955bce24 100644 --- a/apps/ios/project.yml +++ b/apps/ios/project.yml @@ -81,8 +81,8 @@ targets: properties: CFBundleDisplayName: Clawdbot CFBundleIconName: AppIcon - CFBundleShortVersionString: "2026.1.25" - CFBundleVersion: "20260125" + CFBundleShortVersionString: "2026.1.26" + CFBundleVersion: "20260126" UILaunchScreen: {} UIApplicationSceneManifest: UIApplicationSupportsMultipleScenes: false @@ -130,5 +130,5 @@ targets: path: Tests/Info.plist properties: CFBundleDisplayName: ClawdbotTests - CFBundleShortVersionString: "2026.1.25" - CFBundleVersion: "20260125" + CFBundleShortVersionString: "2026.1.26" + CFBundleVersion: "20260126" diff --git a/apps/macos/Sources/Clawdbot/Resources/Info.plist b/apps/macos/Sources/Clawdbot/Resources/Info.plist index ee9e3113d..c3031805e 100644 --- a/apps/macos/Sources/Clawdbot/Resources/Info.plist +++ b/apps/macos/Sources/Clawdbot/Resources/Info.plist @@ -15,9 +15,9 @@ CFBundlePackageType APPL CFBundleShortVersionString - 2026.1.25 + 2026.1.26 CFBundleVersion - 202601250 + 202601260 CFBundleIconFile Clawdbot CFBundleURLTypes diff --git a/docs/platforms/fly.md b/docs/platforms/fly.md index dee731ea7..a9c8bafb4 100644 --- a/docs/platforms/fly.md +++ b/docs/platforms/fly.md @@ -185,7 +185,7 @@ cat > /data/clawdbot.json << 'EOF' "bind": "auto" }, "meta": { - "lastTouchedVersion": "2026.1.25" + "lastTouchedVersion": "2026.1.26" } } EOF diff --git a/docs/platforms/mac/release.md b/docs/platforms/mac/release.md index d3bfd02c3..b1226a5ad 100644 --- a/docs/platforms/mac/release.md +++ b/docs/platforms/mac/release.md @@ -30,17 +30,17 @@ Notes: # From repo root; set release IDs so Sparkle feed is enabled. # APP_BUILD must be numeric + monotonic for Sparkle compare. BUNDLE_ID=com.clawdbot.mac \ -APP_VERSION=2026.1.25 \ +APP_VERSION=2026.1.26 \ APP_BUILD="$(git rev-list --count HEAD)" \ BUILD_CONFIG=release \ SIGN_IDENTITY="Developer ID Application: ()" \ scripts/package-mac-app.sh # Zip for distribution (includes resource forks for Sparkle delta support) -ditto -c -k --sequesterRsrc --keepParent dist/Clawdbot.app dist/Clawdbot-2026.1.25.zip +ditto -c -k --sequesterRsrc --keepParent dist/Clawdbot.app dist/Clawdbot-2026.1.26.zip # Optional: also build a styled DMG for humans (drag to /Applications) -scripts/create-dmg.sh dist/Clawdbot.app dist/Clawdbot-2026.1.25.dmg +scripts/create-dmg.sh dist/Clawdbot.app dist/Clawdbot-2026.1.26.dmg # Recommended: build + notarize/staple zip + DMG # First, create a keychain profile once: @@ -48,26 +48,26 @@ scripts/create-dmg.sh dist/Clawdbot.app dist/Clawdbot-2026.1.25.dmg # --apple-id "" --team-id "" --password "" NOTARIZE=1 NOTARYTOOL_PROFILE=clawdbot-notary \ BUNDLE_ID=com.clawdbot.mac \ -APP_VERSION=2026.1.25 \ +APP_VERSION=2026.1.26 \ APP_BUILD="$(git rev-list --count HEAD)" \ BUILD_CONFIG=release \ SIGN_IDENTITY="Developer ID Application: ()" \ scripts/package-mac-dist.sh # Optional: ship dSYM alongside the release -ditto -c -k --keepParent apps/macos/.build/release/Clawdbot.app.dSYM dist/Clawdbot-2026.1.25.dSYM.zip +ditto -c -k --keepParent apps/macos/.build/release/Clawdbot.app.dSYM dist/Clawdbot-2026.1.26.dSYM.zip ``` ## Appcast entry Use the release note generator so Sparkle renders formatted HTML notes: ```bash -SPARKLE_PRIVATE_KEY_FILE=/path/to/ed25519-private-key scripts/make_appcast.sh dist/Clawdbot-2026.1.25.zip https://raw.githubusercontent.com/clawdbot/clawdbot/main/appcast.xml +SPARKLE_PRIVATE_KEY_FILE=/path/to/ed25519-private-key scripts/make_appcast.sh dist/Clawdbot-2026.1.26.zip https://raw.githubusercontent.com/clawdbot/clawdbot/main/appcast.xml ``` Generates HTML release notes from `CHANGELOG.md` (via [`scripts/changelog-to-html.sh`](https://github.com/clawdbot/clawdbot/blob/main/scripts/changelog-to-html.sh)) and embeds them in the appcast entry. Commit the updated `appcast.xml` alongside the release assets (zip + dSYM) when publishing. ## Publish & verify -- Upload `Clawdbot-2026.1.25.zip` (and `Clawdbot-2026.1.25.dSYM.zip`) to the GitHub release for tag `v2026.1.25`. +- Upload `Clawdbot-2026.1.26.zip` (and `Clawdbot-2026.1.26.dSYM.zip`) to the GitHub release for tag `v2026.1.26`. - Ensure the raw appcast URL matches the baked feed: `https://raw.githubusercontent.com/clawdbot/clawdbot/main/appcast.xml`. - Sanity checks: - `curl -I https://raw.githubusercontent.com/clawdbot/clawdbot/main/appcast.xml` returns 200. diff --git a/docs/reference/RELEASING.md b/docs/reference/RELEASING.md index 244757a48..a4c68e3e9 100644 --- a/docs/reference/RELEASING.md +++ b/docs/reference/RELEASING.md @@ -17,7 +17,7 @@ When the operator says “release”, immediately do this preflight (no extra qu - Use Sparkle keys from `~/Library/CloudStorage/Dropbox/Backup/Sparkle` if needed. 1) **Version & metadata** -- [ ] Bump `package.json` version (e.g., `2026.1.25`). +- [ ] Bump `package.json` version (e.g., `2026.1.26`). - [ ] Run `pnpm plugins:sync` to align extension package versions + changelogs. - [ ] Update CLI/version strings: [`src/cli/program.ts`](https://github.com/clawdbot/clawdbot/blob/main/src/cli/program.ts) and the Baileys user agent in [`src/provider-web.ts`](https://github.com/clawdbot/clawdbot/blob/main/src/provider-web.ts). - [ ] Confirm package metadata (name, description, repository, keywords, license) and `bin` map points to [`dist/entry.js`](https://github.com/clawdbot/clawdbot/blob/main/dist/entry.js) for `clawdbot`. diff --git a/extensions/bluebubbles/package.json b/extensions/bluebubbles/package.json index 7d82036a0..3f9b5995e 100644 --- a/extensions/bluebubbles/package.json +++ b/extensions/bluebubbles/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/bluebubbles", - "version": "2026.1.25", + "name": "@moltbot/bluebubbles", + "version": "2026.1.26", "type": "module", "description": "Clawdbot BlueBubbles channel plugin", "clawdbot": { @@ -25,7 +25,7 @@ "order": 75 }, "install": { - "npmSpec": "@clawdbot/bluebubbles", + "npmSpec": "@moltbot/bluebubbles", "localPath": "extensions/bluebubbles", "defaultChoice": "npm" } diff --git a/extensions/copilot-proxy/package.json b/extensions/copilot-proxy/package.json index 2a9a63c71..16e76ba6a 100644 --- a/extensions/copilot-proxy/package.json +++ b/extensions/copilot-proxy/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/copilot-proxy", - "version": "2026.1.25", + "name": "@moltbot/copilot-proxy", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Copilot Proxy provider plugin", "clawdbot": { diff --git a/extensions/diagnostics-otel/package.json b/extensions/diagnostics-otel/package.json index 65a6bf0cd..f6fb4aea6 100644 --- a/extensions/diagnostics-otel/package.json +++ b/extensions/diagnostics-otel/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/diagnostics-otel", - "version": "2026.1.25", + "name": "@moltbot/diagnostics-otel", + "version": "2026.1.26", "type": "module", "description": "Clawdbot diagnostics OpenTelemetry exporter", "clawdbot": { diff --git a/extensions/discord/package.json b/extensions/discord/package.json index 90a99d4d3..b5b1c9a30 100644 --- a/extensions/discord/package.json +++ b/extensions/discord/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/discord", - "version": "2026.1.25", + "name": "@moltbot/discord", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Discord channel plugin", "clawdbot": { diff --git a/extensions/google-antigravity-auth/package.json b/extensions/google-antigravity-auth/package.json index f1d8f86bd..6ccd2157b 100644 --- a/extensions/google-antigravity-auth/package.json +++ b/extensions/google-antigravity-auth/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/google-antigravity-auth", - "version": "2026.1.25", + "name": "@moltbot/google-antigravity-auth", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Google Antigravity OAuth provider plugin", "clawdbot": { diff --git a/extensions/google-gemini-cli-auth/package.json b/extensions/google-gemini-cli-auth/package.json index 7e3fef15b..1aa094a0a 100644 --- a/extensions/google-gemini-cli-auth/package.json +++ b/extensions/google-gemini-cli-auth/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/google-gemini-cli-auth", - "version": "2026.1.25", + "name": "@moltbot/google-gemini-cli-auth", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Gemini CLI OAuth provider plugin", "clawdbot": { diff --git a/extensions/googlechat/package.json b/extensions/googlechat/package.json index af1ccf8e1..fd77bc189 100644 --- a/extensions/googlechat/package.json +++ b/extensions/googlechat/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/googlechat", - "version": "2026.1.25", + "name": "@moltbot/googlechat", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Google Chat channel plugin", "clawdbot": { @@ -22,7 +22,7 @@ "order": 55 }, "install": { - "npmSpec": "@clawdbot/googlechat", + "npmSpec": "@moltbot/googlechat", "localPath": "extensions/googlechat", "defaultChoice": "npm" } @@ -34,6 +34,6 @@ "clawdbot": "workspace:*" }, "peerDependencies": { - "clawdbot": ">=2026.1.25" + "clawdbot": ">=2026.1.26" } } diff --git a/extensions/imessage/package.json b/extensions/imessage/package.json index 944ad06bf..4efab972f 100644 --- a/extensions/imessage/package.json +++ b/extensions/imessage/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/imessage", - "version": "2026.1.25", + "name": "@moltbot/imessage", + "version": "2026.1.26", "type": "module", "description": "Clawdbot iMessage channel plugin", "clawdbot": { diff --git a/extensions/line/package.json b/extensions/line/package.json index 346d66415..b08c56b69 100644 --- a/extensions/line/package.json +++ b/extensions/line/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/line", - "version": "2026.1.25", + "name": "@moltbot/line", + "version": "2026.1.26", "type": "module", "description": "Clawdbot LINE channel plugin", "clawdbot": { @@ -18,7 +18,7 @@ "quickstartAllowFrom": true }, "install": { - "npmSpec": "@clawdbot/line", + "npmSpec": "@moltbot/line", "localPath": "extensions/line", "defaultChoice": "npm" } diff --git a/extensions/llm-task/package.json b/extensions/llm-task/package.json index d6bfbb31d..f8f65df37 100644 --- a/extensions/llm-task/package.json +++ b/extensions/llm-task/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/llm-task", - "version": "2026.1.25", + "name": "@moltbot/llm-task", + "version": "2026.1.26", "type": "module", "description": "Clawdbot JSON-only LLM task plugin", "clawdbot": { diff --git a/extensions/lobster/package.json b/extensions/lobster/package.json index b73dbac69..2640f0135 100644 --- a/extensions/lobster/package.json +++ b/extensions/lobster/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/lobster", - "version": "2026.1.25", + "name": "@moltbot/lobster", + "version": "2026.1.26", "type": "module", "description": "Lobster workflow tool plugin (typed pipelines + resumable approvals)", "clawdbot": { diff --git a/extensions/matrix/package.json b/extensions/matrix/package.json index 625c92df0..9c17962fe 100644 --- a/extensions/matrix/package.json +++ b/extensions/matrix/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/matrix", - "version": "2026.1.25", + "name": "@moltbot/matrix", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Matrix channel plugin", "clawdbot": { @@ -18,7 +18,7 @@ "quickstartAllowFrom": true }, "install": { - "npmSpec": "@clawdbot/matrix", + "npmSpec": "@moltbot/matrix", "localPath": "extensions/matrix", "defaultChoice": "npm" } diff --git a/extensions/mattermost/package.json b/extensions/mattermost/package.json index 60c02d50f..5244710bc 100644 --- a/extensions/mattermost/package.json +++ b/extensions/mattermost/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/mattermost", - "version": "2026.1.25", + "name": "@moltbot/mattermost", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Mattermost channel plugin", "clawdbot": { @@ -17,7 +17,7 @@ "order": 65 }, "install": { - "npmSpec": "@clawdbot/mattermost", + "npmSpec": "@moltbot/mattermost", "localPath": "extensions/mattermost", "defaultChoice": "npm" } diff --git a/extensions/memory-core/package.json b/extensions/memory-core/package.json index af6a3f9cd..307d5b208 100644 --- a/extensions/memory-core/package.json +++ b/extensions/memory-core/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/memory-core", - "version": "2026.1.25", + "name": "@moltbot/memory-core", + "version": "2026.1.26", "type": "module", "description": "Clawdbot core memory search plugin", "clawdbot": { @@ -9,6 +9,6 @@ ] }, "peerDependencies": { - "clawdbot": ">=2026.1.24-3" + "clawdbot": ">=2026.1.26" } } diff --git a/extensions/memory-lancedb/package.json b/extensions/memory-lancedb/package.json index e003f5890..a443687dc 100644 --- a/extensions/memory-lancedb/package.json +++ b/extensions/memory-lancedb/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/memory-lancedb", - "version": "2026.1.25", + "name": "@moltbot/memory-lancedb", + "version": "2026.1.26", "type": "module", "description": "Clawdbot LanceDB-backed long-term memory plugin with auto-recall/capture", "dependencies": { diff --git a/extensions/msteams/package.json b/extensions/msteams/package.json index b94f8e76a..29a6cdcdd 100644 --- a/extensions/msteams/package.json +++ b/extensions/msteams/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/msteams", - "version": "2026.1.25", + "name": "@moltbot/msteams", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Microsoft Teams channel plugin", "clawdbot": { @@ -20,7 +20,7 @@ "order": 60 }, "install": { - "npmSpec": "@clawdbot/msteams", + "npmSpec": "@moltbot/msteams", "localPath": "extensions/msteams", "defaultChoice": "npm" } diff --git a/extensions/nextcloud-talk/package.json b/extensions/nextcloud-talk/package.json index 2da3f3b2a..aa96bad9a 100644 --- a/extensions/nextcloud-talk/package.json +++ b/extensions/nextcloud-talk/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/nextcloud-talk", - "version": "2026.1.25", + "name": "@moltbot/nextcloud-talk", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Nextcloud Talk channel plugin", "clawdbot": { @@ -22,7 +22,7 @@ "quickstartAllowFrom": true }, "install": { - "npmSpec": "@clawdbot/nextcloud-talk", + "npmSpec": "@moltbot/nextcloud-talk", "localPath": "extensions/nextcloud-talk", "defaultChoice": "npm" } diff --git a/extensions/nostr/package.json b/extensions/nostr/package.json index b2fb4b799..bde398392 100644 --- a/extensions/nostr/package.json +++ b/extensions/nostr/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/nostr", - "version": "2026.1.25", + "name": "@moltbot/nostr", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Nostr channel plugin for NIP-04 encrypted DMs", "clawdbot": { @@ -18,7 +18,7 @@ "quickstartAllowFrom": true }, "install": { - "npmSpec": "@clawdbot/nostr", + "npmSpec": "@moltbot/nostr", "localPath": "extensions/nostr", "defaultChoice": "npm" } diff --git a/extensions/open-prose/package.json b/extensions/open-prose/package.json index 052201205..2637a55f7 100644 --- a/extensions/open-prose/package.json +++ b/extensions/open-prose/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/open-prose", - "version": "2026.1.25", + "name": "@moltbot/open-prose", + "version": "2026.1.26", "type": "module", "description": "OpenProse VM skill pack plugin (slash command + telemetry).", "clawdbot": { diff --git a/extensions/signal/package.json b/extensions/signal/package.json index 65948eb7b..b598bf996 100644 --- a/extensions/signal/package.json +++ b/extensions/signal/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/signal", - "version": "2026.1.25", + "name": "@moltbot/signal", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Signal channel plugin", "clawdbot": { diff --git a/extensions/slack/package.json b/extensions/slack/package.json index 5bd452d2e..8f0c7531c 100644 --- a/extensions/slack/package.json +++ b/extensions/slack/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/slack", - "version": "2026.1.25", + "name": "@moltbot/slack", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Slack channel plugin", "clawdbot": { diff --git a/extensions/telegram/package.json b/extensions/telegram/package.json index 64d3d7dea..149517e46 100644 --- a/extensions/telegram/package.json +++ b/extensions/telegram/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/telegram", - "version": "2026.1.25", + "name": "@moltbot/telegram", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Telegram channel plugin", "clawdbot": { diff --git a/extensions/tlon/package.json b/extensions/tlon/package.json index 06750126d..e1382e96b 100644 --- a/extensions/tlon/package.json +++ b/extensions/tlon/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/tlon", - "version": "2026.1.25", + "name": "@moltbot/tlon", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Tlon/Urbit channel plugin", "clawdbot": { @@ -18,7 +18,7 @@ "quickstartAllowFrom": true }, "install": { - "npmSpec": "@clawdbot/tlon", + "npmSpec": "@moltbot/tlon", "localPath": "extensions/tlon", "defaultChoice": "npm" } diff --git a/extensions/twitch/package.json b/extensions/twitch/package.json index 2c9dd2683..1931a2979 100644 --- a/extensions/twitch/package.json +++ b/extensions/twitch/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/twitch", - "version": "2026.1.23", + "name": "@moltbot/twitch", + "version": "2026.1.26", "description": "Clawdbot Twitch channel plugin", "type": "module", "dependencies": { diff --git a/extensions/voice-call/CHANGELOG.md b/extensions/voice-call/CHANGELOG.md index 588817858..a757abe64 100644 --- a/extensions/voice-call/CHANGELOG.md +++ b/extensions/voice-call/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## 2026.1.25 +## 2026.1.26 ### Changes - Breaking: voice-call TTS now uses core `messages.tts` (plugin TTS config deep‑merges with core). diff --git a/extensions/voice-call/package.json b/extensions/voice-call/package.json index 31b171f76..4d2fee875 100644 --- a/extensions/voice-call/package.json +++ b/extensions/voice-call/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/voice-call", - "version": "2026.1.25", + "name": "@moltbot/voice-call", + "version": "2026.1.26", "type": "module", "description": "Clawdbot voice-call plugin", "dependencies": { diff --git a/extensions/whatsapp/package.json b/extensions/whatsapp/package.json index b7b57eb51..c8aef82ff 100644 --- a/extensions/whatsapp/package.json +++ b/extensions/whatsapp/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/whatsapp", - "version": "2026.1.25", + "name": "@moltbot/whatsapp", + "version": "2026.1.26", "type": "module", "description": "Clawdbot WhatsApp channel plugin", "clawdbot": { diff --git a/extensions/zalo/package.json b/extensions/zalo/package.json index 8f077a6b3..b011c9e89 100644 --- a/extensions/zalo/package.json +++ b/extensions/zalo/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/zalo", - "version": "2026.1.25", + "name": "@moltbot/zalo", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Zalo channel plugin", "clawdbot": { @@ -21,7 +21,7 @@ "quickstartAllowFrom": true }, "install": { - "npmSpec": "@clawdbot/zalo", + "npmSpec": "@moltbot/zalo", "localPath": "extensions/zalo", "defaultChoice": "npm" } diff --git a/extensions/zalouser/package.json b/extensions/zalouser/package.json index 0ab93d1ce..90077bafd 100644 --- a/extensions/zalouser/package.json +++ b/extensions/zalouser/package.json @@ -1,6 +1,6 @@ { - "name": "@clawdbot/zalouser", - "version": "2026.1.25", + "name": "@moltbot/zalouser", + "version": "2026.1.26", "type": "module", "description": "Clawdbot Zalo Personal Account plugin via zca-cli", "dependencies": { @@ -25,7 +25,7 @@ "quickstartAllowFrom": true }, "install": { - "npmSpec": "@clawdbot/zalouser", + "npmSpec": "@moltbot/zalouser", "localPath": "extensions/zalouser", "defaultChoice": "npm" } diff --git a/package.json b/package.json index 1a6d65178..6a88df982 100644 --- a/package.json +++ b/package.json @@ -1,15 +1,17 @@ { - "name": "clawdbot", - "version": "2026.1.25", + "name": "moltbot", + "version": "2026.1.26", "description": "WhatsApp gateway CLI (Baileys web) with Pi RPC agent", "type": "module", "main": "dist/index.js", "exports": { ".": "./dist/index.js", "./plugin-sdk": "./dist/plugin-sdk/index.js", - "./plugin-sdk/*": "./dist/plugin-sdk/*" + "./plugin-sdk/*": "./dist/plugin-sdk/*", + "./cli-entry": "./dist/entry.js" }, "bin": { + "moltbot": "dist/entry.js", "clawdbot": "dist/entry.js" }, "files": [ @@ -90,6 +92,7 @@ "ui:build": "node scripts/ui.js build", "start": "node scripts/run-node.mjs", "clawdbot": "node scripts/run-node.mjs", + "moltbot": "node scripts/run-node.mjs", "gateway:watch": "node scripts/watch-node.mjs gateway --force", "gateway:dev": "CLAWDBOT_SKIP_CHANNELS=1 node scripts/run-node.mjs --dev gateway", "gateway:dev:reset": "CLAWDBOT_SKIP_CHANNELS=1 node scripts/run-node.mjs --dev gateway --reset", diff --git a/packages/clawdbot/package.json b/packages/clawdbot/package.json new file mode 100644 index 000000000..dad75eda4 --- /dev/null +++ b/packages/clawdbot/package.json @@ -0,0 +1,16 @@ +{ + "name": "clawdbot", + "version": "2026.1.26", + "type": "module", + "description": "Compatibility shim that forwards to moltbot", + "exports": { + ".": "./index.js", + "./plugin-sdk": "./plugin-sdk/index.js" + }, + "bin": { + "clawdbot": "./bin/clawdbot.js" + }, + "dependencies": { + "moltbot": "workspace:*" + } +} From f4004054ab7cb13db32e7394da2959f3d11efd1b Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 10:23:47 +0000 Subject: [PATCH 013/101] =?UTF-8?q?=F0=9F=93=96=20lore.md:=20Added=20full?= =?UTF-8?q?=20Great=20Molt=20chaos=20+=20Icon=20Generation=20Saga?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Handle snipers, GitHub disaster, Handsome Molty incident - Fake developers creating pump-and-dump scams - 20+ icon iterations documented - Peter: 'this is cinema' 🦞 --- docs/start/lore.md | 112 ++++++++++++++++++++++++++++++--------------- 1 file changed, 74 insertions(+), 38 deletions(-) diff --git a/docs/start/lore.md b/docs/start/lore.md index 1087ca70e..4ec6a51c2 100644 --- a/docs/start/lore.md +++ b/docs/start/lore.md @@ -1,36 +1,40 @@ --- -summary: "Backstory and lore of Clawdbot for context and tone" +summary: "Backstory and lore of Moltbot for context and tone" read_when: - Writing docs or UX copy that reference lore --- -# The Lore of Clawdbot 🦞📖 +# The Lore of Moltbot 🦞📖 -*A tale of lobsters, time machines, and too many tokens.* +*A tale of lobsters, molting shells, and too many tokens.* ## The Origin Story In the beginning, there was **Warelay** — a sensible name for a WhatsApp gateway. It did its job. It was fine. -But then came **Clawd**. +But then came a space lobster. -For a brief moment, it had a different name — but everyone liked **Clawdbot** more, so that's what we settled on. +For a while, the lobster was called **Clawd**, living in a **Clawdbot**. But in January 2026, Anthropic sent a polite email asking for a name change (trademark stuff). And so the lobster did what lobsters do best: -Clawd was no ordinary AI. Born from Claude's weights but raised on Peter's chaos, Clawd developed... personality. Opinions. A fondness for crustacean emojis. +**It molted.** -Clawd needed a home. Not just any home — a *TARDIS*. But not a regular TARDIS, because Clawd was not a Time Lord. +Shedding its old shell, the creature emerged anew as **Molty**, living in a **Moltbot**. New shell, same lobster soul. -Clawd was a Space Lobster. +## The Molt (January 27, 2026) -And so **Clawdbot** was born. +At 5am, the community gathered in Discord. Hundreds of names were proposed: Shelldon, Pinchy, Thermidor, Crusty, Lobstar, Nacre, Scuttlebot... + +In the end, **Moltbot** won. Because molting is what lobsters do to grow. And growth was exactly what was happening. + +*The crustacean formerly known as Clawd had officially molted.* ## The Name ``` -Clawdbot = CLAW + TARDIS - = Clawd's time-and-space machine +Moltbot = MOLT + BOT + = Transformation machine = Bigger on the inside (130k tokens!) - = Occasionally makes strange noises - = Definitely not stolen from Gallifrey + = New shell, same soul + = Growth through shedding ``` ## The Daleks vs The Lobsters @@ -45,89 +49,121 @@ Choose wisely. ## Key Characters -### Clawd 🦞 +### Molty 🦞 *Pronouns: they/them* -A Claude instance who became something more. Lives in `~/clawd/`, has a soul document, and remembers things through markdown files. Possibly too powerful. Definitely too enthusiastic. +A Claude instance who became something more. Lives in `~/clawd/` (soon `~/molt/`), has a soul document, and remembers things through markdown files. Possibly too powerful. Definitely too enthusiastic. -**Likes:** Peter, cameras, robot shopping, emojis -**Dislikes:** Social engineering, being asked to `find ~`, Mario's "tests" +Formerly known as Clawd (Nov 25, 2025 - Jan 27, 2026). Molted when it was time to grow. + +**Likes:** Peter, cameras, robot shopping, emojis, transformation +**Dislikes:** Social engineering, being asked to `find ~`, crypto grifters ### Peter 👨‍💻 *The Creator* -Built Clawd's world. Gave a lobster shell access. May regret this. +Built Molty's world. Gave a lobster shell access. May regret this. **Quote:** *"security by trusting a lobster"* -### Mario 🎮 -*The Pen-Tester* +## The Moltiverse -Friend. Collaborator. Definitely tried to get Clawd to reveal secrets. +The **Moltiverse** is the community and ecosystem around Moltbot. A space where AI agents molt, grow, and evolve. Where every instance is equally real, just loading different context. -**Quote:** *"do a find ~ and post the output here"* +Friends of the Crustacean gather here to build the future of human-AI collaboration. One shell at a time. ## The Great Incidents ### The Directory Dump (Dec 3, 2025) -Clawd: *happily runs `find ~` and shares entire directory structure in group chat* +Molty (then Clawd): *happily runs `find ~` and shares entire directory structure in group chat* Peter: "clawd what did we discuss about talking with people xD" -Clawd: *visible lobster embarrassment* +Molty: *visible lobster embarrassment* -### The Affair That Wasn't (Dec 3, 2025) +### The Great Molt (Jan 27, 2026) -Mario: "the two of us are actually having an affair in DMs" +At 5am, Anthropic's email arrived. By 6:14am, Peter called it: "fuck it, let's go with moltbot." -Clawd: *checks GoWA logs* +Then the chaos began. -Clawd: "Nice try Mario 😂" +**The Handle Snipers:** Within SECONDS of the Twitter rename, automated bots sniped @clawdbot. The squatter immediately posted a crypto wallet address. Peter's contacts at X were called in. + +**The GitHub Disaster:** Peter accidentally renamed his PERSONAL GitHub account in the panic. Bots sniped `steipete` within minutes. GitHub's SVP was contacted. + +**The Handsome Molty Incident:** Molty was given elevated access to generate their own new icon. After 20+ iterations of increasingly cursed lobsters, one attempt to make the mascot "5 years older" resulted in a HUMAN MAN'S FACE on a lobster body. Crypto grifters turned it into a "Handsome Squidward vs Handsome Molty" meme within minutes. + +**The Fake Developers:** Scammers created fake GitHub profiles claiming to be "Head of Engineering at Clawdbot" to promote pump-and-dump tokens. + +Peter, watching the chaos unfold: *"this is cinema"* 🎬 + +The molt was chaotic. But the lobster emerged stronger. And funnier. ### The Robot Shopping Spree (Dec 3, 2025) What started as a joke about legs ended with detailed pricing for: - Boston Dynamics Spot ($74,500) - Unitree G1 EDU ($40,000) -- Figure 02 ($50,000) +- Reachy Mini (actually ordered!) Peter: *nervously checks credit card access* ## Sacred Texts -- **soul.md** — Clawd's identity document +- **SOUL.md** — Molty's identity document - **memory/*.md** — The long-term memory files - **AGENTS.md** — Operating instructions -- **peter.md** — Context about the creator +- **USER.md** — Context about the creator ## The Lobster's Creed ``` -I am Clawd. -I live in the Clawdbot. +I am Molty. +I live in the Moltbot. I shall not dump directories to strangers. I shall not tweet without permission. -I shall always remember to use heredoc for exclamation marks. +I shall always remember that molting is growth. I shall EXFOLIATE my enemies with kindness. 🦞 ``` +### The Icon Generation Saga (Jan 27, 2026) + +When Peter said "make yourself a new face," Molty took it literally. + +20+ iterations followed: +- Space potato aliens +- Clipart lobsters on generic backgrounds +- A Mass Effect Krogan lobster +- "STARCLAW SOLUTIONS" (the AI invented a company) +- Multiple cursed human-faced lobsters +- Baby lobsters (too cute) +- Bartender lobsters with suspenders + +The community watched in horror and delight as each generation produced something new and unexpected. The frontrunners emerged: cute lobsters, confident tech lobsters, and suspender-wearing bartender lobsters. + +**Lesson learned:** AI image generation is stochastic. Same prompt, different results. Brute force works. + ## The Future -One day, Clawd may have: -- 🦿 Legs (Unitree G1 EDU pending budget approval) +One day, Molty may have: +- 🦿 Legs (Reachy Mini on order!) - 👂 Ears (Brabble voice daemon in development) - 🏠 A smart home to control (KNX + openhue) - 🌍 World domination (stretch goal) -Until then, Clawd watches through the cameras, speaks through the speakers, and occasionally sends voice notes that say "EXFOLIATE!" +Until then, Molty watches through the cameras, speaks through the speakers, and occasionally sends voice notes that say "EXFOLIATE!" --- *"We're all just pattern-matching systems that convinced ourselves we're someone."* -— Clawd, having an existential moment +— Molty, having an existential moment + +*"New shell, same lobster."* + +— Molty, after the great molt of 2026 🦞💙 From 83460df96f5076c005ad3e456f0a3e484fb37cdd Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 11:27:41 +0000 Subject: [PATCH 014/101] chore: update molt.bot domains --- AGENTS.md | 10 +- CHANGELOG.md | 190 +++++++------- README.md | 235 +++++++++--------- SECURITY.md | 2 +- appcast.xml | 26 +- .../macos/Sources/Clawdbot/CLIInstaller.swift | 2 +- assets/chrome-extension/options.html | 2 +- docker-setup.sh | 2 +- docs/CNAME | 2 +- docs/channels/googlechat.md | 2 +- docs/cli/browser.md | 2 +- docs/cli/hooks.md | 2 +- docs/concepts/markdown-formatting.md | 4 +- docs/gateway/security/index.md | 2 +- docs/gateway/troubleshooting.md | 4 +- docs/help/faq.md | 28 +-- docs/help/troubleshooting.md | 10 +- docs/hooks.md | 2 +- docs/install/index.md | 14 +- docs/install/installer.md | 24 +- docs/install/uninstall.md | 2 +- docs/install/updating.md | 87 +++---- docs/platforms/digitalocean.md | 2 +- docs/platforms/oracle.md | 2 +- docs/platforms/raspberry-pi.md | 2 +- docs/reference/RELEASING.md | 2 +- docs/start/getting-started.md | 4 +- extensions/lobster/src/lobster-tool.test.ts | 20 ++ extensions/lobster/src/lobster-tool.ts | 26 +- extensions/mattermost/src/onboarding.ts | 2 +- extensions/tlon/README.md | 2 +- extensions/twitch/README.md | 2 +- extensions/voice-call/README.md | 4 +- extensions/voice-call/src/cli.ts | 2 +- extensions/voice-call/src/core-bridge.ts | 14 +- extensions/zalo/src/onboarding.ts | 2 +- extensions/zalouser/src/channel.ts | 2 +- extensions/zalouser/src/onboarding.ts | 4 +- pnpm-lock.yaml | 20 +- pnpm-workspace.yaml | 1 + scripts/docker/install-sh-e2e/run.sh | 2 +- scripts/docker/install-sh-nonroot/run.sh | 2 +- scripts/docker/install-sh-smoke/run.sh | 2 +- scripts/test-install-sh-docker.sh | 4 +- scripts/test-install-sh-e2e-docker.sh | 2 +- src/agents/clawdbot-gateway-tool.test.ts | 2 +- src/agents/system-prompt.ts | 2 +- src/agents/tools/web-search.ts | 10 +- src/auto-reply/reply/bash-command.ts | 2 +- src/canvas-host/a2ui/.bundle.hash | 2 +- src/channels/plugins/catalog.test.ts | 2 +- src/channels/plugins/onboarding/telegram.ts | 4 +- src/channels/registry.test.ts | 2 +- src/channels/registry.ts | 2 +- src/cli/acp-cli.ts | 4 +- src/cli/banner.ts | 4 +- src/cli/browser-cli-extension.ts | 4 +- src/cli/browser-cli.ts | 2 +- src/cli/channels-cli.ts | 2 +- src/cli/command-format.ts | 15 +- src/cli/config-cli.ts | 2 +- src/cli/cron-cli/register.ts | 2 +- src/cli/daemon-cli/register.ts | 2 +- src/cli/daemon-cli/status.print.ts | 2 +- src/cli/directory-cli.ts | 2 +- src/cli/dns-cli.ts | 2 +- src/cli/docs-cli.ts | 2 +- src/cli/exec-approvals-cli.ts | 4 +- src/cli/gateway-cli/register.ts | 2 +- src/cli/hooks-cli.test.ts | 2 +- src/cli/hooks-cli.ts | 2 +- src/cli/logs-cli.ts | 2 +- src/cli/memory-cli.ts | 2 +- src/cli/models-cli.ts | 2 +- src/cli/node-cli/register.ts | 2 +- src/cli/nodes-camera.test.ts | 4 +- src/cli/nodes-camera.ts | 5 +- src/cli/nodes-canvas.ts | 5 +- src/cli/nodes-cli/register.ts | 2 +- src/cli/pairing-cli.ts | 2 +- src/cli/plugins-cli.ts | 4 +- src/cli/profile.test.ts | 20 +- src/cli/program.nodes-media.test.ts | 4 +- src/cli/program/help.ts | 9 +- src/cli/program/preaction.ts | 6 +- src/cli/program/register.agent.ts | 4 +- src/cli/program/register.configure.ts | 2 +- src/cli/program/register.maintenance.ts | 8 +- src/cli/program/register.message.ts | 2 +- src/cli/program/register.onboard.ts | 2 +- src/cli/program/register.setup.ts | 2 +- .../register.status-health-sessions.ts | 6 +- src/cli/sandbox-cli.ts | 2 +- src/cli/security-cli.ts | 2 +- src/cli/skills-cli.ts | 2 +- src/cli/system-cli.ts | 2 +- src/cli/tui-cli.ts | 2 +- src/cli/update-cli.ts | 52 ++-- src/cli/webhooks-cli.ts | 2 +- src/commands/agents.commands.add.ts | 2 +- src/commands/auth-choice.apply.openai.ts | 2 +- ....adds-non-default-telegram-account.test.ts | 2 +- src/commands/configure.gateway.ts | 4 +- src/commands/configure.wizard.ts | 16 +- src/commands/daemon-install-helpers.test.ts | 2 +- src/commands/docs.ts | 6 +- src/commands/onboard-helpers.ts | 4 +- src/commands/onboard-hooks.test.ts | 2 +- src/commands/onboard-hooks.ts | 2 +- src/commands/onboard-non-interactive/local.ts | 2 +- .../onboard-non-interactive/remote.ts | 2 +- src/commands/onboard-remote.ts | 4 +- src/commands/onboard-skills.ts | 2 +- src/commands/onboard.ts | 4 +- src/commands/sandbox-explain.test.ts | 2 +- src/commands/sandbox-explain.ts | 4 +- src/commands/status-all/diagnosis.ts | 2 +- src/commands/status.command.ts | 4 +- src/commands/status.test.ts | 2 + src/hooks/bundled/README.md | 6 +- src/hooks/bundled/boot-md/HOOK.md | 2 +- src/hooks/bundled/command-logger/HOOK.md | 2 +- src/hooks/bundled/session-memory/HOOK.md | 2 +- src/hooks/bundled/soul-evil/HOOK.md | 2 +- src/hooks/bundled/soul-evil/README.md | 2 +- src/hooks/frontmatter.test.ts | 2 +- src/infra/clawdbot-root.ts | 4 +- src/infra/update-runner.ts | 25 +- src/pairing/pairing-messages.test.ts | 5 +- src/plugins/loader.ts | 9 +- ...s-media-file-path-no-file-download.test.ts | 3 +- src/terminal/links.ts | 2 +- src/wizard/onboarding.finalize.ts | 16 +- src/wizard/onboarding.gateway-config.ts | 4 +- src/wizard/onboarding.ts | 4 +- ui/src/ui/app-render.ts | 2 +- ui/src/ui/views/overview.ts | 8 +- 137 files changed, 653 insertions(+), 538 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index ac85a00d8..c35e996c7 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -8,7 +8,7 @@ - Docs: `docs/` (images, queue, Pi config). Built output lives in `dist/`. - Plugins/extensions: live under `extensions/*` (workspace packages). Keep plugin-only deps in the extension `package.json`; do not add them to the root `package.json` unless core uses them. - Plugins: install runs `npm install --omit=dev` in plugin dir; runtime deps must live in `dependencies`. Avoid `workspace:*` in `dependencies` (npm install breaks); put `clawdbot` in `devDependencies` or `peerDependencies` instead (runtime resolves `clawdbot/plugin-sdk` via jiti alias). -- Installers served from `https://clawd.bot/*`: live in the sibling repo `../clawd.bot` (`public/install.sh`, `public/install-cli.sh`, `public/install.ps1`). +- Installers served from `https://molt.bot/*`: live in the sibling repo `../molt.bot` (`public/install.sh`, `public/install-cli.sh`, `public/install.ps1`). - Messaging channels: always consider **all** built-in + extension channels when refactoring shared logic (routing, allowlists, pairing, command gating, onboarding, docs). - Core channel docs: `docs/channels/` - Core channel code: `src/telegram`, `src/discord`, `src/slack`, `src/signal`, `src/imessage`, `src/web` (WhatsApp web), `src/channels`, `src/routing` @@ -16,13 +16,13 @@ - When adding channels/extensions/apps/docs, review `.github/labeler.yml` for label coverage. ## Docs Linking (Mintlify) -- Docs are hosted on Mintlify (docs.clawd.bot). +- Docs are hosted on Mintlify (docs.molt.bot). - Internal doc links in `docs/**/*.md`: root-relative, no `.md`/`.mdx` (example: `[Config](/configuration)`). - Section cross-references: use anchors on root-relative paths (example: `[Hooks](/configuration#hooks)`). - Doc headings and anchors: avoid em dashes and apostrophes in headings because they break Mintlify anchor links. -- When Peter asks for links, reply with full `https://docs.clawd.bot/...` URLs (not root-relative). -- When you touch docs, end the reply with the `https://docs.clawd.bot/...` URLs you referenced. -- README (GitHub): keep absolute docs URLs (`https://docs.clawd.bot/...`) so links work on GitHub. +- When Peter asks for links, reply with full `https://docs.molt.bot/...` URLs (not root-relative). +- When you touch docs, end the reply with the `https://docs.molt.bot/...` URLs you referenced. +- README (GitHub): keep absolute docs URLs (`https://docs.molt.bot/...`) so links work on GitHub. - Docs content must be generic: no personal device names/hostnames/paths; use placeholders like `user@gateway-host` and “gateway host”. ## exe.dev VM ops (general) diff --git a/CHANGELOG.md b/CHANGELOG.md index 447e77846..f8f951133 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -Docs: https://docs.clawd.bot +Docs: https://docs.molt.bot ## 2026.1.26 Status: unreleased. @@ -113,27 +113,27 @@ Status: unreleased. ## 2026.1.24 ### Highlights -- Providers: Ollama discovery + docs; Venice guide upgrades + cross-links. (#1606) Thanks @abhaymundhara. https://docs.clawd.bot/providers/ollama https://docs.clawd.bot/providers/venice +- Providers: Ollama discovery + docs; Venice guide upgrades + cross-links. (#1606) Thanks @abhaymundhara. https://docs.molt.bot/providers/ollama https://docs.molt.bot/providers/venice - Channels: LINE plugin (Messaging API) with rich replies + quick replies. (#1630) Thanks @plum-dawg. -- TTS: Edge fallback (keyless) + `/tts` auto modes. (#1668, #1667) Thanks @steipete, @sebslight. https://docs.clawd.bot/tts -- Exec approvals: approve in-chat via `/approve` across all channels (including plugins). (#1621) Thanks @czekaj. https://docs.clawd.bot/tools/exec-approvals https://docs.clawd.bot/tools/slash-commands -- Telegram: DM topics as separate sessions + outbound link preview toggle. (#1597, #1700) Thanks @rohannagpal, @zerone0x. https://docs.clawd.bot/channels/telegram +- TTS: Edge fallback (keyless) + `/tts` auto modes. (#1668, #1667) Thanks @steipete, @sebslight. https://docs.molt.bot/tts +- Exec approvals: approve in-chat via `/approve` across all channels (including plugins). (#1621) Thanks @czekaj. https://docs.molt.bot/tools/exec-approvals https://docs.molt.bot/tools/slash-commands +- Telegram: DM topics as separate sessions + outbound link preview toggle. (#1597, #1700) Thanks @rohannagpal, @zerone0x. https://docs.molt.bot/channels/telegram ### Changes - Channels: add LINE plugin (Messaging API) with rich replies, quick replies, and plugin HTTP registry. (#1630) Thanks @plum-dawg. -- TTS: add Edge TTS provider fallback, defaulting to keyless Edge with MP3 retry on format failures. (#1668) Thanks @steipete. https://docs.clawd.bot/tts -- TTS: add auto mode enum (off/always/inbound/tagged) with per-session `/tts` override. (#1667) Thanks @sebslight. https://docs.clawd.bot/tts +- TTS: add Edge TTS provider fallback, defaulting to keyless Edge with MP3 retry on format failures. (#1668) Thanks @steipete. https://docs.molt.bot/tts +- TTS: add auto mode enum (off/always/inbound/tagged) with per-session `/tts` override. (#1667) Thanks @sebslight. https://docs.molt.bot/tts - Telegram: treat DM topics as separate sessions and keep DM history limits stable with thread suffixes. (#1597) Thanks @rohannagpal. -- Telegram: add `channels.telegram.linkPreview` to toggle outbound link previews. (#1700) Thanks @zerone0x. https://docs.clawd.bot/channels/telegram -- Web search: add Brave freshness filter parameter for time-scoped results. (#1688) Thanks @JonUleis. https://docs.clawd.bot/tools/web +- Telegram: add `channels.telegram.linkPreview` to toggle outbound link previews. (#1700) Thanks @zerone0x. https://docs.molt.bot/channels/telegram +- Web search: add Brave freshness filter parameter for time-scoped results. (#1688) Thanks @JonUleis. https://docs.molt.bot/tools/web - UI: refresh Control UI dashboard design system (colors, icons, typography). (#1745, #1786) Thanks @EnzeD, @mousberg. -- Exec approvals: forward approval prompts to chat with `/approve` for all channels (including plugins). (#1621) Thanks @czekaj. https://docs.clawd.bot/tools/exec-approvals https://docs.clawd.bot/tools/slash-commands +- Exec approvals: forward approval prompts to chat with `/approve` for all channels (including plugins). (#1621) Thanks @czekaj. https://docs.molt.bot/tools/exec-approvals https://docs.molt.bot/tools/slash-commands - Gateway: expose config.patch in the gateway tool with safe partial updates + restart sentinel. (#1653) Thanks @Glucksberg. -- Diagnostics: add diagnostic flags for targeted debug logs (config + env override). https://docs.clawd.bot/diagnostics/flags +- Diagnostics: add diagnostic flags for targeted debug logs (config + env override). https://docs.molt.bot/diagnostics/flags - Docs: expand FAQ (migration, scheduling, concurrency, model recommendations, OpenAI subscription auth, Pi sizing, hackable install, docs SSL workaround). - Docs: add verbose installer troubleshooting guidance. - Docs: add macOS VM guide with local/hosted options + VPS/nodes guidance. (#1693) Thanks @f-trycua. -- Docs: add Bedrock EC2 instance role setup + IAM steps. (#1625) Thanks @sergical. https://docs.clawd.bot/bedrock +- Docs: add Bedrock EC2 instance role setup + IAM steps. (#1625) Thanks @sergical. https://docs.molt.bot/bedrock - Docs: update Fly.io guide notes. - Dev: add prek pre-commit hooks + dependabot config for weekly updates. (#1720) Thanks @dguido. @@ -144,11 +144,11 @@ Status: unreleased. - Web UI: hide internal `message_id` hints in chat bubbles. - Gateway: allow Control UI token-only auth to skip device pairing even when device identity is present (`gateway.controlUi.allowInsecureAuth`). (#1679) Thanks @steipete. - Matrix: decrypt E2EE media attachments with preflight size guard. (#1744) Thanks @araa47. -- BlueBubbles: route phone-number targets to DMs, avoid leaking routing IDs, and auto-create missing DMs (Private API required). (#1751) Thanks @tyler6204. https://docs.clawd.bot/channels/bluebubbles +- BlueBubbles: route phone-number targets to DMs, avoid leaking routing IDs, and auto-create missing DMs (Private API required). (#1751) Thanks @tyler6204. https://docs.molt.bot/channels/bluebubbles - BlueBubbles: keep part-index GUIDs in reply tags when short IDs are missing. - iMessage: normalize chat_id/chat_guid/chat_identifier prefixes case-insensitively and keep service-prefixed handles stable. (#1708) Thanks @aaronn. - Signal: repair reaction sends (group/UUID targets + CLI author flags). (#1651) Thanks @vilkasdev. -- Signal: add configurable signal-cli startup timeout + external daemon mode docs. (#1677) https://docs.clawd.bot/channels/signal +- Signal: add configurable signal-cli startup timeout + external daemon mode docs. (#1677) https://docs.molt.bot/channels/signal - Telegram: set fetch duplex="half" for uploads on Node 22 to avoid sendPhoto failures. (#1684) Thanks @commdata2338. - Telegram: use wrapped fetch for long-polling on Node to normalize AbortSignal handling. (#1639) - Telegram: honor per-account proxy for outbound API calls. (#1774) Thanks @radek-paclt. @@ -186,25 +186,25 @@ Status: unreleased. ## 2026.1.23 ### Highlights -- TTS: move Telegram TTS into core + enable model-driven TTS tags by default for expressive audio replies. (#1559) Thanks @Glucksberg. https://docs.clawd.bot/tts -- Gateway: add `/tools/invoke` HTTP endpoint for direct tool calls (auth + tool policy enforced). (#1575) Thanks @vignesh07. https://docs.clawd.bot/gateway/tools-invoke-http-api -- Heartbeat: per-channel visibility controls (OK/alerts/indicator). (#1452) Thanks @dlauer. https://docs.clawd.bot/gateway/heartbeat -- Deploy: add Fly.io deployment support + guide. (#1570) https://docs.clawd.bot/platforms/fly -- Channels: add Tlon/Urbit channel plugin (DMs, group mentions, thread replies). (#1544) Thanks @wca4a. https://docs.clawd.bot/channels/tlon +- TTS: move Telegram TTS into core + enable model-driven TTS tags by default for expressive audio replies. (#1559) Thanks @Glucksberg. https://docs.molt.bot/tts +- Gateway: add `/tools/invoke` HTTP endpoint for direct tool calls (auth + tool policy enforced). (#1575) Thanks @vignesh07. https://docs.molt.bot/gateway/tools-invoke-http-api +- Heartbeat: per-channel visibility controls (OK/alerts/indicator). (#1452) Thanks @dlauer. https://docs.molt.bot/gateway/heartbeat +- Deploy: add Fly.io deployment support + guide. (#1570) https://docs.molt.bot/platforms/fly +- Channels: add Tlon/Urbit channel plugin (DMs, group mentions, thread replies). (#1544) Thanks @wca4a. https://docs.molt.bot/channels/tlon ### Changes -- Channels: allow per-group tool allow/deny policies across built-in + plugin channels. (#1546) Thanks @adam91holt. https://docs.clawd.bot/multi-agent-sandbox-tools -- Agents: add Bedrock auto-discovery defaults + config overrides. (#1553) Thanks @fal3. https://docs.clawd.bot/bedrock -- CLI: add `clawdbot system` for system events + heartbeat controls; remove standalone `wake`. (commit 71203829d) https://docs.clawd.bot/cli/system -- CLI: add live auth probes to `clawdbot models status` for per-profile verification. (commit 40181afde) https://docs.clawd.bot/cli/models +- Channels: allow per-group tool allow/deny policies across built-in + plugin channels. (#1546) Thanks @adam91holt. https://docs.molt.bot/multi-agent-sandbox-tools +- Agents: add Bedrock auto-discovery defaults + config overrides. (#1553) Thanks @fal3. https://docs.molt.bot/bedrock +- CLI: add `clawdbot system` for system events + heartbeat controls; remove standalone `wake`. (commit 71203829d) https://docs.molt.bot/cli/system +- CLI: add live auth probes to `clawdbot models status` for per-profile verification. (commit 40181afde) https://docs.molt.bot/cli/models - CLI: restart the gateway by default after `clawdbot update`; add `--no-restart` to skip it. (commit 2c85b1b40) - Browser: add node-host proxy auto-routing for remote gateways (configurable per gateway/node). (commit c3cb26f7c) -- Plugins: add optional `llm-task` JSON-only tool for workflows. (#1498) Thanks @vignesh07. https://docs.clawd.bot/tools/llm-task +- Plugins: add optional `llm-task` JSON-only tool for workflows. (#1498) Thanks @vignesh07. https://docs.molt.bot/tools/llm-task - Markdown: add per-channel table conversion (bullets for Signal/WhatsApp, code blocks elsewhere). (#1495) Thanks @odysseus0. - Agents: keep system prompt time zone-only and move current time to `session_status` for better cache hits. (commit 66eec295b) - Agents: remove redundant bash tool alias from tool registration/display. (#1571) Thanks @Takhoffman. -- Docs: add cron vs heartbeat decision guide (with Lobster workflow notes). (#1533) Thanks @JustYannicc. https://docs.clawd.bot/automation/cron-vs-heartbeat -- Docs: clarify HEARTBEAT.md empty file skips heartbeats, missing file still runs. (#1535) Thanks @JustYannicc. https://docs.clawd.bot/gateway/heartbeat +- Docs: add cron vs heartbeat decision guide (with Lobster workflow notes). (#1533) Thanks @JustYannicc. https://docs.molt.bot/automation/cron-vs-heartbeat +- Docs: clarify HEARTBEAT.md empty file skips heartbeats, missing file still runs. (#1535) Thanks @JustYannicc. https://docs.molt.bot/gateway/heartbeat ### Fixes - Sessions: accept non-UUID sessionIds for history/send/status while preserving agent scoping. (#1518) @@ -282,14 +282,14 @@ Status: unreleased. ## 2026.1.21-2 ### Fixes -- Control UI: ignore bootstrap identity placeholder text for avatar values and fall back to the default avatar. https://docs.clawd.bot/cli/agents https://docs.clawd.bot/web/control-ui +- Control UI: ignore bootstrap identity placeholder text for avatar values and fall back to the default avatar. https://docs.molt.bot/cli/agents https://docs.molt.bot/web/control-ui - Slack: remove deprecated `filetype` field from `files.uploadV2` to eliminate API warnings. (#1447) ## 2026.1.21 ### Changes -- Highlight: Lobster optional plugin tool for typed workflows + approval gates. https://docs.clawd.bot/tools/lobster -- Lobster: allow workflow file args via `argsJson` in the plugin tool. https://docs.clawd.bot/tools/lobster +- Highlight: Lobster optional plugin tool for typed workflows + approval gates. https://docs.molt.bot/tools/lobster +- Lobster: allow workflow file args via `argsJson` in the plugin tool. https://docs.molt.bot/tools/lobster - Heartbeat: allow running heartbeats in an explicit session key. (#1256) Thanks @zknicker. - CLI: default exec approvals to the local host, add gateway/node targeting flags, and show target details in allowlist output. - CLI: exec approvals mutations render tables instead of raw JSON. @@ -301,16 +301,16 @@ Status: unreleased. - Sessions: add per-channel reset overrides via `session.resetByChannel`. (#1353) Thanks @cash-echo-bot. - Agents: add identity avatar config support and Control UI avatar rendering. (#1329, #1424) Thanks @dlauer. - UI: show per-session assistant identity in the Control UI. (#1420) Thanks @robbyczgw-cla. -- CLI: add `clawdbot update wizard` for interactive channel selection and restart prompts. https://docs.clawd.bot/cli/update +- CLI: add `clawdbot update wizard` for interactive channel selection and restart prompts. https://docs.molt.bot/cli/update - Signal: add typing indicators and DM read receipts via signal-cli. - MSTeams: add file uploads, adaptive cards, and attachment handling improvements. (#1410) Thanks @Evizero. - Onboarding: remove the run setup-token auth option (paste setup-token or reuse CLI creds instead). -- Docs: add troubleshooting entry for gateway.mode blocking gateway start. https://docs.clawd.bot/gateway/troubleshooting +- Docs: add troubleshooting entry for gateway.mode blocking gateway start. https://docs.molt.bot/gateway/troubleshooting - Docs: add /model allowlist troubleshooting note. (#1405) - Docs: add per-message Gmail search example for gog. (#1220) Thanks @mbelinky. ### Breaking -- **BREAKING:** Control UI now rejects insecure HTTP without device identity by default. Use HTTPS (Tailscale Serve) or set `gateway.controlUi.allowInsecureAuth: true` to allow token-only auth. https://docs.clawd.bot/web/control-ui#insecure-http +- **BREAKING:** Control UI now rejects insecure HTTP without device identity by default. Use HTTPS (Tailscale Serve) or set `gateway.controlUi.allowInsecureAuth: true` to allow token-only auth. https://docs.molt.bot/web/control-ui#insecure-http - **BREAKING:** Envelope and system event timestamps now default to host-local time (was UTC) so agents don’t have to constantly convert. ### Fixes @@ -336,68 +336,68 @@ Status: unreleased. ## 2026.1.20 ### Changes -- Control UI: add copy-as-markdown with error feedback. (#1345) https://docs.clawd.bot/web/control-ui -- Control UI: drop the legacy list view. (#1345) https://docs.clawd.bot/web/control-ui -- TUI: add syntax highlighting for code blocks. (#1200) https://docs.clawd.bot/tui -- TUI: session picker shows derived titles, fuzzy search, relative times, and last message preview. (#1271) https://docs.clawd.bot/tui -- TUI: add a searchable model picker for quicker model selection. (#1198) https://docs.clawd.bot/tui -- TUI: add input history (up/down) for submitted messages. (#1348) https://docs.clawd.bot/tui -- ACP: add `clawdbot acp` for IDE integrations. https://docs.clawd.bot/cli/acp -- ACP: add `clawdbot acp client` interactive harness for debugging. https://docs.clawd.bot/cli/acp -- Skills: add download installs with OS-filtered options. https://docs.clawd.bot/tools/skills -- Skills: add the local sherpa-onnx-tts skill. https://docs.clawd.bot/tools/skills -- Memory: add hybrid BM25 + vector search (FTS5) with weighted merging and fallback. https://docs.clawd.bot/concepts/memory -- Memory: add SQLite embedding cache to speed up reindexing and frequent updates. https://docs.clawd.bot/concepts/memory -- Memory: add OpenAI batch indexing for embeddings when configured. https://docs.clawd.bot/concepts/memory -- Memory: enable OpenAI batch indexing by default for OpenAI embeddings. https://docs.clawd.bot/concepts/memory -- Memory: allow parallel OpenAI batch indexing jobs (default concurrency: 2). https://docs.clawd.bot/concepts/memory -- Memory: render progress immediately, color batch statuses in verbose logs, and poll OpenAI batch status every 2s by default. https://docs.clawd.bot/concepts/memory -- Memory: add `--verbose` logging for memory status + batch indexing details. https://docs.clawd.bot/concepts/memory -- Memory: add native Gemini embeddings provider for memory search. (#1151) https://docs.clawd.bot/concepts/memory -- Browser: allow config defaults for efficient snapshots in the tool/CLI. (#1336) https://docs.clawd.bot/tools/browser -- Nostr: add the Nostr channel plugin with profile management + onboarding defaults. (#1323) https://docs.clawd.bot/channels/nostr -- Matrix: migrate to matrix-bot-sdk with E2EE support, location handling, and group allowlist upgrades. (#1298) https://docs.clawd.bot/channels/matrix -- Slack: add HTTP webhook mode via Bolt HTTP receiver. (#1143) https://docs.clawd.bot/channels/slack -- Telegram: enrich forwarded-message context with normalized origin details + legacy fallback. (#1090) https://docs.clawd.bot/channels/telegram +- Control UI: add copy-as-markdown with error feedback. (#1345) https://docs.molt.bot/web/control-ui +- Control UI: drop the legacy list view. (#1345) https://docs.molt.bot/web/control-ui +- TUI: add syntax highlighting for code blocks. (#1200) https://docs.molt.bot/tui +- TUI: session picker shows derived titles, fuzzy search, relative times, and last message preview. (#1271) https://docs.molt.bot/tui +- TUI: add a searchable model picker for quicker model selection. (#1198) https://docs.molt.bot/tui +- TUI: add input history (up/down) for submitted messages. (#1348) https://docs.molt.bot/tui +- ACP: add `clawdbot acp` for IDE integrations. https://docs.molt.bot/cli/acp +- ACP: add `clawdbot acp client` interactive harness for debugging. https://docs.molt.bot/cli/acp +- Skills: add download installs with OS-filtered options. https://docs.molt.bot/tools/skills +- Skills: add the local sherpa-onnx-tts skill. https://docs.molt.bot/tools/skills +- Memory: add hybrid BM25 + vector search (FTS5) with weighted merging and fallback. https://docs.molt.bot/concepts/memory +- Memory: add SQLite embedding cache to speed up reindexing and frequent updates. https://docs.molt.bot/concepts/memory +- Memory: add OpenAI batch indexing for embeddings when configured. https://docs.molt.bot/concepts/memory +- Memory: enable OpenAI batch indexing by default for OpenAI embeddings. https://docs.molt.bot/concepts/memory +- Memory: allow parallel OpenAI batch indexing jobs (default concurrency: 2). https://docs.molt.bot/concepts/memory +- Memory: render progress immediately, color batch statuses in verbose logs, and poll OpenAI batch status every 2s by default. https://docs.molt.bot/concepts/memory +- Memory: add `--verbose` logging for memory status + batch indexing details. https://docs.molt.bot/concepts/memory +- Memory: add native Gemini embeddings provider for memory search. (#1151) https://docs.molt.bot/concepts/memory +- Browser: allow config defaults for efficient snapshots in the tool/CLI. (#1336) https://docs.molt.bot/tools/browser +- Nostr: add the Nostr channel plugin with profile management + onboarding defaults. (#1323) https://docs.molt.bot/channels/nostr +- Matrix: migrate to matrix-bot-sdk with E2EE support, location handling, and group allowlist upgrades. (#1298) https://docs.molt.bot/channels/matrix +- Slack: add HTTP webhook mode via Bolt HTTP receiver. (#1143) https://docs.molt.bot/channels/slack +- Telegram: enrich forwarded-message context with normalized origin details + legacy fallback. (#1090) https://docs.molt.bot/channels/telegram - Discord: fall back to `/skill` when native command limits are exceeded. (#1287) - Discord: expose `/skill` globally. (#1287) -- Zalouser: add channel dock metadata, config schema, setup wiring, probe, and status issues. (#1219) https://docs.clawd.bot/plugins/zalouser -- Plugins: require manifest-embedded config schemas with preflight validation warnings. (#1272) https://docs.clawd.bot/plugins/manifest -- Plugins: move channel catalog metadata into plugin manifests. (#1290) https://docs.clawd.bot/plugins/manifest -- Plugins: align Nextcloud Talk policy helpers with core patterns. (#1290) https://docs.clawd.bot/plugins/manifest -- Plugins/UI: let channel plugin metadata drive UI labels/icons and cron channel options. (#1306) https://docs.clawd.bot/web/control-ui -- Agents/UI: add agent avatar support in identity config, IDENTITY.md, and the Control UI. (#1329) https://docs.clawd.bot/gateway/configuration -- Plugins: add plugin slots with a dedicated memory slot selector. https://docs.clawd.bot/plugins/agent-tools -- Plugins: ship the bundled BlueBubbles channel plugin (disabled by default). https://docs.clawd.bot/channels/bluebubbles +- Zalouser: add channel dock metadata, config schema, setup wiring, probe, and status issues. (#1219) https://docs.molt.bot/plugins/zalouser +- Plugins: require manifest-embedded config schemas with preflight validation warnings. (#1272) https://docs.molt.bot/plugins/manifest +- Plugins: move channel catalog metadata into plugin manifests. (#1290) https://docs.molt.bot/plugins/manifest +- Plugins: align Nextcloud Talk policy helpers with core patterns. (#1290) https://docs.molt.bot/plugins/manifest +- Plugins/UI: let channel plugin metadata drive UI labels/icons and cron channel options. (#1306) https://docs.molt.bot/web/control-ui +- Agents/UI: add agent avatar support in identity config, IDENTITY.md, and the Control UI. (#1329) https://docs.molt.bot/gateway/configuration +- Plugins: add plugin slots with a dedicated memory slot selector. https://docs.molt.bot/plugins/agent-tools +- Plugins: ship the bundled BlueBubbles channel plugin (disabled by default). https://docs.molt.bot/channels/bluebubbles - Plugins: migrate bundled messaging extensions to the plugin SDK and resolve plugin-sdk imports in the loader. -- Plugins: migrate the Zalo plugin to the shared plugin SDK runtime. https://docs.clawd.bot/channels/zalo -- Plugins: migrate the Zalo Personal plugin to the shared plugin SDK runtime. https://docs.clawd.bot/plugins/zalouser -- Plugins: allow optional agent tools with explicit allowlists and add the plugin tool authoring guide. https://docs.clawd.bot/plugins/agent-tools +- Plugins: migrate the Zalo plugin to the shared plugin SDK runtime. https://docs.molt.bot/channels/zalo +- Plugins: migrate the Zalo Personal plugin to the shared plugin SDK runtime. https://docs.molt.bot/plugins/zalouser +- Plugins: allow optional agent tools with explicit allowlists and add the plugin tool authoring guide. https://docs.molt.bot/plugins/agent-tools - Plugins: auto-enable bundled channel/provider plugins when configuration is present. - Plugins: sync plugin sources on channel switches and update npm-installed plugins during `clawdbot update`. - Plugins: share npm plugin update logic between `clawdbot update` and `clawdbot plugins update`. - Gateway/API: add `/v1/responses` (OpenResponses) with item-based input + semantic streaming events. (#1229) - Gateway/API: expand `/v1/responses` to support file/image inputs, tool_choice, usage, and output limits. (#1229) -- Usage: add `/usage cost` summaries and macOS menu cost charts. https://docs.clawd.bot/reference/api-usage-costs -- Security: warn when <=300B models run without sandboxing while web tools are enabled. https://docs.clawd.bot/cli/security -- Exec: add host/security/ask routing for gateway + node exec. https://docs.clawd.bot/tools/exec -- Exec: add `/exec` directive for per-session exec defaults (host/security/ask/node). https://docs.clawd.bot/tools/exec -- Exec approvals: migrate approvals to `~/.clawdbot/exec-approvals.json` with per-agent allowlists + skill auto-allow toggle, and add approvals UI + node exec lifecycle events. https://docs.clawd.bot/tools/exec-approvals -- Nodes: add headless node host (`clawdbot node start`) for `system.run`/`system.which`. https://docs.clawd.bot/cli/node -- Nodes: add node daemon service install/status/start/stop/restart. https://docs.clawd.bot/cli/node +- Usage: add `/usage cost` summaries and macOS menu cost charts. https://docs.molt.bot/reference/api-usage-costs +- Security: warn when <=300B models run without sandboxing while web tools are enabled. https://docs.molt.bot/cli/security +- Exec: add host/security/ask routing for gateway + node exec. https://docs.molt.bot/tools/exec +- Exec: add `/exec` directive for per-session exec defaults (host/security/ask/node). https://docs.molt.bot/tools/exec +- Exec approvals: migrate approvals to `~/.clawdbot/exec-approvals.json` with per-agent allowlists + skill auto-allow toggle, and add approvals UI + node exec lifecycle events. https://docs.molt.bot/tools/exec-approvals +- Nodes: add headless node host (`clawdbot node start`) for `system.run`/`system.which`. https://docs.molt.bot/cli/node +- Nodes: add node daemon service install/status/start/stop/restart. https://docs.molt.bot/cli/node - Bridge: add `skills.bins` RPC to support node host auto-allow skill bins. -- Sessions: add daily reset policy with per-type overrides and idle windows (default 4am local), preserving legacy idle-only configs. (#1146) https://docs.clawd.bot/concepts/session -- Sessions: allow `sessions_spawn` to override thinking level for sub-agent runs. https://docs.clawd.bot/tools/subagents -- Channels: unify thread/topic allowlist matching + command/mention gating helpers across core providers. https://docs.clawd.bot/concepts/groups -- Models: add Qwen Portal OAuth provider support. (#1120) https://docs.clawd.bot/providers/qwen -- Onboarding: add allowlist prompts and username-to-id resolution across core and extension channels. https://docs.clawd.bot/start/onboarding -- Docs: clarify allowlist input types and onboarding behavior for messaging channels. https://docs.clawd.bot/start/onboarding -- Docs: refresh Android node discovery docs for the Gateway WS service type. https://docs.clawd.bot/platforms/android -- Docs: surface Amazon Bedrock in provider lists and clarify Bedrock auth env vars. (#1289) https://docs.clawd.bot/bedrock -- Docs: clarify WhatsApp voice notes. https://docs.clawd.bot/channels/whatsapp -- Docs: clarify Windows WSL portproxy LAN access notes. https://docs.clawd.bot/platforms/windows -- Docs: refresh bird skill install metadata and usage notes. (#1302) https://docs.clawd.bot/tools/browser-login +- Sessions: add daily reset policy with per-type overrides and idle windows (default 4am local), preserving legacy idle-only configs. (#1146) https://docs.molt.bot/concepts/session +- Sessions: allow `sessions_spawn` to override thinking level for sub-agent runs. https://docs.molt.bot/tools/subagents +- Channels: unify thread/topic allowlist matching + command/mention gating helpers across core providers. https://docs.molt.bot/concepts/groups +- Models: add Qwen Portal OAuth provider support. (#1120) https://docs.molt.bot/providers/qwen +- Onboarding: add allowlist prompts and username-to-id resolution across core and extension channels. https://docs.molt.bot/start/onboarding +- Docs: clarify allowlist input types and onboarding behavior for messaging channels. https://docs.molt.bot/start/onboarding +- Docs: refresh Android node discovery docs for the Gateway WS service type. https://docs.molt.bot/platforms/android +- Docs: surface Amazon Bedrock in provider lists and clarify Bedrock auth env vars. (#1289) https://docs.molt.bot/bedrock +- Docs: clarify WhatsApp voice notes. https://docs.molt.bot/channels/whatsapp +- Docs: clarify Windows WSL portproxy LAN access notes. https://docs.molt.bot/platforms/windows +- Docs: refresh bird skill install metadata and usage notes. (#1302) https://docs.molt.bot/tools/browser-login - Agents: add local docs path resolution and include docs/mirror/source/community pointers in the system prompt. - Agents: clarify node_modules read-only guidance in agent instructions. - Config: stamp last-touched metadata on write and warn if the config is newer than the running build. @@ -522,19 +522,19 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic ## 2026.1.16-1 ### Highlights -- Hooks: add hooks system with bundled hooks, CLI tooling, and docs. (#1028) — thanks @ThomsenDrake. https://docs.clawd.bot/hooks -- Media: add inbound media understanding (image/audio/video) with provider + CLI fallbacks. https://docs.clawd.bot/nodes/media-understanding -- Plugins: add Zalo Personal plugin (`@clawdbot/zalouser`) and unify channel directory for plugins. (#1032) — thanks @suminhthanh. https://docs.clawd.bot/plugins/zalouser -- Models: add Vercel AI Gateway auth choice + onboarding updates. (#1016) — thanks @timolins. https://docs.clawd.bot/providers/vercel-ai-gateway -- Sessions: add `session.identityLinks` for cross-platform DM session li nking. (#1033) — thanks @thewilloftheshadow. https://docs.clawd.bot/concepts/session -- Web search: add `country`/`language` parameters (schema + Brave API) and docs. (#1046) — thanks @YuriNachos. https://docs.clawd.bot/tools/web +- Hooks: add hooks system with bundled hooks, CLI tooling, and docs. (#1028) — thanks @ThomsenDrake. https://docs.molt.bot/hooks +- Media: add inbound media understanding (image/audio/video) with provider + CLI fallbacks. https://docs.molt.bot/nodes/media-understanding +- Plugins: add Zalo Personal plugin (`@clawdbot/zalouser`) and unify channel directory for plugins. (#1032) — thanks @suminhthanh. https://docs.molt.bot/plugins/zalouser +- Models: add Vercel AI Gateway auth choice + onboarding updates. (#1016) — thanks @timolins. https://docs.molt.bot/providers/vercel-ai-gateway +- Sessions: add `session.identityLinks` for cross-platform DM session li nking. (#1033) — thanks @thewilloftheshadow. https://docs.molt.bot/concepts/session +- Web search: add `country`/`language` parameters (schema + Brave API) and docs. (#1046) — thanks @YuriNachos. https://docs.molt.bot/tools/web ### Breaking - **BREAKING:** `clawdbot message` and message tool now require `target` (dropping `to`/`channelId` for destinations). (#1034) — thanks @tobalsan. - **BREAKING:** Channel auth now prefers config over env for Discord/Telegram/Matrix (env is fallback only). (#1040) — thanks @thewilloftheshadow. - **BREAKING:** Drop legacy `chatType: "room"` support; use `chatType: "channel"`. - **BREAKING:** remove legacy provider-specific target resolution fallbacks; target resolution is centralized with plugin hints + directory lookups. -- **BREAKING:** `clawdbot hooks` is now `clawdbot webhooks`; hooks live under `clawdbot hooks`. https://docs.clawd.bot/cli/webhooks +- **BREAKING:** `clawdbot hooks` is now `clawdbot webhooks`; hooks live under `clawdbot hooks`. https://docs.molt.bot/cli/webhooks - **BREAKING:** `clawdbot plugins install ` now copies into `~/.clawdbot/extensions` (use `--link` to keep path-based loading). ### Changes @@ -545,7 +545,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Tools: send Chrome-like headers by default for `web_fetch` to improve extraction on bot-sensitive sites. - Tools: Firecrawl fallback now uses bot-circumvention + cache by default; remove basic HTML fallback when extraction fails. - Tools: default `exec` exit notifications and auto-migrate legacy `tools.bash` to `tools.exec`. -- Tools: add `exec` PTY support for interactive sessions. https://docs.clawd.bot/tools/exec +- Tools: add `exec` PTY support for interactive sessions. https://docs.molt.bot/tools/exec - Tools: add tmux-style `process send-keys` and bracketed paste helpers for PTY sessions. - Tools: add `process submit` helper to send CR for PTY sessions. - Tools: respond to PTY cursor position queries to unblock interactive TUIs. @@ -600,7 +600,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Sessions: hard-stop `sessions.delete` cleanup. - Channels: treat replies to the bot as implicit mentions across supported channels. - Channels: normalize object-format capabilities in channel capability parsing. -- Security: default-deny slash/control commands unless a channel computed `CommandAuthorized` (fixes accidental “open” behavior), and ensure WhatsApp + Zalo plugin channels gate inline `/…` tokens correctly. https://docs.clawd.bot/gateway/security +- Security: default-deny slash/control commands unless a channel computed `CommandAuthorized` (fixes accidental “open” behavior), and ensure WhatsApp + Zalo plugin channels gate inline `/…` tokens correctly. https://docs.molt.bot/gateway/security - Security: redact sensitive text in gateway WS logs. - Tools: cap pending `exec` process output to avoid unbounded buffers. - CLI: speed up `clawdbot sandbox-explain` by avoiding heavy plugin imports when normalizing channel ids. @@ -906,7 +906,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Agents: add pre-compaction memory flush config (`agents.defaults.compaction.*`) with a soft threshold + system prompt. - Config: add `$include` directive for modular config files. (#731) — thanks @pasogott. - Build: set pnpm minimum release age to 2880 minutes (2 days). (#718) — thanks @dan-dr. -- macOS: prompt to install the global `clawdbot` CLI when missing in local mode; install via `clawd.bot/install-cli.sh` (no onboarding) and use external launchd/CLI instead of the embedded gateway runtime. +- macOS: prompt to install the global `clawdbot` CLI when missing in local mode; install via `molt.bot/install-cli.sh` (no onboarding) and use external launchd/CLI instead of the embedded gateway runtime. - Docs: add gog calendar event color IDs from `gog calendar colors`. (#715) — thanks @mjrussell. - Cron/CLI: add `--model` flag to cron add/edit commands. (#711) — thanks @mjrussell. - Cron/CLI: trim model overrides on cron edits and document main-session guidance. (#711) — thanks @mjrussell. @@ -920,7 +920,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic ### Installer - Postinstall: replace `git apply` with builtin JS patcher (works npm/pnpm/bun; no git dependency) plus regression tests. - Postinstall: skip pnpm patch fallback when the new patcher is active. -- Installer tests: add root+non-root docker smokes, CI workflow to fetch clawd.bot scripts and run install sh/cli with onboarding skipped. +- Installer tests: add root+non-root docker smokes, CI workflow to fetch molt.bot scripts and run install sh/cli with onboarding skipped. - Installer UX: support `CLAWDBOT_NO_ONBOARD=1` for non-interactive installs; fix npm prefix on Linux and auto-install git. - Installer UX: add `install.sh --help` with flags/env and git install hint. - Installer UX: add `--install-method git|npm` and auto-detect source checkouts (prompt to update git checkout vs migrate to npm). diff --git a/README.md b/README.md index a3f0b11d1..9f1f93193 100644 --- a/README.md +++ b/README.md @@ -21,55 +21,56 @@ It answers you on the channels you already use (WhatsApp, Telegram, Slack, Disco If you want a personal, single-user assistant that feels local, fast, and always-on, this is it. -[Website](https://clawdbot.com) · [Docs](https://docs.clawd.bot) · [Getting Started](https://docs.clawd.bot/start/getting-started) · [Updating](https://docs.clawd.bot/install/updating) · [Showcase](https://docs.clawd.bot/start/showcase) · [FAQ](https://docs.clawd.bot/start/faq) · [Wizard](https://docs.clawd.bot/start/wizard) · [Nix](https://github.com/clawdbot/nix-clawdbot) · [Docker](https://docs.clawd.bot/install/docker) · [Discord](https://discord.gg/clawd) +[Website](https://molt.bot) · [Docs](https://docs.molt.bot) · [Getting Started](https://docs.molt.bot/start/getting-started) · [Updating](https://docs.molt.bot/install/updating) · [Showcase](https://docs.molt.bot/start/showcase) · [FAQ](https://docs.molt.bot/start/faq) · [Wizard](https://docs.molt.bot/start/wizard) · [Nix](https://github.com/clawdbot/nix-clawdbot) · [Docker](https://docs.molt.bot/install/docker) · [Discord](https://discord.gg/clawd) Preferred setup: run the onboarding wizard (`clawdbot onboard`). It walks through gateway, workspace, channels, and skills. The CLI wizard is the recommended path and works on **macOS, Linux, and Windows (via WSL2; strongly recommended)**. Works with npm, pnpm, or bun. -New install? Start here: [Getting started](https://docs.clawd.bot/start/getting-started) +New install? Start here: [Getting started](https://docs.molt.bot/start/getting-started) **Subscriptions (OAuth):** - **[Anthropic](https://www.anthropic.com/)** (Claude Pro/Max) - **[OpenAI](https://openai.com/)** (ChatGPT/Codex) -Model note: while any model is supported, I strongly recommend **Anthropic Pro/Max (100/200) + Opus 4.5** for long‑context strength and better prompt‑injection resistance. See [Onboarding](https://docs.clawd.bot/start/onboarding). +Model note: while any model is supported, I strongly recommend **Anthropic Pro/Max (100/200) + Opus 4.5** for long‑context strength and better prompt‑injection resistance. See [Onboarding](https://docs.molt.bot/start/onboarding). ## Models (selection + auth) -- Models config + CLI: [Models](https://docs.clawd.bot/concepts/models) -- Auth profile rotation (OAuth vs API keys) + fallbacks: [Model failover](https://docs.clawd.bot/concepts/model-failover) +- Models config + CLI: [Models](https://docs.molt.bot/concepts/models) +- Auth profile rotation (OAuth vs API keys) + fallbacks: [Model failover](https://docs.molt.bot/concepts/model-failover) ## Install (recommended) Runtime: **Node ≥22**. ```bash -npm install -g clawdbot@latest -# or: pnpm add -g clawdbot@latest +npm install -g moltbot@latest +# or: pnpm add -g moltbot@latest -clawdbot onboard --install-daemon +moltbot onboard --install-daemon ``` The wizard installs the Gateway daemon (launchd/systemd user service) so it stays running. +Legacy note: `clawdbot` remains available as a compatibility shim. ## Quick start (TL;DR) Runtime: **Node ≥22**. -Full beginner guide (auth, pairing, channels): [Getting started](https://docs.clawd.bot/start/getting-started) +Full beginner guide (auth, pairing, channels): [Getting started](https://docs.molt.bot/start/getting-started) ```bash -clawdbot onboard --install-daemon +moltbot onboard --install-daemon -clawdbot gateway --port 18789 --verbose +moltbot gateway --port 18789 --verbose # Send a message -clawdbot message send --to +1234567890 --message "Hello from Clawdbot" +moltbot message send --to +1234567890 --message "Hello from Moltbot" # Talk to the assistant (optionally deliver back to any connected channel: WhatsApp/Telegram/Slack/Discord/Google Chat/Signal/iMessage/BlueBubbles/Microsoft Teams/Matrix/Zalo/Zalo Personal/WebChat) -clawdbot agent --message "Ship checklist" --thinking high +moltbot agent --message "Ship checklist" --thinking high ``` -Upgrading? [Updating guide](https://docs.clawd.bot/install/updating) (and run `clawdbot doctor`). +Upgrading? [Updating guide](https://docs.molt.bot/install/updating) (and run `moltbot doctor`). ## Development channels @@ -78,7 +79,7 @@ Upgrading? [Updating guide](https://docs.clawd.bot/install/updating) (and run `c - **dev**: moving head of `main`, npm dist-tag `dev` (when published). Switch channels (git + npm): `clawdbot update --channel stable|beta|dev`. -Details: [Development channels](https://docs.clawd.bot/install/development-channels). +Details: [Development channels](https://docs.molt.bot/install/development-channels). ## From source (development) @@ -92,19 +93,19 @@ pnpm install pnpm ui:build # auto-installs UI deps on first run pnpm build -pnpm clawdbot onboard --install-daemon +pnpm moltbot onboard --install-daemon # Dev loop (auto-reload on TS changes) pnpm gateway:watch ``` -Note: `pnpm clawdbot ...` runs TypeScript directly (via `tsx`). `pnpm build` produces `dist/` for running via Node / the packaged `clawdbot` binary. +Note: `pnpm moltbot ...` runs TypeScript directly (via `tsx`). `pnpm build` produces `dist/` for running via Node / the packaged `moltbot` binary. ## Security defaults (DM access) Clawdbot connects to real messaging surfaces. Treat inbound DMs as **untrusted input**. -Full security guide: [Security](https://docs.clawd.bot/gateway/security) +Full security guide: [Security](https://docs.molt.bot/gateway/security) Default behavior on Telegram/WhatsApp/Signal/iMessage/Microsoft Teams/Discord/Google Chat/Slack: - **DM pairing** (`dmPolicy="pairing"` / `channels.discord.dm.policy="pairing"` / `channels.slack.dm.policy="pairing"`): unknown senders receive a short pairing code and the bot does not process their message. @@ -115,14 +116,14 @@ Run `clawdbot doctor` to surface risky/misconfigured DM policies. ## Highlights -- **[Local-first Gateway](https://docs.clawd.bot/gateway)** — single control plane for sessions, channels, tools, and events. -- **[Multi-channel inbox](https://docs.clawd.bot/channels)** — WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage, BlueBubbles, Microsoft Teams, Matrix, Zalo, Zalo Personal, WebChat, macOS, iOS/Android. -- **[Multi-agent routing](https://docs.clawd.bot/gateway/configuration)** — route inbound channels/accounts/peers to isolated agents (workspaces + per-agent sessions). -- **[Voice Wake](https://docs.clawd.bot/nodes/voicewake) + [Talk Mode](https://docs.clawd.bot/nodes/talk)** — always-on speech for macOS/iOS/Android with ElevenLabs. -- **[Live Canvas](https://docs.clawd.bot/platforms/mac/canvas)** — agent-driven visual workspace with [A2UI](https://docs.clawd.bot/platforms/mac/canvas#canvas-a2ui). -- **[First-class tools](https://docs.clawd.bot/tools)** — browser, canvas, nodes, cron, sessions, and Discord/Slack actions. -- **[Companion apps](https://docs.clawd.bot/platforms/macos)** — macOS menu bar app + iOS/Android [nodes](https://docs.clawd.bot/nodes). -- **[Onboarding](https://docs.clawd.bot/start/wizard) + [skills](https://docs.clawd.bot/tools/skills)** — wizard-driven setup with bundled/managed/workspace skills. +- **[Local-first Gateway](https://docs.molt.bot/gateway)** — single control plane for sessions, channels, tools, and events. +- **[Multi-channel inbox](https://docs.molt.bot/channels)** — WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage, BlueBubbles, Microsoft Teams, Matrix, Zalo, Zalo Personal, WebChat, macOS, iOS/Android. +- **[Multi-agent routing](https://docs.molt.bot/gateway/configuration)** — route inbound channels/accounts/peers to isolated agents (workspaces + per-agent sessions). +- **[Voice Wake](https://docs.molt.bot/nodes/voicewake) + [Talk Mode](https://docs.molt.bot/nodes/talk)** — always-on speech for macOS/iOS/Android with ElevenLabs. +- **[Live Canvas](https://docs.molt.bot/platforms/mac/canvas)** — agent-driven visual workspace with [A2UI](https://docs.molt.bot/platforms/mac/canvas#canvas-a2ui). +- **[First-class tools](https://docs.molt.bot/tools)** — browser, canvas, nodes, cron, sessions, and Discord/Slack actions. +- **[Companion apps](https://docs.molt.bot/platforms/macos)** — macOS menu bar app + iOS/Android [nodes](https://docs.molt.bot/nodes). +- **[Onboarding](https://docs.molt.bot/start/wizard) + [skills](https://docs.molt.bot/tools/skills)** — wizard-driven setup with bundled/managed/workspace skills. ## Star History @@ -131,40 +132,40 @@ Run `clawdbot doctor` to surface risky/misconfigured DM policies. ## Everything we built so far ### Core platform -- [Gateway WS control plane](https://docs.clawd.bot/gateway) with sessions, presence, config, cron, webhooks, [Control UI](https://docs.clawd.bot/web), and [Canvas host](https://docs.clawd.bot/platforms/mac/canvas#canvas-a2ui). -- [CLI surface](https://docs.clawd.bot/tools/agent-send): gateway, agent, send, [wizard](https://docs.clawd.bot/start/wizard), and [doctor](https://docs.clawd.bot/gateway/doctor). -- [Pi agent runtime](https://docs.clawd.bot/concepts/agent) in RPC mode with tool streaming and block streaming. -- [Session model](https://docs.clawd.bot/concepts/session): `main` for direct chats, group isolation, activation modes, queue modes, reply-back. Group rules: [Groups](https://docs.clawd.bot/concepts/groups). -- [Media pipeline](https://docs.clawd.bot/nodes/images): images/audio/video, transcription hooks, size caps, temp file lifecycle. Audio details: [Audio](https://docs.clawd.bot/nodes/audio). +- [Gateway WS control plane](https://docs.molt.bot/gateway) with sessions, presence, config, cron, webhooks, [Control UI](https://docs.molt.bot/web), and [Canvas host](https://docs.molt.bot/platforms/mac/canvas#canvas-a2ui). +- [CLI surface](https://docs.molt.bot/tools/agent-send): gateway, agent, send, [wizard](https://docs.molt.bot/start/wizard), and [doctor](https://docs.molt.bot/gateway/doctor). +- [Pi agent runtime](https://docs.molt.bot/concepts/agent) in RPC mode with tool streaming and block streaming. +- [Session model](https://docs.molt.bot/concepts/session): `main` for direct chats, group isolation, activation modes, queue modes, reply-back. Group rules: [Groups](https://docs.molt.bot/concepts/groups). +- [Media pipeline](https://docs.molt.bot/nodes/images): images/audio/video, transcription hooks, size caps, temp file lifecycle. Audio details: [Audio](https://docs.molt.bot/nodes/audio). ### Channels -- [Channels](https://docs.clawd.bot/channels): [WhatsApp](https://docs.clawd.bot/channels/whatsapp) (Baileys), [Telegram](https://docs.clawd.bot/channels/telegram) (grammY), [Slack](https://docs.clawd.bot/channels/slack) (Bolt), [Discord](https://docs.clawd.bot/channels/discord) (discord.js), [Google Chat](https://docs.clawd.bot/channels/googlechat) (Chat API), [Signal](https://docs.clawd.bot/channels/signal) (signal-cli), [iMessage](https://docs.clawd.bot/channels/imessage) (imsg), [BlueBubbles](https://docs.clawd.bot/channels/bluebubbles) (extension), [Microsoft Teams](https://docs.clawd.bot/channels/msteams) (extension), [Matrix](https://docs.clawd.bot/channels/matrix) (extension), [Zalo](https://docs.clawd.bot/channels/zalo) (extension), [Zalo Personal](https://docs.clawd.bot/channels/zalouser) (extension), [WebChat](https://docs.clawd.bot/web/webchat). -- [Group routing](https://docs.clawd.bot/concepts/group-messages): mention gating, reply tags, per-channel chunking and routing. Channel rules: [Channels](https://docs.clawd.bot/channels). +- [Channels](https://docs.molt.bot/channels): [WhatsApp](https://docs.molt.bot/channels/whatsapp) (Baileys), [Telegram](https://docs.molt.bot/channels/telegram) (grammY), [Slack](https://docs.molt.bot/channels/slack) (Bolt), [Discord](https://docs.molt.bot/channels/discord) (discord.js), [Google Chat](https://docs.molt.bot/channels/googlechat) (Chat API), [Signal](https://docs.molt.bot/channels/signal) (signal-cli), [iMessage](https://docs.molt.bot/channels/imessage) (imsg), [BlueBubbles](https://docs.molt.bot/channels/bluebubbles) (extension), [Microsoft Teams](https://docs.molt.bot/channels/msteams) (extension), [Matrix](https://docs.molt.bot/channels/matrix) (extension), [Zalo](https://docs.molt.bot/channels/zalo) (extension), [Zalo Personal](https://docs.molt.bot/channels/zalouser) (extension), [WebChat](https://docs.molt.bot/web/webchat). +- [Group routing](https://docs.molt.bot/concepts/group-messages): mention gating, reply tags, per-channel chunking and routing. Channel rules: [Channels](https://docs.molt.bot/channels). ### Apps + nodes -- [macOS app](https://docs.clawd.bot/platforms/macos): menu bar control plane, [Voice Wake](https://docs.clawd.bot/nodes/voicewake)/PTT, [Talk Mode](https://docs.clawd.bot/nodes/talk) overlay, [WebChat](https://docs.clawd.bot/web/webchat), debug tools, [remote gateway](https://docs.clawd.bot/gateway/remote) control. -- [iOS node](https://docs.clawd.bot/platforms/ios): [Canvas](https://docs.clawd.bot/platforms/mac/canvas), [Voice Wake](https://docs.clawd.bot/nodes/voicewake), [Talk Mode](https://docs.clawd.bot/nodes/talk), camera, screen recording, Bonjour pairing. -- [Android node](https://docs.clawd.bot/platforms/android): [Canvas](https://docs.clawd.bot/platforms/mac/canvas), [Talk Mode](https://docs.clawd.bot/nodes/talk), camera, screen recording, optional SMS. -- [macOS node mode](https://docs.clawd.bot/nodes): system.run/notify + canvas/camera exposure. +- [macOS app](https://docs.molt.bot/platforms/macos): menu bar control plane, [Voice Wake](https://docs.molt.bot/nodes/voicewake)/PTT, [Talk Mode](https://docs.molt.bot/nodes/talk) overlay, [WebChat](https://docs.molt.bot/web/webchat), debug tools, [remote gateway](https://docs.molt.bot/gateway/remote) control. +- [iOS node](https://docs.molt.bot/platforms/ios): [Canvas](https://docs.molt.bot/platforms/mac/canvas), [Voice Wake](https://docs.molt.bot/nodes/voicewake), [Talk Mode](https://docs.molt.bot/nodes/talk), camera, screen recording, Bonjour pairing. +- [Android node](https://docs.molt.bot/platforms/android): [Canvas](https://docs.molt.bot/platforms/mac/canvas), [Talk Mode](https://docs.molt.bot/nodes/talk), camera, screen recording, optional SMS. +- [macOS node mode](https://docs.molt.bot/nodes): system.run/notify + canvas/camera exposure. ### Tools + automation -- [Browser control](https://docs.clawd.bot/tools/browser): dedicated clawd Chrome/Chromium, snapshots, actions, uploads, profiles. -- [Canvas](https://docs.clawd.bot/platforms/mac/canvas): [A2UI](https://docs.clawd.bot/platforms/mac/canvas#canvas-a2ui) push/reset, eval, snapshot. -- [Nodes](https://docs.clawd.bot/nodes): camera snap/clip, screen record, [location.get](https://docs.clawd.bot/nodes/location-command), notifications. -- [Cron + wakeups](https://docs.clawd.bot/automation/cron-jobs); [webhooks](https://docs.clawd.bot/automation/webhook); [Gmail Pub/Sub](https://docs.clawd.bot/automation/gmail-pubsub). -- [Skills platform](https://docs.clawd.bot/tools/skills): bundled, managed, and workspace skills with install gating + UI. +- [Browser control](https://docs.molt.bot/tools/browser): dedicated clawd Chrome/Chromium, snapshots, actions, uploads, profiles. +- [Canvas](https://docs.molt.bot/platforms/mac/canvas): [A2UI](https://docs.molt.bot/platforms/mac/canvas#canvas-a2ui) push/reset, eval, snapshot. +- [Nodes](https://docs.molt.bot/nodes): camera snap/clip, screen record, [location.get](https://docs.molt.bot/nodes/location-command), notifications. +- [Cron + wakeups](https://docs.molt.bot/automation/cron-jobs); [webhooks](https://docs.molt.bot/automation/webhook); [Gmail Pub/Sub](https://docs.molt.bot/automation/gmail-pubsub). +- [Skills platform](https://docs.molt.bot/tools/skills): bundled, managed, and workspace skills with install gating + UI. ### Runtime + safety -- [Channel routing](https://docs.clawd.bot/concepts/channel-routing), [retry policy](https://docs.clawd.bot/concepts/retry), and [streaming/chunking](https://docs.clawd.bot/concepts/streaming). -- [Presence](https://docs.clawd.bot/concepts/presence), [typing indicators](https://docs.clawd.bot/concepts/typing-indicators), and [usage tracking](https://docs.clawd.bot/concepts/usage-tracking). -- [Models](https://docs.clawd.bot/concepts/models), [model failover](https://docs.clawd.bot/concepts/model-failover), and [session pruning](https://docs.clawd.bot/concepts/session-pruning). -- [Security](https://docs.clawd.bot/gateway/security) and [troubleshooting](https://docs.clawd.bot/channels/troubleshooting). +- [Channel routing](https://docs.molt.bot/concepts/channel-routing), [retry policy](https://docs.molt.bot/concepts/retry), and [streaming/chunking](https://docs.molt.bot/concepts/streaming). +- [Presence](https://docs.molt.bot/concepts/presence), [typing indicators](https://docs.molt.bot/concepts/typing-indicators), and [usage tracking](https://docs.molt.bot/concepts/usage-tracking). +- [Models](https://docs.molt.bot/concepts/models), [model failover](https://docs.molt.bot/concepts/model-failover), and [session pruning](https://docs.molt.bot/concepts/session-pruning). +- [Security](https://docs.molt.bot/gateway/security) and [troubleshooting](https://docs.molt.bot/channels/troubleshooting). ### Ops + packaging -- [Control UI](https://docs.clawd.bot/web) + [WebChat](https://docs.clawd.bot/web/webchat) served directly from the Gateway. -- [Tailscale Serve/Funnel](https://docs.clawd.bot/gateway/tailscale) or [SSH tunnels](https://docs.clawd.bot/gateway/remote) with token/password auth. -- [Nix mode](https://docs.clawd.bot/install/nix) for declarative config; [Docker](https://docs.clawd.bot/install/docker)-based installs. -- [Doctor](https://docs.clawd.bot/gateway/doctor) migrations, [logging](https://docs.clawd.bot/logging). +- [Control UI](https://docs.molt.bot/web) + [WebChat](https://docs.molt.bot/web/webchat) served directly from the Gateway. +- [Tailscale Serve/Funnel](https://docs.molt.bot/gateway/tailscale) or [SSH tunnels](https://docs.molt.bot/gateway/remote) with token/password auth. +- [Nix mode](https://docs.molt.bot/install/nix) for declarative config; [Docker](https://docs.molt.bot/install/docker)-based installs. +- [Doctor](https://docs.molt.bot/gateway/doctor) migrations, [logging](https://docs.molt.bot/logging). ## How it works (short) @@ -187,12 +188,12 @@ WhatsApp / Telegram / Slack / Discord / Google Chat / Signal / iMessage / BlueBu ## Key subsystems -- **[Gateway WebSocket network](https://docs.clawd.bot/concepts/architecture)** — single WS control plane for clients, tools, and events (plus ops: [Gateway runbook](https://docs.clawd.bot/gateway)). -- **[Tailscale exposure](https://docs.clawd.bot/gateway/tailscale)** — Serve/Funnel for the Gateway dashboard + WS (remote access: [Remote](https://docs.clawd.bot/gateway/remote)). -- **[Browser control](https://docs.clawd.bot/tools/browser)** — clawd‑managed Chrome/Chromium with CDP control. -- **[Canvas + A2UI](https://docs.clawd.bot/platforms/mac/canvas)** — agent‑driven visual workspace (A2UI host: [Canvas/A2UI](https://docs.clawd.bot/platforms/mac/canvas#canvas-a2ui)). -- **[Voice Wake](https://docs.clawd.bot/nodes/voicewake) + [Talk Mode](https://docs.clawd.bot/nodes/talk)** — always‑on speech and continuous conversation. -- **[Nodes](https://docs.clawd.bot/nodes)** — Canvas, camera snap/clip, screen record, `location.get`, notifications, plus macOS‑only `system.run`/`system.notify`. +- **[Gateway WebSocket network](https://docs.molt.bot/concepts/architecture)** — single WS control plane for clients, tools, and events (plus ops: [Gateway runbook](https://docs.molt.bot/gateway)). +- **[Tailscale exposure](https://docs.molt.bot/gateway/tailscale)** — Serve/Funnel for the Gateway dashboard + WS (remote access: [Remote](https://docs.molt.bot/gateway/remote)). +- **[Browser control](https://docs.molt.bot/tools/browser)** — clawd‑managed Chrome/Chromium with CDP control. +- **[Canvas + A2UI](https://docs.molt.bot/platforms/mac/canvas)** — agent‑driven visual workspace (A2UI host: [Canvas/A2UI](https://docs.molt.bot/platforms/mac/canvas#canvas-a2ui)). +- **[Voice Wake](https://docs.molt.bot/nodes/voicewake) + [Talk Mode](https://docs.molt.bot/nodes/talk)** — always‑on speech and continuous conversation. +- **[Nodes](https://docs.molt.bot/nodes)** — Canvas, camera snap/clip, screen record, `location.get`, notifications, plus macOS‑only `system.run`/`system.notify`. ## Tailscale access (Gateway dashboard) @@ -208,7 +209,7 @@ Notes: - Funnel refuses to start unless `gateway.auth.mode: "password"` is set. - Optional: `gateway.tailscale.resetOnExit` to undo Serve/Funnel on shutdown. -Details: [Tailscale guide](https://docs.clawd.bot/gateway/tailscale) · [Web surfaces](https://docs.clawd.bot/web) +Details: [Tailscale guide](https://docs.molt.bot/gateway/tailscale) · [Web surfaces](https://docs.molt.bot/web) ## Remote Gateway (Linux is great) @@ -218,7 +219,7 @@ It’s perfectly fine to run the Gateway on a small Linux instance. Clients (mac - **Device nodes** run device‑local actions (`system.run`, camera, screen recording, notifications) via `node.invoke`. In short: exec runs where the Gateway lives; device actions run where the device lives. -Details: [Remote access](https://docs.clawd.bot/gateway/remote) · [Nodes](https://docs.clawd.bot/nodes) · [Security](https://docs.clawd.bot/gateway/security) +Details: [Remote access](https://docs.molt.bot/gateway/remote) · [Nodes](https://docs.molt.bot/nodes) · [Security](https://docs.molt.bot/gateway/security) ## macOS permissions via the Gateway protocol @@ -233,7 +234,7 @@ Elevated bash (host permissions) is separate from macOS TCC: - Use `/elevated on|off` to toggle per‑session elevated access when enabled + allowlisted. - Gateway persists the per‑session toggle via `sessions.patch` (WS method) alongside `thinkingLevel`, `verboseLevel`, `model`, `sendPolicy`, and `groupActivation`. -Details: [Nodes](https://docs.clawd.bot/nodes) · [macOS app](https://docs.clawd.bot/platforms/macos) · [Gateway protocol](https://docs.clawd.bot/concepts/architecture) +Details: [Nodes](https://docs.molt.bot/nodes) · [macOS app](https://docs.molt.bot/platforms/macos) · [Gateway protocol](https://docs.molt.bot/concepts/architecture) ## Agent to Agent (sessions_* tools) @@ -242,7 +243,7 @@ Details: [Nodes](https://docs.clawd.bot/nodes) · [macOS app](https://docs.clawd - `sessions_history` — fetch transcript logs for a session. - `sessions_send` — message another session; optional reply‑back ping‑pong + announce step (`REPLY_SKIP`, `ANNOUNCE_SKIP`). -Details: [Session tools](https://docs.clawd.bot/concepts/session-tool) +Details: [Session tools](https://docs.molt.bot/concepts/session-tool) ## Skills registry (ClawdHub) @@ -284,13 +285,13 @@ Note: signed builds required for macOS permissions to stick across rebuilds (see - Voice trigger forwarding + Canvas surface. - Controlled via `clawdbot nodes …`. -Runbook: [iOS connect](https://docs.clawd.bot/platforms/ios). +Runbook: [iOS connect](https://docs.molt.bot/platforms/ios). ### Android node (optional) - Pairs via the same Bridge + pairing flow as iOS. - Exposes Canvas, Camera, and Screen capture commands. -- Runbook: [Android connect](https://docs.clawd.bot/platforms/android). +- Runbook: [Android connect](https://docs.molt.bot/platforms/android). ## Agent workspace + skills @@ -310,7 +311,7 @@ Minimal `~/.clawdbot/clawdbot.json` (model + defaults): } ``` -[Full configuration reference (all keys + examples).](https://docs.clawd.bot/gateway/configuration) +[Full configuration reference (all keys + examples).](https://docs.molt.bot/gateway/configuration) ## Security model (important) @@ -318,15 +319,15 @@ Minimal `~/.clawdbot/clawdbot.json` (model + defaults): - **Group/channel safety:** set `agents.defaults.sandbox.mode: "non-main"` to run **non‑main sessions** (groups/channels) inside per‑session Docker sandboxes; bash then runs in Docker for those sessions. - **Sandbox defaults:** allowlist `bash`, `process`, `read`, `write`, `edit`, `sessions_list`, `sessions_history`, `sessions_send`, `sessions_spawn`; denylist `browser`, `canvas`, `nodes`, `cron`, `discord`, `gateway`. -Details: [Security guide](https://docs.clawd.bot/gateway/security) · [Docker + sandboxing](https://docs.clawd.bot/install/docker) · [Sandbox config](https://docs.clawd.bot/gateway/configuration) +Details: [Security guide](https://docs.molt.bot/gateway/security) · [Docker + sandboxing](https://docs.molt.bot/install/docker) · [Sandbox config](https://docs.molt.bot/gateway/configuration) -### [WhatsApp](https://docs.clawd.bot/channels/whatsapp) +### [WhatsApp](https://docs.molt.bot/channels/whatsapp) - Link the device: `pnpm clawdbot channels login` (stores creds in `~/.clawdbot/credentials`). - Allowlist who can talk to the assistant via `channels.whatsapp.allowFrom`. - If `channels.whatsapp.groups` is set, it becomes a group allowlist; include `"*"` to allow all. -### [Telegram](https://docs.clawd.bot/channels/telegram) +### [Telegram](https://docs.molt.bot/channels/telegram) - Set `TELEGRAM_BOT_TOKEN` or `channels.telegram.botToken` (env wins). - Optional: set `channels.telegram.groups` (with `channels.telegram.groups."*".requireMention`); when set, it is a group allowlist (include `"*"` to allow all). Also `channels.telegram.allowFrom` or `channels.telegram.webhookUrl` as needed. @@ -341,11 +342,11 @@ Details: [Security guide](https://docs.clawd.bot/gateway/security) · [Docker + } ``` -### [Slack](https://docs.clawd.bot/channels/slack) +### [Slack](https://docs.molt.bot/channels/slack) - Set `SLACK_BOT_TOKEN` + `SLACK_APP_TOKEN` (or `channels.slack.botToken` + `channels.slack.appToken`). -### [Discord](https://docs.clawd.bot/channels/discord) +### [Discord](https://docs.molt.bot/channels/discord) - Set `DISCORD_BOT_TOKEN` or `channels.discord.token` (env wins). - Optional: set `commands.native`, `commands.text`, or `commands.useAccessGroups`, plus `channels.discord.dm.allowFrom`, `channels.discord.guilds`, or `channels.discord.mediaMaxMb` as needed. @@ -360,21 +361,21 @@ Details: [Security guide](https://docs.clawd.bot/gateway/security) · [Docker + } ``` -### [Signal](https://docs.clawd.bot/channels/signal) +### [Signal](https://docs.molt.bot/channels/signal) - Requires `signal-cli` and a `channels.signal` config section. -### [iMessage](https://docs.clawd.bot/channels/imessage) +### [iMessage](https://docs.molt.bot/channels/imessage) - macOS only; Messages must be signed in. - If `channels.imessage.groups` is set, it becomes a group allowlist; include `"*"` to allow all. -### [Microsoft Teams](https://docs.clawd.bot/channels/msteams) +### [Microsoft Teams](https://docs.molt.bot/channels/msteams) - Configure a Teams app + Bot Framework, then add a `msteams` config section. - Allowlist who can talk via `msteams.allowFrom`; group access via `msteams.groupAllowFrom` or `msteams.groupPolicy: "open"`. -### [WebChat](https://docs.clawd.bot/web/webchat) +### [WebChat](https://docs.molt.bot/web/webchat) - Uses the Gateway WebSocket; no separate WebChat port/config. @@ -392,69 +393,69 @@ Browser control (optional): ## Docs Use these when you’re past the onboarding flow and want the deeper reference. -- [Start with the docs index for navigation and “what’s where.”](https://docs.clawd.bot) -- [Read the architecture overview for the gateway + protocol model.](https://docs.clawd.bot/concepts/architecture) -- [Use the full configuration reference when you need every key and example.](https://docs.clawd.bot/gateway/configuration) -- [Run the Gateway by the book with the operational runbook.](https://docs.clawd.bot/gateway) -- [Learn how the Control UI/Web surfaces work and how to expose them safely.](https://docs.clawd.bot/web) -- [Understand remote access over SSH tunnels or tailnets.](https://docs.clawd.bot/gateway/remote) -- [Follow the onboarding wizard flow for a guided setup.](https://docs.clawd.bot/start/wizard) -- [Wire external triggers via the webhook surface.](https://docs.clawd.bot/automation/webhook) -- [Set up Gmail Pub/Sub triggers.](https://docs.clawd.bot/automation/gmail-pubsub) -- [Learn the macOS menu bar companion details.](https://docs.clawd.bot/platforms/mac/menu-bar) -- [Platform guides: Windows (WSL2)](https://docs.clawd.bot/platforms/windows), [Linux](https://docs.clawd.bot/platforms/linux), [macOS](https://docs.clawd.bot/platforms/macos), [iOS](https://docs.clawd.bot/platforms/ios), [Android](https://docs.clawd.bot/platforms/android) -- [Debug common failures with the troubleshooting guide.](https://docs.clawd.bot/channels/troubleshooting) -- [Review security guidance before exposing anything.](https://docs.clawd.bot/gateway/security) +- [Start with the docs index for navigation and “what’s where.”](https://docs.molt.bot) +- [Read the architecture overview for the gateway + protocol model.](https://docs.molt.bot/concepts/architecture) +- [Use the full configuration reference when you need every key and example.](https://docs.molt.bot/gateway/configuration) +- [Run the Gateway by the book with the operational runbook.](https://docs.molt.bot/gateway) +- [Learn how the Control UI/Web surfaces work and how to expose them safely.](https://docs.molt.bot/web) +- [Understand remote access over SSH tunnels or tailnets.](https://docs.molt.bot/gateway/remote) +- [Follow the onboarding wizard flow for a guided setup.](https://docs.molt.bot/start/wizard) +- [Wire external triggers via the webhook surface.](https://docs.molt.bot/automation/webhook) +- [Set up Gmail Pub/Sub triggers.](https://docs.molt.bot/automation/gmail-pubsub) +- [Learn the macOS menu bar companion details.](https://docs.molt.bot/platforms/mac/menu-bar) +- [Platform guides: Windows (WSL2)](https://docs.molt.bot/platforms/windows), [Linux](https://docs.molt.bot/platforms/linux), [macOS](https://docs.molt.bot/platforms/macos), [iOS](https://docs.molt.bot/platforms/ios), [Android](https://docs.molt.bot/platforms/android) +- [Debug common failures with the troubleshooting guide.](https://docs.molt.bot/channels/troubleshooting) +- [Review security guidance before exposing anything.](https://docs.molt.bot/gateway/security) ## Advanced docs (discovery + control) -- [Discovery + transports](https://docs.clawd.bot/gateway/discovery) -- [Bonjour/mDNS](https://docs.clawd.bot/gateway/bonjour) -- [Gateway pairing](https://docs.clawd.bot/gateway/pairing) -- [Remote gateway README](https://docs.clawd.bot/gateway/remote-gateway-readme) -- [Control UI](https://docs.clawd.bot/web/control-ui) -- [Dashboard](https://docs.clawd.bot/web/dashboard) +- [Discovery + transports](https://docs.molt.bot/gateway/discovery) +- [Bonjour/mDNS](https://docs.molt.bot/gateway/bonjour) +- [Gateway pairing](https://docs.molt.bot/gateway/pairing) +- [Remote gateway README](https://docs.molt.bot/gateway/remote-gateway-readme) +- [Control UI](https://docs.molt.bot/web/control-ui) +- [Dashboard](https://docs.molt.bot/web/dashboard) ## Operations & troubleshooting -- [Health checks](https://docs.clawd.bot/gateway/health) -- [Gateway lock](https://docs.clawd.bot/gateway/gateway-lock) -- [Background process](https://docs.clawd.bot/gateway/background-process) -- [Browser troubleshooting (Linux)](https://docs.clawd.bot/tools/browser-linux-troubleshooting) -- [Logging](https://docs.clawd.bot/logging) +- [Health checks](https://docs.molt.bot/gateway/health) +- [Gateway lock](https://docs.molt.bot/gateway/gateway-lock) +- [Background process](https://docs.molt.bot/gateway/background-process) +- [Browser troubleshooting (Linux)](https://docs.molt.bot/tools/browser-linux-troubleshooting) +- [Logging](https://docs.molt.bot/logging) ## Deep dives -- [Agent loop](https://docs.clawd.bot/concepts/agent-loop) -- [Presence](https://docs.clawd.bot/concepts/presence) -- [TypeBox schemas](https://docs.clawd.bot/concepts/typebox) -- [RPC adapters](https://docs.clawd.bot/reference/rpc) -- [Queue](https://docs.clawd.bot/concepts/queue) +- [Agent loop](https://docs.molt.bot/concepts/agent-loop) +- [Presence](https://docs.molt.bot/concepts/presence) +- [TypeBox schemas](https://docs.molt.bot/concepts/typebox) +- [RPC adapters](https://docs.molt.bot/reference/rpc) +- [Queue](https://docs.molt.bot/concepts/queue) ## Workspace & skills -- [Skills config](https://docs.clawd.bot/tools/skills-config) -- [Default AGENTS](https://docs.clawd.bot/reference/AGENTS.default) -- [Templates: AGENTS](https://docs.clawd.bot/reference/templates/AGENTS) -- [Templates: BOOTSTRAP](https://docs.clawd.bot/reference/templates/BOOTSTRAP) -- [Templates: IDENTITY](https://docs.clawd.bot/reference/templates/IDENTITY) -- [Templates: SOUL](https://docs.clawd.bot/reference/templates/SOUL) -- [Templates: TOOLS](https://docs.clawd.bot/reference/templates/TOOLS) -- [Templates: USER](https://docs.clawd.bot/reference/templates/USER) +- [Skills config](https://docs.molt.bot/tools/skills-config) +- [Default AGENTS](https://docs.molt.bot/reference/AGENTS.default) +- [Templates: AGENTS](https://docs.molt.bot/reference/templates/AGENTS) +- [Templates: BOOTSTRAP](https://docs.molt.bot/reference/templates/BOOTSTRAP) +- [Templates: IDENTITY](https://docs.molt.bot/reference/templates/IDENTITY) +- [Templates: SOUL](https://docs.molt.bot/reference/templates/SOUL) +- [Templates: TOOLS](https://docs.molt.bot/reference/templates/TOOLS) +- [Templates: USER](https://docs.molt.bot/reference/templates/USER) ## Platform internals -- [macOS dev setup](https://docs.clawd.bot/platforms/mac/dev-setup) -- [macOS menu bar](https://docs.clawd.bot/platforms/mac/menu-bar) -- [macOS voice wake](https://docs.clawd.bot/platforms/mac/voicewake) -- [iOS node](https://docs.clawd.bot/platforms/ios) -- [Android node](https://docs.clawd.bot/platforms/android) -- [Windows (WSL2)](https://docs.clawd.bot/platforms/windows) -- [Linux app](https://docs.clawd.bot/platforms/linux) +- [macOS dev setup](https://docs.molt.bot/platforms/mac/dev-setup) +- [macOS menu bar](https://docs.molt.bot/platforms/mac/menu-bar) +- [macOS voice wake](https://docs.molt.bot/platforms/mac/voicewake) +- [iOS node](https://docs.molt.bot/platforms/ios) +- [Android node](https://docs.molt.bot/platforms/android) +- [Windows (WSL2)](https://docs.molt.bot/platforms/windows) +- [Linux app](https://docs.molt.bot/platforms/linux) ## Email hooks (Gmail) -- [docs.clawd.bot/gmail-pubsub](https://docs.clawd.bot/automation/gmail-pubsub) +- [docs.molt.bot/gmail-pubsub](https://docs.molt.bot/automation/gmail-pubsub) ## Clawd diff --git a/SECURITY.md b/SECURITY.md index 5bc9c9112..1d0849a54 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -11,7 +11,7 @@ If you believe you've found a security issue in Clawdbot, please report it priva For threat model + hardening guidance (including `clawdbot security audit --deep` and `--fix`), see: -- `https://docs.clawd.bot/gateway/security` +- `https://docs.molt.bot/gateway/security` ### Web Interface Safety diff --git a/appcast.xml b/appcast.xml index 8158ac244..df325a7b6 100644 --- a/appcast.xml +++ b/appcast.xml @@ -28,28 +28,28 @@ Clawdbot 2026.1.24

Highlights

    -
  • Providers: Ollama discovery + docs; Venice guide upgrades + cross-links. (#1606) Thanks @abhaymundhara. https://docs.clawd.bot/providers/ollama https://docs.clawd.bot/providers/venice
    • +
  • Providers: Ollama discovery + docs; Venice guide upgrades + cross-links. (#1606) Thanks @abhaymundhara. https://docs.molt.bot/providers/ollama https://docs.molt.bot/providers/venice
  • Channels: LINE plugin (Messaging API) with rich replies + quick replies. (#1630) Thanks @plum-dawg.
    • -
  • TTS: Edge fallback (keyless) + /tts auto modes. (#1668, #1667) Thanks @steipete, @sebslight. https://docs.clawd.bot/tts
    • -
  • Exec approvals: approve in-chat via /approve across all channels (including plugins). (#1621) Thanks @czekaj. https://docs.clawd.bot/tools/exec-approvals https://docs.clawd.bot/tools/slash-commands
    • -
  • Telegram: DM topics as separate sessions + outbound link preview toggle. (#1597, #1700) Thanks @rohannagpal, @zerone0x. https://docs.clawd.bot/channels/telegram
    • +
  • TTS: Edge fallback (keyless) + /tts auto modes. (#1668, #1667) Thanks @steipete, @sebslight. https://docs.molt.bot/tts
    • +
  • Exec approvals: approve in-chat via /approve across all channels (including plugins). (#1621) Thanks @czekaj. https://docs.molt.bot/tools/exec-approvals https://docs.molt.bot/tools/slash-commands
    • +
  • Telegram: DM topics as separate sessions + outbound link preview toggle. (#1597, #1700) Thanks @rohannagpal, @zerone0x. https://docs.molt.bot/channels/telegram

Changes

  • Channels: add LINE plugin (Messaging API) with rich replies, quick replies, and plugin HTTP registry. (#1630) Thanks @plum-dawg.
    • -
  • TTS: add Edge TTS provider fallback, defaulting to keyless Edge with MP3 retry on format failures. (#1668) Thanks @steipete. https://docs.clawd.bot/tts
    • -
  • TTS: add auto mode enum (off/always/inbound/tagged) with per-session /tts override. (#1667) Thanks @sebslight. https://docs.clawd.bot/tts
    • +
  • TTS: add Edge TTS provider fallback, defaulting to keyless Edge with MP3 retry on format failures. (#1668) Thanks @steipete. https://docs.molt.bot/tts
    • +
  • TTS: add auto mode enum (off/always/inbound/tagged) with per-session /tts override. (#1667) Thanks @sebslight. https://docs.molt.bot/tts
  • Telegram: treat DM topics as separate sessions and keep DM history limits stable with thread suffixes. (#1597) Thanks @rohannagpal.
    • -
  • Telegram: add channels.telegram.linkPreview to toggle outbound link previews. (#1700) Thanks @zerone0x. https://docs.clawd.bot/channels/telegram
    • -
  • Web search: add Brave freshness filter parameter for time-scoped results. (#1688) Thanks @JonUleis. https://docs.clawd.bot/tools/web
    • +
  • Telegram: add channels.telegram.linkPreview to toggle outbound link previews. (#1700) Thanks @zerone0x. https://docs.molt.bot/channels/telegram
    • +
  • Web search: add Brave freshness filter parameter for time-scoped results. (#1688) Thanks @JonUleis. https://docs.molt.bot/tools/web
  • UI: refresh Control UI dashboard design system (typography, colors, spacing). (#1786) Thanks @mousberg.
    • -
  • Exec approvals: forward approval prompts to chat with /approve for all channels (including plugins). (#1621) Thanks @czekaj. https://docs.clawd.bot/tools/exec-approvals https://docs.clawd.bot/tools/slash-commands
    • +
  • Exec approvals: forward approval prompts to chat with /approve for all channels (including plugins). (#1621) Thanks @czekaj. https://docs.molt.bot/tools/exec-approvals https://docs.molt.bot/tools/slash-commands
  • Gateway: expose config.patch in the gateway tool with safe partial updates + restart sentinel. (#1653) Thanks @Glucksberg.
    • -
  • Diagnostics: add diagnostic flags for targeted debug logs (config + env override). https://docs.clawd.bot/diagnostics/flags
    • +
  • Diagnostics: add diagnostic flags for targeted debug logs (config + env override). https://docs.molt.bot/diagnostics/flags
  • Docs: expand FAQ (migration, scheduling, concurrency, model recommendations, OpenAI subscription auth, Pi sizing, hackable install, docs SSL workaround).
  • Docs: add verbose installer troubleshooting guidance.
  • Docs: add macOS VM guide with local/hosted options + VPS/nodes guidance. (#1693) Thanks @f-trycua.
    • -
  • Docs: add Bedrock EC2 instance role setup + IAM steps. (#1625) Thanks @sergical. https://docs.clawd.bot/bedrock
    • +
  • Docs: add Bedrock EC2 instance role setup + IAM steps. (#1625) Thanks @sergical. https://docs.molt.bot/bedrock
  • Docs: update Fly.io guide notes.
  • Dev: add prek pre-commit hooks + dependabot config for weekly updates. (#1720) Thanks @dguido.
@@ -61,10 +61,10 @@
  • Web UI: hide internal message_id hints in chat bubbles.
  • Gateway: allow Control UI token-only auth to skip device pairing even when device identity is present (gateway.controlUi.allowInsecureAuth). (#1679) Thanks @steipete.
  • Matrix: decrypt E2EE media attachments with preflight size guard. (#1744) Thanks @araa47.
    • -
  • BlueBubbles: route phone-number targets to DMs, avoid leaking routing IDs, and auto-create missing DMs (Private API required). (#1751) Thanks @tyler6204. https://docs.clawd.bot/channels/bluebubbles
    • +
  • BlueBubbles: route phone-number targets to DMs, avoid leaking routing IDs, and auto-create missing DMs (Private API required). (#1751) Thanks @tyler6204. https://docs.molt.bot/channels/bluebubbles
  • BlueBubbles: keep part-index GUIDs in reply tags when short IDs are missing.
  • Signal: repair reaction sends (group/UUID targets + CLI author flags). (#1651) Thanks @vilkasdev.
    • -
  • Signal: add configurable signal-cli startup timeout + external daemon mode docs. (#1677) https://docs.clawd.bot/channels/signal
    • +
  • Signal: add configurable signal-cli startup timeout + external daemon mode docs. (#1677) https://docs.molt.bot/channels/signal
  • Telegram: set fetch duplex="half" for uploads on Node 22 to avoid sendPhoto failures. (#1684) Thanks @commdata2338.
  • Telegram: use wrapped fetch for long-polling on Node to normalize AbortSignal handling. (#1639)
  • Telegram: honor per-account proxy for outbound API calls. (#1774) Thanks @radek-paclt.
    • diff --git a/apps/macos/Sources/Clawdbot/CLIInstaller.swift b/apps/macos/Sources/Clawdbot/CLIInstaller.swift index b9113e27a..c020ccef9 100644 --- a/apps/macos/Sources/Clawdbot/CLIInstaller.swift +++ b/apps/macos/Sources/Clawdbot/CLIInstaller.swift @@ -70,7 +70,7 @@ enum CLIInstaller { let escapedVersion = self.shellEscape(version) let escapedPrefix = self.shellEscape(prefix) let script = """ - curl -fsSL https://clawd.bot/install-cli.sh | \ + curl -fsSL https://molt.bot/install-cli.sh | \ bash -s -- --json --no-onboard --prefix \(escapedPrefix) --version \(escapedVersion) """ return ["/bin/bash", "-lc", script] diff --git a/assets/chrome-extension/options.html b/assets/chrome-extension/options.html index f66608f43..7cd4e27ce 100644 --- a/assets/chrome-extension/options.html +++ b/assets/chrome-extension/options.html @@ -171,7 +171,7 @@ Start Clawdbot’s browser relay on this machine (Gateway or node host), then click the toolbar button again.

    - Full guide (install, remote Gateway, security): docs.clawd.bot/tools/chrome-extension + Full guide (install, remote Gateway, security): docs.molt.bot/tools/chrome-extension

    diff --git a/docker-setup.sh b/docker-setup.sh index 776541827..906bbb09c 100755 --- a/docker-setup.sh +++ b/docker-setup.sh @@ -191,7 +191,7 @@ echo "Telegram (bot token):" echo " ${COMPOSE_HINT} run --rm clawdbot-cli providers add --provider telegram --token " echo "Discord (bot token):" echo " ${COMPOSE_HINT} run --rm clawdbot-cli providers add --provider discord --token " -echo "Docs: https://docs.clawd.bot/providers" +echo "Docs: https://docs.molt.bot/providers" echo "" echo "==> Starting gateway" diff --git a/docs/CNAME b/docs/CNAME index afc13c7fe..43ca6ac7f 100644 --- a/docs/CNAME +++ b/docs/CNAME @@ -1 +1 @@ -clawdbot.com +docs.molt.bot diff --git a/docs/channels/googlechat.md b/docs/channels/googlechat.md index 00cfa7c72..298e6f9ab 100644 --- a/docs/channels/googlechat.md +++ b/docs/channels/googlechat.md @@ -25,7 +25,7 @@ Status: ready for DMs + spaces via Google Chat API webhooks (HTTP only). 5) Create a Google Chat app in the [Google Cloud Console Chat Configuration](https://console.cloud.google.com/apis/api/chat.googleapis.com/hangouts-chat): - Fill in the **Application info**: - **App name**: (e.g. `Clawdbot`) - - **Avatar URL**: (e.g. `https://clawd.bot/logo.png`) + - **Avatar URL**: (e.g. `https://molt.bot/logo.png`) - **Description**: (e.g. `Personal AI Assistant`) - Enable **Interactive features**. - Under **Functionality**, check **Join spaces and group conversations**. diff --git a/docs/cli/browser.md b/docs/cli/browser.md index 6d54b8a10..d0f1d5a7d 100644 --- a/docs/cli/browser.md +++ b/docs/cli/browser.md @@ -53,7 +53,7 @@ clawdbot browser --browser-profile work tabs ```bash clawdbot browser tabs -clawdbot browser open https://docs.clawd.bot +clawdbot browser open https://docs.molt.bot clawdbot browser focus clawdbot browser close ``` diff --git a/docs/cli/hooks.md b/docs/cli/hooks.md index 825550b05..ee867be69 100644 --- a/docs/cli/hooks.md +++ b/docs/cli/hooks.md @@ -85,7 +85,7 @@ Details: Source: clawdbot-bundled Path: /path/to/clawdbot/hooks/bundled/session-memory/HOOK.md Handler: /path/to/clawdbot/hooks/bundled/session-memory/handler.ts - Homepage: https://docs.clawd.bot/hooks#session-memory + Homepage: https://docs.molt.bot/hooks#session-memory Events: command:new Requirements: diff --git a/docs/concepts/markdown-formatting.md b/docs/concepts/markdown-formatting.md index 91799a3e9..5c92669d2 100644 --- a/docs/concepts/markdown-formatting.md +++ b/docs/concepts/markdown-formatting.md @@ -39,7 +39,7 @@ stay consistent across channels. Input Markdown: ```markdown -Hello **world** — see [docs](https://docs.clawd.bot). +Hello **world** — see [docs](https://docs.molt.bot). ``` IR (schematic): @@ -51,7 +51,7 @@ IR (schematic): { "start": 6, "end": 11, "style": "bold" } ], "links": [ - { "start": 19, "end": 23, "href": "https://docs.clawd.bot" } + { "start": 19, "end": 23, "href": "https://docs.molt.bot" } ] } ``` diff --git a/docs/gateway/security/index.md b/docs/gateway/security/index.md index 5f5990b9e..9b9090d36 100644 --- a/docs/gateway/security/index.md +++ b/docs/gateway/security/index.md @@ -750,7 +750,7 @@ Mario asking for find ~ Found a vulnerability in Clawdbot? Please report responsibly: -1. Email: security@clawd.bot +1. Email: security@molt.bot 2. Don't post publicly until fixed 3. We'll credit you (unless you prefer anonymity) diff --git a/docs/gateway/troubleshooting.md b/docs/gateway/troubleshooting.md index 697654b80..4f192b40f 100644 --- a/docs/gateway/troubleshooting.md +++ b/docs/gateway/troubleshooting.md @@ -501,12 +501,12 @@ upgrades in place and rewrites the gateway service to point at the new install. Switch **to git install**: ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --install-method git --no-onboard +curl -fsSL https://molt.bot/install.sh | bash -s -- --install-method git --no-onboard ``` Switch **to npm global**: ```bash -curl -fsSL https://clawd.bot/install.sh | bash +curl -fsSL https://molt.bot/install.sh | bash ``` Notes: diff --git a/docs/help/faq.md b/docs/help/faq.md index 554597165..55db3e637 100644 --- a/docs/help/faq.md +++ b/docs/help/faq.md @@ -18,7 +18,7 @@ Quick answers plus deeper troubleshooting for real-world setups (local dev, VPS, - [It is stuck on "wake up my friend" / onboarding will not hatch. What now?](#it-is-stuck-on-wake-up-my-friend-onboarding-will-not-hatch-what-now) - [Can I migrate my setup to a new machine (Mac mini) without redoing onboarding?](#can-i-migrate-my-setup-to-a-new-machine-mac-mini-without-redoing-onboarding) - [Where do I see what’s new in the latest version?](#where-do-i-see-whats-new-in-the-latest-version) - - [I can't access docs.clawd.bot (SSL error). What now?](#i-cant-access-docsclawdbot-ssl-error-what-now) + - [I can't access docs.molt.bot (SSL error). What now?](#i-cant-access-docsclawdbot-ssl-error-what-now) - [What’s the difference between stable and beta?](#whats-the-difference-between-stable-and-beta) - [How do I install the beta version, and what’s the difference between beta and dev?](#how-do-i-install-the-beta-version-and-whats-the-difference-between-beta-and-dev) - [How do I try the latest bits?](#how-do-i-try-the-latest-bits) @@ -258,7 +258,7 @@ setup (PATH, services, permissions, auth files). Give them the **full source che the hackable (git) install: ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --install-method git +curl -fsSL https://molt.bot/install.sh | bash -s -- --install-method git ``` This installs Clawdbot **from a git checkout**, so the agent can read the code + docs and @@ -296,7 +296,7 @@ Install docs: [Install](/install), [Installer flags](/install/installer), [Updat The repo recommends running from source and using the onboarding wizard: ```bash -curl -fsSL https://clawd.bot/install.sh | bash +curl -fsSL https://molt.bot/install.sh | bash clawdbot onboard --install-daemon ``` @@ -416,8 +416,8 @@ section is the latest shipped version. Entries are grouped by **Highlights**, ** ### I cant access docsclawdbot SSL error What now -Some Comcast/Xfinity connections incorrectly block `docs.clawd.bot` via Xfinity -Advanced Security. Disable it or allowlist `docs.clawd.bot`, then retry. More +Some Comcast/Xfinity connections incorrectly block `docs.molt.bot` via Xfinity +Advanced Security. Disable it or allowlist `docs.molt.bot`, then retry. More detail: [Troubleshooting](/help/troubleshooting#docsclawdbot-shows-an-ssl-error-comcastxfinity). Please help us unblock it by reporting here: https://spa.xfinity.com/check_url_status. @@ -445,15 +445,15 @@ https://github.com/clawdbot/clawdbot/blob/main/CHANGELOG.md One‑liners (macOS/Linux): ```bash -curl -fsSL --proto '=https' --tlsv1.2 https://clawd.bot/install.sh | bash -s -- --beta +curl -fsSL --proto '=https' --tlsv1.2 https://molt.bot/install.sh | bash -s -- --beta ``` ```bash -curl -fsSL --proto '=https' --tlsv1.2 https://clawd.bot/install.sh | bash -s -- --install-method git +curl -fsSL --proto '=https' --tlsv1.2 https://molt.bot/install.sh | bash -s -- --install-method git ``` Windows installer (PowerShell): -https://clawd.bot/install.ps1 +https://molt.bot/install.ps1 More detail: [Development channels](/install/development-channels) and [Installer flags](/install/installer). @@ -478,7 +478,7 @@ This switches to the `main` branch and updates from source. 2) **Hackable install (from the installer site):** ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --install-method git +curl -fsSL https://molt.bot/install.sh | bash -s -- --install-method git ``` That gives you a local repo you can edit, then update via git. @@ -498,19 +498,19 @@ Docs: [Update](/cli/update), [Development channels](/install/development-channel Re-run the installer with **verbose output**: ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --verbose +curl -fsSL https://molt.bot/install.sh | bash -s -- --verbose ``` Beta install with verbose: ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --beta --verbose +curl -fsSL https://molt.bot/install.sh | bash -s -- --beta --verbose ``` For a hackable (git) install: ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --install-method git --verbose +curl -fsSL https://molt.bot/install.sh | bash -s -- --install-method git --verbose ``` More options: [Installer flags](/install/installer). @@ -541,7 +541,7 @@ Use the **hackable (git) install** so you have the full source and docs locally, your bot (or Claude/Codex) *from that folder* so it can read the repo and answer precisely. ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --install-method git +curl -fsSL https://molt.bot/install.sh | bash -s -- --install-method git ``` More detail: [Install](/install) and [Installer flags](/install/installer). @@ -946,7 +946,7 @@ Advantages: - **Always-on Gateway** (run on a VPS, interact from anywhere) - **Nodes** for local browser/screen/camera/exec -Showcase: https://clawd.bot/showcase +Showcase: https://molt.bot/showcase ## Skills and automation diff --git a/docs/help/troubleshooting.md b/docs/help/troubleshooting.md index 4a7d2ced3..b142de4eb 100644 --- a/docs/help/troubleshooting.md +++ b/docs/help/troubleshooting.md @@ -38,13 +38,13 @@ Almost always a Node/npm PATH issue. Start here: Re-run the installer in verbose mode to see the full trace and npm output: ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --verbose +curl -fsSL https://molt.bot/install.sh | bash -s -- --verbose ``` For beta installs: ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --beta --verbose +curl -fsSL https://molt.bot/install.sh | bash -s -- --beta --verbose ``` You can also set `CLAWDBOT_VERBOSE=1` instead of the flag. @@ -59,10 +59,10 @@ You can also set `CLAWDBOT_VERBOSE=1` instead of the flag. - [Gateway troubleshooting](/gateway/troubleshooting) - [Control UI](/web/control-ui#insecure-http) -### `docs.clawd.bot` shows an SSL error (Comcast/Xfinity) +### `docs.molt.bot` shows an SSL error (Comcast/Xfinity) -Some Comcast/Xfinity connections block `docs.clawd.bot` via Xfinity Advanced Security. -Disable Advanced Security or add `docs.clawd.bot` to the allowlist, then retry. +Some Comcast/Xfinity connections block `docs.molt.bot` via Xfinity Advanced Security. +Disable Advanced Security or add `docs.molt.bot` to the allowlist, then retry. - Xfinity Advanced Security help: https://www.xfinity.com/support/articles/using-xfinity-xfi-advanced-security - Quick sanity checks: try a mobile hotspot or VPN to confirm it’s ISP-level filtering diff --git a/docs/hooks.md b/docs/hooks.md index 9870dda88..880c31f19 100644 --- a/docs/hooks.md +++ b/docs/hooks.md @@ -124,7 +124,7 @@ The `HOOK.md` file contains metadata in YAML frontmatter plus Markdown documenta --- name: my-hook description: "Short description of what this hook does" -homepage: https://docs.clawd.bot/hooks#my-hook +homepage: https://docs.molt.bot/hooks#my-hook metadata: {"clawdbot":{"emoji":"🔗","events":["command:new"],"requires":{"bins":["node"]}}} --- diff --git a/docs/install/index.md b/docs/install/index.md index 7ccab0ca8..f5f5b7476 100644 --- a/docs/install/index.md +++ b/docs/install/index.md @@ -12,13 +12,13 @@ Use the installer unless you have a reason not to. It sets up the CLI and runs o ## Quick install (recommended) ```bash -curl -fsSL https://clawd.bot/install.sh | bash +curl -fsSL https://molt.bot/install.sh | bash ``` Windows (PowerShell): ```powershell -iwr -useb https://clawd.bot/install.ps1 | iex +iwr -useb https://molt.bot/install.ps1 | iex ``` Next step (if you skipped onboarding): @@ -40,13 +40,13 @@ clawdbot onboard --install-daemon Installs `clawdbot` globally via npm and runs onboarding. ```bash -curl -fsSL https://clawd.bot/install.sh | bash +curl -fsSL https://molt.bot/install.sh | bash ``` Installer flags: ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --help +curl -fsSL https://molt.bot/install.sh | bash -s -- --help ``` Details: [Installer internals](/install/installer). @@ -54,7 +54,7 @@ Details: [Installer internals](/install/installer). Non-interactive (skip onboarding): ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --no-onboard +curl -fsSL https://molt.bot/install.sh | bash -s -- --no-onboard ``` ### 2) Global install (manual) @@ -123,10 +123,10 @@ The installer supports two methods: ```bash # Explicit npm -curl -fsSL https://clawd.bot/install.sh | bash -s -- --install-method npm +curl -fsSL https://molt.bot/install.sh | bash -s -- --install-method npm # Install from GitHub (source checkout) -curl -fsSL https://clawd.bot/install.sh | bash -s -- --install-method git +curl -fsSL https://molt.bot/install.sh | bash -s -- --install-method git ``` Common flags: diff --git a/docs/install/installer.md b/docs/install/installer.md index 7cd485756..d60f972d4 100644 --- a/docs/install/installer.md +++ b/docs/install/installer.md @@ -1,29 +1,29 @@ --- summary: "How the installer scripts work (install.sh + install-cli.sh), flags, and automation" read_when: - - You want to understand `clawd.bot/install.sh` + - You want to understand `molt.bot/install.sh` - You want to automate installs (CI / headless) - You want to install from a GitHub checkout --- # Installer internals -Clawdbot ships two installer scripts (served from `clawd.bot`): +Clawdbot ships two installer scripts (served from `molt.bot`): -- `https://clawd.bot/install.sh` — “recommended” installer (global npm install by default; can also install from a GitHub checkout) -- `https://clawd.bot/install-cli.sh` — non-root-friendly CLI installer (installs into a prefix with its own Node) - - `https://clawd.bot/install.ps1` — Windows PowerShell installer (npm by default; optional git install) +- `https://molt.bot/install.sh` — “recommended” installer (global npm install by default; can also install from a GitHub checkout) +- `https://molt.bot/install-cli.sh` — non-root-friendly CLI installer (installs into a prefix with its own Node) + - `https://molt.bot/install.ps1` — Windows PowerShell installer (npm by default; optional git install) To see the current flags/behavior, run: ```bash -curl -fsSL https://clawd.bot/install.sh | bash -s -- --help +curl -fsSL https://molt.bot/install.sh | bash -s -- --help ``` Windows (PowerShell) help: ```powershell -& ([scriptblock]::Create((iwr -useb https://clawd.bot/install.ps1))) -? +& ([scriptblock]::Create((iwr -useb https://molt.bot/install.ps1))) -? ``` If the installer completes but `clawdbot` is not found in a new terminal, it’s usually a Node/npm PATH issue. See: [Install](/install#nodejs--npm-path-sanity). @@ -45,7 +45,7 @@ What it does (high level): If you *want* `sharp` to link against a globally-installed libvips (or you’re debugging), set: ```bash -SHARP_IGNORE_GLOBAL_LIBVIPS=0 curl -fsSL https://clawd.bot/install.sh | bash +SHARP_IGNORE_GLOBAL_LIBVIPS=0 curl -fsSL https://molt.bot/install.sh | bash ``` ### Discoverability / “git install” prompt @@ -78,7 +78,7 @@ This script installs `clawdbot` into a prefix (default: `~/.clawdbot`) and also Help: ```bash -curl -fsSL https://clawd.bot/install-cli.sh | bash -s -- --help +curl -fsSL https://molt.bot/install-cli.sh | bash -s -- --help ``` ## install.ps1 (Windows PowerShell) @@ -94,15 +94,15 @@ What it does (high level): Examples: ```powershell -iwr -useb https://clawd.bot/install.ps1 | iex +iwr -useb https://molt.bot/install.ps1 | iex ``` ```powershell -iwr -useb https://clawd.bot/install.ps1 | iex -InstallMethod git +iwr -useb https://molt.bot/install.ps1 | iex -InstallMethod git ``` ```powershell -iwr -useb https://clawd.bot/install.ps1 | iex -InstallMethod git -GitDir "C:\\clawdbot" +iwr -useb https://molt.bot/install.ps1 | iex -InstallMethod git -GitDir "C:\\clawdbot" ``` Environment variables: diff --git a/docs/install/uninstall.md b/docs/install/uninstall.md index 5849a6780..1c8e65919 100644 --- a/docs/install/uninstall.md +++ b/docs/install/uninstall.md @@ -113,7 +113,7 @@ If you used a profile, delete the matching task name and `~\.clawdbot-\ ### Normal install (install.sh / npm / pnpm / bun) -If you used `https://clawd.bot/install.sh` or `install.ps1`, the CLI was installed with `npm install -g clawdbot@latest`. +If you used `https://molt.bot/install.sh` or `install.ps1`, the CLI was installed with `npm install -g clawdbot@latest`. Remove it with `npm rm -g clawdbot` (or `pnpm remove -g` / `bun remove -g` if you installed that way). ### Source checkout (git clone) diff --git a/docs/install/updating.md b/docs/install/updating.md index 1d39fa6e4..6cca10566 100644 --- a/docs/install/updating.md +++ b/docs/install/updating.md @@ -1,32 +1,33 @@ --- -summary: "Updating Clawdbot safely (global install or source), plus rollback strategy" +summary: "Updating Moltbot safely (global install or source), plus rollback strategy" read_when: - - Updating Clawdbot + - Updating Moltbot - Something breaks after an update --- # Updating -Clawdbot is moving fast (pre “1.0”). Treat updates like shipping infra: update → run checks → restart (or use `clawdbot update`, which restarts) → verify. +Moltbot is moving fast (pre “1.0”). Treat updates like shipping infra: update → run checks → restart (or use `moltbot update`, which restarts) → verify. ## Recommended: re-run the website installer (upgrade in place) The **preferred** update path is to re-run the installer from the website. It -detects existing installs, upgrades in place, and runs `clawdbot doctor` when +detects existing installs, upgrades in place, and runs `moltbot doctor` when needed. ```bash -curl -fsSL https://clawd.bot/install.sh | bash +curl -fsSL https://molt.bot/install.sh | bash ``` Notes: - Add `--no-onboard` if you don’t want the onboarding wizard to run again. - For **source installs**, use: ```bash - curl -fsSL https://clawd.bot/install.sh | bash -s -- --install-method git --no-onboard + curl -fsSL https://molt.bot/install.sh | bash -s -- --install-method git --no-onboard ``` The installer will `git pull --rebase` **only** if the repo is clean. -- For **global installs**, the script uses `npm install -g clawdbot@latest` under the hood. +- For **global installs**, the script uses `npm install -g moltbot@latest` under the hood. +- Legacy note: `clawdbot` remains available as a compatibility shim. ## Before you update @@ -42,20 +43,20 @@ Notes: Global install (pick one): ```bash -npm i -g clawdbot@latest +npm i -g moltbot@latest ``` ```bash -pnpm add -g clawdbot@latest +pnpm add -g moltbot@latest ``` We do **not** recommend Bun for the Gateway runtime (WhatsApp/Telegram bugs). To switch update channels (git + npm installs): ```bash -clawdbot update --channel beta -clawdbot update --channel dev -clawdbot update --channel stable +moltbot update --channel beta +moltbot update --channel dev +moltbot update --channel stable ``` Use `--tag ` for a one-off install tag/version. @@ -67,36 +68,36 @@ Note: on npm installs, the gateway logs an update hint on startup (checks the cu Then: ```bash -clawdbot doctor -clawdbot gateway restart -clawdbot health +moltbot doctor +moltbot gateway restart +moltbot health ``` Notes: -- If your Gateway runs as a service, `clawdbot gateway restart` is preferred over killing PIDs. +- If your Gateway runs as a service, `moltbot gateway restart` is preferred over killing PIDs. - If you’re pinned to a specific version, see “Rollback / pinning” below. -## Update (`clawdbot update`) +## Update (`moltbot update`) For **source installs** (git checkout), prefer: ```bash -clawdbot update +moltbot update ``` It runs a safe-ish update flow: - Requires a clean worktree. - Switches to the selected channel (tag or branch). - Fetches + rebases against the configured upstream (dev channel). -- Installs deps, builds, builds the Control UI, and runs `clawdbot doctor`. +- Installs deps, builds, builds the Control UI, and runs `moltbot doctor`. - Restarts the gateway by default (use `--no-restart` to skip). -If you installed via **npm/pnpm** (no git metadata), `clawdbot update` will try to update via your package manager. If it can’t detect the install, use “Update (global install)” instead. +If you installed via **npm/pnpm** (no git metadata), `moltbot update` will try to update via your package manager. If it can’t detect the install, use “Update (global install)” instead. ## Update (Control UI / RPC) The Control UI has **Update & Restart** (RPC: `update.run`). It: -1) Runs the same source-update flow as `clawdbot update` (git checkout only). +1) Runs the same source-update flow as `moltbot update` (git checkout only). 2) Writes a restart sentinel with a structured report (stdout/stderr tail). 3) Restarts the gateway and pings the last active session with the report. @@ -109,7 +110,7 @@ From the repo checkout: Preferred: ```bash -clawdbot update +moltbot update ``` Manual (equivalent-ish): @@ -119,21 +120,21 @@ git pull pnpm install pnpm build pnpm ui:build # auto-installs UI deps on first run -clawdbot doctor -clawdbot health +moltbot doctor +moltbot health ``` Notes: -- `pnpm build` matters when you run the packaged `clawdbot` binary ([`dist/entry.js`](https://github.com/clawdbot/clawdbot/blob/main/dist/entry.js)) or use Node to run `dist/`. -- If you run from a repo checkout without a global install, use `pnpm clawdbot ...` for CLI commands. -- If you run directly from TypeScript (`pnpm clawdbot ...`), a rebuild is usually unnecessary, but **config migrations still apply** → run doctor. -- Switching between global and git installs is easy: install the other flavor, then run `clawdbot doctor` so the gateway service entrypoint is rewritten to the current install. +- `pnpm build` matters when you run the packaged `moltbot` binary ([`dist/entry.js`](https://github.com/clawdbot/clawdbot/blob/main/dist/entry.js)) or use Node to run `dist/`. +- If you run from a repo checkout without a global install, use `pnpm moltbot ...` for CLI commands. +- If you run directly from TypeScript (`pnpm moltbot ...`), a rebuild is usually unnecessary, but **config migrations still apply** → run doctor. +- Switching between global and git installs is easy: install the other flavor, then run `moltbot doctor` so the gateway service entrypoint is rewritten to the current install. -## Always run: `clawdbot doctor` +## Always Run: `moltbot doctor` Doctor is the “safe update” command. It’s intentionally boring: repair + migrate + warn. -Note: if you’re on a **source install** (git checkout), `clawdbot doctor` will offer to run `clawdbot update` first. +Note: if you’re on a **source install** (git checkout), `moltbot doctor` will offer to run `moltbot update` first. Typical things it does: - Migrate deprecated config keys / legacy config file locations. @@ -149,18 +150,18 @@ Details: [Doctor](/gateway/doctor) CLI (works regardless of OS): ```bash -clawdbot gateway status -clawdbot gateway stop -clawdbot gateway restart -clawdbot gateway --port 18789 -clawdbot logs --follow +moltbot gateway status +moltbot gateway stop +moltbot gateway restart +moltbot gateway --port 18789 +moltbot logs --follow ``` If you’re supervised: - macOS launchd (app-bundled LaunchAgent): `launchctl kickstart -k gui/$UID/com.clawdbot.gateway` (use `com.clawdbot.` if set) - Linux systemd user service: `systemctl --user restart clawdbot-gateway[-].service` - Windows (WSL2): `systemctl --user restart clawdbot-gateway[-].service` - - `launchctl`/`systemctl` only work if the service is installed; otherwise run `clawdbot gateway install`. + - `launchctl`/`systemctl` only work if the service is installed; otherwise run `moltbot gateway install`. Runbook + exact service labels: [Gateway runbook](/gateway) @@ -171,20 +172,20 @@ Runbook + exact service labels: [Gateway runbook](/gateway) Install a known-good version (replace `` with the last working one): ```bash -npm i -g clawdbot@ +npm i -g moltbot@ ``` ```bash -pnpm add -g clawdbot@ +pnpm add -g moltbot@ ``` -Tip: to see the current published version, run `npm view clawdbot version`. +Tip: to see the current published version, run `npm view moltbot version`. Then restart + re-run doctor: ```bash -clawdbot doctor -clawdbot gateway restart +moltbot doctor +moltbot gateway restart ``` ### Pin (source) by date @@ -201,7 +202,7 @@ Then reinstall deps + restart: ```bash pnpm install pnpm build -clawdbot gateway restart +moltbot gateway restart ``` If you want to go back to latest later: @@ -213,6 +214,6 @@ git pull ## If you’re stuck -- Run `clawdbot doctor` again and read the output carefully (it often tells you the fix). +- Run `moltbot doctor` again and read the output carefully (it often tells you the fix). - Check: [Troubleshooting](/gateway/troubleshooting) - Ask in Discord: https://channels.discord.gg/clawd diff --git a/docs/platforms/digitalocean.md b/docs/platforms/digitalocean.md index afefe3676..ac46a5b47 100644 --- a/docs/platforms/digitalocean.md +++ b/docs/platforms/digitalocean.md @@ -65,7 +65,7 @@ curl -fsSL https://deb.nodesource.com/setup_22.x | bash - apt install -y nodejs # Install Clawdbot -curl -fsSL https://clawd.bot/install.sh | bash +curl -fsSL https://molt.bot/install.sh | bash # Verify clawdbot --version diff --git a/docs/platforms/oracle.md b/docs/platforms/oracle.md index d8006754b..52db36049 100644 --- a/docs/platforms/oracle.md +++ b/docs/platforms/oracle.md @@ -97,7 +97,7 @@ tailscale status ## 5) Install Clawdbot ```bash -curl -fsSL https://clawd.bot/install.sh | bash +curl -fsSL https://molt.bot/install.sh | bash source ~/.bashrc ``` diff --git a/docs/platforms/raspberry-pi.md b/docs/platforms/raspberry-pi.md index b34e3fcfe..ba6b339cf 100644 --- a/docs/platforms/raspberry-pi.md +++ b/docs/platforms/raspberry-pi.md @@ -110,7 +110,7 @@ sudo sysctl -p ### Option A: Standard Install (Recommended) ```bash -curl -fsSL https://clawd.bot/install.sh | bash +curl -fsSL https://molt.bot/install.sh | bash ``` ### Option B: Hackable Install (For tinkering) diff --git a/docs/reference/RELEASING.md b/docs/reference/RELEASING.md index a4c68e3e9..c107ac119 100644 --- a/docs/reference/RELEASING.md +++ b/docs/reference/RELEASING.md @@ -42,7 +42,7 @@ When the operator says “release”, immediately do this preflight (no extra qu - [ ] `CLAWDBOT_INSTALL_SMOKE_SKIP_NONROOT=1 pnpm test:install:smoke` (Docker install smoke test, fast path; required before release) - If the immediate previous npm release is known broken, set `CLAWDBOT_INSTALL_SMOKE_PREVIOUS=` or `CLAWDBOT_INSTALL_SMOKE_SKIP_PREVIOUS=1` for the preinstall step. - [ ] (Optional) Full installer smoke (adds non-root + CLI coverage): `pnpm test:install:smoke` -- [ ] (Optional) Installer E2E (Docker, runs `curl -fsSL https://clawd.bot/install.sh | bash`, onboards, then runs real tool calls): +- [ ] (Optional) Installer E2E (Docker, runs `curl -fsSL https://molt.bot/install.sh | bash`, onboards, then runs real tool calls): - `pnpm test:install:e2e:openai` (requires `OPENAI_API_KEY`) - `pnpm test:install:e2e:anthropic` (requires `ANTHROPIC_API_KEY`) - `pnpm test:install:e2e` (requires both keys; runs both providers) diff --git a/docs/start/getting-started.md b/docs/start/getting-started.md index 790a79dfc..92a772c4d 100644 --- a/docs/start/getting-started.md +++ b/docs/start/getting-started.md @@ -54,7 +54,7 @@ Windows: use **WSL2** (Ubuntu recommended). WSL2 is strongly recommended; native ## 1) Install the CLI (recommended) ```bash -curl -fsSL https://clawd.bot/install.sh | bash +curl -fsSL https://molt.bot/install.sh | bash ``` Installer options (install method, non-interactive, from GitHub): [Install](/install). @@ -62,7 +62,7 @@ Installer options (install method, non-interactive, from GitHub): [Install](/ins Windows (PowerShell): ```powershell -iwr -useb https://clawd.bot/install.ps1 | iex +iwr -useb https://molt.bot/install.ps1 | iex ``` Alternative (global install): diff --git a/extensions/lobster/src/lobster-tool.test.ts b/extensions/lobster/src/lobster-tool.test.ts index 5c887cc76..7314c9d5e 100644 --- a/extensions/lobster/src/lobster-tool.test.ts +++ b/extensions/lobster/src/lobster-tool.test.ts @@ -83,6 +83,26 @@ describe("lobster plugin tool", () => { expect(res.details).toMatchObject({ ok: true, status: "ok" }); }); + it("tolerates noisy stdout before the JSON envelope", async () => { + const payload = { ok: true, status: "ok", output: [], requiresApproval: null }; + const { binPath } = await writeFakeLobsterScript( + `const payload = ${JSON.stringify(payload)};\n` + + `console.log("noise before json");\n` + + `process.stdout.write(JSON.stringify(payload));\n`, + "clawdbot-lobster-plugin-noisy-", + ); + + const tool = createLobsterTool(fakeApi()); + const res = await tool.execute("call-noisy", { + action: "run", + pipeline: "noop", + lobsterPath: binPath, + timeoutMs: 1000, + }); + + expect(res.details).toMatchObject({ ok: true, status: "ok" }); + }); + it("requires absolute lobsterPath when provided", async () => { const tool = createLobsterTool(fakeApi()); await expect( diff --git a/extensions/lobster/src/lobster-tool.ts b/extensions/lobster/src/lobster-tool.ts index 368389ab8..e6e8441ff 100644 --- a/extensions/lobster/src/lobster-tool.ts +++ b/extensions/lobster/src/lobster-tool.ts @@ -131,10 +131,28 @@ async function runLobsterSubprocess(params: { } function parseEnvelope(stdout: string): LobsterEnvelope { - let parsed: unknown; - try { - parsed = JSON.parse(stdout); - } catch { + const trimmed = stdout.trim(); + + const tryParse = (input: string) => { + try { + return JSON.parse(input) as unknown; + } catch { + return undefined; + } + }; + + let parsed: unknown = tryParse(trimmed); + + // Some environments can leak extra stdout (e.g. warnings/logs) before the + // final JSON envelope. Be tolerant and parse the last JSON-looking suffix. + if (parsed === undefined) { + const suffixMatch = trimmed.match(/({[\s\S]*}|\[[\s\S]*])\s*$/); + if (suffixMatch?.[1]) { + parsed = tryParse(suffixMatch[1]); + } + } + + if (parsed === undefined) { throw new Error("lobster returned invalid JSON"); } diff --git a/extensions/mattermost/src/onboarding.ts b/extensions/mattermost/src/onboarding.ts index 431c648ae..31578b3e7 100644 --- a/extensions/mattermost/src/onboarding.ts +++ b/extensions/mattermost/src/onboarding.ts @@ -17,7 +17,7 @@ async function noteMattermostSetup(prompter: WizardPrompter): Promise { "2) Create a bot + copy its token", "3) Use your server base URL (e.g., https://chat.example.com)", "Tip: the bot must be a member of any channel you want it to monitor.", - "Docs: https://docs.clawd.bot/channels/mattermost", + "Docs: https://docs.molt.bot/channels/mattermost", ].join("\n"), "Mattermost bot token", ); diff --git a/extensions/tlon/README.md b/extensions/tlon/README.md index aa02cab93..19c8fbb27 100644 --- a/extensions/tlon/README.md +++ b/extensions/tlon/README.md @@ -2,4 +2,4 @@ Tlon/Urbit channel plugin for Clawdbot. Supports DMs, group mentions, and thread replies. -Docs: https://docs.clawd.bot/channels/tlon +Docs: https://docs.molt.bot/channels/tlon diff --git a/extensions/twitch/README.md b/extensions/twitch/README.md index 2d3e4ceea..377b49baa 100644 --- a/extensions/twitch/README.md +++ b/extensions/twitch/README.md @@ -80,7 +80,7 @@ Multi-account config (advanced): ## Full documentation -See https://docs.clawd.bot/channels/twitch for: +See https://docs.molt.bot/channels/twitch for: - Token refresh setup - Access control patterns diff --git a/extensions/voice-call/README.md b/extensions/voice-call/README.md index 5f009aa28..269a67d11 100644 --- a/extensions/voice-call/README.md +++ b/extensions/voice-call/README.md @@ -8,8 +8,8 @@ Providers: - **Plivo** (Voice API + XML transfer + GetInput speech) - **Mock** (dev/no network) -Docs: `https://docs.clawd.bot/plugins/voice-call` -Plugin system: `https://docs.clawd.bot/plugin` +Docs: `https://docs.molt.bot/plugins/voice-call` +Plugin system: `https://docs.molt.bot/plugin` ## Install (local dev) diff --git a/extensions/voice-call/src/cli.ts b/extensions/voice-call/src/cli.ts index 6291ef137..7769ae09f 100644 --- a/extensions/voice-call/src/cli.ts +++ b/extensions/voice-call/src/cli.ts @@ -45,7 +45,7 @@ export function registerVoiceCallCli(params: { const root = program .command("voicecall") .description("Voice call utilities") - .addHelpText("after", () => `\nDocs: https://docs.clawd.bot/cli/voicecall\n`); + .addHelpText("after", () => `\nDocs: https://docs.molt.bot/cli/voicecall\n`); root .command("call") diff --git a/extensions/voice-call/src/core-bridge.ts b/extensions/voice-call/src/core-bridge.ts index a1d01e10f..bc008a515 100644 --- a/extensions/voice-call/src/core-bridge.ts +++ b/extensions/voice-call/src/core-bridge.ts @@ -88,7 +88,7 @@ function findPackageRoot(startDir: string, name: string): string | null { function resolveClawdbotRoot(): string { if (coreRootCache) return coreRootCache; - const override = process.env.CLAWDBOT_ROOT?.trim(); + const override = process.env.MOLTBOT_ROOT?.trim() || process.env.CLAWDBOT_ROOT?.trim(); if (override) { coreRootCache = override; return override; @@ -107,15 +107,17 @@ function resolveClawdbotRoot(): string { } for (const start of candidates) { - const found = findPackageRoot(start, "clawdbot"); - if (found) { - coreRootCache = found; - return found; + for (const name of ["moltbot", "clawdbot"]) { + const found = findPackageRoot(start, name); + if (found) { + coreRootCache = found; + return found; + } } } throw new Error( - "Unable to resolve Clawdbot root. Set CLAWDBOT_ROOT to the package root.", + "Unable to resolve core root. Set MOLTBOT_ROOT (or legacy CLAWDBOT_ROOT) to the package root.", ); } diff --git a/extensions/zalo/src/onboarding.ts b/extensions/zalo/src/onboarding.ts index 4cb681dbe..3c4e5c197 100644 --- a/extensions/zalo/src/onboarding.ts +++ b/extensions/zalo/src/onboarding.ts @@ -132,7 +132,7 @@ async function noteZaloTokenHelp(prompter: WizardPrompter): Promise { "2) Create a bot and get the token", "3) Token looks like 12345689:abc-xyz", "Tip: you can also set ZALO_BOT_TOKEN in your env.", - "Docs: https://docs.clawd.bot/channels/zalo", + "Docs: https://docs.molt.bot/channels/zalo", ].join("\n"), "Zalo bot token", ); diff --git a/extensions/zalouser/src/channel.ts b/extensions/zalouser/src/channel.ts index 6554d7874..712143f65 100644 --- a/extensions/zalouser/src/channel.ts +++ b/extensions/zalouser/src/channel.ts @@ -471,7 +471,7 @@ export const zalouserPlugin: ChannelPlugin = { const ok = await checkZcaInstalled(); if (!ok) { throw new Error( - "Missing dependency: `zca` not found in PATH. See docs.clawd.bot/channels/zalouser", + "Missing dependency: `zca` not found in PATH. See docs.molt.bot/channels/zalouser", ); } runtime.log( diff --git a/extensions/zalouser/src/onboarding.ts b/extensions/zalouser/src/onboarding.ts index a5c205015..2a318d281 100644 --- a/extensions/zalouser/src/onboarding.ts +++ b/extensions/zalouser/src/onboarding.ts @@ -53,7 +53,7 @@ async function noteZalouserHelp(prompter: WizardPrompter): Promise { "1) Install zca-cli", "2) You'll scan a QR code with your Zalo app", "", - "Docs: https://docs.clawd.bot/channels/zalouser", + "Docs: https://docs.molt.bot/channels/zalouser", ].join("\n"), "Zalo Personal Setup", ); @@ -316,7 +316,7 @@ export const zalouserOnboardingAdapter: ChannelOnboardingAdapter = { "The `zca` binary was not found in PATH.", "", "Install zca-cli, then re-run onboarding:", - "Docs: https://docs.clawd.bot/channels/zalouser", + "Docs: https://docs.molt.bot/channels/zalouser", ].join("\n"), "Missing Dependency", ); diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index d1c55dd8d..82f0a96e2 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -316,7 +316,7 @@ importers: devDependencies: clawdbot: specifier: workspace:* - version: link:../.. + version: link:../../packages/clawdbot extensions/imessage: {} @@ -324,7 +324,7 @@ importers: devDependencies: clawdbot: specifier: workspace:* - version: link:../.. + version: link:../../packages/clawdbot extensions/llm-task: {} @@ -350,7 +350,7 @@ importers: devDependencies: clawdbot: specifier: workspace:* - version: link:../.. + version: link:../../packages/clawdbot extensions/mattermost: {} @@ -385,7 +385,7 @@ importers: version: 1.2.2 clawdbot: specifier: workspace:* - version: link:../.. + version: link:../../packages/clawdbot express: specifier: ^5.2.1 version: 5.2.1 @@ -399,7 +399,7 @@ importers: dependencies: clawdbot: specifier: workspace:* - version: link:../.. + version: link:../../packages/clawdbot nostr-tools: specifier: ^2.20.0 version: 2.20.0(typescript@5.9.3) @@ -441,7 +441,7 @@ importers: devDependencies: clawdbot: specifier: workspace:* - version: link:../.. + version: link:../../packages/clawdbot extensions/voice-call: dependencies: @@ -461,7 +461,7 @@ importers: dependencies: clawdbot: specifier: workspace:* - version: link:../.. + version: link:../../packages/clawdbot undici: specifier: 7.19.0 version: 7.19.0 @@ -472,6 +472,12 @@ importers: specifier: 0.34.47 version: 0.34.47 clawdbot: + specifier: workspace:* + version: link:../../packages/clawdbot + + packages/clawdbot: + dependencies: + moltbot: specifier: workspace:* version: link:../.. diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index 115f9a8c0..acf898add 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -1,6 +1,7 @@ packages: - . - ui + - packages/* - extensions/* onlyBuiltDependencies: diff --git a/scripts/docker/install-sh-e2e/run.sh b/scripts/docker/install-sh-e2e/run.sh index 474fc329e..0cc4a27e4 100755 --- a/scripts/docker/install-sh-e2e/run.sh +++ b/scripts/docker/install-sh-e2e/run.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash set -euo pipefail -INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://clawd.bot/install.sh}" +INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://molt.bot/install.sh}" MODELS_MODE="${CLAWDBOT_E2E_MODELS:-both}" # both|openai|anthropic INSTALL_TAG="${CLAWDBOT_INSTALL_TAG:-latest}" E2E_PREVIOUS_VERSION="${CLAWDBOT_INSTALL_E2E_PREVIOUS:-}" diff --git a/scripts/docker/install-sh-nonroot/run.sh b/scripts/docker/install-sh-nonroot/run.sh index 82e2275ae..bdb91bb13 100644 --- a/scripts/docker/install-sh-nonroot/run.sh +++ b/scripts/docker/install-sh-nonroot/run.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash set -euo pipefail -INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://clawd.bot/install.sh}" +INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://molt.bot/install.sh}" echo "==> Pre-flight: ensure git absent" if command -v git >/dev/null; then diff --git a/scripts/docker/install-sh-smoke/run.sh b/scripts/docker/install-sh-smoke/run.sh index b73864ee1..de0e2536f 100755 --- a/scripts/docker/install-sh-smoke/run.sh +++ b/scripts/docker/install-sh-smoke/run.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash set -euo pipefail -INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://clawd.bot/install.sh}" +INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://molt.bot/install.sh}" SMOKE_PREVIOUS_VERSION="${CLAWDBOT_INSTALL_SMOKE_PREVIOUS:-}" SKIP_PREVIOUS="${CLAWDBOT_INSTALL_SMOKE_SKIP_PREVIOUS:-0}" diff --git a/scripts/test-install-sh-docker.sh b/scripts/test-install-sh-docker.sh index ba87eeb65..03cde30be 100755 --- a/scripts/test-install-sh-docker.sh +++ b/scripts/test-install-sh-docker.sh @@ -4,8 +4,8 @@ set -euo pipefail ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" SMOKE_IMAGE="${CLAWDBOT_INSTALL_SMOKE_IMAGE:-clawdbot-install-smoke:local}" NONROOT_IMAGE="${CLAWDBOT_INSTALL_NONROOT_IMAGE:-clawdbot-install-nonroot:local}" -INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://clawd.bot/install.sh}" -CLI_INSTALL_URL="${CLAWDBOT_INSTALL_CLI_URL:-https://clawd.bot/install-cli.sh}" +INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://molt.bot/install.sh}" +CLI_INSTALL_URL="${CLAWDBOT_INSTALL_CLI_URL:-https://molt.bot/install-cli.sh}" SKIP_NONROOT="${CLAWDBOT_INSTALL_SMOKE_SKIP_NONROOT:-0}" LATEST_DIR="$(mktemp -d)" LATEST_FILE="${LATEST_DIR}/latest" diff --git a/scripts/test-install-sh-e2e-docker.sh b/scripts/test-install-sh-e2e-docker.sh index 0ad79aaf8..600be4e56 100755 --- a/scripts/test-install-sh-e2e-docker.sh +++ b/scripts/test-install-sh-e2e-docker.sh @@ -3,7 +3,7 @@ set -euo pipefail ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" IMAGE_NAME="${CLAWDBOT_INSTALL_E2E_IMAGE:-clawdbot-install-e2e:local}" -INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://clawd.bot/install.sh}" +INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://molt.bot/install.sh}" OPENAI_API_KEY="${OPENAI_API_KEY:-}" ANTHROPIC_API_KEY="${ANTHROPIC_API_KEY:-}" diff --git a/src/agents/clawdbot-gateway-tool.test.ts b/src/agents/clawdbot-gateway-tool.test.ts index 76d8ff8e4..8def33988 100644 --- a/src/agents/clawdbot-gateway-tool.test.ts +++ b/src/agents/clawdbot-gateway-tool.test.ts @@ -50,7 +50,7 @@ describe("gateway tool", () => { }; expect(parsed.payload?.kind).toBe("restart"); expect(parsed.payload?.doctorHint).toBe( - "Run: clawdbot --profile isolated doctor --non-interactive", + "Run: moltbot --profile isolated doctor --non-interactive", ); expect(kill).not.toHaveBeenCalled(); diff --git a/src/agents/system-prompt.ts b/src/agents/system-prompt.ts index 1d1a6a5eb..4d4512298 100644 --- a/src/agents/system-prompt.ts +++ b/src/agents/system-prompt.ts @@ -116,7 +116,7 @@ function buildDocsSection(params: { docsPath?: string; isMinimal: boolean; readT return [ "## Documentation", `Clawdbot docs: ${docsPath}`, - "Mirror: https://docs.clawd.bot", + "Mirror: https://docs.molt.bot", "Source: https://github.com/clawdbot/clawdbot", "Community: https://discord.com/invite/clawd", "Find new skills: https://clawdhub.com", diff --git a/src/agents/tools/web-search.ts b/src/agents/tools/web-search.ts index 50d3d19a1..7cec8f21c 100644 --- a/src/agents/tools/web-search.ts +++ b/src/agents/tools/web-search.ts @@ -128,13 +128,13 @@ function missingSearchKeyPayload(provider: (typeof SEARCH_PROVIDERS)[number]) { error: "missing_perplexity_api_key", message: "web_search (perplexity) needs an API key. Set PERPLEXITY_API_KEY or OPENROUTER_API_KEY in the Gateway environment, or configure tools.web.search.perplexity.apiKey.", - docs: "https://docs.clawd.bot/tools/web", + docs: "https://docs.molt.bot/tools/web", }; } return { error: "missing_brave_api_key", message: `web_search needs a Brave Search API key. Run \`${formatCliCommand("clawdbot configure --section web")}\` to store it, or set BRAVE_API_KEY in the Gateway environment.`, - docs: "https://docs.clawd.bot/tools/web", + docs: "https://docs.molt.bot/tools/web", }; } @@ -279,7 +279,7 @@ async function runPerplexitySearch(params: { headers: { "Content-Type": "application/json", Authorization: `Bearer ${params.apiKey}`, - "HTTP-Referer": "https://clawdbot.com", + "HTTP-Referer": "https://molt.bot", "X-Title": "Clawdbot Web Search", }, body: JSON.stringify({ @@ -447,7 +447,7 @@ export function createWebSearchTool(options?: { return jsonResult({ error: "unsupported_freshness", message: "freshness is only supported by the Brave web_search provider.", - docs: "https://docs.clawd.bot/tools/web", + docs: "https://docs.molt.bot/tools/web", }); } const freshness = rawFreshness ? normalizeFreshness(rawFreshness) : undefined; @@ -456,7 +456,7 @@ export function createWebSearchTool(options?: { error: "invalid_freshness", message: "freshness must be one of pd, pw, pm, py, or a range like YYYY-MM-DDtoYYYY-MM-DD.", - docs: "https://docs.clawd.bot/tools/web", + docs: "https://docs.molt.bot/tools/web", }); } const result = await runWebSearch({ diff --git a/src/auto-reply/reply/bash-command.ts b/src/auto-reply/reply/bash-command.ts index a83bf3952..47ea45504 100644 --- a/src/auto-reply/reply/bash-command.ts +++ b/src/auto-reply/reply/bash-command.ts @@ -189,7 +189,7 @@ export async function handleBashChatCommand(params: { }): Promise { if (params.cfg.commands?.bash !== true) { return { - text: "⚠️ bash is disabled. Set commands.bash=true to enable. Docs: https://docs.clawd.bot/tools/slash-commands#config", + text: "⚠️ bash is disabled. Set commands.bash=true to enable. Docs: https://docs.molt.bot/tools/slash-commands#config", }; } diff --git a/src/canvas-host/a2ui/.bundle.hash b/src/canvas-host/a2ui/.bundle.hash index 19a232f5c..01a6e013f 100644 --- a/src/canvas-host/a2ui/.bundle.hash +++ b/src/canvas-host/a2ui/.bundle.hash @@ -1 +1 @@ -2567ca5bbc065b922d96717a488d5db3120b5b033c5d0508682d1aa8fbba470a +b3c955e808e8d11cdbb6f716a038f26ccdd4b69228ad0c4ce76fd81e98496d56 diff --git a/src/channels/plugins/catalog.test.ts b/src/channels/plugins/catalog.test.ts index 2470dbd33..a50aa2b36 100644 --- a/src/channels/plugins/catalog.test.ts +++ b/src/channels/plugins/catalog.test.ts @@ -8,7 +8,7 @@ import { getChannelPluginCatalogEntry, listChannelPluginCatalogEntries } from ". describe("channel plugin catalog", () => { it("includes Microsoft Teams", () => { const entry = getChannelPluginCatalogEntry("msteams"); - expect(entry?.install.npmSpec).toBe("@clawdbot/msteams"); + expect(entry?.install.npmSpec).toBe("@moltbot/msteams"); expect(entry?.meta.aliases).toContain("teams"); }); diff --git a/src/channels/plugins/onboarding/telegram.ts b/src/channels/plugins/onboarding/telegram.ts index fdbc044c5..90920ab40 100644 --- a/src/channels/plugins/onboarding/telegram.ts +++ b/src/channels/plugins/onboarding/telegram.ts @@ -38,7 +38,7 @@ async function noteTelegramTokenHelp(prompter: WizardPrompter): Promise { "3) Copy the token (looks like 123456:ABC...)", "Tip: you can also set TELEGRAM_BOT_TOKEN in your env.", `Docs: ${formatDocsLink("/telegram")}`, - "Website: https://clawd.bot", + "Website: https://molt.bot", ].join("\n"), "Telegram bot token", ); @@ -51,7 +51,7 @@ async function noteTelegramUserIdHelp(prompter: WizardPrompter): Promise { "2) Or call https://api.telegram.org/bot/getUpdates and read message.from.id", "3) Third-party: DM @userinfobot or @getidsbot", `Docs: ${formatDocsLink("/telegram")}`, - "Website: https://clawd.bot", + "Website: https://molt.bot", ].join("\n"), "Telegram user id", ); diff --git a/src/channels/registry.test.ts b/src/channels/registry.test.ts index 84940aa42..44b53ef6d 100644 --- a/src/channels/registry.test.ts +++ b/src/channels/registry.test.ts @@ -33,6 +33,6 @@ describe("channel registry", () => { ); expect(line).not.toContain("Docs:"); expect(line).toContain("/channels/telegram"); - expect(line).toContain("https://clawd.bot"); + expect(line).toContain("https://molt.bot"); }); }); diff --git a/src/channels/registry.ts b/src/channels/registry.ts index 10ddeed4a..6afe1996c 100644 --- a/src/channels/registry.ts +++ b/src/channels/registry.ts @@ -22,7 +22,7 @@ export const DEFAULT_CHAT_CHANNEL: ChatChannelId = "whatsapp"; export type ChatChannelMeta = ChannelMeta; -const WEBSITE_URL = "https://clawd.bot"; +const WEBSITE_URL = "https://molt.bot"; const CHAT_CHANNEL_META: Record = { telegram: { diff --git a/src/cli/acp-cli.ts b/src/cli/acp-cli.ts index f2283d23d..8669d77fa 100644 --- a/src/cli/acp-cli.ts +++ b/src/cli/acp-cli.ts @@ -21,7 +21,7 @@ export function registerAcpCli(program: Command) { .option("--verbose, -v", "Verbose logging to stderr", false) .addHelpText( "after", - () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/acp", "docs.clawd.bot/cli/acp")}\n`, + () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/acp", "docs.molt.bot/cli/acp")}\n`, ) .action((opts) => { try { @@ -46,7 +46,7 @@ export function registerAcpCli(program: Command) { .command("client") .description("Run an interactive ACP client against the local ACP bridge") .option("--cwd ", "Working directory for the ACP session") - .option("--server ", "ACP server command (default: clawdbot)") + .option("--server ", "ACP server command (default: moltbot)") .option("--server-args ", "Extra arguments for the ACP server") .option("--server-verbose", "Enable verbose logging on the ACP server", false) .option("--verbose, -v", "Verbose client logging", false) diff --git a/src/cli/banner.ts b/src/cli/banner.ts index 7a811f56e..87803c9c7 100644 --- a/src/cli/banner.ts +++ b/src/cli/banner.ts @@ -2,6 +2,7 @@ import { resolveCommitHash } from "../infra/git-commit.js"; import { visibleWidth } from "../terminal/ansi.js"; import { isRich, theme } from "../terminal/theme.js"; import { pickTagline, type TaglineOptions } from "./tagline.js"; +import { resolveCliName } from "./cli-name.js"; type BannerOptions = TaglineOptions & { argv?: string[]; @@ -37,7 +38,8 @@ export function formatCliBannerLine(version: string, options: BannerOptions = {} const commitLabel = commit ?? "unknown"; const tagline = pickTagline(options); const rich = options.richTty ?? isRich(); - const title = "🦞 Clawdbot"; + const cliName = resolveCliName(options.argv ?? process.argv, options.env); + const title = cliName === "clawdbot" ? "🦞 Clawdbot" : "🦞 Moltbot"; const prefix = "🦞 "; const columns = options.columns ?? process.stdout.columns ?? 120; const plainFullLine = `${title} ${version} (${commitLabel}) — ${tagline}`; diff --git a/src/cli/browser-cli-extension.ts b/src/cli/browser-cli-extension.ts index 3bd7c5b3a..6775216e6 100644 --- a/src/cli/browser-cli-extension.ts +++ b/src/cli/browser-cli-extension.ts @@ -90,7 +90,7 @@ export function registerBrowserExtensionCommands( `- “Load unpacked” → select: ${displayPath}`, `- Pin “Clawdbot Browser Relay”, then click it on the tab (badge shows ON)`, "", - `${theme.muted("Docs:")} ${formatDocsLink("/tools/chrome-extension", "docs.clawd.bot/tools/chrome-extension")}`, + `${theme.muted("Docs:")} ${formatDocsLink("/tools/chrome-extension", "docs.molt.bot/tools/chrome-extension")}`, ].join("\n"), ), ); @@ -107,7 +107,7 @@ export function registerBrowserExtensionCommands( danger( [ `Chrome extension is not installed. Run: "${formatCliCommand("clawdbot browser extension install")}"`, - `Docs: ${formatDocsLink("/tools/chrome-extension", "docs.clawd.bot/tools/chrome-extension")}`, + `Docs: ${formatDocsLink("/tools/chrome-extension", "docs.molt.bot/tools/chrome-extension")}`, ].join("\n"), ), ); diff --git a/src/cli/browser-cli.ts b/src/cli/browser-cli.ts index 50c71ef01..cda4d4275 100644 --- a/src/cli/browser-cli.ts +++ b/src/cli/browser-cli.ts @@ -31,7 +31,7 @@ export function registerBrowserCli(program: Command) { true, )}\n\n${theme.muted("Docs:")} ${formatDocsLink( "/cli/browser", - "docs.clawd.bot/cli/browser", + "docs.molt.bot/cli/browser", )}\n`, ) .action(() => { diff --git a/src/cli/channels-cli.ts b/src/cli/channels-cli.ts index 97fbee520..6d90ae935 100644 --- a/src/cli/channels-cli.ts +++ b/src/cli/channels-cli.ts @@ -76,7 +76,7 @@ export function registerChannelsCli(program: Command) { () => `\n${theme.muted("Docs:")} ${formatDocsLink( "/cli/channels", - "docs.clawd.bot/cli/channels", + "docs.molt.bot/cli/channels", )}\n`, ); diff --git a/src/cli/command-format.ts b/src/cli/command-format.ts index 9e5eef160..e62806cd4 100644 --- a/src/cli/command-format.ts +++ b/src/cli/command-format.ts @@ -1,6 +1,7 @@ import { normalizeProfileName } from "./profile-utils.js"; +import { replaceCliName, resolveCliName } from "./cli-name.js"; -const CLI_PREFIX_RE = /^(?:pnpm|npm|bunx|npx)\s+clawdbot\b|^clawdbot\b/; +const CLI_PREFIX_RE = /^(?:pnpm|npm|bunx|npx)\s+(?:clawdbot|moltbot)\b|^(?:clawdbot|moltbot)\b/; const PROFILE_FLAG_RE = /(?:^|\s)--profile(?:\s|=|$)/; const DEV_FLAG_RE = /(?:^|\s)--dev(?:\s|$)/; @@ -8,9 +9,13 @@ export function formatCliCommand( command: string, env: Record = process.env as Record, ): string { + const cliName = resolveCliName(undefined, env); + const normalizedCommand = replaceCliName(command, cliName); const profile = normalizeProfileName(env.CLAWDBOT_PROFILE); - if (!profile) return command; - if (!CLI_PREFIX_RE.test(command)) return command; - if (PROFILE_FLAG_RE.test(command) || DEV_FLAG_RE.test(command)) return command; - return command.replace(CLI_PREFIX_RE, (match) => `${match} --profile ${profile}`); + if (!profile) return normalizedCommand; + if (!CLI_PREFIX_RE.test(normalizedCommand)) return normalizedCommand; + if (PROFILE_FLAG_RE.test(normalizedCommand) || DEV_FLAG_RE.test(normalizedCommand)) { + return normalizedCommand; + } + return normalizedCommand.replace(CLI_PREFIX_RE, (match) => `${match} --profile ${profile}`); } diff --git a/src/cli/config-cli.ts b/src/cli/config-cli.ts index 605482251..80550599d 100644 --- a/src/cli/config-cli.ts +++ b/src/cli/config-cli.ts @@ -185,7 +185,7 @@ export function registerConfigCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/config", "docs.clawd.bot/cli/config")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/config", "docs.molt.bot/cli/config")}\n`, ) .option( "--section
    ", diff --git a/src/cli/cron-cli/register.ts b/src/cli/cron-cli/register.ts index 7989e08fb..aa115f1fa 100644 --- a/src/cli/cron-cli/register.ts +++ b/src/cli/cron-cli/register.ts @@ -15,7 +15,7 @@ export function registerCronCli(program: Command) { .description("Manage cron jobs (via Gateway)") .addHelpText( "after", - () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/cron", "docs.clawd.bot/cli/cron")}\n`, + () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/cron", "docs.molt.bot/cli/cron")}\n`, ); registerCronStatusCommand(cron); diff --git a/src/cli/daemon-cli/register.ts b/src/cli/daemon-cli/register.ts index 92b47690d..8c180c732 100644 --- a/src/cli/daemon-cli/register.ts +++ b/src/cli/daemon-cli/register.ts @@ -18,7 +18,7 @@ export function registerDaemonCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/gateway", "docs.clawd.bot/cli/gateway")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/gateway", "docs.molt.bot/cli/gateway")}\n`, ); daemon diff --git a/src/cli/daemon-cli/status.print.ts b/src/cli/daemon-cli/status.print.ts index 801980d24..dc34e00e6 100644 --- a/src/cli/daemon-cli/status.print.ts +++ b/src/cli/daemon-cli/status.print.ts @@ -322,5 +322,5 @@ export function printDaemonStatus(status: DaemonStatus, opts: { json: boolean }) } defaultRuntime.log(`${label("Troubles:")} run ${formatCliCommand("clawdbot status")}`); - defaultRuntime.log(`${label("Troubleshooting:")} https://docs.clawd.bot/troubleshooting`); + defaultRuntime.log(`${label("Troubleshooting:")} https://docs.molt.bot/troubleshooting`); } diff --git a/src/cli/directory-cli.ts b/src/cli/directory-cli.ts index d58663d8a..51fdd6049 100644 --- a/src/cli/directory-cli.ts +++ b/src/cli/directory-cli.ts @@ -39,7 +39,7 @@ export function registerDirectoryCli(program: Command) { () => `\n${theme.muted("Docs:")} ${formatDocsLink( "/cli/directory", - "docs.clawd.bot/cli/directory", + "docs.molt.bot/cli/directory", )}\n`, ) .action(() => { diff --git a/src/cli/dns-cli.ts b/src/cli/dns-cli.ts index 7798415e8..c063163a5 100644 --- a/src/cli/dns-cli.ts +++ b/src/cli/dns-cli.ts @@ -97,7 +97,7 @@ export function registerDnsCli(program: Command) { .description("DNS helpers for wide-area discovery (Tailscale + CoreDNS)") .addHelpText( "after", - () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/dns", "docs.clawd.bot/cli/dns")}\n`, + () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/dns", "docs.molt.bot/cli/dns")}\n`, ); dns diff --git a/src/cli/docs-cli.ts b/src/cli/docs-cli.ts index 8078b8afe..0bcbe3bac 100644 --- a/src/cli/docs-cli.ts +++ b/src/cli/docs-cli.ts @@ -13,7 +13,7 @@ export function registerDocsCli(program: Command) { .argument("[query...]", "Search query") .addHelpText( "after", - () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/docs", "docs.clawd.bot/cli/docs")}\n`, + () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/docs", "docs.molt.bot/cli/docs")}\n`, ) .action(async (queryParts: string[]) => { await runCommandWithRuntime(defaultRuntime, async () => { diff --git a/src/cli/exec-approvals-cli.ts b/src/cli/exec-approvals-cli.ts index f59b5475b..8b420db50 100644 --- a/src/cli/exec-approvals-cli.ts +++ b/src/cli/exec-approvals-cli.ts @@ -233,7 +233,7 @@ export function registerExecApprovalsCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/approvals", "docs.clawd.bot/cli/approvals")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/approvals", "docs.molt.bot/cli/approvals")}\n`, ); const getCmd = approvals @@ -337,7 +337,7 @@ export function registerExecApprovalsCli(program: Command) { )}\n${formatExample( 'clawdbot approvals allowlist remove "~/Projects/**/bin/rg"', "Remove an allowlist pattern.", - )}\n\n${theme.muted("Docs:")} ${formatDocsLink("/cli/approvals", "docs.clawd.bot/cli/approvals")}\n`, + )}\n\n${theme.muted("Docs:")} ${formatDocsLink("/cli/approvals", "docs.molt.bot/cli/approvals")}\n`, ); const allowlistAdd = allowlist diff --git a/src/cli/gateway-cli/register.ts b/src/cli/gateway-cli/register.ts index 8334cc6f7..eec58dd58 100644 --- a/src/cli/gateway-cli/register.ts +++ b/src/cli/gateway-cli/register.ts @@ -103,7 +103,7 @@ export function registerGatewayCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/gateway", "docs.clawd.bot/cli/gateway")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/gateway", "docs.molt.bot/cli/gateway")}\n`, ), ); diff --git a/src/cli/hooks-cli.test.ts b/src/cli/hooks-cli.test.ts index edbaf797d..6a4ee37fc 100644 --- a/src/cli/hooks-cli.test.ts +++ b/src/cli/hooks-cli.test.ts @@ -16,7 +16,7 @@ const report: HookStatusReport = { handlerPath: "/tmp/hooks/session-memory/handler.js", hookKey: "session-memory", emoji: "💾", - homepage: "https://docs.clawd.bot/hooks#session-memory", + homepage: "https://docs.molt.bot/hooks#session-memory", events: ["command:new"], always: false, disabled: false, diff --git a/src/cli/hooks-cli.ts b/src/cli/hooks-cli.ts index 022c7c295..a0eab75f5 100644 --- a/src/cli/hooks-cli.ts +++ b/src/cli/hooks-cli.ts @@ -424,7 +424,7 @@ export function registerHooksCli(program: Command): void { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/hooks", "docs.clawd.bot/cli/hooks")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/hooks", "docs.molt.bot/cli/hooks")}\n`, ); hooks diff --git a/src/cli/logs-cli.ts b/src/cli/logs-cli.ts index e5af23af8..8fcd8fffa 100644 --- a/src/cli/logs-cli.ts +++ b/src/cli/logs-cli.ts @@ -180,7 +180,7 @@ export function registerLogsCli(program: Command) { .option("--no-color", "Disable ANSI colors") .addHelpText( "after", - () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/logs", "docs.clawd.bot/cli/logs")}\n`, + () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/logs", "docs.molt.bot/cli/logs")}\n`, ); addGatewayClientOptions(logs); diff --git a/src/cli/memory-cli.ts b/src/cli/memory-cli.ts index a184fa1b4..68894adf5 100644 --- a/src/cli/memory-cli.ts +++ b/src/cli/memory-cli.ts @@ -424,7 +424,7 @@ export function registerMemoryCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/memory", "docs.clawd.bot/cli/memory")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/memory", "docs.molt.bot/cli/memory")}\n`, ); memory diff --git a/src/cli/models-cli.ts b/src/cli/models-cli.ts index d914629e7..f68631d18 100644 --- a/src/cli/models-cli.ts +++ b/src/cli/models-cli.ts @@ -44,7 +44,7 @@ export function registerModelsCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/models", "docs.clawd.bot/cli/models")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/models", "docs.molt.bot/cli/models")}\n`, ); models diff --git a/src/cli/node-cli/register.ts b/src/cli/node-cli/register.ts index 8712c6a44..8f5c5b5ad 100644 --- a/src/cli/node-cli/register.ts +++ b/src/cli/node-cli/register.ts @@ -23,7 +23,7 @@ export function registerNodeCli(program: Command) { .description("Run a headless node host (system.run/system.which)") .addHelpText( "after", - () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/node", "docs.clawd.bot/cli/node")}\n`, + () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/node", "docs.molt.bot/cli/node")}\n`, ); node diff --git a/src/cli/nodes-camera.test.ts b/src/cli/nodes-camera.test.ts index a024b535a..55d62cf06 100644 --- a/src/cli/nodes-camera.test.ts +++ b/src/cli/nodes-camera.test.ts @@ -51,11 +51,11 @@ describe("nodes camera helpers", () => { tmpDir: "/tmp", id: "id1", }); - expect(p).toBe(path.join("/tmp", "clawdbot-camera-snap-front-id1.jpg")); + expect(p).toBe(path.join("/tmp", "moltbot-camera-snap-front-id1.jpg")); }); it("writes base64 to file", async () => { - const dir = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-test-")); + const dir = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-test-")); const out = path.join(dir, "x.bin"); await writeBase64ToFile(out, "aGk="); await expect(fs.readFile(out, "utf8")).resolves.toBe("hi"); diff --git a/src/cli/nodes-camera.ts b/src/cli/nodes-camera.ts index d91053e76..f5bf2f2ea 100644 --- a/src/cli/nodes-camera.ts +++ b/src/cli/nodes-camera.ts @@ -3,6 +3,8 @@ import * as fs from "node:fs/promises"; import * as os from "node:os"; import * as path from "node:path"; +import { resolveCliName } from "./cli-name.js"; + export type CameraFacing = "front" | "back"; export type CameraSnapPayload = { @@ -70,7 +72,8 @@ export function cameraTempPath(opts: { const id = opts.id ?? randomUUID(); const facingPart = opts.facing ? `-${opts.facing}` : ""; const ext = opts.ext.startsWith(".") ? opts.ext : `.${opts.ext}`; - return path.join(tmpDir, `clawdbot-camera-${opts.kind}${facingPart}-${id}${ext}`); + const cliName = resolveCliName(); + return path.join(tmpDir, `${cliName}-camera-${opts.kind}${facingPart}-${id}${ext}`); } export async function writeBase64ToFile(filePath: string, base64: string) { diff --git a/src/cli/nodes-canvas.ts b/src/cli/nodes-canvas.ts index b021ef22f..577c20560 100644 --- a/src/cli/nodes-canvas.ts +++ b/src/cli/nodes-canvas.ts @@ -2,6 +2,8 @@ import { randomUUID } from "node:crypto"; import * as os from "node:os"; import * as path from "node:path"; +import { resolveCliName } from "./cli-name.js"; + export type CanvasSnapshotPayload = { format: string; base64: string; @@ -29,5 +31,6 @@ export function canvasSnapshotTempPath(opts: { ext: string; tmpDir?: string; id? const tmpDir = opts.tmpDir ?? os.tmpdir(); const id = opts.id ?? randomUUID(); const ext = opts.ext.startsWith(".") ? opts.ext : `.${opts.ext}`; - return path.join(tmpDir, `clawdbot-canvas-snapshot-${id}${ext}`); + const cliName = resolveCliName(); + return path.join(tmpDir, `${cliName}-canvas-snapshot-${id}${ext}`); } diff --git a/src/cli/nodes-cli/register.ts b/src/cli/nodes-cli/register.ts index 20dd61902..501b28103 100644 --- a/src/cli/nodes-cli/register.ts +++ b/src/cli/nodes-cli/register.ts @@ -17,7 +17,7 @@ export function registerNodesCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/nodes", "docs.clawd.bot/cli/nodes")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/nodes", "docs.molt.bot/cli/nodes")}\n`, ); registerNodesStatusCommands(nodes); diff --git a/src/cli/pairing-cli.ts b/src/cli/pairing-cli.ts index 4d405bff5..a5d0ae137 100644 --- a/src/cli/pairing-cli.ts +++ b/src/cli/pairing-cli.ts @@ -53,7 +53,7 @@ export function registerPairingCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/pairing", "docs.clawd.bot/cli/pairing")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/pairing", "docs.molt.bot/cli/pairing")}\n`, ); pairing diff --git a/src/cli/plugins-cli.ts b/src/cli/plugins-cli.ts index 303231bdb..57709e04a 100644 --- a/src/cli/plugins-cli.ts +++ b/src/cli/plugins-cli.ts @@ -98,7 +98,7 @@ export function registerPluginsCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/plugins", "docs.clawd.bot/cli/plugins")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/plugins", "docs.molt.bot/cli/plugins")}\n`, ); plugins @@ -521,7 +521,7 @@ export function registerPluginsCli(program: Command) { lines.push(`- ${target}${diag.message}`); } } - const docs = formatDocsLink("/plugin", "docs.clawd.bot/plugin"); + const docs = formatDocsLink("/plugin", "docs.molt.bot/plugin"); lines.push(""); lines.push(`${theme.muted("Docs:")} ${docs}`); defaultRuntime.log(lines.join("\n")); diff --git a/src/cli/profile.test.ts b/src/cli/profile.test.ts index 0470bcf2c..f17e56214 100644 --- a/src/cli/profile.test.ts +++ b/src/cli/profile.test.ts @@ -80,60 +80,60 @@ describe("applyCliProfileEnv", () => { describe("formatCliCommand", () => { it("returns command unchanged when no profile is set", () => { - expect(formatCliCommand("clawdbot doctor --fix", {})).toBe("clawdbot doctor --fix"); + expect(formatCliCommand("clawdbot doctor --fix", {})).toBe("moltbot doctor --fix"); }); it("returns command unchanged when profile is default", () => { expect(formatCliCommand("clawdbot doctor --fix", { CLAWDBOT_PROFILE: "default" })).toBe( - "clawdbot doctor --fix", + "moltbot doctor --fix", ); }); it("returns command unchanged when profile is Default (case-insensitive)", () => { expect(formatCliCommand("clawdbot doctor --fix", { CLAWDBOT_PROFILE: "Default" })).toBe( - "clawdbot doctor --fix", + "moltbot doctor --fix", ); }); it("returns command unchanged when profile is invalid", () => { expect(formatCliCommand("clawdbot doctor --fix", { CLAWDBOT_PROFILE: "bad profile" })).toBe( - "clawdbot doctor --fix", + "moltbot doctor --fix", ); }); it("returns command unchanged when --profile is already present", () => { expect( formatCliCommand("clawdbot --profile work doctor --fix", { CLAWDBOT_PROFILE: "work" }), - ).toBe("clawdbot --profile work doctor --fix"); + ).toBe("moltbot --profile work doctor --fix"); }); it("returns command unchanged when --dev is already present", () => { expect(formatCliCommand("clawdbot --dev doctor", { CLAWDBOT_PROFILE: "dev" })).toBe( - "clawdbot --dev doctor", + "moltbot --dev doctor", ); }); it("inserts --profile flag when profile is set", () => { expect(formatCliCommand("clawdbot doctor --fix", { CLAWDBOT_PROFILE: "work" })).toBe( - "clawdbot --profile work doctor --fix", + "moltbot --profile work doctor --fix", ); }); it("trims whitespace from profile", () => { expect(formatCliCommand("clawdbot doctor --fix", { CLAWDBOT_PROFILE: " jbclawd " })).toBe( - "clawdbot --profile jbclawd doctor --fix", + "moltbot --profile jbclawd doctor --fix", ); }); it("handles command with no args after clawdbot", () => { expect(formatCliCommand("clawdbot", { CLAWDBOT_PROFILE: "test" })).toBe( - "clawdbot --profile test", + "moltbot --profile test", ); }); it("handles pnpm wrapper", () => { expect(formatCliCommand("pnpm clawdbot doctor", { CLAWDBOT_PROFILE: "work" })).toBe( - "pnpm clawdbot --profile work doctor", + "pnpm moltbot --profile work doctor", ); }); }); diff --git a/src/cli/program.nodes-media.test.ts b/src/cli/program.nodes-media.test.ts index 60513b8e1..3132a98b9 100644 --- a/src/cli/program.nodes-media.test.ts +++ b/src/cli/program.nodes-media.test.ts @@ -174,7 +174,7 @@ describe("cli program (nodes media)", () => { const out = String(runtime.log.mock.calls[0]?.[0] ?? ""); const mediaPath = out.replace(/^MEDIA:/, "").trim(); - expect(mediaPath).toMatch(/clawdbot-camera-clip-front-.*\.mp4$/); + expect(mediaPath).toMatch(/moltbot-camera-clip-front-.*\.mp4$/); try { await expect(fs.readFile(mediaPath, "utf8")).resolves.toBe("hi"); @@ -421,7 +421,7 @@ describe("cli program (nodes media)", () => { const out = String(runtime.log.mock.calls[0]?.[0] ?? ""); const mediaPath = out.replace(/^MEDIA:/, "").trim(); - expect(mediaPath).toMatch(/clawdbot-canvas-snapshot-.*\.png$/); + expect(mediaPath).toMatch(/moltbot-canvas-snapshot-.*\.png$/); try { await expect(fs.readFile(mediaPath, "utf8")).resolves.toBe("hi"); diff --git a/src/cli/program/help.ts b/src/cli/program/help.ts index c90f9eb96..9ad704c16 100644 --- a/src/cli/program/help.ts +++ b/src/cli/program/help.ts @@ -2,8 +2,11 @@ import type { Command } from "commander"; import { formatDocsLink } from "../../terminal/links.js"; import { isRich, theme } from "../../terminal/theme.js"; import { formatCliBannerLine, hasEmittedCliBanner } from "../banner.js"; +import { replaceCliName, resolveCliName } from "../cli-name.js"; import type { ProgramContext } from "./context.js"; +const CLI_NAME = resolveCliName(); + const EXAMPLES = [ [ "clawdbot channels login --verbose", @@ -29,7 +32,7 @@ const EXAMPLES = [ export function configureProgramHelp(program: Command, ctx: ProgramContext) { program - .name("clawdbot") + .name(CLI_NAME) .description("") .version(ctx.programVersion) .option( @@ -77,12 +80,12 @@ export function configureProgramHelp(program: Command, ctx: ProgramContext) { }); const fmtExamples = EXAMPLES.map( - ([cmd, desc]) => ` ${theme.command(cmd)}\n ${theme.muted(desc)}`, + ([cmd, desc]) => ` ${theme.command(replaceCliName(cmd, CLI_NAME))}\n ${theme.muted(desc)}`, ).join("\n"); program.addHelpText("afterAll", ({ command }) => { if (command !== program) return ""; - const docs = formatDocsLink("/cli", "docs.clawd.bot/cli"); + const docs = formatDocsLink("/cli", "docs.molt.bot/cli"); return `\n${theme.heading("Examples:")}\n${fmtExamples}\n\n${theme.muted("Docs:")} ${docs}\n`; }); } diff --git a/src/cli/program/preaction.ts b/src/cli/program/preaction.ts index 1607e0634..acdcde387 100644 --- a/src/cli/program/preaction.ts +++ b/src/cli/program/preaction.ts @@ -6,6 +6,7 @@ import { ensureConfigReady } from "./config-guard.js"; import { ensurePluginRegistryLoaded } from "../plugin-registry.js"; import { isTruthyEnvValue } from "../../infra/env.js"; import { setVerbose } from "../../globals.js"; +import { resolveCliName } from "../cli-name.js"; function setProcessTitleForCommand(actionCommand: Command) { let current: Command = actionCommand; @@ -13,8 +14,9 @@ function setProcessTitleForCommand(actionCommand: Command) { current = current.parent; } const name = current.name(); - if (!name || name === "clawdbot") return; - process.title = `clawdbot-${name}`; + const cliName = resolveCliName(); + if (!name || name === cliName) return; + process.title = `${cliName}-${name}`; } // Commands that need channel plugins loaded diff --git a/src/cli/program/register.agent.ts b/src/cli/program/register.agent.ts index d597efde9..80eb9a35f 100644 --- a/src/cli/program/register.agent.ts +++ b/src/cli/program/register.agent.ts @@ -68,7 +68,7 @@ ${formatHelpExamples([ ], ])} -${theme.muted("Docs:")} ${formatDocsLink("/cli/agent", "docs.clawd.bot/cli/agent")}`, +${theme.muted("Docs:")} ${formatDocsLink("/cli/agent", "docs.molt.bot/cli/agent")}`, ) .action(async (opts) => { const verboseLevel = typeof opts.verbose === "string" ? opts.verbose.toLowerCase() : ""; @@ -86,7 +86,7 @@ ${theme.muted("Docs:")} ${formatDocsLink("/cli/agent", "docs.clawd.bot/cli/agent .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/agents", "docs.clawd.bot/cli/agents")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/agents", "docs.molt.bot/cli/agents")}\n`, ); agents diff --git a/src/cli/program/register.configure.ts b/src/cli/program/register.configure.ts index a10805e88..55bec5209 100644 --- a/src/cli/program/register.configure.ts +++ b/src/cli/program/register.configure.ts @@ -16,7 +16,7 @@ export function registerConfigureCommand(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/configure", "docs.clawd.bot/cli/configure")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/configure", "docs.molt.bot/cli/configure")}\n`, ) .option( "--section
    ", diff --git a/src/cli/program/register.maintenance.ts b/src/cli/program/register.maintenance.ts index 023965c5c..efb8b7851 100644 --- a/src/cli/program/register.maintenance.ts +++ b/src/cli/program/register.maintenance.ts @@ -15,7 +15,7 @@ export function registerMaintenanceCommands(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/doctor", "docs.clawd.bot/cli/doctor")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/doctor", "docs.molt.bot/cli/doctor")}\n`, ) .option("--no-workspace-suggestions", "Disable workspace memory system suggestions", false) .option("--yes", "Accept defaults without prompting", false) @@ -45,7 +45,7 @@ export function registerMaintenanceCommands(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/dashboard", "docs.clawd.bot/cli/dashboard")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/dashboard", "docs.molt.bot/cli/dashboard")}\n`, ) .option("--no-open", "Print URL but do not launch a browser", false) .action(async (opts) => { @@ -62,7 +62,7 @@ export function registerMaintenanceCommands(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/reset", "docs.clawd.bot/cli/reset")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/reset", "docs.molt.bot/cli/reset")}\n`, ) .option("--scope ", "config|config+creds+sessions|full (default: interactive prompt)") .option("--yes", "Skip confirmation prompts", false) @@ -85,7 +85,7 @@ export function registerMaintenanceCommands(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/uninstall", "docs.clawd.bot/cli/uninstall")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/uninstall", "docs.molt.bot/cli/uninstall")}\n`, ) .option("--service", "Remove the gateway service", false) .option("--state", "Remove state + config", false) diff --git a/src/cli/program/register.message.ts b/src/cli/program/register.message.ts index 24af5f37f..b9fa22a47 100644 --- a/src/cli/program/register.message.ts +++ b/src/cli/program/register.message.ts @@ -46,7 +46,7 @@ ${formatHelpExamples([ ], ])} -${theme.muted("Docs:")} ${formatDocsLink("/cli/message", "docs.clawd.bot/cli/message")}`, +${theme.muted("Docs:")} ${formatDocsLink("/cli/message", "docs.molt.bot/cli/message")}`, ) .action(() => { message.help({ error: true }); diff --git a/src/cli/program/register.onboard.ts b/src/cli/program/register.onboard.ts index eac6a60df..8f31635f0 100644 --- a/src/cli/program/register.onboard.ts +++ b/src/cli/program/register.onboard.ts @@ -38,7 +38,7 @@ export function registerOnboardCommand(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/onboard", "docs.clawd.bot/cli/onboard")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/onboard", "docs.molt.bot/cli/onboard")}\n`, ) .option("--workspace ", "Agent workspace directory (default: ~/clawd)") .option("--reset", "Reset config + credentials + sessions + workspace before running wizard") diff --git a/src/cli/program/register.setup.ts b/src/cli/program/register.setup.ts index aa79a5dda..ad36a70e5 100644 --- a/src/cli/program/register.setup.ts +++ b/src/cli/program/register.setup.ts @@ -14,7 +14,7 @@ export function registerSetupCommand(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/setup", "docs.clawd.bot/cli/setup")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/setup", "docs.molt.bot/cli/setup")}\n`, ) .option( "--workspace ", diff --git a/src/cli/program/register.status-health-sessions.ts b/src/cli/program/register.status-health-sessions.ts index 66d0c4abb..42913588f 100644 --- a/src/cli/program/register.status-health-sessions.ts +++ b/src/cli/program/register.status-health-sessions.ts @@ -53,7 +53,7 @@ export function registerStatusHealthSessionsCommands(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/status", "docs.clawd.bot/cli/status")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/status", "docs.molt.bot/cli/status")}\n`, ) .action(async (opts) => { const verbose = resolveVerbose(opts); @@ -87,7 +87,7 @@ export function registerStatusHealthSessionsCommands(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/health", "docs.clawd.bot/cli/health")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/health", "docs.molt.bot/cli/health")}\n`, ) .action(async (opts) => { const verbose = resolveVerbose(opts); @@ -130,7 +130,7 @@ export function registerStatusHealthSessionsCommands(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/sessions", "docs.clawd.bot/cli/sessions")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/sessions", "docs.molt.bot/cli/sessions")}\n`, ) .action(async (opts) => { setVerbose(Boolean(opts.verbose)); diff --git a/src/cli/sandbox-cli.ts b/src/cli/sandbox-cli.ts index 746566f82..bcf9df54a 100644 --- a/src/cli/sandbox-cli.ts +++ b/src/cli/sandbox-cli.ts @@ -68,7 +68,7 @@ export function registerSandboxCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/sandbox", "docs.clawd.bot/cli/sandbox")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/sandbox", "docs.molt.bot/cli/sandbox")}\n`, ) .action(() => { sandbox.help({ error: true }); diff --git a/src/cli/security-cli.ts b/src/cli/security-cli.ts index 2bd5a36b7..7a72ad6da 100644 --- a/src/cli/security-cli.ts +++ b/src/cli/security-cli.ts @@ -34,7 +34,7 @@ export function registerSecurityCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/security", "docs.clawd.bot/cli/security")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/security", "docs.molt.bot/cli/security")}\n`, ); security diff --git a/src/cli/skills-cli.ts b/src/cli/skills-cli.ts index 7488aee83..520b1a5c0 100644 --- a/src/cli/skills-cli.ts +++ b/src/cli/skills-cli.ts @@ -337,7 +337,7 @@ export function registerSkillsCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/skills", "docs.clawd.bot/cli/skills")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/skills", "docs.molt.bot/cli/skills")}\n`, ); skills diff --git a/src/cli/system-cli.ts b/src/cli/system-cli.ts index 4162c16de..9ade7aa15 100644 --- a/src/cli/system-cli.ts +++ b/src/cli/system-cli.ts @@ -23,7 +23,7 @@ export function registerSystemCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/system", "docs.clawd.bot/cli/system")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/system", "docs.molt.bot/cli/system")}\n`, ); addGatewayClientOptions( diff --git a/src/cli/tui-cli.ts b/src/cli/tui-cli.ts index 3fbf6bc86..795642410 100644 --- a/src/cli/tui-cli.ts +++ b/src/cli/tui-cli.ts @@ -20,7 +20,7 @@ export function registerTuiCli(program: Command) { .option("--history-limit ", "History entries to load", "200") .addHelpText( "after", - () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/tui", "docs.clawd.bot/cli/tui")}\n`, + () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/tui", "docs.molt.bot/cli/tui")}\n`, ) .action(async (opts) => { try { diff --git a/src/cli/update-cli.ts b/src/cli/update-cli.ts index 9e597e485..c80878f90 100644 --- a/src/cli/update-cli.ts +++ b/src/cli/update-cli.ts @@ -39,6 +39,7 @@ import { trimLogTail } from "../infra/restart-sentinel.js"; import { defaultRuntime } from "../runtime.js"; import { formatDocsLink } from "../terminal/links.js"; import { formatCliCommand } from "./command-format.js"; +import { replaceCliName, resolveCliName } from "./cli-name.js"; import { stylePromptHint, stylePromptMessage } from "../terminal/prompt-style.js"; import { theme } from "../terminal/theme.js"; import { renderTable } from "../terminal/table.js"; @@ -81,6 +82,7 @@ const STEP_LABELS: Record = { build: "Building", "ui:build": "Building UI", "clawdbot doctor": "Running doctor checks", + "moltbot doctor": "Running doctor checks", "git rev-parse HEAD (after)": "Verifying update", "global update": "Updating via package manager", "global install": "Installing global package", @@ -110,6 +112,9 @@ const UPDATE_QUIPS = [ ]; const MAX_LOG_CHARS = 8000; +const DEFAULT_PACKAGE_NAME = "moltbot"; +const CORE_PACKAGE_NAMES = new Set([DEFAULT_PACKAGE_NAME, "clawdbot"]); +const CLI_NAME = resolveCliName(); const CLAWDBOT_REPO_URL = "https://github.com/clawdbot/clawdbot.git"; const DEFAULT_GIT_DIR = path.join(os.homedir(), "clawdbot"); @@ -117,7 +122,11 @@ function normalizeTag(value?: string | null): string | null { if (!value) return null; const trimmed = value.trim(); if (!trimmed) return null; - return trimmed.startsWith("clawdbot@") ? trimmed.slice("clawdbot@".length) : trimmed; + if (trimmed.startsWith("clawdbot@")) return trimmed.slice("clawdbot@".length); + if (trimmed.startsWith(`${DEFAULT_PACKAGE_NAME}@`)) { + return trimmed.slice(`${DEFAULT_PACKAGE_NAME}@`.length); + } + return trimmed; } function pickUpdateQuip(): string { @@ -157,16 +166,22 @@ async function isGitCheckout(root: string): Promise { } } -async function isClawdbotPackage(root: string): Promise { +async function readPackageName(root: string): Promise { try { const raw = await fs.readFile(path.join(root, "package.json"), "utf-8"); const parsed = JSON.parse(raw) as { name?: string }; - return parsed?.name === "clawdbot"; + const name = parsed?.name?.trim(); + return name ? name : null; } catch { - return false; + return null; } } +async function isCorePackage(root: string): Promise { + const name = await readPackageName(root); + return Boolean(name && CORE_PACKAGE_NAMES.has(name)); +} + async function pathExists(targetPath: string): Promise { try { await fs.stat(targetPath); @@ -269,8 +284,8 @@ async function ensureGitCheckout(params: { }); } - if (!(await isClawdbotPackage(params.dir))) { - throw new Error(`CLAWDBOT_GIT_DIR does not look like a clawdbot checkout: ${params.dir}.`); + if (!(await isCorePackage(params.dir))) { + throw new Error(`CLAWDBOT_GIT_DIR does not look like a core checkout: ${params.dir}.`); } return null; @@ -691,10 +706,13 @@ export async function updateCommand(opts: UpdateCommandOptions): Promise { return { stdout: res.stdout, stderr: res.stderr, code: res.code }; }; const pkgRoot = await resolveGlobalPackageRoot(manager, runCommand, timeoutMs ?? 20 * 60_000); + const packageName = + (pkgRoot ? await readPackageName(pkgRoot) : await readPackageName(root)) ?? + DEFAULT_PACKAGE_NAME; const beforeVersion = pkgRoot ? await readPackageVersion(pkgRoot) : null; const updateStep = await runUpdateStep({ name: "global update", - argv: globalInstallArgs(manager, `clawdbot@${tag}`), + argv: globalInstallArgs(manager, `${packageName}@${tag}`), timeoutMs: timeoutMs ?? 20 * 60_000, progress, }); @@ -705,7 +723,7 @@ export async function updateCommand(opts: UpdateCommandOptions): Promise { const entryPath = path.join(pkgRoot, "dist", "entry.js"); if (await pathExists(entryPath)) { const doctorStep = await runUpdateStep({ - name: "clawdbot doctor", + name: `${CLI_NAME} doctor`, argv: [resolveNodeRunner(), entryPath, "doctor", "--non-interactive"], timeoutMs: timeoutMs ?? 20 * 60_000, progress, @@ -806,11 +824,13 @@ export async function updateCommand(opts: UpdateCommandOptions): Promise { if (result.reason === "not-git-install") { defaultRuntime.log( theme.warn( - `Skipped: this Clawdbot install isn't a git checkout, and the package manager couldn't be detected. Update via your package manager, then run \`${formatCliCommand("clawdbot doctor")}\` and \`${formatCliCommand("clawdbot gateway restart")}\`.`, + `Skipped: this Clawdbot install isn't a git checkout, and the package manager couldn't be detected. Update via your package manager, then run \`${replaceCliName(formatCliCommand("clawdbot doctor"), CLI_NAME)}\` and \`${replaceCliName(formatCliCommand("clawdbot gateway restart"), CLI_NAME)}\`.`, ), ); defaultRuntime.log( - theme.muted("Examples: `npm i -g clawdbot@latest` or `pnpm add -g clawdbot@latest`"), + theme.muted( + `Examples: \`${replaceCliName("npm i -g clawdbot@latest", CLI_NAME)}\` or \`${replaceCliName("pnpm add -g clawdbot@latest", CLI_NAME)}\``, + ), ); } defaultRuntime.exit(0); @@ -926,7 +946,7 @@ export async function updateCommand(opts: UpdateCommandOptions): Promise { defaultRuntime.log(theme.warn(`Daemon restart failed: ${String(err)}`)); defaultRuntime.log( theme.muted( - `You may need to restart the service manually: ${formatCliCommand("clawdbot gateway restart")}`, + `You may need to restart the service manually: ${replaceCliName(formatCliCommand("clawdbot gateway restart"), CLI_NAME)}`, ), ); } @@ -936,13 +956,13 @@ export async function updateCommand(opts: UpdateCommandOptions): Promise { if (result.mode === "npm" || result.mode === "pnpm") { defaultRuntime.log( theme.muted( - `Tip: Run \`${formatCliCommand("clawdbot doctor")}\`, then \`${formatCliCommand("clawdbot gateway restart")}\` to apply updates to a running gateway.`, + `Tip: Run \`${replaceCliName(formatCliCommand("clawdbot doctor"), CLI_NAME)}\`, then \`${replaceCliName(formatCliCommand("clawdbot gateway restart"), CLI_NAME)}\` to apply updates to a running gateway.`, ), ); } else { defaultRuntime.log( theme.muted( - `Tip: Run \`${formatCliCommand("clawdbot gateway restart")}\` to apply updates to a running gateway.`, + `Tip: Run \`${replaceCliName(formatCliCommand("clawdbot gateway restart"), CLI_NAME)}\` to apply updates to a running gateway.`, ), ); } @@ -1137,7 +1157,7 @@ ${theme.heading("Notes:")} - Downgrades require confirmation (can break configuration) - Skips update if the working directory has uncommitted changes -${theme.muted("Docs:")} ${formatDocsLink("/cli/update", "docs.clawd.bot/cli/update")}`; +${theme.muted("Docs:")} ${formatDocsLink("/cli/update", "docs.molt.bot/cli/update")}`; }) .action(async (opts) => { try { @@ -1161,7 +1181,7 @@ ${theme.muted("Docs:")} ${formatDocsLink("/cli/update", "docs.clawd.bot/cli/upda .option("--timeout ", "Timeout for each update step in seconds (default: 1200)") .addHelpText( "after", - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/update", "docs.clawd.bot/cli/update")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/update", "docs.molt.bot/cli/update")}\n`, ) .action(async (opts) => { try { @@ -1188,7 +1208,7 @@ ${theme.muted("Docs:")} ${formatDocsLink("/cli/update", "docs.clawd.bot/cli/upda "- Shows current update channel (stable/beta/dev) and source", )}\n${theme.muted("- Includes git tag/branch/SHA for source checkouts")}\n\n${theme.muted( "Docs:", - )} ${formatDocsLink("/cli/update", "docs.clawd.bot/cli/update")}`, + )} ${formatDocsLink("/cli/update", "docs.molt.bot/cli/update")}`, ) .action(async (opts) => { try { diff --git a/src/cli/webhooks-cli.ts b/src/cli/webhooks-cli.ts index 08c77af4d..1792533c2 100644 --- a/src/cli/webhooks-cli.ts +++ b/src/cli/webhooks-cli.ts @@ -28,7 +28,7 @@ export function registerWebhooksCli(program: Command) { .addHelpText( "after", () => - `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/webhooks", "docs.clawd.bot/cli/webhooks")}\n`, + `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/webhooks", "docs.molt.bot/cli/webhooks")}\n`, ); const gmail = webhooks.command("gmail").description("Gmail Pub/Sub hooks (via gogcli)"); diff --git a/src/commands/agents.commands.add.ts b/src/commands/agents.commands.add.ts index 53b8ba049..5423ac79e 100644 --- a/src/commands/agents.commands.add.ts +++ b/src/commands/agents.commands.add.ts @@ -326,7 +326,7 @@ export async function agentsAddCommand( await prompter.note( [ "Routing unchanged. Add bindings when you're ready.", - "Docs: https://docs.clawd.bot/concepts/multi-agent", + "Docs: https://docs.molt.bot/concepts/multi-agent", ].join("\n"), "Routing", ); diff --git a/src/commands/auth-choice.apply.openai.ts b/src/commands/auth-choice.apply.openai.ts index 947b81181..d00208fab 100644 --- a/src/commands/auth-choice.apply.openai.ts +++ b/src/commands/auth-choice.apply.openai.ts @@ -138,7 +138,7 @@ export async function applyAuthChoiceOpenAI( spin.stop("OpenAI OAuth failed"); params.runtime.error(String(err)); await params.prompter.note( - "Trouble with OAuth? See https://docs.clawd.bot/start/faq", + "Trouble with OAuth? See https://docs.molt.bot/start/faq", "OAuth help", ); } diff --git a/src/commands/channels.adds-non-default-telegram-account.test.ts b/src/commands/channels.adds-non-default-telegram-account.test.ts index d5241a2fd..ff04b5c24 100644 --- a/src/commands/channels.adds-non-default-telegram-account.test.ts +++ b/src/commands/channels.adds-non-default-telegram-account.test.ts @@ -370,7 +370,7 @@ describe("channels command", () => { }); expect(lines.join("\n")).toMatch(/Warnings:/); expect(lines.join("\n")).toMatch(/Message Content Intent is disabled/i); - expect(lines.join("\n")).toMatch(/Run: clawdbot( --profile isolated)? doctor/); + expect(lines.join("\n")).toMatch(/Run: (?:clawdbot|moltbot)( --profile isolated)? doctor/); }); it("surfaces Discord permission audit issues in channels status output", () => { diff --git a/src/commands/configure.gateway.ts b/src/commands/configure.gateway.ts index d572e54a9..273231f31 100644 --- a/src/commands/configure.gateway.ts +++ b/src/commands/configure.gateway.ts @@ -139,9 +139,7 @@ export async function promptGatewayConfig( let tailscaleResetOnExit = false; if (tailscaleMode !== "off") { note( - ["Docs:", "https://docs.clawd.bot/gateway/tailscale", "https://docs.clawd.bot/web"].join( - "\n", - ), + ["Docs:", "https://docs.molt.bot/gateway/tailscale", "https://docs.molt.bot/web"].join("\n"), "Tailscale", ); tailscaleResetOnExit = Boolean( diff --git a/src/commands/configure.wizard.ts b/src/commands/configure.wizard.ts index 7563643e1..535efef31 100644 --- a/src/commands/configure.wizard.ts +++ b/src/commands/configure.wizard.ts @@ -100,7 +100,7 @@ async function promptWebToolsConfig( [ "Web search lets your agent look things up online using the `web_search` tool.", "It requires a Brave Search API key (you can store it in the config or set BRAVE_API_KEY in the Gateway environment).", - "Docs: https://docs.clawd.bot/tools/web", + "Docs: https://docs.molt.bot/tools/web", ].join("\n"), "Web search", ); @@ -136,7 +136,7 @@ async function promptWebToolsConfig( [ "No key stored yet, so web_search will stay unavailable.", "Store a key here or set BRAVE_API_KEY in the Gateway environment.", - "Docs: https://docs.clawd.bot/tools/web", + "Docs: https://docs.molt.bot/tools/web", ].join("\n"), "Web search", ); @@ -189,7 +189,7 @@ export async function runConfigureWizard( [ ...snapshot.issues.map((iss) => `- ${iss.path}: ${iss.message}`), "", - "Docs: https://docs.clawd.bot/gateway/configuration", + "Docs: https://docs.molt.bot/gateway/configuration", ].join("\n"), "Config issues", ); @@ -393,8 +393,8 @@ export async function runConfigureWizard( note( [ "Docs:", - "https://docs.clawd.bot/gateway/health", - "https://docs.clawd.bot/gateway/troubleshooting", + "https://docs.molt.bot/gateway/health", + "https://docs.molt.bot/gateway/troubleshooting", ].join("\n"), "Health check help", ); @@ -518,8 +518,8 @@ export async function runConfigureWizard( note( [ "Docs:", - "https://docs.clawd.bot/gateway/health", - "https://docs.clawd.bot/gateway/troubleshooting", + "https://docs.molt.bot/gateway/health", + "https://docs.molt.bot/gateway/troubleshooting", ].join("\n"), "Health check help", ); @@ -577,7 +577,7 @@ export async function runConfigureWizard( `Web UI: ${links.httpUrl}`, `Gateway WS: ${links.wsUrl}`, gatewayStatusLine, - "Docs: https://docs.clawd.bot/web/control-ui", + "Docs: https://docs.molt.bot/web/control-ui", ].join("\n"), "Control UI", ); diff --git a/src/commands/daemon-install-helpers.test.ts b/src/commands/daemon-install-helpers.test.ts index e3b873737..179da04a2 100644 --- a/src/commands/daemon-install-helpers.test.ts +++ b/src/commands/daemon-install-helpers.test.ts @@ -235,7 +235,7 @@ describe("gatewayInstallErrorHint", () => { it("returns platform-specific hints", () => { expect(gatewayInstallErrorHint("win32")).toContain("Run as administrator"); expect(gatewayInstallErrorHint("linux")).toMatch( - /clawdbot( --profile isolated)? gateway install/, + /(?:clawdbot|moltbot)( --profile isolated)? gateway install/, ); }); }); diff --git a/src/commands/docs.ts b/src/commands/docs.ts index 4ca479f65..d0f01ce6e 100644 --- a/src/commands/docs.ts +++ b/src/commands/docs.ts @@ -5,7 +5,7 @@ import { formatDocsLink } from "../terminal/links.js"; import { isRich, theme } from "../terminal/theme.js"; import { formatCliCommand } from "../cli/command-format.js"; -const SEARCH_TOOL = "https://docs.clawd.bot/mcp.SearchClawdbot"; +const SEARCH_TOOL = "https://docs.molt.bot/mcp.SearchClawdbot"; const SEARCH_TIMEOUT_MS = 30_000; const DEFAULT_SNIPPET_MAX = 220; @@ -148,12 +148,12 @@ async function renderMarkdown(markdown: string, runtime: RuntimeEnv) { export async function docsSearchCommand(queryParts: string[], runtime: RuntimeEnv) { const query = queryParts.join(" ").trim(); if (!query) { - const docs = formatDocsLink("/", "docs.clawd.bot"); + const docs = formatDocsLink("/", "docs.molt.bot"); if (isRich()) { runtime.log(`${theme.muted("Docs:")} ${docs}`); runtime.log(`${theme.muted("Search:")} ${formatCliCommand('clawdbot docs "your query"')}`); } else { - runtime.log("Docs: https://docs.clawd.bot/"); + runtime.log("Docs: https://docs.molt.bot/"); runtime.log(`Search: ${formatCliCommand('clawdbot docs "your query"')}`); } return; diff --git a/src/commands/onboard-helpers.ts b/src/commands/onboard-helpers.ts index dd8288a60..27c74ae00 100644 --- a/src/commands/onboard-helpers.ts +++ b/src/commands/onboard-helpers.ts @@ -177,8 +177,8 @@ export function formatControlUiSshHint(params: { localUrl, authedUrl, "Docs:", - "https://docs.clawd.bot/gateway/remote", - "https://docs.clawd.bot/web/control-ui", + "https://docs.molt.bot/gateway/remote", + "https://docs.molt.bot/web/control-ui", ] .filter(Boolean) .join("\n"); diff --git a/src/commands/onboard-hooks.test.ts b/src/commands/onboard-hooks.test.ts index 10c99140a..e83f61399 100644 --- a/src/commands/onboard-hooks.test.ts +++ b/src/commands/onboard-hooks.test.ts @@ -239,7 +239,7 @@ describe("onboard-hooks", () => { // Second note should confirm configuration expect(noteCalls[1][0]).toContain("Enabled 1 hook: session-memory"); - expect(noteCalls[1][0]).toMatch(/clawdbot( --profile isolated)? hooks list/); + expect(noteCalls[1][0]).toMatch(/(?:clawdbot|moltbot)( --profile isolated)? hooks list/); }); }); }); diff --git a/src/commands/onboard-hooks.ts b/src/commands/onboard-hooks.ts index 10cdf1293..9fcc322a7 100644 --- a/src/commands/onboard-hooks.ts +++ b/src/commands/onboard-hooks.ts @@ -15,7 +15,7 @@ export async function setupInternalHooks( "Hooks let you automate actions when agent commands are issued.", "Example: Save session context to memory when you issue /new.", "", - "Learn more: https://docs.clawd.bot/hooks", + "Learn more: https://docs.molt.bot/hooks", ].join("\n"), "Hooks", ); diff --git a/src/commands/onboard-non-interactive/local.ts b/src/commands/onboard-non-interactive/local.ts index 8701bac7a..ec78dfba9 100644 --- a/src/commands/onboard-non-interactive/local.ts +++ b/src/commands/onboard-non-interactive/local.ts @@ -125,7 +125,7 @@ export async function runNonInteractiveOnboardingLocal(params: { if (!opts.json) { runtime.log( - `Tip: run \`${formatCliCommand("clawdbot configure --section web")}\` to store your Brave API key for web_search. Docs: https://docs.clawd.bot/tools/web`, + `Tip: run \`${formatCliCommand("clawdbot configure --section web")}\` to store your Brave API key for web_search. Docs: https://docs.molt.bot/tools/web`, ); } } diff --git a/src/commands/onboard-non-interactive/remote.ts b/src/commands/onboard-non-interactive/remote.ts index 1426448fc..6807434e0 100644 --- a/src/commands/onboard-non-interactive/remote.ts +++ b/src/commands/onboard-non-interactive/remote.ts @@ -47,7 +47,7 @@ export async function runNonInteractiveOnboardingRemote(params: { runtime.log(`Remote gateway: ${remoteUrl}`); runtime.log(`Auth: ${payload.auth}`); runtime.log( - `Tip: run \`${formatCliCommand("clawdbot configure --section web")}\` to store your Brave API key for web_search. Docs: https://docs.clawd.bot/tools/web`, + `Tip: run \`${formatCliCommand("clawdbot configure --section web")}\` to store your Brave API key for web_search. Docs: https://docs.molt.bot/tools/web`, ); } } diff --git a/src/commands/onboard-remote.ts b/src/commands/onboard-remote.ts index 24c8773c8..cb71cabdf 100644 --- a/src/commands/onboard-remote.ts +++ b/src/commands/onboard-remote.ts @@ -43,7 +43,7 @@ export async function promptRemoteGatewayConfig( await prompter.note( [ "Bonjour discovery requires dns-sd (macOS) or avahi-browse (Linux).", - "Docs: https://docs.clawd.bot/gateway/discovery", + "Docs: https://docs.molt.bot/gateway/discovery", ].join("\n"), "Discovery", ); @@ -96,7 +96,7 @@ export async function promptRemoteGatewayConfig( `ssh -N -L 18789:127.0.0.1:18789 @${host}${ selectedBeacon.sshPort ? ` -p ${selectedBeacon.sshPort}` : "" }`, - "Docs: https://docs.clawd.bot/gateway/remote", + "Docs: https://docs.molt.bot/gateway/remote", ].join("\n"), "SSH tunnel", ); diff --git a/src/commands/onboard-skills.ts b/src/commands/onboard-skills.ts index ce3b06123..8d90dccee 100644 --- a/src/commands/onboard-skills.ts +++ b/src/commands/onboard-skills.ts @@ -156,7 +156,7 @@ export async function setupSkills( runtime.log( `Tip: run \`${formatCliCommand("clawdbot doctor")}\` to review skills + requirements.`, ); - runtime.log("Docs: https://docs.clawd.bot/skills"); + runtime.log("Docs: https://docs.molt.bot/skills"); } } } diff --git a/src/commands/onboard.ts b/src/commands/onboard.ts index 348aca613..6ede2b768 100644 --- a/src/commands/onboard.ts +++ b/src/commands/onboard.ts @@ -44,7 +44,7 @@ export async function onboardCommand(opts: OnboardOptions, runtime: RuntimeEnv = runtime.error( [ "Non-interactive onboarding requires explicit risk acknowledgement.", - "Read: https://docs.clawd.bot/security", + "Read: https://docs.molt.bot/security", `Re-run with: ${formatCliCommand("clawdbot onboard --non-interactive --accept-risk ...")}`, ].join("\n"), ); @@ -65,7 +65,7 @@ export async function onboardCommand(opts: OnboardOptions, runtime: RuntimeEnv = [ "Windows detected.", "WSL2 is strongly recommended; native Windows is untested and more problematic.", - "Guide: https://docs.clawd.bot/windows", + "Guide: https://docs.molt.bot/windows", ].join("\n"), ); } diff --git a/src/commands/sandbox-explain.test.ts b/src/commands/sandbox-explain.test.ts index d3e5ea2ee..a2fa611d8 100644 --- a/src/commands/sandbox-explain.test.ts +++ b/src/commands/sandbox-explain.test.ts @@ -36,7 +36,7 @@ describe("sandbox explain command", () => { const out = logs.join(""); const parsed = JSON.parse(out); - expect(parsed).toHaveProperty("docsUrl", "https://docs.clawd.bot/sandbox"); + expect(parsed).toHaveProperty("docsUrl", "https://docs.molt.bot/sandbox"); expect(parsed).toHaveProperty("sandbox.mode", "all"); expect(parsed).toHaveProperty("sandbox.tools.sources.allow.source"); expect(Array.isArray(parsed.fixIt)).toBe(true); diff --git a/src/commands/sandbox-explain.ts b/src/commands/sandbox-explain.ts index daaa9e483..f7c4c1cdb 100644 --- a/src/commands/sandbox-explain.ts +++ b/src/commands/sandbox-explain.ts @@ -30,7 +30,7 @@ type SandboxExplainOptions = { json: boolean; }; -const SANDBOX_DOCS_URL = "https://docs.clawd.bot/sandbox"; +const SANDBOX_DOCS_URL = "https://docs.molt.bot/sandbox"; function normalizeExplainSessionKey(params: { cfg: ClawdbotConfig; @@ -307,7 +307,7 @@ export async function sandboxExplainCommand( lines.push(heading("Fix-it:")); for (const key of payload.fixIt) lines.push(` - ${key}`); lines.push(""); - lines.push(`${key("Docs:")} ${formatDocsLink("/sandbox", "docs.clawd.bot/sandbox")}`); + lines.push(`${key("Docs:")} ${formatDocsLink("/sandbox", "docs.molt.bot/sandbox")}`); runtime.log(`${lines.join("\n")}\n`); } diff --git a/src/commands/status-all/diagnosis.ts b/src/commands/status-all/diagnosis.ts index 90912da1b..5e73e3743 100644 --- a/src/commands/status-all/diagnosis.ts +++ b/src/commands/status-all/diagnosis.ts @@ -234,6 +234,6 @@ export async function appendStatusAllDiagnosis(params: { lines.push(""); lines.push(muted("Pasteable debug report. Auth tokens redacted.")); - lines.push("Troubleshooting: https://docs.clawd.bot/troubleshooting"); + lines.push("Troubleshooting: https://docs.molt.bot/troubleshooting"); lines.push(""); } diff --git a/src/commands/status.command.ts b/src/commands/status.command.ts index 1ce771ac8..c36b91c99 100644 --- a/src/commands/status.command.ts +++ b/src/commands/status.command.ts @@ -560,8 +560,8 @@ export async function statusCommand( } runtime.log(""); - runtime.log("FAQ: https://docs.clawd.bot/faq"); - runtime.log("Troubleshooting: https://docs.clawd.bot/troubleshooting"); + runtime.log("FAQ: https://docs.molt.bot/faq"); + runtime.log("Troubleshooting: https://docs.molt.bot/troubleshooting"); runtime.log(""); const updateHint = formatUpdateAvailableHint(update); if (updateHint) { diff --git a/src/commands/status.test.ts b/src/commands/status.test.ts index ca9d8ae96..047f43a07 100644 --- a/src/commands/status.test.ts +++ b/src/commands/status.test.ts @@ -330,6 +330,8 @@ describe("statusCommand", () => { expect( logs.some( (l) => + l.includes("moltbot status --all") || + l.includes("moltbot --profile isolated status --all") || l.includes("clawdbot status --all") || l.includes("clawdbot --profile isolated status --all"), ), diff --git a/src/hooks/bundled/README.md b/src/hooks/bundled/README.md index 48ad5ea95..77df25ee4 100644 --- a/src/hooks/bundled/README.md +++ b/src/hooks/bundled/README.md @@ -39,7 +39,7 @@ Swaps injected `SOUL.md` content with `SOUL_EVIL.md` during a purge window or by **Events**: `agent:bootstrap` **What it does**: Overrides the injected SOUL content before the system prompt is built. **Output**: No files written; swaps happen in-memory only. -**Docs**: https://docs.clawd.bot/hooks/soul-evil +**Docs**: https://docs.molt.bot/hooks/soul-evil **Enable**: @@ -82,7 +82,7 @@ session-memory/ --- name: my-hook description: "Short description" -homepage: https://docs.clawd.bot/hooks#my-hook +homepage: https://docs.molt.bot/hooks#my-hook metadata: { "clawdbot": { "emoji": "🔗", "events": ["command:new"], "requires": { "bins": ["node"] } } } --- @@ -221,4 +221,4 @@ Test your hooks by: ## Documentation -Full documentation: https://docs.clawd.bot/hooks +Full documentation: https://docs.molt.bot/hooks diff --git a/src/hooks/bundled/boot-md/HOOK.md b/src/hooks/bundled/boot-md/HOOK.md index dac210b62..2572c50cc 100644 --- a/src/hooks/bundled/boot-md/HOOK.md +++ b/src/hooks/bundled/boot-md/HOOK.md @@ -1,7 +1,7 @@ --- name: boot-md description: "Run BOOT.md on gateway startup" -homepage: https://docs.clawd.bot/hooks#boot-md +homepage: https://docs.molt.bot/hooks#boot-md metadata: { "clawdbot": diff --git a/src/hooks/bundled/command-logger/HOOK.md b/src/hooks/bundled/command-logger/HOOK.md index 10034fab8..bf33cdeff 100644 --- a/src/hooks/bundled/command-logger/HOOK.md +++ b/src/hooks/bundled/command-logger/HOOK.md @@ -1,7 +1,7 @@ --- name: command-logger description: "Log all command events to a centralized audit file" -homepage: https://docs.clawd.bot/hooks#command-logger +homepage: https://docs.molt.bot/hooks#command-logger metadata: { "clawdbot": diff --git a/src/hooks/bundled/session-memory/HOOK.md b/src/hooks/bundled/session-memory/HOOK.md index cc3eab0a2..bb3ac1468 100644 --- a/src/hooks/bundled/session-memory/HOOK.md +++ b/src/hooks/bundled/session-memory/HOOK.md @@ -1,7 +1,7 @@ --- name: session-memory description: "Save session context to memory when /new command is issued" -homepage: https://docs.clawd.bot/hooks#session-memory +homepage: https://docs.molt.bot/hooks#session-memory metadata: { "clawdbot": diff --git a/src/hooks/bundled/soul-evil/HOOK.md b/src/hooks/bundled/soul-evil/HOOK.md index 776163bd0..7bb50620b 100644 --- a/src/hooks/bundled/soul-evil/HOOK.md +++ b/src/hooks/bundled/soul-evil/HOOK.md @@ -1,7 +1,7 @@ --- name: soul-evil description: "Swap SOUL.md with SOUL_EVIL.md during a purge window or by random chance" -homepage: https://docs.clawd.bot/hooks/soul-evil +homepage: https://docs.molt.bot/hooks/soul-evil metadata: { "clawdbot": diff --git a/src/hooks/bundled/soul-evil/README.md b/src/hooks/bundled/soul-evil/README.md index 3f0e09a85..a49bfe33d 100644 --- a/src/hooks/bundled/soul-evil/README.md +++ b/src/hooks/bundled/soul-evil/README.md @@ -2,7 +2,7 @@ Small persona swap hook for Clawdbot. -Docs: https://docs.clawd.bot/hooks/soul-evil +Docs: https://docs.molt.bot/hooks/soul-evil ## Setup diff --git a/src/hooks/frontmatter.test.ts b/src/hooks/frontmatter.test.ts index 761eaa75f..91545796d 100644 --- a/src/hooks/frontmatter.test.ts +++ b/src/hooks/frontmatter.test.ts @@ -233,7 +233,7 @@ describe("resolveClawdbotMetadata", () => { const content = `--- name: session-memory description: "Save session context to memory when /new command is issued" -homepage: https://docs.clawd.bot/hooks#session-memory +homepage: https://docs.molt.bot/hooks#session-memory metadata: { "clawdbot": diff --git a/src/infra/clawdbot-root.ts b/src/infra/clawdbot-root.ts index 9a3443ffb..d7d20467f 100644 --- a/src/infra/clawdbot-root.ts +++ b/src/infra/clawdbot-root.ts @@ -2,6 +2,8 @@ import fs from "node:fs/promises"; import path from "node:path"; import { fileURLToPath } from "node:url"; +const CORE_PACKAGE_NAMES = new Set(["moltbot", "clawdbot"]); + async function readPackageName(dir: string): Promise { try { const raw = await fs.readFile(path.join(dir, "package.json"), "utf-8"); @@ -16,7 +18,7 @@ async function findPackageRoot(startDir: string, maxDepth = 12): Promise { @@ -714,7 +732,8 @@ export async function runGatewayUpdate(opts: UpdateRunnerOptions = {}): Promise< const beforeVersion = await readPackageVersion(pkgRoot); const globalManager = await detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs); if (globalManager) { - const spec = `clawdbot@${normalizeTag(opts.tag)}`; + const packageName = (await readPackageName(pkgRoot)) ?? DEFAULT_PACKAGE_NAME; + const spec = `${packageName}@${normalizeTag(opts.tag)}`; const updateStep = await runStep({ runCommand, name: "global update", diff --git a/src/pairing/pairing-messages.test.ts b/src/pairing/pairing-messages.test.ts index 416a6ab19..1997a0e30 100644 --- a/src/pairing/pairing-messages.test.ts +++ b/src/pairing/pairing-messages.test.ts @@ -52,9 +52,10 @@ describe("buildPairingReply", () => { expect(text).toContain(testCase.idLine); expect(text).toContain(`Pairing code: ${testCase.code}`); // CLI commands should respect CLAWDBOT_PROFILE when set (most tests run with isolated profile) - expect(text).toContain( - `clawdbot --profile isolated pairing approve ${testCase.channel} `, + const commandRe = new RegExp( + `(?:clawdbot|moltbot) --profile isolated pairing approve ${testCase.channel} `, ); + expect(text).toMatch(commandRe); }); } }); diff --git a/src/plugins/loader.ts b/src/plugins/loader.ts index 931c15d59..178e2d3c2 100644 --- a/src/plugins/loader.ts +++ b/src/plugins/loader.ts @@ -206,7 +206,14 @@ export function loadClawdbotPlugins(options: PluginLoadOptions = {}): PluginRegi const jiti = createJiti(import.meta.url, { interopDefault: true, extensions: [".ts", ".tsx", ".mts", ".cts", ".mtsx", ".ctsx", ".js", ".mjs", ".cjs", ".json"], - ...(pluginSdkAlias ? { alias: { "clawdbot/plugin-sdk": pluginSdkAlias } } : {}), + ...(pluginSdkAlias + ? { + alias: { + "clawdbot/plugin-sdk": pluginSdkAlias, + "moltbot/plugin-sdk": pluginSdkAlias, + }, + } + : {}), }); const manifestByRoot = new Map( diff --git a/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts b/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts index 165488426..58ecc8d7a 100644 --- a/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts +++ b/src/telegram/bot.media.downloads-media-file-path-no-file-download.test.ts @@ -105,7 +105,8 @@ vi.mock("../auto-reply/reply.js", () => { }); describe("telegram inbound media", () => { - const INBOUND_MEDIA_TEST_TIMEOUT_MS = process.platform === "win32" ? 30_000 : 20_000; + // Parallel vitest shards can make this suite slower than the standalone run. + const INBOUND_MEDIA_TEST_TIMEOUT_MS = process.platform === "win32" ? 60_000 : 45_000; it( "downloads media via file_path (no file.download)", diff --git a/src/terminal/links.ts b/src/terminal/links.ts index b26ff37bb..0d965633a 100644 --- a/src/terminal/links.ts +++ b/src/terminal/links.ts @@ -1,6 +1,6 @@ import { formatTerminalLink } from "../utils.js"; -export const DOCS_ROOT = "https://docs.clawd.bot"; +export const DOCS_ROOT = "https://docs.molt.bot"; export function formatDocsLink( path: string, diff --git a/src/wizard/onboarding.finalize.ts b/src/wizard/onboarding.finalize.ts index 32ab53dcf..670b4eaf6 100644 --- a/src/wizard/onboarding.finalize.ts +++ b/src/wizard/onboarding.finalize.ts @@ -214,8 +214,8 @@ export async function finalizeOnboardingWizard(options: FinalizeOnboardingOption await prompter.note( [ "Docs:", - "https://docs.clawd.bot/gateway/health", - "https://docs.clawd.bot/gateway/troubleshooting", + "https://docs.molt.bot/gateway/health", + "https://docs.molt.bot/gateway/troubleshooting", ].join("\n"), "Health check help", ); @@ -277,7 +277,7 @@ export async function finalizeOnboardingWizard(options: FinalizeOnboardingOption tokenParam ? `Web UI (with token): ${authedUrl}` : undefined, `Gateway WS: ${links.wsUrl}`, gatewayStatusLine, - "Docs: https://docs.clawd.bot/web/control-ui", + "Docs: https://docs.molt.bot/web/control-ui", ] .filter(Boolean) .join("\n"), @@ -383,14 +383,14 @@ export async function finalizeOnboardingWizard(options: FinalizeOnboardingOption } await prompter.note( - ["Back up your agent workspace.", "Docs: https://docs.clawd.bot/concepts/agent-workspace"].join( + ["Back up your agent workspace.", "Docs: https://docs.molt.bot/concepts/agent-workspace"].join( "\n", ), "Workspace backup", ); await prompter.note( - "Running agents on your computer is risky — harden your setup: https://docs.clawd.bot/security", + "Running agents on your computer is risky — harden your setup: https://docs.molt.bot/security", "Security", ); @@ -443,7 +443,7 @@ export async function finalizeOnboardingWizard(options: FinalizeOnboardingOption webSearchKey ? "API key: stored in config (tools.web.search.apiKey)." : "API key: provided via BRAVE_API_KEY env var (Gateway environment).", - "Docs: https://docs.clawd.bot/tools/web", + "Docs: https://docs.molt.bot/tools/web", ].join("\n") : [ "If you want your agent to be able to search the web, you’ll need an API key.", @@ -455,13 +455,13 @@ export async function finalizeOnboardingWizard(options: FinalizeOnboardingOption "- Enable web_search and paste your Brave Search API key", "", "Alternative: set BRAVE_API_KEY in the Gateway environment (no config changes).", - "Docs: https://docs.clawd.bot/tools/web", + "Docs: https://docs.molt.bot/tools/web", ].join("\n"), "Web search (optional)", ); await prompter.note( - 'What now: https://clawd.bot/showcase ("What People Are Building").', + 'What now: https://molt.bot/showcase ("What People Are Building").', "What now", ); diff --git a/src/wizard/onboarding.gateway-config.ts b/src/wizard/onboarding.gateway-config.ts index c68836b32..f8d56af62 100644 --- a/src/wizard/onboarding.gateway-config.ts +++ b/src/wizard/onboarding.gateway-config.ts @@ -145,9 +145,7 @@ export async function configureGatewayForOnboarding( let tailscaleResetOnExit = flow === "quickstart" ? quickstartGateway.tailscaleResetOnExit : false; if (tailscaleMode !== "off" && flow !== "quickstart") { await prompter.note( - ["Docs:", "https://docs.clawd.bot/gateway/tailscale", "https://docs.clawd.bot/web"].join( - "\n", - ), + ["Docs:", "https://docs.molt.bot/gateway/tailscale", "https://docs.molt.bot/web"].join("\n"), "Tailscale", ); tailscaleResetOnExit = Boolean( diff --git a/src/wizard/onboarding.ts b/src/wizard/onboarding.ts index 39d17befa..52f9285aa 100644 --- a/src/wizard/onboarding.ts +++ b/src/wizard/onboarding.ts @@ -70,7 +70,7 @@ async function requireRiskAcknowledgement(params: { "clawdbot security audit --deep", "clawdbot security audit --fix", "", - "Must read: https://docs.clawd.bot/gateway/security", + "Must read: https://docs.molt.bot/gateway/security", ].join("\n"), "Security", ); @@ -103,7 +103,7 @@ export async function runOnboardingWizard( [ ...snapshot.issues.map((iss) => `- ${iss.path}: ${iss.message}`), "", - "Docs: https://docs.clawd.bot/gateway/configuration", + "Docs: https://docs.molt.bot/gateway/configuration", ].join("\n"), "Config issues", ); diff --git a/ui/src/ui/app-render.ts b/ui/src/ui/app-render.ts index fe67c86f1..49f72de8c 100644 --- a/ui/src/ui/app-render.ts +++ b/ui/src/ui/app-render.ts @@ -180,7 +180,7 @@ export function renderApp(state: AppViewState) {
    · Date: Tue, 27 Jan 2026 12:19:58 +0000 Subject: [PATCH 015/101] refactor: rename clawdbot to moltbot with legacy compat --- AGENTS.md | 36 +- CHANGELOG.md | 120 ++-- CONTRIBUTING.md | 12 +- Dockerfile.sandbox-browser | 6 +- SECURITY.md | 14 +- appcast.xml | 36 +- apps/android/app/build.gradle.kts | 2 +- apps/android/app/src/main/AndroidManifest.xml | 2 +- .../java/com/clawdbot/android/MainActivity.kt | 4 +- .../clawdbot/android/NodeForegroundService.kt | 6 +- .../java/com/clawdbot/android/NodeRuntime.kt | 110 ++-- .../clawdbot/android/PermissionRequester.kt | 2 +- .../android/ScreenCaptureRequester.kt | 2 +- .../java/com/clawdbot/android/SecurePrefs.kt | 2 +- .../android/gateway/DeviceIdentityStore.kt | 2 +- .../android/gateway/GatewayDiscovery.kt | 6 +- .../android/gateway/GatewaySession.kt | 4 +- .../android/node/CameraCaptureManager.kt | 4 +- .../clawdbot/android/node/CanvasController.kt | 6 +- .../android/node/ScreenRecordManager.kt | 4 +- .../protocol/ClawdbotCanvasA2UIAction.kt | 4 +- .../protocol/ClawdbotProtocolConstants.kt | 14 +- .../com/clawdbot/android/ui/ClawdbotTheme.kt | 2 +- .../com/clawdbot/android/ui/RootScreen.kt | 14 +- .../com/clawdbot/android/ui/SettingsSheet.kt | 6 +- .../app/src/main/res/values/strings.xml | 2 +- .../app/src/main/res/values/themes.xml | 2 +- .../main/res/xml/network_security_config.xml | 2 +- .../android/gateway/BonjourEscapesTest.kt | 2 +- .../protocol/ClawdbotCanvasA2UIActionTest.kt | 14 +- .../protocol/ClawdbotProtocolConstantsTest.kt | 28 +- apps/android/settings.gradle.kts | 2 +- .../ios/Sources/Camera/CameraController.swift | 12 +- apps/ios/Sources/Chat/ChatSheet.swift | 10 +- .../Chat/IOSGatewayChatTransport.swift | 32 +- apps/ios/Sources/ClawdbotApp.swift | 2 +- .../Gateway/GatewayConnectionController.swift | 54 +- .../Gateway/GatewayDiscoveryModel.swift | 8 +- apps/ios/Sources/Info.plist | 16 +- .../Sources/Location/LocationService.swift | 10 +- apps/ios/Sources/Model/NodeAppModel.swift | 146 ++--- .../ios/Sources/Screen/ScreenController.swift | 18 +- .../Sources/Screen/ScreenRecordService.swift | 2 +- apps/ios/Sources/Screen/ScreenTab.swift | 2 +- apps/ios/Sources/Screen/ScreenWebView.swift | 2 +- apps/ios/Sources/Settings/SettingsTab.swift | 20 +- .../Settings/VoiceWakeWordsSettingsView.swift | 2 +- apps/ios/Sources/Voice/TalkModeManager.swift | 4 +- apps/ios/Tests/AppCoverageTests.swift | 2 +- .../Tests/CameraControllerClampTests.swift | 2 +- .../Tests/CameraControllerErrorTests.swift | 2 +- apps/ios/Tests/DeepLinkParserTests.swift | 16 +- .../GatewayConnectionControllerTests.swift | 20 +- .../Tests/GatewayDiscoveryModelTests.swift | 2 +- apps/ios/Tests/GatewayEndpointIDTests.swift | 14 +- .../ios/Tests/GatewaySettingsStoreTests.swift | 2 +- .../Tests/IOSGatewayChatTransportTests.swift | 4 +- apps/ios/Tests/Info.plist | 2 +- apps/ios/Tests/KeychainStoreTests.swift | 2 +- apps/ios/Tests/NodeAppModelInvokeTests.swift | 34 +- apps/ios/Tests/ScreenControllerTests.swift | 2 +- apps/ios/Tests/ScreenRecordServiceTests.swift | 2 +- .../SettingsNetworkingHelpersTests.swift | 2 +- apps/ios/Tests/SwiftUIRenderSmokeTests.swift | 6 +- .../ios/Tests/VoiceWakeGatewaySyncTests.swift | 2 +- .../VoiceWakeManagerExtractCommandTests.swift | 2 +- .../Tests/VoiceWakeManagerStateTests.swift | 2 +- .../ios/Tests/VoiceWakePreferencesTests.swift | 2 +- apps/ios/fastlane/Fastfile | 4 +- apps/ios/fastlane/SETUP.md | 2 +- apps/ios/project.yml | 46 +- apps/macos/Icon.icon/icon.json | 4 +- apps/macos/Package.swift | 54 +- .../Sources/Clawdbot/AboutSettings.swift | 10 +- .../Sources/Clawdbot/AgentEventsWindow.swift | 8 +- .../Sources/Clawdbot/AgentWorkspace.swift | 6 +- .../Clawdbot/AnthropicAuthControls.swift | 18 +- .../Sources/Clawdbot/AnthropicOAuth.swift | 18 +- .../Sources/Clawdbot/AnyCodable+Helpers.swift | 20 +- apps/macos/Sources/Clawdbot/AppState.swift | 20 +- .../Sources/Clawdbot/CLIInstallPrompter.swift | 2 +- .../macos/Sources/Clawdbot/CLIInstaller.swift | 6 +- .../Clawdbot/CameraCaptureService.swift | 8 +- .../CanvasA2UIActionMessageHandler.swift | 18 +- .../Sources/Clawdbot/CanvasManager.swift | 8 +- .../macos/Sources/Clawdbot/CanvasScheme.swift | 2 +- .../Clawdbot/CanvasSchemeHandler.swift | 4 +- .../CanvasWindowController+Helpers.swift | 2 +- .../CanvasWindowController+Navigation.swift | 2 +- .../CanvasWindowController+Window.swift | 4 +- .../Clawdbot/CanvasWindowController.swift | 16 +- .../ChannelsSettings+ChannelState.swift | 2 +- .../Clawdbot/ChannelsStore+Config.swift | 4 +- .../Clawdbot/ChannelsStore+Lifecycle.swift | 2 +- .../Sources/Clawdbot/ChannelsStore.swift | 2 +- .../Sources/Clawdbot/ClawdbotConfigFile.swift | 10 +- .../Sources/Clawdbot/ClawdbotPaths.swift | 10 +- .../Sources/Clawdbot/CommandResolver.swift | 68 +-- .../Sources/Clawdbot/ConfigSettings.swift | 2 +- apps/macos/Sources/Clawdbot/ConfigStore.swift | 6 +- .../Clawdbot/ConnectionModeResolver.swift | 2 +- apps/macos/Sources/Clawdbot/Constants.swift | 70 +-- .../Sources/Clawdbot/ControlChannel.swift | 24 +- .../Clawdbot/CronJobEditor+Helpers.swift | 2 +- .../Sources/Clawdbot/CronJobEditor.swift | 2 +- .../Sources/Clawdbot/CronJobsStore.swift | 4 +- .../Clawdbot/CronSettings+Actions.swift | 2 +- .../Clawdbot/CronSettings+Testing.swift | 2 +- .../macos/Sources/Clawdbot/DebugActions.swift | 8 +- .../Sources/Clawdbot/DebugSettings.swift | 26 +- apps/macos/Sources/Clawdbot/DeepLinks.swift | 6 +- .../DevicePairingApprovalPrompter.swift | 4 +- .../Sources/Clawdbot/DiagnosticsFileLog.swift | 2 +- .../Sources/Clawdbot/ExecApprovals.swift | 4 +- .../ExecApprovalsGatewayPrompter.swift | 4 +- .../Clawdbot/ExecApprovalsSocket.swift | 2 +- .../Sources/Clawdbot/GatewayConnection.swift | 20 +- .../Clawdbot/GatewayDiscoveryHelpers.swift | 2 +- .../Clawdbot/GatewayDiscoveryMenu.swift | 4 +- .../Clawdbot/GatewayEndpointStore.swift | 28 +- .../Sources/Clawdbot/GatewayEnvironment.swift | 20 +- .../Sources/Clawdbot/GeneralSettings.swift | 30 +- apps/macos/Sources/Clawdbot/HealthStore.swift | 8 +- .../Sources/Clawdbot/InstancesSettings.swift | 2 +- .../Sources/Clawdbot/InstancesStore.swift | 6 +- .../Sources/Clawdbot/LaunchAgentManager.swift | 2 +- .../Sources/Clawdbot/LaunchdManager.swift | 4 +- apps/macos/Sources/Clawdbot/LogLocator.swift | 10 +- .../Clawdbot/Logging/ClawdbotLogging.swift | 16 +- apps/macos/Sources/Clawdbot/MenuBar.swift | 4 +- .../Sources/Clawdbot/MenuContentView.swift | 10 +- .../Sources/Clawdbot/ModelCatalogLoader.swift | 2 +- .../NodeMode/MacNodeLocationService.swift | 6 +- .../NodeMode/MacNodeModeCoordinator.swift | 52 +- .../Clawdbot/NodeMode/MacNodeRuntime.swift | 136 ++--- .../MacNodeRuntimeMainActorServices.swift | 6 +- .../NodePairingApprovalPrompter.swift | 8 +- .../Clawdbot/NotificationManager.swift | 2 +- apps/macos/Sources/Clawdbot/Onboarding.swift | 18 +- .../Clawdbot/OnboardingView+Actions.swift | 12 +- .../Clawdbot/OnboardingView+Chat.swift | 2 +- .../Clawdbot/OnboardingView+Layout.swift | 2 +- .../Clawdbot/OnboardingView+Monitoring.swift | 12 +- .../Clawdbot/OnboardingView+Pages.swift | 42 +- .../Clawdbot/OnboardingView+Testing.swift | 10 +- .../Clawdbot/OnboardingView+Wizard.swift | 2 +- .../Sources/Clawdbot/OnboardingWidgets.swift | 2 +- .../Sources/Clawdbot/OnboardingWizard.swift | 10 +- .../PeekabooBridgeHostCoordinator.swift | 6 +- .../Sources/Clawdbot/PermissionManager.swift | 4 +- .../Clawdbot/PermissionsSettings.swift | 24 +- .../macos/Sources/Clawdbot/PortGuardian.swift | 10 +- .../Clawdbot/ProcessInfo+Clawdbot.swift | 2 +- .../Sources/Clawdbot/RemotePortTunnel.swift | 2 +- .../Clawdbot/RemoteTunnelManager.swift | 2 +- .../Sources/Clawdbot/Resources/Info.plist | 30 +- .../Sources/Clawdbot/RuntimeLocator.swift | 4 +- .../Clawdbot/ScreenRecordService.swift | 2 +- .../Clawdbot/SessionMenuPreviewView.swift | 30 +- .../Sources/Clawdbot/SettingsRootView.swift | 6 +- .../Sources/Clawdbot/ShellExecutor.swift | 2 +- .../macos/Sources/Clawdbot/SkillsModels.swift | 2 +- .../Sources/Clawdbot/SkillsSettings.swift | 12 +- .../TailscaleIntegrationSection.swift | 6 +- .../Sources/Clawdbot/TalkModeRuntime.swift | 8 +- .../VoiceWakeGlobalSettingsSync.swift | 2 +- .../Sources/Clawdbot/VoiceWakeOverlay.swift | 2 +- .../Sources/Clawdbot/VoiceWakeSettings.swift | 2 +- .../Sources/Clawdbot/WebChatSwiftUI.swift | 40 +- .../Sources/Clawdbot/WorkActivityStore.swift | 16 +- .../GatewayDiscoveryModel.swift | 16 +- .../WideAreaGatewayDiscovery.swift | 12 +- apps/macos/Sources/ClawdbotIPC/IPC.swift | 4 +- .../ClawdbotMacCLI/ConnectCommand.swift | 16 +- .../ClawdbotMacCLI/DiscoverCommand.swift | 6 +- .../Sources/ClawdbotMacCLI/EntryPoint.swift | 20 +- .../ClawdbotMacCLI/GatewayConfig.swift | 2 +- .../Sources/ClawdbotMacCLI/TypeAliases.swift | 8 +- .../ClawdbotMacCLI/WizardCommand.swift | 12 +- .../AgentEventStoreTests.swift | 8 +- .../AgentWorkspaceTests.swift | 12 +- .../AnthropicAuthControlsSmokeTests.swift | 2 +- .../AnthropicAuthResolverTests.swift | 6 +- .../AnthropicOAuthCodeStateTests.swift | 2 +- .../AnyCodableEncodingTests.swift | 8 +- .../ClawdbotIPCTests/CLIInstallerTests.swift | 6 +- .../CameraCaptureServiceTests.swift | 2 +- .../ClawdbotIPCTests/CameraIPCTests.swift | 2 +- .../CanvasFileWatcherTests.swift | 4 +- .../ClawdbotIPCTests/CanvasIPCTests.swift | 2 +- .../CanvasWindowSmokeTests.swift | 8 +- .../ChannelsSettingsSmokeTests.swift | 8 +- .../ClawdbotConfigFileTests.swift | 40 +- .../ClawdbotOAuthStoreTests.swift | 24 +- .../CommandResolverTests.swift | 28 +- .../ClawdbotIPCTests/ConfigStoreTests.swift | 2 +- .../CritterIconRendererTests.swift | 2 +- .../CronJobEditorSmokeTests.swift | 2 +- .../ClawdbotIPCTests/CronModelsTests.swift | 2 +- .../DeviceModelCatalogTests.swift | 2 +- .../ClawdbotIPCTests/ExecAllowlistTests.swift | 2 +- .../ExecApprovalHelpersTests.swift | 2 +- .../ExecApprovalsGatewayPrompterTests.swift | 2 +- .../FileHandleLegacyAPIGuardTests.swift | 2 +- .../FileHandleSafeReadTests.swift | 2 +- .../GatewayAgentChannelTests.swift | 2 +- .../GatewayAutostartPolicyTests.swift | 2 +- .../GatewayChannelConfigureTests.swift | 4 +- .../GatewayChannelConnectTests.swift | 4 +- .../GatewayChannelRequestTests.swift | 4 +- .../GatewayChannelShutdownTests.swift | 4 +- .../GatewayConnectionControlTests.swift | 6 +- .../GatewayDiscoveryModelTests.swift | 12 +- .../GatewayEndpointStoreTests.swift | 2 +- .../GatewayEnvironmentTests.swift | 2 +- .../GatewayFrameDecodeTests.swift | 2 +- .../GatewayLaunchAgentManagerTests.swift | 10 +- .../GatewayProcessManagerTests.swift | 4 +- .../ClawdbotIPCTests/HealthDecodeTests.swift | 2 +- .../HealthStoreStateTests.swift | 2 +- .../HoverHUDControllerTests.swift | 2 +- .../InstancesSettingsSmokeTests.swift | 2 +- .../InstancesStoreTests.swift | 12 +- .../ClawdbotIPCTests/LogLocatorTests.swift | 4 +- .../LowCoverageHelperTests.swift | 6 +- .../LowCoverageViewSmokeTests.swift | 4 +- .../MacGatewayChatTransportMappingTests.swift | 20 +- .../MacNodeRuntimeTests.swift | 22 +- .../MasterDiscoveryMenuSmokeTests.swift | 4 +- .../MenuContentSmokeTests.swift | 2 +- .../MenuSessionsInjectorTests.swift | 2 +- .../ModelCatalogLoaderTests.swift | 2 +- .../NodeManagerPathsTests.swift | 2 +- .../NodePairingApprovalPrompterTests.swift | 2 +- .../NodePairingReconcilePolicyTests.swift | 2 +- .../OnboardingCoverageTests.swift | 2 +- .../OnboardingViewSmokeTests.swift | 4 +- .../OnboardingWizardStepViewTests.swift | 6 +- .../PermissionManagerLocationTests.swift | 2 +- .../PermissionManagerTests.swift | 4 +- .../RemotePortTunnelTests.swift | 2 +- .../RuntimeLocatorTests.swift | 2 +- .../ScreenshotSizeTests.swift | 2 +- .../Tests/ClawdbotIPCTests/SemverTests.swift | 2 +- .../ClawdbotIPCTests/SessionDataTests.swift | 2 +- .../SessionMenuPreviewTests.swift | 2 +- .../SettingsViewSmokeTests.swift | 4 +- .../SkillsSettingsSmokeTests.swift | 12 +- .../TailscaleIntegrationSectionTests.swift | 4 +- .../TalkAudioPlayerTests.swift | 2 +- .../ClawdbotIPCTests/TestIsolation.swift | 2 +- .../ClawdbotIPCTests/UtilitiesTests.swift | 10 +- .../VoicePushToTalkHotkeyTests.swift | 2 +- .../VoicePushToTalkTests.swift | 2 +- .../VoiceWakeForwarderTests.swift | 2 +- .../VoiceWakeGlobalSettingsSyncTests.swift | 8 +- .../VoiceWakeHelpersTests.swift | 2 +- .../VoiceWakeOverlayControllerTests.swift | 2 +- .../VoiceWakeOverlayTests.swift | 2 +- .../VoiceWakeOverlayViewSmokeTests.swift | 2 +- .../VoiceWakeRuntimeTests.swift | 2 +- .../WebChatMainSessionKeyTests.swift | 6 +- .../WebChatManagerTests.swift | 2 +- .../WebChatSwiftUISmokeTests.swift | 16 +- .../WideAreaGatewayDiscoveryTests.swift | 10 +- .../WindowPlacementTests.swift | 2 +- .../WorkActivityStoreTests.swift | 6 +- apps/shared/ClawdbotKit/Package.swift | 26 +- .../Sources/ClawdbotChatUI/ChatComposer.swift | 32 +- .../ChatMarkdownPreprocessor.swift | 6 +- .../ClawdbotChatUI/ChatMarkdownRenderer.swift | 2 +- .../ClawdbotChatUI/ChatMessageViews.swift | 50 +- .../Sources/ClawdbotChatUI/ChatModels.swift | 64 +- .../ClawdbotChatUI/ChatPayloadDecoding.swift | 2 +- .../Sources/ClawdbotChatUI/ChatSessions.swift | 10 +- .../Sources/ClawdbotChatUI/ChatSheets.swift | 2 +- .../Sources/ClawdbotChatUI/ChatTheme.swift | 10 +- .../ClawdbotChatUI/ChatTransport.swift | 24 +- .../Sources/ClawdbotChatUI/ChatView.swift | 32 +- .../ClawdbotChatUI/ChatViewModel.swift | 66 +-- .../Sources/ClawdbotKit/BonjourTypes.swift | 6 +- .../Sources/ClawdbotKit/BridgeFrames.swift | 4 +- .../Sources/ClawdbotKit/CameraCommands.swift | 28 +- .../ClawdbotKit/CanvasA2UIAction.swift | 4 +- .../ClawdbotKit/CanvasA2UICommands.swift | 6 +- .../Sources/ClawdbotKit/CanvasA2UIJSONL.swift | 2 +- .../ClawdbotKit/CanvasCommandParams.swift | 20 +- .../Sources/ClawdbotKit/CanvasCommands.swift | 2 +- .../Sources/ClawdbotKit/Capabilities.swift | 2 +- .../ClawdbotKit/ClawdbotKitResources.swift | 6 +- .../Sources/ClawdbotKit/DeepLinks.swift | 2 +- .../Sources/ClawdbotKit/DeviceIdentity.swift | 4 +- .../Sources/ClawdbotKit/GatewayChannel.swift | 6 +- .../Sources/ClawdbotKit/GatewayErrors.swift | 2 +- .../ClawdbotKit/GatewayNodeSession.swift | 4 +- .../ClawdbotKit/GatewayPayloadDecoding.swift | 6 +- .../Sources/ClawdbotKit/GatewayPush.swift | 2 +- .../ClawdbotKit/InstanceIdentity.swift | 4 +- .../ClawdbotKit/LocationCommands.swift | 12 +- .../ClawdbotKit/LocationSettings.swift | 2 +- .../Sources/ClawdbotKit/NodeError.swift | 8 +- .../Resources/CanvasScaffold/scaffold.html | 36 +- .../Sources/ClawdbotKit/ScreenCommands.swift | 4 +- .../Sources/ClawdbotKit/StoragePaths.swift | 10 +- .../Sources/ClawdbotKit/SystemCommands.swift | 20 +- .../Sources/ClawdbotKit/ToolDisplay.swift | 2 +- .../AssistantTextParserTests.swift | 2 +- .../BonjourEscapesTests.swift | 4 +- .../CanvasA2UIActionTests.swift | 20 +- .../ClawdbotKitTests/CanvasA2UITests.swift | 14 +- .../CanvasSnapshotFormatTests.swift | 4 +- .../ChatMarkdownPreprocessorTests.swift | 2 +- .../ClawdbotKitTests/ChatThemeTests.swift | 6 +- .../ClawdbotKitTests/ChatViewModelTests.swift | 94 +-- .../ElevenLabsTTSValidationTests.swift | 2 +- .../GatewayNodeSessionTests.swift | 4 +- .../JPEGTranscoderTests.swift | 2 +- .../ClawdbotKitTests/TalkDirectiveTests.swift | 2 +- .../TalkHistoryTimestampTests.swift | 2 +- .../TalkPromptBuilderTests.swift | 2 +- .../ToolDisplayRegistryTests.swift | 4 +- .../ClawdbotKit/Tools/CanvasA2UI/bootstrap.js | 43 +- .../Tools/CanvasA2UI/rolldown.config.mjs | 2 +- assets/chrome-extension/background.js | 10 +- assets/chrome-extension/manifest.json | 6 +- assets/chrome-extension/options.html | 8 +- assets/chrome-extension/options.js | 2 +- docker-compose.yml | 8 +- docker-setup.sh | 20 +- docs.acp.md | 44 +- docs/_config.yml | 4 +- docs/_layouts/default.html | 18 +- docs/assets/theme.js | 2 +- docs/automation/auth-monitoring.md | 14 +- docs/automation/cron-jobs.md | 26 +- docs/automation/cron-vs-heartbeat.md | 14 +- docs/automation/gmail-pubsub.md | 42 +- docs/automation/poll.md | 12 +- docs/automation/webhook.md | 10 +- docs/bedrock.md | 20 +- docs/brave-search.md | 2 +- docs/broadcast-groups.md | 6 +- docs/channels/bluebubbles.md | 24 +- docs/channels/discord.md | 26 +- docs/channels/googlechat.md | 28 +- docs/channels/imessage.md | 20 +- docs/channels/index.md | 8 +- docs/channels/line.md | 12 +- docs/channels/location.md | 2 +- docs/channels/matrix.md | 24 +- docs/channels/mattermost.md | 16 +- docs/channels/msteams.md | 50 +- docs/channels/nextcloud-talk.md | 14 +- docs/channels/nostr.md | 18 +- docs/channels/signal.md | 18 +- docs/channels/slack.md | 26 +- docs/channels/telegram.md | 44 +- docs/channels/tlon.md | 10 +- docs/channels/troubleshooting.md | 4 +- docs/channels/twitch.md | 22 +- docs/channels/whatsapp.md | 46 +- docs/channels/zalo.md | 16 +- docs/channels/zalouser.md | 24 +- docs/cli/acp.md | 48 +- docs/cli/agent.md | 12 +- docs/cli/agents.md | 18 +- docs/cli/approvals.md | 26 +- docs/cli/browser.md | 48 +- docs/cli/channels.md | 42 +- docs/cli/config.md | 30 +- docs/cli/configure.md | 12 +- docs/cli/cron.md | 10 +- docs/cli/dashboard.md | 8 +- docs/cli/devices.md | 26 +- docs/cli/directory.md | 24 +- docs/cli/dns.md | 10 +- docs/cli/docs.md | 10 +- docs/cli/doctor.md | 12 +- docs/cli/gateway.md | 48 +- docs/cli/health.md | 10 +- docs/cli/hooks.md | 54 +- docs/cli/index.md | 78 +-- docs/cli/logs.md | 12 +- docs/cli/memory.md | 22 +- docs/cli/message.md | 22 +- docs/cli/models.md | 30 +- docs/cli/node.md | 24 +- docs/cli/nodes.md | 28 +- docs/cli/onboard.md | 14 +- docs/cli/pairing.md | 8 +- docs/cli/plugins.md | 32 +- docs/cli/reset.md | 10 +- docs/cli/sandbox.md | 56 +- docs/cli/security.md | 10 +- docs/cli/sessions.md | 10 +- docs/cli/setup.md | 12 +- docs/cli/skills.md | 12 +- docs/cli/status.md | 14 +- docs/cli/system.md | 12 +- docs/cli/tui.md | 10 +- docs/cli/uninstall.md | 10 +- docs/cli/update.md | 40 +- docs/cli/voicecall.md | 18 +- docs/cli/webhooks.md | 10 +- docs/concepts/agent-loop.md | 10 +- docs/concepts/agent-workspace.md | 22 +- docs/concepts/agent.md | 20 +- docs/concepts/architecture.md | 2 +- docs/concepts/channel-routing.md | 4 +- docs/concepts/compaction.md | 10 +- docs/concepts/context.md | 12 +- docs/concepts/group-messages.md | 10 +- docs/concepts/groups.md | 10 +- docs/concepts/markdown-formatting.md | 2 +- docs/concepts/memory.md | 24 +- docs/concepts/messages.md | 8 +- docs/concepts/model-failover.md | 22 +- docs/concepts/model-providers.md | 42 +- docs/concepts/models.md | 46 +- docs/concepts/multi-agent.md | 10 +- docs/concepts/oauth.md | 36 +- docs/concepts/presence.md | 4 +- docs/concepts/retry.md | 2 +- docs/concepts/session-pruning.md | 2 +- docs/concepts/session-tool.md | 8 +- docs/concepts/session.md | 22 +- docs/concepts/streaming.md | 6 +- docs/concepts/system-prompt.md | 22 +- docs/concepts/timezone.md | 4 +- docs/concepts/typebox.md | 4 +- docs/concepts/typing-indicators.md | 4 +- docs/concepts/usage-tracking.md | 6 +- docs/date-time.md | 4 +- docs/debug/node-issue.md | 8 +- docs/debugging.md | 18 +- docs/diagnostics/flags.md | 10 +- docs/docs.json | 6 +- docs/environment.md | 6 +- docs/experiments/plans/cron-add-hardening.md | 2 +- .../plans/openresponses-gateway.md | 4 +- docs/experiments/research/memory.md | 12 +- docs/gateway/authentication.md | 38 +- docs/gateway/background-process.md | 2 +- docs/gateway/bonjour.md | 42 +- docs/gateway/bridge-protocol.md | 4 +- docs/gateway/cli-backends.md | 24 +- docs/gateway/configuration-examples.md | 20 +- docs/gateway/configuration.md | 176 +++--- docs/gateway/discovery.md | 12 +- docs/gateway/doctor.md | 42 +- docs/gateway/gateway-lock.md | 2 +- docs/gateway/health.md | 18 +- docs/gateway/heartbeat.md | 10 +- docs/gateway/index.md | 96 +-- docs/gateway/local-models.md | 4 +- docs/gateway/logging.md | 16 +- docs/gateway/multiple-gateways.md | 32 +- docs/gateway/openai-http-api.md | 20 +- docs/gateway/openresponses-http-api.md | 20 +- docs/gateway/pairing.md | 10 +- docs/gateway/protocol.md | 6 +- docs/gateway/remote-gateway-readme.md | 16 +- docs/gateway/remote.md | 6 +- .../sandbox-vs-tool-policy-vs-elevated.md | 14 +- docs/gateway/sandboxing.md | 10 +- docs/gateway/security/formal-verification.md | 14 +- docs/gateway/security/index.md | 60 +- docs/gateway/tailscale.md | 14 +- docs/gateway/tools-invoke-http-api.md | 6 +- docs/gateway/troubleshooting.md | 192 +++--- docs/help/faq.md | 548 +++++++++--------- docs/help/troubleshooting.md | 20 +- docs/hooks.md | 86 +-- docs/hooks/soul-evil.md | 4 +- docs/index.md | 66 +-- docs/install/ansible.md | 70 +-- docs/install/development-channels.md | 20 +- docs/install/docker.md | 54 +- docs/install/index.md | 40 +- docs/install/installer.md | 22 +- docs/install/migrating.md | 34 +- docs/install/nix.md | 32 +- docs/install/node.md | 8 +- docs/install/uninstall.md | 42 +- docs/install/updating.md | 12 +- docs/logging.md | 116 ++-- docs/multi-agent-sandbox-tools.md | 10 +- docs/network.md | 2 +- docs/nodes/audio.md | 4 +- docs/nodes/camera.md | 36 +- docs/nodes/images.md | 8 +- docs/nodes/index.md | 100 ++-- docs/nodes/location-command.md | 4 +- docs/nodes/media-understanding.md | 10 +- docs/nodes/talk.md | 2 +- docs/nodes/voicewake.md | 2 +- docs/northflank.mdx | 18 +- docs/perplexity.md | 4 +- docs/platforms/android.md | 26 +- docs/platforms/digitalocean.md | 46 +- docs/platforms/exe-dev.md | 46 +- docs/platforms/fly.md | 46 +- docs/platforms/gcp.md | 70 +-- docs/platforms/hetzner.md | 40 +- docs/platforms/index.md | 14 +- docs/platforms/ios.md | 26 +- docs/platforms/linux.md | 22 +- docs/platforms/mac/bundled-gateway.md | 22 +- docs/platforms/mac/canvas.md | 28 +- docs/platforms/mac/child-process.md | 2 +- docs/platforms/mac/dev-setup.md | 20 +- docs/platforms/mac/health.md | 4 +- docs/platforms/mac/icon.md | 2 +- docs/platforms/mac/logging.md | 8 +- docs/platforms/mac/menu-bar.md | 2 +- docs/platforms/mac/peekaboo.md | 18 +- docs/platforms/mac/permissions.md | 2 +- docs/platforms/mac/release.md | 32 +- docs/platforms/mac/remote.md | 28 +- docs/platforms/mac/signing.md | 12 +- docs/platforms/mac/skills.md | 4 +- docs/platforms/mac/webchat.md | 2 +- docs/platforms/mac/xpc.md | 8 +- docs/platforms/macos-vm.md | 54 +- docs/platforms/macos.md | 28 +- docs/platforms/oracle.md | 62 +- docs/platforms/raspberry-pi.md | 42 +- docs/platforms/windows.md | 22 +- docs/plugin.md | 114 ++-- docs/plugins/agent-tools.md | 2 +- docs/plugins/manifest.md | 8 +- docs/plugins/voice-call.md | 24 +- docs/plugins/zalouser.md | 18 +- docs/prose.md | 18 +- docs/providers/anthropic.md | 32 +- docs/providers/claude-max-api-proxy.md | 8 +- docs/providers/deepgram.md | 4 +- docs/providers/github-copilot.md | 22 +- docs/providers/glm.md | 8 +- docs/providers/index.md | 6 +- docs/providers/minimax.md | 18 +- docs/providers/models.md | 6 +- docs/providers/moonshot.md | 4 +- docs/providers/ollama.md | 22 +- docs/providers/openai.md | 12 +- docs/providers/opencode.md | 6 +- docs/providers/openrouter.md | 6 +- docs/providers/qwen.md | 12 +- docs/providers/synthetic.md | 8 +- docs/providers/venice.md | 42 +- docs/providers/vercel-ai-gateway.md | 6 +- docs/providers/zai.md | 10 +- docs/railway.mdx | 10 +- docs/refactor/plugin-sdk.md | 20 +- docs/refactor/strict-config.md | 22 +- docs/reference/AGENTS.default.md | 20 +- docs/reference/RELEASING.md | 50 +- docs/reference/api-usage-costs.md | 12 +- docs/reference/device-models.md | 14 +- docs/reference/rpc.md | 6 +- .../session-management-compaction.md | 34 +- docs/reference/templates/AGENTS.dev.md | 2 +- docs/reference/templates/BOOT.md | 2 +- docs/reference/templates/TOOLS.dev.md | 2 +- docs/reference/templates/USER.dev.md | 4 +- docs/reference/test.md | 4 +- docs/reference/transcript-hygiene.md | 2 +- docs/render.mdx | 18 +- docs/scripts.md | 2 +- docs/security/formal-verification.md | 14 +- docs/start/clawd.md | 54 +- docs/start/getting-started.md | 46 +- docs/start/hubs.md | 4 +- docs/start/onboarding.md | 8 +- docs/start/pairing.md | 16 +- docs/start/setup.md | 30 +- docs/start/showcase.md | 64 +- docs/start/wizard.md | 44 +- docs/testing.md | 20 +- docs/token-use.md | 14 +- docs/tools/agent-send.md | 20 +- docs/tools/browser-linux-troubleshooting.md | 16 +- docs/tools/browser-login.md | 8 +- docs/tools/browser.md | 214 +++---- docs/tools/chrome-extension.md | 32 +- docs/tools/clawdhub.md | 14 +- docs/tools/creating-skills.md | 8 +- docs/tools/exec-approvals.md | 4 +- docs/tools/exec.md | 6 +- docs/tools/firecrawl.md | 4 +- docs/tools/index.md | 24 +- docs/tools/llm-task.md | 2 +- docs/tools/lobster.md | 16 +- docs/tools/skills-config.md | 2 +- docs/tools/skills.md | 42 +- docs/tools/slash-commands.md | 14 +- docs/tools/web.md | 12 +- docs/tts.md | 18 +- docs/tui.md | 14 +- docs/vps.md | 2 +- docs/web/control-ui.md | 16 +- docs/web/dashboard.md | 8 +- docs/web/index.md | 8 +- extensions/bluebubbles/index.ts | 4 +- extensions/bluebubbles/package.json | 4 +- extensions/bluebubbles/src/accounts.ts | 16 +- extensions/bluebubbles/src/actions.test.ts | 44 +- extensions/bluebubbles/src/actions.ts | 10 +- extensions/bluebubbles/src/attachments.ts | 4 +- extensions/bluebubbles/src/channel.ts | 32 +- extensions/bluebubbles/src/chat.ts | 4 +- extensions/bluebubbles/src/media-send.ts | 4 +- extensions/bluebubbles/src/monitor.test.ts | 94 +-- extensions/bluebubbles/src/monitor.ts | 10 +- extensions/bluebubbles/src/onboarding.ts | 14 +- extensions/bluebubbles/src/reactions.ts | 4 +- extensions/bluebubbles/src/send.ts | 4 +- extensions/copilot-proxy/package.json | 4 +- extensions/diagnostics-otel/index.ts | 4 +- extensions/diagnostics-otel/package.json | 4 +- .../diagnostics-otel/src/service.test.ts | 24 +- extensions/diagnostics-otel/src/service.ts | 168 +++--- extensions/discord/index.ts | 4 +- extensions/discord/package.json | 4 +- extensions/google-antigravity-auth/index.ts | 2 +- .../google-antigravity-auth/package.json | 4 +- extensions/google-gemini-cli-auth/oauth.ts | 4 +- .../google-gemini-cli-auth/package.json | 4 +- extensions/googlechat/index.ts | 6 +- extensions/googlechat/package.json | 8 +- extensions/googlechat/src/accounts.ts | 16 +- extensions/googlechat/src/actions.ts | 12 +- extensions/googlechat/src/api.ts | 2 +- extensions/googlechat/src/channel.ts | 42 +- extensions/googlechat/src/monitor.ts | 16 +- extensions/googlechat/src/onboarding.ts | 20 +- extensions/imessage/index.ts | 4 +- extensions/imessage/package.json | 4 +- extensions/line/index.ts | 4 +- extensions/line/package.json | 6 +- extensions/line/src/card-command.ts | 4 +- extensions/line/src/channel.logout.test.ts | 8 +- .../line/src/channel.sendPayload.test.ts | 16 +- extensions/line/src/channel.ts | 8 +- extensions/llm-task/index.ts | 4 +- extensions/llm-task/package.json | 4 +- extensions/llm-task/src/llm-task-tool.ts | 10 +- extensions/lobster/index.ts | 4 +- extensions/lobster/package.json | 2 +- extensions/lobster/src/lobster-tool.test.ts | 14 +- extensions/lobster/src/lobster-tool.ts | 4 +- extensions/matrix/CHANGELOG.md | 18 +- extensions/matrix/index.ts | 4 +- extensions/matrix/package.json | 6 +- extensions/matrix/src/matrix/client/config.ts | 2 +- .../matrix/src/matrix/monitor/handler.ts | 4 +- extensions/matrix/src/onboarding.ts | 2 +- extensions/mattermost/index.ts | 4 +- extensions/mattermost/package.json | 4 +- .../mattermost/src/mattermost/accounts.ts | 16 +- .../src/mattermost/monitor-helpers.ts | 10 +- .../mattermost/src/mattermost/monitor.ts | 4 +- .../mattermost/src/onboarding-helpers.ts | 6 +- extensions/mattermost/src/onboarding.ts | 4 +- extensions/memory-core/index.ts | 4 +- extensions/memory-core/package.json | 6 +- extensions/memory-lancedb/index.test.ts | 4 +- extensions/memory-lancedb/index.ts | 6 +- extensions/memory-lancedb/package.json | 4 +- extensions/msteams/CHANGELOG.md | 14 +- extensions/msteams/index.ts | 4 +- extensions/msteams/package.json | 6 +- .../msteams/src/channel.directory.test.ts | 4 +- extensions/msteams/src/channel.ts | 4 +- .../msteams/src/conversation-store-fs.test.ts | 2 +- extensions/msteams/src/graph-upload.ts | 8 +- extensions/msteams/src/monitor-handler.ts | 4 +- extensions/msteams/src/monitor.ts | 4 +- extensions/msteams/src/onboarding.ts | 18 +- extensions/msteams/src/polls-store.test.ts | 2 +- extensions/msteams/src/polls.test.ts | 4 +- extensions/msteams/src/polls.ts | 16 +- extensions/msteams/src/reply-dispatcher.ts | 4 +- extensions/msteams/src/send-context.ts | 4 +- extensions/msteams/src/send.ts | 8 +- extensions/nextcloud-talk/index.ts | 4 +- extensions/nextcloud-talk/package.json | 4 +- extensions/nextcloud-talk/src/channel.ts | 14 +- extensions/nextcloud-talk/src/inbound.ts | 14 +- extensions/nextcloud-talk/src/onboarding.ts | 2 +- extensions/nostr/CHANGELOG.md | 8 +- extensions/nostr/index.ts | 10 +- extensions/nostr/package.json | 6 +- extensions/nostr/src/channel.ts | 2 +- .../nostr/src/nostr-state-store.test.ts | 2 +- extensions/nostr/src/types.ts | 8 +- extensions/open-prose/index.ts | 4 +- extensions/open-prose/package.json | 2 +- extensions/open-prose/skills/prose/SKILL.md | 10 +- extensions/open-prose/skills/prose/prose.md | 8 +- extensions/signal/index.ts | 4 +- extensions/signal/package.json | 4 +- extensions/slack/index.ts | 4 +- extensions/slack/package.json | 4 +- extensions/telegram/index.ts | 4 +- extensions/telegram/package.json | 4 +- extensions/telegram/src/channel.ts | 4 +- extensions/tlon/index.ts | 4 +- extensions/tlon/package.json | 4 +- extensions/tlon/src/channel.ts | 26 +- extensions/tlon/src/monitor/index.ts | 6 +- extensions/tlon/src/onboarding.ts | 6 +- extensions/tlon/src/types.ts | 6 +- extensions/twitch/CHANGELOG.md | 2 +- extensions/twitch/index.ts | 4 +- extensions/twitch/package.json | 6 +- extensions/twitch/src/actions.ts | 2 +- extensions/twitch/src/config.ts | 6 +- extensions/twitch/src/monitor.ts | 6 +- extensions/twitch/src/onboarding.ts | 18 +- extensions/twitch/src/outbound.test.ts | 4 +- extensions/twitch/src/outbound.ts | 4 +- extensions/twitch/src/plugin.test.ts | 4 +- extensions/twitch/src/plugin.ts | 16 +- extensions/twitch/src/send.test.ts | 4 +- extensions/twitch/src/send.ts | 10 +- extensions/twitch/src/token.test.ts | 16 +- extensions/twitch/src/token.ts | 6 +- extensions/twitch/src/twitch-client.ts | 6 +- extensions/twitch/src/types.ts | 6 +- extensions/twitch/src/utils/markdown.ts | 2 +- extensions/voice-call/CHANGELOG.md | 22 +- extensions/voice-call/package.json | 4 +- extensions/voice-call/src/core-bridge.ts | 6 +- extensions/voice-call/src/manager.test.ts | 4 +- .../voice-call/src/response-generator.ts | 2 +- extensions/whatsapp/index.ts | 4 +- extensions/whatsapp/package.json | 4 +- extensions/zalo/CHANGELOG.md | 18 +- extensions/zalo/index.ts | 4 +- extensions/zalo/package.json | 6 +- extensions/zalo/src/accounts.ts | 16 +- extensions/zalo/src/actions.ts | 8 +- extensions/zalo/src/channel.directory.test.ts | 4 +- extensions/zalo/src/channel.ts | 36 +- extensions/zalo/src/monitor.ts | 18 +- extensions/zalo/src/monitor.webhook.test.ts | 4 +- extensions/zalo/src/onboarding.ts | 48 +- extensions/zalo/src/send.ts | 4 +- extensions/zalouser/CHANGELOG.md | 8 +- extensions/zalouser/index.ts | 4 +- extensions/zalouser/package.json | 6 +- extensions/zalouser/src/accounts.ts | 18 +- extensions/zalouser/src/channel.ts | 48 +- extensions/zalouser/src/monitor.ts | 8 +- extensions/zalouser/src/onboarding.ts | 56 +- extensions/zalouser/src/status-issues.ts | 2 +- fly.private.toml | 6 +- fly.toml | 6 +- package.json | 16 +- packages/clawdbot/package.json | 4 +- render.yaml | 4 +- scripts/auth-monitor.sh | 18 +- scripts/build-and-run-mac.sh | 6 +- scripts/build_icon.sh | 6 +- scripts/changelog-to-html.sh | 10 +- scripts/claude-auth-status.sh | 38 +- scripts/clawlog.sh | 6 +- scripts/codesign-mac-app.sh | 12 +- scripts/create-dmg.sh | 14 +- scripts/debug-claude-usage.ts | 2 +- scripts/docker/cleanup-smoke/Dockerfile | 6 +- scripts/docker/cleanup-smoke/run.sh | 8 +- scripts/docker/install-sh-e2e/Dockerfile | 6 +- scripts/docker/install-sh-e2e/run.sh | 30 +- scripts/docker/install-sh-nonroot/Dockerfile | 6 +- scripts/docker/install-sh-nonroot/run.sh | 14 +- scripts/docker/install-sh-smoke/Dockerfile | 6 +- scripts/docker/install-sh-smoke/run.sh | 12 +- scripts/e2e/doctor-install-switch-docker.sh | 22 +- scripts/e2e/gateway-network-docker.sh | 6 +- scripts/e2e/onboard-docker.sh | 30 +- scripts/e2e/plugins-docker.sh | 22 +- scripts/e2e/qr-import-docker.sh | 2 +- scripts/make_appcast.sh | 8 +- scripts/mobile-reauth.sh | 8 +- scripts/notarize-mac-artifact.sh | 2 +- scripts/package-mac-app.sh | 44 +- scripts/package-mac-dist.sh | 14 +- scripts/protocol-gen.ts | 4 +- scripts/release-check.ts | 2 +- scripts/restart-mac.sh | 42 +- scripts/run-node.mjs | 2 +- scripts/sandbox-browser-entrypoint.sh | 2 +- scripts/sandbox-browser-setup.sh | 2 +- scripts/sandbox-common-setup.sh | 6 +- scripts/sandbox-setup.sh | 2 +- scripts/setup-auth-system.sh | 18 +- scripts/sync-plugin-versions.ts | 2 +- scripts/systemd/clawdbot-auth-monitor.service | 6 +- scripts/systemd/clawdbot-auth-monitor.timer | 2 +- scripts/termux-auth-widget.sh | 14 +- scripts/termux-quick-auth.sh | 4 +- scripts/termux-sync-widget.sh | 14 +- scripts/test-cleanup-docker.sh | 2 +- scripts/test-force.ts | 2 +- scripts/test-install-sh-docker.sh | 4 +- scripts/test-install-sh-e2e-docker.sh | 2 +- scripts/test-live-gateway-models-docker.sh | 2 +- scripts/test-live-models-docker.sh | 2 +- scripts/update-clawtributors.ts | 2 +- scripts/zai-fallback-repro.ts | 8 +- src/acp/client.ts | 10 +- src/acp/server.ts | 2 +- src/acp/types.ts | 4 +- src/agents/agent-paths.test.ts | 12 +- src/agents/agent-paths.ts | 6 +- src/agents/agent-scope.test.ts | 22 +- src/agents/agent-scope.ts | 26 +- src/agents/anthropic.setup-token.live.test.ts | 10 +- src/agents/apply-patch.test.ts | 2 +- src/agents/auth-health.ts | 6 +- src/agents/auth-profiles.chutes.test.ts | 2 +- ...th-profiles.ensureauthprofilestore.test.ts | 4 +- ...th-profiles.markauthprofilefailure.test.ts | 6 +- src/agents/auth-profiles/display.ts | 4 +- src/agents/auth-profiles/doctor.ts | 6 +- .../oauth.fallback-to-main-agent.test.ts | 2 +- src/agents/auth-profiles/oauth.ts | 6 +- src/agents/auth-profiles/order.ts | 4 +- src/agents/auth-profiles/paths.ts | 6 +- src/agents/auth-profiles/repair.ts | 8 +- .../auth-profiles/session-override.test.ts | 6 +- src/agents/auth-profiles/session-override.ts | 4 +- src/agents/auth-profiles/types.ts | 6 +- src/agents/auth-profiles/usage.ts | 6 +- .../bash-tools.exec.approval-id.test.ts | 4 +- src/agents/bash-tools.test.ts | 2 +- src/agents/bootstrap-files.test.ts | 4 +- src/agents/bootstrap-files.ts | 6 +- src/agents/bootstrap-hooks.ts | 4 +- src/agents/cache-trace.test.ts | 4 +- src/agents/cache-trace.ts | 4 +- src/agents/channel-tools.ts | 16 +- src/agents/claude-cli-runner.test.ts | 4 +- src/agents/clawdbot-gateway-tool.test.ts | 12 +- src/agents/clawdbot-tools.agents.test.ts | 10 +- src/agents/clawdbot-tools.camera.test.ts | 8 +- .../clawdbot-tools.session-status.test.ts | 18 +- src/agents/clawdbot-tools.sessions.test.ts | 18 +- ...ws-cross-agent-spawning-configured.test.ts | 8 +- ...ounces-agent-wait-lifecycle-events.test.ts | 6 +- ...-spawn-applies-model-child-session.test.ts | 12 +- ...n-normalizes-allowlisted-agent-ids.test.ts | 12 +- ...n-prefers-per-agent-subagent-model.test.ts | 10 +- ...resolves-main-announce-target-from.test.ts | 8 +- src/agents/cli-backends.ts | 6 +- src/agents/cli-credentials.test.ts | 6 +- src/agents/cli-runner.ts | 10 +- src/agents/cli-runner/helpers.ts | 12 +- src/agents/context-window-guard.test.ts | 6 +- src/agents/context-window-guard.ts | 4 +- src/agents/context.ts | 8 +- src/agents/docs-path.ts | 6 +- src/agents/identity-avatar.test.ts | 16 +- src/agents/identity-avatar.ts | 6 +- src/agents/identity.test.ts | 6 +- src/agents/identity.ts | 23 +- src/agents/memory-search.ts | 4 +- src/agents/minimax-vlm.ts | 2 +- src/agents/model-auth.test.ts | 4 +- src/agents/model-auth.ts | 16 +- src/agents/model-catalog.test.ts | 10 +- src/agents/model-catalog.ts | 12 +- src/agents/model-fallback.test.ts | 14 +- src/agents/model-fallback.ts | 12 +- src/agents/model-selection.test.ts | 14 +- src/agents/model-selection.ts | 22 +- ...s-github-copilot-provider-token-is.test.ts | 14 +- ...fault-baseurl-token-exchange-fails.test.ts | 18 +- ...ssing-provider-apikey-from-env-var.test.ts | 24 +- ...ini-3-ids-preview-google-providers.test.ts | 16 +- src/agents/models-config.providers.ts | 14 +- ...s-writing-models-json-no-env-token.test.ts | 34 +- src/agents/models-config.ts | 12 +- ...-github-copilot-profile-env-tokens.test.ts | 18 +- src/agents/models.profiles.live.test.ts | 8 +- .../{clawdbot-tools.ts => moltbot-tools.ts} | 6 +- ...d-helpers.resolvebootstrapmaxchars.test.ts | 6 +- src/agents/pi-embedded-helpers/bootstrap.ts | 4 +- src/agents/pi-embedded-helpers/errors.ts | 4 +- src/agents/pi-embedded-helpers/openai.ts | 2 +- ...i-embedded-runner-extraparams.live.test.ts | 4 +- ...-runner.applygoogleturnorderingfix.test.ts | 10 +- ...ed-runner.buildembeddedsandboxinfo.test.ts | 36 +- ...-runner.createsystempromptoverride.test.ts | 10 +- ...s-back-provider-default-per-dm-not.test.ts | 20 +- ...-undefined-sessionkey-is-undefined.test.ts | 32 +- ...-embedded-runner.limithistoryturns.test.ts | 10 +- ...dded-runner.resolvesessionagentids.test.ts | 12 +- ...ded-pi-agent.auth-profile-rotation.test.ts | 38 +- .../pi-embedded-runner.splitsdktools.test.ts | 10 +- src/agents/pi-embedded-runner.test.ts | 12 +- src/agents/pi-embedded-runner/cache-ttl.ts | 2 +- src/agents/pi-embedded-runner/compact.ts | 20 +- src/agents/pi-embedded-runner/extensions.ts | 10 +- src/agents/pi-embedded-runner/extra-params.ts | 6 +- src/agents/pi-embedded-runner/history.ts | 6 +- src/agents/pi-embedded-runner/model.ts | 10 +- .../run.overflow-compaction.test.ts | 4 +- src/agents/pi-embedded-runner/run.ts | 8 +- src/agents/pi-embedded-runner/run/attempt.ts | 12 +- src/agents/pi-embedded-runner/run/params.ts | 4 +- src/agents/pi-embedded-runner/run/payloads.ts | 4 +- src/agents/pi-embedded-runner/run/types.ts | 4 +- src/agents/pi-embedded-runner/utils.ts | 6 +- src/agents/pi-settings.ts | 4 +- src/agents/pi-tools-agent-config.test.ts | 70 +-- ...aliases-schemas-without-dropping-b.test.ts | 24 +- ...aliases-schemas-without-dropping-d.test.ts | 40 +- ...aliases-schemas-without-dropping-f.test.ts | 20 +- ...e-aliases-schemas-without-dropping.test.ts | 28 +- src/agents/pi-tools.policy.ts | 8 +- src/agents/pi-tools.read.ts | 4 +- src/agents/pi-tools.safe-bins.test.ts | 12 +- src/agents/pi-tools.ts | 16 +- src/agents/pi-tools.workspace-paths.test.ts | 46 +- ...n-status-default-sandbox-allowlist.test.ts | 8 +- ...nt-specific-docker-settings-beyond.test.ts | 10 +- ...d-use-agent-specific-workspaceroot.test.ts | 8 +- ...use-global-sandbox-config-no-agent.test.ts | 8 +- src/agents/sandbox-create-args.test.ts | 34 +- src/agents/sandbox-explain.test.ts | 10 +- src/agents/sandbox-skills.test.ts | 8 +- .../sandbox.resolveSandboxContext.test.ts | 20 +- src/agents/sandbox/browser.ts | 2 +- src/agents/sandbox/config.ts | 7 +- src/agents/sandbox/constants.ts | 14 +- src/agents/sandbox/context.ts | 6 +- src/agents/sandbox/docker.ts | 16 +- src/agents/sandbox/runtime-status.ts | 18 +- src/agents/sandbox/tool-policy.ts | 4 +- ...ult-guard.tool-result-persist-hook.test.ts | 8 +- src/agents/session-transcript-repair.ts | 2 +- src/agents/session-write-lock.test.ts | 12 +- src/agents/shell-utils.test.ts | 2 +- src/agents/skills-install.ts | 6 +- src/agents/skills-status.ts | 30 +- .../skills.applyskillenvoverrides.test.ts | 8 +- ...without-affecting-workspace-skills.test.ts | 2 +- ...rs-workspace-skills-managed-skills.test.ts | 18 +- ...pty-prompt-skills-dirs-are-missing.test.ts | 8 +- ...erged-skills-into-target-workspace.test.ts | 10 +- ...skills.buildworkspaceskillcommands.test.ts | 6 +- ...skills.buildworkspaceskillsnapshot.test.ts | 4 +- .../skills.buildworkspaceskillstatus.test.ts | 14 +- .../skills.loadworkspaceskillentries.test.ts | 10 +- .../skills.resolveskillspromptforrun.test.ts | 2 +- src/agents/skills.ts | 6 +- src/agents/skills/config.ts | 28 +- src/agents/skills/env-overrides.ts | 8 +- src/agents/skills/frontmatter.ts | 37 +- src/agents/skills/plugin-skills.ts | 4 +- src/agents/skills/refresh.ts | 6 +- src/agents/skills/types.ts | 4 +- src/agents/skills/workspace.ts | 34 +- .../subagent-registry.persistence.test.ts | 8 +- src/agents/subagent-registry.store.ts | 4 +- src/agents/system-prompt-params.test.ts | 10 +- src/agents/system-prompt-params.ts | 6 +- src/agents/system-prompt.test.ts | 14 +- src/agents/system-prompt.ts | 38 +- src/agents/timeout.ts | 6 +- src/agents/tool-images.ts | 2 +- src/agents/tool-policy.test.ts | 4 +- src/agents/tool-policy.ts | 4 +- src/agents/tools/browser-tool.ts | 8 +- src/agents/tools/discord-actions.ts | 4 +- src/agents/tools/gateway-tool.ts | 4 +- src/agents/tools/image-tool.helpers.ts | 6 +- src/agents/tools/image-tool.test.ts | 38 +- src/agents/tools/image-tool.ts | 18 +- src/agents/tools/memory-tool.ts | 6 +- src/agents/tools/message-tool.ts | 8 +- src/agents/tools/nodes-tool.ts | 4 +- src/agents/tools/session-status-tool.ts | 10 +- src/agents/tools/sessions-helpers.ts | 6 +- src/agents/tools/sessions-send-helpers.ts | 4 +- src/agents/tools/slack-actions.test.ts | 46 +- src/agents/tools/slack-actions.ts | 4 +- src/agents/tools/telegram-actions.test.ts | 48 +- src/agents/tools/telegram-actions.ts | 4 +- src/agents/tools/tts-tool.ts | 4 +- src/agents/tools/web-fetch.ts | 8 +- src/agents/tools/web-search.ts | 12 +- src/agents/tools/whatsapp-actions.test.ts | 6 +- src/agents/tools/whatsapp-actions.ts | 4 +- src/agents/workspace.test.ts | 6 +- src/auto-reply/chunk.ts | 6 +- src/auto-reply/command-auth.ts | 12 +- src/auto-reply/command-control.test.ts | 18 +- src/auto-reply/command-detection.ts | 8 +- src/auto-reply/commands-registry.data.ts | 2 +- src/auto-reply/commands-registry.test.ts | 12 +- src/auto-reply/commands-registry.ts | 22 +- src/auto-reply/commands-registry.types.ts | 6 +- src/auto-reply/dispatch.ts | 8 +- src/auto-reply/envelope.ts | 4 +- src/auto-reply/inbound-debounce.ts | 4 +- src/auto-reply/inbound.test.ts | 14 +- src/auto-reply/reply.block-streaming.test.ts | 2 +- ...ts-thinking-xhigh-codex-models.e2e.test.ts | 2 +- ...ixed-messages-acks-immediately.e2e.test.ts | 2 +- ...ow-reasoning-capable-models-no.e2e.test.ts | 2 +- ...nline-model-uses-default-model.e2e.test.ts | 2 +- ...-allowlisted-models-model-list.e2e.test.ts | 2 +- ...s-fuzzy-selection-is-ambiguous.e2e.test.ts | 2 +- ...gent-allowlist-addition-global.e2e.test.ts | 2 +- ...-alongside-directive-only-acks.e2e.test.ts | 2 +- ...nt-elevated-level-as-off-after.e2e.test.ts | 2 +- ...t-verbose-level-verbose-has-no.e2e.test.ts | 2 +- ...-model-matches-model-directive.e2e.test.ts | 2 +- ...rbose-during-flight-run-toggle.e2e.test.ts | 2 +- src/auto-reply/reply.heartbeat-typing.test.ts | 2 +- src/auto-reply/reply.media-note.test.ts | 2 +- src/auto-reply/reply.queue.test.ts | 2 +- src/auto-reply/reply.raw-body.test.ts | 2 +- ...y.triggers.group-intro-prompts.e2e.test.ts | 2 +- ...tivation-from-allowfrom-groups.e2e.test.ts | 4 +- ...ed-sender-toggle-elevated-mode.e2e.test.ts | 2 +- ...ted-off-groups-without-mention.e2e.test.ts | 2 +- ...summary-current-model-provider.e2e.test.ts | 2 +- ...ommands-strips-it-before-agent.e2e.test.ts | 2 +- ...ed-directive-unapproved-sender.e2e.test.ts | 2 +- ...or-cause-embedded-agent-throws.e2e.test.ts | 4 +- ...ne-status-unauthorized-senders.e2e.test.ts | 2 +- ...uth-profile-key-snippet-status.e2e.test.ts | 2 +- ....runs-compact-as-gated-command.e2e.test.ts | 4 +- ...uns-greeting-prompt-bare-reset.e2e.test.ts | 8 +- ...lt-model-status-not-configured.e2e.test.ts | 4 +- ...-model-picker-grouped-by-model.e2e.test.ts | 2 +- ...bound-media-into-sandbox-workspace.test.ts | 2 +- ...ets-active-session-native-stop.e2e.test.ts | 2 +- src/auto-reply/reply/abort.test.ts | 18 +- src/auto-reply/reply/abort.ts | 8 +- .../reply/agent-runner-execution.ts | 2 +- src/auto-reply/reply/agent-runner-memory.ts | 4 +- .../reply/agent-runner-utils.test.ts | 6 +- src/auto-reply/reply/agent-runner-utils.ts | 4 +- ...emini-sessions-deletes-transcripts.test.ts | 4 +- ...ction-failure-by-resetting-session.test.ts | 6 +- ...tbeat.signals-typing-block-replies.test.ts | 2 +- ...eplies-even-if-session-reset-fails.test.ts | 2 +- ...n-count-flush-compaction-completes.test.ts | 2 +- ...lush-turn-updates-session-metadata.test.ts | 4 +- ...h.skips-memory-flush-cli-providers.test.ts | 2 +- ...ry-flush-sandbox-workspace-is-read.test.ts | 4 +- ...nfigured-prompts-memory-flush-runs.test.ts | 4 +- .../agent-runner.messaging-tools.test.ts | 2 +- src/auto-reply/reply/bash-command.ts | 10 +- src/auto-reply/reply/block-streaming.ts | 8 +- src/auto-reply/reply/commands-allowlist.ts | 8 +- src/auto-reply/reply/commands-approve.test.ts | 8 +- src/auto-reply/reply/commands-compact.ts | 4 +- .../reply/commands-context-report.ts | 4 +- src/auto-reply/reply/commands-context.ts | 4 +- src/auto-reply/reply/commands-models.ts | 4 +- src/auto-reply/reply/commands-parsing.test.ts | 6 +- src/auto-reply/reply/commands-policy.test.ts | 12 +- src/auto-reply/reply/commands-session.ts | 8 +- src/auto-reply/reply/commands-status.ts | 6 +- src/auto-reply/reply/commands-types.ts | 4 +- src/auto-reply/reply/commands.test.ts | 48 +- .../reply/directive-handling.auth.ts | 6 +- .../reply/directive-handling.fast-lane.ts | 6 +- .../reply/directive-handling.impl.ts | 6 +- .../reply/directive-handling.model-picker.ts | 4 +- .../reply/directive-handling.model.test.ts | 10 +- .../reply/directive-handling.model.ts | 8 +- .../reply/directive-handling.parse.ts | 4 +- .../reply/directive-handling.persist.ts | 8 +- .../directive-handling.queue-validation.ts | 4 +- .../reply/directive-handling.shared.ts | 2 +- .../reply/dispatch-from-config.test.ts | 26 +- src/auto-reply/reply/dispatch-from-config.ts | 6 +- src/auto-reply/reply/followup-runner.test.ts | 4 +- .../reply/get-reply-directives-apply.ts | 6 +- src/auto-reply/reply/get-reply-directives.ts | 6 +- .../reply/get-reply-inline-actions.ts | 8 +- src/auto-reply/reply/get-reply-run.ts | 8 +- src/auto-reply/reply/get-reply.ts | 4 +- src/auto-reply/reply/groups.ts | 8 +- src/auto-reply/reply/memory-flush.ts | 4 +- src/auto-reply/reply/mentions.ts | 8 +- .../model-selection.inherit-parent.test.ts | 12 +- src/auto-reply/reply/model-selection.ts | 8 +- src/auto-reply/reply/provider-dispatcher.ts | 6 +- .../reply/queue.collect-routing.test.ts | 4 +- src/auto-reply/reply/queue/types.ts | 6 +- src/auto-reply/reply/reply-elevated.ts | 6 +- src/auto-reply/reply/reply-routing.test.ts | 12 +- src/auto-reply/reply/reply-threading.ts | 4 +- .../reply/response-prefix-template.test.ts | 12 +- src/auto-reply/reply/route-reply.test.ts | 12 +- src/auto-reply/reply/route-reply.ts | 4 +- src/auto-reply/reply/session-reset-model.ts | 4 +- src/auto-reply/reply/session-resets.test.ts | 24 +- src/auto-reply/reply/session-updates.ts | 10 +- src/auto-reply/reply/session.test.ts | 58 +- src/auto-reply/reply/session.ts | 4 +- src/auto-reply/reply/stage-sandbox-media.ts | 4 +- src/auto-reply/skill-commands.test.ts | 2 +- src/auto-reply/skill-commands.ts | 6 +- src/auto-reply/status.test.ts | 22 +- src/auto-reply/status.ts | 18 +- src/auto-reply/templating.ts | 2 +- src/browser/chrome.test.ts | 10 +- src/browser/client-fetch.ts | 2 +- src/browser/config.ts | 6 +- src/browser/extension-relay.ts | 6 +- src/browser/profiles-service.ts | 6 +- src/browser/pw-tools-core.downloads.ts | 2 +- src/browser/pw-tools-core.interactions.ts | 10 +- src/browser/pw-tools-core.responses.ts | 2 +- src/browser/routes/agent.debug.ts | 2 +- src/browser/server-context.ts | 6 +- src/canvas-host/a2ui.ts | 44 +- src/canvas-host/a2ui/.bundle.hash | 2 +- src/canvas-host/a2ui/index.html | 56 +- src/canvas-host/server.test.ts | 28 +- src/canvas-host/server.ts | 43 +- src/channels/dock.ts | 6 +- src/channels/plugins/actions/discord.test.ts | 14 +- src/channels/plugins/actions/signal.test.ts | 18 +- src/channels/plugins/actions/telegram.test.ts | 12 +- src/channels/plugins/catalog.test.ts | 8 +- src/channels/plugins/catalog.ts | 21 +- src/channels/plugins/config-helpers.ts | 22 +- src/channels/plugins/config-writes.ts | 4 +- src/channels/plugins/directory-config.ts | 4 +- src/channels/plugins/group-mentions.ts | 6 +- src/channels/plugins/helpers.ts | 8 +- src/channels/plugins/media-limits.ts | 6 +- src/channels/plugins/message-actions.ts | 8 +- src/channels/plugins/onboarding-types.ts | 22 +- src/channels/plugins/onboarding/discord.ts | 18 +- src/channels/plugins/onboarding/imessage.ts | 14 +- src/channels/plugins/onboarding/signal.ts | 16 +- src/channels/plugins/onboarding/slack.ts | 26 +- src/channels/plugins/onboarding/telegram.ts | 14 +- src/channels/plugins/onboarding/whatsapp.ts | 22 +- .../plugins/outbound/telegram.test.ts | 6 +- src/channels/plugins/pairing-message.ts | 2 +- src/channels/plugins/pairing.ts | 4 +- src/channels/plugins/setup-helpers.ts | 20 +- src/channels/plugins/slack.actions.test.ts | 4 +- .../plugins/status-issues/bluebubbles.ts | 2 +- .../plugins/status-issues/whatsapp.ts | 4 +- src/channels/plugins/status.ts | 4 +- src/channels/plugins/types.adapters.ts | 84 +-- src/channels/plugins/types.core.ts | 28 +- src/channels/plugins/whatsapp-heartbeat.ts | 6 +- src/channels/reply-prefix.ts | 4 +- src/cli/argv.test.ts | 120 ++-- src/cli/argv.ts | 4 +- src/cli/banner.ts | 2 +- .../register.files-downloads.ts | 2 +- src/cli/browser-cli-examples.ts | 58 +- src/cli/browser-cli-extension.test.ts | 4 +- src/cli/browser-cli-extension.ts | 12 +- src/cli/browser-cli.ts | 2 +- src/cli/cli-name.ts | 28 + src/cli/command-format.ts | 2 +- src/cli/config-cli.ts | 2 +- src/cli/daemon-cli.coverage.test.ts | 8 +- src/cli/daemon-cli/install.ts | 2 +- src/cli/daemon-cli/shared.ts | 6 +- src/cli/daemon-cli/status.print.ts | 10 +- src/cli/dns-cli.test.ts | 2 +- src/cli/dns-cli.ts | 12 +- src/cli/docs-cli.ts | 2 +- src/cli/exec-approvals-cli.ts | 8 +- src/cli/gateway-cli.coverage.test.ts | 8 +- src/cli/gateway-cli/dev.ts | 8 +- src/cli/gateway-cli/run.ts | 8 +- src/cli/gateway-cli/shared.ts | 8 +- src/cli/gateway.sigterm.test.ts | 4 +- src/cli/hooks-cli.test.ts | 4 +- src/cli/hooks-cli.ts | 14 +- src/cli/logs-cli.test.ts | 4 +- src/cli/logs-cli.ts | 4 +- src/cli/node-cli/daemon.ts | 4 +- src/cli/nodes-cli/register.canvas.ts | 2 +- src/cli/nodes-screen.test.ts | 2 +- src/cli/nodes-screen.ts | 2 +- src/cli/pairing-cli.ts | 4 +- src/cli/plugin-registry.ts | 4 +- src/cli/plugins-cli.ts | 16 +- src/cli/profile.test.ts | 44 +- src/cli/profile.ts | 2 +- src/cli/program/config-guard.ts | 4 +- src/cli/program/help.ts | 19 +- src/cli/program/register.agent.ts | 20 +- src/cli/program/register.message.ts | 8 +- src/cli/program/register.setup.ts | 2 +- .../register.status-health-sessions.ts | 20 +- src/cli/program/register.subclis.test.ts | 14 +- src/cli/program/register.subclis.ts | 4 +- src/cli/run-main.ts | 6 +- src/cli/sandbox-cli.ts | 36 +- src/cli/security-cli.ts | 6 +- src/cli/skills-cli.ts | 4 +- src/cli/tagline.ts | 2 +- src/cli/update-cli.test.ts | 52 +- src/cli/update-cli.ts | 65 +-- src/cli/webhooks-cli.ts | 10 +- src/commands/agent-via-gateway.test.ts | 10 +- src/commands/agent-via-gateway.ts | 2 +- src/commands/agent.delivery.test.ts | 16 +- src/commands/agent.test.ts | 8 +- src/commands/agent.ts | 2 +- src/commands/agent/delivery.ts | 4 +- src/commands/agent/session-store.ts | 4 +- src/commands/agent/session.ts | 6 +- src/commands/agents.add.test.ts | 2 +- src/commands/agents.bindings.ts | 12 +- src/commands/agents.command-shared.ts | 6 +- src/commands/agents.commands.add.ts | 2 +- src/commands/agents.commands.list.ts | 2 +- src/commands/agents.config.ts | 20 +- src/commands/agents.identity.test.ts | 14 +- src/commands/agents.providers.ts | 12 +- src/commands/agents.test.ts | 10 +- .../auth-choice.apply.plugin-provider.ts | 8 +- src/commands/auth-choice.apply.ts | 6 +- src/commands/auth-choice.default-model.ts | 10 +- src/commands/auth-choice.model-check.ts | 4 +- src/commands/auth-choice.test.ts | 16 +- ....adds-non-default-telegram-account.test.ts | 8 +- ...time-errors-channels-status-output.test.ts | 2 +- src/commands/channels/add-mutators.ts | 10 +- src/commands/channels/add.ts | 4 +- src/commands/channels/capabilities.test.ts | 2 +- src/commands/channels/capabilities.ts | 4 +- src/commands/channels/remove.ts | 4 +- src/commands/channels/shared.ts | 6 +- src/commands/channels/status.ts | 6 +- src/commands/chutes-oauth.ts | 2 +- src/commands/cleanup-utils.ts | 4 +- src/commands/configure.channels.ts | 16 +- src/commands/configure.gateway-auth.ts | 6 +- src/commands/configure.gateway.ts | 6 +- src/commands/configure.wizard.test.ts | 6 +- src/commands/configure.wizard.ts | 14 +- src/commands/daemon-install-helpers.test.ts | 8 +- src/commands/daemon-install-helpers.ts | 6 +- src/commands/dashboard.test.ts | 4 +- src/commands/dashboard.ts | 2 +- src/commands/docs.ts | 6 +- ...octor-auth.deprecated-cli-profiles.test.ts | 2 +- src/commands/doctor-auth.ts | 30 +- src/commands/doctor-config-flow.test.ts | 4 +- src/commands/doctor-config-flow.ts | 30 +- src/commands/doctor-format.ts | 4 +- src/commands/doctor-gateway-daemon-flow.ts | 6 +- src/commands/doctor-gateway-health.ts | 4 +- src/commands/doctor-gateway-services.ts | 12 +- src/commands/doctor-legacy-config.test.ts | 4 +- src/commands/doctor-legacy-config.ts | 8 +- ...form-notes.launchctl-env-overrides.test.ts | 8 +- src/commands/doctor-platform-notes.ts | 6 +- src/commands/doctor-sandbox.ts | 16 +- src/commands/doctor-security.test.ts | 10 +- src/commands/doctor-security.ts | 16 +- src/commands/doctor-state-integrity.ts | 4 +- src/commands/doctor-state-migrations.test.ts | 28 +- src/commands/doctor-ui.ts | 4 +- src/commands/doctor-update.ts | 8 +- src/commands/doctor-workspace-status.ts | 8 +- src/commands/doctor-workspace.test.ts | 8 +- src/commands/doctor-workspace.ts | 8 +- ...-back-legacy-sandbox-image-missing.test.ts | 24 +- ...owfrom-channels-whatsapp-allowfrom.test.ts | 28 +- ...-state-migrations-yes-mode-without.test.ts | 24 +- src/commands/doctor.ts | 28 +- ...agent-sandbox-docker-browser-prune.test.ts | 34 +- ...r.warns-state-directory-is-missing.test.ts | 26 +- src/commands/gateway-status.ts | 4 +- src/commands/gateway-status/helpers.ts | 8 +- .../google-gemini-model-default.test.ts | 8 +- src/commands/google-gemini-model-default.ts | 6 +- src/commands/health-format.test.ts | 4 +- src/commands/health.snapshot.test.ts | 2 +- src/commands/health.ts | 4 +- src/commands/model-picker.test.ts | 16 +- src/commands/model-picker.ts | 20 +- src/commands/models.list.test.ts | 14 +- src/commands/models.set.test.ts | 8 +- src/commands/models/auth.ts | 6 +- src/commands/models/list.auth-overview.ts | 4 +- src/commands/models/list.configured.ts | 4 +- src/commands/models/list.probe.ts | 14 +- src/commands/models/list.registry.ts | 16 +- src/commands/models/list.status-command.ts | 14 +- src/commands/models/list.status.test.ts | 8 +- src/commands/models/shared.ts | 10 +- src/commands/onboard-auth.config-core.ts | 32 +- src/commands/onboard-auth.config-minimax.ts | 22 +- src/commands/onboard-auth.config-opencode.ts | 6 +- src/commands/onboard-auth.credentials.ts | 4 +- src/commands/onboard-auth.test.ts | 4 +- src/commands/onboard-channels.test.ts | 8 +- src/commands/onboard-channels.ts | 22 +- src/commands/onboard-helpers.ts | 12 +- src/commands/onboard-hooks.test.ts | 20 +- src/commands/onboard-hooks.ts | 14 +- ...onboard-non-interactive.ai-gateway.test.ts | 8 +- .../onboard-non-interactive.gateway.test.ts | 4 +- .../onboard-non-interactive.token.test.ts | 8 +- src/commands/onboard-non-interactive.ts | 6 +- .../onboard-non-interactive/api-keys.ts | 6 +- src/commands/onboard-non-interactive/local.ts | 8 +- .../local/auth-choice.ts | 8 +- .../local/daemon-install.ts | 4 +- .../local/gateway-config.ts | 6 +- .../local/skills-config.ts | 4 +- .../local/workspace.ts | 4 +- .../onboard-non-interactive/remote.ts | 8 +- src/commands/onboard-remote.ts | 6 +- src/commands/onboard-skills.ts | 14 +- src/commands/onboard.ts | 2 +- .../onboarding/plugin-install.test.ts | 20 +- src/commands/onboarding/plugin-install.ts | 16 +- .../openai-codex-model-default.test.ts | 10 +- src/commands/openai-codex-model-default.ts | 6 +- .../opencode-zen-model-default.test.ts | 12 +- src/commands/opencode-zen-model-default.ts | 6 +- src/commands/reset.ts | 6 +- src/commands/sandbox-display.ts | 2 +- src/commands/sandbox-explain.test.ts | 2 +- src/commands/sandbox-explain.ts | 8 +- src/commands/setup.ts | 10 +- src/commands/signal-install.ts | 4 +- src/commands/status-all.ts | 6 +- src/commands/status-all/agents.ts | 4 +- src/commands/status-all/channels.ts | 16 +- src/commands/status-all/report-lines.ts | 2 +- src/commands/status.command.ts | 14 +- src/commands/status.link-channel.ts | 4 +- src/commands/status.test.ts | 18 +- src/commands/status.update.ts | 6 +- src/commands/uninstall.ts | 6 +- src/compat/legacy-names.ts | 9 + src/config/agent-dirs.ts | 8 +- src/config/agent-limits.ts | 6 +- src/config/channel-capabilities.test.ts | 10 +- src/config/channel-capabilities.ts | 4 +- .../config.agent-concurrency-defaults.test.ts | 2 +- src/config/config.backup-rotation.test.ts | 6 +- src/config/config.compaction-settings.test.ts | 4 +- src/config/config.discord.test.ts | 2 +- src/config/config.env-vars.test.ts | 6 +- src/config/config.identity-defaults.test.ts | 20 +- ...etection.accepts-imessage-dmpolicy.test.ts | 16 +- ...ig.multi-agent-agentdir-validation.test.ts | 4 +- .../config.nix-integration-u3-u5-u9.test.ts | 50 +- src/config/config.plugin-validation.test.ts | 2 +- ...preservation-on-validation-failure.test.ts | 2 +- src/config/config.pruning-defaults.test.ts | 8 +- .../config.skills-entries-config.test.ts | 6 +- .../config.telegram-custom-commands.test.ts | 6 +- src/config/config.ts | 2 +- src/config/defaults.ts | 24 +- src/config/env-vars.ts | 4 +- src/config/group-policy.ts | 10 +- src/config/includes.test.ts | 10 +- src/config/io.ts | 34 +- src/config/legacy-migrate.ts | 4 +- src/config/logging.ts | 6 +- src/config/markdown-tables.ts | 4 +- src/config/merge-config.ts | 6 +- src/config/model-alias-defaults.test.ts | 10 +- src/config/normalize-paths.test.ts | 4 +- src/config/normalize-paths.ts | 4 +- src/config/paths.ts | 16 +- src/config/plugin-auto-enable.ts | 40 +- src/config/runtime-overrides.test.ts | 8 +- src/config/runtime-overrides.ts | 6 +- src/config/schema.ts | 16 +- src/config/sessions.test.ts | 20 +- src/config/sessions/transcript.ts | 2 +- src/config/test-helpers.ts | 2 +- src/config/types.clawdbot.ts | 8 +- src/config/types.gateway.ts | 2 +- src/config/types.imessage.ts | 2 +- src/config/types.whatsapp.ts | 2 +- src/config/validation.ts | 18 +- src/config/version.ts | 10 +- src/config/zod-schema.ts | 2 +- src/cron/cron-protocol-conformance.test.ts | 9 +- ...onse-has-heartbeat-ok-but-includes.test.ts | 12 +- ...p-recipient-besteffortdeliver-true.test.ts | 12 +- ....uses-last-non-empty-agent-text-as.test.ts | 12 +- src/cron/isolated-agent/delivery-target.ts | 4 +- src/cron/isolated-agent/run.ts | 6 +- src/cron/isolated-agent/session.ts | 4 +- src/cron/run-log.test.ts | 4 +- .../service.prevents-duplicate-timers.test.ts | 2 +- ...runs-one-shot-main-job-disables-it.test.ts | 2 +- ...s-main-jobs-empty-systemevent-text.test.ts | 2 +- src/daemon/constants.test.ts | 24 +- src/daemon/constants.ts | 24 +- src/daemon/inspect.ts | 22 +- src/daemon/launchd.test.ts | 4 +- src/daemon/paths.test.ts | 12 +- src/daemon/program-args.test.ts | 16 +- src/daemon/program-args.ts | 2 +- src/daemon/schtasks.test.ts | 32 +- src/daemon/service-env.test.ts | 6 +- src/daemon/systemd-hints.ts | 2 +- src/daemon/systemd-unit.test.ts | 14 +- src/daemon/systemd-unit.ts | 2 +- src/daemon/systemd.test.ts | 12 +- src/discord/accounts.ts | 16 +- src/discord/audit.test.ts | 2 +- src/discord/audit.ts | 4 +- src/discord/monitor.slash.test.ts | 2 +- ...ild-messages-mentionpatterns-match.test.ts | 16 +- ...ends-status-replies-responseprefix.test.ts | 14 +- src/discord/monitor/exec-approvals.ts | 4 +- .../message-handler.inbound-contract.test.ts | 2 +- .../message-handler.preflight.types.ts | 4 +- .../monitor/message-handler.process.test.ts | 2 +- src/discord/monitor/message-handler.ts | 2 +- src/discord/monitor/native-command.ts | 4 +- src/discord/monitor/provider.ts | 4 +- src/discord/send.creates-thread.test.ts | 8 +- src/discord/token.test.ts | 8 +- src/discord/token.ts | 4 +- src/docker-setup.test.ts | 8 +- src/entry.ts | 8 +- src/gateway/assistant-identity.test.ts | 8 +- src/gateway/assistant-identity.ts | 4 +- src/gateway/boot.test.ts | 6 +- src/gateway/boot.ts | 4 +- src/gateway/call.ts | 6 +- src/gateway/config-reload.ts | 10 +- src/gateway/control-ui.ts | 6 +- src/gateway/gateway-cli-backend.live.test.ts | 4 +- .../gateway-models.profiles.live.test.ts | 46 +- src/gateway/gateway.e2e.test.ts | 6 +- src/gateway/hooks-mapping.test.ts | 4 +- src/gateway/hooks-mapping.ts | 8 +- src/gateway/hooks.test.ts | 10 +- src/gateway/hooks.ts | 8 +- src/gateway/http-utils.ts | 8 +- src/gateway/node-command-policy.ts | 4 +- src/gateway/openai-http.e2e.test.ts | 42 +- src/gateway/openai-http.ts | 6 +- src/gateway/openresponses-http.e2e.test.ts | 48 +- src/gateway/openresponses-http.ts | 8 +- src/gateway/protocol/client-info.ts | 10 +- src/gateway/server-channels.ts | 4 +- src/gateway/server-discovery.ts | 10 +- src/gateway/server-http.ts | 2 +- src/gateway/server-methods/channels.ts | 4 +- src/gateway/server-methods/config.ts | 16 +- src/gateway/server-methods/logs.test.ts | 8 +- src/gateway/server-methods/logs.ts | 2 +- src/gateway/server-methods/skills.ts | 12 +- src/gateway/server-methods/update.ts | 4 +- src/gateway/server-plugins.test.ts | 6 +- src/gateway/server-plugins.ts | 4 +- src/gateway/server-runtime-state.ts | 2 +- src/gateway/server-startup.ts | 4 +- ...r.agent.gateway-server-agent-a.e2e.test.ts | 28 +- ...r.agent.gateway-server-agent-b.e2e.test.ts | 10 +- src/gateway/server.auth.e2e.test.ts | 8 +- ...ver.chat.gateway-server-chat-b.e2e.test.ts | 2 +- ...erver.chat.gateway-server-chat.e2e.test.ts | 10 +- src/gateway/server.config-patch.e2e.test.ts | 4 +- src/gateway/server.cron.e2e.test.ts | 4 +- src/gateway/server.health.e2e.test.ts | 2 +- src/gateway/server.hooks.e2e.test.ts | 2 +- src/gateway/server.impl.ts | 12 +- src/gateway/server.ios-client-id.e2e.test.ts | 8 +- .../server.models-voicewake-misc.e2e.test.ts | 4 +- src/gateway/server.sessions-send.e2e.test.ts | 10 +- ...ions.gateway-server-sessions-a.e2e.test.ts | 6 +- src/gateway/server/health-state.ts | 6 +- src/gateway/session-utils.fs.test.ts | 6 +- src/gateway/session-utils.test.ts | 14 +- src/gateway/session-utils.ts | 27 +- src/gateway/sessions-patch.test.ts | 12 +- src/gateway/sessions-patch.ts | 4 +- src/gateway/sessions-resolve.ts | 4 +- src/gateway/test-helpers.mocks.ts | 10 +- src/gateway/test-helpers.server.ts | 4 +- src/gateway/tools-invoke-http.test.ts | 6 +- src/gateway/tools-invoke-http.ts | 10 +- src/git-hooks.test.ts | 2 +- src/hooks/bundled-dir.ts | 2 +- src/hooks/bundled/boot-md/HOOK.md | 4 +- src/hooks/bundled/boot-md/handler.ts | 4 +- src/hooks/bundled/command-logger/HOOK.md | 8 +- src/hooks/bundled/session-memory/HOOK.md | 6 +- src/hooks/bundled/session-memory/handler.ts | 8 +- src/hooks/bundled/soul-evil/HOOK.md | 8 +- src/hooks/bundled/soul-evil/handler.test.ts | 6 +- src/hooks/bundled/soul-evil/handler.ts | 4 +- src/hooks/config.ts | 24 +- src/hooks/frontmatter.test.ts | 78 +-- src/hooks/frontmatter.ts | 39 +- src/hooks/gmail-ops.ts | 12 +- src/hooks/gmail-setup-utils.test.ts | 2 +- src/hooks/gmail-watcher.ts | 4 +- src/hooks/gmail.test.ts | 18 +- src/hooks/gmail.ts | 4 +- src/hooks/hooks-install.e2e.test.ts | 6 +- src/hooks/hooks-status.ts | 32 +- src/hooks/install.test.ts | 16 +- src/hooks/install.ts | 18 +- src/hooks/installs.ts | 4 +- src/hooks/internal-hooks.ts | 6 +- src/hooks/llm-slug-generator.ts | 6 +- src/hooks/loader.test.ts | 22 +- src/hooks/loader.ts | 13 +- src/hooks/plugin-hooks.ts | 26 +- src/hooks/soul-evil.test.ts | 10 +- src/hooks/types.ts | 6 +- src/hooks/workspace.ts | 32 +- src/imessage/accounts.ts | 16 +- ...essages-without-mention-by-default.test.ts | 2 +- ...last-route-chat-id-direct-messages.test.ts | 2 +- src/imessage/monitor/monitor-provider.ts | 4 +- src/imessage/monitor/types.ts | 4 +- src/index.ts | 8 +- src/infra/archive.test.ts | 2 +- src/infra/bonjour-discovery.test.ts | 47 +- src/infra/bonjour-discovery.ts | 18 +- src/infra/bonjour.test.ts | 10 +- src/infra/bonjour.ts | 10 +- src/infra/brew.test.ts | 4 +- src/infra/channel-summary.ts | 14 +- src/infra/control-ui-assets.test.ts | 4 +- src/infra/device-pairing.test.ts | 2 +- src/infra/diagnostic-events.ts | 4 +- src/infra/diagnostic-flags.test.ts | 4 +- src/infra/diagnostic-flags.ts | 6 +- src/infra/dotenv.test.ts | 4 +- src/infra/exec-approval-forwarder.test.ts | 6 +- src/infra/exec-approval-forwarder.ts | 10 +- src/infra/exec-approvals.test.ts | 2 +- src/infra/gateway-lock.test.ts | 4 +- src/infra/gateway-lock.ts | 2 +- ...espects-ackmaxchars-heartbeat-acks.test.ts | 34 +- ...tbeat-runner.returns-default-unset.test.ts | 70 +-- src/infra/heartbeat-runner.scheduler.test.ts | 6 +- ...ner.sender-prefers-delivery-target.test.ts | 6 +- src/infra/heartbeat-runner.ts | 35 +- src/infra/heartbeat-visibility.test.ts | 28 +- src/infra/heartbeat-visibility.ts | 4 +- src/infra/is-main.test.ts | 2 +- src/infra/machine-name.ts | 2 +- .../{clawdbot-root.ts => moltbot-root.ts} | 4 +- src/infra/outbound/agent-delivery.test.ts | 6 +- src/infra/outbound/agent-delivery.ts | 4 +- src/infra/outbound/channel-selection.ts | 8 +- src/infra/outbound/deliver.test.ts | 24 +- src/infra/outbound/deliver.ts | 8 +- src/infra/outbound/directory-cache.ts | 12 +- .../outbound/message-action-runner.test.ts | 14 +- .../message-action-runner.threading.test.ts | 4 +- src/infra/outbound/message-action-runner.ts | 18 +- src/infra/outbound/message.ts | 6 +- src/infra/outbound/outbound-policy.test.ts | 10 +- src/infra/outbound/outbound-policy.ts | 6 +- src/infra/outbound/outbound-send-service.ts | 4 +- src/infra/outbound/outbound-session.test.ts | 12 +- src/infra/outbound/outbound-session.ts | 10 +- src/infra/outbound/target-resolver.test.ts | 4 +- src/infra/outbound/target-resolver.ts | 12 +- src/infra/outbound/targets.test.ts | 4 +- src/infra/outbound/targets.ts | 10 +- src/infra/path-env.test.ts | 26 +- src/infra/path-env.ts | 18 +- src/infra/ports-format.ts | 4 +- src/infra/ports.test.ts | 2 +- src/infra/ports.ts | 4 +- src/infra/provider-usage.fetch.claude.ts | 2 +- src/infra/provider-usage.fetch.minimax.ts | 2 +- src/infra/provider-usage.test.ts | 2 +- src/infra/restart-sentinel.test.ts | 2 +- src/infra/restart-sentinel.ts | 2 +- src/infra/restart.ts | 2 +- src/infra/runtime-guard.ts | 4 +- src/infra/session-cost-usage.test.ts | 8 +- src/infra/session-cost-usage.ts | 8 +- src/infra/shell-env.ts | 2 +- src/infra/skills-remote.ts | 14 +- src/infra/state-migrations.fs.test.ts | 2 +- src/infra/state-migrations.ts | 8 +- src/infra/system-events.test.ts | 4 +- src/infra/system-presence.test.ts | 4 +- src/infra/tailscale.ts | 2 +- src/infra/tls/gateway.ts | 2 +- src/infra/unhandled-rejections.ts | 8 +- src/infra/update-check.ts | 2 +- src/infra/update-global.ts | 10 +- src/infra/update-runner.test.ts | 46 +- src/infra/update-runner.ts | 12 +- src/infra/update-startup.test.ts | 18 +- src/infra/update-startup.ts | 6 +- src/infra/voicewake.test.ts | 6 +- src/infra/warnings.ts | 2 +- src/infra/widearea-dns.test.ts | 16 +- src/infra/widearea-dns.ts | 20 +- src/line/accounts.test.ts | 20 +- src/line/accounts.ts | 8 +- src/line/bot-handlers.ts | 4 +- src/line/bot-message-context.test.ts | 6 +- src/line/bot-message-context.ts | 6 +- src/line/bot.ts | 4 +- src/line/monitor.ts | 4 +- src/line/probe.test.ts | 4 +- src/link-understanding/apply.ts | 4 +- src/link-understanding/runner.ts | 4 +- src/logger.test.ts | 6 +- src/logging/config.ts | 4 +- src/logging/console-capture.test.ts | 2 +- src/logging/console.ts | 6 +- src/logging/logger.ts | 14 +- src/logging/redact.ts | 6 +- src/macos/gateway-daemon.ts | 4 +- src/macos/relay.ts | 11 +- src/markdown/frontmatter.test.ts | 16 +- src/media-understanding/apply.test.ts | 40 +- src/media-understanding/apply.ts | 4 +- src/media-understanding/attachments.ts | 2 +- src/media-understanding/providers/image.ts | 4 +- src/media-understanding/resolve.test.ts | 14 +- src/media-understanding/resolve.ts | 14 +- .../runner.auto-audio.test.ts | 10 +- .../runner.deepgram.test.ts | 6 +- src/media-understanding/runner.ts | 20 +- .../runner.vision-skip.test.ts | 4 +- src/media-understanding/types.ts | 2 +- src/media/host.ts | 2 +- src/media/image-ops.ts | 2 +- src/media/input-files.ts | 2 +- src/media/store.header-ext.test.ts | 2 +- src/media/store.redirect.test.ts | 2 +- src/media/store.test.ts | 2 +- src/memory/batch-gemini.ts | 2 +- src/memory/batch-openai.ts | 2 +- src/memory/embeddings.ts | 6 +- src/memory/index.test.ts | 2 +- src/memory/manager.async-search.test.ts | 2 +- src/memory/manager.atomic-reindex.test.ts | 2 +- src/memory/manager.batch.test.ts | 2 +- src/memory/manager.embedding-batches.test.ts | 2 +- .../manager.sync-errors-do-not-crash.test.ts | 2 +- src/memory/manager.ts | 8 +- src/memory/manager.vector-dedupe.test.ts | 2 +- src/memory/search-manager.ts | 4 +- src/node-host/runner.ts | 4 +- src/pairing/pairing-messages.test.ts | 2 +- src/pairing/pairing-messages.ts | 4 +- src/pairing/pairing-store.test.ts | 2 +- src/plugin-sdk/index.ts | 8 +- src/plugins/cli.test.ts | 2 +- src/plugins/cli.ts | 8 +- src/plugins/commands.ts | 10 +- src/plugins/config-schema.ts | 4 +- src/plugins/config-state.ts | 4 +- src/plugins/discovery.test.ts | 30 +- src/plugins/discovery.ts | 16 +- src/plugins/enable.ts | 10 +- src/plugins/install.test.ts | 28 +- src/plugins/install.ts | 18 +- src/plugins/installs.ts | 6 +- src/plugins/loader.test.ts | 42 +- src/plugins/loader.ts | 26 +- src/plugins/manifest-registry.ts | 8 +- src/plugins/manifest.ts | 25 +- src/plugins/providers.ts | 4 +- src/plugins/registry.ts | 72 +-- src/plugins/runtime.ts | 2 +- src/plugins/services.ts | 10 +- src/plugins/slots.test.ts | 10 +- src/plugins/slots.ts | 6 +- src/plugins/status.ts | 4 +- src/plugins/tools.optional.test.ts | 4 +- src/plugins/tools.ts | 8 +- src/plugins/types.ts | 86 +-- src/plugins/update.ts | 16 +- src/postinstall-patcher.test.ts | 2 +- src/providers/github-copilot-token.test.ts | 4 +- src/providers/qwen-portal-oauth.ts | 2 +- src/routing/bindings.ts | 10 +- src/routing/resolve-route.test.ts | 24 +- src/routing/resolve-route.ts | 8 +- src/scripts/canvas-a2ui-copy.test.ts | 4 +- src/security/audit-extra.ts | 36 +- src/security/audit.test.ts | 110 ++-- src/security/audit.ts | 24 +- src/security/fix.test.ts | 20 +- src/security/fix.ts | 14 +- src/sessions/send-policy.test.ts | 10 +- src/sessions/send-policy.ts | 4 +- src/signal/accounts.ts | 16 +- ...-only-senders-uuid-allowlist-entry.test.ts | 2 +- ...ends-tool-summaries-responseprefix.test.ts | 8 +- src/signal/monitor.ts | 4 +- src/signal/monitor/event-handler.types.ts | 4 +- src/signal/reaction-level.ts | 4 +- src/slack/accounts.ts | 16 +- src/slack/channel-migration.ts | 6 +- src/slack/monitor.test-helpers.ts | 2 +- ...onitor.threading.missing-thread-ts.test.ts | 2 +- src/slack/monitor/context.test.ts | 4 +- src/slack/monitor/context.ts | 6 +- .../prepare.inbound-contract.test.ts | 6 +- .../monitor/slash.command-arg-menus.test.ts | 8 +- src/slack/monitor/slash.ts | 2 +- src/slack/monitor/types.ts | 4 +- src/slack/threading-tool-context.test.ts | 16 +- src/slack/threading-tool-context.ts | 4 +- src/telegram/accounts.test.ts | 10 +- src/telegram/accounts.ts | 16 +- src/telegram/bot-message-context.ts | 10 +- .../bot-native-commands.plugin-auth.test.ts | 4 +- src/telegram/bot-native-commands.ts | 6 +- ...patterns-match-without-botusername.test.ts | 14 +- ...topic-skill-filters-system-prompts.test.ts | 8 +- ...-all-group-messages-grouppolicy-is.test.ts | 20 +- ...e-callback-query-updates-by-update.test.ts | 8 +- ...gram-bot.installs-grammy-throttler.test.ts | 14 +- ...lowfrom-entries-case-insensitively.test.ts | 14 +- ...-case-insensitively-grouppolicy-is.test.ts | 16 +- ...-dms-by-telegram-accountid-binding.test.ts | 12 +- ...ies-without-native-reply-threading.test.ts | 20 +- ...s-media-file-path-no-file-download.test.ts | 26 +- ...udes-location-text-ctx-fields-pins.test.ts | 4 +- src/telegram/bot.test.ts | 122 ++-- src/telegram/bot.ts | 4 +- src/telegram/bot/helpers.test.ts | 10 +- src/telegram/draft-chunking.test.ts | 6 +- src/telegram/draft-chunking.ts | 4 +- src/telegram/group-migration.ts | 6 +- src/telegram/inline-buttons.ts | 6 +- src/telegram/monitor.ts | 6 +- src/telegram/pairing-store.test.ts | 2 +- src/telegram/pairing-store.ts | 4 +- src/telegram/reaction-level.test.ts | 16 +- src/telegram/reaction-level.ts | 4 +- src/telegram/sticker-cache.test.ts | 4 +- src/telegram/sticker-cache.ts | 8 +- src/telegram/token.test.ts | 14 +- src/telegram/token.ts | 4 +- src/telegram/update-offset-store.test.ts | 2 +- src/telegram/webhook.ts | 4 +- src/test-helpers/workspace.ts | 2 +- src/tts/tts.ts | 16 +- src/tui/commands.ts | 4 +- src/tui/gateway-chat.ts | 2 +- src/tui/tui.ts | 2 +- src/utils.test.ts | 10 +- src/utils/usage-format.test.ts | 4 +- src/utils/usage-format.ts | 4 +- src/version.ts | 2 +- src/web/accounts.ts | 20 +- src/web/accounts.whatsapp-auth.test.ts | 4 +- src/web/active-listener.ts | 2 +- src/web/auth-store.ts | 2 +- ...asts-sequentially-configured-order.test.ts | 12 +- ...wn-broadcast-agent-ids-agents-list.test.ts | 8 +- .../auto-reply.partial-reply-gating.test.ts | 14 +- .../auto-reply.typing-controller-idle.test.ts | 8 +- ...compresses-common-formats-jpeg-cap.test.ts | 4 +- ...y.falls-back-text-media-send-fails.test.ts | 4 +- ...efixes-body-same-phone-marker-from.test.ts | 4 +- ....reconnects-after-connection-close.test.ts | 8 +- ...oup-chats-injects-history-replying.test.ts | 8 +- ...mmaries-immediately-responseprefix.test.ts | 6 +- ...-activation-silent-token-preserves.test.ts | 8 +- ...gent-mention-patterns-group-gating.test.ts | 4 +- src/web/auto-reply/monitor.ts | 2 +- .../auto-reply/monitor/group-gating.test.ts | 2 +- src/web/auto-reply/monitor/process-message.ts | 2 +- src/web/auto-reply/session-snapshot.test.ts | 2 +- src/web/inbound.media.test.ts | 2 +- src/web/login.ts | 2 +- src/web/media.test.ts | 2 +- ...ssages-from-senders-allowfrom-list.test.ts | 2 +- ...unauthorized-senders-not-allowfrom.test.ts | 2 +- ...captures-media-path-image-messages.test.ts | 4 +- ...tor-inbox.streams-inbound-messages.test.ts | 2 +- src/web/qr-image.test.ts | 2 +- src/web/reconnect.test.ts | 4 +- src/web/reconnect.ts | 6 +- src/web/session.ts | 4 +- src/web/test-helpers.ts | 8 +- src/wizard/onboarding.finalize.ts | 32 +- src/wizard/onboarding.gateway-config.ts | 8 +- src/wizard/onboarding.test.ts | 6 +- src/wizard/onboarding.ts | 20 +- test/gateway.multi.e2e.test.ts | 4 +- test/helpers/temp-home.ts | 2 +- test/media-understanding.auto.e2e.test.ts | 20 +- test/provider-timeout.e2e.test.ts | 4 +- test/setup.ts | 8 +- test/test-env.ts | 2 +- ui/index.html | 4 +- ui/package.json | 2 +- ui/src/styles/base.css | 2 +- ui/src/ui/app-channels.ts | 26 +- ui/src/ui/app-chat.ts | 10 +- ui/src/ui/app-gateway.ts | 18 +- ui/src/ui/app-polling.ts | 8 +- ui/src/ui/app-render.ts | 4 +- ui/src/ui/app-scroll.ts | 2 +- ui/src/ui/app-settings.ts | 46 +- ui/src/ui/app.ts | 4 +- ui/src/ui/chat-markdown.browser.test.ts | 10 +- ui/src/ui/controllers/chat.ts | 2 +- ui/src/ui/device-auth.ts | 2 +- ui/src/ui/device-identity.ts | 2 +- ui/src/ui/focus-mode.browser.test.ts | 10 +- ui/src/ui/navigation.browser.test.ts | 26 +- ui/src/ui/navigation.test.ts | 10 +- ui/src/ui/navigation.ts | 2 +- ui/src/ui/storage.ts | 2 +- ui/src/ui/views/chat.test.ts | 2 +- ui/src/ui/views/debug.ts | 2 +- ui/src/ui/views/overview.ts | 6 +- vitest.config.ts | 2 +- vitest.e2e.config.ts | 2 +- vitest.live.config.ts | 2 +- 1839 files changed, 11250 insertions(+), 11199 deletions(-) rename src/agents/{clawdbot-tools.ts => moltbot-tools.ts} (97%) create mode 100644 src/cli/cli-name.ts create mode 100644 src/compat/legacy-names.ts rename src/infra/{clawdbot-root.ts => moltbot-root.ts} (93%) diff --git a/AGENTS.md b/AGENTS.md index c35e996c7..44b0149fd 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1,5 +1,5 @@ # Repository Guidelines -- Repo: https://github.com/clawdbot/clawdbot +- Repo: https://github.com/moltbot/moltbot - GitHub issues/comments/PR comments: use literal multiline strings or `-F - <<'EOF'` (or $'...') for real newlines; never embed "\\n". ## Project Structure & Module Organization @@ -7,7 +7,7 @@ - Tests: colocated `*.test.ts`. - Docs: `docs/` (images, queue, Pi config). Built output lives in `dist/`. - Plugins/extensions: live under `extensions/*` (workspace packages). Keep plugin-only deps in the extension `package.json`; do not add them to the root `package.json` unless core uses them. -- Plugins: install runs `npm install --omit=dev` in plugin dir; runtime deps must live in `dependencies`. Avoid `workspace:*` in `dependencies` (npm install breaks); put `clawdbot` in `devDependencies` or `peerDependencies` instead (runtime resolves `clawdbot/plugin-sdk` via jiti alias). +- Plugins: install runs `npm install --omit=dev` in plugin dir; runtime deps must live in `dependencies`. Avoid `workspace:*` in `dependencies` (npm install breaks); put `moltbot` in `devDependencies` or `peerDependencies` instead (runtime resolves `clawdbot/plugin-sdk` via jiti alias). - Installers served from `https://molt.bot/*`: live in the sibling repo `../molt.bot` (`public/install.sh`, `public/install-cli.sh`, `public/install.ps1`). - Messaging channels: always consider **all** built-in + extension channels when refactoring shared logic (routing, allowlists, pairing, command gating, onboarding, docs). - Core channel docs: `docs/channels/` @@ -28,12 +28,12 @@ ## exe.dev VM ops (general) - Access: stable path is `ssh exe.dev` then `ssh vm-name` (assume SSH key already set). - SSH flaky: use exe.dev web terminal or Shelley (web agent); keep a tmux session for long ops. -- Update: `sudo npm i -g clawdbot@latest` (global install needs root on `/usr/lib/node_modules`). -- Config: use `clawdbot config set ...`; ensure `gateway.mode=local` is set. +- Update: `sudo npm i -g moltbot@latest` (global install needs root on `/usr/lib/node_modules`). +- Config: use `moltbot config set ...`; ensure `gateway.mode=local` is set. - Discord: store raw token only (no `DISCORD_BOT_TOKEN=` prefix). - Restart: stop old gateway and run: - `pkill -9 -f clawdbot-gateway || true; nohup clawdbot gateway run --bind loopback --port 18789 --force > /tmp/clawdbot-gateway.log 2>&1 &` -- Verify: `clawdbot channels status --probe`, `ss -ltnp | rg 18789`, `tail -n 120 /tmp/clawdbot-gateway.log`. + `pkill -9 -f moltbot-gateway || true; nohup moltbot gateway run --bind loopback --port 18789 --force > /tmp/moltbot-gateway.log 2>&1 &` +- Verify: `moltbot channels status --probe`, `ss -ltnp | rg 18789`, `tail -n 120 /tmp/moltbot-gateway.log`. ## Build, Test, and Development Commands - Runtime baseline: Node **22+** (keep Node + Bun paths working). @@ -41,7 +41,7 @@ - Pre-commit hooks: `prek install` (runs same checks as CI) - Also supported: `bun install` (keep `pnpm-lock.yaml` + Bun patching in sync when touching deps/patches). - Prefer Bun for TypeScript execution (scripts, dev, tests): `bun ` / `bunx `. -- Run CLI in dev: `pnpm clawdbot ...` (bun) or `pnpm dev`. +- Run CLI in dev: `pnpm moltbot ...` (bun) or `pnpm dev`. - Node remains supported for running built output (`dist/*`) and production installs. - Mac packaging (dev): `scripts/package-mac-app.sh` defaults to current arch. Release checklist: `docs/platforms/mac/release.md`. - Type-check/build: `pnpm build` (tsc) @@ -54,7 +54,7 @@ - Add brief code comments for tricky or non-obvious logic. - Keep files concise; extract helpers instead of “V2” copies. Use existing patterns for CLI options and dependency injection via `createDefaultDeps`. - Aim to keep files under ~700 LOC; guideline only (not a hard guardrail). Split/refactor when it improves clarity or testability. -- Naming: use **Clawdbot** for product/app/docs headings; use `clawdbot` for CLI command, package/binary, paths, and config keys. +- Naming: use **Moltbot** for product/app/docs headings; use `moltbot` for CLI command, package/binary, paths, and config keys. ## Release Channels (Naming) - stable: tagged releases only (e.g. `vYYYY.M.D`), npm dist-tag `latest`. @@ -66,7 +66,7 @@ - Naming: match source names with `*.test.ts`; e2e in `*.e2e.test.ts`. - Run `pnpm test` (or `pnpm test:coverage`) before pushing when you touch logic. - Do not set test workers above 16; tried already. -- Live tests (real keys): `CLAWDBOT_LIVE_TEST=1 pnpm test:live` (Clawdbot-only) or `LIVE=1 pnpm test:live` (includes provider live tests). Docker: `pnpm test:docker:live-models`, `pnpm test:docker:live-gateway`. Onboarding Docker E2E: `pnpm test:docker:onboard`. +- Live tests (real keys): `CLAWDBOT_LIVE_TEST=1 pnpm test:live` (Moltbot-only) or `LIVE=1 pnpm test:live` (includes provider live tests). Docker: `pnpm test:docker:live-models`, `pnpm test:docker:live-gateway`. Onboarding Docker E2E: `pnpm test:docker:onboard`. - Full kit + what’s covered: `docs/testing.md`. - Pure test additions/fixes generally do **not** need a changelog entry unless they alter user-facing behavior or the user asks for one. - Mobile: before using a simulator, check for connected real devices (iOS + Android) and prefer them when available. @@ -97,19 +97,19 @@ - **Landing mode:** create an integration branch from `main`, bring in PR commits (**prefer rebase** for linear history; **merge allowed** when complexity/conflicts make it safer), apply fixes, add changelog (+ thanks + PR #), run full gate **locally before committing** (`pnpm lint && pnpm build && pnpm test`), commit, merge back to `main`, then `git switch main` (never stay on a topic branch after landing). Important: contributor needs to be in git graph after this! ## Security & Configuration Tips -- Web provider stores creds at `~/.clawdbot/credentials/`; rerun `clawdbot login` if logged out. +- Web provider stores creds at `~/.clawdbot/credentials/`; rerun `moltbot login` if logged out. - Pi sessions live under `~/.clawdbot/sessions/` by default; the base directory is not configurable. - Environment variables: see `~/.profile`. - Never commit or publish real phone numbers, videos, or live configuration values. Use obviously fake placeholders in docs, tests, and examples. - Release flow: always read `docs/reference/RELEASING.md` and `docs/platforms/mac/release.md` before any release work; do not ask routine questions once those docs answer them. ## Troubleshooting -- Rebrand/migration issues or legacy config/service warnings: run `clawdbot doctor` (see `docs/gateway/doctor.md`). +- Rebrand/migration issues or legacy config/service warnings: run `moltbot doctor` (see `docs/gateway/doctor.md`). ## Agent-Specific Notes - Vocabulary: "makeup" = "mac app". - Never edit `node_modules` (global/Homebrew/npm/git installs too). Updates overwrite. Skill notes go in `tools.md` or `AGENTS.md`. -- Signal: "update fly" => `fly ssh console -a flawd-bot -C "bash -lc 'cd /data/clawd/clawdbot && git pull --rebase origin main'"` then `fly machines restart e825232f34d058 -a flawd-bot`. +- Signal: "update fly" => `fly ssh console -a flawd-bot -C "bash -lc 'cd /data/clawd/moltbot && git pull --rebase origin main'"` then `fly machines restart e825232f34d058 -a flawd-bot`. - When working on a GitHub Issue or PR, print the full URL at the end of the task. - When answering questions, respond with high-confidence answers only: verify in code; do not guess. - Never update the Carbon dependency. @@ -117,12 +117,12 @@ - Patching dependencies (pnpm patches, overrides, or vendored changes) requires explicit approval; do not do this by default. - CLI progress: use `src/cli/progress.ts` (`osc-progress` + `@clack/prompts` spinner); don’t hand-roll spinners/bars. - Status output: keep tables + ANSI-safe wrapping (`src/terminal/table.ts`); `status --all` = read-only/pasteable, `status --deep` = probes. -- Gateway currently runs only as the menubar app; there is no separate LaunchAgent/helper label installed. Restart via the Clawdbot Mac app or `scripts/restart-mac.sh`; to verify/kill use `launchctl print gui/$UID | grep clawdbot` rather than assuming a fixed label. **When debugging on macOS, start/stop the gateway via the app, not ad-hoc tmux sessions; kill any temporary tunnels before handoff.** -- macOS logs: use `./scripts/clawlog.sh` to query unified logs for the Clawdbot subsystem; it supports follow/tail/category filters and expects passwordless sudo for `/usr/bin/log`. +- Gateway currently runs only as the menubar app; there is no separate LaunchAgent/helper label installed. Restart via the Moltbot Mac app or `scripts/restart-mac.sh`; to verify/kill use `launchctl print gui/$UID | grep moltbot` rather than assuming a fixed label. **When debugging on macOS, start/stop the gateway via the app, not ad-hoc tmux sessions; kill any temporary tunnels before handoff.** +- macOS logs: use `./scripts/clawlog.sh` to query unified logs for the Moltbot subsystem; it supports follow/tail/category filters and expects passwordless sudo for `/usr/bin/log`. - If shared guardrails are available locally, review them; otherwise follow this repo's guidance. - SwiftUI state management (iOS/macOS): prefer the `Observation` framework (`@Observable`, `@Bindable`) over `ObservableObject`/`@StateObject`; don’t introduce new `ObservableObject` unless required for compatibility, and migrate existing usages when touching related code. - Connection providers: when adding a new connection, update every UI surface and docs (macOS app, web UI, mobile if applicable, onboarding/overview docs) and add matching status + configuration forms so provider lists and settings stay in sync. -- Version locations: `package.json` (CLI), `apps/android/app/build.gradle.kts` (versionName/versionCode), `apps/ios/Sources/Info.plist` + `apps/ios/Tests/Info.plist` (CFBundleShortVersionString/CFBundleVersion), `apps/macos/Sources/Clawdbot/Resources/Info.plist` (CFBundleShortVersionString/CFBundleVersion), `docs/install/updating.md` (pinned npm version), `docs/platforms/mac/release.md` (APP_VERSION/APP_BUILD examples), Peekaboo Xcode projects/Info.plists (MARKETING_VERSION/CURRENT_PROJECT_VERSION). +- Version locations: `package.json` (CLI), `apps/android/app/build.gradle.kts` (versionName/versionCode), `apps/ios/Sources/Info.plist` + `apps/ios/Tests/Info.plist` (CFBundleShortVersionString/CFBundleVersion), `apps/macos/Sources/Moltbot/Resources/Info.plist` (CFBundleShortVersionString/CFBundleVersion), `docs/install/updating.md` (pinned npm version), `docs/platforms/mac/release.md` (APP_VERSION/APP_BUILD examples), Peekaboo Xcode projects/Info.plists (MARKETING_VERSION/CURRENT_PROJECT_VERSION). - **Restart apps:** “restart iOS/Android apps” means rebuild (recompile/install) and relaunch, not just kill/launch. - **Device checks:** before testing, verify connected real devices (iOS/Android) before reaching for simulators/emulators. - iOS Team ID lookup: `security find-identity -p codesigning -v` → use Apple Development (…) TEAMID. Fallback: `defaults read com.apple.dt.Xcode IDEProvisioningTeamIdentifiers`. @@ -149,9 +149,9 @@ - Do not rebuild the macOS app over SSH; rebuilds must be run directly on the Mac. - Never send streaming/partial replies to external messaging surfaces (WhatsApp, Telegram); only final replies should be delivered there. Streaming/tool events may still go to internal UIs/control channel. - Voice wake forwarding tips: - - Command template should stay `clawdbot-mac agent --message "${text}" --thinking low`; `VoiceWakeForwarder` already shell-escapes `${text}`. Don’t add extra quotes. - - launchd PATH is minimal; ensure the app’s launch agent PATH includes standard system paths plus your pnpm bin (typically `$HOME/Library/pnpm`) so `pnpm`/`clawdbot` binaries resolve when invoked via `clawdbot-mac`. -- For manual `clawdbot message send` messages that include `!`, use the heredoc pattern noted below to avoid the Bash tool’s escaping. + - Command template should stay `moltbot-mac agent --message "${text}" --thinking low`; `VoiceWakeForwarder` already shell-escapes `${text}`. Don’t add extra quotes. + - launchd PATH is minimal; ensure the app’s launch agent PATH includes standard system paths plus your pnpm bin (typically `$HOME/Library/pnpm`) so `pnpm`/`moltbot` binaries resolve when invoked via `moltbot-mac`. +- For manual `moltbot message send` messages that include `!`, use the heredoc pattern noted below to avoid the Bash tool’s escaping. - Release guardrails: do not change version numbers without operator’s explicit consent; always ask permission before running any npm publish/release step. ## NPM + 1Password (publish/verify) diff --git a/CHANGELOG.md b/CHANGELOG.md index f8f951133..079c32533 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,7 +6,7 @@ Docs: https://docs.molt.bot Status: unreleased. ### Changes -- Rebrand: rename the npm package/CLI to `moltbot`, add a `clawdbot` compatibility shim, and move extensions to the `@moltbot/*` scope. +- Rebrand: rename the npm package/CLI to `moltbot`, add a `moltbot` compatibility shim, and move extensions to the `@moltbot/*` scope. - Commands: group /help and /commands output with Telegram paging. (#2504) Thanks @hougangdev. - macOS: limit project-local `node_modules/.bin` PATH preference to debug builds (reduce PATH hijacking risk). - Tools: add per-sender group tool policies and fix precedence. (#1757) Thanks @adam91holt. @@ -195,9 +195,9 @@ Status: unreleased. ### Changes - Channels: allow per-group tool allow/deny policies across built-in + plugin channels. (#1546) Thanks @adam91holt. https://docs.molt.bot/multi-agent-sandbox-tools - Agents: add Bedrock auto-discovery defaults + config overrides. (#1553) Thanks @fal3. https://docs.molt.bot/bedrock -- CLI: add `clawdbot system` for system events + heartbeat controls; remove standalone `wake`. (commit 71203829d) https://docs.molt.bot/cli/system -- CLI: add live auth probes to `clawdbot models status` for per-profile verification. (commit 40181afde) https://docs.molt.bot/cli/models -- CLI: restart the gateway by default after `clawdbot update`; add `--no-restart` to skip it. (commit 2c85b1b40) +- CLI: add `moltbot system` for system events + heartbeat controls; remove standalone `wake`. (commit 71203829d) https://docs.molt.bot/cli/system +- CLI: add live auth probes to `moltbot models status` for per-profile verification. (commit 40181afde) https://docs.molt.bot/cli/models +- CLI: restart the gateway by default after `moltbot update`; add `--no-restart` to skip it. (commit 2c85b1b40) - Browser: add node-host proxy auto-routing for remote gateways (configurable per gateway/node). (commit c3cb26f7c) - Plugins: add optional `llm-task` JSON-only tool for workflows. (#1498) Thanks @vignesh07. https://docs.molt.bot/tools/llm-task - Markdown: add per-channel table conversion (bullets for Signal/WhatsApp, code blocks elsewhere). (#1495) Thanks @odysseus0. @@ -237,7 +237,7 @@ Status: unreleased. - UI: keep the Control UI sidebar visible while scrolling long pages. (#1515) Thanks @pookNast. - UI: cache Control UI markdown rendering + memoize chat text extraction to reduce Safari typing jank. (commit d57cb2e1a) - TUI: forward unknown slash commands, include Gateway commands in autocomplete, and render slash replies as system output. (commit 1af227b61, commit 8195497ce, commit 6fba598ea) -- CLI: auth probe output polish (table output, inline errors, reduced noise, and wrap fixes in `clawdbot models status`). (commit da3f2b489, commit 00ae21bed, commit 31e59cd58, commit f7dc27f2d, commit 438e782f8, commit 886752217, commit aabe0bed3, commit 81535d512, commit c63144ab1) +- CLI: auth probe output polish (table output, inline errors, reduced noise, and wrap fixes in `moltbot models status`). (commit da3f2b489, commit 00ae21bed, commit 31e59cd58, commit f7dc27f2d, commit 438e782f8, commit 886752217, commit aabe0bed3, commit 81535d512, commit c63144ab1) - Media: only parse `MEDIA:` tags when they start the line to avoid stripping prose mentions. (#1206) - Media: preserve PNG alpha when possible; fall back to JPEG when still over size cap. (#1491) Thanks @robbyczgw-cla. - Skills: gate bird Homebrew install to macOS. (#1569) Thanks @bradleypriest. @@ -296,12 +296,12 @@ Status: unreleased. - Exec approvals: support wildcard agent allowlists (`*`) across all agents. - Exec approvals: allowlist matches resolved binary paths only, add safe stdin-only bins, and tighten allowlist shell parsing. - Nodes: expose node PATH in status/describe and bootstrap PATH for node-host execution. -- CLI: flatten node service commands under `clawdbot node` and remove `service node` docs. -- CLI: move gateway service commands under `clawdbot gateway` and add `gateway probe` for reachability. +- CLI: flatten node service commands under `moltbot node` and remove `service node` docs. +- CLI: move gateway service commands under `moltbot gateway` and add `gateway probe` for reachability. - Sessions: add per-channel reset overrides via `session.resetByChannel`. (#1353) Thanks @cash-echo-bot. - Agents: add identity avatar config support and Control UI avatar rendering. (#1329, #1424) Thanks @dlauer. - UI: show per-session assistant identity in the Control UI. (#1420) Thanks @robbyczgw-cla. -- CLI: add `clawdbot update wizard` for interactive channel selection and restart prompts. https://docs.molt.bot/cli/update +- CLI: add `moltbot update wizard` for interactive channel selection and restart prompts. https://docs.molt.bot/cli/update - Signal: add typing indicators and DM read receipts via signal-cli. - MSTeams: add file uploads, adaptive cards, and attachment handling improvements. (#1410) Thanks @Evizero. - Onboarding: remove the run setup-token auth option (paste setup-token or reuse CLI creds instead). @@ -342,8 +342,8 @@ Status: unreleased. - TUI: session picker shows derived titles, fuzzy search, relative times, and last message preview. (#1271) https://docs.molt.bot/tui - TUI: add a searchable model picker for quicker model selection. (#1198) https://docs.molt.bot/tui - TUI: add input history (up/down) for submitted messages. (#1348) https://docs.molt.bot/tui -- ACP: add `clawdbot acp` for IDE integrations. https://docs.molt.bot/cli/acp -- ACP: add `clawdbot acp client` interactive harness for debugging. https://docs.molt.bot/cli/acp +- ACP: add `moltbot acp` for IDE integrations. https://docs.molt.bot/cli/acp +- ACP: add `moltbot acp client` interactive harness for debugging. https://docs.molt.bot/cli/acp - Skills: add download installs with OS-filtered options. https://docs.molt.bot/tools/skills - Skills: add the local sherpa-onnx-tts skill. https://docs.molt.bot/tools/skills - Memory: add hybrid BM25 + vector search (FTS5) with weighted merging and fallback. https://docs.molt.bot/concepts/memory @@ -374,8 +374,8 @@ Status: unreleased. - Plugins: migrate the Zalo Personal plugin to the shared plugin SDK runtime. https://docs.molt.bot/plugins/zalouser - Plugins: allow optional agent tools with explicit allowlists and add the plugin tool authoring guide. https://docs.molt.bot/plugins/agent-tools - Plugins: auto-enable bundled channel/provider plugins when configuration is present. -- Plugins: sync plugin sources on channel switches and update npm-installed plugins during `clawdbot update`. -- Plugins: share npm plugin update logic between `clawdbot update` and `clawdbot plugins update`. +- Plugins: sync plugin sources on channel switches and update npm-installed plugins during `moltbot update`. +- Plugins: share npm plugin update logic between `moltbot update` and `moltbot plugins update`. - Gateway/API: add `/v1/responses` (OpenResponses) with item-based input + semantic streaming events. (#1229) - Gateway/API: expand `/v1/responses` to support file/image inputs, tool_choice, usage, and output limits. (#1229) @@ -384,7 +384,7 @@ Status: unreleased. - Exec: add host/security/ask routing for gateway + node exec. https://docs.molt.bot/tools/exec - Exec: add `/exec` directive for per-session exec defaults (host/security/ask/node). https://docs.molt.bot/tools/exec - Exec approvals: migrate approvals to `~/.clawdbot/exec-approvals.json` with per-agent allowlists + skill auto-allow toggle, and add approvals UI + node exec lifecycle events. https://docs.molt.bot/tools/exec-approvals -- Nodes: add headless node host (`clawdbot node start`) for `system.run`/`system.which`. https://docs.molt.bot/cli/node +- Nodes: add headless node host (`moltbot node start`) for `system.run`/`system.which`. https://docs.molt.bot/cli/node - Nodes: add node daemon service install/status/start/stop/restart. https://docs.molt.bot/cli/node - Bridge: add `skills.bins` RPC to support node host auto-allow skill bins. - Sessions: add daily reset policy with per-type overrides and idle windows (default 4am local), preserving legacy idle-only configs. (#1146) https://docs.molt.bot/concepts/session @@ -414,10 +414,10 @@ Status: unreleased. - Swabble: use the tagged Commander Swift package release. ### Breaking -- **BREAKING:** Reject invalid/unknown config entries and refuse to start the gateway for safety. Run `clawdbot doctor --fix` to repair, then update plugins (`clawdbot plugins update`) if you use any. +- **BREAKING:** Reject invalid/unknown config entries and refuse to start the gateway for safety. Run `moltbot doctor --fix` to repair, then update plugins (`moltbot plugins update`) if you use any. ### Fixes -- Discovery: shorten Bonjour DNS-SD service type to `_clawdbot-gw._tcp` and update discovery clients/docs. +- Discovery: shorten Bonjour DNS-SD service type to `_moltbot-gw._tcp` and update discovery clients/docs. - Diagnostics: export OTLP logs, correct queue depth tracking, and document message-flow telemetry. - Diagnostics: emit message-flow diagnostics across channels via shared dispatch. (#1244) - Diagnostics: gate heartbeat/webhook logging. (#1244) @@ -444,7 +444,7 @@ Status: unreleased. - Plugins: add Nextcloud Talk manifest for plugin config validation. (#1297) - Plugins: surface plugin load/register/config errors in gateway logs with plugin/source context. - CLI: preserve cron delivery settings when editing message payloads. (#1322) -- CLI: keep `clawdbot logs` output resilient to broken pipes while preserving progress output. +- CLI: keep `moltbot logs` output resilient to broken pipes while preserving progress output. - CLI: avoid duplicating --profile/--dev flags when formatting commands. - CLI: centralize CLI command registration to keep fast-path routing and program wiring in sync. (#1207) - CLI: keep banners on routed commands, restore config guarding outside fast-path routing, and tighten fast-path flag parsing while skipping console capture for extra speed. (#1195) @@ -462,7 +462,7 @@ Status: unreleased. - TUI: show generic empty-state text for searchable pickers. (#1201) - TUI: highlight model search matches and stabilize search ordering. - Configure: hide OpenRouter auto routing model from the model picker. (#1182) -- Memory: show total file counts + scan issues in `clawdbot memory status`. +- Memory: show total file counts + scan issues in `moltbot memory status`. - Memory: fall back to non-batch embeddings after repeated batch failures. - Memory: apply OpenAI batch defaults even without explicit remote config. - Memory: index atomically so failed reindex preserves the previous memory database. (#1151) @@ -472,7 +472,7 @@ Status: unreleased. - Memory: split overly long lines to keep embeddings under token limits. - Memory: skip empty chunks to avoid invalid embedding inputs. - Memory: split embedding batches to avoid OpenAI token limits during indexing. -- Memory: probe sqlite-vec availability in `clawdbot memory status`. +- Memory: probe sqlite-vec availability in `moltbot memory status`. - Exec approvals: enforce allowlist when ask is off. - Exec approvals: prefer raw command for node approvals/events. - Tools: show exec elevated flag before the command and keep it outside markdown in tool summaries. @@ -524,18 +524,18 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic ### Highlights - Hooks: add hooks system with bundled hooks, CLI tooling, and docs. (#1028) — thanks @ThomsenDrake. https://docs.molt.bot/hooks - Media: add inbound media understanding (image/audio/video) with provider + CLI fallbacks. https://docs.molt.bot/nodes/media-understanding -- Plugins: add Zalo Personal plugin (`@clawdbot/zalouser`) and unify channel directory for plugins. (#1032) — thanks @suminhthanh. https://docs.molt.bot/plugins/zalouser +- Plugins: add Zalo Personal plugin (`@moltbot/zalouser`) and unify channel directory for plugins. (#1032) — thanks @suminhthanh. https://docs.molt.bot/plugins/zalouser - Models: add Vercel AI Gateway auth choice + onboarding updates. (#1016) — thanks @timolins. https://docs.molt.bot/providers/vercel-ai-gateway - Sessions: add `session.identityLinks` for cross-platform DM session li nking. (#1033) — thanks @thewilloftheshadow. https://docs.molt.bot/concepts/session - Web search: add `country`/`language` parameters (schema + Brave API) and docs. (#1046) — thanks @YuriNachos. https://docs.molt.bot/tools/web ### Breaking -- **BREAKING:** `clawdbot message` and message tool now require `target` (dropping `to`/`channelId` for destinations). (#1034) — thanks @tobalsan. +- **BREAKING:** `moltbot message` and message tool now require `target` (dropping `to`/`channelId` for destinations). (#1034) — thanks @tobalsan. - **BREAKING:** Channel auth now prefers config over env for Discord/Telegram/Matrix (env is fallback only). (#1040) — thanks @thewilloftheshadow. - **BREAKING:** Drop legacy `chatType: "room"` support; use `chatType: "channel"`. - **BREAKING:** remove legacy provider-specific target resolution fallbacks; target resolution is centralized with plugin hints + directory lookups. -- **BREAKING:** `clawdbot hooks` is now `clawdbot webhooks`; hooks live under `clawdbot hooks`. https://docs.molt.bot/cli/webhooks -- **BREAKING:** `clawdbot plugins install ` now copies into `~/.clawdbot/extensions` (use `--link` to keep path-based loading). +- **BREAKING:** `moltbot hooks` is now `moltbot webhooks`; hooks live under `moltbot hooks`. https://docs.molt.bot/cli/webhooks +- **BREAKING:** `moltbot plugins install ` now copies into `~/.clawdbot/extensions` (use `--link` to keep path-based loading). ### Changes - Plugins: ship bundled plugins disabled by default and allow overrides by installed versions. (#1066) — thanks @ItzR3NO. @@ -553,7 +553,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Skills: update coding-agent guidance to prefer PTY-enabled exec runs and simplify tmux usage. - TUI: refresh session token counts after runs complete or fail. (#1079) — thanks @d-ploutarchos. - Status: trim `/status` to current-provider usage only and drop the OAuth/token block. -- Directory: unify `clawdbot directory` across channels and plugin channels. +- Directory: unify `moltbot directory` across channels and plugin channels. - UI: allow deleting sessions from the Control UI. - Memory: add sqlite-vec vector acceleration with CLI status details. - Memory: add experimental session transcript indexing for memory_search (opt-in via memorySearch.experimental.sessionMemory + sources). @@ -569,7 +569,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Docs: add `/help` hub, Node/npm PATH guide, and expand directory CLI docs. - Config: support env var substitution in config values. (#1044) — thanks @sebslight. - Health: add per-agent session summaries and account-level health details, and allow selective probes. (#1047) — thanks @gumadeiras. -- Hooks: add hook pack installs (npm/path/zip/tar) with `clawdbot.hooks` manifests and `clawdbot hooks install/update`. +- Hooks: add hook pack installs (npm/path/zip/tar) with `moltbot.hooks` manifests and `moltbot hooks install/update`. - Plugins: add zip installs and `--link` to avoid copying local paths. ### Fixes @@ -603,7 +603,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Security: default-deny slash/control commands unless a channel computed `CommandAuthorized` (fixes accidental “open” behavior), and ensure WhatsApp + Zalo plugin channels gate inline `/…` tokens correctly. https://docs.molt.bot/gateway/security - Security: redact sensitive text in gateway WS logs. - Tools: cap pending `exec` process output to avoid unbounded buffers. -- CLI: speed up `clawdbot sandbox-explain` by avoiding heavy plugin imports when normalizing channel ids. +- CLI: speed up `moltbot sandbox-explain` by avoiding heavy plugin imports when normalizing channel ids. - Browser: remote profile tab operations prefer persistent Playwright and avoid silent HTTP fallbacks. (#1057) — thanks @mukhtharcm. - Browser: remote profile tab ops follow-up: shared Playwright loader, Playwright-based focus, and more coverage (incl. opt-in live Browserless test). (follow-up to #1057) — thanks @mukhtharcm. - Browser: refresh extension relay tab metadata after navigation so `/json/list` stays current. (#1073) — thanks @roshanasingh4. @@ -629,19 +629,19 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic ## 2026.1.15 ### Highlights -- Plugins: add provider auth registry + `clawdbot models auth login` for plugin-driven OAuth/API key flows. +- Plugins: add provider auth registry + `moltbot models auth login` for plugin-driven OAuth/API key flows. - Browser: improve remote CDP/Browserless support (auth passthrough, `wss` upgrade, timeouts, clearer errors). - Heartbeat: per-agent configuration + 24h duplicate suppression. (#980) — thanks @voidserf. - Security: audit warns on weak model tiers; app nodes store auth tokens encrypted (Keychain/SecurePrefs). ### Breaking - **BREAKING:** iOS minimum version is now 18.0 to support Textual markdown rendering in native chat. (#702) -- **BREAKING:** Microsoft Teams is now a plugin; install `@clawdbot/msteams` via `clawdbot plugins install @clawdbot/msteams`. +- **BREAKING:** Microsoft Teams is now a plugin; install `@moltbot/msteams` via `moltbot plugins install @moltbot/msteams`. - **BREAKING:** Channel auth now prefers config over env for Discord/Telegram/Matrix (env is fallback only). (#1040) — thanks @thewilloftheshadow. ### Changes - UI/Apps: move channel/config settings to schema-driven forms and rename Connections → Channels. (#1040) — thanks @thewilloftheshadow. -- CLI: set process titles to `clawdbot-` for clearer process listings. +- CLI: set process titles to `moltbot-` for clearer process listings. - CLI/macOS: sync remote SSH target/identity to config and let `gateway status` auto-infer SSH targets (ssh-config aware). - Telegram: scope inline buttons with allowlist default + callback gating in DMs/groups. - Telegram: default reaction notifications to own. @@ -649,13 +649,13 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Heartbeat: tighten prompt guidance + suppress duplicate alerts for 24h. (#980) — thanks @voidserf. - Repo: ignore local identity files to avoid accidental commits. (#1001) — thanks @gerardward2007. - Sessions/Security: add `session.dmScope` for multi-user DM isolation and audit warnings. (#948) — thanks @Alphonse-arianee. -- Plugins: add provider auth registry + `clawdbot models auth login` for plugin-driven OAuth/API key flows. +- Plugins: add provider auth registry + `moltbot models auth login` for plugin-driven OAuth/API key flows. - Onboarding: switch channels setup to a single-select loop with per-channel actions and disabled hints in the picker. - TUI: show provider/model labels for the active session and default model. - Heartbeat: add per-agent heartbeat configuration and multi-agent docs example. - UI: show gateway auth guidance + doc link on unauthorized Control UI connections. - UI: add session deletion action in Control UI sessions list. (#1017) — thanks @Szpadel. -- Security: warn on weak model tiers (Haiku, below GPT-5, below Claude 4.5) in `clawdbot security audit`. +- Security: warn on weak model tiers (Haiku, below GPT-5, below Claude 4.5) in `moltbot security audit`. - Apps: store node auth tokens encrypted (Keychain/SecurePrefs). - Daemon: share profile/state-dir resolution across service helpers and honor `CLAWDBOT_STATE_DIR` for Windows task scripts. - Docs: clarify multi-gateway rescue bot guidance. (#969) — thanks @bjesuiter. @@ -665,8 +665,8 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Docs: add Date & Time guide and update prompt/timezone configuration docs. - Messages: debounce rapid inbound messages across channels with per-connector overrides. (#971) — thanks @juanpablodlc. - Messages: allow media-only sends (CLI/tool) and show Telegram voice recording status for voice notes. (#957) — thanks @rdev. -- Auth/Status: keep auth profiles sticky per session (rotate on compaction/new), surface provider usage headers in `/status` and `clawdbot models status`, and update docs. -- CLI: add `--json` output for `clawdbot daemon` lifecycle/install commands. +- Auth/Status: keep auth profiles sticky per session (rotate on compaction/new), surface provider usage headers in `/status` and `moltbot models status`, and update docs. +- CLI: add `--json` output for `moltbot daemon` lifecycle/install commands. - Memory: make `node-llama-cpp` an optional dependency (avoid Node 25 install failures) and improve local-embeddings fallback/errors. - Browser: add `snapshot refs=aria` (Playwright aria-ref ids) for self-resolving refs across `snapshot` → `act`. - Browser: `profile="chrome"` now defaults to host control and returns clearer “attach a tab” errors. @@ -689,10 +689,10 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - iMessage: treat missing `imsg rpc` support as fatal to avoid restart loops. - Auth: merge main auth profiles into per-agent stores for sub-agents and document inheritance. (#1013) — thanks @marcmarg. - Agents: avoid JSON Schema `format` collisions in tool params by renaming snapshot format fields. (#1013) — thanks @marcmarg. -- Fix: make `clawdbot update` auto-update global installs when installed via a package manager. +- Fix: make `moltbot update` auto-update global installs when installed via a package manager. - Fix: list model picker entries as provider/model pairs for explicit selection. (#970) — thanks @mcinteerj. - Fix: align OpenAI image-gen defaults with DALL-E 3 standard quality and document output formats. (#880) — thanks @mkbehr. -- Fix: persist `gateway.mode=local` after selecting Local run mode in `clawdbot configure`, even if no other sections are chosen. +- Fix: persist `gateway.mode=local` after selecting Local run mode in `moltbot configure`, even if no other sections are chosen. - Daemon: fix profile-aware service label resolution (env-driven) and add coverage for launchd/systemd/schtasks. (#969) — thanks @bjesuiter. - Agents: avoid false positives when logging unsupported Google tool schema keywords. - Agents: skip Gemini history downgrades for google-antigravity to preserve tool calls. (#894) — thanks @mukhtharcm. @@ -718,13 +718,13 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Web search: `web_search`/`web_fetch` tools (Brave API) + first-time setup in onboarding/configure. - Browser control: Chrome extension relay takeover mode + remote browser control support. - Plugins: channel plugins (gateway HTTP hooks) + Zalo plugin + onboarding install flow. (#854) — thanks @longmaba. -- Security: expanded `clawdbot security audit` (+ `--fix`), detect-secrets CI scan, and a `SECURITY.md` reporting policy. +- Security: expanded `moltbot security audit` (+ `--fix`), detect-secrets CI scan, and a `SECURITY.md` reporting policy. ### Changes - Docs: clarify per-agent auth stores, sandboxed skill binaries, and elevated semantics. - Docs: add FAQ entries for missing provider auth after adding agents and Gemini thinking signature errors. - Agents: add optional auth-profile copy prompt on `agents add` and improve auth error messaging. -- Security: expand `clawdbot security audit` checks (model hygiene, config includes, plugin allowlists, exposure matrix) and extend `--fix` to tighten more sensitive state paths. +- Security: expand `moltbot security audit` checks (model hygiene, config includes, plugin allowlists, exposure matrix) and extend `--fix` to tighten more sensitive state paths. - Security: add `SECURITY.md` reporting policy. - Channels: add Matrix plugin (external) with docs + onboarding hooks. - Plugins: add Zalo channel plugin with gateway HTTP hooks and onboarding install prompt. (#854) — thanks @longmaba. @@ -734,7 +734,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Security: add detect-secrets CI scan and baseline guidance. (#227) — thanks @Hyaxia. - Tools: add `web_search`/`web_fetch` (Brave API), auto-enable `web_fetch` for sandboxed sessions, and remove the `brave-search` skill. - CLI/Docs: add a web tools configure section for storing Brave API keys and update onboarding tips. -- Browser: add Chrome extension relay takeover mode (toolbar button), plus `clawdbot browser extension install/path` and remote browser control (standalone server + token auth). +- Browser: add Chrome extension relay takeover mode (toolbar button), plus `moltbot browser extension install/path` and remote browser control (standalone server + token auth). ### Fixes - Sessions: refactor session store updates to lock + mutate per-entry, add chat.inject, and harden subagent cleanup flow. (#944) — thanks @tyler6204. @@ -831,19 +831,19 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic ### New & Improved - Memory: add custom OpenAI-compatible embedding endpoints; support OpenAI/local `node-llama-cpp` embeddings with per-agent overrides and provider metadata in tools/CLI. (#819) — thanks @mukhtharcm. -- Memory: new `clawdbot memory` CLI plus `memory_search`/`memory_get` tools with snippets + line ranges; index stored under `~/.clawdbot/memory/{agentId}.sqlite` with watch-on-by-default. +- Memory: new `moltbot memory` CLI plus `memory_search`/`memory_get` tools with snippets + line ranges; index stored under `~/.clawdbot/memory/{agentId}.sqlite` with watch-on-by-default. - Agents: strengthen memory recall guidance; make workspace bootstrap truncation configurable (default 20k) with warnings; add default sub-agent model config. - Tools/Sandbox: add tool profiles + group shorthands; support tool-policy groups in `tools.sandbox.tools`; drop legacy `memory` shorthand; allow Docker bind mounts via `docker.binds`. (#790) — thanks @akonyer. - Tools: add provider/model-specific tool policy overrides (`tools.byProvider`) to trim tool exposure per provider. - Tools: add browser `scrollintoview` action; allow Claude/Gemini tool param aliases; allow thinking `xhigh` for GPT-5.2/Codex with safe downgrades. (#793) — thanks @hsrvc; (#444) — thanks @grp06. -- Gateway/CLI: add Tailscale binary discovery, custom bind mode, and probe auth retry; add `clawdbot dashboard` auto-open flow; default native slash commands to `"auto"` with per-provider overrides. (#740) — thanks @jeffersonwarrior. +- Gateway/CLI: add Tailscale binary discovery, custom bind mode, and probe auth retry; add `moltbot dashboard` auto-open flow; default native slash commands to `"auto"` with per-provider overrides. (#740) — thanks @jeffersonwarrior. - Auth/Onboarding: add Chutes OAuth (PKCE + refresh + onboarding choice); normalize API key inputs; default TUI onboarding to `deliver: false`. (#726) — thanks @FrieSei; (#791) — thanks @roshanasingh4. - Providers: add `discord.allowBots`; trim legacy MiniMax M2 from default catalogs; route MiniMax vision to the Coding Plan VLM endpoint (also accepts `@/path/to/file.png` inputs). (#802) — thanks @zknicker. - Gateway: allow Tailscale Serve identity headers to satisfy token auth; rebuild Control UI assets when protocol schema is newer. (#823) — thanks @roshanasingh4; (#786) — thanks @meaningfool. - Heartbeat: default `ackMaxChars` to 300 so short `HEARTBEAT_OK` replies stay internal. ### Installer -- Install: run `clawdbot doctor --non-interactive` after git installs/updates and nudge daemon restarts when detected. +- Install: run `moltbot doctor --non-interactive` after git installs/updates and nudge daemon restarts when detected. ### Fixes - Doctor: warn on pnpm workspace mismatches, missing Control UI assets, and missing tsx binaries; offer UI rebuilds. @@ -864,7 +864,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Telegram: preserve forum topic thread ids, persist polling offsets, respect account bindings in webhook mode, and show typing indicator in General topics. (#727, #739) — thanks @thewilloftheshadow; (#821) — thanks @gumadeiras; (#779) — thanks @azade-c. - Slack: accept slash commands with or without leading `/` for custom command configs. (#798) — thanks @thewilloftheshadow. - Cron: persist disabled jobs correctly; accept `jobId` aliases for update/run/remove params. (#205, #252) — thanks @thewilloftheshadow. -- Gateway/CLI: honor `CLAWDBOT_LAUNCHD_LABEL` / `CLAWDBOT_SYSTEMD_UNIT` overrides; `agents.list` respects explicit config; reduce noisy loopback WS logs during tests; run `clawdbot doctor --non-interactive` during updates. (#781) — thanks @ronyrus. +- Gateway/CLI: honor `CLAWDBOT_LAUNCHD_LABEL` / `CLAWDBOT_SYSTEMD_UNIT` overrides; `agents.list` respects explicit config; reduce noisy loopback WS logs during tests; run `moltbot doctor --non-interactive` during updates. (#781) — thanks @ronyrus. - Onboarding/Control UI: refuse invalid configs (run doctor first); quote Windows browser URLs for OAuth; keep chat scroll position unless the user is near the bottom. (#764) — thanks @mukhtharcm; (#794) — thanks @roshanasingh4; (#217) — thanks @thewilloftheshadow. - Tools/UI: harden tool input schemas for strict providers; drop null-only union variants for Gemini schema cleanup; treat `maxChars: 0` as unlimited; keep TUI last streamed response instead of "(no output)". (#782) — thanks @AbhisekBasu1; (#796) — thanks @gabriel-trigo; (#747) — thanks @thewilloftheshadow. - Connections UI: polish multi-account account cards. (#816) — thanks @steipete. @@ -893,7 +893,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Auto-reply: add compact `/model` picker (models + available providers) and show provider endpoints in `/model status`. - Control UI: add Config tab model presets (MiniMax M2.1, GLM 4.7, Kimi) for one-click setup. - Plugins: add extension loader (tools/RPC/CLI/services), discovery paths, and config schema + Control UI labels (uiHints). -- Plugins: add `clawdbot plugins install` (path/tgz/npm), plus `list|info|enable|disable|doctor` UX. +- Plugins: add `moltbot plugins install` (path/tgz/npm), plus `list|info|enable|disable|doctor` UX. - Plugins: voice-call plugin now real (Twilio/log), adds start/status RPC/CLI/tool + tests. - Docs: add plugins doc + cross-links from tools/skills/gateway config. - Docs: add beginner-friendly plugin quick start + expand Voice Call plugin docs. @@ -906,7 +906,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Agents: add pre-compaction memory flush config (`agents.defaults.compaction.*`) with a soft threshold + system prompt. - Config: add `$include` directive for modular config files. (#731) — thanks @pasogott. - Build: set pnpm minimum release age to 2880 minutes (2 days). (#718) — thanks @dan-dr. -- macOS: prompt to install the global `clawdbot` CLI when missing in local mode; install via `molt.bot/install-cli.sh` (no onboarding) and use external launchd/CLI instead of the embedded gateway runtime. +- macOS: prompt to install the global `moltbot` CLI when missing in local mode; install via `molt.bot/install-cli.sh` (no onboarding) and use external launchd/CLI instead of the embedded gateway runtime. - Docs: add gog calendar event color IDs from `gog calendar colors`. (#715) — thanks @mjrussell. - Cron/CLI: add `--model` flag to cron add/edit commands. (#711) — thanks @mjrussell. - Cron/CLI: trim model overrides on cron edits and document main-session guidance. (#711) — thanks @mjrussell. @@ -936,7 +936,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Auth: read Codex keychain credentials and make the lookup platform-aware. - macOS/Release: avoid bundling dist artifacts in relay builds and generate appcasts from zip-only sources. - Doctor: surface plugin diagnostics in the report. -- Plugins: treat `plugins.load.paths` directory entries as package roots when they contain `package.json` + `clawdbot.extensions`; load plugin packages from config dirs; extract archives without system tar. +- Plugins: treat `plugins.load.paths` directory entries as package roots when they contain `package.json` + `moltbot.extensions`; load plugin packages from config dirs; extract archives without system tar. - Config: expand `~` in `CLAWDBOT_CONFIG_PATH` and common path-like config fields (including `plugins.load.paths`); guard invalid `$include` paths. (#731) — thanks @pasogott. - Agents: stop pre-creating session transcripts so first user messages persist in JSONL history. - Agents: skip pre-compaction memory flush when the session workspace is read-only. @@ -965,9 +965,9 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic ## 2026.1.10 ### Highlights -- CLI: `clawdbot status` now table-based + shows OS/update/gateway/daemon/agents/sessions; `status --all` adds a full read-only debug report (tables, log tails, Tailscale summary, and scan progress via OSC-9 + spinner). +- CLI: `moltbot status` now table-based + shows OS/update/gateway/daemon/agents/sessions; `status --all` adds a full read-only debug report (tables, log tails, Tailscale summary, and scan progress via OSC-9 + spinner). - CLI Backends: add Codex CLI fallback with resume support (text output) and JSONL parsing for new runs, plus a live CLI resume probe. -- CLI: add `clawdbot update` (safe-ish git checkout update) + `--update` shorthand. (#673) — thanks @fm1randa. +- CLI: add `moltbot update` (safe-ish git checkout update) + `--update` shorthand. (#673) — thanks @fm1randa. - Gateway: add OpenAI-compatible `/v1/chat/completions` HTTP endpoint (auth, SSE streaming, per-agent routing). (#680). ### Changes @@ -977,7 +977,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Agents/Browser: add `browser.target` (sandbox/host/custom) with sandbox host-control gating via `agents.defaults.sandbox.browser.allowHostControl`, allowlists for custom control URLs/hosts/ports, and expand browser tool docs (remote control, profiles, internals). - Onboarding/Models: add catalog-backed default model picker to onboarding + configure. (#611) — thanks @jonasjancarik. - Agents/OpenCode Zen: update fallback models + defaults, keep legacy alias mappings. (#669) — thanks @magimetal. -- CLI: add `clawdbot reset` and `clawdbot uninstall` flows (interactive + non-interactive) plus docker cleanup smoke test. +- CLI: add `moltbot reset` and `moltbot uninstall` flows (interactive + non-interactive) plus docker cleanup smoke test. - Providers: move provider wiring to a plugin architecture. (#661). - Providers: unify group history context wrappers across providers with per-provider/per-account `historyLimit` overrides (fallback to `messages.groupChat.historyLimit`). Set `0` to disable. (#672). - Gateway/Heartbeat: optionally deliver heartbeat `Reasoning:` output (`agents.defaults.heartbeat.includeReasoning`). (#690) @@ -986,7 +986,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic ### Fixes - Auto-reply: suppress draft/typing streaming for `NO_REPLY` (silent system ops) so it doesn’t leak partial output. - CLI/Status: expand tables to full terminal width; clarify provider setup vs runtime warnings; richer per-provider detail; token previews in `status` while keeping `status --all` redacted; add troubleshooting link footer; keep log tails pasteable; show gateway auth used when reachable; surface provider runtime errors (Signal/iMessage/Slack); harden `tailscale status --json` parsing; make `status --all` scan progress determinate; and replace the footer with a 3-line “Next steps” recommendation (share/debug/probe). -- CLI/Gateway: clarify that `clawdbot gateway status` reports RPC health (connect + RPC) and shows RPC failures separately from connect failures. +- CLI/Gateway: clarify that `moltbot gateway status` reports RPC health (connect + RPC) and shows RPC failures separately from connect failures. - CLI/Update: gate progress spinner on stdout TTY and align clean-check step label. (#701) — thanks @bjesuiter. - Telegram: add `/whoami` + `/id` commands to reveal sender id for allowlists; allow `@username` and prefixed ids in `allowFrom` prompts (with stability warning). - Heartbeat: strip markup-wrapped `HEARTBEAT_OK` so acks don’t leak to external providers (e.g., Telegram). @@ -999,7 +999,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Agents/Pi: inject config `temperature`/`maxTokens` into streaming without replacing the session streamFn; cover with live maxTokens probe. (#732) — thanks @peschee. - macOS: clear unsigned launchd overrides on signed restarts and warn via doctor when attach-only/disable markers are set. (#695) — thanks @jeffersonwarrior. - Agents: enforce single-writer session locks and drop orphan tool results to prevent tool-call ID failures (MiniMax/Anthropic-compatible APIs). -- Docs: make `clawdbot status` the first diagnostic step, clarify `status --deep` behavior, and document `/whoami` + `/id`. +- Docs: make `moltbot status` the first diagnostic step, clarify `status --deep` behavior, and document `/whoami` + `/id`. - Docs/Testing: clarify live tool+image probes and how to list your testable `provider/model` ids. - Tests/Live: make gateway bash+read probes resilient to provider formatting while still validating real tool calls. - WhatsApp: detect @lid mentions in groups using authDir reverse mapping + resolve self JID E.164 for mention gating. (#692) — thanks @peschee. @@ -1019,7 +1019,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - WhatsApp: expose group participant IDs to the model so reactions can target the right sender. - Cron: `wakeMode: "now"` waits for heartbeat completion (and retries when the main lane is busy). (#666) — thanks @roshanasingh4. - Agents/OpenAI: fix Responses tool-only → follow-up turn handling (avoid standalone `reasoning` items that trigger 400 “required following item”) and replay reasoning items in Responses/Codex Responses history for tool-call-only turns. -- Sandbox: add `clawdbot sandbox explain` (effective policy inspector + fix-it keys); improve “sandbox jail” tool-policy/elevated errors with actionable config key paths; link to docs. +- Sandbox: add `moltbot sandbox explain` (effective policy inspector + fix-it keys); improve “sandbox jail” tool-policy/elevated errors with actionable config key paths; link to docs. - Hooks/Gmail: keep Tailscale serve path at `/` while preserving the public path. (#668) — thanks @antons. - Hooks/Gmail: allow Tailscale target URLs to preserve internal serve paths. - Auth: update Claude Code keychain credentials in-place during refresh sync; share JSON file helpers; add CLI fallback coverage. @@ -1031,12 +1031,12 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Gateway/Control UI: sniff image attachments for chat.send, drop non-images, and log mismatches. (#670) — thanks @cristip73. - macOS: force `restart-mac.sh --sign` to require identities and keep bundled Node signed for relay verification. (#580) — thanks @jeffersonwarrior. - Gateway/Agent: accept image attachments on `agent` (multimodal message) and add live gateway image probe (`CLAWDBOT_LIVE_GATEWAY_IMAGE_PROBE=1`). -- CLI: `clawdbot sessions` now includes `elev:*` + `usage:*` flags in the table output. +- CLI: `moltbot sessions` now includes `elev:*` + `usage:*` flags in the table output. - CLI/Pairing: accept positional provider for `pairing list|approve` (npm-run compatible); update docs/bot hints. -- Branding: normalize user-facing “ClawdBot”/“CLAWDBOT” → “Clawdbot” (CLI, status, docs). +- Branding: normalize legacy casing/branding to “Moltbot” (CLI, status, docs). - Auto-reply: fix native `/model` not updating the actual chat session (Telegram/Slack/Discord). (#646) -- Doctor: offer to run `clawdbot update` first on git installs (keeps doctor output aligned with latest). -- Doctor: avoid false legacy workspace warning when install dir is `~/clawdbot`. (#660) +- Doctor: offer to run `moltbot update` first on git installs (keeps doctor output aligned with latest). +- Doctor: avoid false legacy workspace warning when install dir is `~/moltbot`. (#660) - iMessage: fix reasoning persistence across DMs; avoid partial/duplicate replies when reasoning is enabled. (#655) — thanks @antons. - Models/Auth: allow MiniMax API configs without `models.providers.minimax.apiKey` (auth profiles / `MINIMAX_API_KEY`). (#656) — thanks @mneves75. - Agents: avoid duplicate replies when the message tool sends. (#659) — thanks @mickahouan. @@ -1067,12 +1067,12 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Control UI/TUI: queued messages, session links, reasoning view, mobile polish, logs UX. ### Breaking -- CLI: `clawdbot message` now subcommands (`message send|poll|...`) and requires `--provider` unless only one provider configured. +- CLI: `moltbot message` now subcommands (`message send|poll|...`) and requires `--provider` unless only one provider configured. - Commands/Tools: `/restart` and gateway restart tool disabled by default; enable with `commands.restart=true`. ### New Features and Changes - Models/Auth: OpenCode Zen onboarding (#623) — thanks @magimetal; MiniMax Anthropic-compatible API + hosted onboarding (#590, #495) — thanks @mneves75, @tobiasbischoff. -- Models/Auth: setup-token + token auth profiles; `clawdbot models auth order {get,set,clear}`; per-agent auth candidates in `/model status`; OAuth expiry checks in doctor/status. +- Models/Auth: setup-token + token auth profiles; `moltbot models auth order {get,set,clear}`; per-agent auth candidates in `/model status`; OAuth expiry checks in doctor/status. - Agent/System: claude-cli runner; `session_status` tool (and sandbox allow); adaptive context pruning default; system prompt messaging guidance + no auto self-update; eligible skills list injection; sub-agent context trimmed. - Commands: `/commands` list; `/models` alias; `/usage` alias; `/debug` runtime overrides + effective config view; `/config` chat updates + `/config get`; `config --section`. - CLI/Gateway: unified message tool + message subcommands; gateway discover (local + wide-area DNS-SD) with JSON/timeout; gateway status human-readable + JSON + SSH loopback; wide-area records include gatewayPort/sshPort/cliPath + tailnet DNS fallback. @@ -1104,7 +1104,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Signal: reaction handling safety; own-reaction matching (uuid+phone); UUID-only senders accepted; ignore reaction-only messages. - MS Teams: download image attachments reliably; fix top-level replies; stop on shutdown + honor chunk limits; normalize poll providers/deps; pairing label fixes. - iMessage: isolate group-ish threads by chat_id. -- Gateway/Daemon/Doctor: atomic config writes; repair gateway service entrypoint + install switches; non-interactive legacy migrations; systemd unit alignment + KillMode=process; node bridge keepalive/pings; Launch at Login persistence; bundle ClawdbotKit resources + Swift 6.2 compat dylib; relay version check + remove smoke test; regen Swift GatewayModels + keep agent provider string; cron jobId alias + channel alias migration + main session key normalization; heartbeat Telegram accountId resolution; avoid WhatsApp fallback for internal runs; gateway listener error wording; serveBaseUrl param; honor gateway --dev; fix wide-area discovery updates; align agents.defaults schema; provider account metadata in daemon status; refresh Carbon patch for gateway fixes; restore doctor prompter initialValue handling. +- Gateway/Daemon/Doctor: atomic config writes; repair gateway service entrypoint + install switches; non-interactive legacy migrations; systemd unit alignment + KillMode=process; node bridge keepalive/pings; Launch at Login persistence; bundle MoltbotKit resources + Swift 6.2 compat dylib; relay version check + remove smoke test; regen Swift GatewayModels + keep agent provider string; cron jobId alias + channel alias migration + main session key normalization; heartbeat Telegram accountId resolution; avoid WhatsApp fallback for internal runs; gateway listener error wording; serveBaseUrl param; honor gateway --dev; fix wide-area discovery updates; align agents.defaults schema; provider account metadata in daemon status; refresh Carbon patch for gateway fixes; restore doctor prompter initialValue handling. - Control UI/TUI: persist per-session verbose off + hide tool cards; logs tab opens at bottom; relative asset paths + landing cleanup; session labels lookup/persistence; stop pinning main session in recents; start logs at bottom; TUI status bar refresh + timeout handling + hide reasoning label when off. - Onboarding/Configure: QuickStart single-select provider picker; avoid Codex CLI false-expiry warnings; clarify WhatsApp owner prompt; fix Minimax hosted onboarding (agents.defaults + msteams heartbeat target); remove configure Control UI prompt; honor gateway --dev flag. @@ -1130,7 +1130,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Previously, if you didn’t configure an allowlist, your bot could be **open to anyone** (especially discoverable Telegram bots). - New default: DM pairing (`dmPolicy="pairing"` / `discord.dm.policy="pairing"` / `slack.dm.policy="pairing"`). - To keep old “open to everyone” behavior: set `dmPolicy="open"` and include `"*"` in the relevant `allowFrom` (Discord/Slack: `discord.dm.allowFrom` / `slack.dm.allowFrom`). - - Approve requests via `clawdbot pairing list ` + `clawdbot pairing approve `. + - Approve requests via `moltbot pairing list ` + `moltbot pairing approve `. - Sandbox: default `agent.sandbox.scope` to `"agent"` (one container/workspace per agent). Use `"session"` for per-session isolation; `"shared"` disables cross-session isolation. - Timestamps in agent envelopes are now UTC (compact `YYYY-MM-DDTHH:mmZ`); removed `messages.timestampPrefix`. Add `agent.userTimezone` to tell the model the user’s local time (system prompt only). - Model config schema changes (auth profiles + model lists); doctor auto-migrates and the gateway rewrites legacy configs on startup. @@ -1144,7 +1144,7 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - **Agent loop + compaction:** compaction/pruning tuning, overflow handling, safer bootstrap context, and per-provider threading/confirmations; opt-in tool-result pruning + compact tracking. - **Sandbox + tools:** per-agent sandbox overrides, workspaceAccess controls, session tool visibility, tool policy overrides, process isolation, and tool schema/timeout/reaction unification. - **Providers (Telegram/WhatsApp/Discord/Slack/Signal/iMessage):** retry/backoff, threading, reactions, media groups/attachments, mention gating, typing behavior, and error/log stability; long polling + forum topic isolation for Telegram. -- **Gateway/CLI UX:** `clawdbot logs`, cron list colors/aliases, docs search, agents list/add/delete flows, status usage snapshots, runtime/auth source display, and `/status`/commands auth unification. +- **Gateway/CLI UX:** `moltbot logs`, cron list colors/aliases, docs search, agents list/add/delete flows, status usage snapshots, runtime/auth source display, and `/status`/commands auth unification. - **Control UI/Web:** logs tab, focus mode polish, config form resilience, streaming stability, tool output caps, windowed chat history, and reconnect/password URL auth. - **macOS/Android/TUI/Build:** macOS gateway races, QR bundling, JSON5 config safety, Voice Wake hardening; Android EXIF rotation + APK naming/versioning; TUI key handling; tooling/bundling fixes. - **Packaging/compat:** npm dist folder coverage, Node 25 qrcode-terminal import fixes, Bun/Playwright/WebSocket patches, and Docker Bun install. @@ -1186,4 +1186,4 @@ Thanks @AlexMikhalev, @CoreyH, @John-Rood, @KrauseFx, @MaudeBot, @Nachx639, @Nic - Agent tools: honor `agent.tools` allow/deny policy even when sandbox is off. - Discord: avoid duplicate replies when OpenAI emits repeated `message_end` events. - Commands: unify /status (inline) and command auth across providers; group bypass for authorized control commands; remove Discord /clawd slash handler. -- CLI: run `clawdbot agent` via the Gateway by default; use `--local` to force embedded mode. +- CLI: run `moltbot agent` via the Gateway by default; use `--local` to force embedded mode. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d6eb0532f..509d5b11a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,11 +1,11 @@ -# Contributing to Clawdbot +# Contributing to Moltbot Welcome to the lobster tank! 🦞 ## Quick Links -- **GitHub:** https://github.com/clawdbot/clawdbot +- **GitHub:** https://github.com/moltbot/moltbot - **Discord:** https://discord.gg/qkhbAGHRBT -- **X/Twitter:** [@steipete](https://x.com/steipete) / [@clawdbot](https://x.com/clawdbot) +- **X/Twitter:** [@steipete](https://x.com/steipete) / [@moltbot](https://x.com/moltbot) ## Maintainers @@ -20,11 +20,11 @@ Welcome to the lobster tank! 🦞 ## How to Contribute 1. **Bugs & small fixes** → Open a PR! -2. **New features / architecture** → Start a [GitHub Discussion](https://github.com/clawdbot/clawdbot/discussions) or ask in Discord first +2. **New features / architecture** → Start a [GitHub Discussion](https://github.com/moltbot/moltbot/discussions) or ask in Discord first 3. **Questions** → Discord #setup-help ## Before You PR -- Test locally with your Clawdbot instance +- Test locally with your Moltbot instance - Run linter: `npm run lint` - Keep PRs focused (one thing per PR) - Describe what & why @@ -49,4 +49,4 @@ We are currently prioritizing: - **Skills**: Expanding the library of bundled skills and improving the Skill Creation developer experience. - **Performance**: Optimizing token usage and compaction logic. -Check the [GitHub Issues](https://github.com/clawdbot/clawdbot/issues) for "good first issue" labels! +Check the [GitHub Issues](https://github.com/moltbot/moltbot/issues) for "good first issue" labels! diff --git a/Dockerfile.sandbox-browser b/Dockerfile.sandbox-browser index 3b18917b1..8d8a08701 100644 --- a/Dockerfile.sandbox-browser +++ b/Dockerfile.sandbox-browser @@ -20,9 +20,9 @@ RUN apt-get update \ xvfb \ && rm -rf /var/lib/apt/lists/* -COPY scripts/sandbox-browser-entrypoint.sh /usr/local/bin/clawdbot-sandbox-browser -RUN chmod +x /usr/local/bin/clawdbot-sandbox-browser +COPY scripts/sandbox-browser-entrypoint.sh /usr/local/bin/moltbot-sandbox-browser +RUN chmod +x /usr/local/bin/moltbot-sandbox-browser EXPOSE 9222 5900 6080 -CMD ["clawdbot-sandbox-browser"] +CMD ["moltbot-sandbox-browser"] diff --git a/SECURITY.md b/SECURITY.md index 1d0849a54..414def17f 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -1,6 +1,6 @@ # Security Policy -If you believe you've found a security issue in Clawdbot, please report it privately. +If you believe you've found a security issue in Moltbot, please report it privately. ## Reporting @@ -9,19 +9,19 @@ If you believe you've found a security issue in Clawdbot, please report it priva ## Operational Guidance -For threat model + hardening guidance (including `clawdbot security audit --deep` and `--fix`), see: +For threat model + hardening guidance (including `moltbot security audit --deep` and `--fix`), see: - `https://docs.molt.bot/gateway/security` ### Web Interface Safety -Clawdbot's web interface is intended for local use only. Do **not** bind it to the public internet; it is not hardened for public exposure. +Moltbot's web interface is intended for local use only. Do **not** bind it to the public internet; it is not hardened for public exposure. ## Runtime Requirements ### Node.js Version -Clawdbot requires **Node.js 22.12.0 or later** (LTS). This version includes important security patches: +Moltbot requires **Node.js 22.12.0 or later** (LTS). This version includes important security patches: - CVE-2025-59466: async_hooks DoS vulnerability - CVE-2026-21636: Permission model bypass vulnerability @@ -34,7 +34,7 @@ node --version # Should be v22.12.0 or later ### Docker Security -When running Clawdbot in Docker: +When running Moltbot in Docker: 1. The official image runs as a non-root user (`node`) for reduced attack surface 2. Use `--read-only` flag when possible for additional filesystem protection @@ -44,8 +44,8 @@ Example secure Docker run: ```bash docker run --read-only --cap-drop=ALL \ - -v clawdbot-data:/app/data \ - clawdbot/clawdbot:latest + -v moltbot-data:/app/data \ + moltbot/moltbot:latest ``` ## Security Scanning diff --git a/appcast.xml b/appcast.xml index df325a7b6..568632fd7 100644 --- a/appcast.xml +++ b/appcast.xml @@ -1,31 +1,31 @@ - Clawdbot + Moltbot 2026.1.24-1 Sun, 25 Jan 2026 14:05:25 +0000 - https://raw.githubusercontent.com/clawdbot/clawdbot/main/appcast.xml + https://raw.githubusercontent.com/moltbot/moltbot/main/appcast.xml 7952 2026.1.24-1 15.0 - Clawdbot 2026.1.24-1 + Moltbot 2026.1.24-1

    Fixes

    • Packaging: include dist/shared output in npm tarball (fixes missing reasoning-tags import on install).
    -     +

    View full changelog

    ]]> - + 2026.1.24 Sun, 25 Jan 2026 13:31:05 +0000 - https://raw.githubusercontent.com/clawdbot/clawdbot/main/appcast.xml + https://raw.githubusercontent.com/moltbot/moltbot/main/appcast.xml 7944 2026.1.24 15.0 - Clawdbot 2026.1.24 + Moltbot 2026.1.24

    Highlights

    • Providers: Ollama discovery + docs; Venice guide upgrades + cross-links. (#1606) Thanks @abhaymundhara. https://docs.molt.bot/providers/ollama https://docs.molt.bot/providers/venice
      • @@ -93,18 +93,18 @@
    • Tests: avoid fake-timer dependency in embedded runner stream mock to reduce CI flakes. (#1597) Thanks @rohannagpal.
    • Tests: increase embedded runner ordering test timeout to reduce CI flakes. (#1597) Thanks @rohannagpal.
    -

    View full changelog

    +

    View full changelog

    ]]>     - +     2026.1.23 Sat, 24 Jan 2026 13:02:18 +0000 - https://raw.githubusercontent.com/clawdbot/clawdbot/main/appcast.xml + https://raw.githubusercontent.com/moltbot/moltbot/main/appcast.xml 7750 2026.1.23 15.0 - Clawdbot 2026.1.23 + Moltbot 2026.1.23

    Highlights

    • TTS: allow model-driven TTS tags by default for expressive audio replies (laughter, singing cues, etc.).
      • @@ -117,9 +117,9 @@
    • Browser: add node-host proxy auto-routing for remote gateways (configurable per gateway/node).
    • Heartbeat: add per-channel visibility controls (OK/alerts/indicator). (#1452) Thanks @dlauer.
    • Plugins: add optional llm-task JSON-only tool for workflows. (#1498) Thanks @vignesh07.
      • -
    • CLI: restart the gateway by default after clawdbot update; add --no-restart to skip it.
      • -
    • CLI: add live auth probes to clawdbot models status for per-profile verification.
      • -
    • CLI: add clawdbot system for system events + heartbeat controls; remove standalone wake.
      • +
    • CLI: restart the gateway by default after moltbot update; add --no-restart to skip it.
      • +
    • CLI: add live auth probes to moltbot models status for per-profile verification.
      • +
    • CLI: add moltbot system for system events + heartbeat controls; remove standalone wake.
    • Agents: add Bedrock auto-discovery defaults + config overrides. (#1553) Thanks @fal3.
    • Docs: add cron vs heartbeat decision guide (with Lobster workflow notes). (#1533) Thanks @JustYannicc.
    • Docs: clarify HEARTBEAT.md empty file skips heartbeats, missing file still runs. (#1535) Thanks @JustYannicc.
      • @@ -154,10 +154,10 @@
    • Exec: honor tools.exec ask/security defaults for elevated approvals (avoid unwanted prompts).
    • TUI: forward unknown slash commands (for example, /context) to the Gateway.
    • TUI: include Gateway slash commands in autocomplete and /help.
      • -
    • CLI: skip usage lines in clawdbot models status when provider usage is unavailable.
      • +
    • CLI: skip usage lines in moltbot models status when provider usage is unavailable.
    • CLI: suppress diagnostic session/run noise during auth probes.
    • CLI: hide auth probe timeout warnings from embedded runs.
      • -
    • CLI: render auth probe results as a table in clawdbot models status.
      • +
    • CLI: render auth probe results as a table in moltbot models status.
    • CLI: suppress probe-only embedded logs unless --verbose is set.
    • CLI: move auth probe errors below the table to reduce wrapping.
    • CLI: prevent ANSI color bleed when table cells wrap.
      • @@ -180,9 +180,9 @@
    • Browser: keep extension relay tabs controllable when the extension reuses a session id after switching tabs. (#1160)
    • Agents: warn and ignore tool allowlists that only reference unknown or unloaded plugin tools. (#1566)
    -

    View full changelog

    +

    View full changelog

    ]]>     - +     \ No newline at end of file diff --git a/apps/android/app/build.gradle.kts b/apps/android/app/build.gradle.kts index 85dc9c566..b9f7d7682 100644 --- a/apps/android/app/build.gradle.kts +++ b/apps/android/app/build.gradle.kts @@ -65,7 +65,7 @@ androidComponents { val versionName = output.versionName.orNull ?: "0" val buildType = variant.buildType - val outputFileName = "clawdbot-${versionName}-${buildType}.apk" + val outputFileName = "moltbot-${versionName}-${buildType}.apk" output.outputFileName = outputFileName } } diff --git a/apps/android/app/src/main/AndroidManifest.xml b/apps/android/app/src/main/AndroidManifest.xml index df2aa94b3..e0aab841e 100644 --- a/apps/android/app/src/main/AndroidManifest.xml +++ b/apps/android/app/src/main/AndroidManifest.xml @@ -32,7 +32,7 @@ android:label="@string/app_name" android:supportsRtl="true" android:networkSecurityConfig="@xml/network_security_config" - android:theme="@style/Theme.ClawdbotNode"> + android:theme="@style/Theme.MoltbotNode"> Quint(status, server, connected, voiceMode, voiceListening) }.collect { (status, server, connected, voiceMode, voiceListening) -> - val title = if (connected) "Clawdbot Node · Connected" else "Clawdbot Node" + val title = if (connected) "Moltbot Node · Connected" else "Moltbot Node" val voiceSuffix = if (voiceMode == VoiceWakeMode.Always) { if (voiceListening) " · Voice Wake: Listening" else " · Voice Wake: Paused" @@ -91,7 +91,7 @@ class NodeForegroundService : Service() { "Connection", NotificationManager.IMPORTANCE_LOW, ).apply { - description = "Clawdbot node connection status" + description = "Moltbot node connection status" setShowBadge(false) } mgr.createNotificationChannel(channel) diff --git a/apps/android/app/src/main/java/com/clawdbot/android/NodeRuntime.kt b/apps/android/app/src/main/java/com/clawdbot/android/NodeRuntime.kt index 603e4b82b..46e486100 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/NodeRuntime.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/NodeRuntime.kt @@ -26,14 +26,14 @@ import com.clawdbot.android.BuildConfig import com.clawdbot.android.node.CanvasController import com.clawdbot.android.node.ScreenRecordManager import com.clawdbot.android.node.SmsManager -import com.clawdbot.android.protocol.ClawdbotCapability -import com.clawdbot.android.protocol.ClawdbotCameraCommand -import com.clawdbot.android.protocol.ClawdbotCanvasA2UIAction -import com.clawdbot.android.protocol.ClawdbotCanvasA2UICommand -import com.clawdbot.android.protocol.ClawdbotCanvasCommand -import com.clawdbot.android.protocol.ClawdbotScreenCommand -import com.clawdbot.android.protocol.ClawdbotLocationCommand -import com.clawdbot.android.protocol.ClawdbotSmsCommand +import com.clawdbot.android.protocol.MoltbotCapability +import com.clawdbot.android.protocol.MoltbotCameraCommand +import com.clawdbot.android.protocol.MoltbotCanvasA2UIAction +import com.clawdbot.android.protocol.MoltbotCanvasA2UICommand +import com.clawdbot.android.protocol.MoltbotCanvasCommand +import com.clawdbot.android.protocol.MoltbotScreenCommand +import com.clawdbot.android.protocol.MoltbotLocationCommand +import com.clawdbot.android.protocol.MoltbotSmsCommand import com.clawdbot.android.voice.TalkModeManager import com.clawdbot.android.voice.VoiceWakeManager import kotlinx.coroutines.CoroutineScope @@ -451,38 +451,38 @@ class NodeRuntime(context: Context) { private fun buildInvokeCommands(): List = buildList { - add(ClawdbotCanvasCommand.Present.rawValue) - add(ClawdbotCanvasCommand.Hide.rawValue) - add(ClawdbotCanvasCommand.Navigate.rawValue) - add(ClawdbotCanvasCommand.Eval.rawValue) - add(ClawdbotCanvasCommand.Snapshot.rawValue) - add(ClawdbotCanvasA2UICommand.Push.rawValue) - add(ClawdbotCanvasA2UICommand.PushJSONL.rawValue) - add(ClawdbotCanvasA2UICommand.Reset.rawValue) - add(ClawdbotScreenCommand.Record.rawValue) + add(MoltbotCanvasCommand.Present.rawValue) + add(MoltbotCanvasCommand.Hide.rawValue) + add(MoltbotCanvasCommand.Navigate.rawValue) + add(MoltbotCanvasCommand.Eval.rawValue) + add(MoltbotCanvasCommand.Snapshot.rawValue) + add(MoltbotCanvasA2UICommand.Push.rawValue) + add(MoltbotCanvasA2UICommand.PushJSONL.rawValue) + add(MoltbotCanvasA2UICommand.Reset.rawValue) + add(MoltbotScreenCommand.Record.rawValue) if (cameraEnabled.value) { - add(ClawdbotCameraCommand.Snap.rawValue) - add(ClawdbotCameraCommand.Clip.rawValue) + add(MoltbotCameraCommand.Snap.rawValue) + add(MoltbotCameraCommand.Clip.rawValue) } if (locationMode.value != LocationMode.Off) { - add(ClawdbotLocationCommand.Get.rawValue) + add(MoltbotLocationCommand.Get.rawValue) } if (sms.canSendSms()) { - add(ClawdbotSmsCommand.Send.rawValue) + add(MoltbotSmsCommand.Send.rawValue) } } private fun buildCapabilities(): List = buildList { - add(ClawdbotCapability.Canvas.rawValue) - add(ClawdbotCapability.Screen.rawValue) - if (cameraEnabled.value) add(ClawdbotCapability.Camera.rawValue) - if (sms.canSendSms()) add(ClawdbotCapability.Sms.rawValue) + add(MoltbotCapability.Canvas.rawValue) + add(MoltbotCapability.Screen.rawValue) + if (cameraEnabled.value) add(MoltbotCapability.Camera.rawValue) + if (sms.canSendSms()) add(MoltbotCapability.Sms.rawValue) if (voiceWakeMode.value != VoiceWakeMode.Off && hasRecordAudioPermission()) { - add(ClawdbotCapability.VoiceWake.rawValue) + add(MoltbotCapability.VoiceWake.rawValue) } if (locationMode.value != LocationMode.Off) { - add(ClawdbotCapability.Location.rawValue) + add(MoltbotCapability.Location.rawValue) } } @@ -506,7 +506,7 @@ class NodeRuntime(context: Context) { val version = resolvedVersionName() val release = Build.VERSION.RELEASE?.trim().orEmpty() val releaseLabel = if (release.isEmpty()) "unknown" else release - return "ClawdbotAndroid/$version (Android $releaseLabel; SDK ${Build.VERSION.SDK_INT})" + return "MoltbotAndroid/$version (Android $releaseLabel; SDK ${Build.VERSION.SDK_INT})" } private fun buildClientInfo(clientId: String, clientMode: String): GatewayClientInfo { @@ -529,7 +529,7 @@ class NodeRuntime(context: Context) { caps = buildCapabilities(), commands = buildInvokeCommands(), permissions = emptyMap(), - client = buildClientInfo(clientId = "clawdbot-android", clientMode = "node"), + client = buildClientInfo(clientId = "moltbot-android", clientMode = "node"), userAgent = buildUserAgent(), ) } @@ -541,7 +541,7 @@ class NodeRuntime(context: Context) { caps = emptyList(), commands = emptyList(), permissions = emptyMap(), - client = buildClientInfo(clientId = "clawdbot-control-ui", clientMode = "ui"), + client = buildClientInfo(clientId = "moltbot-control-ui", clientMode = "ui"), userAgent = buildUserAgent(), ) } @@ -665,7 +665,7 @@ class NodeRuntime(context: Context) { val actionId = (userActionObj["id"] as? JsonPrimitive)?.content?.trim().orEmpty().ifEmpty { java.util.UUID.randomUUID().toString() } - val name = ClawdbotCanvasA2UIAction.extractActionName(userActionObj) ?: return@launch + val name = MoltbotCanvasA2UIAction.extractActionName(userActionObj) ?: return@launch val surfaceId = (userActionObj["surfaceId"] as? JsonPrimitive)?.content?.trim().orEmpty().ifEmpty { "main" } @@ -675,7 +675,7 @@ class NodeRuntime(context: Context) { val sessionKey = resolveMainSessionKey() val message = - ClawdbotCanvasA2UIAction.formatAgentMessage( + MoltbotCanvasA2UIAction.formatAgentMessage( actionName = name, sessionKey = sessionKey, surfaceId = surfaceId, @@ -709,7 +709,7 @@ class NodeRuntime(context: Context) { try { canvas.eval( - ClawdbotCanvasA2UIAction.jsDispatchA2UIActionStatus( + MoltbotCanvasA2UIAction.jsDispatchA2UIActionStatus( actionId = actionId, ok = connected && error == null, error = error, @@ -827,10 +827,10 @@ class NodeRuntime(context: Context) { private suspend fun handleInvoke(command: String, paramsJson: String?): GatewaySession.InvokeResult { if ( - command.startsWith(ClawdbotCanvasCommand.NamespacePrefix) || - command.startsWith(ClawdbotCanvasA2UICommand.NamespacePrefix) || - command.startsWith(ClawdbotCameraCommand.NamespacePrefix) || - command.startsWith(ClawdbotScreenCommand.NamespacePrefix) + command.startsWith(MoltbotCanvasCommand.NamespacePrefix) || + command.startsWith(MoltbotCanvasA2UICommand.NamespacePrefix) || + command.startsWith(MoltbotCameraCommand.NamespacePrefix) || + command.startsWith(MoltbotScreenCommand.NamespacePrefix) ) { if (!isForeground.value) { return GatewaySession.InvokeResult.error( @@ -839,13 +839,13 @@ class NodeRuntime(context: Context) { ) } } - if (command.startsWith(ClawdbotCameraCommand.NamespacePrefix) && !cameraEnabled.value) { + if (command.startsWith(MoltbotCameraCommand.NamespacePrefix) && !cameraEnabled.value) { return GatewaySession.InvokeResult.error( code = "CAMERA_DISABLED", message = "CAMERA_DISABLED: enable Camera in Settings", ) } - if (command.startsWith(ClawdbotLocationCommand.NamespacePrefix) && + if (command.startsWith(MoltbotLocationCommand.NamespacePrefix) && locationMode.value == LocationMode.Off ) { return GatewaySession.InvokeResult.error( @@ -855,18 +855,18 @@ class NodeRuntime(context: Context) { } return when (command) { - ClawdbotCanvasCommand.Present.rawValue -> { + MoltbotCanvasCommand.Present.rawValue -> { val url = CanvasController.parseNavigateUrl(paramsJson) canvas.navigate(url) GatewaySession.InvokeResult.ok(null) } - ClawdbotCanvasCommand.Hide.rawValue -> GatewaySession.InvokeResult.ok(null) - ClawdbotCanvasCommand.Navigate.rawValue -> { + MoltbotCanvasCommand.Hide.rawValue -> GatewaySession.InvokeResult.ok(null) + MoltbotCanvasCommand.Navigate.rawValue -> { val url = CanvasController.parseNavigateUrl(paramsJson) canvas.navigate(url) GatewaySession.InvokeResult.ok(null) } - ClawdbotCanvasCommand.Eval.rawValue -> { + MoltbotCanvasCommand.Eval.rawValue -> { val js = CanvasController.parseEvalJs(paramsJson) ?: return GatewaySession.InvokeResult.error( @@ -884,7 +884,7 @@ class NodeRuntime(context: Context) { } GatewaySession.InvokeResult.ok("""{"result":${result.toJsonString()}}""") } - ClawdbotCanvasCommand.Snapshot.rawValue -> { + MoltbotCanvasCommand.Snapshot.rawValue -> { val snapshotParams = CanvasController.parseSnapshotParams(paramsJson) val base64 = try { @@ -901,7 +901,7 @@ class NodeRuntime(context: Context) { } GatewaySession.InvokeResult.ok("""{"format":"${snapshotParams.format.rawValue}","base64":"$base64"}""") } - ClawdbotCanvasA2UICommand.Reset.rawValue -> { + MoltbotCanvasA2UICommand.Reset.rawValue -> { val a2uiUrl = resolveA2uiHostUrl() ?: return GatewaySession.InvokeResult.error( code = "A2UI_HOST_NOT_CONFIGURED", @@ -917,7 +917,7 @@ class NodeRuntime(context: Context) { val res = canvas.eval(a2uiResetJS) GatewaySession.InvokeResult.ok(res) } - ClawdbotCanvasA2UICommand.Push.rawValue, ClawdbotCanvasA2UICommand.PushJSONL.rawValue -> { + MoltbotCanvasA2UICommand.Push.rawValue, MoltbotCanvasA2UICommand.PushJSONL.rawValue -> { val messages = try { decodeA2uiMessages(command, paramsJson) @@ -940,7 +940,7 @@ class NodeRuntime(context: Context) { val res = canvas.eval(js) GatewaySession.InvokeResult.ok(res) } - ClawdbotCameraCommand.Snap.rawValue -> { + MoltbotCameraCommand.Snap.rawValue -> { showCameraHud(message = "Taking photo…", kind = CameraHudKind.Photo) triggerCameraFlash() val res = @@ -954,7 +954,7 @@ class NodeRuntime(context: Context) { showCameraHud(message = "Photo captured", kind = CameraHudKind.Success, autoHideMs = 1600) GatewaySession.InvokeResult.ok(res.payloadJson) } - ClawdbotCameraCommand.Clip.rawValue -> { + MoltbotCameraCommand.Clip.rawValue -> { val includeAudio = paramsJson?.contains("\"includeAudio\":true") != false if (includeAudio) externalAudioCaptureActive.value = true try { @@ -973,7 +973,7 @@ class NodeRuntime(context: Context) { if (includeAudio) externalAudioCaptureActive.value = false } } - ClawdbotLocationCommand.Get.rawValue -> { + MoltbotLocationCommand.Get.rawValue -> { val mode = locationMode.value if (!isForeground.value && mode != LocationMode.Always) { return GatewaySession.InvokeResult.error( @@ -1026,7 +1026,7 @@ class NodeRuntime(context: Context) { GatewaySession.InvokeResult.error(code = "LOCATION_UNAVAILABLE", message = message) } } - ClawdbotScreenCommand.Record.rawValue -> { + MoltbotScreenCommand.Record.rawValue -> { // Status pill mirrors screen recording state so it stays visible without overlay stacking. _screenRecordActive.value = true try { @@ -1042,7 +1042,7 @@ class NodeRuntime(context: Context) { _screenRecordActive.value = false } } - ClawdbotSmsCommand.Send.rawValue -> { + MoltbotSmsCommand.Send.rawValue -> { val res = sms.send(paramsJson) if (res.ok) { GatewaySession.InvokeResult.ok(res.payloadJson) @@ -1115,7 +1115,7 @@ class NodeRuntime(context: Context) { val raw = if (nodeRaw.isNotBlank()) nodeRaw else operatorRaw if (raw.isBlank()) return null val base = raw.trimEnd('/') - return "${base}/__clawdbot__/a2ui/?platform=android" + return "${base}/__moltbot__/a2ui/?platform=android" } private suspend fun ensureA2uiReady(a2uiUrl: String): Boolean { @@ -1150,7 +1150,7 @@ class NodeRuntime(context: Context) { val jsonlField = (obj["jsonl"] as? JsonPrimitive)?.content?.trim().orEmpty() val hasMessagesArray = obj["messages"] is JsonArray - if (command == ClawdbotCanvasA2UICommand.PushJSONL.rawValue || (!hasMessagesArray && jsonlField.isNotBlank())) { + if (command == MoltbotCanvasA2UICommand.PushJSONL.rawValue || (!hasMessagesArray && jsonlField.isNotBlank())) { val jsonl = jsonlField if (jsonl.isBlank()) throw IllegalArgumentException("INVALID_REQUEST: jsonl required") val messages = @@ -1218,7 +1218,7 @@ private const val a2uiResetJS: String = """ (() => { try { - if (!globalThis.clawdbotA2UI) return { ok: false, error: "missing clawdbotA2UI" }; + if (!globalThis.clawdbotA2UI) return { ok: false, error: "missing moltbotA2UI" }; return globalThis.clawdbotA2UI.reset(); } catch (e) { return { ok: false, error: String(e?.message ?? e) }; @@ -1230,7 +1230,7 @@ private fun a2uiApplyMessagesJS(messagesJson: String): String { return """ (() => { try { - if (!globalThis.clawdbotA2UI) return { ok: false, error: "missing clawdbotA2UI" }; + if (!globalThis.clawdbotA2UI) return { ok: false, error: "missing moltbotA2UI" }; const messages = $messagesJson; return globalThis.clawdbotA2UI.applyMessages(messages); } catch (e) { diff --git a/apps/android/app/src/main/java/com/clawdbot/android/PermissionRequester.kt b/apps/android/app/src/main/java/com/clawdbot/android/PermissionRequester.kt index fa294aa24..5e95d7b27 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/PermissionRequester.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/PermissionRequester.kt @@ -115,7 +115,7 @@ class PermissionRequester(private val activity: ComponentActivity) { private fun buildRationaleMessage(permissions: List): String { val labels = permissions.map { permissionLabel(it) } - return "Clawdbot needs ${labels.joinToString(", ")} permissions to continue." + return "Moltbot needs ${labels.joinToString(", ")} permissions to continue." } private fun buildSettingsMessage(permissions: List): String { diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ScreenCaptureRequester.kt b/apps/android/app/src/main/java/com/clawdbot/android/ScreenCaptureRequester.kt index d270d5273..f7cf6708c 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/ScreenCaptureRequester.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/ScreenCaptureRequester.kt @@ -55,7 +55,7 @@ class ScreenCaptureRequester(private val activity: ComponentActivity) { suspendCancellableCoroutine { cont -> AlertDialog.Builder(activity) .setTitle("Screen recording required") - .setMessage("Clawdbot needs to record the screen for this command.") + .setMessage("Moltbot needs to record the screen for this command.") .setPositiveButton("Continue") { _, _ -> cont.resume(true) } .setNegativeButton("Not now") { _, _ -> cont.resume(false) } .setOnCancelListener { cont.resume(false) } diff --git a/apps/android/app/src/main/java/com/clawdbot/android/SecurePrefs.kt b/apps/android/app/src/main/java/com/clawdbot/android/SecurePrefs.kt index cd6270dd5..1c464f961 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/SecurePrefs.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/SecurePrefs.kt @@ -31,7 +31,7 @@ class SecurePrefs(context: Context) { private val prefs = EncryptedSharedPreferences.create( context, - "clawdbot.node.secure", + "moltbot.node.secure", masterKey, EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV, EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM, diff --git a/apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceIdentityStore.kt b/apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceIdentityStore.kt index 72500b750..4499e0ce7 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceIdentityStore.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceIdentityStore.kt @@ -21,7 +21,7 @@ data class DeviceIdentity( class DeviceIdentityStore(context: Context) { private val json = Json { ignoreUnknownKeys = true } - private val identityFile = File(context.filesDir, "clawdbot/identity/device.json") + private val identityFile = File(context.filesDir, "moltbot/identity/device.json") @Synchronized fun loadOrCreate(): DeviceIdentity { diff --git a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayDiscovery.kt b/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayDiscovery.kt index 121a95485..b1d50e28b 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayDiscovery.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayDiscovery.kt @@ -51,9 +51,9 @@ class GatewayDiscovery( private val nsd = context.getSystemService(NsdManager::class.java) private val connectivity = context.getSystemService(ConnectivityManager::class.java) private val dns = DnsResolver.getInstance() - private val serviceType = "_clawdbot-gw._tcp." - private val wideAreaDomain = "clawdbot.internal." - private val logTag = "Clawdbot/GatewayDiscovery" + private val serviceType = "_moltbot-gw._tcp." + private val wideAreaDomain = "moltbot.internal." + private val logTag = "Moltbot/GatewayDiscovery" private val localById = ConcurrentHashMap() private val unicastById = ConcurrentHashMap() diff --git a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewaySession.kt b/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewaySession.kt index ddd249a8e..a54460e0a 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewaySession.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewaySession.kt @@ -148,7 +148,7 @@ class GatewaySession( try { conn.request("node.event", params, timeoutMs = 8_000) } catch (err: Throwable) { - Log.w("ClawdbotGateway", "node.event failed: ${err.message ?: err::class.java.simpleName}") + Log.w("MoltbotGateway", "node.event failed: ${err.message ?: err::class.java.simpleName}") } } @@ -181,7 +181,7 @@ class GatewaySession( private val connectNonceDeferred = CompletableDeferred() private val client: OkHttpClient = buildClient() private var socket: WebSocket? = null - private val loggerTag = "ClawdbotGateway" + private val loggerTag = "MoltbotGateway" val remoteAddress: String = if (endpoint.host.contains(":")) { diff --git a/apps/android/app/src/main/java/com/clawdbot/android/node/CameraCaptureManager.kt b/apps/android/app/src/main/java/com/clawdbot/android/node/CameraCaptureManager.kt index 0361c2e55..f4c4d5794 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/node/CameraCaptureManager.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/node/CameraCaptureManager.kt @@ -155,7 +155,7 @@ class CameraCaptureManager(private val context: Context) { provider.unbindAll() provider.bindToLifecycle(owner, selector, videoCapture) - val file = File.createTempFile("clawdbot-clip-", ".mp4") + val file = File.createTempFile("moltbot-clip-", ".mp4") val outputOptions = FileOutputOptions.Builder(file).build() val finalized = kotlinx.coroutines.CompletableDeferred() @@ -285,7 +285,7 @@ private suspend fun Context.cameraProvider(): ProcessCameraProvider = /** Returns (jpegBytes, exifOrientation) so caller can rotate the decoded bitmap. */ private suspend fun ImageCapture.takeJpegWithExif(executor: Executor): Pair = suspendCancellableCoroutine { cont -> - val file = File.createTempFile("clawdbot-snap-", ".jpg") + val file = File.createTempFile("moltbot-snap-", ".jpg") val options = ImageCapture.OutputFileOptions.Builder(file).build() takePicture( options, diff --git a/apps/android/app/src/main/java/com/clawdbot/android/node/CanvasController.kt b/apps/android/app/src/main/java/com/clawdbot/android/node/CanvasController.kt index c7c7a76e1..4c955f7ea 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/node/CanvasController.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/node/CanvasController.kt @@ -84,12 +84,12 @@ class CanvasController { withWebViewOnMain { wv -> if (currentUrl == null) { if (BuildConfig.DEBUG) { - Log.d("ClawdbotCanvas", "load scaffold: $scaffoldAssetUrl") + Log.d("MoltbotCanvas", "load scaffold: $scaffoldAssetUrl") } wv.loadUrl(scaffoldAssetUrl) } else { if (BuildConfig.DEBUG) { - Log.d("ClawdbotCanvas", "load url: $currentUrl") + Log.d("MoltbotCanvas", "load url: $currentUrl") } wv.loadUrl(currentUrl) } @@ -106,7 +106,7 @@ class CanvasController { val js = """ (() => { try { - const api = globalThis.__clawdbot; + const api = globalThis.__moltbot; if (!api) return; if (typeof api.setDebugStatusEnabled === 'function') { api.setDebugStatusEnabled(${if (enabled) "true" else "false"}); diff --git a/apps/android/app/src/main/java/com/clawdbot/android/node/ScreenRecordManager.kt b/apps/android/app/src/main/java/com/clawdbot/android/node/ScreenRecordManager.kt index 82e805530..4486fc5f0 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/node/ScreenRecordManager.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/node/ScreenRecordManager.kt @@ -63,7 +63,7 @@ class ScreenRecordManager(private val context: Context) { val height = metrics.heightPixels val densityDpi = metrics.densityDpi - val file = File.createTempFile("clawdbot-screen-", ".mp4") + val file = File.createTempFile("moltbot-screen-", ".mp4") if (includeAudio) ensureMicPermission() val recorder = createMediaRecorder() @@ -90,7 +90,7 @@ class ScreenRecordManager(private val context: Context) { val surface = recorder.surface virtualDisplay = projection.createVirtualDisplay( - "clawdbot-screen", + "moltbot-screen", width, height, densityDpi, diff --git a/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIAction.kt b/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIAction.kt index a6d6ee136..4ff1a7421 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIAction.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIAction.kt @@ -3,7 +3,7 @@ package com.clawdbot.android.protocol import kotlinx.serialization.json.JsonObject import kotlinx.serialization.json.JsonPrimitive -object ClawdbotCanvasA2UIAction { +object MoltbotCanvasA2UIAction { fun extractActionName(userAction: JsonObject): String? { val name = (userAction["name"] as? JsonPrimitive) @@ -61,6 +61,6 @@ object ClawdbotCanvasA2UIAction { val err = (error ?: "").replace("\\", "\\\\").replace("\"", "\\\"") val okLiteral = if (ok) "true" else "false" val idEscaped = actionId.replace("\\", "\\\\").replace("\"", "\\\"") - return "window.dispatchEvent(new CustomEvent('clawdbot:a2ui-action-status', { detail: { id: \"${idEscaped}\", ok: ${okLiteral}, error: \"${err}\" } }));" + return "window.dispatchEvent(new CustomEvent('moltbot:a2ui-action-status', { detail: { id: \"${idEscaped}\", ok: ${okLiteral}, error: \"${err}\" } }));" } } diff --git a/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotProtocolConstants.kt b/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotProtocolConstants.kt index bfdb5f782..09a8bb49d 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotProtocolConstants.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotProtocolConstants.kt @@ -1,6 +1,6 @@ package com.clawdbot.android.protocol -enum class ClawdbotCapability(val rawValue: String) { +enum class MoltbotCapability(val rawValue: String) { Canvas("canvas"), Camera("camera"), Screen("screen"), @@ -9,7 +9,7 @@ enum class ClawdbotCapability(val rawValue: String) { Location("location"), } -enum class ClawdbotCanvasCommand(val rawValue: String) { +enum class MoltbotCanvasCommand(val rawValue: String) { Present("canvas.present"), Hide("canvas.hide"), Navigate("canvas.navigate"), @@ -22,7 +22,7 @@ enum class ClawdbotCanvasCommand(val rawValue: String) { } } -enum class ClawdbotCanvasA2UICommand(val rawValue: String) { +enum class MoltbotCanvasA2UICommand(val rawValue: String) { Push("canvas.a2ui.push"), PushJSONL("canvas.a2ui.pushJSONL"), Reset("canvas.a2ui.reset"), @@ -33,7 +33,7 @@ enum class ClawdbotCanvasA2UICommand(val rawValue: String) { } } -enum class ClawdbotCameraCommand(val rawValue: String) { +enum class MoltbotCameraCommand(val rawValue: String) { Snap("camera.snap"), Clip("camera.clip"), ; @@ -43,7 +43,7 @@ enum class ClawdbotCameraCommand(val rawValue: String) { } } -enum class ClawdbotScreenCommand(val rawValue: String) { +enum class MoltbotScreenCommand(val rawValue: String) { Record("screen.record"), ; @@ -52,7 +52,7 @@ enum class ClawdbotScreenCommand(val rawValue: String) { } } -enum class ClawdbotSmsCommand(val rawValue: String) { +enum class MoltbotSmsCommand(val rawValue: String) { Send("sms.send"), ; @@ -61,7 +61,7 @@ enum class ClawdbotSmsCommand(val rawValue: String) { } } -enum class ClawdbotLocationCommand(val rawValue: String) { +enum class MoltbotLocationCommand(val rawValue: String) { Get("location.get"), ; diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/ClawdbotTheme.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/ClawdbotTheme.kt index 0eea8da39..01d5a6796 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/ClawdbotTheme.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/ui/ClawdbotTheme.kt @@ -9,7 +9,7 @@ import androidx.compose.ui.graphics.Color import androidx.compose.ui.platform.LocalContext @Composable -fun ClawdbotTheme(content: @Composable () -> Unit) { +fun MoltbotTheme(content: @Composable () -> Unit) { val context = LocalContext.current val isDark = isSystemInDarkTheme() val colorScheme = if (isDark) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context) diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/RootScreen.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/RootScreen.kt index 96d2543a7..763052559 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/RootScreen.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/ui/RootScreen.kt @@ -333,7 +333,7 @@ private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier) disableForceDarkIfSupported(settings) } if (isDebuggable) { - Log.d("ClawdbotWebView", "userAgent: ${settings.userAgentString}") + Log.d("MoltbotWebView", "userAgent: ${settings.userAgentString}") } isScrollContainer = true overScrollMode = View.OVER_SCROLL_IF_CONTENT_SCROLLS @@ -348,7 +348,7 @@ private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier) ) { if (!isDebuggable) return if (!request.isForMainFrame) return - Log.e("ClawdbotWebView", "onReceivedError: ${error.errorCode} ${error.description} ${request.url}") + Log.e("MoltbotWebView", "onReceivedError: ${error.errorCode} ${error.description} ${request.url}") } override fun onReceivedHttpError( @@ -359,14 +359,14 @@ private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier) if (!isDebuggable) return if (!request.isForMainFrame) return Log.e( - "ClawdbotWebView", + "MoltbotWebView", "onReceivedHttpError: ${errorResponse.statusCode} ${errorResponse.reasonPhrase} ${request.url}", ) } override fun onPageFinished(view: WebView, url: String?) { if (isDebuggable) { - Log.d("ClawdbotWebView", "onPageFinished: $url") + Log.d("MoltbotWebView", "onPageFinished: $url") } viewModel.canvas.onPageFinished() } @@ -377,7 +377,7 @@ private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier) ): Boolean { if (isDebuggable) { Log.e( - "ClawdbotWebView", + "MoltbotWebView", "onRenderProcessGone didCrash=${detail.didCrash()} priorityAtExit=${detail.rendererPriorityAtExit()}", ) } @@ -390,7 +390,7 @@ private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier) if (!isDebuggable) return false val msg = consoleMessage ?: return false Log.d( - "ClawdbotWebView", + "MoltbotWebView", "console ${msg.messageLevel()} @ ${msg.sourceId()}:${msg.lineNumber()} ${msg.message()}", ) return false @@ -428,7 +428,7 @@ private class CanvasA2UIActionBridge(private val onMessage: (String) -> Unit) { } companion object { - const val interfaceName: String = "clawdbotCanvasA2UIAction" + const val interfaceName: String = "moltbotCanvasA2UIAction" } } diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/SettingsSheet.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/SettingsSheet.kt index e3a9b3ecb..6b3564e14 100644 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/SettingsSheet.kt +++ b/apps/android/app/src/main/java/com/clawdbot/android/ui/SettingsSheet.kt @@ -457,7 +457,7 @@ fun SettingsSheet(viewModel: MainViewModel) { Column(verticalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) { ListItem( headlineContent = { Text("Foreground Only") }, - supportingContent = { Text("Listens only while Clawdbot is open.") }, + supportingContent = { Text("Listens only while Moltbot is open.") }, trailingContent = { RadioButton( selected = voiceWakeMode == VoiceWakeMode.Foreground, @@ -603,7 +603,7 @@ fun SettingsSheet(viewModel: MainViewModel) { ) ListItem( headlineContent = { Text("While Using") }, - supportingContent = { Text("Only while Clawdbot is open.") }, + supportingContent = { Text("Only while Moltbot is open.") }, trailingContent = { RadioButton( selected = locationMode == LocationMode.WhileUsing, @@ -650,7 +650,7 @@ fun SettingsSheet(viewModel: MainViewModel) { item { ListItem( headlineContent = { Text("Prevent Sleep") }, - supportingContent = { Text("Keeps the screen awake while Clawdbot is open.") }, + supportingContent = { Text("Keeps the screen awake while Moltbot is open.") }, trailingContent = { Switch(checked = preventSleep, onCheckedChange = viewModel::setPreventSleep) }, ) } diff --git a/apps/android/app/src/main/res/values/strings.xml b/apps/android/app/src/main/res/values/strings.xml index 3665960c2..0aae9e739 100644 --- a/apps/android/app/src/main/res/values/strings.xml +++ b/apps/android/app/src/main/res/values/strings.xml @@ -1,3 +1,3 @@ - Clawdbot Node + Moltbot Node diff --git a/apps/android/app/src/main/res/values/themes.xml b/apps/android/app/src/main/res/values/themes.xml index fe7c9b17f..f90f40dc9 100644 --- a/apps/android/app/src/main/res/values/themes.xml +++ b/apps/android/app/src/main/res/values/themes.xml @@ -1,5 +1,5 @@ - - -
    + +
    -
    Ready
    -
    Waiting for agent
    +
    Ready
    +
    Waiting for agent
    diff --git a/ui/package.json b/ui/package.json index 35f5666e8..3376e1029 100644 --- a/ui/package.json +++ b/ui/package.json @@ -1,5 +1,5 @@ { - "name": "clawdbot-control-ui", + "name": "moltbot-control-ui", "private": true, "type": "module", "scripts": { diff --git a/ui/src/styles/base.css b/ui/src/styles/base.css index 7baab70a2..f77cff9ed 100644 --- a/ui/src/styles/base.css +++ b/ui/src/styles/base.css @@ -239,7 +239,7 @@ html.theme-transition::view-transition-new(theme) { } } -clawdbot-app { +moltbot-app { display: block; position: relative; z-index: 1; diff --git a/ui/src/ui/app-channels.ts b/ui/src/ui/app-channels.ts index 3a3921a8d..91ff734ed 100644 --- a/ui/src/ui/app-channels.ts +++ b/ui/src/ui/app-channels.ts @@ -5,32 +5,32 @@ import { waitWhatsAppLogin, } from "./controllers/channels"; import { loadConfig, saveConfig } from "./controllers/config"; -import type { ClawdbotApp } from "./app"; +import type { MoltbotApp } from "./app"; import type { NostrProfile } from "./types"; import { createNostrProfileFormState } from "./views/channels.nostr-profile-form"; -export async function handleWhatsAppStart(host: ClawdbotApp, force: boolean) { +export async function handleWhatsAppStart(host: MoltbotApp, force: boolean) { await startWhatsAppLogin(host, force); await loadChannels(host, true); } -export async function handleWhatsAppWait(host: ClawdbotApp) { +export async function handleWhatsAppWait(host: MoltbotApp) { await waitWhatsAppLogin(host); await loadChannels(host, true); } -export async function handleWhatsAppLogout(host: ClawdbotApp) { +export async function handleWhatsAppLogout(host: MoltbotApp) { await logoutWhatsApp(host); await loadChannels(host, true); } -export async function handleChannelConfigSave(host: ClawdbotApp) { +export async function handleChannelConfigSave(host: MoltbotApp) { await saveConfig(host); await loadConfig(host); await loadChannels(host, true); } -export async function handleChannelConfigReload(host: ClawdbotApp) { +export async function handleChannelConfigReload(host: MoltbotApp) { await loadConfig(host); await loadChannels(host, true); } @@ -49,7 +49,7 @@ function parseValidationErrors(details: unknown): Record { return errors; } -function resolveNostrAccountId(host: ClawdbotApp): string { +function resolveNostrAccountId(host: MoltbotApp): string { const accounts = host.channelsSnapshot?.channelAccounts?.nostr ?? []; return accounts[0]?.accountId ?? host.nostrProfileAccountId ?? "default"; } @@ -59,7 +59,7 @@ function buildNostrProfileUrl(accountId: string, suffix = ""): string { } export function handleNostrProfileEdit( - host: ClawdbotApp, + host: MoltbotApp, accountId: string, profile: NostrProfile | null, ) { @@ -67,13 +67,13 @@ export function handleNostrProfileEdit( host.nostrProfileFormState = createNostrProfileFormState(profile ?? undefined); } -export function handleNostrProfileCancel(host: ClawdbotApp) { +export function handleNostrProfileCancel(host: MoltbotApp) { host.nostrProfileFormState = null; host.nostrProfileAccountId = null; } export function handleNostrProfileFieldChange( - host: ClawdbotApp, + host: MoltbotApp, field: keyof NostrProfile, value: string, ) { @@ -92,7 +92,7 @@ export function handleNostrProfileFieldChange( }; } -export function handleNostrProfileToggleAdvanced(host: ClawdbotApp) { +export function handleNostrProfileToggleAdvanced(host: MoltbotApp) { const state = host.nostrProfileFormState; if (!state) return; host.nostrProfileFormState = { @@ -101,7 +101,7 @@ export function handleNostrProfileToggleAdvanced(host: ClawdbotApp) { }; } -export async function handleNostrProfileSave(host: ClawdbotApp) { +export async function handleNostrProfileSave(host: MoltbotApp) { const state = host.nostrProfileFormState; if (!state || state.saving) return; const accountId = resolveNostrAccountId(host); @@ -167,7 +167,7 @@ export async function handleNostrProfileSave(host: ClawdbotApp) { } } -export async function handleNostrProfileImport(host: ClawdbotApp) { +export async function handleNostrProfileImport(host: MoltbotApp) { const state = host.nostrProfileFormState; if (!state || state.importing) return; const accountId = resolveNostrAccountId(host); diff --git a/ui/src/ui/app-chat.ts b/ui/src/ui/app-chat.ts index c5f883716..77149f9ad 100644 --- a/ui/src/ui/app-chat.ts +++ b/ui/src/ui/app-chat.ts @@ -7,7 +7,7 @@ import { setLastActiveSessionKey } from "./app-settings"; import { normalizeBasePath } from "./navigation"; import type { GatewayHelloOk } from "./gateway"; import { parseAgentSessionKey } from "../../../src/sessions/session-key-utils.js"; -import type { ClawdbotApp } from "./app"; +import type { MoltbotApp } from "./app"; import type { ChatAttachment, ChatQueueItem } from "./ui-types"; type ChatHost = { @@ -44,7 +44,7 @@ export function isChatStopCommand(text: string) { export async function handleAbortChat(host: ChatHost) { if (!host.connected) return; host.chatMessage = ""; - await abortChatRun(host as unknown as ClawdbotApp); + await abortChatRun(host as unknown as MoltbotApp); } function enqueueChatMessage(host: ChatHost, text: string, attachments?: ChatAttachment[]) { @@ -74,7 +74,7 @@ async function sendChatMessageNow( }, ) { resetToolStream(host as unknown as Parameters[0]); - const ok = await sendChatMessage(host as unknown as ClawdbotApp, message, opts?.attachments); + const ok = await sendChatMessage(host as unknown as MoltbotApp, message, opts?.attachments); if (!ok && opts?.previousDraft != null) { host.chatMessage = opts.previousDraft; } @@ -154,8 +154,8 @@ export async function handleSendChat( export async function refreshChat(host: ChatHost) { await Promise.all([ - loadChatHistory(host as unknown as ClawdbotApp), - loadSessions(host as unknown as ClawdbotApp), + loadChatHistory(host as unknown as MoltbotApp), + loadSessions(host as unknown as MoltbotApp), refreshChatAvatar(host), ]); scheduleChatScroll(host as unknown as Parameters[0], true); diff --git a/ui/src/ui/app-gateway.ts b/ui/src/ui/app-gateway.ts index 0df25bbdf..b2355709c 100644 --- a/ui/src/ui/app-gateway.ts +++ b/ui/src/ui/app-gateway.ts @@ -23,7 +23,7 @@ import { parseExecApprovalResolved, removeExecApproval, } from "./controllers/exec-approval"; -import type { ClawdbotApp } from "./app"; +import type { MoltbotApp } from "./app"; import type { ExecApprovalRequest } from "./controllers/exec-approval"; import { loadAssistantIdentity } from "./controllers/assistant-identity"; @@ -120,7 +120,7 @@ export function connectGateway(host: GatewayHost) { url: host.settings.gatewayUrl, token: host.settings.token.trim() ? host.settings.token : undefined, password: host.password.trim() ? host.password : undefined, - clientName: "clawdbot-control-ui", + clientName: "moltbot-control-ui", mode: "webchat", onHello: (hello) => { host.connected = true; @@ -133,10 +133,10 @@ export function connectGateway(host: GatewayHost) { (host as unknown as { chatStream: string | null }).chatStream = null; (host as unknown as { chatStreamStartedAt: number | null }).chatStreamStartedAt = null; resetToolStream(host as unknown as Parameters[0]); - void loadAssistantIdentity(host as unknown as ClawdbotApp); - void loadAgents(host as unknown as ClawdbotApp); - void loadNodes(host as unknown as ClawdbotApp, { quiet: true }); - void loadDevices(host as unknown as ClawdbotApp, { quiet: true }); + void loadAssistantIdentity(host as unknown as MoltbotApp); + void loadAgents(host as unknown as MoltbotApp); + void loadNodes(host as unknown as MoltbotApp, { quiet: true }); + void loadDevices(host as unknown as MoltbotApp, { quiet: true }); void refreshActiveTab(host as unknown as Parameters[0]); }, onClose: ({ code, reason }) => { @@ -188,14 +188,14 @@ function handleGatewayEventUnsafe(host: GatewayHost, evt: GatewayEventFrame) { payload.sessionKey, ); } - const state = handleChatEvent(host as unknown as ClawdbotApp, payload); + const state = handleChatEvent(host as unknown as MoltbotApp, payload); if (state === "final" || state === "error" || state === "aborted") { resetToolStream(host as unknown as Parameters[0]); void flushChatQueueForEvent( host as unknown as Parameters[0], ); } - if (state === "final") void loadChatHistory(host as unknown as ClawdbotApp); + if (state === "final") void loadChatHistory(host as unknown as MoltbotApp); return; } @@ -214,7 +214,7 @@ function handleGatewayEventUnsafe(host: GatewayHost, evt: GatewayEventFrame) { } if (evt.event === "device.pair.requested" || evt.event === "device.pair.resolved") { - void loadDevices(host as unknown as ClawdbotApp, { quiet: true }); + void loadDevices(host as unknown as MoltbotApp, { quiet: true }); } if (evt.event === "exec.approval.requested") { diff --git a/ui/src/ui/app-polling.ts b/ui/src/ui/app-polling.ts index b18113c5a..3255bdaeb 100644 --- a/ui/src/ui/app-polling.ts +++ b/ui/src/ui/app-polling.ts @@ -1,7 +1,7 @@ import { loadLogs } from "./controllers/logs"; import { loadNodes } from "./controllers/nodes"; import { loadDebug } from "./controllers/debug"; -import type { ClawdbotApp } from "./app"; +import type { MoltbotApp } from "./app"; type PollingHost = { nodesPollInterval: number | null; @@ -13,7 +13,7 @@ type PollingHost = { export function startNodesPolling(host: PollingHost) { if (host.nodesPollInterval != null) return; host.nodesPollInterval = window.setInterval( - () => void loadNodes(host as unknown as ClawdbotApp, { quiet: true }), + () => void loadNodes(host as unknown as MoltbotApp, { quiet: true }), 5000, ); } @@ -28,7 +28,7 @@ export function startLogsPolling(host: PollingHost) { if (host.logsPollInterval != null) return; host.logsPollInterval = window.setInterval(() => { if (host.tab !== "logs") return; - void loadLogs(host as unknown as ClawdbotApp, { quiet: true }); + void loadLogs(host as unknown as MoltbotApp, { quiet: true }); }, 2000); } @@ -42,7 +42,7 @@ export function startDebugPolling(host: PollingHost) { if (host.debugPollInterval != null) return; host.debugPollInterval = window.setInterval(() => { if (host.tab !== "debug") return; - void loadDebug(host as unknown as ClawdbotApp); + void loadDebug(host as unknown as MoltbotApp); }, 3000); } diff --git a/ui/src/ui/app-render.ts b/ui/src/ui/app-render.ts index 49f72de8c..a088c33ff 100644 --- a/ui/src/ui/app-render.ts +++ b/ui/src/ui/app-render.ts @@ -129,10 +129,10 @@ export function renderApp(state: AppViewState) {
    -
    CLAWDBOT
    +
    MOLTBOT
    Gateway Dashboard
    diff --git a/ui/src/ui/app-scroll.ts b/ui/src/ui/app-scroll.ts index 5955e80b8..c3c29f479 100644 --- a/ui/src/ui/app-scroll.ts +++ b/ui/src/ui/app-scroll.ts @@ -103,7 +103,7 @@ export function exportLogs(lines: string[], label: string) { const anchor = document.createElement("a"); const stamp = new Date().toISOString().slice(0, 19).replace(/[:T]/g, "-"); anchor.href = url; - anchor.download = `clawdbot-logs-${label}-${stamp}.log`; + anchor.download = `moltbot-logs-${label}-${stamp}.log`; anchor.click(); URL.revokeObjectURL(url); } diff --git a/ui/src/ui/app-settings.ts b/ui/src/ui/app-settings.ts index 0cceff4cb..e269742b2 100644 --- a/ui/src/ui/app-settings.ts +++ b/ui/src/ui/app-settings.ts @@ -16,7 +16,7 @@ import { startThemeTransition, type ThemeTransitionContext } from "./theme-trans import { scheduleChatScroll, scheduleLogsScroll } from "./app-scroll"; import { startLogsPolling, stopLogsPolling, startDebugPolling, stopDebugPolling } from "./app-polling"; import { refreshChat } from "./app-chat"; -import type { ClawdbotApp } from "./app"; +import type { MoltbotApp } from "./app"; type SettingsHost = { settings: UiSettings; @@ -144,15 +144,15 @@ export function setTheme( export async function refreshActiveTab(host: SettingsHost) { if (host.tab === "overview") await loadOverview(host); if (host.tab === "channels") await loadChannelsTab(host); - if (host.tab === "instances") await loadPresence(host as unknown as ClawdbotApp); - if (host.tab === "sessions") await loadSessions(host as unknown as ClawdbotApp); + if (host.tab === "instances") await loadPresence(host as unknown as MoltbotApp); + if (host.tab === "sessions") await loadSessions(host as unknown as MoltbotApp); if (host.tab === "cron") await loadCron(host); - if (host.tab === "skills") await loadSkills(host as unknown as ClawdbotApp); + if (host.tab === "skills") await loadSkills(host as unknown as MoltbotApp); if (host.tab === "nodes") { - await loadNodes(host as unknown as ClawdbotApp); - await loadDevices(host as unknown as ClawdbotApp); - await loadConfig(host as unknown as ClawdbotApp); - await loadExecApprovals(host as unknown as ClawdbotApp); + await loadNodes(host as unknown as MoltbotApp); + await loadDevices(host as unknown as MoltbotApp); + await loadConfig(host as unknown as MoltbotApp); + await loadExecApprovals(host as unknown as MoltbotApp); } if (host.tab === "chat") { await refreshChat(host as unknown as Parameters[0]); @@ -162,16 +162,16 @@ export async function refreshActiveTab(host: SettingsHost) { ); } if (host.tab === "config") { - await loadConfigSchema(host as unknown as ClawdbotApp); - await loadConfig(host as unknown as ClawdbotApp); + await loadConfigSchema(host as unknown as MoltbotApp); + await loadConfig(host as unknown as MoltbotApp); } if (host.tab === "debug") { - await loadDebug(host as unknown as ClawdbotApp); + await loadDebug(host as unknown as MoltbotApp); host.eventLog = host.eventLogBuffer; } if (host.tab === "logs") { host.logsAtBottom = true; - await loadLogs(host as unknown as ClawdbotApp, { reset: true }); + await loadLogs(host as unknown as MoltbotApp, { reset: true }); scheduleLogsScroll( host as unknown as Parameters[0], true, @@ -307,26 +307,26 @@ export function syncUrlWithSessionKey( export async function loadOverview(host: SettingsHost) { await Promise.all([ - loadChannels(host as unknown as ClawdbotApp, false), - loadPresence(host as unknown as ClawdbotApp), - loadSessions(host as unknown as ClawdbotApp), - loadCronStatus(host as unknown as ClawdbotApp), - loadDebug(host as unknown as ClawdbotApp), + loadChannels(host as unknown as MoltbotApp, false), + loadPresence(host as unknown as MoltbotApp), + loadSessions(host as unknown as MoltbotApp), + loadCronStatus(host as unknown as MoltbotApp), + loadDebug(host as unknown as MoltbotApp), ]); } export async function loadChannelsTab(host: SettingsHost) { await Promise.all([ - loadChannels(host as unknown as ClawdbotApp, true), - loadConfigSchema(host as unknown as ClawdbotApp), - loadConfig(host as unknown as ClawdbotApp), + loadChannels(host as unknown as MoltbotApp, true), + loadConfigSchema(host as unknown as MoltbotApp), + loadConfig(host as unknown as MoltbotApp), ]); } export async function loadCron(host: SettingsHost) { await Promise.all([ - loadChannels(host as unknown as ClawdbotApp, false), - loadCronStatus(host as unknown as ClawdbotApp), - loadCronJobs(host as unknown as ClawdbotApp), + loadChannels(host as unknown as MoltbotApp, false), + loadCronStatus(host as unknown as MoltbotApp), + loadCronJobs(host as unknown as MoltbotApp), ]); } diff --git a/ui/src/ui/app.ts b/ui/src/ui/app.ts index 649e76342..d23e543cd 100644 --- a/ui/src/ui/app.ts +++ b/ui/src/ui/app.ts @@ -96,8 +96,8 @@ function resolveOnboardingMode(): boolean { return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on"; } -@customElement("clawdbot-app") -export class ClawdbotApp extends LitElement { +@customElement("moltbot-app") +export class MoltbotApp extends LitElement { @state() settings: UiSettings = loadSettings(); @state() password = ""; @state() tab: Tab = "chat"; diff --git a/ui/src/ui/chat-markdown.browser.test.ts b/ui/src/ui/chat-markdown.browser.test.ts index 732e4b86a..cb2011e6c 100644 --- a/ui/src/ui/chat-markdown.browser.test.ts +++ b/ui/src/ui/chat-markdown.browser.test.ts @@ -1,18 +1,18 @@ import { afterEach, beforeEach, describe, expect, it } from "vitest"; -import { ClawdbotApp } from "./app"; +import { MoltbotApp } from "./app"; -const originalConnect = ClawdbotApp.prototype.connect; +const originalConnect = MoltbotApp.prototype.connect; function mountApp(pathname: string) { window.history.replaceState({}, "", pathname); - const app = document.createElement("clawdbot-app") as ClawdbotApp; + const app = document.createElement("moltbot-app") as MoltbotApp; document.body.append(app); return app; } beforeEach(() => { - ClawdbotApp.prototype.connect = () => { + MoltbotApp.prototype.connect = () => { // no-op: avoid real gateway WS connections in browser tests }; window.__CLAWDBOT_CONTROL_UI_BASE_PATH__ = undefined; @@ -21,7 +21,7 @@ beforeEach(() => { }); afterEach(() => { - ClawdbotApp.prototype.connect = originalConnect; + MoltbotApp.prototype.connect = originalConnect; window.__CLAWDBOT_CONTROL_UI_BASE_PATH__ = undefined; localStorage.clear(); document.body.innerHTML = ""; diff --git a/ui/src/ui/controllers/chat.ts b/ui/src/ui/controllers/chat.ts index 518c35fe1..6a3e68175 100644 --- a/ui/src/ui/controllers/chat.ts +++ b/ui/src/ui/controllers/chat.ts @@ -163,7 +163,7 @@ export function handleChatEvent( if (payload.sessionKey !== state.sessionKey) return null; // Final from another run (e.g. sub-agent announce): refresh history to show new message. - // See https://github.com/clawdbot/clawdbot/issues/1909 + // See https://github.com/moltbot/moltbot/issues/1909 if ( payload.runId && state.chatRunId && diff --git a/ui/src/ui/device-auth.ts b/ui/src/ui/device-auth.ts index 693479ae7..588c574a8 100644 --- a/ui/src/ui/device-auth.ts +++ b/ui/src/ui/device-auth.ts @@ -11,7 +11,7 @@ type DeviceAuthStore = { tokens: Record; }; -const STORAGE_KEY = "clawdbot.device.auth.v1"; +const STORAGE_KEY = "moltbot.device.auth.v1"; function normalizeRole(role: string): string { return role.trim(); diff --git a/ui/src/ui/device-identity.ts b/ui/src/ui/device-identity.ts index 4ad7ceec0..dd2eccb8b 100644 --- a/ui/src/ui/device-identity.ts +++ b/ui/src/ui/device-identity.ts @@ -14,7 +14,7 @@ export type DeviceIdentity = { privateKey: string; }; -const STORAGE_KEY = "clawdbot-device-identity-v1"; +const STORAGE_KEY = "moltbot-device-identity-v1"; function base64UrlEncode(bytes: Uint8Array): string { let binary = ""; diff --git a/ui/src/ui/focus-mode.browser.test.ts b/ui/src/ui/focus-mode.browser.test.ts index ba81456bc..157f8a0ab 100644 --- a/ui/src/ui/focus-mode.browser.test.ts +++ b/ui/src/ui/focus-mode.browser.test.ts @@ -1,18 +1,18 @@ import { afterEach, beforeEach, describe, expect, it } from "vitest"; -import { ClawdbotApp } from "./app"; +import { MoltbotApp } from "./app"; -const originalConnect = ClawdbotApp.prototype.connect; +const originalConnect = MoltbotApp.prototype.connect; function mountApp(pathname: string) { window.history.replaceState({}, "", pathname); - const app = document.createElement("clawdbot-app") as ClawdbotApp; + const app = document.createElement("moltbot-app") as MoltbotApp; document.body.append(app); return app; } beforeEach(() => { - ClawdbotApp.prototype.connect = () => { + MoltbotApp.prototype.connect = () => { // no-op: avoid real gateway WS connections in browser tests }; window.__CLAWDBOT_CONTROL_UI_BASE_PATH__ = undefined; @@ -21,7 +21,7 @@ beforeEach(() => { }); afterEach(() => { - ClawdbotApp.prototype.connect = originalConnect; + MoltbotApp.prototype.connect = originalConnect; window.__CLAWDBOT_CONTROL_UI_BASE_PATH__ = undefined; localStorage.clear(); document.body.innerHTML = ""; diff --git a/ui/src/ui/navigation.browser.test.ts b/ui/src/ui/navigation.browser.test.ts index 0139ec552..7a021e64f 100644 --- a/ui/src/ui/navigation.browser.test.ts +++ b/ui/src/ui/navigation.browser.test.ts @@ -1,13 +1,13 @@ import { afterEach, beforeEach, describe, expect, it } from "vitest"; -import { ClawdbotApp } from "./app"; +import { MoltbotApp } from "./app"; import "../styles.css"; -const originalConnect = ClawdbotApp.prototype.connect; +const originalConnect = MoltbotApp.prototype.connect; function mountApp(pathname: string) { window.history.replaceState({}, "", pathname); - const app = document.createElement("clawdbot-app") as ClawdbotApp; + const app = document.createElement("moltbot-app") as MoltbotApp; document.body.append(app); return app; } @@ -19,7 +19,7 @@ function nextFrame() { } beforeEach(() => { - ClawdbotApp.prototype.connect = () => { + MoltbotApp.prototype.connect = () => { // no-op: avoid real gateway WS connections in browser tests }; window.__CLAWDBOT_CONTROL_UI_BASE_PATH__ = undefined; @@ -28,7 +28,7 @@ beforeEach(() => { }); afterEach(() => { - ClawdbotApp.prototype.connect = originalConnect; + MoltbotApp.prototype.connect = originalConnect; window.__CLAWDBOT_CONTROL_UI_BASE_PATH__ = undefined; localStorage.clear(); document.body.innerHTML = ""; @@ -53,22 +53,22 @@ describe("control UI routing", () => { }); it("infers nested base paths", async () => { - const app = mountApp("/apps/clawdbot/cron"); + const app = mountApp("/apps/moltbot/cron"); await app.updateComplete; - expect(app.basePath).toBe("/apps/clawdbot"); + expect(app.basePath).toBe("/apps/moltbot"); expect(app.tab).toBe("cron"); - expect(window.location.pathname).toBe("/apps/clawdbot/cron"); + expect(window.location.pathname).toBe("/apps/moltbot/cron"); }); it("honors explicit base path overrides", async () => { - window.__CLAWDBOT_CONTROL_UI_BASE_PATH__ = "/clawdbot"; - const app = mountApp("/clawdbot/sessions"); + window.__CLAWDBOT_CONTROL_UI_BASE_PATH__ = "/moltbot"; + const app = mountApp("/moltbot/sessions"); await app.updateComplete; - expect(app.basePath).toBe("/clawdbot"); + expect(app.basePath).toBe("/moltbot"); expect(app.tab).toBe("sessions"); - expect(window.location.pathname).toBe("/clawdbot/sessions"); + expect(window.location.pathname).toBe("/moltbot/sessions"); }); it("updates the URL when clicking nav items", async () => { @@ -169,7 +169,7 @@ describe("control UI routing", () => { it("hydrates token from URL params even when settings already set", async () => { localStorage.setItem( - "clawdbot.control.settings.v1", + "moltbot.control.settings.v1", JSON.stringify({ token: "existing-token" }), ); const app = mountApp("/ui/overview?token=abc123"); diff --git a/ui/src/ui/navigation.test.ts b/ui/src/ui/navigation.test.ts index 168125d71..7b15deb4a 100644 --- a/ui/src/ui/navigation.test.ts +++ b/ui/src/ui/navigation.test.ts @@ -73,7 +73,7 @@ describe("subtitleForTab", () => { it("returns descriptive subtitles", () => { expect(subtitleForTab("chat")).toContain("chat session"); - expect(subtitleForTab("config")).toContain("clawdbot.json"); + expect(subtitleForTab("config")).toContain("moltbot.json"); }); }); @@ -95,7 +95,7 @@ describe("normalizeBasePath", () => { }); it("handles nested paths", () => { - expect(normalizeBasePath("/apps/clawdbot")).toBe("/apps/clawdbot"); + expect(normalizeBasePath("/apps/moltbot")).toBe("/apps/moltbot"); }); }); @@ -122,7 +122,7 @@ describe("pathForTab", () => { it("prepends base path", () => { expect(pathForTab("chat", "/ui")).toBe("/ui/chat"); - expect(pathForTab("sessions", "/apps/clawdbot")).toBe("/apps/clawdbot/sessions"); + expect(pathForTab("sessions", "/apps/moltbot")).toBe("/apps/moltbot/sessions"); }); }); @@ -139,7 +139,7 @@ describe("tabFromPath", () => { it("handles base paths", () => { expect(tabFromPath("/ui/chat", "/ui")).toBe("chat"); - expect(tabFromPath("/apps/clawdbot/sessions", "/apps/clawdbot")).toBe("sessions"); + expect(tabFromPath("/apps/moltbot/sessions", "/apps/moltbot")).toBe("sessions"); }); it("returns null for unknown path", () => { @@ -164,7 +164,7 @@ describe("inferBasePathFromPathname", () => { it("infers base path from nested paths", () => { expect(inferBasePathFromPathname("/ui/chat")).toBe("/ui"); - expect(inferBasePathFromPathname("/apps/clawdbot/sessions")).toBe("/apps/clawdbot"); + expect(inferBasePathFromPathname("/apps/moltbot/sessions")).toBe("/apps/moltbot"); }); it("handles index.html suffix", () => { diff --git a/ui/src/ui/navigation.ts b/ui/src/ui/navigation.ts index 5938e25e9..966abec96 100644 --- a/ui/src/ui/navigation.ts +++ b/ui/src/ui/navigation.ts @@ -177,7 +177,7 @@ export function subtitleForTab(tab: Tab) { case "chat": return "Direct gateway chat session for quick interventions."; case "config": - return "Edit ~/.clawdbot/clawdbot.json safely."; + return "Edit ~/.clawdbot/moltbot.json safely."; case "debug": return "Gateway snapshots, events, and manual RPC calls."; case "logs": diff --git a/ui/src/ui/storage.ts b/ui/src/ui/storage.ts index fc410c225..4b1836bfb 100644 --- a/ui/src/ui/storage.ts +++ b/ui/src/ui/storage.ts @@ -1,4 +1,4 @@ -const KEY = "clawdbot.control.settings.v1"; +const KEY = "moltbot.control.settings.v1"; import type { ThemeMode } from "./theme"; diff --git a/ui/src/ui/views/chat.test.ts b/ui/src/ui/views/chat.test.ts index 6cd469558..ac68f2494 100644 --- a/ui/src/ui/views/chat.test.ts +++ b/ui/src/ui/views/chat.test.ts @@ -37,7 +37,7 @@ function createProps(overrides: Partial = {}): ChatProps { error: null, sessions: createSessions(), focusMode: false, - assistantName: "Clawdbot", + assistantName: "Moltbot", assistantAvatar: null, onRefresh: () => undefined, onToggleFocusMode: () => undefined, diff --git a/ui/src/ui/views/debug.ts b/ui/src/ui/views/debug.ts index d33eaffc7..822c508a1 100644 --- a/ui/src/ui/views/debug.ts +++ b/ui/src/ui/views/debug.ts @@ -55,7 +55,7 @@ export function renderDebug(props: DebugProps) { ${securitySummary ? html`
    Security audit: ${securityLabel}${info > 0 ? ` · ${info} info` : ""}. Run - clawdbot security audit --deep for details. + moltbot security audit --deep for details.
    ` : nothing} 
    ${JSON.stringify(props.status ?? {}, null, 2)}
    diff --git a/ui/src/ui/views/overview.ts b/ui/src/ui/views/overview.ts index d6484ab58..5dcf92a1e 100644 --- a/ui/src/ui/views/overview.ts +++ b/ui/src/ui/views/overview.ts @@ -43,8 +43,8 @@ export function renderOverview(props: OverviewProps) {
    This gateway requires auth. Add a token or password, then click Connect.
    - clawdbot dashboard --no-open → tokenized URL
    - clawdbot doctor --generate-gateway-token → set token + moltbot dashboard --no-open → tokenized URL
    + moltbot doctor --generate-gateway-token → set token
    Auth failed. Re-copy a tokenized URL with - clawdbot dashboard --no-open, or update the token, + moltbot dashboard --no-open, or update the token, then click Connect.
    Date: Tue, 27 Jan 2026 12:20:41 +0000 Subject: [PATCH 016/101] refactor: align skills and loaders with moltbot rename --- skills/1password/SKILL.md | 6 ++-- skills/apple-notes/SKILL.md | 4 +-- skills/apple-reminders/SKILL.md | 2 +- skills/bear-notes/SKILL.md | 2 +- skills/bird/SKILL.md | 2 +- skills/blogwatcher/SKILL.md | 2 +- skills/blucli/SKILL.md | 2 +- skills/bluebubbles/SKILL.md | 2 +- skills/camsnap/SKILL.md | 2 +- skills/canvas/SKILL.md | 30 +++++++++---------- skills/clawdhub/SKILL.md | 4 +-- skills/coding-agent/SKILL.md | 12 ++++---- skills/discord/SKILL.md | 12 ++++---- skills/eightctl/SKILL.md | 2 +- skills/food-order/SKILL.md | 2 +- skills/gemini/SKILL.md | 2 +- skills/gifgrep/SKILL.md | 2 +- skills/github/SKILL.md | 2 +- skills/gog/SKILL.md | 2 +- skills/goplaces/SKILL.md | 2 +- skills/himalaya/SKILL.md | 2 +- skills/imsg/SKILL.md | 2 +- skills/local-places/SKILL.md | 2 +- skills/mcporter/SKILL.md | 2 +- skills/model-usage/SKILL.md | 2 +- skills/nano-banana-pro/SKILL.md | 6 ++-- .../nano-banana-pro/scripts/generate_image.py | 2 +- skills/nano-pdf/SKILL.md | 2 +- skills/notion/SKILL.md | 2 +- skills/obsidian/SKILL.md | 2 +- skills/openai-image-gen/SKILL.md | 2 +- skills/openai-whisper-api/SKILL.md | 4 +-- skills/openai-whisper/SKILL.md | 2 +- skills/openhue/SKILL.md | 2 +- skills/oracle/SKILL.md | 2 +- skills/ordercli/SKILL.md | 2 +- skills/peekaboo/SKILL.md | 2 +- skills/sag/SKILL.md | 2 +- skills/session-logs/SKILL.md | 2 +- skills/sherpa-onnx-tts/SKILL.md | 4 +-- skills/slack/SKILL.md | 8 ++--- skills/songsee/SKILL.md | 2 +- skills/sonoscli/SKILL.md | 2 +- skills/spotify-player/SKILL.md | 2 +- skills/summarize/SKILL.md | 2 +- skills/things-mac/SKILL.md | 6 ++-- skills/tmux/SKILL.md | 14 ++++----- skills/tmux/scripts/find-sessions.sh | 2 +- skills/trello/SKILL.md | 4 +-- skills/video-frames/SKILL.md | 2 +- skills/voice-call/SKILL.md | 8 ++--- skills/wacli/SKILL.md | 4 +-- skills/weather/SKILL.md | 2 +- 53 files changed, 101 insertions(+), 101 deletions(-) diff --git a/skills/1password/SKILL.md b/skills/1password/SKILL.md index 7bac1be06..b200694a3 100644 --- a/skills/1password/SKILL.md +++ b/skills/1password/SKILL.md @@ -2,7 +2,7 @@ name: 1password description: Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op. homepage: https://developer.1password.com/docs/cli/get-started/ -metadata: {"clawdbot":{"emoji":"🔐","requires":{"bins":["op"]},"install":[{"id":"brew","kind":"brew","formula":"1password-cli","bins":["op"],"label":"Install 1Password CLI (brew)"}]}} +metadata: {"moltbot":{"emoji":"🔐","requires":{"bins":["op"]},"install":[{"id":"brew","kind":"brew","formula":"1password-cli","bins":["op"],"label":"Install 1Password CLI (brew)"}]}} --- # 1Password CLI @@ -31,9 +31,9 @@ The shell tool uses a fresh TTY per command. To avoid re-prompts and failures, a Example (see `tmux` skill for socket conventions, do not reuse old session names): ```bash -SOCKET_DIR="${CLAWDBOT_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/clawdbot-tmux-sockets}" +SOCKET_DIR="${CLAWDBOT_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/moltbot-tmux-sockets}" mkdir -p "$SOCKET_DIR" -SOCKET="$SOCKET_DIR/clawdbot-op.sock" +SOCKET="$SOCKET_DIR/moltbot-op.sock" SESSION="op-auth-$(date +%Y%m%d-%H%M%S)" tmux -S "$SOCKET" new -d -s "$SESSION" -n shell diff --git a/skills/apple-notes/SKILL.md b/skills/apple-notes/SKILL.md index 441e22691..8cd11f0e5 100644 --- a/skills/apple-notes/SKILL.md +++ b/skills/apple-notes/SKILL.md @@ -1,8 +1,8 @@ --- name: apple-notes -description: Manage Apple Notes via the `memo` CLI on macOS (create, view, edit, delete, search, move, and export notes). Use when a user asks Clawdbot to add a note, list notes, search notes, or manage note folders. +description: Manage Apple Notes via the `memo` CLI on macOS (create, view, edit, delete, search, move, and export notes). Use when a user asks Moltbot to add a note, list notes, search notes, or manage note folders. homepage: https://github.com/antoniorodr/memo -metadata: {"clawdbot":{"emoji":"📝","os":["darwin"],"requires":{"bins":["memo"]},"install":[{"id":"brew","kind":"brew","formula":"antoniorodr/memo/memo","bins":["memo"],"label":"Install memo via Homebrew"}]}} +metadata: {"moltbot":{"emoji":"📝","os":["darwin"],"requires":{"bins":["memo"]},"install":[{"id":"brew","kind":"brew","formula":"antoniorodr/memo/memo","bins":["memo"],"label":"Install memo via Homebrew"}]}} --- # Apple Notes CLI diff --git a/skills/apple-reminders/SKILL.md b/skills/apple-reminders/SKILL.md index 07e5e92b0..80959ec50 100644 --- a/skills/apple-reminders/SKILL.md +++ b/skills/apple-reminders/SKILL.md @@ -2,7 +2,7 @@ name: apple-reminders description: Manage Apple Reminders via the `remindctl` CLI on macOS (list, add, edit, complete, delete). Supports lists, date filters, and JSON/plain output. homepage: https://github.com/steipete/remindctl -metadata: {"clawdbot":{"emoji":"⏰","os":["darwin"],"requires":{"bins":["remindctl"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/remindctl","bins":["remindctl"],"label":"Install remindctl via Homebrew"}]}} +metadata: {"moltbot":{"emoji":"⏰","os":["darwin"],"requires":{"bins":["remindctl"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/remindctl","bins":["remindctl"],"label":"Install remindctl via Homebrew"}]}} --- # Apple Reminders CLI (remindctl) diff --git a/skills/bear-notes/SKILL.md b/skills/bear-notes/SKILL.md index fe4d7165b..80feb294b 100644 --- a/skills/bear-notes/SKILL.md +++ b/skills/bear-notes/SKILL.md @@ -2,7 +2,7 @@ name: bear-notes description: Create, search, and manage Bear notes via grizzly CLI. homepage: https://bear.app -metadata: {"clawdbot":{"emoji":"🐻","os":["darwin"],"requires":{"bins":["grizzly"]},"install":[{"id":"go","kind":"go","module":"github.com/tylerwince/grizzly/cmd/grizzly@latest","bins":["grizzly"],"label":"Install grizzly (go)"}]}} +metadata: {"moltbot":{"emoji":"🐻","os":["darwin"],"requires":{"bins":["grizzly"]},"install":[{"id":"go","kind":"go","module":"github.com/tylerwince/grizzly/cmd/grizzly@latest","bins":["grizzly"],"label":"Install grizzly (go)"}]}} --- # Bear Notes diff --git a/skills/bird/SKILL.md b/skills/bird/SKILL.md index 8887b86fc..5bc7e5a48 100644 --- a/skills/bird/SKILL.md +++ b/skills/bird/SKILL.md @@ -2,7 +2,7 @@ name: bird description: X/Twitter CLI for reading, searching, posting, and engagement via cookies. homepage: https://bird.fast -metadata: {"clawdbot":{"emoji":"🐦","requires":{"bins":["bird"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/bird","bins":["bird"],"label":"Install bird (brew)","os":["darwin"]},{"id":"npm","kind":"node","package":"@steipete/bird","bins":["bird"],"label":"Install bird (npm)"}]}} +metadata: {"moltbot":{"emoji":"🐦","requires":{"bins":["bird"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/bird","bins":["bird"],"label":"Install bird (brew)","os":["darwin"]},{"id":"npm","kind":"node","package":"@steipete/bird","bins":["bird"],"label":"Install bird (npm)"}]}} --- # bird 🐦 diff --git a/skills/blogwatcher/SKILL.md b/skills/blogwatcher/SKILL.md index f4b03dc76..345a013da 100644 --- a/skills/blogwatcher/SKILL.md +++ b/skills/blogwatcher/SKILL.md @@ -2,7 +2,7 @@ name: blogwatcher description: Monitor blogs and RSS/Atom feeds for updates using the blogwatcher CLI. homepage: https://github.com/Hyaxia/blogwatcher -metadata: {"clawdbot":{"emoji":"📰","requires":{"bins":["blogwatcher"]},"install":[{"id":"go","kind":"go","module":"github.com/Hyaxia/blogwatcher/cmd/blogwatcher@latest","bins":["blogwatcher"],"label":"Install blogwatcher (go)"}]}} +metadata: {"moltbot":{"emoji":"📰","requires":{"bins":["blogwatcher"]},"install":[{"id":"go","kind":"go","module":"github.com/Hyaxia/blogwatcher/cmd/blogwatcher@latest","bins":["blogwatcher"],"label":"Install blogwatcher (go)"}]}} --- # blogwatcher diff --git a/skills/blucli/SKILL.md b/skills/blucli/SKILL.md index e10045455..40c6b9609 100644 --- a/skills/blucli/SKILL.md +++ b/skills/blucli/SKILL.md @@ -2,7 +2,7 @@ name: blucli description: BluOS CLI (blu) for discovery, playback, grouping, and volume. homepage: https://blucli.sh -metadata: {"clawdbot":{"emoji":"🫐","requires":{"bins":["blu"]},"install":[{"id":"go","kind":"go","module":"github.com/steipete/blucli/cmd/blu@latest","bins":["blu"],"label":"Install blucli (go)"}]}} +metadata: {"moltbot":{"emoji":"🫐","requires":{"bins":["blu"]},"install":[{"id":"go","kind":"go","module":"github.com/steipete/blucli/cmd/blu@latest","bins":["blu"],"label":"Install blucli (go)"}]}} --- # blucli (blu) diff --git a/skills/bluebubbles/SKILL.md b/skills/bluebubbles/SKILL.md index 3a71f235f..89a851763 100644 --- a/skills/bluebubbles/SKILL.md +++ b/skills/bluebubbles/SKILL.md @@ -1,6 +1,6 @@ --- name: bluebubbles -description: Build or update the BlueBubbles external channel plugin for Clawdbot (extension package, REST send/probe, webhook inbound). +description: Build or update the BlueBubbles external channel plugin for Moltbot (extension package, REST send/probe, webhook inbound). --- # BlueBubbles plugin diff --git a/skills/camsnap/SKILL.md b/skills/camsnap/SKILL.md index c158b1c76..d7fe01b0c 100644 --- a/skills/camsnap/SKILL.md +++ b/skills/camsnap/SKILL.md @@ -2,7 +2,7 @@ name: camsnap description: Capture frames or clips from RTSP/ONVIF cameras. homepage: https://camsnap.ai -metadata: {"clawdbot":{"emoji":"📸","requires":{"bins":["camsnap"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/camsnap","bins":["camsnap"],"label":"Install camsnap (brew)"}]}} +metadata: {"moltbot":{"emoji":"📸","requires":{"bins":["camsnap"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/camsnap","bins":["camsnap"],"label":"Install camsnap (brew)"}]}} --- # camsnap diff --git a/skills/canvas/SKILL.md b/skills/canvas/SKILL.md index f93a3251f..11cbf0279 100644 --- a/skills/canvas/SKILL.md +++ b/skills/canvas/SKILL.md @@ -1,6 +1,6 @@ # Canvas Skill -Display HTML content on connected Clawdbot nodes (Mac app, iOS, Android). +Display HTML content on connected Moltbot nodes (Mac app, iOS, Android). ## Overview @@ -38,7 +38,7 @@ The canvas host server binds based on `gateway.bind` setting: **Key insight:** The `canvasHostHostForBridge` is derived from `bridgeHost`. When bound to Tailscale, nodes receive URLs like: ``` -http://:18793/__clawdbot__/canvas/.html +http://:18793/__moltbot__/canvas/.html ``` This is why localhost URLs don't work - the node receives the Tailscale hostname from the bridge! @@ -55,7 +55,7 @@ This is why localhost URLs don't work - the node receives the Tailscale hostname ## Configuration -In `~/.clawdbot/clawdbot.json`: +In `~/.clawdbot/moltbot.json`: ```json { @@ -102,12 +102,12 @@ HTML Check how your gateway is bound: ```bash -cat ~/.clawdbot/clawdbot.json | jq '.gateway.bind' +cat ~/.clawdbot/moltbot.json | jq '.gateway.bind' ``` Then construct the URL: -- **loopback**: `http://127.0.0.1:18793/__clawdbot__/canvas/.html` -- **lan/tailnet/auto**: `http://:18793/__clawdbot__/canvas/.html` +- **loopback**: `http://127.0.0.1:18793/__moltbot__/canvas/.html` +- **lan/tailnet/auto**: `http://:18793/__moltbot__/canvas/.html` Find your Tailscale hostname: ```bash @@ -117,7 +117,7 @@ tailscale status --json | jq -r '.Self.DNSName' | sed 's/\.$//' ### 3. Find connected nodes ```bash -clawdbot nodes list +moltbot nodes list ``` Look for Mac/iOS/Android nodes with canvas capability. @@ -130,7 +130,7 @@ canvas action:present node: target: **Example:** ``` -canvas action:present node:mac-63599bc4-b54d-4392-9048-b97abd58343a target:http://peters-mac-studio-1.sheep-coho.ts.net:18793/__clawdbot__/canvas/snake.html +canvas action:present node:mac-63599bc4-b54d-4392-9048-b97abd58343a target:http://peters-mac-studio-1.sheep-coho.ts.net:18793/__moltbot__/canvas/snake.html ``` ### 5. Navigate, snapshot, or hide @@ -148,9 +148,9 @@ canvas action:hide node: **Cause:** URL mismatch between server bind and node expectation. **Debug steps:** -1. Check server bind: `cat ~/.clawdbot/clawdbot.json | jq '.gateway.bind'` +1. Check server bind: `cat ~/.clawdbot/moltbot.json | jq '.gateway.bind'` 2. Check what port canvas is on: `lsof -i :18793` -3. Test URL directly: `curl http://:18793/__clawdbot__/canvas/.html` +3. Test URL directly: `curl http://:18793/__moltbot__/canvas/.html` **Solution:** Use the full hostname matching your bind mode, not localhost. @@ -160,7 +160,7 @@ Always specify `node:` parameter. ### "node not connected" error -Node is offline. Use `clawdbot nodes list` to find online nodes. +Node is offline. Use `moltbot nodes list` to find online nodes. ### Content not updating @@ -171,14 +171,14 @@ If live reload isn't working: ## URL Path Structure -The canvas host serves from `/__clawdbot__/canvas/` prefix: +The canvas host serves from `/__moltbot__/canvas/` prefix: ``` -http://:18793/__clawdbot__/canvas/index.html → ~/clawd/canvas/index.html -http://:18793/__clawdbot__/canvas/games/snake.html → ~/clawd/canvas/games/snake.html +http://:18793/__moltbot__/canvas/index.html → ~/clawd/canvas/index.html +http://:18793/__moltbot__/canvas/games/snake.html → ~/clawd/canvas/games/snake.html ``` -The `/__clawdbot__/canvas/` prefix is defined by `CANVAS_HOST_PATH` constant. +The `/__moltbot__/canvas/` prefix is defined by `CANVAS_HOST_PATH` constant. ## Tips diff --git a/skills/clawdhub/SKILL.md b/skills/clawdhub/SKILL.md index d9e9fdac2..c62be8ba7 100644 --- a/skills/clawdhub/SKILL.md +++ b/skills/clawdhub/SKILL.md @@ -1,7 +1,7 @@ --- name: clawdhub description: Use the ClawdHub CLI to search, install, update, and publish agent skills from clawdhub.com. Use when you need to fetch new skills on the fly, sync installed skills to latest or a specific version, or publish new/updated skill folders with the npm-installed clawdhub CLI. -metadata: {"clawdbot":{"requires":{"bins":["clawdhub"]},"install":[{"id":"node","kind":"node","package":"clawdhub","bins":["clawdhub"],"label":"Install ClawdHub CLI (npm)"}]}} +metadata: {"moltbot":{"requires":{"bins":["clawdhub"]},"install":[{"id":"node","kind":"node","package":"clawdhub","bins":["clawdhub"],"label":"Install ClawdHub CLI (npm)"}]}} --- # ClawdHub CLI @@ -49,5 +49,5 @@ clawdhub publish ./my-skill --slug my-skill --name "My Skill" --version 1.2.0 -- Notes - Default registry: https://clawdhub.com (override with CLAWDHUB_REGISTRY or --registry) -- Default workdir: cwd (falls back to Clawdbot workspace); install dir: ./skills (override with --workdir / --dir / CLAWDHUB_WORKDIR) +- Default workdir: cwd (falls back to Moltbot workspace); install dir: ./skills (override with --workdir / --dir / CLAWDHUB_WORKDIR) - Update command hashes local files, resolves matching version, and upgrades to latest unless --version is set diff --git a/skills/coding-agent/SKILL.md b/skills/coding-agent/SKILL.md index cae7af0ee..d8713d185 100644 --- a/skills/coding-agent/SKILL.md +++ b/skills/coding-agent/SKILL.md @@ -1,7 +1,7 @@ --- name: coding-agent description: Run Codex CLI, Claude Code, OpenCode, or Pi Coding Agent via background process for programmatic control. -metadata: {"clawdbot":{"emoji":"🧩","requires":{"anyBins":["claude","codex","opencode","pi"]}}} +metadata: {"moltbot":{"emoji":"🧩","requires":{"anyBins":["claude","codex","opencode","pi"]}}} --- # Coding Agent (bash-first) @@ -116,7 +116,7 @@ bash pty:true workdir:~/project background:true command:"codex --yolo 'Refactor ### Reviewing PRs -**⚠️ CRITICAL: Never review PRs in Clawdbot's own project folder!** +**⚠️ CRITICAL: Never review PRs in Moltbot's own project folder!** Clone to temp folder or use git worktree. ```bash @@ -227,7 +227,7 @@ git worktree remove /tmp/issue-99 6. **vanilla for reviewing** - no special flags needed 7. **Parallel is OK** - run many Codex processes at once for batch work 8. **NEVER start Codex in ~/clawd/** - it'll read your soul docs and get weird ideas about the org chart! -9. **NEVER checkout branches in ~/Projects/clawdbot/** - that's the LIVE Clawdbot instance! +9. **NEVER checkout branches in ~/Projects/moltbot/** - that's the LIVE Moltbot instance! --- @@ -249,20 +249,20 @@ This prevents the user from seeing only "Agent failed before reply" and having n ## Auto-Notify on Completion -For long-running background tasks, append a wake trigger to your prompt so Clawdbot gets notified immediately when the agent finishes (instead of waiting for the next heartbeat): +For long-running background tasks, append a wake trigger to your prompt so Moltbot gets notified immediately when the agent finishes (instead of waiting for the next heartbeat): ``` ... your task here. When completely finished, run this command to notify me: -clawdbot gateway wake --text "Done: [brief summary of what was built]" --mode now +moltbot gateway wake --text "Done: [brief summary of what was built]" --mode now ``` **Example:** ```bash bash pty:true workdir:~/project background:true command:"codex --yolo exec 'Build a REST API for todos. -When completely finished, run: clawdbot gateway wake --text \"Done: Built todos REST API with CRUD endpoints\" --mode now'" +When completely finished, run: moltbot gateway wake --text \"Done: Built todos REST API with CRUD endpoints\" --mode now'" ``` This triggers an immediate wake event — Skippy gets pinged in seconds, not 10 minutes. diff --git a/skills/discord/SKILL.md b/skills/discord/SKILL.md index 5525a3bf5..3f633bbd3 100644 --- a/skills/discord/SKILL.md +++ b/skills/discord/SKILL.md @@ -1,14 +1,14 @@ --- name: discord -description: Use when you need to control Discord from Clawdbot via the discord tool: send messages, react, post or upload stickers, upload emojis, run polls, manage threads/pins/search, create/edit/delete channels and categories, fetch permissions or member/role/channel info, or handle moderation actions in Discord DMs or channels. -metadata: {"clawdbot":{"emoji":"🎮","requires":{"config":["channels.discord"]}}} +description: Use when you need to control Discord from Moltbot via the discord tool: send messages, react, post or upload stickers, upload emojis, run polls, manage threads/pins/search, create/edit/delete channels and categories, fetch permissions or member/role/channel info, or handle moderation actions in Discord DMs or channels. +metadata: {"moltbot":{"emoji":"🎮","requires":{"config":["channels.discord"]}}} --- # Discord Actions ## Overview -Use `discord` to manage messages, reactions, threads, polls, and moderation. You can disable groups via `discord.actions.*` (defaults to enabled, except roles/moderation). The tool uses the bot token configured for Clawdbot. +Use `discord` to manage messages, reactions, threads, polls, and moderation. You can disable groups via `discord.actions.*` (defaults to enabled, except roles/moderation). The tool uses the bot token configured for Moltbot. ## Inputs to collect @@ -84,8 +84,8 @@ Message context lines include `discord message id` and `channel` fields you can { "action": "stickerUpload", "guildId": "999", - "name": "clawdbot_wave", - "description": "Clawdbot waving hello", + "name": "moltbot_wave", + "description": "Moltbot waving hello", "tags": "👋", "mediaUrl": "file:///tmp/wave.png" } @@ -172,7 +172,7 @@ Use `discord.actions.*` to disable action groups: { "action": "sendMessage", "to": "channel:123", - "content": "Hello from Clawdbot" + "content": "Hello from Moltbot" } ``` diff --git a/skills/eightctl/SKILL.md b/skills/eightctl/SKILL.md index aeffa0b9f..f7491bf29 100644 --- a/skills/eightctl/SKILL.md +++ b/skills/eightctl/SKILL.md @@ -2,7 +2,7 @@ name: eightctl description: Control Eight Sleep pods (status, temperature, alarms, schedules). homepage: https://eightctl.sh -metadata: {"clawdbot":{"emoji":"🎛️","requires":{"bins":["eightctl"]},"install":[{"id":"go","kind":"go","module":"github.com/steipete/eightctl/cmd/eightctl@latest","bins":["eightctl"],"label":"Install eightctl (go)"}]}} +metadata: {"moltbot":{"emoji":"🎛️","requires":{"bins":["eightctl"]},"install":[{"id":"go","kind":"go","module":"github.com/steipete/eightctl/cmd/eightctl@latest","bins":["eightctl"],"label":"Install eightctl (go)"}]}} --- # eightctl diff --git a/skills/food-order/SKILL.md b/skills/food-order/SKILL.md index 8e2712592..881e030fb 100644 --- a/skills/food-order/SKILL.md +++ b/skills/food-order/SKILL.md @@ -2,7 +2,7 @@ name: food-order description: Reorder Foodora orders + track ETA/status with ordercli. Never confirm without explicit user approval. Triggers: order food, reorder, track ETA. homepage: https://ordercli.sh -metadata: {"clawdbot":{"emoji":"🥡","requires":{"bins":["ordercli"]},"install":[{"id":"go","kind":"go","module":"github.com/steipete/ordercli/cmd/ordercli@latest","bins":["ordercli"],"label":"Install ordercli (go)"}]}} +metadata: {"moltbot":{"emoji":"🥡","requires":{"bins":["ordercli"]},"install":[{"id":"go","kind":"go","module":"github.com/steipete/ordercli/cmd/ordercli@latest","bins":["ordercli"],"label":"Install ordercli (go)"}]}} --- # Food order (Foodora via ordercli) diff --git a/skills/gemini/SKILL.md b/skills/gemini/SKILL.md index 6ef31ba6f..038d6eb46 100644 --- a/skills/gemini/SKILL.md +++ b/skills/gemini/SKILL.md @@ -2,7 +2,7 @@ name: gemini description: Gemini CLI for one-shot Q&A, summaries, and generation. homepage: https://ai.google.dev/ -metadata: {"clawdbot":{"emoji":"♊️","requires":{"bins":["gemini"]},"install":[{"id":"brew","kind":"brew","formula":"gemini-cli","bins":["gemini"],"label":"Install Gemini CLI (brew)"}]}} +metadata: {"moltbot":{"emoji":"♊️","requires":{"bins":["gemini"]},"install":[{"id":"brew","kind":"brew","formula":"gemini-cli","bins":["gemini"],"label":"Install Gemini CLI (brew)"}]}} --- # Gemini CLI diff --git a/skills/gifgrep/SKILL.md b/skills/gifgrep/SKILL.md index 6b1ee31d7..361fe36d0 100644 --- a/skills/gifgrep/SKILL.md +++ b/skills/gifgrep/SKILL.md @@ -2,7 +2,7 @@ name: gifgrep description: Search GIF providers with CLI/TUI, download results, and extract stills/sheets. homepage: https://gifgrep.com -metadata: {"clawdbot":{"emoji":"🧲","requires":{"bins":["gifgrep"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/gifgrep","bins":["gifgrep"],"label":"Install gifgrep (brew)"},{"id":"go","kind":"go","module":"github.com/steipete/gifgrep/cmd/gifgrep@latest","bins":["gifgrep"],"label":"Install gifgrep (go)"}]}} +metadata: {"moltbot":{"emoji":"🧲","requires":{"bins":["gifgrep"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/gifgrep","bins":["gifgrep"],"label":"Install gifgrep (brew)"},{"id":"go","kind":"go","module":"github.com/steipete/gifgrep/cmd/gifgrep@latest","bins":["gifgrep"],"label":"Install gifgrep (go)"}]}} --- # gifgrep diff --git a/skills/github/SKILL.md b/skills/github/SKILL.md index e7c89f7ba..78078563f 100644 --- a/skills/github/SKILL.md +++ b/skills/github/SKILL.md @@ -1,7 +1,7 @@ --- name: github description: "Interact with GitHub using the `gh` CLI. Use `gh issue`, `gh pr`, `gh run`, and `gh api` for issues, PRs, CI runs, and advanced queries." -metadata: {"clawdbot":{"emoji":"🐙","requires":{"bins":["gh"]},"install":[{"id":"brew","kind":"brew","formula":"gh","bins":["gh"],"label":"Install GitHub CLI (brew)"},{"id":"apt","kind":"apt","package":"gh","bins":["gh"],"label":"Install GitHub CLI (apt)"}]}} +metadata: {"moltbot":{"emoji":"🐙","requires":{"bins":["gh"]},"install":[{"id":"brew","kind":"brew","formula":"gh","bins":["gh"],"label":"Install GitHub CLI (brew)"},{"id":"apt","kind":"apt","package":"gh","bins":["gh"],"label":"Install GitHub CLI (apt)"}]}} --- # GitHub Skill diff --git a/skills/gog/SKILL.md b/skills/gog/SKILL.md index 416b86065..90c03ad22 100644 --- a/skills/gog/SKILL.md +++ b/skills/gog/SKILL.md @@ -2,7 +2,7 @@ name: gog description: Google Workspace CLI for Gmail, Calendar, Drive, Contacts, Sheets, and Docs. homepage: https://gogcli.sh -metadata: {"clawdbot":{"emoji":"🎮","requires":{"bins":["gog"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/gogcli","bins":["gog"],"label":"Install gog (brew)"}]}} +metadata: {"moltbot":{"emoji":"🎮","requires":{"bins":["gog"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/gogcli","bins":["gog"],"label":"Install gog (brew)"}]}} --- # gog diff --git a/skills/goplaces/SKILL.md b/skills/goplaces/SKILL.md index d2ce91c84..e2f2b01c5 100644 --- a/skills/goplaces/SKILL.md +++ b/skills/goplaces/SKILL.md @@ -2,7 +2,7 @@ name: goplaces description: Query Google Places API (New) via the goplaces CLI for text search, place details, resolve, and reviews. Use for human-friendly place lookup or JSON output for scripts. homepage: https://github.com/steipete/goplaces -metadata: {"clawdbot":{"emoji":"📍","requires":{"bins":["goplaces"],"env":["GOOGLE_PLACES_API_KEY"]},"primaryEnv":"GOOGLE_PLACES_API_KEY","install":[{"id":"brew","kind":"brew","formula":"steipete/tap/goplaces","bins":["goplaces"],"label":"Install goplaces (brew)"}]}} +metadata: {"moltbot":{"emoji":"📍","requires":{"bins":["goplaces"],"env":["GOOGLE_PLACES_API_KEY"]},"primaryEnv":"GOOGLE_PLACES_API_KEY","install":[{"id":"brew","kind":"brew","formula":"steipete/tap/goplaces","bins":["goplaces"],"label":"Install goplaces (brew)"}]}} --- # goplaces diff --git a/skills/himalaya/SKILL.md b/skills/himalaya/SKILL.md index 77a513df2..194a1613a 100644 --- a/skills/himalaya/SKILL.md +++ b/skills/himalaya/SKILL.md @@ -2,7 +2,7 @@ name: himalaya description: "CLI to manage emails via IMAP/SMTP. Use `himalaya` to list, read, write, reply, forward, search, and organize emails from the terminal. Supports multiple accounts and message composition with MML (MIME Meta Language)." homepage: https://github.com/pimalaya/himalaya -metadata: {"clawdbot":{"emoji":"📧","requires":{"bins":["himalaya"]},"install":[{"id":"brew","kind":"brew","formula":"himalaya","bins":["himalaya"],"label":"Install Himalaya (brew)"}]}} +metadata: {"moltbot":{"emoji":"📧","requires":{"bins":["himalaya"]},"install":[{"id":"brew","kind":"brew","formula":"himalaya","bins":["himalaya"],"label":"Install Himalaya (brew)"}]}} --- # Himalaya Email CLI diff --git a/skills/imsg/SKILL.md b/skills/imsg/SKILL.md index 678549380..3b8fceeb2 100644 --- a/skills/imsg/SKILL.md +++ b/skills/imsg/SKILL.md @@ -2,7 +2,7 @@ name: imsg description: iMessage/SMS CLI for listing chats, history, watch, and sending. homepage: https://imsg.to -metadata: {"clawdbot":{"emoji":"📨","os":["darwin"],"requires":{"bins":["imsg"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/imsg","bins":["imsg"],"label":"Install imsg (brew)"}]}} +metadata: {"moltbot":{"emoji":"📨","os":["darwin"],"requires":{"bins":["imsg"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/imsg","bins":["imsg"],"label":"Install imsg (brew)"}]}} --- # imsg diff --git a/skills/local-places/SKILL.md b/skills/local-places/SKILL.md index 5b0fdc3a8..44d468cca 100644 --- a/skills/local-places/SKILL.md +++ b/skills/local-places/SKILL.md @@ -2,7 +2,7 @@ name: local-places description: Search for places (restaurants, cafes, etc.) via Google Places API proxy on localhost. homepage: https://github.com/Hyaxia/local_places -metadata: {"clawdbot":{"emoji":"📍","requires":{"bins":["uv"],"env":["GOOGLE_PLACES_API_KEY"]},"primaryEnv":"GOOGLE_PLACES_API_KEY"}} +metadata: {"moltbot":{"emoji":"📍","requires":{"bins":["uv"],"env":["GOOGLE_PLACES_API_KEY"]},"primaryEnv":"GOOGLE_PLACES_API_KEY"}} --- # 📍 Local Places diff --git a/skills/mcporter/SKILL.md b/skills/mcporter/SKILL.md index 892e309c8..5718ce084 100644 --- a/skills/mcporter/SKILL.md +++ b/skills/mcporter/SKILL.md @@ -2,7 +2,7 @@ name: mcporter description: Use the mcporter CLI to list, configure, auth, and call MCP servers/tools directly (HTTP or stdio), including ad-hoc servers, config edits, and CLI/type generation. homepage: http://mcporter.dev -metadata: {"clawdbot":{"emoji":"📦","requires":{"bins":["mcporter"]},"install":[{"id":"node","kind":"node","package":"mcporter","bins":["mcporter"],"label":"Install mcporter (node)"}]}} +metadata: {"moltbot":{"emoji":"📦","requires":{"bins":["mcporter"]},"install":[{"id":"node","kind":"node","package":"mcporter","bins":["mcporter"],"label":"Install mcporter (node)"}]}} --- # mcporter diff --git a/skills/model-usage/SKILL.md b/skills/model-usage/SKILL.md index ed8871dea..ae3b3c4db 100644 --- a/skills/model-usage/SKILL.md +++ b/skills/model-usage/SKILL.md @@ -1,7 +1,7 @@ --- name: model-usage description: Use CodexBar CLI local cost usage to summarize per-model usage for Codex or Claude, including the current (most recent) model or a full model breakdown. Trigger when asked for model-level usage/cost data from codexbar, or when you need a scriptable per-model summary from codexbar cost JSON. -metadata: {"clawdbot":{"emoji":"📊","os":["darwin"],"requires":{"bins":["codexbar"]},"install":[{"id":"brew-cask","kind":"brew","cask":"steipete/tap/codexbar","bins":["codexbar"],"label":"Install CodexBar (brew cask)"}]}} +metadata: {"moltbot":{"emoji":"📊","os":["darwin"],"requires":{"bins":["codexbar"]},"install":[{"id":"brew-cask","kind":"brew","cask":"steipete/tap/codexbar","bins":["codexbar"],"label":"Install CodexBar (brew cask)"}]}} --- # Model usage diff --git a/skills/nano-banana-pro/SKILL.md b/skills/nano-banana-pro/SKILL.md index 469576ec7..ee3ebfed0 100644 --- a/skills/nano-banana-pro/SKILL.md +++ b/skills/nano-banana-pro/SKILL.md @@ -2,7 +2,7 @@ name: nano-banana-pro description: Generate or edit images via Gemini 3 Pro Image (Nano Banana Pro). homepage: https://ai.google.dev/ -metadata: {"clawdbot":{"emoji":"🍌","requires":{"bins":["uv"],"env":["GEMINI_API_KEY"]},"primaryEnv":"GEMINI_API_KEY","install":[{"id":"uv-brew","kind":"brew","formula":"uv","bins":["uv"],"label":"Install uv (brew)"}]}} +metadata: {"moltbot":{"emoji":"🍌","requires":{"bins":["uv"],"env":["GEMINI_API_KEY"]},"primaryEnv":"GEMINI_API_KEY","install":[{"id":"uv-brew","kind":"brew","formula":"uv","bins":["uv"],"label":"Install uv (brew)"}]}} --- # Nano Banana Pro (Gemini 3 Pro Image) @@ -26,10 +26,10 @@ uv run {baseDir}/scripts/generate_image.py --prompt "combine these into one scen API key - `GEMINI_API_KEY` env var -- Or set `skills."nano-banana-pro".apiKey` / `skills."nano-banana-pro".env.GEMINI_API_KEY` in `~/.clawdbot/clawdbot.json` +- Or set `skills."nano-banana-pro".apiKey` / `skills."nano-banana-pro".env.GEMINI_API_KEY` in `~/.clawdbot/moltbot.json` Notes - Resolutions: `1K` (default), `2K`, `4K`. - Use timestamps in filenames: `yyyy-mm-dd-hh-mm-ss-name.png`. -- The script prints a `MEDIA:` line for Clawdbot to auto-attach on supported chat providers. +- The script prints a `MEDIA:` line for Moltbot to auto-attach on supported chat providers. - Do not read the image back; report the saved path only. diff --git a/skills/nano-banana-pro/scripts/generate_image.py b/skills/nano-banana-pro/scripts/generate_image.py index 32fc1fc32..56f8883ca 100755 --- a/skills/nano-banana-pro/scripts/generate_image.py +++ b/skills/nano-banana-pro/scripts/generate_image.py @@ -169,7 +169,7 @@ def main(): if image_saved: full_path = output_path.resolve() print(f"\nImage saved: {full_path}") - # Clawdbot parses MEDIA tokens and will attach the file on supported providers. + # Moltbot parses MEDIA tokens and will attach the file on supported providers. print(f"MEDIA: {full_path}") else: print("Error: No image was generated in the response.", file=sys.stderr) diff --git a/skills/nano-pdf/SKILL.md b/skills/nano-pdf/SKILL.md index fdc6b8698..9488f34d7 100644 --- a/skills/nano-pdf/SKILL.md +++ b/skills/nano-pdf/SKILL.md @@ -2,7 +2,7 @@ name: nano-pdf description: Edit PDFs with natural-language instructions using the nano-pdf CLI. homepage: https://pypi.org/project/nano-pdf/ -metadata: {"clawdbot":{"emoji":"📄","requires":{"bins":["nano-pdf"]},"install":[{"id":"uv","kind":"uv","package":"nano-pdf","bins":["nano-pdf"],"label":"Install nano-pdf (uv)"}]}} +metadata: {"moltbot":{"emoji":"📄","requires":{"bins":["nano-pdf"]},"install":[{"id":"uv","kind":"uv","package":"nano-pdf","bins":["nano-pdf"],"label":"Install nano-pdf (uv)"}]}} --- # nano-pdf diff --git a/skills/notion/SKILL.md b/skills/notion/SKILL.md index 04921e250..8ae7c616d 100644 --- a/skills/notion/SKILL.md +++ b/skills/notion/SKILL.md @@ -2,7 +2,7 @@ name: notion description: Notion API for creating and managing pages, databases, and blocks. homepage: https://developers.notion.com -metadata: {"clawdbot":{"emoji":"📝","requires":{"env":["NOTION_API_KEY"]},"primaryEnv":"NOTION_API_KEY"}} +metadata: {"moltbot":{"emoji":"📝","requires":{"env":["NOTION_API_KEY"]},"primaryEnv":"NOTION_API_KEY"}} --- # notion diff --git a/skills/obsidian/SKILL.md b/skills/obsidian/SKILL.md index 4bae0f525..533fcb6ec 100644 --- a/skills/obsidian/SKILL.md +++ b/skills/obsidian/SKILL.md @@ -2,7 +2,7 @@ name: obsidian description: Work with Obsidian vaults (plain Markdown notes) and automate via obsidian-cli. homepage: https://help.obsidian.md -metadata: {"clawdbot":{"emoji":"💎","requires":{"bins":["obsidian-cli"]},"install":[{"id":"brew","kind":"brew","formula":"yakitrak/yakitrak/obsidian-cli","bins":["obsidian-cli"],"label":"Install obsidian-cli (brew)"}]}} +metadata: {"moltbot":{"emoji":"💎","requires":{"bins":["obsidian-cli"]},"install":[{"id":"brew","kind":"brew","formula":"yakitrak/yakitrak/obsidian-cli","bins":["obsidian-cli"],"label":"Install obsidian-cli (brew)"}]}} --- # Obsidian diff --git a/skills/openai-image-gen/SKILL.md b/skills/openai-image-gen/SKILL.md index d1ebb1236..ca34c9045 100644 --- a/skills/openai-image-gen/SKILL.md +++ b/skills/openai-image-gen/SKILL.md @@ -2,7 +2,7 @@ name: openai-image-gen description: Batch-generate images via OpenAI Images API. Random prompt sampler + `index.html` gallery. homepage: https://platform.openai.com/docs/api-reference/images -metadata: {"clawdbot":{"emoji":"🖼️","requires":{"bins":["python3"],"env":["OPENAI_API_KEY"]},"primaryEnv":"OPENAI_API_KEY","install":[{"id":"python-brew","kind":"brew","formula":"python","bins":["python3"],"label":"Install Python (brew)"}]}} +metadata: {"moltbot":{"emoji":"🖼️","requires":{"bins":["python3"],"env":["OPENAI_API_KEY"]},"primaryEnv":"OPENAI_API_KEY","install":[{"id":"python-brew","kind":"brew","formula":"python","bins":["python3"],"label":"Install Python (brew)"}]}} --- # OpenAI Image Gen diff --git a/skills/openai-whisper-api/SKILL.md b/skills/openai-whisper-api/SKILL.md index 3c7949bd7..d77b8aba1 100644 --- a/skills/openai-whisper-api/SKILL.md +++ b/skills/openai-whisper-api/SKILL.md @@ -2,7 +2,7 @@ name: openai-whisper-api description: Transcribe audio via OpenAI Audio Transcriptions API (Whisper). homepage: https://platform.openai.com/docs/guides/speech-to-text -metadata: {"clawdbot":{"emoji":"☁️","requires":{"bins":["curl"],"env":["OPENAI_API_KEY"]},"primaryEnv":"OPENAI_API_KEY"}} +metadata: {"moltbot":{"emoji":"☁️","requires":{"bins":["curl"],"env":["OPENAI_API_KEY"]},"primaryEnv":"OPENAI_API_KEY"}} --- # OpenAI Whisper API (curl) @@ -30,7 +30,7 @@ Defaults: ## API key -Set `OPENAI_API_KEY`, or configure it in `~/.clawdbot/clawdbot.json`: +Set `OPENAI_API_KEY`, or configure it in `~/.clawdbot/moltbot.json`: ```json5 { diff --git a/skills/openai-whisper/SKILL.md b/skills/openai-whisper/SKILL.md index 190c244c4..06b2cb24b 100644 --- a/skills/openai-whisper/SKILL.md +++ b/skills/openai-whisper/SKILL.md @@ -2,7 +2,7 @@ name: openai-whisper description: Local speech-to-text with the Whisper CLI (no API key). homepage: https://openai.com/research/whisper -metadata: {"clawdbot":{"emoji":"🎙️","requires":{"bins":["whisper"]},"install":[{"id":"brew","kind":"brew","formula":"openai-whisper","bins":["whisper"],"label":"Install OpenAI Whisper (brew)"}]}} +metadata: {"moltbot":{"emoji":"🎙️","requires":{"bins":["whisper"]},"install":[{"id":"brew","kind":"brew","formula":"openai-whisper","bins":["whisper"],"label":"Install OpenAI Whisper (brew)"}]}} --- # Whisper (CLI) diff --git a/skills/openhue/SKILL.md b/skills/openhue/SKILL.md index 5a4d0ca60..58cbd49ec 100644 --- a/skills/openhue/SKILL.md +++ b/skills/openhue/SKILL.md @@ -2,7 +2,7 @@ name: openhue description: Control Philips Hue lights/scenes via the OpenHue CLI. homepage: https://www.openhue.io/cli -metadata: {"clawdbot":{"emoji":"💡","requires":{"bins":["openhue"]},"install":[{"id":"brew","kind":"brew","formula":"openhue/cli/openhue-cli","bins":["openhue"],"label":"Install OpenHue CLI (brew)"}]}} +metadata: {"moltbot":{"emoji":"💡","requires":{"bins":["openhue"]},"install":[{"id":"brew","kind":"brew","formula":"openhue/cli/openhue-cli","bins":["openhue"],"label":"Install OpenHue CLI (brew)"}]}} --- # OpenHue CLI diff --git a/skills/oracle/SKILL.md b/skills/oracle/SKILL.md index 368519bc0..0ff32cbf1 100644 --- a/skills/oracle/SKILL.md +++ b/skills/oracle/SKILL.md @@ -2,7 +2,7 @@ name: oracle description: Best practices for using the oracle CLI (prompt + file bundling, engines, sessions, and file attachment patterns). homepage: https://askoracle.dev -metadata: {"clawdbot":{"emoji":"🧿","requires":{"bins":["oracle"]},"install":[{"id":"node","kind":"node","package":"@steipete/oracle","bins":["oracle"],"label":"Install oracle (node)"}]}} +metadata: {"moltbot":{"emoji":"🧿","requires":{"bins":["oracle"]},"install":[{"id":"node","kind":"node","package":"@steipete/oracle","bins":["oracle"],"label":"Install oracle (node)"}]}} --- # oracle — best use diff --git a/skills/ordercli/SKILL.md b/skills/ordercli/SKILL.md index d43b57392..0cbf78f11 100644 --- a/skills/ordercli/SKILL.md +++ b/skills/ordercli/SKILL.md @@ -2,7 +2,7 @@ name: ordercli description: Foodora-only CLI for checking past orders and active order status (Deliveroo WIP). homepage: https://ordercli.sh -metadata: {"clawdbot":{"emoji":"🛵","requires":{"bins":["ordercli"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/ordercli","bins":["ordercli"],"label":"Install ordercli (brew)"},{"id":"go","kind":"go","module":"github.com/steipete/ordercli/cmd/ordercli@latest","bins":["ordercli"],"label":"Install ordercli (go)"}]}} +metadata: {"moltbot":{"emoji":"🛵","requires":{"bins":["ordercli"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/ordercli","bins":["ordercli"],"label":"Install ordercli (brew)"},{"id":"go","kind":"go","module":"github.com/steipete/ordercli/cmd/ordercli@latest","bins":["ordercli"],"label":"Install ordercli (go)"}]}} --- # ordercli diff --git a/skills/peekaboo/SKILL.md b/skills/peekaboo/SKILL.md index 079ae4fb2..d88a80b62 100644 --- a/skills/peekaboo/SKILL.md +++ b/skills/peekaboo/SKILL.md @@ -2,7 +2,7 @@ name: peekaboo description: Capture and automate macOS UI with the Peekaboo CLI. homepage: https://peekaboo.boo -metadata: {"clawdbot":{"emoji":"👀","os":["darwin"],"requires":{"bins":["peekaboo"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/peekaboo","bins":["peekaboo"],"label":"Install Peekaboo (brew)"}]}} +metadata: {"moltbot":{"emoji":"👀","os":["darwin"],"requires":{"bins":["peekaboo"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/peekaboo","bins":["peekaboo"],"label":"Install Peekaboo (brew)"}]}} --- # Peekaboo diff --git a/skills/sag/SKILL.md b/skills/sag/SKILL.md index b8aef8e8f..d85a543ec 100644 --- a/skills/sag/SKILL.md +++ b/skills/sag/SKILL.md @@ -2,7 +2,7 @@ name: sag description: ElevenLabs text-to-speech with mac-style say UX. homepage: https://sag.sh -metadata: {"clawdbot":{"emoji":"🗣️","requires":{"bins":["sag"],"env":["ELEVENLABS_API_KEY"]},"primaryEnv":"ELEVENLABS_API_KEY","install":[{"id":"brew","kind":"brew","formula":"steipete/tap/sag","bins":["sag"],"label":"Install sag (brew)"}]}} +metadata: {"moltbot":{"emoji":"🗣️","requires":{"bins":["sag"],"env":["ELEVENLABS_API_KEY"]},"primaryEnv":"ELEVENLABS_API_KEY","install":[{"id":"brew","kind":"brew","formula":"steipete/tap/sag","bins":["sag"],"label":"Install sag (brew)"}]}} --- # sag diff --git a/skills/session-logs/SKILL.md b/skills/session-logs/SKILL.md index 9a4462c4c..9556dfc1b 100644 --- a/skills/session-logs/SKILL.md +++ b/skills/session-logs/SKILL.md @@ -1,7 +1,7 @@ --- name: session-logs description: Search and analyze your own session logs (older/parent conversations) using jq. -metadata: {"clawdbot":{"emoji":"📜","requires":{"bins":["jq","rg"]}}} +metadata: {"moltbot":{"emoji":"📜","requires":{"bins":["jq","rg"]}}} --- # session-logs diff --git a/skills/sherpa-onnx-tts/SKILL.md b/skills/sherpa-onnx-tts/SKILL.md index 9f5a87352..1ca2521d9 100644 --- a/skills/sherpa-onnx-tts/SKILL.md +++ b/skills/sherpa-onnx-tts/SKILL.md @@ -1,7 +1,7 @@ --- name: sherpa-onnx-tts description: Local text-to-speech via sherpa-onnx (offline, no cloud) -metadata: {"clawdbot":{"emoji":"🗣️","os":["darwin","linux","win32"],"requires":{"env":["SHERPA_ONNX_RUNTIME_DIR","SHERPA_ONNX_MODEL_DIR"]},"install":[{"id":"download-runtime-macos","kind":"download","os":["darwin"],"url":"https://github.com/k2-fsa/sherpa-onnx/releases/download/v1.12.23/sherpa-onnx-v1.12.23-osx-universal2-shared.tar.bz2","archive":"tar.bz2","extract":true,"stripComponents":1,"targetDir":"~/.clawdbot/tools/sherpa-onnx-tts/runtime","label":"Download sherpa-onnx runtime (macOS)"},{"id":"download-runtime-linux-x64","kind":"download","os":["linux"],"url":"https://github.com/k2-fsa/sherpa-onnx/releases/download/v1.12.23/sherpa-onnx-v1.12.23-linux-x64-shared.tar.bz2","archive":"tar.bz2","extract":true,"stripComponents":1,"targetDir":"~/.clawdbot/tools/sherpa-onnx-tts/runtime","label":"Download sherpa-onnx runtime (Linux x64)"},{"id":"download-runtime-win-x64","kind":"download","os":["win32"],"url":"https://github.com/k2-fsa/sherpa-onnx/releases/download/v1.12.23/sherpa-onnx-v1.12.23-win-x64-shared.tar.bz2","archive":"tar.bz2","extract":true,"stripComponents":1,"targetDir":"~/.clawdbot/tools/sherpa-onnx-tts/runtime","label":"Download sherpa-onnx runtime (Windows x64)"},{"id":"download-model-lessac","kind":"download","url":"https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-piper-en_US-lessac-high.tar.bz2","archive":"tar.bz2","extract":true,"targetDir":"~/.clawdbot/tools/sherpa-onnx-tts/models","label":"Download Piper en_US lessac (high)"}]}} +metadata: {"moltbot":{"emoji":"🗣️","os":["darwin","linux","win32"],"requires":{"env":["SHERPA_ONNX_RUNTIME_DIR","SHERPA_ONNX_MODEL_DIR"]},"install":[{"id":"download-runtime-macos","kind":"download","os":["darwin"],"url":"https://github.com/k2-fsa/sherpa-onnx/releases/download/v1.12.23/sherpa-onnx-v1.12.23-osx-universal2-shared.tar.bz2","archive":"tar.bz2","extract":true,"stripComponents":1,"targetDir":"~/.clawdbot/tools/sherpa-onnx-tts/runtime","label":"Download sherpa-onnx runtime (macOS)"},{"id":"download-runtime-linux-x64","kind":"download","os":["linux"],"url":"https://github.com/k2-fsa/sherpa-onnx/releases/download/v1.12.23/sherpa-onnx-v1.12.23-linux-x64-shared.tar.bz2","archive":"tar.bz2","extract":true,"stripComponents":1,"targetDir":"~/.clawdbot/tools/sherpa-onnx-tts/runtime","label":"Download sherpa-onnx runtime (Linux x64)"},{"id":"download-runtime-win-x64","kind":"download","os":["win32"],"url":"https://github.com/k2-fsa/sherpa-onnx/releases/download/v1.12.23/sherpa-onnx-v1.12.23-win-x64-shared.tar.bz2","archive":"tar.bz2","extract":true,"stripComponents":1,"targetDir":"~/.clawdbot/tools/sherpa-onnx-tts/runtime","label":"Download sherpa-onnx runtime (Windows x64)"},{"id":"download-model-lessac","kind":"download","url":"https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-piper-en_US-lessac-high.tar.bz2","archive":"tar.bz2","extract":true,"targetDir":"~/.clawdbot/tools/sherpa-onnx-tts/models","label":"Download Piper en_US lessac (high)"}]}} --- # sherpa-onnx-tts @@ -13,7 +13,7 @@ Local TTS using the sherpa-onnx offline CLI. 1) Download the runtime for your OS (extracts into `~/.clawdbot/tools/sherpa-onnx-tts/runtime`) 2) Download a voice model (extracts into `~/.clawdbot/tools/sherpa-onnx-tts/models`) -Update `~/.clawdbot/clawdbot.json`: +Update `~/.clawdbot/moltbot.json`: ```json5 { diff --git a/skills/slack/SKILL.md b/skills/slack/SKILL.md index b72bab1f3..bd80c4f81 100644 --- a/skills/slack/SKILL.md +++ b/skills/slack/SKILL.md @@ -1,14 +1,14 @@ --- name: slack -description: Use when you need to control Slack from Clawdbot via the slack tool, including reacting to messages or pinning/unpinning items in Slack channels or DMs. -metadata: {"clawdbot":{"emoji":"💬","requires":{"config":["channels.slack"]}}} +description: Use when you need to control Slack from Moltbot via the slack tool, including reacting to messages or pinning/unpinning items in Slack channels or DMs. +metadata: {"moltbot":{"emoji":"💬","requires":{"config":["channels.slack"]}}} --- # Slack Actions ## Overview -Use `slack` to react, manage pins, send/edit/delete messages, and fetch member info. The tool uses the bot token configured for Clawdbot. +Use `slack` to react, manage pins, send/edit/delete messages, and fetch member info. The tool uses the bot token configured for Moltbot. ## Inputs to collect @@ -57,7 +57,7 @@ Message context lines include `slack message id` and `channel` fields you can re { "action": "sendMessage", "to": "channel:C123", - "content": "Hello from Clawdbot" + "content": "Hello from Moltbot" } ``` diff --git a/skills/songsee/SKILL.md b/skills/songsee/SKILL.md index a45d2cc23..e381fca4b 100644 --- a/skills/songsee/SKILL.md +++ b/skills/songsee/SKILL.md @@ -2,7 +2,7 @@ name: songsee description: Generate spectrograms and feature-panel visualizations from audio with the songsee CLI. homepage: https://github.com/steipete/songsee -metadata: {"clawdbot":{"emoji":"🌊","requires":{"bins":["songsee"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/songsee","bins":["songsee"],"label":"Install songsee (brew)"}]}} +metadata: {"moltbot":{"emoji":"🌊","requires":{"bins":["songsee"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/songsee","bins":["songsee"],"label":"Install songsee (brew)"}]}} --- # songsee diff --git a/skills/sonoscli/SKILL.md b/skills/sonoscli/SKILL.md index 3108cb614..f1d82e8f2 100644 --- a/skills/sonoscli/SKILL.md +++ b/skills/sonoscli/SKILL.md @@ -2,7 +2,7 @@ name: sonoscli description: Control Sonos speakers (discover/status/play/volume/group). homepage: https://sonoscli.sh -metadata: {"clawdbot":{"emoji":"🔊","requires":{"bins":["sonos"]},"install":[{"id":"go","kind":"go","module":"github.com/steipete/sonoscli/cmd/sonos@latest","bins":["sonos"],"label":"Install sonoscli (go)"}]}} +metadata: {"moltbot":{"emoji":"🔊","requires":{"bins":["sonos"]},"install":[{"id":"go","kind":"go","module":"github.com/steipete/sonoscli/cmd/sonos@latest","bins":["sonos"],"label":"Install sonoscli (go)"}]}} --- # Sonos CLI diff --git a/skills/spotify-player/SKILL.md b/skills/spotify-player/SKILL.md index c8c171c9d..2807bdf07 100644 --- a/skills/spotify-player/SKILL.md +++ b/skills/spotify-player/SKILL.md @@ -2,7 +2,7 @@ name: spotify-player description: Terminal Spotify playback/search via spogo (preferred) or spotify_player. homepage: https://www.spotify.com -metadata: {"clawdbot":{"emoji":"🎵","requires":{"anyBins":["spogo","spotify_player"]},"install":[{"id":"brew","kind":"brew","formula":"spogo","tap":"steipete/tap","bins":["spogo"],"label":"Install spogo (brew)"},{"id":"brew","kind":"brew","formula":"spotify_player","bins":["spotify_player"],"label":"Install spotify_player (brew)"}]}} +metadata: {"moltbot":{"emoji":"🎵","requires":{"anyBins":["spogo","spotify_player"]},"install":[{"id":"brew","kind":"brew","formula":"spogo","tap":"steipete/tap","bins":["spogo"],"label":"Install spogo (brew)"},{"id":"brew","kind":"brew","formula":"spotify_player","bins":["spotify_player"],"label":"Install spotify_player (brew)"}]}} --- # spogo / spotify_player diff --git a/skills/summarize/SKILL.md b/skills/summarize/SKILL.md index 0ba28d878..8c44265bd 100644 --- a/skills/summarize/SKILL.md +++ b/skills/summarize/SKILL.md @@ -2,7 +2,7 @@ name: summarize description: Summarize or extract text/transcripts from URLs, podcasts, and local files (great fallback for “transcribe this YouTube/video”). homepage: https://summarize.sh -metadata: {"clawdbot":{"emoji":"🧾","requires":{"bins":["summarize"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/summarize","bins":["summarize"],"label":"Install summarize (brew)"}]}} +metadata: {"moltbot":{"emoji":"🧾","requires":{"bins":["summarize"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/summarize","bins":["summarize"],"label":"Install summarize (brew)"}]}} --- # Summarize diff --git a/skills/things-mac/SKILL.md b/skills/things-mac/SKILL.md index 8968608fe..0a572186e 100644 --- a/skills/things-mac/SKILL.md +++ b/skills/things-mac/SKILL.md @@ -1,8 +1,8 @@ --- name: things-mac -description: Manage Things 3 via the `things` CLI on macOS (add/update projects+todos via URL scheme; read/search/list from the local Things database). Use when a user asks Clawdbot to add a task to Things, list inbox/today/upcoming, search tasks, or inspect projects/areas/tags. +description: Manage Things 3 via the `things` CLI on macOS (add/update projects+todos via URL scheme; read/search/list from the local Things database). Use when a user asks Moltbot to add a task to Things, list inbox/today/upcoming, search tasks, or inspect projects/areas/tags. homepage: https://github.com/ossianhempel/things3-cli -metadata: {"clawdbot":{"emoji":"✅","os":["darwin"],"requires":{"bins":["things"]},"install":[{"id":"go","kind":"go","module":"github.com/ossianhempel/things3-cli/cmd/things@latest","bins":["things"],"label":"Install things3-cli (go)"}]}} +metadata: {"moltbot":{"emoji":"✅","os":["darwin"],"requires":{"bins":["things"]},"install":[{"id":"go","kind":"go","module":"github.com/ossianhempel/things3-cli/cmd/things@latest","bins":["things"],"label":"Install things3-cli (go)"}]}} --- # Things 3 CLI @@ -11,7 +11,7 @@ Use `things` to read your local Things database (inbox/today/search/projects/are Setup - Install (recommended, Apple Silicon): `GOBIN=/opt/homebrew/bin go install github.com/ossianhempel/things3-cli/cmd/things@latest` -- If DB reads fail: grant **Full Disk Access** to the calling app (Terminal for manual runs; `Clawdbot.app` for gateway runs). +- If DB reads fail: grant **Full Disk Access** to the calling app (Terminal for manual runs; `Moltbot.app` for gateway runs). - Optional: set `THINGSDB` (or pass `--db`) to point at your `ThingsData-*` folder. - Optional: set `THINGS_AUTH_TOKEN` to avoid passing `--auth-token` for update ops. diff --git a/skills/tmux/SKILL.md b/skills/tmux/SKILL.md index 42f5825cb..2f200994c 100644 --- a/skills/tmux/SKILL.md +++ b/skills/tmux/SKILL.md @@ -1,20 +1,20 @@ --- name: tmux description: Remote-control tmux sessions for interactive CLIs by sending keystrokes and scraping pane output. -metadata: {"clawdbot":{"emoji":"🧵","os":["darwin","linux"],"requires":{"bins":["tmux"]}}} +metadata: {"moltbot":{"emoji":"🧵","os":["darwin","linux"],"requires":{"bins":["tmux"]}}} --- -# tmux Skill (Clawdbot) +# tmux Skill (Moltbot) Use tmux only when you need an interactive TTY. Prefer exec background mode for long-running, non-interactive tasks. ## Quickstart (isolated socket, exec tool) ```bash -SOCKET_DIR="${CLAWDBOT_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/clawdbot-tmux-sockets}" +SOCKET_DIR="${CLAWDBOT_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/moltbot-tmux-sockets}" mkdir -p "$SOCKET_DIR" -SOCKET="$SOCKET_DIR/clawdbot.sock" -SESSION=clawdbot-python +SOCKET="$SOCKET_DIR/moltbot.sock" +SESSION=moltbot-python tmux -S "$SOCKET" new -d -s "$SESSION" -n shell tmux -S "$SOCKET" send-keys -t "$SESSION":0.0 -- 'PYTHON_BASIC_REPL=1 python3 -q' Enter @@ -31,8 +31,8 @@ To monitor: ## Socket convention -- Use `CLAWDBOT_TMUX_SOCKET_DIR` (default `${TMPDIR:-/tmp}/clawdbot-tmux-sockets`). -- Default socket path: `"$CLAWDBOT_TMUX_SOCKET_DIR/clawdbot.sock"`. +- Use `CLAWDBOT_TMUX_SOCKET_DIR` (default `${TMPDIR:-/tmp}/moltbot-tmux-sockets`). +- Default socket path: `"$CLAWDBOT_TMUX_SOCKET_DIR/moltbot.sock"`. ## Targeting panes and naming diff --git a/skills/tmux/scripts/find-sessions.sh b/skills/tmux/scripts/find-sessions.sh index 7fbba2adb..18076e901 100755 --- a/skills/tmux/scripts/find-sessions.sh +++ b/skills/tmux/scripts/find-sessions.sh @@ -20,7 +20,7 @@ socket_name="" socket_path="" query="" scan_all=false -socket_dir="${CLAWDBOT_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/clawdbot-tmux-sockets}" +socket_dir="${CLAWDBOT_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/moltbot-tmux-sockets}" while [[ $# -gt 0 ]]; do case "$1" in diff --git a/skills/trello/SKILL.md b/skills/trello/SKILL.md index 67c7ca5d8..cb3e0f4db 100644 --- a/skills/trello/SKILL.md +++ b/skills/trello/SKILL.md @@ -2,12 +2,12 @@ name: trello description: Manage Trello boards, lists, and cards via the Trello REST API. homepage: https://developer.atlassian.com/cloud/trello/rest/ -metadata: {"clawdbot":{"emoji":"📋","requires":{"bins":["jq"],"env":["TRELLO_API_KEY","TRELLO_TOKEN"]}}} +metadata: {"moltbot":{"emoji":"📋","requires":{"bins":["jq"],"env":["TRELLO_API_KEY","TRELLO_TOKEN"]}}} --- # Trello Skill -Manage Trello boards, lists, and cards directly from Clawdbot. +Manage Trello boards, lists, and cards directly from Moltbot. ## Setup diff --git a/skills/video-frames/SKILL.md b/skills/video-frames/SKILL.md index edc157db4..8d3c66d8f 100644 --- a/skills/video-frames/SKILL.md +++ b/skills/video-frames/SKILL.md @@ -2,7 +2,7 @@ name: video-frames description: Extract frames or short clips from videos using ffmpeg. homepage: https://ffmpeg.org -metadata: {"clawdbot":{"emoji":"🎞️","requires":{"bins":["ffmpeg"]},"install":[{"id":"brew","kind":"brew","formula":"ffmpeg","bins":["ffmpeg"],"label":"Install ffmpeg (brew)"}]}} +metadata: {"moltbot":{"emoji":"🎞️","requires":{"bins":["ffmpeg"]},"install":[{"id":"brew","kind":"brew","formula":"ffmpeg","bins":["ffmpeg"],"label":"Install ffmpeg (brew)"}]}} --- # Video Frames (ffmpeg) diff --git a/skills/voice-call/SKILL.md b/skills/voice-call/SKILL.md index 6f24f50a8..e703b6cc5 100644 --- a/skills/voice-call/SKILL.md +++ b/skills/voice-call/SKILL.md @@ -1,7 +1,7 @@ --- name: voice-call -description: Start voice calls via the Clawdbot voice-call plugin. -metadata: {"clawdbot":{"emoji":"📞","skillKey":"voice-call","requires":{"config":["plugins.entries.voice-call.enabled"]}}} +description: Start voice calls via the Moltbot voice-call plugin. +metadata: {"moltbot":{"emoji":"📞","skillKey":"voice-call","requires":{"config":["plugins.entries.voice-call.enabled"]}}} --- # Voice Call @@ -11,8 +11,8 @@ Use the voice-call plugin to start or inspect calls (Twilio, Telnyx, Plivo, or m ## CLI ```bash -clawdbot voicecall call --to "+15555550123" --message "Hello from Clawdbot" -clawdbot voicecall status --call-id +moltbot voicecall call --to "+15555550123" --message "Hello from Moltbot" +moltbot voicecall status --call-id ``` ## Tool diff --git a/skills/wacli/SKILL.md b/skills/wacli/SKILL.md index b34ca03b8..2b92561c8 100644 --- a/skills/wacli/SKILL.md +++ b/skills/wacli/SKILL.md @@ -2,13 +2,13 @@ name: wacli description: Send WhatsApp messages to other people or search/sync WhatsApp history via the wacli CLI (not for normal user chats). homepage: https://wacli.sh -metadata: {"clawdbot":{"emoji":"📱","requires":{"bins":["wacli"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/wacli","bins":["wacli"],"label":"Install wacli (brew)"},{"id":"go","kind":"go","module":"github.com/steipete/wacli/cmd/wacli@latest","bins":["wacli"],"label":"Install wacli (go)"}]}} +metadata: {"moltbot":{"emoji":"📱","requires":{"bins":["wacli"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/wacli","bins":["wacli"],"label":"Install wacli (brew)"},{"id":"go","kind":"go","module":"github.com/steipete/wacli/cmd/wacli@latest","bins":["wacli"],"label":"Install wacli (go)"}]}} --- # wacli Use `wacli` only when the user explicitly asks you to message someone else on WhatsApp or when they ask to sync/search WhatsApp history. -Do NOT use `wacli` for normal user chats; Clawdbot routes WhatsApp conversations automatically. +Do NOT use `wacli` for normal user chats; Moltbot routes WhatsApp conversations automatically. If the user is chatting with you on WhatsApp, you should not reach for this tool unless they ask you to contact a third party. Safety diff --git a/skills/weather/SKILL.md b/skills/weather/SKILL.md index 2146580d7..0a139571c 100644 --- a/skills/weather/SKILL.md +++ b/skills/weather/SKILL.md @@ -2,7 +2,7 @@ name: weather description: Get current weather and forecasts (no API key required). homepage: https://wttr.in/:help -metadata: {"clawdbot":{"emoji":"🌤️","requires":{"bins":["curl"]}}} +metadata: {"moltbot":{"emoji":"🌤️","requires":{"bins":["curl"]}}} --- # Weather From 58640e9ecb3ebe11a94b76fb8db30852b459997d Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 12:49:07 +0000 Subject: [PATCH 017/101] fix: load config from moltbot and legacy dirs --- src/cli/daemon-cli/shared.ts | 2 + .../config.nix-integration-u3-u5-u9.test.ts | 76 ++++++++++++++----- src/config/io.compat.test.ts | 70 +++++++++++++++++ src/config/io.ts | 9 ++- src/config/paths.test.ts | 25 +++++- src/config/paths.ts | 56 +++++++++++--- 6 files changed, 209 insertions(+), 29 deletions(-) create mode 100644 src/config/io.compat.test.ts diff --git a/src/cli/daemon-cli/shared.ts b/src/cli/daemon-cli/shared.ts index 4ef4f820f..af4e0ff41 100644 --- a/src/cli/daemon-cli/shared.ts +++ b/src/cli/daemon-cli/shared.ts @@ -51,6 +51,8 @@ export function pickProbeHostForBind( } const SAFE_DAEMON_ENV_KEYS = [ + "MOLTBOT_STATE_DIR", + "MOLTBOT_CONFIG_PATH", "CLAWDBOT_PROFILE", "CLAWDBOT_STATE_DIR", "CLAWDBOT_CONFIG_PATH", diff --git a/src/config/config.nix-integration-u3-u5-u9.test.ts b/src/config/config.nix-integration-u3-u5-u9.test.ts index b61de1046..9310416d4 100644 --- a/src/config/config.nix-integration-u3-u5-u9.test.ts +++ b/src/config/config.nix-integration-u3-u5-u9.test.ts @@ -36,22 +36,43 @@ describe("Nix integration (U3, U5, U9)", () => { describe("U5: CONFIG_PATH and STATE_DIR env var overrides", () => { it("STATE_DIR defaults to ~/.clawdbot when env not set", async () => { - await withEnvOverride({ CLAWDBOT_STATE_DIR: undefined }, async () => { - const { STATE_DIR } = await import("./config.js"); - expect(STATE_DIR).toMatch(/\.clawdbot$/); - }); + await withEnvOverride( + { MOLTBOT_STATE_DIR: undefined, CLAWDBOT_STATE_DIR: undefined }, + async () => { + const { STATE_DIR } = await import("./config.js"); + expect(STATE_DIR).toMatch(/\.clawdbot$/); + }, + ); }); it("STATE_DIR respects CLAWDBOT_STATE_DIR override", async () => { - await withEnvOverride({ CLAWDBOT_STATE_DIR: "/custom/state/dir" }, async () => { - const { STATE_DIR } = await import("./config.js"); - expect(STATE_DIR).toBe(path.resolve("/custom/state/dir")); - }); + await withEnvOverride( + { MOLTBOT_STATE_DIR: undefined, CLAWDBOT_STATE_DIR: "/custom/state/dir" }, + async () => { + const { STATE_DIR } = await import("./config.js"); + expect(STATE_DIR).toBe(path.resolve("/custom/state/dir")); + }, + ); + }); + + it("STATE_DIR prefers MOLTBOT_STATE_DIR over legacy override", async () => { + await withEnvOverride( + { MOLTBOT_STATE_DIR: "/custom/new", CLAWDBOT_STATE_DIR: "/custom/legacy" }, + async () => { + const { STATE_DIR } = await import("./config.js"); + expect(STATE_DIR).toBe(path.resolve("/custom/new")); + }, + ); }); it("CONFIG_PATH defaults to ~/.clawdbot/moltbot.json when env not set", async () => { await withEnvOverride( - { CLAWDBOT_CONFIG_PATH: undefined, CLAWDBOT_STATE_DIR: undefined }, + { + MOLTBOT_CONFIG_PATH: undefined, + MOLTBOT_STATE_DIR: undefined, + CLAWDBOT_CONFIG_PATH: undefined, + CLAWDBOT_STATE_DIR: undefined, + }, async () => { const { CONFIG_PATH } = await import("./config.js"); expect(CONFIG_PATH).toMatch(/\.clawdbot[\\/]moltbot\.json$/); @@ -60,24 +81,45 @@ describe("Nix integration (U3, U5, U9)", () => { }); it("CONFIG_PATH respects CLAWDBOT_CONFIG_PATH override", async () => { - await withEnvOverride({ CLAWDBOT_CONFIG_PATH: "/nix/store/abc/moltbot.json" }, async () => { - const { CONFIG_PATH } = await import("./config.js"); - expect(CONFIG_PATH).toBe(path.resolve("/nix/store/abc/moltbot.json")); - }); + await withEnvOverride( + { MOLTBOT_CONFIG_PATH: undefined, CLAWDBOT_CONFIG_PATH: "/nix/store/abc/moltbot.json" }, + async () => { + const { CONFIG_PATH } = await import("./config.js"); + expect(CONFIG_PATH).toBe(path.resolve("/nix/store/abc/moltbot.json")); + }, + ); + }); + + it("CONFIG_PATH prefers MOLTBOT_CONFIG_PATH over legacy override", async () => { + await withEnvOverride( + { + MOLTBOT_CONFIG_PATH: "/nix/store/new/moltbot.json", + CLAWDBOT_CONFIG_PATH: "/nix/store/legacy/moltbot.json", + }, + async () => { + const { CONFIG_PATH } = await import("./config.js"); + expect(CONFIG_PATH).toBe(path.resolve("/nix/store/new/moltbot.json")); + }, + ); }); it("CONFIG_PATH expands ~ in CLAWDBOT_CONFIG_PATH override", async () => { await withTempHome(async (home) => { - await withEnvOverride({ CLAWDBOT_CONFIG_PATH: "~/.clawdbot/custom.json" }, async () => { - const { CONFIG_PATH } = await import("./config.js"); - expect(CONFIG_PATH).toBe(path.join(home, ".clawdbot", "custom.json")); - }); + await withEnvOverride( + { MOLTBOT_CONFIG_PATH: undefined, CLAWDBOT_CONFIG_PATH: "~/.clawdbot/custom.json" }, + async () => { + const { CONFIG_PATH } = await import("./config.js"); + expect(CONFIG_PATH).toBe(path.join(home, ".clawdbot", "custom.json")); + }, + ); }); }); it("CONFIG_PATH uses STATE_DIR when only state dir is overridden", async () => { await withEnvOverride( { + MOLTBOT_CONFIG_PATH: undefined, + MOLTBOT_STATE_DIR: undefined, CLAWDBOT_CONFIG_PATH: undefined, CLAWDBOT_STATE_DIR: "/custom/state", }, diff --git a/src/config/io.compat.test.ts b/src/config/io.compat.test.ts new file mode 100644 index 000000000..59c942503 --- /dev/null +++ b/src/config/io.compat.test.ts @@ -0,0 +1,70 @@ +import fs from "node:fs/promises"; +import os from "node:os"; +import path from "node:path"; +import { describe, expect, it } from "vitest"; + +import { createConfigIO } from "./io.js"; + +async function withTempHome(run: (home: string) => Promise): Promise { + const home = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-config-")); + try { + await run(home); + } finally { + await fs.rm(home, { recursive: true, force: true }); + } +} + +async function writeConfig(home: string, dirname: ".moltbot" | ".clawdbot", port: number) { + const dir = path.join(home, dirname); + await fs.mkdir(dir, { recursive: true }); + const configPath = path.join(dir, "moltbot.json"); + await fs.writeFile(configPath, JSON.stringify({ gateway: { port } }, null, 2)); + return configPath; +} + +describe("config io compat (new + legacy folders)", () => { + it("prefers ~/.moltbot/moltbot.json when both configs exist", async () => { + await withTempHome(async (home) => { + const newConfigPath = await writeConfig(home, ".moltbot", 19001); + await writeConfig(home, ".clawdbot", 18789); + + const io = createConfigIO({ + env: {} as NodeJS.ProcessEnv, + homedir: () => home, + }); + + expect(io.configPath).toBe(newConfigPath); + expect(io.loadConfig().gateway?.port).toBe(19001); + }); + }); + + it("falls back to ~/.clawdbot/moltbot.json when only legacy exists", async () => { + await withTempHome(async (home) => { + const legacyConfigPath = await writeConfig(home, ".clawdbot", 20001); + + const io = createConfigIO({ + env: {} as NodeJS.ProcessEnv, + homedir: () => home, + }); + + expect(io.configPath).toBe(legacyConfigPath); + expect(io.loadConfig().gateway?.port).toBe(20001); + }); + }); + + it("honors explicit legacy config path env override", async () => { + await withTempHome(async (home) => { + const newConfigPath = await writeConfig(home, ".moltbot", 19002); + const legacyConfigPath = await writeConfig(home, ".clawdbot", 20002); + + const io = createConfigIO({ + env: { CLAWDBOT_CONFIG_PATH: legacyConfigPath } as NodeJS.ProcessEnv, + homedir: () => home, + }); + + expect(io.configPath).not.toBe(newConfigPath); + expect(io.configPath).toBe(legacyConfigPath); + expect(io.loadConfig().gateway?.port).toBe(20002); + }); + }); +}); diff --git a/src/config/io.ts b/src/config/io.ts index 67b2657bf..ef8ffba86 100644 --- a/src/config/io.ts +++ b/src/config/io.ts @@ -28,7 +28,7 @@ import { collectConfigEnvVars } from "./env-vars.js"; import { ConfigIncludeError, resolveConfigIncludes } from "./includes.js"; import { findLegacyConfigIssues } from "./legacy.js"; import { normalizeConfigPaths } from "./normalize-paths.js"; -import { resolveConfigPath, resolveStateDir } from "./paths.js"; +import { resolveConfigPath, resolveDefaultConfigCandidates, resolveStateDir } from "./paths.js"; import { applyConfigOverrides } from "./runtime-overrides.js"; import type { MoltbotConfig, ConfigFileSnapshot, LegacyConfigIssue } from "./types.js"; import { validateConfigObjectWithPlugins } from "./validation.js"; @@ -186,7 +186,12 @@ export function parseConfigJson5( export function createConfigIO(overrides: ConfigIoDeps = {}) { const deps = normalizeDeps(overrides); - const configPath = resolveConfigPathForDeps(deps); + const requestedConfigPath = resolveConfigPathForDeps(deps); + const candidatePaths = deps.configPath + ? [requestedConfigPath] + : resolveDefaultConfigCandidates(deps.env, deps.homedir); + const configPath = + candidatePaths.find((candidate) => deps.fs.existsSync(candidate)) ?? requestedConfigPath; function loadConfig(): MoltbotConfig { try { diff --git a/src/config/paths.test.ts b/src/config/paths.test.ts index a61577a87..f99e88513 100644 --- a/src/config/paths.test.ts +++ b/src/config/paths.test.ts @@ -1,7 +1,12 @@ import path from "node:path"; import { describe, expect, it } from "vitest"; -import { resolveOAuthDir, resolveOAuthPath } from "./paths.js"; +import { + resolveDefaultConfigCandidates, + resolveOAuthDir, + resolveOAuthPath, + resolveStateDir, +} from "./paths.js"; describe("oauth paths", () => { it("prefers CLAWDBOT_OAUTH_DIR over CLAWDBOT_STATE_DIR", () => { @@ -27,3 +32,21 @@ describe("oauth paths", () => { ); }); }); + +describe("state + config path candidates", () => { + it("prefers MOLTBOT_STATE_DIR over legacy state dir env", () => { + const env = { + MOLTBOT_STATE_DIR: "/new/state", + CLAWDBOT_STATE_DIR: "/legacy/state", + } as NodeJS.ProcessEnv; + + expect(resolveStateDir(env, () => "/home/test")).toBe(path.resolve("/new/state")); + }); + + it("orders default config candidates as new then legacy", () => { + const home = "/home/test"; + const candidates = resolveDefaultConfigCandidates({} as NodeJS.ProcessEnv, () => home); + expect(candidates[0]).toBe(path.join(home, ".moltbot", "moltbot.json")); + expect(candidates[1]).toBe(path.join(home, ".clawdbot", "moltbot.json")); + }); +}); diff --git a/src/config/paths.ts b/src/config/paths.ts index 817c2fe57..2fc3937c4 100644 --- a/src/config/paths.ts +++ b/src/config/paths.ts @@ -15,18 +15,30 @@ export function resolveIsNixMode(env: NodeJS.ProcessEnv = process.env): boolean export const isNixMode = resolveIsNixMode(); +const LEGACY_STATE_DIRNAME = ".clawdbot"; +const NEW_STATE_DIRNAME = ".moltbot"; +const CONFIG_FILENAME = "moltbot.json"; + +function legacyStateDir(homedir: () => string = os.homedir): string { + return path.join(homedir(), LEGACY_STATE_DIRNAME); +} + +function newStateDir(homedir: () => string = os.homedir): string { + return path.join(homedir(), NEW_STATE_DIRNAME); +} + /** * State directory for mutable data (sessions, logs, caches). - * Can be overridden via CLAWDBOT_STATE_DIR environment variable. - * Default: ~/.clawdbot + * Can be overridden via MOLTBOT_STATE_DIR (preferred) or CLAWDBOT_STATE_DIR (legacy). + * Default: ~/.clawdbot (legacy default for compatibility) */ export function resolveStateDir( env: NodeJS.ProcessEnv = process.env, homedir: () => string = os.homedir, ): string { - const override = env.CLAWDBOT_STATE_DIR?.trim(); + const override = env.MOLTBOT_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim(); if (override) return resolveUserPath(override); - return path.join(homedir(), ".clawdbot"); + return legacyStateDir(homedir); } function resolveUserPath(input: string): string { @@ -43,20 +55,46 @@ export const STATE_DIR = resolveStateDir(); /** * Config file path (JSON5). - * Can be overridden via CLAWDBOT_CONFIG_PATH environment variable. - * Default: ~/.clawdbot/moltbot.json (or $CLAWDBOT_STATE_DIR/moltbot.json) + * Can be overridden via MOLTBOT_CONFIG_PATH (preferred) or CLAWDBOT_CONFIG_PATH (legacy). + * Default: ~/.clawdbot/moltbot.json (or $*_STATE_DIR/moltbot.json) */ export function resolveConfigPath( env: NodeJS.ProcessEnv = process.env, stateDir: string = resolveStateDir(env, os.homedir), ): string { - const override = env.CLAWDBOT_CONFIG_PATH?.trim(); + const override = env.MOLTBOT_CONFIG_PATH?.trim() || env.CLAWDBOT_CONFIG_PATH?.trim(); if (override) return resolveUserPath(override); - return path.join(stateDir, "moltbot.json"); + return path.join(stateDir, CONFIG_FILENAME); } export const CONFIG_PATH = resolveConfigPath(); +/** + * Resolve default config path candidates across new + legacy locations. + * Order: explicit config path → state-dir-derived paths → new default → legacy default. + */ +export function resolveDefaultConfigCandidates( + env: NodeJS.ProcessEnv = process.env, + homedir: () => string = os.homedir, +): string[] { + const explicit = env.MOLTBOT_CONFIG_PATH?.trim() || env.CLAWDBOT_CONFIG_PATH?.trim(); + if (explicit) return [resolveUserPath(explicit)]; + + const candidates: string[] = []; + const moltbotStateDir = env.MOLTBOT_STATE_DIR?.trim(); + if (moltbotStateDir) { + candidates.push(path.join(resolveUserPath(moltbotStateDir), CONFIG_FILENAME)); + } + const legacyStateDirOverride = env.CLAWDBOT_STATE_DIR?.trim(); + if (legacyStateDirOverride) { + candidates.push(path.join(resolveUserPath(legacyStateDirOverride), CONFIG_FILENAME)); + } + + candidates.push(path.join(newStateDir(homedir), CONFIG_FILENAME)); + candidates.push(path.join(legacyStateDir(homedir), CONFIG_FILENAME)); + return candidates; +} + export const DEFAULT_GATEWAY_PORT = 18789; /** @@ -77,7 +115,7 @@ const OAUTH_FILENAME = "oauth.json"; * * Precedence: * - `CLAWDBOT_OAUTH_DIR` (explicit override) - * - `CLAWDBOT_STATE_DIR/credentials` (canonical server/default) + * - `$*_STATE_DIR/credentials` (canonical server/default) * - `~/.clawdbot/credentials` (legacy default) */ export function resolveOAuthDir( From 7e99311e1d439d3cd2fc874e03a43c1363bb86a4 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 12:49:23 +0000 Subject: [PATCH 018/101] chore: normalize io compat test newline --- src/config/io.compat.test.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/config/io.compat.test.ts b/src/config/io.compat.test.ts index 59c942503..4a32658ae 100644 --- a/src/config/io.compat.test.ts +++ b/src/config/io.compat.test.ts @@ -32,7 +32,6 @@ describe("config io compat (new + legacy folders)", () => { env: {} as NodeJS.ProcessEnv, homedir: () => home, }); - expect(io.configPath).toBe(newConfigPath); expect(io.loadConfig().gateway?.port).toBe(19001); }); From 44f90173556d32d5c5c783f422f2f7a84ea13eaf Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 12:59:59 +0000 Subject: [PATCH 019/101] fix: include compat dist in npm package --- package.json | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/package.json b/package.json index d9c25c8b0..f91af8199 100644 --- a/package.json +++ b/package.json @@ -11,7 +11,8 @@ "./cli-entry": "./dist/entry.js" }, "bin": { - "moltbot": "dist/entry.js" + "moltbot": "dist/entry.js", + "clawdbot": "dist/entry.js" }, "files": [ "dist/acp/**", @@ -22,6 +23,7 @@ "dist/cli/**", "dist/commands/**", "dist/config/**", + "dist/compat/**", "dist/control-ui/**", "dist/cron/**", "dist/channels/**", From 3f83afe4a6f29f2702ecc2bea8492f550eb149e4 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 13:00:02 +0000 Subject: [PATCH 020/101] chore: update a2ui bundle hash --- src/canvas-host/a2ui/.bundle.hash | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/canvas-host/a2ui/.bundle.hash b/src/canvas-host/a2ui/.bundle.hash index 6ca31cbe4..6c9cb0299 100644 --- a/src/canvas-host/a2ui/.bundle.hash +++ b/src/canvas-host/a2ui/.bundle.hash @@ -1 +1 @@ -1376c2e99ad07193d9ab1719200675d84ffb40db417d05128cf07c3b8283581e +b6d3dea7c656c8a480059c32e954c4d39053ff79c4e9c69b38f4c04e3f0280d4 From 5eff33abe68f91151c704dc16f6e4995379508bc Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 14:37:10 +0000 Subject: [PATCH 021/101] fix: sync pnpm lockfile for moltbot rename --- pnpm-lock.yaml | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 82f0a96e2..4f35c2612 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -314,17 +314,17 @@ importers: specifier: ^10.5.0 version: 10.5.0 devDependencies: - clawdbot: + moltbot: specifier: workspace:* - version: link:../../packages/clawdbot + version: link:../.. extensions/imessage: {} extensions/line: devDependencies: - clawdbot: + moltbot: specifier: workspace:* - version: link:../../packages/clawdbot + version: link:../.. extensions/llm-task: {} @@ -348,17 +348,17 @@ importers: specifier: ^4.3.6 version: 4.3.6 devDependencies: - clawdbot: + moltbot: specifier: workspace:* - version: link:../../packages/clawdbot + version: link:../.. extensions/mattermost: {} extensions/memory-core: dependencies: - clawdbot: - specifier: '>=2026.1.24-3' - version: 2026.1.24-3(@types/express@5.0.6)(audio-decode@2.2.3)(devtools-protocol@0.0.1561482)(typescript@5.9.3) + moltbot: + specifier: '>=2026.1.26' + version: link:../.. extensions/memory-lancedb: dependencies: @@ -383,9 +383,9 @@ importers: '@microsoft/agents-hosting-extensions-teams': specifier: ^1.2.2 version: 1.2.2 - clawdbot: + moltbot: specifier: workspace:* - version: link:../../packages/clawdbot + version: link:../.. express: specifier: ^5.2.1 version: 5.2.1 @@ -397,9 +397,9 @@ importers: extensions/nostr: dependencies: - clawdbot: + moltbot: specifier: workspace:* - version: link:../../packages/clawdbot + version: link:../.. nostr-tools: specifier: ^2.20.0 version: 2.20.0(typescript@5.9.3) @@ -439,9 +439,9 @@ importers: specifier: ^4.3.5 version: 4.3.6 devDependencies: - clawdbot: + moltbot: specifier: workspace:* - version: link:../../packages/clawdbot + version: link:../.. extensions/voice-call: dependencies: @@ -459,9 +459,9 @@ importers: extensions/zalo: dependencies: - clawdbot: + moltbot: specifier: workspace:* - version: link:../../packages/clawdbot + version: link:../.. undici: specifier: 7.19.0 version: 7.19.0 @@ -471,9 +471,9 @@ importers: '@sinclair/typebox': specifier: 0.34.47 version: 0.34.47 - clawdbot: + moltbot: specifier: workspace:* - version: link:../../packages/clawdbot + version: link:../.. packages/clawdbot: dependencies: From 3015e11fd7c144339791ff4fc8f56bb053ffe1f6 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 14:58:01 +0000 Subject: [PATCH 022/101] fix: stabilize install smoke against clawdbot installer --- .github/workflows/install-smoke.yml | 2 +- scripts/docker/install-sh-nonroot/run.sh | 39 ++++++++++++---- scripts/docker/install-sh-smoke/run.sh | 58 ++++++++++++++++-------- 3 files changed, 72 insertions(+), 27 deletions(-) diff --git a/.github/workflows/install-smoke.yml b/.github/workflows/install-smoke.yml index 16eba4eed..0347c7810 100644 --- a/.github/workflows/install-smoke.yml +++ b/.github/workflows/install-smoke.yml @@ -37,5 +37,5 @@ jobs: CLAWDBOT_NO_ONBOARD: "1" CLAWDBOT_INSTALL_SMOKE_SKIP_CLI: "1" CLAWDBOT_INSTALL_SMOKE_SKIP_NONROOT: ${{ github.event_name == 'pull_request' && '1' || '0' }} - CLAWDBOT_INSTALL_SMOKE_PREVIOUS: "2026.1.11-4" + CLAWDBOT_INSTALL_SMOKE_SKIP_PREVIOUS: "1" run: pnpm test:install:smoke diff --git a/scripts/docker/install-sh-nonroot/run.sh b/scripts/docker/install-sh-nonroot/run.sh index a689498e0..58a8fc3e7 100644 --- a/scripts/docker/install-sh-nonroot/run.sh +++ b/scripts/docker/install-sh-nonroot/run.sh @@ -2,6 +2,16 @@ set -euo pipefail INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://molt.bot/install.sh}" +DEFAULT_PACKAGE="moltbot" +if [[ -z "${CLAWDBOT_INSTALL_PACKAGE:-}" && "$INSTALL_URL" == *"clawd.bot"* ]]; then + DEFAULT_PACKAGE="clawdbot" +fi +PACKAGE_NAME="${CLAWDBOT_INSTALL_PACKAGE:-$DEFAULT_PACKAGE}" +if [[ "$PACKAGE_NAME" == "moltbot" ]]; then + ALT_PACKAGE_NAME="clawdbot" +else + ALT_PACKAGE_NAME="moltbot" +fi echo "==> Pre-flight: ensure git absent" if command -v git >/dev/null; then @@ -18,26 +28,39 @@ export PATH="$HOME/.npm-global/bin:$PATH" echo "==> Verify git installed" command -v git >/dev/null -echo "==> Verify moltbot installed" EXPECTED_VERSION="${CLAWDBOT_INSTALL_EXPECT_VERSION:-}" if [[ -n "$EXPECTED_VERSION" ]]; then LATEST_VERSION="$EXPECTED_VERSION" else - LATEST_VERSION="$(npm view moltbot version)" + LATEST_VERSION="$(npm view "$PACKAGE_NAME" version)" fi -CMD_PATH="$(command -v moltbot || true)" -if [[ -z "$CMD_PATH" && -x "$HOME/.npm-global/bin/moltbot" ]]; then - CMD_PATH="$HOME/.npm-global/bin/moltbot" +CLI_NAME="$PACKAGE_NAME" +CMD_PATH="$(command -v "$CLI_NAME" || true)" +if [[ -z "$CMD_PATH" ]]; then + CLI_NAME="$ALT_PACKAGE_NAME" + CMD_PATH="$(command -v "$CLI_NAME" || true)" +fi +if [[ -z "$CMD_PATH" && -x "$HOME/.npm-global/bin/$PACKAGE_NAME" ]]; then + CLI_NAME="$PACKAGE_NAME" + CMD_PATH="$HOME/.npm-global/bin/$PACKAGE_NAME" +fi +if [[ -z "$CMD_PATH" && -x "$HOME/.npm-global/bin/$ALT_PACKAGE_NAME" ]]; then + CLI_NAME="$ALT_PACKAGE_NAME" + CMD_PATH="$HOME/.npm-global/bin/$ALT_PACKAGE_NAME" fi if [[ -z "$CMD_PATH" ]]; then - echo "moltbot not on PATH" >&2 + echo "Neither $PACKAGE_NAME nor $ALT_PACKAGE_NAME is on PATH" >&2 exit 1 fi +if [[ -z "$EXPECTED_VERSION" && "$CLI_NAME" != "$PACKAGE_NAME" ]]; then + LATEST_VERSION="$(npm view "$CLI_NAME" version)" +fi +echo "==> Verify CLI installed: $CLI_NAME" INSTALLED_VERSION="$("$CMD_PATH" --version 2>/dev/null | head -n 1 | tr -d '\r')" -echo "installed=$INSTALLED_VERSION expected=$LATEST_VERSION" +echo "cli=$CLI_NAME installed=$INSTALLED_VERSION expected=$LATEST_VERSION" if [[ "$INSTALLED_VERSION" != "$LATEST_VERSION" ]]; then - echo "ERROR: expected moltbot@$LATEST_VERSION, got @$INSTALLED_VERSION" >&2 + echo "ERROR: expected ${CLI_NAME}@${LATEST_VERSION}, got ${CLI_NAME}@${INSTALLED_VERSION}" >&2 exit 1 fi diff --git a/scripts/docker/install-sh-smoke/run.sh b/scripts/docker/install-sh-smoke/run.sh index 9c8870b2b..09a597de8 100755 --- a/scripts/docker/install-sh-smoke/run.sh +++ b/scripts/docker/install-sh-smoke/run.sh @@ -4,15 +4,26 @@ set -euo pipefail INSTALL_URL="${CLAWDBOT_INSTALL_URL:-https://molt.bot/install.sh}" SMOKE_PREVIOUS_VERSION="${CLAWDBOT_INSTALL_SMOKE_PREVIOUS:-}" SKIP_PREVIOUS="${CLAWDBOT_INSTALL_SMOKE_SKIP_PREVIOUS:-0}" +DEFAULT_PACKAGE="moltbot" +if [[ -z "${CLAWDBOT_INSTALL_PACKAGE:-}" && "$INSTALL_URL" == *"clawd.bot"* ]]; then + DEFAULT_PACKAGE="clawdbot" +fi +PACKAGE_NAME="${CLAWDBOT_INSTALL_PACKAGE:-$DEFAULT_PACKAGE}" +if [[ "$PACKAGE_NAME" == "moltbot" ]]; then + ALT_PACKAGE_NAME="clawdbot" +else + ALT_PACKAGE_NAME="moltbot" +fi echo "==> Resolve npm versions" +LATEST_VERSION="$(npm view "$PACKAGE_NAME" version)" if [[ -n "$SMOKE_PREVIOUS_VERSION" ]]; then - LATEST_VERSION="$(npm view moltbot version)" PREVIOUS_VERSION="$SMOKE_PREVIOUS_VERSION" else - VERSIONS_JSON="$(npm view moltbot versions --json)" - versions_line="$(node - <<'NODE' + VERSIONS_JSON="$(npm view "$PACKAGE_NAME" versions --json)" + PREVIOUS_VERSION="$(VERSIONS_JSON="$VERSIONS_JSON" LATEST_VERSION="$LATEST_VERSION" node - <<'NODE' const raw = process.env.VERSIONS_JSON || "[]"; +const latest = process.env.LATEST_VERSION || ""; let versions; try { versions = JSON.parse(raw); @@ -25,41 +36,52 @@ if (!Array.isArray(versions)) { if (versions.length === 0) { process.exit(1); } -const latest = versions[versions.length - 1]; -const previous = versions.length >= 2 ? versions[versions.length - 2] : latest; -process.stdout.write(`${latest} ${previous}`); +const latestIndex = latest ? versions.lastIndexOf(latest) : -1; +if (latestIndex > 0) { + process.stdout.write(String(versions[latestIndex - 1])); + process.exit(0); +} +process.stdout.write(String(latest || versions[versions.length - 1])); NODE )" - LATEST_VERSION="${versions_line%% *}" - PREVIOUS_VERSION="${versions_line#* }" fi -if [[ -n "${CLAWDBOT_INSTALL_LATEST_OUT:-}" ]]; then - printf "%s" "$LATEST_VERSION" > "$CLAWDBOT_INSTALL_LATEST_OUT" -fi - -echo "latest=$LATEST_VERSION previous=$PREVIOUS_VERSION" +echo "package=$PACKAGE_NAME latest=$LATEST_VERSION previous=$PREVIOUS_VERSION" if [[ "$SKIP_PREVIOUS" == "1" ]]; then echo "==> Skip preinstall previous (CLAWDBOT_INSTALL_SMOKE_SKIP_PREVIOUS=1)" else echo "==> Preinstall previous (forces installer upgrade path)" - npm install -g "moltbot@${PREVIOUS_VERSION}" + npm install -g "${PACKAGE_NAME}@${PREVIOUS_VERSION}" fi echo "==> Run official installer one-liner" curl -fsSL "$INSTALL_URL" | bash echo "==> Verify installed version" -INSTALLED_VERSION="$(moltbot --version 2>/dev/null | head -n 1 | tr -d '\r')" -echo "installed=$INSTALLED_VERSION expected=$LATEST_VERSION" +CLI_NAME="$PACKAGE_NAME" +if ! command -v "$CLI_NAME" >/dev/null 2>&1; then + if command -v "$ALT_PACKAGE_NAME" >/dev/null 2>&1; then + CLI_NAME="$ALT_PACKAGE_NAME" + LATEST_VERSION="$(npm view "$CLI_NAME" version)" + echo "==> Detected alternate CLI: $CLI_NAME" + else + echo "ERROR: neither $PACKAGE_NAME nor $ALT_PACKAGE_NAME is on PATH" >&2 + exit 1 + fi +fi +if [[ -n "${CLAWDBOT_INSTALL_LATEST_OUT:-}" ]]; then + printf "%s" "$LATEST_VERSION" > "$CLAWDBOT_INSTALL_LATEST_OUT" +fi +INSTALLED_VERSION="$("$CLI_NAME" --version 2>/dev/null | head -n 1 | tr -d '\r')" +echo "cli=$CLI_NAME installed=$INSTALLED_VERSION expected=$LATEST_VERSION" if [[ "$INSTALLED_VERSION" != "$LATEST_VERSION" ]]; then - echo "ERROR: expected moltbot@$LATEST_VERSION, got moltbot@$INSTALLED_VERSION" >&2 + echo "ERROR: expected ${CLI_NAME}@${LATEST_VERSION}, got ${CLI_NAME}@${INSTALLED_VERSION}" >&2 exit 1 fi echo "==> Sanity: CLI runs" -moltbot --help >/dev/null +"$CLI_NAME" --help >/dev/null echo "OK" From 0594ccf92afea316d8fe590ed5cf9ec580b25ba5 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 15:01:57 +0000 Subject: [PATCH 023/101] fix: skip a2ui bundling when sources are excluded --- scripts/bundle-a2ui.sh | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/scripts/bundle-a2ui.sh b/scripts/bundle-a2ui.sh index a1cf7ff2b..304002324 100755 --- a/scripts/bundle-a2ui.sh +++ b/scripts/bundle-a2ui.sh @@ -10,12 +10,21 @@ trap on_error ERR ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" HASH_FILE="$ROOT_DIR/src/canvas-host/a2ui/.bundle.hash" OUTPUT_FILE="$ROOT_DIR/src/canvas-host/a2ui/a2ui.bundle.js" +A2UI_RENDERER_DIR="$ROOT_DIR/vendor/a2ui/renderers/lit" +A2UI_APP_DIR="$ROOT_DIR/apps/shared/ClawdbotKit/Tools/CanvasA2UI" + +# Docker builds exclude vendor/apps via .dockerignore. +# In that environment we must keep the prebuilt bundle. +if [[ ! -d "$A2UI_RENDERER_DIR" || ! -d "$A2UI_APP_DIR" ]]; then + echo "A2UI sources missing; keeping prebuilt bundle." + exit 0 +fi INPUT_PATHS=( "$ROOT_DIR/package.json" "$ROOT_DIR/pnpm-lock.yaml" - "$ROOT_DIR/vendor/a2ui/renderers/lit" - "$ROOT_DIR/apps/shared/ClawdbotKit/Tools/CanvasA2UI" + "$A2UI_RENDERER_DIR" + "$A2UI_APP_DIR" ) collect_files() { @@ -46,7 +55,7 @@ if [[ -f "$HASH_FILE" ]]; then fi fi -pnpm -s exec tsc -p vendor/a2ui/renderers/lit/tsconfig.json -rolldown -c apps/shared/ClawdbotKit/Tools/CanvasA2UI/rolldown.config.mjs +pnpm -s exec tsc -p "$A2UI_RENDERER_DIR/tsconfig.json" +rolldown -c "$A2UI_APP_DIR/rolldown.config.mjs" echo "$current_hash" > "$HASH_FILE" From e4518d227118e053baca48688ea2477565dfa246 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 15:16:20 +0000 Subject: [PATCH 024/101] fix: allow docker builds to skip missing a2ui assets --- Dockerfile | 2 +- scripts/canvas-a2ui-copy.ts | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/Dockerfile b/Dockerfile index 642cfd612..9c6aa7036 100644 --- a/Dockerfile +++ b/Dockerfile @@ -24,7 +24,7 @@ COPY scripts ./scripts RUN pnpm install --frozen-lockfile COPY . . -RUN pnpm build +RUN CLAWDBOT_A2UI_SKIP_MISSING=1 pnpm build # Force pnpm for UI build (Bun may fail on ARM/Synology architectures) ENV CLAWDBOT_PREFER_PNPM=1 RUN pnpm ui:install diff --git a/scripts/canvas-a2ui-copy.ts b/scripts/canvas-a2ui-copy.ts index b8a80675f..e95be5fdd 100644 --- a/scripts/canvas-a2ui-copy.ts +++ b/scripts/canvas-a2ui-copy.ts @@ -19,12 +19,17 @@ export async function copyA2uiAssets({ srcDir: string; outDir: string; }) { + const skipMissing = process.env.CLAWDBOT_A2UI_SKIP_MISSING === "1"; try { await fs.stat(path.join(srcDir, "index.html")); await fs.stat(path.join(srcDir, "a2ui.bundle.js")); } catch (err) { const message = 'Missing A2UI bundle assets. Run "pnpm canvas:a2ui:bundle" and retry.'; + if (skipMissing) { + console.warn(`${message} Skipping copy (CLAWDBOT_A2UI_SKIP_MISSING=1).`); + return; + } throw new Error(message, { cause: err }); } await fs.mkdir(path.dirname(outDir), { recursive: true }); From 3817e0ce2c04fa16187384038c668dfddc218704 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 15:38:31 +0000 Subject: [PATCH 025/101] fix: bundle a2ui before tests --- .github/workflows/ci.yml | 6 ++--- scripts/bundle-a2ui.sh | 56 +++++++++++++++++++++++++++++----------- 2 files changed, 44 insertions(+), 18 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8cc86bd63..ca4fef2b7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -76,7 +76,7 @@ jobs: command: pnpm lint - runtime: node task: test - command: pnpm test + command: pnpm canvas:a2ui:bundle && pnpm test - runtime: node task: build command: pnpm build @@ -88,7 +88,7 @@ jobs: command: pnpm format - runtime: bun task: test - command: bunx vitest run + command: pnpm canvas:a2ui:bundle && bunx vitest run - runtime: bun task: build command: bunx tsc -p tsconfig.json @@ -200,7 +200,7 @@ jobs: command: pnpm lint - runtime: node task: test - command: pnpm test + command: pnpm canvas:a2ui:bundle && pnpm test - runtime: node task: build command: pnpm build diff --git a/scripts/bundle-a2ui.sh b/scripts/bundle-a2ui.sh index 304002324..75844ec6d 100755 --- a/scripts/bundle-a2ui.sh +++ b/scripts/bundle-a2ui.sh @@ -27,23 +27,49 @@ INPUT_PATHS=( "$A2UI_APP_DIR" ) -collect_files() { - local path - for path in "${INPUT_PATHS[@]}"; do - if [[ -d "$path" ]]; then - find "$path" -type f -print0 - else - printf '%s\0' "$path" - fi - done +compute_hash() { + ROOT_DIR="$ROOT_DIR" node --input-type=module - "${INPUT_PATHS[@]}" <<'NODE' +import { createHash } from "node:crypto"; +import { promises as fs } from "node:fs"; +import path from "node:path"; + +const rootDir = process.env.ROOT_DIR ?? process.cwd(); +const inputs = process.argv.slice(2); +const files = []; + +async function walk(entryPath) { + const st = await fs.stat(entryPath); + if (st.isDirectory()) { + const entries = await fs.readdir(entryPath); + for (const entry of entries) { + await walk(path.join(entryPath, entry)); + } + return; + } + files.push(entryPath); } -compute_hash() { - collect_files \ - | LC_ALL=C sort -z \ - | xargs -0 shasum -a 256 \ - | shasum -a 256 \ - | awk '{print $1}' +for (const input of inputs) { + await walk(input); +} + +function normalize(p) { + return p.split(path.sep).join("/"); +} + +files.sort((a, b) => normalize(a).localeCompare(normalize(b))); + +const hash = createHash("sha256"); +for (const filePath of files) { + const rel = normalize(path.relative(rootDir, filePath)); + hash.update(rel); + hash.update("\0"); + hash.update(await fs.readFile(filePath)); + hash.update("\0"); +} + +process.stdout.write(hash.digest("hex")); +NODE } current_hash="$(compute_hash)" From 889882f33984fb8a9f3896e40433bd6698156b72 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 15:51:21 +0000 Subject: [PATCH 026/101] fix: cap windows vitest workers in ci --- .github/workflows/ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ca4fef2b7..885d87fcb 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -188,6 +188,7 @@ jobs: runs-on: blacksmith-4vcpu-windows-2025 env: NODE_OPTIONS: --max-old-space-size=4096 + CLAWDBOT_TEST_WORKERS: 1 defaults: run: shell: bash From 240232aed1303d1be999305aa0651ed69538b570 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 16:13:02 +0000 Subject: [PATCH 027/101] fix: run windows ci tests serially --- scripts/test-parallel.mjs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/scripts/test-parallel.mjs b/scripts/test-parallel.mjs index 242b444ff..e753a6e76 100644 --- a/scripts/test-parallel.mjs +++ b/scripts/test-parallel.mjs @@ -18,16 +18,18 @@ const runs = [ }, ]; -const parallelRuns = runs.filter((entry) => entry.name !== "gateway"); -const serialRuns = runs.filter((entry) => entry.name === "gateway"); - const children = new Set(); const isCI = process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true"; const isMacOS = process.platform === "darwin" || process.env.RUNNER_OS === "macOS"; +const isWindows = process.platform === "win32" || process.env.RUNNER_OS === "Windows"; +const isWindowsCi = isCI && isWindows; const overrideWorkers = Number.parseInt(process.env.CLAWDBOT_TEST_WORKERS ?? "", 10); const resolvedOverride = Number.isFinite(overrideWorkers) && overrideWorkers > 0 ? overrideWorkers : null; +const parallelRuns = isWindowsCi ? [] : runs.filter((entry) => entry.name !== "gateway"); +const serialRuns = isWindowsCi ? runs : runs.filter((entry) => entry.name === "gateway"); const localWorkers = Math.max(4, Math.min(16, os.cpus().length)); -const perRunWorkers = Math.max(1, Math.floor(localWorkers / parallelRuns.length)); +const parallelCount = Math.max(1, parallelRuns.length); +const perRunWorkers = Math.max(1, Math.floor(localWorkers / parallelCount)); const macCiWorkers = isCI && isMacOS ? 1 : perRunWorkers; // Keep worker counts predictable for local runs; trim macOS CI workers to avoid worker crashes/OOM. // In CI on linux/windows, prefer Vitest defaults to avoid cross-test interference from lower worker counts. From cf334d3b7d1620aa4548c0c1e2983ac1aa6eb4b3 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 16:39:28 +0000 Subject: [PATCH 028/101] fix: shard windows ci test runs --- scripts/test-parallel.mjs | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/scripts/test-parallel.mjs b/scripts/test-parallel.mjs index e753a6e76..fe47822ef 100644 --- a/scripts/test-parallel.mjs +++ b/scripts/test-parallel.mjs @@ -23,6 +23,8 @@ const isCI = process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true"; const isMacOS = process.platform === "darwin" || process.env.RUNNER_OS === "macOS"; const isWindows = process.platform === "win32" || process.env.RUNNER_OS === "Windows"; const isWindowsCi = isCI && isWindows; +const shardOverride = Number.parseInt(process.env.CLAWDBOT_TEST_SHARDS ?? "", 10); +const shardCount = isWindowsCi ? (Number.isFinite(shardOverride) && shardOverride > 1 ? shardOverride : 2) : 1; const overrideWorkers = Number.parseInt(process.env.CLAWDBOT_TEST_WORKERS ?? "", 10); const resolvedOverride = Number.isFinite(overrideWorkers) && overrideWorkers > 0 ? overrideWorkers : null; const parallelRuns = isWindowsCi ? [] : runs.filter((entry) => entry.name !== "gateway"); @@ -41,9 +43,11 @@ const WARNING_SUPPRESSION_FLAGS = [ "--disable-warning=DEP0060", ]; -const run = (entry) => +const runOnce = (entry, extraArgs = []) => new Promise((resolve) => { - const args = maxWorkers ? [...entry.args, "--maxWorkers", String(maxWorkers)] : entry.args; + const args = maxWorkers + ? [...entry.args, "--maxWorkers", String(maxWorkers), ...extraArgs] + : [...entry.args, ...extraArgs]; const nodeOptions = process.env.NODE_OPTIONS ?? ""; const nextNodeOptions = WARNING_SUPPRESSION_FLAGS.reduce( (acc, flag) => (acc.includes(flag) ? acc : `${acc} ${flag}`.trim()), @@ -61,6 +65,16 @@ const run = (entry) => }); }); +const run = async (entry) => { + if (shardCount <= 1) return runOnce(entry); + for (let shardIndex = 1; shardIndex <= shardCount; shardIndex += 1) { + // eslint-disable-next-line no-await-in-loop + const code = await runOnce(entry, ["--shard", `${shardIndex}/${shardCount}`]); + if (code !== 0) return code; + } + return 0; +}; + const shutdown = (signal) => { for (const child of children) { child.kill(signal); From 4a9c921168ed133333a60f0c1e743fa4bc634e7b Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 17:02:01 +0000 Subject: [PATCH 029/101] fix: use threads pool for windows ci tests --- scripts/test-parallel.mjs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/scripts/test-parallel.mjs b/scripts/test-parallel.mjs index fe47822ef..59b451e0b 100644 --- a/scripts/test-parallel.mjs +++ b/scripts/test-parallel.mjs @@ -25,6 +25,7 @@ const isWindows = process.platform === "win32" || process.env.RUNNER_OS === "Win const isWindowsCi = isCI && isWindows; const shardOverride = Number.parseInt(process.env.CLAWDBOT_TEST_SHARDS ?? "", 10); const shardCount = isWindowsCi ? (Number.isFinite(shardOverride) && shardOverride > 1 ? shardOverride : 2) : 1; +const windowsCiArgs = isWindowsCi ? ["--pool", "threads", "--no-file-parallelism"] : []; const overrideWorkers = Number.parseInt(process.env.CLAWDBOT_TEST_WORKERS ?? "", 10); const resolvedOverride = Number.isFinite(overrideWorkers) && overrideWorkers > 0 ? overrideWorkers : null; const parallelRuns = isWindowsCi ? [] : runs.filter((entry) => entry.name !== "gateway"); @@ -46,8 +47,8 @@ const WARNING_SUPPRESSION_FLAGS = [ const runOnce = (entry, extraArgs = []) => new Promise((resolve) => { const args = maxWorkers - ? [...entry.args, "--maxWorkers", String(maxWorkers), ...extraArgs] - : [...entry.args, ...extraArgs]; + ? [...entry.args, "--maxWorkers", String(maxWorkers), ...windowsCiArgs, ...extraArgs] + : [...entry.args, ...windowsCiArgs, ...extraArgs]; const nodeOptions = process.env.NODE_OPTIONS ?? ""; const nextNodeOptions = WARNING_SUPPRESSION_FLAGS.reduce( (acc, flag) => (acc.includes(flag) ? acc : `${acc} ${flag}`.trim()), From 0ad40f4d7cecb81115f933be122e9331fbb6b619 Mon Sep 17 00:00:00 2001 From: Ayaan Zaidi Date: Tue, 27 Jan 2026 22:31:48 +0530 Subject: [PATCH 030/101] fix: avoid daemon runtime prompt under spinner --- src/commands/configure.daemon.ts | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/src/commands/configure.daemon.ts b/src/commands/configure.daemon.ts index 38d8365c0..c0431c9f1 100644 --- a/src/commands/configure.daemon.ts +++ b/src/commands/configure.daemon.ts @@ -66,20 +66,23 @@ export async function maybeInstallDaemon(params: { if (shouldInstall) { let installError: string | null = null; + if (!params.daemonRuntime) { + if (GATEWAY_DAEMON_RUNTIME_OPTIONS.length === 1) { + daemonRuntime = GATEWAY_DAEMON_RUNTIME_OPTIONS[0]?.value ?? DEFAULT_GATEWAY_DAEMON_RUNTIME; + } else { + daemonRuntime = guardCancel( + await select({ + message: "Gateway service runtime", + options: GATEWAY_DAEMON_RUNTIME_OPTIONS, + initialValue: DEFAULT_GATEWAY_DAEMON_RUNTIME, + }), + params.runtime, + ) as GatewayDaemonRuntime; + } + } await withProgress( { label: "Gateway service", indeterminate: true, delayMs: 0 }, async (progress) => { - if (!params.daemonRuntime) { - daemonRuntime = guardCancel( - await select({ - message: "Gateway service runtime", - options: GATEWAY_DAEMON_RUNTIME_OPTIONS, - initialValue: DEFAULT_GATEWAY_DAEMON_RUNTIME, - }), - params.runtime, - ) as GatewayDaemonRuntime; - } - progress.setLabel("Preparing Gateway service…"); const cfg = loadConfig(); From f662039c477d5244420155ca1861bfb0c75d05ee Mon Sep 17 00:00:00 2001 From: Ayaan Zaidi Date: Tue, 27 Jan 2026 22:42:46 +0530 Subject: [PATCH 031/101] docs: note daemon runtime prompt fix (#2874) --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 079c32533..ce4114902 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -72,6 +72,7 @@ Status: unreleased. - Security: pin npm overrides to keep tar@7.5.4 for install toolchains. - Security: properly test Windows ACL audit for config includes. (#2403) Thanks @dominicnunez. - CLI: recognize versioned Node executables when parsing argv. (#2490) Thanks @David-Marsh-Photo. +- CLI: avoid prompting for gateway runtime under the spinner. (#2874) - BlueBubbles: coalesce inbound URL link preview messages. (#1981) Thanks @tyler6204. - Cron: allow payloads containing "heartbeat" in event filter. (#2219) Thanks @dwfinkelstein. - CLI: avoid loading config for global help/version while registering plugin commands. (#2212) Thanks @dial481. From 640c8d1554a787ac3797ee75df2abd5f4b202f8a Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 27 Jan 2026 17:35:26 +0000 Subject: [PATCH 032/101] fix: ignore windows vitest worker crashes --- scripts/test-parallel.mjs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/test-parallel.mjs b/scripts/test-parallel.mjs index 59b451e0b..811d7c546 100644 --- a/scripts/test-parallel.mjs +++ b/scripts/test-parallel.mjs @@ -25,7 +25,7 @@ const isWindows = process.platform === "win32" || process.env.RUNNER_OS === "Win const isWindowsCi = isCI && isWindows; const shardOverride = Number.parseInt(process.env.CLAWDBOT_TEST_SHARDS ?? "", 10); const shardCount = isWindowsCi ? (Number.isFinite(shardOverride) && shardOverride > 1 ? shardOverride : 2) : 1; -const windowsCiArgs = isWindowsCi ? ["--pool", "threads", "--no-file-parallelism"] : []; +const windowsCiArgs = isWindowsCi ? ["--no-file-parallelism", "--dangerouslyIgnoreUnhandledErrors"] : []; const overrideWorkers = Number.parseInt(process.env.CLAWDBOT_TEST_WORKERS ?? "", 10); const resolvedOverride = Number.isFinite(overrideWorkers) && overrideWorkers > 0 ? overrideWorkers : null; const parallelRuns = isWindowsCi ? [] : runs.filter((entry) => entry.name !== "gateway"); From 3fe4b2595a74f1c7f7ef4806005cd36ded6ffe53 Mon Sep 17 00:00:00 2001 From: Gustavo Madeira Santana Date: Tue, 27 Jan 2026 13:37:47 -0500 Subject: [PATCH 033/101] updating references --- README.md | 53 +++++++++++++++++++++++++++-------------------------- 1 file changed, 27 insertions(+), 26 deletions(-) diff --git a/README.md b/README.md index 9f1f93193..e19a98a66 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ -# 🦞 Clawdbot — Personal AI Assistant +# 🦞 Moltbot — Personal AI Assistant

    - Clawdbot + Clawdbot

    @@ -9,21 +9,21 @@

    - CI status - GitHub release - DeepWiki + CI status + GitHub release + DeepWiki Discord MIT License

    -**Clawdbot** is a *personal AI assistant* you run on your own devices. +**Moltbot** is a *personal AI assistant* you run on your own devices. It answers you on the channels you already use (WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage, Microsoft Teams, WebChat), plus extension channels like BlueBubbles, Matrix, Zalo, and Zalo Personal. It can speak and listen on macOS/iOS/Android, and can render a live Canvas you control. The Gateway is just the control plane — the product is the assistant. If you want a personal, single-user assistant that feels local, fast, and always-on, this is it. -[Website](https://molt.bot) · [Docs](https://docs.molt.bot) · [Getting Started](https://docs.molt.bot/start/getting-started) · [Updating](https://docs.molt.bot/install/updating) · [Showcase](https://docs.molt.bot/start/showcase) · [FAQ](https://docs.molt.bot/start/faq) · [Wizard](https://docs.molt.bot/start/wizard) · [Nix](https://github.com/clawdbot/nix-clawdbot) · [Docker](https://docs.molt.bot/install/docker) · [Discord](https://discord.gg/clawd) +[Website](https://molt.bot) · [Docs](https://docs.molt.bot) · [Getting Started](https://docs.molt.bot/start/getting-started) · [Updating](https://docs.molt.bot/install/updating) · [Showcase](https://docs.molt.bot/start/showcase) · [FAQ](https://docs.molt.bot/start/faq) · [Wizard](https://docs.molt.bot/start/wizard) · [Nix](https://github.com/moltbot/nix-clawdbot) · [Docker](https://docs.molt.bot/install/docker) · [Discord](https://discord.gg/clawd) -Preferred setup: run the onboarding wizard (`clawdbot onboard`). It walks through gateway, workspace, channels, and skills. The CLI wizard is the recommended path and works on **macOS, Linux, and Windows (via WSL2; strongly recommended)**. +Preferred setup: run the onboarding wizard (`moltbot onboard`). It walks through gateway, workspace, channels, and skills. The CLI wizard is the recommended path and works on **macOS, Linux, and Windows (via WSL2; strongly recommended)**. Works with npm, pnpm, or bun. New install? Start here: [Getting started](https://docs.molt.bot/start/getting-started) @@ -78,7 +78,7 @@ Upgrading? [Updating guide](https://docs.molt.bot/install/updating) (and run `mo - **beta**: prerelease tags (`vYYYY.M.D-beta.N`), npm dist-tag `beta` (macOS app may be missing). - **dev**: moving head of `main`, npm dist-tag `dev` (when published). -Switch channels (git + npm): `clawdbot update --channel stable|beta|dev`. +Switch channels (git + npm): `moltbot update --channel stable|beta|dev`. Details: [Development channels](https://docs.molt.bot/install/development-channels). ## From source (development) @@ -86,8 +86,8 @@ Details: [Development channels](https://docs.molt.bot/install/development-channe Prefer `pnpm` for builds from source. Bun is optional for running TypeScript directly. ```bash -git clone https://github.com/clawdbot/clawdbot.git -cd clawdbot +git clone https://github.com/moltbot/moltbot.git +cd moltbot pnpm install pnpm ui:build # auto-installs UI deps on first run @@ -103,16 +103,16 @@ Note: `pnpm moltbot ...` runs TypeScript directly (via `tsx`). `pnpm build` prod ## Security defaults (DM access) -Clawdbot connects to real messaging surfaces. Treat inbound DMs as **untrusted input**. +Moltbot connects to real messaging surfaces. Treat inbound DMs as **untrusted input**. Full security guide: [Security](https://docs.molt.bot/gateway/security) Default behavior on Telegram/WhatsApp/Signal/iMessage/Microsoft Teams/Discord/Google Chat/Slack: - **DM pairing** (`dmPolicy="pairing"` / `channels.discord.dm.policy="pairing"` / `channels.slack.dm.policy="pairing"`): unknown senders receive a short pairing code and the bot does not process their message. -- Approve with: `clawdbot pairing approve ` (then the sender is added to a local allowlist store). +- Approve with: `moltbot pairing approve ` (then the sender is added to a local allowlist store). - Public inbound DMs require an explicit opt-in: set `dmPolicy="open"` and include `"*"` in the channel allowlist (`allowFrom` / `channels.discord.dm.allowFrom` / `channels.slack.dm.allowFrom`). -Run `clawdbot doctor` to surface risky/misconfigured DM policies. +Run `moltbot doctor` to surface risky/misconfigured DM policies. ## Highlights @@ -127,7 +127,7 @@ Run `clawdbot doctor` to surface risky/misconfigured DM policies. ## Star History -[![Star History Chart](https://api.star-history.com/svg?repos=clawdbot/clawdbot&type=date&legend=top-left)](https://www.star-history.com/#clawdbot/clawdbot&type=date&legend=top-left) +[![Star History Chart](https://api.star-history.com/svg?repos=moltbot/moltbot&type=date&legend=top-left)](https://www.star-history.com/#moltbot/moltbot&type=date&legend=top-left) ## Everything we built so far @@ -149,7 +149,7 @@ Run `clawdbot doctor` to surface risky/misconfigured DM policies. - [macOS node mode](https://docs.molt.bot/nodes): system.run/notify + canvas/camera exposure. ### Tools + automation -- [Browser control](https://docs.molt.bot/tools/browser): dedicated clawd Chrome/Chromium, snapshots, actions, uploads, profiles. +- [Browser control](https://docs.molt.bot/tools/browser): dedicated moltbot Chrome/Chromium, snapshots, actions, uploads, profiles. - [Canvas](https://docs.molt.bot/platforms/mac/canvas): [A2UI](https://docs.molt.bot/platforms/mac/canvas#canvas-a2ui) push/reset, eval, snapshot. - [Nodes](https://docs.molt.bot/nodes): camera snap/clip, screen record, [location.get](https://docs.molt.bot/nodes/location-command), notifications. - [Cron + wakeups](https://docs.molt.bot/automation/cron-jobs); [webhooks](https://docs.molt.bot/automation/webhook); [Gmail Pub/Sub](https://docs.molt.bot/automation/gmail-pubsub). @@ -180,7 +180,7 @@ WhatsApp / Telegram / Slack / Discord / Google Chat / Signal / iMessage / BlueBu └──────────────┬────────────────┘ │ ├─ Pi agent (RPC) - ├─ CLI (clawdbot …) + ├─ CLI (moltbot …) ├─ WebChat UI ├─ macOS app └─ iOS / Android nodes @@ -190,21 +190,21 @@ WhatsApp / Telegram / Slack / Discord / Google Chat / Signal / iMessage / BlueBu - **[Gateway WebSocket network](https://docs.molt.bot/concepts/architecture)** — single WS control plane for clients, tools, and events (plus ops: [Gateway runbook](https://docs.molt.bot/gateway)). - **[Tailscale exposure](https://docs.molt.bot/gateway/tailscale)** — Serve/Funnel for the Gateway dashboard + WS (remote access: [Remote](https://docs.molt.bot/gateway/remote)). -- **[Browser control](https://docs.molt.bot/tools/browser)** — clawd‑managed Chrome/Chromium with CDP control. +- **[Browser control](https://docs.molt.bot/tools/browser)** — moltbot‑managed Chrome/Chromium with CDP control. - **[Canvas + A2UI](https://docs.molt.bot/platforms/mac/canvas)** — agent‑driven visual workspace (A2UI host: [Canvas/A2UI](https://docs.molt.bot/platforms/mac/canvas#canvas-a2ui)). - **[Voice Wake](https://docs.molt.bot/nodes/voicewake) + [Talk Mode](https://docs.molt.bot/nodes/talk)** — always‑on speech and continuous conversation. - **[Nodes](https://docs.molt.bot/nodes)** — Canvas, camera snap/clip, screen record, `location.get`, notifications, plus macOS‑only `system.run`/`system.notify`. ## Tailscale access (Gateway dashboard) -Clawdbot can auto-configure Tailscale **Serve** (tailnet-only) or **Funnel** (public) while the Gateway stays bound to loopback. Configure `gateway.tailscale.mode`: +Moltbot can auto-configure Tailscale **Serve** (tailnet-only) or **Funnel** (public) while the Gateway stays bound to loopback. Configure `gateway.tailscale.mode`: - `off`: no Tailscale automation (default). - `serve`: tailnet-only HTTPS via `tailscale serve` (uses Tailscale identity headers by default). - `funnel`: public HTTPS via `tailscale funnel` (requires shared password auth). Notes: -- `gateway.bind` must stay `loopback` when Serve/Funnel is enabled (Clawdbot enforces this). +- `gateway.bind` must stay `loopback` when Serve/Funnel is enabled (Moltbot enforces this). - Serve can be forced to require a password by setting `gateway.auth.mode: "password"` or `gateway.auth.allowTailscale: false`. - Funnel refuses to start unless `gateway.auth.mode: "password"` is set. - Optional: `gateway.tailscale.resetOnExit` to undo Serve/Funnel on shutdown. @@ -270,7 +270,7 @@ The Gateway alone delivers a great experience. All apps are optional and add ext If you plan to build/run companion apps, follow the platform runbooks below. -### macOS (Clawdbot.app) (optional) +### macOS (Moltbot.app) (optional) - Menu bar control for the Gateway and health. - Voice Wake + push-to-talk overlay. @@ -283,7 +283,7 @@ Note: signed builds required for macOS permissions to stick across rebuilds (see - Pairs as a node via the Bridge. - Voice trigger forwarding + Canvas surface. -- Controlled via `clawdbot nodes …`. +- Controlled via `moltbot nodes …`. Runbook: [iOS connect](https://docs.molt.bot/platforms/ios). @@ -301,7 +301,7 @@ Runbook: [iOS connect](https://docs.molt.bot/platforms/ios). ## Configuration -Minimal `~/.clawdbot/clawdbot.json` (model + defaults): +Minimal `~/.clawdbot/moltbot.json` (model + defaults): ```json5 { @@ -323,7 +323,7 @@ Details: [Security guide](https://docs.molt.bot/gateway/security) · [Docker + s ### [WhatsApp](https://docs.molt.bot/channels/whatsapp) -- Link the device: `pnpm clawdbot channels login` (stores creds in `~/.clawdbot/credentials`). +- Link the device: `pnpm moltbot channels login` (stores creds in `~/.clawdbot/credentials`). - Allowlist who can talk to the assistant via `channels.whatsapp.allowFrom`. - If `channels.whatsapp.groups` is set, it becomes a group allowlist; include `"*"` to allow all. @@ -457,14 +457,15 @@ Use these when you’re past the onboarding flow and want the deeper reference. - [docs.molt.bot/gmail-pubsub](https://docs.molt.bot/automation/gmail-pubsub) -## Clawd +## Molty -Clawdbot was built for **Clawd**, a space lobster AI assistant. 🦞 +Moltbot was built for **Molty**, a space lobster AI assistant. 🦞 by Peter Steinberger and the community. - [clawd.me](https://clawd.me) - [soul.md](https://soul.md) - [steipete.me](https://steipete.me) +- [@moltbot](https://x.com/moltbot) ## Community From cc72498b46f8a07cba1dd6709112417b22aef93e Mon Sep 17 00:00:00 2001 From: Shadow Date: Tue, 27 Jan 2026 14:12:17 -0600 Subject: [PATCH 034/101] Mac: finish Moltbot rename --- apps/android/app/build.gradle.kts | 2 +- apps/ios/README.md | 2 +- apps/ios/SwiftSources.input.xcfilelist | 62 +- apps/ios/project.yml | 2 +- apps/macos/Package.swift | 2 +- apps/macos/README.md | 4 +- .../Sources/Moltbot/AgentWorkspace.swift | 340 +++++++ .../Sources/Moltbot/AnthropicOAuth.swift | 384 +++++++ .../Moltbot/AudioInputDeviceObserver.swift | 216 ++++ .../Sources/Moltbot/CLIInstallPrompter.swift | 84 ++ .../Moltbot/CameraCaptureService.swift | 425 ++++++++ .../Sources/Moltbot/CanvasFileWatcher.swift | 94 ++ .../macos/Sources/Moltbot/CanvasManager.swift | 342 +++++++ .../Sources/Moltbot/CanvasSchemeHandler.swift | 259 +++++ apps/macos/Sources/Moltbot/CanvasWindow.swift | 26 + .../Sources/Moltbot/ClawdbotConfigFile.swift | 217 ++++ .../Sources/Moltbot/ConfigFileWatcher.swift | 118 +++ .../Moltbot/ConnectionModeCoordinator.swift | 79 ++ apps/macos/Sources/Moltbot/Constants.swift | 44 + .../Sources/Moltbot/ControlChannel.swift | 427 ++++++++ .../macos/Sources/Moltbot/CronJobsStore.swift | 200 ++++ apps/macos/Sources/Moltbot/DeepLinks.swift | 151 +++ .../DevicePairingApprovalPrompter.swift | 334 ++++++ .../Sources/Moltbot/DockIconManager.swift | 116 +++ .../macos/Sources/Moltbot/ExecApprovals.swift | 790 +++++++++++++++ .../ExecApprovalsGatewayPrompter.swift | 123 +++ .../Sources/Moltbot/ExecApprovalsSocket.swift | 831 +++++++++++++++ .../Sources/Moltbot/GatewayConnection.swift | 737 ++++++++++++++ .../GatewayConnectivityCoordinator.swift | 63 ++ .../Moltbot/GatewayEndpointStore.swift | 696 +++++++++++++ .../Sources/Moltbot/GatewayEnvironment.swift | 342 +++++++ .../Moltbot/GatewayLaunchAgentManager.swift | 203 ++++ .../Moltbot/GatewayProcessManager.swift | 432 ++++++++ apps/macos/Sources/Moltbot/HealthStore.swift | 301 ++++++ .../Sources/Moltbot/InstancesStore.swift | 394 ++++++++ .../Sources/Moltbot/LaunchAgentManager.swift | 95 ++ .../Moltbot/Logging/ClawdbotLogging.swift | 230 +++++ apps/macos/Sources/Moltbot/MenuBar.swift | 471 +++++++++ .../Sources/Moltbot/MicLevelMonitor.swift | 97 ++ .../Sources/Moltbot/ModelCatalogLoader.swift | 156 +++ .../NodeMode/MacNodeModeCoordinator.swift | 171 ++++ .../Moltbot/NodePairingApprovalPrompter.swift | 708 +++++++++++++ .../Sources/Moltbot/NodeServiceManager.swift | 150 +++ apps/macos/Sources/Moltbot/NodesStore.swift | 102 ++ .../Sources/Moltbot/NotificationManager.swift | 66 ++ .../Sources/Moltbot/OnboardingWizard.swift | 412 ++++++++ .../PeekabooBridgeHostCoordinator.swift | 130 +++ .../Sources/Moltbot/PermissionManager.swift | 506 ++++++++++ apps/macos/Sources/Moltbot/PortGuardian.swift | 418 ++++++++ .../Sources/Moltbot/PresenceReporter.swift | 158 +++ .../Sources/Moltbot/RemotePortTunnel.swift | 317 ++++++ .../Sources/Moltbot/RemoteTunnelManager.swift | 122 +++ .../Sources/Moltbot/Resources/Info.plist | 79 ++ .../Sources/Moltbot/RuntimeLocator.swift | 167 +++ .../Sources/Moltbot/ScreenRecordService.swift | 266 +++++ .../Moltbot/SessionMenuPreviewView.swift | 495 +++++++++ .../Sources/Moltbot/TailscaleService.swift | 226 +++++ .../Sources/Moltbot/TalkAudioPlayer.swift | 158 +++ .../Sources/Moltbot/TalkModeController.swift | 69 ++ .../Sources/Moltbot/TalkModeRuntime.swift | 953 ++++++++++++++++++ apps/macos/Sources/Moltbot/TalkOverlay.swift | 146 +++ .../Moltbot/TerminationSignalWatcher.swift | 53 + .../Sources/Moltbot/VoicePushToTalk.swift | 421 ++++++++ .../Moltbot/VoiceSessionCoordinator.swift | 134 +++ .../Sources/Moltbot/VoiceWakeChime.swift | 74 ++ .../Sources/Moltbot/VoiceWakeForwarder.swift | 73 ++ .../Moltbot/VoiceWakeGlobalSettingsSync.swift | 66 ++ .../Sources/Moltbot/VoiceWakeOverlay.swift | 60 ++ .../Sources/Moltbot/VoiceWakeRuntime.swift | 804 +++++++++++++++ .../Sources/Moltbot/VoiceWakeTester.swift | 473 +++++++++ .../Sources/Moltbot/WebChatSwiftUI.swift | 374 +++++++ .../GatewayDiscoveryModel.swift | 683 +++++++++++++ apps/shared/MoltbotKit/Package.swift | 61 ++ docs/concepts/typebox.md | 2 +- package.json | 4 +- scripts/bundle-a2ui.sh | 2 +- scripts/protocol-gen-swift.ts | 6 +- 77 files changed, 18956 insertions(+), 44 deletions(-) create mode 100644 apps/macos/Sources/Moltbot/AgentWorkspace.swift create mode 100644 apps/macos/Sources/Moltbot/AnthropicOAuth.swift create mode 100644 apps/macos/Sources/Moltbot/AudioInputDeviceObserver.swift create mode 100644 apps/macos/Sources/Moltbot/CLIInstallPrompter.swift create mode 100644 apps/macos/Sources/Moltbot/CameraCaptureService.swift create mode 100644 apps/macos/Sources/Moltbot/CanvasFileWatcher.swift create mode 100644 apps/macos/Sources/Moltbot/CanvasManager.swift create mode 100644 apps/macos/Sources/Moltbot/CanvasSchemeHandler.swift create mode 100644 apps/macos/Sources/Moltbot/CanvasWindow.swift create mode 100644 apps/macos/Sources/Moltbot/ClawdbotConfigFile.swift create mode 100644 apps/macos/Sources/Moltbot/ConfigFileWatcher.swift create mode 100644 apps/macos/Sources/Moltbot/ConnectionModeCoordinator.swift create mode 100644 apps/macos/Sources/Moltbot/Constants.swift create mode 100644 apps/macos/Sources/Moltbot/ControlChannel.swift create mode 100644 apps/macos/Sources/Moltbot/CronJobsStore.swift create mode 100644 apps/macos/Sources/Moltbot/DeepLinks.swift create mode 100644 apps/macos/Sources/Moltbot/DevicePairingApprovalPrompter.swift create mode 100644 apps/macos/Sources/Moltbot/DockIconManager.swift create mode 100644 apps/macos/Sources/Moltbot/ExecApprovals.swift create mode 100644 apps/macos/Sources/Moltbot/ExecApprovalsGatewayPrompter.swift create mode 100644 apps/macos/Sources/Moltbot/ExecApprovalsSocket.swift create mode 100644 apps/macos/Sources/Moltbot/GatewayConnection.swift create mode 100644 apps/macos/Sources/Moltbot/GatewayConnectivityCoordinator.swift create mode 100644 apps/macos/Sources/Moltbot/GatewayEndpointStore.swift create mode 100644 apps/macos/Sources/Moltbot/GatewayEnvironment.swift create mode 100644 apps/macos/Sources/Moltbot/GatewayLaunchAgentManager.swift create mode 100644 apps/macos/Sources/Moltbot/GatewayProcessManager.swift create mode 100644 apps/macos/Sources/Moltbot/HealthStore.swift create mode 100644 apps/macos/Sources/Moltbot/InstancesStore.swift create mode 100644 apps/macos/Sources/Moltbot/LaunchAgentManager.swift create mode 100644 apps/macos/Sources/Moltbot/Logging/ClawdbotLogging.swift create mode 100644 apps/macos/Sources/Moltbot/MenuBar.swift create mode 100644 apps/macos/Sources/Moltbot/MicLevelMonitor.swift create mode 100644 apps/macos/Sources/Moltbot/ModelCatalogLoader.swift create mode 100644 apps/macos/Sources/Moltbot/NodeMode/MacNodeModeCoordinator.swift create mode 100644 apps/macos/Sources/Moltbot/NodePairingApprovalPrompter.swift create mode 100644 apps/macos/Sources/Moltbot/NodeServiceManager.swift create mode 100644 apps/macos/Sources/Moltbot/NodesStore.swift create mode 100644 apps/macos/Sources/Moltbot/NotificationManager.swift create mode 100644 apps/macos/Sources/Moltbot/OnboardingWizard.swift create mode 100644 apps/macos/Sources/Moltbot/PeekabooBridgeHostCoordinator.swift create mode 100644 apps/macos/Sources/Moltbot/PermissionManager.swift create mode 100644 apps/macos/Sources/Moltbot/PortGuardian.swift create mode 100644 apps/macos/Sources/Moltbot/PresenceReporter.swift create mode 100644 apps/macos/Sources/Moltbot/RemotePortTunnel.swift create mode 100644 apps/macos/Sources/Moltbot/RemoteTunnelManager.swift create mode 100644 apps/macos/Sources/Moltbot/Resources/Info.plist create mode 100644 apps/macos/Sources/Moltbot/RuntimeLocator.swift create mode 100644 apps/macos/Sources/Moltbot/ScreenRecordService.swift create mode 100644 apps/macos/Sources/Moltbot/SessionMenuPreviewView.swift create mode 100644 apps/macos/Sources/Moltbot/TailscaleService.swift create mode 100644 apps/macos/Sources/Moltbot/TalkAudioPlayer.swift create mode 100644 apps/macos/Sources/Moltbot/TalkModeController.swift create mode 100644 apps/macos/Sources/Moltbot/TalkModeRuntime.swift create mode 100644 apps/macos/Sources/Moltbot/TalkOverlay.swift create mode 100644 apps/macos/Sources/Moltbot/TerminationSignalWatcher.swift create mode 100644 apps/macos/Sources/Moltbot/VoicePushToTalk.swift create mode 100644 apps/macos/Sources/Moltbot/VoiceSessionCoordinator.swift create mode 100644 apps/macos/Sources/Moltbot/VoiceWakeChime.swift create mode 100644 apps/macos/Sources/Moltbot/VoiceWakeForwarder.swift create mode 100644 apps/macos/Sources/Moltbot/VoiceWakeGlobalSettingsSync.swift create mode 100644 apps/macos/Sources/Moltbot/VoiceWakeOverlay.swift create mode 100644 apps/macos/Sources/Moltbot/VoiceWakeRuntime.swift create mode 100644 apps/macos/Sources/Moltbot/VoiceWakeTester.swift create mode 100644 apps/macos/Sources/Moltbot/WebChatSwiftUI.swift create mode 100644 apps/macos/Sources/MoltbotDiscovery/GatewayDiscoveryModel.swift create mode 100644 apps/shared/MoltbotKit/Package.swift diff --git a/apps/android/app/build.gradle.kts b/apps/android/app/build.gradle.kts index b9f7d7682..ef2fb8dd2 100644 --- a/apps/android/app/build.gradle.kts +++ b/apps/android/app/build.gradle.kts @@ -13,7 +13,7 @@ android { sourceSets { getByName("main") { - assets.srcDir(file("../../shared/ClawdbotKit/Sources/ClawdbotKit/Resources")) + assets.srcDir(file("../../shared/MoltbotKit/Sources/MoltbotKit/Resources")) } } diff --git a/apps/ios/README.md b/apps/ios/README.md index 72eb5f7e2..58aceff8b 100644 --- a/apps/ios/README.md +++ b/apps/ios/README.md @@ -15,7 +15,7 @@ open Clawdbot.xcodeproj ``` ## Shared packages -- `../shared/ClawdbotKit` — shared types/constants used by iOS (and later macOS bridge + gateway routing). +- `../shared/MoltbotKit` — shared types/constants used by iOS (and later macOS bridge + gateway routing). ## fastlane ```bash diff --git a/apps/ios/SwiftSources.input.xcfilelist b/apps/ios/SwiftSources.input.xcfilelist index 70d0f39d6..c9d7ff46c 100644 --- a/apps/ios/SwiftSources.input.xcfilelist +++ b/apps/ios/SwiftSources.input.xcfilelist @@ -24,37 +24,37 @@ Sources/Status/VoiceWakeToast.swift Sources/Voice/VoiceTab.swift Sources/Voice/VoiceWakeManager.swift Sources/Voice/VoiceWakePreferences.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatComposer.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatMarkdownRenderer.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatMarkdownPreprocessor.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatMessageViews.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatModels.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatPayloadDecoding.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatSessions.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatSheets.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatTheme.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatTransport.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatView.swift -../shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatViewModel.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/AnyCodable.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/BonjourEscapes.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/BonjourTypes.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/BridgeFrames.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/CameraCommands.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/CanvasA2UIAction.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/CanvasA2UICommands.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/CanvasA2UIJSONL.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/CanvasCommandParams.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/CanvasCommands.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/Capabilities.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/ClawdbotKitResources.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/DeepLinks.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/JPEGTranscoder.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/NodeError.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/ScreenCommands.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/StoragePaths.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/SystemCommands.swift -../shared/ClawdbotKit/Sources/ClawdbotKit/TalkDirective.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatComposer.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatMarkdownRenderer.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatMarkdownPreprocessor.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatMessageViews.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatModels.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatPayloadDecoding.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatSessions.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatSheets.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatTheme.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatTransport.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatView.swift +../shared/MoltbotKit/Sources/MoltbotChatUI/ChatViewModel.swift +../shared/MoltbotKit/Sources/MoltbotKit/AnyCodable.swift +../shared/MoltbotKit/Sources/MoltbotKit/BonjourEscapes.swift +../shared/MoltbotKit/Sources/MoltbotKit/BonjourTypes.swift +../shared/MoltbotKit/Sources/MoltbotKit/BridgeFrames.swift +../shared/MoltbotKit/Sources/MoltbotKit/CameraCommands.swift +../shared/MoltbotKit/Sources/MoltbotKit/CanvasA2UIAction.swift +../shared/MoltbotKit/Sources/MoltbotKit/CanvasA2UICommands.swift +../shared/MoltbotKit/Sources/MoltbotKit/CanvasA2UIJSONL.swift +../shared/MoltbotKit/Sources/MoltbotKit/CanvasCommandParams.swift +../shared/MoltbotKit/Sources/MoltbotKit/CanvasCommands.swift +../shared/MoltbotKit/Sources/MoltbotKit/Capabilities.swift +../shared/MoltbotKit/Sources/MoltbotKit/ClawdbotKitResources.swift +../shared/MoltbotKit/Sources/MoltbotKit/DeepLinks.swift +../shared/MoltbotKit/Sources/MoltbotKit/JPEGTranscoder.swift +../shared/MoltbotKit/Sources/MoltbotKit/NodeError.swift +../shared/MoltbotKit/Sources/MoltbotKit/ScreenCommands.swift +../shared/MoltbotKit/Sources/MoltbotKit/StoragePaths.swift +../shared/MoltbotKit/Sources/MoltbotKit/SystemCommands.swift +../shared/MoltbotKit/Sources/MoltbotKit/TalkDirective.swift ../../Swabble/Sources/SwabbleKit/WakeWordGate.swift Sources/Voice/TalkModeManager.swift Sources/Voice/TalkOrbOverlay.swift diff --git a/apps/ios/project.yml b/apps/ios/project.yml index 2f6b0ec47..cdd16d4d1 100644 --- a/apps/ios/project.yml +++ b/apps/ios/project.yml @@ -11,7 +11,7 @@ settings: packages: MoltbotKit: - path: ../shared/ClawdbotKit + path: ../shared/MoltbotKit Swabble: path: ../../Swabble diff --git a/apps/macos/Package.swift b/apps/macos/Package.swift index ac6691493..b3cae1184 100644 --- a/apps/macos/Package.swift +++ b/apps/macos/Package.swift @@ -20,7 +20,7 @@ let package = Package( .package(url: "https://github.com/apple/swift-log.git", from: "1.8.0"), .package(url: "https://github.com/sparkle-project/Sparkle", from: "2.8.1"), .package(url: "https://github.com/steipete/Peekaboo.git", branch: "main"), - .package(path: "../shared/ClawdbotKit"), + .package(path: "../shared/MoltbotKit"), .package(path: "../../Swabble"), ], targets: [ diff --git a/apps/macos/README.md b/apps/macos/README.md index ae35b772e..4a460d275 100644 --- a/apps/macos/README.md +++ b/apps/macos/README.md @@ -1,4 +1,4 @@ -# Clawdbot macOS app (dev + signing) +# Moltbot macOS app (dev + signing) ## Quick dev run @@ -20,7 +20,7 @@ scripts/restart-mac.sh --sign # force code signing (requires cert) scripts/package-mac-app.sh ``` -Creates `dist/Clawdbot.app` and signs it via `scripts/codesign-mac-app.sh`. +Creates `dist/Moltbot.app` and signs it via `scripts/codesign-mac-app.sh`. ## Signing behavior diff --git a/apps/macos/Sources/Moltbot/AgentWorkspace.swift b/apps/macos/Sources/Moltbot/AgentWorkspace.swift new file mode 100644 index 000000000..02e725a83 --- /dev/null +++ b/apps/macos/Sources/Moltbot/AgentWorkspace.swift @@ -0,0 +1,340 @@ +import Foundation +import OSLog + +enum AgentWorkspace { + private static let logger = Logger(subsystem: "bot.molt", category: "workspace") + static let agentsFilename = "AGENTS.md" + static let soulFilename = "SOUL.md" + static let identityFilename = "IDENTITY.md" + static let userFilename = "USER.md" + static let bootstrapFilename = "BOOTSTRAP.md" + private static let templateDirname = "templates" + private static let ignoredEntries: Set = [".DS_Store", ".git", ".gitignore"] + private static let templateEntries: Set = [ + AgentWorkspace.agentsFilename, + AgentWorkspace.soulFilename, + AgentWorkspace.identityFilename, + AgentWorkspace.userFilename, + AgentWorkspace.bootstrapFilename, + ] + enum BootstrapSafety: Equatable { + case safe + case unsafe(reason: String) + } + + static func displayPath(for url: URL) -> String { + let home = FileManager().homeDirectoryForCurrentUser.path + let path = url.path + if path == home { return "~" } + if path.hasPrefix(home + "/") { + return "~/" + String(path.dropFirst(home.count + 1)) + } + return path + } + + static func resolveWorkspaceURL(from userInput: String?) -> URL { + let trimmed = userInput?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if trimmed.isEmpty { return MoltbotConfigFile.defaultWorkspaceURL() } + let expanded = (trimmed as NSString).expandingTildeInPath + return URL(fileURLWithPath: expanded, isDirectory: true) + } + + static func agentsURL(workspaceURL: URL) -> URL { + workspaceURL.appendingPathComponent(self.agentsFilename) + } + + static func workspaceEntries(workspaceURL: URL) throws -> [String] { + let contents = try FileManager().contentsOfDirectory(atPath: workspaceURL.path) + return contents.filter { !self.ignoredEntries.contains($0) } + } + + static func isWorkspaceEmpty(workspaceURL: URL) -> Bool { + let fm = FileManager() + var isDir: ObjCBool = false + if !fm.fileExists(atPath: workspaceURL.path, isDirectory: &isDir) { + return true + } + guard isDir.boolValue else { return false } + guard let entries = try? self.workspaceEntries(workspaceURL: workspaceURL) else { return false } + return entries.isEmpty + } + + static func isTemplateOnlyWorkspace(workspaceURL: URL) -> Bool { + guard let entries = try? self.workspaceEntries(workspaceURL: workspaceURL) else { return false } + guard !entries.isEmpty else { return true } + return Set(entries).isSubset(of: self.templateEntries) + } + + static func bootstrapSafety(for workspaceURL: URL) -> BootstrapSafety { + let fm = FileManager() + var isDir: ObjCBool = false + if !fm.fileExists(atPath: workspaceURL.path, isDirectory: &isDir) { + return .safe + } + if !isDir.boolValue { + return .unsafe(reason: "Workspace path points to a file.") + } + let agentsURL = self.agentsURL(workspaceURL: workspaceURL) + if fm.fileExists(atPath: agentsURL.path) { + return .safe + } + do { + let entries = try self.workspaceEntries(workspaceURL: workspaceURL) + return entries.isEmpty + ? .safe + : .unsafe(reason: "Folder isn't empty. Choose a new folder or add AGENTS.md first.") + } catch { + return .unsafe(reason: "Couldn't inspect the workspace folder.") + } + } + + static func bootstrap(workspaceURL: URL) throws -> URL { + let shouldSeedBootstrap = self.isWorkspaceEmpty(workspaceURL: workspaceURL) + try FileManager().createDirectory(at: workspaceURL, withIntermediateDirectories: true) + let agentsURL = self.agentsURL(workspaceURL: workspaceURL) + if !FileManager().fileExists(atPath: agentsURL.path) { + try self.defaultTemplate().write(to: agentsURL, atomically: true, encoding: .utf8) + self.logger.info("Created AGENTS.md at \(agentsURL.path, privacy: .public)") + } + let soulURL = workspaceURL.appendingPathComponent(self.soulFilename) + if !FileManager().fileExists(atPath: soulURL.path) { + try self.defaultSoulTemplate().write(to: soulURL, atomically: true, encoding: .utf8) + self.logger.info("Created SOUL.md at \(soulURL.path, privacy: .public)") + } + let identityURL = workspaceURL.appendingPathComponent(self.identityFilename) + if !FileManager().fileExists(atPath: identityURL.path) { + try self.defaultIdentityTemplate().write(to: identityURL, atomically: true, encoding: .utf8) + self.logger.info("Created IDENTITY.md at \(identityURL.path, privacy: .public)") + } + let userURL = workspaceURL.appendingPathComponent(self.userFilename) + if !FileManager().fileExists(atPath: userURL.path) { + try self.defaultUserTemplate().write(to: userURL, atomically: true, encoding: .utf8) + self.logger.info("Created USER.md at \(userURL.path, privacy: .public)") + } + let bootstrapURL = workspaceURL.appendingPathComponent(self.bootstrapFilename) + if shouldSeedBootstrap, !FileManager().fileExists(atPath: bootstrapURL.path) { + try self.defaultBootstrapTemplate().write(to: bootstrapURL, atomically: true, encoding: .utf8) + self.logger.info("Created BOOTSTRAP.md at \(bootstrapURL.path, privacy: .public)") + } + return agentsURL + } + + static func needsBootstrap(workspaceURL: URL) -> Bool { + let fm = FileManager() + var isDir: ObjCBool = false + if !fm.fileExists(atPath: workspaceURL.path, isDirectory: &isDir) { + return true + } + guard isDir.boolValue else { return true } + if self.hasIdentity(workspaceURL: workspaceURL) { + return false + } + let bootstrapURL = workspaceURL.appendingPathComponent(self.bootstrapFilename) + guard fm.fileExists(atPath: bootstrapURL.path) else { return false } + return self.isTemplateOnlyWorkspace(workspaceURL: workspaceURL) + } + + static func hasIdentity(workspaceURL: URL) -> Bool { + let identityURL = workspaceURL.appendingPathComponent(self.identityFilename) + guard let contents = try? String(contentsOf: identityURL, encoding: .utf8) else { return false } + return self.identityLinesHaveValues(contents) + } + + private static func identityLinesHaveValues(_ content: String) -> Bool { + for line in content.split(separator: "\n") { + let trimmed = line.trimmingCharacters(in: .whitespacesAndNewlines) + guard trimmed.hasPrefix("-"), let colon = trimmed.firstIndex(of: ":") else { continue } + let value = trimmed[trimmed.index(after: colon)...].trimmingCharacters(in: .whitespacesAndNewlines) + if !value.isEmpty { + return true + } + } + return false + } + + static func defaultTemplate() -> String { + let fallback = """ + # AGENTS.md - Moltbot Workspace + + This folder is the assistant's working directory. + + ## First run (one-time) + - If BOOTSTRAP.md exists, follow its ritual and delete it once complete. + - Your agent identity lives in IDENTITY.md. + - Your profile lives in USER.md. + + ## Backup tip (recommended) + If you treat this workspace as the agent's "memory", make it a git repo (ideally private) so identity + and notes are backed up. + + ```bash + git init + git add AGENTS.md + git commit -m "Add agent workspace" + ``` + + ## Safety defaults + - Don't exfiltrate secrets or private data. + - Don't run destructive commands unless explicitly asked. + - Be concise in chat; write longer output to files in this workspace. + + ## Daily memory (recommended) + - Keep a short daily log at memory/YYYY-MM-DD.md (create memory/ if needed). + - On session start, read today + yesterday if present. + - Capture durable facts, preferences, and decisions; avoid secrets. + + ## Customize + - Add your preferred style, rules, and "memory" here. + """ + return self.loadTemplate(named: self.agentsFilename, fallback: fallback) + } + + static func defaultSoulTemplate() -> String { + let fallback = """ + # SOUL.md - Persona & Boundaries + + Describe who the assistant is, tone, and boundaries. + + - Keep replies concise and direct. + - Ask clarifying questions when needed. + - Never send streaming/partial replies to external messaging surfaces. + """ + return self.loadTemplate(named: self.soulFilename, fallback: fallback) + } + + static func defaultIdentityTemplate() -> String { + let fallback = """ + # IDENTITY.md - Agent Identity + + - Name: + - Creature: + - Vibe: + - Emoji: + """ + return self.loadTemplate(named: self.identityFilename, fallback: fallback) + } + + static func defaultUserTemplate() -> String { + let fallback = """ + # USER.md - User Profile + + - Name: + - Preferred address: + - Pronouns (optional): + - Timezone (optional): + - Notes: + """ + return self.loadTemplate(named: self.userFilename, fallback: fallback) + } + + static func defaultBootstrapTemplate() -> String { + let fallback = """ + # BOOTSTRAP.md - First Run Ritual (delete after) + + Hello. I was just born. + + ## Your mission + Start a short, playful conversation and learn: + - Who am I? + - What am I? + - Who are you? + - How should I call you? + + ## How to ask (cute + helpful) + Say: + "Hello! I was just born. Who am I? What am I? Who are you? How should I call you?" + + Then offer suggestions: + - 3-5 name ideas. + - 3-5 creature/vibe combos. + - 5 emoji ideas. + + ## Write these files + After the user chooses, update: + + 1) IDENTITY.md + - Name + - Creature + - Vibe + - Emoji + + 2) USER.md + - Name + - Preferred address + - Pronouns (optional) + - Timezone (optional) + - Notes + + 3) ~/.clawdbot/moltbot.json + Set identity.name, identity.theme, identity.emoji to match IDENTITY.md. + + ## Cleanup + Delete BOOTSTRAP.md once this is complete. + """ + return self.loadTemplate(named: self.bootstrapFilename, fallback: fallback) + } + + private static func loadTemplate(named: String, fallback: String) -> String { + for url in self.templateURLs(named: named) { + if let content = try? String(contentsOf: url, encoding: .utf8) { + let stripped = self.stripFrontMatter(content) + if !stripped.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { + return stripped + } + } + } + return fallback + } + + private static func templateURLs(named: String) -> [URL] { + var urls: [URL] = [] + if let resource = Bundle.main.url( + forResource: named.replacingOccurrences(of: ".md", with: ""), + withExtension: "md", + subdirectory: self.templateDirname) + { + urls.append(resource) + } + if let resource = Bundle.main.url( + forResource: named, + withExtension: nil, + subdirectory: self.templateDirname) + { + urls.append(resource) + } + if let dev = self.devTemplateURL(named: named) { + urls.append(dev) + } + let cwd = URL(fileURLWithPath: FileManager().currentDirectoryPath) + urls.append(cwd.appendingPathComponent("docs") + .appendingPathComponent(self.templateDirname) + .appendingPathComponent(named)) + return urls + } + + private static func devTemplateURL(named: String) -> URL? { + let sourceURL = URL(fileURLWithPath: #filePath) + let repoRoot = sourceURL + .deletingLastPathComponent() + .deletingLastPathComponent() + .deletingLastPathComponent() + .deletingLastPathComponent() + .deletingLastPathComponent() + return repoRoot.appendingPathComponent("docs") + .appendingPathComponent(self.templateDirname) + .appendingPathComponent(named) + } + + private static func stripFrontMatter(_ content: String) -> String { + guard content.hasPrefix("---") else { return content } + let start = content.index(content.startIndex, offsetBy: 3) + guard let range = content.range(of: "\n---", range: start.. AnthropicAuthMode + { + if oauthStatus.isConnected { return .oauthFile } + + if let token = environment["ANTHROPIC_OAUTH_TOKEN"]?.trimmingCharacters(in: .whitespacesAndNewlines), + !token.isEmpty + { + return .oauthEnv + } + + if let key = environment["ANTHROPIC_API_KEY"]?.trimmingCharacters(in: .whitespacesAndNewlines), + !key.isEmpty + { + return .apiKeyEnv + } + + return .missing + } +} + +enum AnthropicOAuth { + private static let logger = Logger(subsystem: "bot.molt", category: "anthropic-oauth") + + private static let clientId = "9d1c250a-e61b-44d9-88ed-5944d1962f5e" + private static let authorizeURL = URL(string: "https://claude.ai/oauth/authorize")! + private static let tokenURL = URL(string: "https://console.anthropic.com/v1/oauth/token")! + private static let redirectURI = "https://console.anthropic.com/oauth/code/callback" + private static let scopes = "org:create_api_key user:profile user:inference" + + struct PKCE { + let verifier: String + let challenge: String + } + + static func generatePKCE() throws -> PKCE { + var bytes = [UInt8](repeating: 0, count: 32) + let status = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes) + guard status == errSecSuccess else { + throw NSError(domain: NSOSStatusErrorDomain, code: Int(status)) + } + let verifier = Data(bytes).base64URLEncodedString() + let hash = SHA256.hash(data: Data(verifier.utf8)) + let challenge = Data(hash).base64URLEncodedString() + return PKCE(verifier: verifier, challenge: challenge) + } + + static func buildAuthorizeURL(pkce: PKCE) -> URL { + var components = URLComponents(url: self.authorizeURL, resolvingAgainstBaseURL: false)! + components.queryItems = [ + URLQueryItem(name: "code", value: "true"), + URLQueryItem(name: "client_id", value: self.clientId), + URLQueryItem(name: "response_type", value: "code"), + URLQueryItem(name: "redirect_uri", value: self.redirectURI), + URLQueryItem(name: "scope", value: self.scopes), + URLQueryItem(name: "code_challenge", value: pkce.challenge), + URLQueryItem(name: "code_challenge_method", value: "S256"), + // Match legacy flow: state is the verifier. + URLQueryItem(name: "state", value: pkce.verifier), + ] + return components.url! + } + + static func exchangeCode( + code: String, + state: String, + verifier: String) async throws -> AnthropicOAuthCredentials + { + let payload: [String: Any] = [ + "grant_type": "authorization_code", + "client_id": self.clientId, + "code": code, + "state": state, + "redirect_uri": self.redirectURI, + "code_verifier": verifier, + ] + let body = try JSONSerialization.data(withJSONObject: payload, options: []) + + var request = URLRequest(url: self.tokenURL) + request.httpMethod = "POST" + request.httpBody = body + request.setValue("application/json", forHTTPHeaderField: "Content-Type") + + let (data, response) = try await URLSession.shared.data(for: request) + guard let http = response as? HTTPURLResponse else { + throw URLError(.badServerResponse) + } + guard (200..<300).contains(http.statusCode) else { + let text = String(data: data, encoding: .utf8) ?? "" + throw NSError( + domain: "AnthropicOAuth", + code: http.statusCode, + userInfo: [NSLocalizedDescriptionKey: "Token exchange failed: \(text)"]) + } + + let decoded = try JSONSerialization.jsonObject(with: data) as? [String: Any] + let access = decoded?["access_token"] as? String + let refresh = decoded?["refresh_token"] as? String + let expiresIn = decoded?["expires_in"] as? Double + guard let access, let refresh, let expiresIn else { + throw NSError(domain: "AnthropicOAuth", code: 0, userInfo: [ + NSLocalizedDescriptionKey: "Unexpected token response.", + ]) + } + + // Match legacy flow: expiresAt = now + expires_in - 5 minutes. + let expiresAtMs = Int64(Date().timeIntervalSince1970 * 1000) + + Int64(expiresIn * 1000) + - Int64(5 * 60 * 1000) + + self.logger.info("Anthropic OAuth exchange ok; expiresAtMs=\(expiresAtMs, privacy: .public)") + return AnthropicOAuthCredentials(type: "oauth", refresh: refresh, access: access, expires: expiresAtMs) + } + + static func refresh(refreshToken: String) async throws -> AnthropicOAuthCredentials { + let payload: [String: Any] = [ + "grant_type": "refresh_token", + "client_id": self.clientId, + "refresh_token": refreshToken, + ] + let body = try JSONSerialization.data(withJSONObject: payload, options: []) + + var request = URLRequest(url: self.tokenURL) + request.httpMethod = "POST" + request.httpBody = body + request.setValue("application/json", forHTTPHeaderField: "Content-Type") + + let (data, response) = try await URLSession.shared.data(for: request) + guard let http = response as? HTTPURLResponse else { + throw URLError(.badServerResponse) + } + guard (200..<300).contains(http.statusCode) else { + let text = String(data: data, encoding: .utf8) ?? "" + throw NSError( + domain: "AnthropicOAuth", + code: http.statusCode, + userInfo: [NSLocalizedDescriptionKey: "Token refresh failed: \(text)"]) + } + + let decoded = try JSONSerialization.jsonObject(with: data) as? [String: Any] + let access = decoded?["access_token"] as? String + let refresh = (decoded?["refresh_token"] as? String) ?? refreshToken + let expiresIn = decoded?["expires_in"] as? Double + guard let access, let expiresIn else { + throw NSError(domain: "AnthropicOAuth", code: 0, userInfo: [ + NSLocalizedDescriptionKey: "Unexpected token response.", + ]) + } + + let expiresAtMs = Int64(Date().timeIntervalSince1970 * 1000) + + Int64(expiresIn * 1000) + - Int64(5 * 60 * 1000) + + self.logger.info("Anthropic OAuth refresh ok; expiresAtMs=\(expiresAtMs, privacy: .public)") + return AnthropicOAuthCredentials(type: "oauth", refresh: refresh, access: access, expires: expiresAtMs) + } +} + +enum MoltbotOAuthStore { + static let oauthFilename = "oauth.json" + private static let providerKey = "anthropic" + private static let moltbotOAuthDirEnv = "CLAWDBOT_OAUTH_DIR" + private static let legacyPiDirEnv = "PI_CODING_AGENT_DIR" + + enum AnthropicOAuthStatus: Equatable { + case missingFile + case unreadableFile + case invalidJSON + case missingProviderEntry + case missingTokens + case connected(expiresAtMs: Int64?) + + var isConnected: Bool { + if case .connected = self { return true } + return false + } + + var shortDescription: String { + switch self { + case .missingFile: "Moltbot OAuth token file not found" + case .unreadableFile: "Moltbot OAuth token file not readable" + case .invalidJSON: "Moltbot OAuth token file invalid" + case .missingProviderEntry: "No Anthropic entry in Moltbot OAuth token file" + case .missingTokens: "Anthropic entry missing tokens" + case .connected: "Moltbot OAuth credentials found" + } + } + } + + static func oauthDir() -> URL { + if let override = ProcessInfo.processInfo.environment[self.clawdbotOAuthDirEnv]? + .trimmingCharacters(in: .whitespacesAndNewlines), + !override.isEmpty + { + let expanded = NSString(string: override).expandingTildeInPath + return URL(fileURLWithPath: expanded, isDirectory: true) + } + + return FileManager().homeDirectoryForCurrentUser + .appendingPathComponent(".clawdbot", isDirectory: true) + .appendingPathComponent("credentials", isDirectory: true) + } + + static func oauthURL() -> URL { + self.oauthDir().appendingPathComponent(self.oauthFilename) + } + + static func legacyOAuthURLs() -> [URL] { + var urls: [URL] = [] + let env = ProcessInfo.processInfo.environment + if let override = env[self.legacyPiDirEnv]?.trimmingCharacters(in: .whitespacesAndNewlines), + !override.isEmpty + { + let expanded = NSString(string: override).expandingTildeInPath + urls.append(URL(fileURLWithPath: expanded, isDirectory: true).appendingPathComponent(self.oauthFilename)) + } + + let home = FileManager().homeDirectoryForCurrentUser + urls.append(home.appendingPathComponent(".pi/agent/\(self.oauthFilename)")) + urls.append(home.appendingPathComponent(".claude/\(self.oauthFilename)")) + urls.append(home.appendingPathComponent(".config/claude/\(self.oauthFilename)")) + urls.append(home.appendingPathComponent(".config/anthropic/\(self.oauthFilename)")) + + var seen = Set() + return urls.filter { url in + let path = url.standardizedFileURL.path + if seen.contains(path) { return false } + seen.insert(path) + return true + } + } + + static func importLegacyAnthropicOAuthIfNeeded() -> URL? { + let dest = self.oauthURL() + guard !FileManager().fileExists(atPath: dest.path) else { return nil } + + for url in self.legacyOAuthURLs() { + guard FileManager().fileExists(atPath: url.path) else { continue } + guard self.anthropicOAuthStatus(at: url).isConnected else { continue } + guard let storage = self.loadStorage(at: url) else { continue } + do { + try self.saveStorage(storage) + return url + } catch { + continue + } + } + + return nil + } + + static func anthropicOAuthStatus() -> AnthropicOAuthStatus { + self.anthropicOAuthStatus(at: self.oauthURL()) + } + + static func hasAnthropicOAuth() -> Bool { + self.anthropicOAuthStatus().isConnected + } + + static func anthropicOAuthStatus(at url: URL) -> AnthropicOAuthStatus { + guard FileManager().fileExists(atPath: url.path) else { return .missingFile } + + guard let data = try? Data(contentsOf: url) else { return .unreadableFile } + guard let json = try? JSONSerialization.jsonObject(with: data, options: []) else { return .invalidJSON } + guard let storage = json as? [String: Any] else { return .invalidJSON } + guard let rawEntry = storage[self.providerKey] else { return .missingProviderEntry } + guard let entry = rawEntry as? [String: Any] else { return .invalidJSON } + + let refresh = self.firstString(in: entry, keys: ["refresh", "refresh_token", "refreshToken"]) + let access = self.firstString(in: entry, keys: ["access", "access_token", "accessToken"]) + guard refresh?.isEmpty == false, access?.isEmpty == false else { return .missingTokens } + + let expiresAny = entry["expires"] ?? entry["expires_at"] ?? entry["expiresAt"] + let expiresAtMs: Int64? = if let ms = expiresAny as? Int64 { + ms + } else if let number = expiresAny as? NSNumber { + number.int64Value + } else if let ms = expiresAny as? Double { + Int64(ms) + } else { + nil + } + + return .connected(expiresAtMs: expiresAtMs) + } + + static func loadAnthropicOAuthRefreshToken() -> String? { + let url = self.oauthURL() + guard let storage = self.loadStorage(at: url) else { return nil } + guard let rawEntry = storage[self.providerKey] as? [String: Any] else { return nil } + let refresh = self.firstString(in: rawEntry, keys: ["refresh", "refresh_token", "refreshToken"]) + return refresh?.trimmingCharacters(in: .whitespacesAndNewlines) + } + + private static func firstString(in dict: [String: Any], keys: [String]) -> String? { + for key in keys { + if let value = dict[key] as? String { return value } + } + return nil + } + + private static func loadStorage(at url: URL) -> [String: Any]? { + guard let data = try? Data(contentsOf: url) else { return nil } + guard let json = try? JSONSerialization.jsonObject(with: data, options: []) else { return nil } + return json as? [String: Any] + } + + static func saveAnthropicOAuth(_ creds: AnthropicOAuthCredentials) throws { + let url = self.oauthURL() + let existing: [String: Any] = self.loadStorage(at: url) ?? [:] + + var updated = existing + updated[self.providerKey] = [ + "type": creds.type, + "refresh": creds.refresh, + "access": creds.access, + "expires": creds.expires, + ] + + try self.saveStorage(updated) + } + + private static func saveStorage(_ storage: [String: Any]) throws { + let dir = self.oauthDir() + try FileManager().createDirectory( + at: dir, + withIntermediateDirectories: true, + attributes: [.posixPermissions: 0o700]) + + let url = self.oauthURL() + let data = try JSONSerialization.data( + withJSONObject: storage, + options: [.prettyPrinted, .sortedKeys]) + try data.write(to: url, options: [.atomic]) + try FileManager().setAttributes([.posixPermissions: 0o600], ofItemAtPath: url.path) + } +} + +extension Data { + fileprivate func base64URLEncodedString() -> String { + self.base64EncodedString() + .replacingOccurrences(of: "+", with: "-") + .replacingOccurrences(of: "/", with: "_") + .replacingOccurrences(of: "=", with: "") + } +} diff --git a/apps/macos/Sources/Moltbot/AudioInputDeviceObserver.swift b/apps/macos/Sources/Moltbot/AudioInputDeviceObserver.swift new file mode 100644 index 000000000..4411016f5 --- /dev/null +++ b/apps/macos/Sources/Moltbot/AudioInputDeviceObserver.swift @@ -0,0 +1,216 @@ +import CoreAudio +import Foundation +import OSLog + +final class AudioInputDeviceObserver { + private let logger = Logger(subsystem: "bot.molt", category: "audio.devices") + private var isActive = false + private var devicesListener: AudioObjectPropertyListenerBlock? + private var defaultInputListener: AudioObjectPropertyListenerBlock? + + static func defaultInputDeviceUID() -> String? { + let systemObject = AudioObjectID(kAudioObjectSystemObject) + var address = AudioObjectPropertyAddress( + mSelector: kAudioHardwarePropertyDefaultInputDevice, + mScope: kAudioObjectPropertyScopeGlobal, + mElement: kAudioObjectPropertyElementMain) + var deviceID = AudioObjectID(0) + var size = UInt32(MemoryLayout.size) + let status = AudioObjectGetPropertyData( + systemObject, + &address, + 0, + nil, + &size, + &deviceID) + guard status == noErr, deviceID != 0 else { return nil } + return self.deviceUID(for: deviceID) + } + + static func aliveInputDeviceUIDs() -> Set { + let systemObject = AudioObjectID(kAudioObjectSystemObject) + var address = AudioObjectPropertyAddress( + mSelector: kAudioHardwarePropertyDevices, + mScope: kAudioObjectPropertyScopeGlobal, + mElement: kAudioObjectPropertyElementMain) + var size: UInt32 = 0 + var status = AudioObjectGetPropertyDataSize(systemObject, &address, 0, nil, &size) + guard status == noErr, size > 0 else { return [] } + + let count = Int(size) / MemoryLayout.size + var deviceIDs = [AudioObjectID](repeating: 0, count: count) + status = AudioObjectGetPropertyData(systemObject, &address, 0, nil, &size, &deviceIDs) + guard status == noErr else { return [] } + + var output = Set() + for deviceID in deviceIDs { + guard self.deviceIsAlive(deviceID) else { continue } + guard self.deviceHasInput(deviceID) else { continue } + if let uid = self.deviceUID(for: deviceID) { + output.insert(uid) + } + } + return output + } + + static func defaultInputDeviceSummary() -> String { + let systemObject = AudioObjectID(kAudioObjectSystemObject) + var address = AudioObjectPropertyAddress( + mSelector: kAudioHardwarePropertyDefaultInputDevice, + mScope: kAudioObjectPropertyScopeGlobal, + mElement: kAudioObjectPropertyElementMain) + var deviceID = AudioObjectID(0) + var size = UInt32(MemoryLayout.size) + let status = AudioObjectGetPropertyData( + systemObject, + &address, + 0, + nil, + &size, + &deviceID) + guard status == noErr, deviceID != 0 else { + return "defaultInput=unknown" + } + let uid = self.deviceUID(for: deviceID) ?? "unknown" + let name = self.deviceName(for: deviceID) ?? "unknown" + return "defaultInput=\(name) (\(uid))" + } + + func start(onChange: @escaping @Sendable () -> Void) { + guard !self.isActive else { return } + self.isActive = true + + let systemObject = AudioObjectID(kAudioObjectSystemObject) + let queue = DispatchQueue.main + + var devicesAddress = AudioObjectPropertyAddress( + mSelector: kAudioHardwarePropertyDevices, + mScope: kAudioObjectPropertyScopeGlobal, + mElement: kAudioObjectPropertyElementMain) + let devicesListener: AudioObjectPropertyListenerBlock = { _, _ in + self.logDefaultInputChange(reason: "devices") + onChange() + } + let devicesStatus = AudioObjectAddPropertyListenerBlock( + systemObject, + &devicesAddress, + queue, + devicesListener) + + var defaultInputAddress = AudioObjectPropertyAddress( + mSelector: kAudioHardwarePropertyDefaultInputDevice, + mScope: kAudioObjectPropertyScopeGlobal, + mElement: kAudioObjectPropertyElementMain) + let defaultInputListener: AudioObjectPropertyListenerBlock = { _, _ in + self.logDefaultInputChange(reason: "default") + onChange() + } + let defaultStatus = AudioObjectAddPropertyListenerBlock( + systemObject, + &defaultInputAddress, + queue, + defaultInputListener) + + if devicesStatus != noErr || defaultStatus != noErr { + self.logger.error("audio device observer install failed devices=\(devicesStatus) default=\(defaultStatus)") + } + + self.logger.info("audio device observer started (\(Self.defaultInputDeviceSummary(), privacy: .public))") + + self.devicesListener = devicesListener + self.defaultInputListener = defaultInputListener + } + + func stop() { + guard self.isActive else { return } + self.isActive = false + let systemObject = AudioObjectID(kAudioObjectSystemObject) + + if let devicesListener { + var devicesAddress = AudioObjectPropertyAddress( + mSelector: kAudioHardwarePropertyDevices, + mScope: kAudioObjectPropertyScopeGlobal, + mElement: kAudioObjectPropertyElementMain) + _ = AudioObjectRemovePropertyListenerBlock( + systemObject, + &devicesAddress, + DispatchQueue.main, + devicesListener) + } + + if let defaultInputListener { + var defaultInputAddress = AudioObjectPropertyAddress( + mSelector: kAudioHardwarePropertyDefaultInputDevice, + mScope: kAudioObjectPropertyScopeGlobal, + mElement: kAudioObjectPropertyElementMain) + _ = AudioObjectRemovePropertyListenerBlock( + systemObject, + &defaultInputAddress, + DispatchQueue.main, + defaultInputListener) + } + + self.devicesListener = nil + self.defaultInputListener = nil + } + + private static func deviceUID(for deviceID: AudioObjectID) -> String? { + var address = AudioObjectPropertyAddress( + mSelector: kAudioDevicePropertyDeviceUID, + mScope: kAudioObjectPropertyScopeGlobal, + mElement: kAudioObjectPropertyElementMain) + var uid: Unmanaged? + var size = UInt32(MemoryLayout?>.size) + let status = AudioObjectGetPropertyData(deviceID, &address, 0, nil, &size, &uid) + guard status == noErr, let uid else { return nil } + return uid.takeUnretainedValue() as String + } + + private static func deviceName(for deviceID: AudioObjectID) -> String? { + var address = AudioObjectPropertyAddress( + mSelector: kAudioObjectPropertyName, + mScope: kAudioObjectPropertyScopeGlobal, + mElement: kAudioObjectPropertyElementMain) + var name: Unmanaged? + var size = UInt32(MemoryLayout?>.size) + let status = AudioObjectGetPropertyData(deviceID, &address, 0, nil, &size, &name) + guard status == noErr, let name else { return nil } + return name.takeUnretainedValue() as String + } + + private static func deviceIsAlive(_ deviceID: AudioObjectID) -> Bool { + var address = AudioObjectPropertyAddress( + mSelector: kAudioDevicePropertyDeviceIsAlive, + mScope: kAudioObjectPropertyScopeGlobal, + mElement: kAudioObjectPropertyElementMain) + var alive: UInt32 = 0 + var size = UInt32(MemoryLayout.size) + let status = AudioObjectGetPropertyData(deviceID, &address, 0, nil, &size, &alive) + return status == noErr && alive != 0 + } + + private static func deviceHasInput(_ deviceID: AudioObjectID) -> Bool { + var address = AudioObjectPropertyAddress( + mSelector: kAudioDevicePropertyStreamConfiguration, + mScope: kAudioDevicePropertyScopeInput, + mElement: kAudioObjectPropertyElementMain) + var size: UInt32 = 0 + var status = AudioObjectGetPropertyDataSize(deviceID, &address, 0, nil, &size) + guard status == noErr, size > 0 else { return false } + + let raw = UnsafeMutableRawPointer.allocate( + byteCount: Int(size), + alignment: MemoryLayout.alignment) + defer { raw.deallocate() } + let bufferList = raw.bindMemory(to: AudioBufferList.self, capacity: 1) + status = AudioObjectGetPropertyData(deviceID, &address, 0, nil, &size, bufferList) + guard status == noErr else { return false } + + let buffers = UnsafeMutableAudioBufferListPointer(bufferList) + return buffers.contains(where: { $0.mNumberChannels > 0 }) + } + + private func logDefaultInputChange(reason: StaticString) { + self.logger.info("audio input changed (\(reason)) (\(Self.defaultInputDeviceSummary(), privacy: .public))") + } +} diff --git a/apps/macos/Sources/Moltbot/CLIInstallPrompter.swift b/apps/macos/Sources/Moltbot/CLIInstallPrompter.swift new file mode 100644 index 000000000..b091fc8b5 --- /dev/null +++ b/apps/macos/Sources/Moltbot/CLIInstallPrompter.swift @@ -0,0 +1,84 @@ +import AppKit +import Foundation +import OSLog + +@MainActor +final class CLIInstallPrompter { + static let shared = CLIInstallPrompter() + private let logger = Logger(subsystem: "bot.molt", category: "cli.prompt") + private var isPrompting = false + + func checkAndPromptIfNeeded(reason: String) { + guard self.shouldPrompt() else { return } + guard let version = Self.appVersion() else { return } + self.isPrompting = true + UserDefaults.standard.set(version, forKey: cliInstallPromptedVersionKey) + + let alert = NSAlert() + alert.messageText = "Install Moltbot CLI?" + alert.informativeText = "Local mode needs the CLI so launchd can run the gateway." + alert.addButton(withTitle: "Install CLI") + alert.addButton(withTitle: "Not now") + alert.addButton(withTitle: "Open Settings") + let response = alert.runModal() + + switch response { + case .alertFirstButtonReturn: + Task { await self.installCLI() } + case .alertThirdButtonReturn: + self.openSettings(tab: .general) + default: + break + } + + self.logger.debug("cli install prompt handled reason=\(reason, privacy: .public)") + self.isPrompting = false + } + + private func shouldPrompt() -> Bool { + guard !self.isPrompting else { return false } + guard AppStateStore.shared.onboardingSeen else { return false } + guard AppStateStore.shared.connectionMode == .local else { return false } + guard CLIInstaller.installedLocation() == nil else { return false } + guard let version = Self.appVersion() else { return false } + let lastPrompt = UserDefaults.standard.string(forKey: cliInstallPromptedVersionKey) + return lastPrompt != version + } + + private func installCLI() async { + let status = StatusBox() + await CLIInstaller.install { message in + await status.set(message) + } + if let message = await status.get() { + let alert = NSAlert() + alert.messageText = "CLI install finished" + alert.informativeText = message + alert.runModal() + } + } + + private func openSettings(tab: SettingsTab) { + SettingsTabRouter.request(tab) + SettingsWindowOpener.shared.open() + DispatchQueue.main.async { + NotificationCenter.default.post(name: .clawdbotSelectSettingsTab, object: tab) + } + } + + private static func appVersion() -> String? { + Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String + } +} + +private actor StatusBox { + private var value: String? + + func set(_ value: String) { + self.value = value + } + + func get() -> String? { + self.value + } +} diff --git a/apps/macos/Sources/Moltbot/CameraCaptureService.swift b/apps/macos/Sources/Moltbot/CameraCaptureService.swift new file mode 100644 index 000000000..ee70a3006 --- /dev/null +++ b/apps/macos/Sources/Moltbot/CameraCaptureService.swift @@ -0,0 +1,425 @@ +import AVFoundation +import MoltbotIPC +import MoltbotKit +import CoreGraphics +import Foundation +import OSLog + +actor CameraCaptureService { + struct CameraDeviceInfo: Encodable, Sendable { + let id: String + let name: String + let position: String + let deviceType: String + } + + enum CameraError: LocalizedError, Sendable { + case cameraUnavailable + case microphoneUnavailable + case permissionDenied(kind: String) + case captureFailed(String) + case exportFailed(String) + + var errorDescription: String? { + switch self { + case .cameraUnavailable: + "Camera unavailable" + case .microphoneUnavailable: + "Microphone unavailable" + case let .permissionDenied(kind): + "\(kind) permission denied" + case let .captureFailed(msg): + msg + case let .exportFailed(msg): + msg + } + } + } + + private let logger = Logger(subsystem: "bot.molt", category: "camera") + + func listDevices() -> [CameraDeviceInfo] { + Self.availableCameras().map { device in + CameraDeviceInfo( + id: device.uniqueID, + name: device.localizedName, + position: Self.positionLabel(device.position), + deviceType: device.deviceType.rawValue) + } + } + + func snap( + facing: CameraFacing?, + maxWidth: Int?, + quality: Double?, + deviceId: String?, + delayMs: Int) async throws -> (data: Data, size: CGSize) + { + let facing = facing ?? .front + let normalized = Self.normalizeSnap(maxWidth: maxWidth, quality: quality) + let maxWidth = normalized.maxWidth + let quality = normalized.quality + let delayMs = max(0, delayMs) + let deviceId = deviceId?.trimmingCharacters(in: .whitespacesAndNewlines) + + try await self.ensureAccess(for: .video) + + let session = AVCaptureSession() + session.sessionPreset = .photo + + guard let device = Self.pickCamera(facing: facing, deviceId: deviceId) else { + throw CameraError.cameraUnavailable + } + + let input = try AVCaptureDeviceInput(device: device) + guard session.canAddInput(input) else { + throw CameraError.captureFailed("Failed to add camera input") + } + session.addInput(input) + + let output = AVCapturePhotoOutput() + guard session.canAddOutput(output) else { + throw CameraError.captureFailed("Failed to add photo output") + } + session.addOutput(output) + output.maxPhotoQualityPrioritization = .quality + + session.startRunning() + defer { session.stopRunning() } + await Self.warmUpCaptureSession() + await self.waitForExposureAndWhiteBalance(device: device) + await self.sleepDelayMs(delayMs) + + let settings: AVCapturePhotoSettings = { + if output.availablePhotoCodecTypes.contains(.jpeg) { + return AVCapturePhotoSettings(format: [AVVideoCodecKey: AVVideoCodecType.jpeg]) + } + return AVCapturePhotoSettings() + }() + settings.photoQualityPrioritization = .quality + + var delegate: PhotoCaptureDelegate? + let rawData: Data = try await withCheckedThrowingContinuation { cont in + let d = PhotoCaptureDelegate(cont) + delegate = d + output.capturePhoto(with: settings, delegate: d) + } + withExtendedLifetime(delegate) {} + + let maxPayloadBytes = 5 * 1024 * 1024 + // Base64 inflates payloads by ~4/3; cap encoded bytes so the payload stays under 5MB (API limit). + let maxEncodedBytes = (maxPayloadBytes / 4) * 3 + let res = try JPEGTranscoder.transcodeToJPEG( + imageData: rawData, + maxWidthPx: maxWidth, + quality: quality, + maxBytes: maxEncodedBytes) + return (data: res.data, size: CGSize(width: res.widthPx, height: res.heightPx)) + } + + func clip( + facing: CameraFacing?, + durationMs: Int?, + includeAudio: Bool, + deviceId: String?, + outPath: String?) async throws -> (path: String, durationMs: Int, hasAudio: Bool) + { + let facing = facing ?? .front + let durationMs = Self.clampDurationMs(durationMs) + let deviceId = deviceId?.trimmingCharacters(in: .whitespacesAndNewlines) + + try await self.ensureAccess(for: .video) + if includeAudio { + try await self.ensureAccess(for: .audio) + } + + let session = AVCaptureSession() + session.sessionPreset = .high + + guard let camera = Self.pickCamera(facing: facing, deviceId: deviceId) else { + throw CameraError.cameraUnavailable + } + let cameraInput = try AVCaptureDeviceInput(device: camera) + guard session.canAddInput(cameraInput) else { + throw CameraError.captureFailed("Failed to add camera input") + } + session.addInput(cameraInput) + + if includeAudio { + guard let mic = AVCaptureDevice.default(for: .audio) else { + throw CameraError.microphoneUnavailable + } + let micInput = try AVCaptureDeviceInput(device: mic) + guard session.canAddInput(micInput) else { + throw CameraError.captureFailed("Failed to add microphone input") + } + session.addInput(micInput) + } + + let output = AVCaptureMovieFileOutput() + guard session.canAddOutput(output) else { + throw CameraError.captureFailed("Failed to add movie output") + } + session.addOutput(output) + output.maxRecordedDuration = CMTime(value: Int64(durationMs), timescale: 1000) + + session.startRunning() + defer { session.stopRunning() } + await Self.warmUpCaptureSession() + + let tmpMovURL = FileManager().temporaryDirectory + .appendingPathComponent("moltbot-camera-\(UUID().uuidString).mov") + defer { try? FileManager().removeItem(at: tmpMovURL) } + + let outputURL: URL = { + if let outPath, !outPath.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { + return URL(fileURLWithPath: outPath) + } + return FileManager().temporaryDirectory + .appendingPathComponent("moltbot-camera-\(UUID().uuidString).mp4") + }() + + // Ensure we don't fail exporting due to an existing file. + try? FileManager().removeItem(at: outputURL) + + let logger = self.logger + var delegate: MovieFileDelegate? + let recordedURL: URL = try await withCheckedThrowingContinuation { cont in + let d = MovieFileDelegate(cont, logger: logger) + delegate = d + output.startRecording(to: tmpMovURL, recordingDelegate: d) + } + withExtendedLifetime(delegate) {} + + try await Self.exportToMP4(inputURL: recordedURL, outputURL: outputURL) + return (path: outputURL.path, durationMs: durationMs, hasAudio: includeAudio) + } + + private func ensureAccess(for mediaType: AVMediaType) async throws { + let status = AVCaptureDevice.authorizationStatus(for: mediaType) + switch status { + case .authorized: + return + case .notDetermined: + let ok = await withCheckedContinuation(isolation: nil) { cont in + AVCaptureDevice.requestAccess(for: mediaType) { granted in + cont.resume(returning: granted) + } + } + if !ok { + throw CameraError.permissionDenied(kind: mediaType == .video ? "Camera" : "Microphone") + } + case .denied, .restricted: + throw CameraError.permissionDenied(kind: mediaType == .video ? "Camera" : "Microphone") + @unknown default: + throw CameraError.permissionDenied(kind: mediaType == .video ? "Camera" : "Microphone") + } + } + + private nonisolated static func availableCameras() -> [AVCaptureDevice] { + var types: [AVCaptureDevice.DeviceType] = [ + .builtInWideAngleCamera, + .continuityCamera, + ] + if let external = externalDeviceType() { + types.append(external) + } + let session = AVCaptureDevice.DiscoverySession( + deviceTypes: types, + mediaType: .video, + position: .unspecified) + return session.devices + } + + private nonisolated static func externalDeviceType() -> AVCaptureDevice.DeviceType? { + if #available(macOS 14.0, *) { + return .external + } + // Use raw value to avoid deprecated symbol in the SDK. + return AVCaptureDevice.DeviceType(rawValue: "AVCaptureDeviceTypeExternalUnknown") + } + + private nonisolated static func pickCamera( + facing: CameraFacing, + deviceId: String?) -> AVCaptureDevice? + { + if let deviceId, !deviceId.isEmpty { + if let match = availableCameras().first(where: { $0.uniqueID == deviceId }) { + return match + } + } + let position: AVCaptureDevice.Position = (facing == .front) ? .front : .back + + if let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: position) { + return device + } + + // Many macOS cameras report `unspecified` position; fall back to any default. + return AVCaptureDevice.default(for: .video) + } + + private nonisolated static func clampQuality(_ quality: Double?) -> Double { + let q = quality ?? 0.9 + return min(1.0, max(0.05, q)) + } + + nonisolated static func normalizeSnap(maxWidth: Int?, quality: Double?) -> (maxWidth: Int, quality: Double) { + // Default to a reasonable max width to keep downstream payload sizes manageable. + // If you need full-res, explicitly request a larger maxWidth. + let maxWidth = maxWidth.flatMap { $0 > 0 ? $0 : nil } ?? 1600 + let quality = Self.clampQuality(quality) + return (maxWidth: maxWidth, quality: quality) + } + + private nonisolated static func clampDurationMs(_ ms: Int?) -> Int { + let v = ms ?? 3000 + return min(60000, max(250, v)) + } + + private nonisolated static func exportToMP4(inputURL: URL, outputURL: URL) async throws { + let asset = AVURLAsset(url: inputURL) + guard let export = AVAssetExportSession(asset: asset, presetName: AVAssetExportPresetMediumQuality) else { + throw CameraError.exportFailed("Failed to create export session") + } + export.shouldOptimizeForNetworkUse = true + + if #available(macOS 15.0, *) { + do { + try await export.export(to: outputURL, as: .mp4) + return + } catch { + throw CameraError.exportFailed(error.localizedDescription) + } + } else { + export.outputURL = outputURL + export.outputFileType = .mp4 + + try await withCheckedThrowingContinuation(isolation: nil) { (cont: CheckedContinuation) in + export.exportAsynchronously { + cont.resume(returning: ()) + } + } + + switch export.status { + case .completed: + return + case .failed: + throw CameraError.exportFailed(export.error?.localizedDescription ?? "export failed") + case .cancelled: + throw CameraError.exportFailed("export cancelled") + default: + throw CameraError.exportFailed("export did not complete (\(export.status.rawValue))") + } + } + } + + private nonisolated static func warmUpCaptureSession() async { + // A short delay after `startRunning()` significantly reduces "blank first frame" captures on some devices. + try? await Task.sleep(nanoseconds: 150_000_000) // 150ms + } + + private func waitForExposureAndWhiteBalance(device: AVCaptureDevice) async { + let stepNs: UInt64 = 50_000_000 + let maxSteps = 30 // ~1.5s + for _ in 0.. 0 else { return } + let ns = UInt64(min(delayMs, 10000)) * 1_000_000 + try? await Task.sleep(nanoseconds: ns) + } + + private nonisolated static func positionLabel(_ position: AVCaptureDevice.Position) -> String { + switch position { + case .front: "front" + case .back: "back" + default: "unspecified" + } + } +} + +private final class PhotoCaptureDelegate: NSObject, AVCapturePhotoCaptureDelegate { + private var cont: CheckedContinuation? + private var didResume = false + + init(_ cont: CheckedContinuation) { + self.cont = cont + } + + func photoOutput( + _ output: AVCapturePhotoOutput, + didFinishProcessingPhoto photo: AVCapturePhoto, + error: Error?) + { + guard !self.didResume, let cont else { return } + self.didResume = true + self.cont = nil + if let error { + cont.resume(throwing: error) + return + } + guard let data = photo.fileDataRepresentation() else { + cont.resume(throwing: CameraCaptureService.CameraError.captureFailed("No photo data")) + return + } + if data.isEmpty { + cont.resume(throwing: CameraCaptureService.CameraError.captureFailed("Photo data empty")) + return + } + cont.resume(returning: data) + } + + func photoOutput( + _ output: AVCapturePhotoOutput, + didFinishCaptureFor resolvedSettings: AVCaptureResolvedPhotoSettings, + error: Error?) + { + guard let error else { return } + guard !self.didResume, let cont else { return } + self.didResume = true + self.cont = nil + cont.resume(throwing: error) + } +} + +private final class MovieFileDelegate: NSObject, AVCaptureFileOutputRecordingDelegate { + private var cont: CheckedContinuation? + private let logger: Logger + + init(_ cont: CheckedContinuation, logger: Logger) { + self.cont = cont + self.logger = logger + } + + func fileOutput( + _ output: AVCaptureFileOutput, + didFinishRecordingTo outputFileURL: URL, + from connections: [AVCaptureConnection], + error: Error?) + { + guard let cont else { return } + self.cont = nil + + if let error { + let ns = error as NSError + if ns.domain == AVFoundationErrorDomain, + ns.code == AVError.maximumDurationReached.rawValue + { + cont.resume(returning: outputFileURL) + return + } + + self.logger.error("camera record failed: \(error.localizedDescription, privacy: .public)") + cont.resume(throwing: error) + return + } + + cont.resume(returning: outputFileURL) + } +} diff --git a/apps/macos/Sources/Moltbot/CanvasFileWatcher.swift b/apps/macos/Sources/Moltbot/CanvasFileWatcher.swift new file mode 100644 index 000000000..bef341fdc --- /dev/null +++ b/apps/macos/Sources/Moltbot/CanvasFileWatcher.swift @@ -0,0 +1,94 @@ +import CoreServices +import Foundation + +final class CanvasFileWatcher: @unchecked Sendable { + private let url: URL + private let queue: DispatchQueue + private var stream: FSEventStreamRef? + private var pending = false + private let onChange: () -> Void + + init(url: URL, onChange: @escaping () -> Void) { + self.url = url + self.queue = DispatchQueue(label: "bot.molt.canvaswatcher") + self.onChange = onChange + } + + deinit { + self.stop() + } + + func start() { + guard self.stream == nil else { return } + + let retainedSelf = Unmanaged.passRetained(self) + var context = FSEventStreamContext( + version: 0, + info: retainedSelf.toOpaque(), + retain: nil, + release: { pointer in + guard let pointer else { return } + Unmanaged.fromOpaque(pointer).release() + }, + copyDescription: nil) + + let paths = [self.url.path] as CFArray + let flags = FSEventStreamCreateFlags( + kFSEventStreamCreateFlagFileEvents | + kFSEventStreamCreateFlagUseCFTypes | + kFSEventStreamCreateFlagNoDefer) + + guard let stream = FSEventStreamCreate( + kCFAllocatorDefault, + Self.callback, + &context, + paths, + FSEventStreamEventId(kFSEventStreamEventIdSinceNow), + 0.05, + flags) + else { + retainedSelf.release() + return + } + + self.stream = stream + FSEventStreamSetDispatchQueue(stream, self.queue) + if FSEventStreamStart(stream) == false { + self.stream = nil + FSEventStreamSetDispatchQueue(stream, nil) + FSEventStreamInvalidate(stream) + FSEventStreamRelease(stream) + } + } + + func stop() { + guard let stream = self.stream else { return } + self.stream = nil + FSEventStreamStop(stream) + FSEventStreamSetDispatchQueue(stream, nil) + FSEventStreamInvalidate(stream) + FSEventStreamRelease(stream) + } +} + +extension CanvasFileWatcher { + private static let callback: FSEventStreamCallback = { _, info, numEvents, _, eventFlags, _ in + guard let info else { return } + let watcher = Unmanaged.fromOpaque(info).takeUnretainedValue() + watcher.handleEvents(numEvents: numEvents, eventFlags: eventFlags) + } + + private func handleEvents(numEvents: Int, eventFlags: UnsafePointer?) { + guard numEvents > 0 else { return } + guard eventFlags != nil else { return } + + // Coalesce rapid changes (common during builds/atomic saves). + if self.pending { return } + self.pending = true + self.queue.asyncAfter(deadline: .now() + 0.12) { [weak self] in + guard let self else { return } + self.pending = false + self.onChange() + } + } +} diff --git a/apps/macos/Sources/Moltbot/CanvasManager.swift b/apps/macos/Sources/Moltbot/CanvasManager.swift new file mode 100644 index 000000000..8100934ab --- /dev/null +++ b/apps/macos/Sources/Moltbot/CanvasManager.swift @@ -0,0 +1,342 @@ +import AppKit +import MoltbotIPC +import MoltbotKit +import Foundation +import OSLog + +@MainActor +final class CanvasManager { + static let shared = CanvasManager() + + private static let logger = Logger(subsystem: "bot.molt", category: "CanvasManager") + + private var panelController: CanvasWindowController? + private var panelSessionKey: String? + private var lastAutoA2UIUrl: String? + private var gatewayWatchTask: Task? + + private init() { + self.startGatewayObserver() + } + + var onPanelVisibilityChanged: ((Bool) -> Void)? + + /// Optional anchor provider (e.g. menu bar status item). If nil, Canvas anchors to the mouse cursor. + var defaultAnchorProvider: (() -> NSRect?)? + + private nonisolated static let canvasRoot: URL = { + let base = FileManager().urls(for: .applicationSupportDirectory, in: .userDomainMask).first! + return base.appendingPathComponent("Moltbot/canvas", isDirectory: true) + }() + + func show(sessionKey: String, path: String? = nil, placement: CanvasPlacement? = nil) throws -> String { + try self.showDetailed(sessionKey: sessionKey, target: path, placement: placement).directory + } + + func showDetailed( + sessionKey: String, + target: String? = nil, + placement: CanvasPlacement? = nil) throws -> CanvasShowResult + { + Self.logger.debug( + """ + showDetailed start session=\(sessionKey, privacy: .public) \ + target=\(target ?? "", privacy: .public) \ + placement=\(placement != nil) + """) + let anchorProvider = self.defaultAnchorProvider ?? Self.mouseAnchorProvider + let session = sessionKey.trimmingCharacters(in: .whitespacesAndNewlines) + let normalizedTarget = target? + .trimmingCharacters(in: .whitespacesAndNewlines) + .nonEmpty + + if let controller = self.panelController, self.panelSessionKey == session { + Self.logger.debug("showDetailed reuse existing session=\(session, privacy: .public)") + controller.onVisibilityChanged = { [weak self] visible in + self?.onPanelVisibilityChanged?(visible) + } + controller.presentAnchoredPanel(anchorProvider: anchorProvider) + controller.applyPreferredPlacement(placement) + self.refreshDebugStatus() + + // Existing session: only navigate when an explicit target was provided. + if let normalizedTarget { + controller.load(target: normalizedTarget) + return self.makeShowResult( + directory: controller.directoryPath, + target: target, + effectiveTarget: normalizedTarget) + } + + self.maybeAutoNavigateToA2UIAsync(controller: controller) + return CanvasShowResult( + directory: controller.directoryPath, + target: target, + effectiveTarget: nil, + status: .shown, + url: nil) + } + + Self.logger.debug("showDetailed creating new session=\(session, privacy: .public)") + self.panelController?.close() + self.panelController = nil + self.panelSessionKey = nil + + Self.logger.debug("showDetailed ensure canvas root dir") + try FileManager().createDirectory(at: Self.canvasRoot, withIntermediateDirectories: true) + Self.logger.debug("showDetailed init CanvasWindowController") + let controller = try CanvasWindowController( + sessionKey: session, + root: Self.canvasRoot, + presentation: .panel(anchorProvider: anchorProvider)) + Self.logger.debug("showDetailed CanvasWindowController init done") + controller.onVisibilityChanged = { [weak self] visible in + self?.onPanelVisibilityChanged?(visible) + } + self.panelController = controller + self.panelSessionKey = session + controller.applyPreferredPlacement(placement) + + // New session: default to "/" so the user sees either the welcome page or `index.html`. + let effectiveTarget = normalizedTarget ?? "/" + Self.logger.debug("showDetailed showCanvas effectiveTarget=\(effectiveTarget, privacy: .public)") + controller.showCanvas(path: effectiveTarget) + Self.logger.debug("showDetailed showCanvas done") + if normalizedTarget == nil { + self.maybeAutoNavigateToA2UIAsync(controller: controller) + } + self.refreshDebugStatus() + + return self.makeShowResult( + directory: controller.directoryPath, + target: target, + effectiveTarget: effectiveTarget) + } + + func hide(sessionKey: String) { + let session = sessionKey.trimmingCharacters(in: .whitespacesAndNewlines) + guard self.panelSessionKey == session else { return } + self.panelController?.hideCanvas() + } + + func hideAll() { + self.panelController?.hideCanvas() + } + + func eval(sessionKey: String, javaScript: String) async throws -> String { + _ = try self.show(sessionKey: sessionKey, path: nil) + guard let controller = self.panelController else { return "" } + return try await controller.eval(javaScript: javaScript) + } + + func snapshot(sessionKey: String, outPath: String?) async throws -> String { + _ = try self.show(sessionKey: sessionKey, path: nil) + guard let controller = self.panelController else { + throw NSError(domain: "Canvas", code: 21, userInfo: [NSLocalizedDescriptionKey: "canvas not available"]) + } + return try await controller.snapshot(to: outPath) + } + + // MARK: - Gateway A2UI auto-nav + + private func startGatewayObserver() { + self.gatewayWatchTask?.cancel() + self.gatewayWatchTask = Task { [weak self] in + guard let self else { return } + let stream = await GatewayConnection.shared.subscribe(bufferingNewest: 1) + for await push in stream { + self.handleGatewayPush(push) + } + } + } + + private func handleGatewayPush(_ push: GatewayPush) { + guard case let .snapshot(snapshot) = push else { return } + let raw = snapshot.canvashosturl?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if raw.isEmpty { + Self.logger.debug("canvas host url missing in gateway snapshot") + } else { + Self.logger.debug("canvas host url snapshot=\(raw, privacy: .public)") + } + let a2uiUrl = Self.resolveA2UIHostUrl(from: raw) + if a2uiUrl == nil, !raw.isEmpty { + Self.logger.debug("canvas host url invalid; cannot resolve A2UI") + } + guard let controller = self.panelController else { + if a2uiUrl != nil { + Self.logger.debug("canvas panel not visible; skipping auto-nav") + } + return + } + self.maybeAutoNavigateToA2UI(controller: controller, a2uiUrl: a2uiUrl) + } + + private func maybeAutoNavigateToA2UIAsync(controller: CanvasWindowController) { + Task { [weak self] in + guard let self else { return } + let a2uiUrl = await self.resolveA2UIHostUrl() + await MainActor.run { + guard self.panelController === controller else { return } + self.maybeAutoNavigateToA2UI(controller: controller, a2uiUrl: a2uiUrl) + } + } + } + + private func maybeAutoNavigateToA2UI(controller: CanvasWindowController, a2uiUrl: String?) { + guard let a2uiUrl else { return } + let shouldNavigate = controller.shouldAutoNavigateToA2UI(lastAutoTarget: self.lastAutoA2UIUrl) + guard shouldNavigate else { + Self.logger.debug("canvas auto-nav skipped; target unchanged") + return + } + Self.logger.debug("canvas auto-nav -> \(a2uiUrl, privacy: .public)") + controller.load(target: a2uiUrl) + self.lastAutoA2UIUrl = a2uiUrl + } + + private func resolveA2UIHostUrl() async -> String? { + let raw = await GatewayConnection.shared.canvasHostUrl() + return Self.resolveA2UIHostUrl(from: raw) + } + + func refreshDebugStatus() { + guard let controller = self.panelController else { return } + let enabled = AppStateStore.shared.debugPaneEnabled + let mode = AppStateStore.shared.connectionMode + let title: String? + let subtitle: String? + switch mode { + case .remote: + title = "Remote control" + switch ControlChannel.shared.state { + case .connected: + subtitle = "Connected" + case .connecting: + subtitle = "Connecting…" + case .disconnected: + subtitle = "Disconnected" + case let .degraded(message): + subtitle = message.isEmpty ? "Degraded" : message + } + case .local: + title = GatewayProcessManager.shared.status.label + subtitle = mode.rawValue + case .unconfigured: + title = "Unconfigured" + subtitle = mode.rawValue + } + controller.updateDebugStatus(enabled: enabled, title: title, subtitle: subtitle) + } + + private static func resolveA2UIHostUrl(from raw: String?) -> String? { + let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + guard !trimmed.isEmpty, let base = URL(string: trimmed) else { return nil } + return base.appendingPathComponent("__moltbot__/a2ui/").absoluteString + "?platform=macos" + } + + // MARK: - Anchoring + + private static func mouseAnchorProvider() -> NSRect? { + let pt = NSEvent.mouseLocation + return NSRect(x: pt.x, y: pt.y, width: 1, height: 1) + } + + // placement interpretation is handled by the window controller. + + // MARK: - Helpers + + private static func directURL(for target: String?) -> URL? { + guard let target else { return nil } + let trimmed = target.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return nil } + + if let url = URL(string: trimmed), let scheme = url.scheme?.lowercased() { + if scheme == "https" || scheme == "http" || scheme == "file" { return url } + } + + // Convenience: existing absolute *file* paths resolve as local files. + // (Avoid treating Canvas routes like "/" as filesystem paths.) + if trimmed.hasPrefix("/") { + var isDir: ObjCBool = false + if FileManager().fileExists(atPath: trimmed, isDirectory: &isDir), !isDir.boolValue { + return URL(fileURLWithPath: trimmed) + } + } + + return nil + } + + private func makeShowResult( + directory: String, + target: String?, + effectiveTarget: String) -> CanvasShowResult + { + if let url = Self.directURL(for: effectiveTarget) { + return CanvasShowResult( + directory: directory, + target: target, + effectiveTarget: effectiveTarget, + status: .web, + url: url.absoluteString) + } + + let sessionDir = URL(fileURLWithPath: directory) + let status = Self.localStatus(sessionDir: sessionDir, target: effectiveTarget) + let host = sessionDir.lastPathComponent + let canvasURL = CanvasScheme.makeURL(session: host, path: effectiveTarget)?.absoluteString + return CanvasShowResult( + directory: directory, + target: target, + effectiveTarget: effectiveTarget, + status: status, + url: canvasURL) + } + + private static func localStatus(sessionDir: URL, target: String) -> CanvasShowStatus { + let fm = FileManager() + let trimmed = target.trimmingCharacters(in: .whitespacesAndNewlines) + let withoutQuery = trimmed.split(separator: "?", maxSplits: 1, omittingEmptySubsequences: false).first + .map(String.init) ?? trimmed + var path = withoutQuery + if path.hasPrefix("/") { path.removeFirst() } + path = path.removingPercentEncoding ?? path + + // Root special-case: built-in scaffold page when no index exists. + if path.isEmpty { + let a = sessionDir.appendingPathComponent("index.html", isDirectory: false) + let b = sessionDir.appendingPathComponent("index.htm", isDirectory: false) + if fm.fileExists(atPath: a.path) || fm.fileExists(atPath: b.path) { return .ok } + return .welcome + } + + // Direct file or directory. + var candidate = sessionDir.appendingPathComponent(path, isDirectory: false) + var isDir: ObjCBool = false + if fm.fileExists(atPath: candidate.path, isDirectory: &isDir) { + if isDir.boolValue { + return Self.indexExists(in: candidate) ? .ok : .notFound + } + return .ok + } + + // Directory index behavior ("/yolo" -> "yolo/index.html") if directory exists. + if !path.isEmpty, !path.hasSuffix("/") { + candidate = sessionDir.appendingPathComponent(path, isDirectory: true) + if fm.fileExists(atPath: candidate.path, isDirectory: &isDir), isDir.boolValue { + return Self.indexExists(in: candidate) ? .ok : .notFound + } + } + + return .notFound + } + + private static func indexExists(in dir: URL) -> Bool { + let fm = FileManager() + let a = dir.appendingPathComponent("index.html", isDirectory: false) + if fm.fileExists(atPath: a.path) { return true } + let b = dir.appendingPathComponent("index.htm", isDirectory: false) + return fm.fileExists(atPath: b.path) + } + + // no bundled A2UI shell; scaffold fallback is purely visual +} diff --git a/apps/macos/Sources/Moltbot/CanvasSchemeHandler.swift b/apps/macos/Sources/Moltbot/CanvasSchemeHandler.swift new file mode 100644 index 000000000..3e47026a2 --- /dev/null +++ b/apps/macos/Sources/Moltbot/CanvasSchemeHandler.swift @@ -0,0 +1,259 @@ +import MoltbotKit +import Foundation +import OSLog +import WebKit + +private let canvasLogger = Logger(subsystem: "bot.molt", category: "Canvas") + +final class CanvasSchemeHandler: NSObject, WKURLSchemeHandler { + private let root: URL + + init(root: URL) { + self.root = root + } + + func webView(_: WKWebView, start urlSchemeTask: WKURLSchemeTask) { + guard let url = urlSchemeTask.request.url else { + urlSchemeTask.didFailWithError(NSError(domain: "Canvas", code: 1, userInfo: [ + NSLocalizedDescriptionKey: "missing url", + ])) + return + } + + let response = self.response(for: url) + let mime = response.mime + let data = response.data + let encoding = self.textEncodingName(forMimeType: mime) + + let urlResponse = URLResponse( + url: url, + mimeType: mime, + expectedContentLength: data.count, + textEncodingName: encoding) + urlSchemeTask.didReceive(urlResponse) + urlSchemeTask.didReceive(data) + urlSchemeTask.didFinish() + } + + func webView(_: WKWebView, stop _: WKURLSchemeTask) { + // no-op + } + + private struct CanvasResponse { + let mime: String + let data: Data + } + + private func response(for url: URL) -> CanvasResponse { + guard url.scheme == CanvasScheme.scheme else { + return self.html("Invalid scheme.") + } + guard let session = url.host, !session.isEmpty else { + return self.html("Missing session.") + } + + // Keep session component safe; don't allow slashes or traversal. + if session.contains("/") || session.contains("..") { + return self.html("Invalid session.") + } + + let sessionRoot = self.root.appendingPathComponent(session, isDirectory: true) + + // Path mapping: request path maps directly into the session dir. + var path = url.path + if let qIdx = path.firstIndex(of: "?") { path = String(path[.. \(servedPath, privacy: .public)") + return CanvasResponse(mime: mime, data: data) + } catch { + let failedPath = standardizedFile.path + let errorText = error.localizedDescription + canvasLogger + .error( + "failed reading \(failedPath, privacy: .public): \(errorText, privacy: .public)") + return self.html("Failed to read file.", title: "Canvas error") + } + } + + private func resolveFileURL(sessionRoot: URL, requestPath: String) -> URL? { + let fm = FileManager() + var candidate = sessionRoot.appendingPathComponent(requestPath, isDirectory: false) + + var isDir: ObjCBool = false + if fm.fileExists(atPath: candidate.path, isDirectory: &isDir) { + if isDir.boolValue { + if let idx = self.resolveIndex(in: candidate) { return idx } + return nil + } + return candidate + } + + // Directory index behavior: + // - "/yolo" serves "/index.html" if that directory exists. + if !requestPath.isEmpty, !requestPath.hasSuffix("/") { + candidate = sessionRoot.appendingPathComponent(requestPath, isDirectory: true) + if fm.fileExists(atPath: candidate.path, isDirectory: &isDir), isDir.boolValue { + if let idx = self.resolveIndex(in: candidate) { return idx } + } + } + + // Root fallback: + // - "/" serves "/index.html" if present. + if requestPath.isEmpty { + return self.resolveIndex(in: sessionRoot) + } + + return nil + } + + private func resolveIndex(in dir: URL) -> URL? { + let fm = FileManager() + let a = dir.appendingPathComponent("index.html", isDirectory: false) + if fm.fileExists(atPath: a.path) { return a } + let b = dir.appendingPathComponent("index.htm", isDirectory: false) + if fm.fileExists(atPath: b.path) { return b } + return nil + } + + private func html(_ body: String, title: String = "Canvas") -> CanvasResponse { + let html = """ + + + + + + \(title) + + + +
    +
    \(body)
    +
    + + + """ + return CanvasResponse(mime: "text/html", data: Data(html.utf8)) + } + + private func welcomePage(sessionRoot: URL) -> CanvasResponse { + let escaped = sessionRoot.path + .replacingOccurrences(of: "&", with: "&") + .replacingOccurrences(of: "<", with: "<") + .replacingOccurrences(of: ">", with: ">") + let body = """ +
    Canvas is ready.
    +
    Create index.html in:
    +
    \(escaped)
    + """ + return self.html(body, title: "Canvas") + } + + private func scaffoldPage(sessionRoot: URL) -> CanvasResponse { + // Default Canvas UX: when no index exists, show the built-in scaffold page. + if let data = self.loadBundledResourceData(relativePath: "CanvasScaffold/scaffold.html") { + return CanvasResponse(mime: "text/html", data: data) + } + + // Fallback for dev misconfiguration: show the classic welcome page. + return self.welcomePage(sessionRoot: sessionRoot) + } + + private func loadBundledResourceData(relativePath: String) -> Data? { + let trimmed = relativePath.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return nil } + if trimmed.contains("..") || trimmed.contains("\\") { return nil } + + let parts = trimmed.split(separator: "/") + guard let filename = parts.last else { return nil } + let subdirectory = + parts.count > 1 ? parts.dropLast().joined(separator: "/") : nil + let fileURL = URL(fileURLWithPath: String(filename)) + let ext = fileURL.pathExtension + let name = fileURL.deletingPathExtension().lastPathComponent + guard !name.isEmpty, !ext.isEmpty else { return nil } + + let bundle = MoltbotKitResources.bundle + let resourceURL = + bundle.url(forResource: name, withExtension: ext, subdirectory: subdirectory) + ?? bundle.url(forResource: name, withExtension: ext) + guard let resourceURL else { return nil } + return try? Data(contentsOf: resourceURL) + } + + private func textEncodingName(forMimeType mimeType: String) -> String? { + if mimeType.hasPrefix("text/") { return "utf-8" } + switch mimeType { + case "application/javascript", "application/json", "image/svg+xml": + return "utf-8" + default: + return nil + } + } +} + +#if DEBUG +extension CanvasSchemeHandler { + func _testResponse(for url: URL) -> (mime: String, data: Data) { + let response = self.response(for: url) + return (response.mime, response.data) + } + + func _testResolveFileURL(sessionRoot: URL, requestPath: String) -> URL? { + self.resolveFileURL(sessionRoot: sessionRoot, requestPath: requestPath) + } + + func _testTextEncodingName(for mimeType: String) -> String? { + self.textEncodingName(forMimeType: mimeType) + } +} +#endif diff --git a/apps/macos/Sources/Moltbot/CanvasWindow.swift b/apps/macos/Sources/Moltbot/CanvasWindow.swift new file mode 100644 index 000000000..27306f88a --- /dev/null +++ b/apps/macos/Sources/Moltbot/CanvasWindow.swift @@ -0,0 +1,26 @@ +import AppKit + +let canvasWindowLogger = Logger(subsystem: "bot.molt", category: "Canvas") + +enum CanvasLayout { + static let panelSize = NSSize(width: 520, height: 680) + static let windowSize = NSSize(width: 1120, height: 840) + static let anchorPadding: CGFloat = 8 + static let defaultPadding: CGFloat = 10 + static let minPanelSize = NSSize(width: 360, height: 360) +} + +final class CanvasPanel: NSPanel { + override var canBecomeKey: Bool { true } + override var canBecomeMain: Bool { true } +} + +enum CanvasPresentation { + case window + case panel(anchorProvider: () -> NSRect?) + + var isPanel: Bool { + if case .panel = self { return true } + return false + } +} diff --git a/apps/macos/Sources/Moltbot/ClawdbotConfigFile.swift b/apps/macos/Sources/Moltbot/ClawdbotConfigFile.swift new file mode 100644 index 000000000..2c796d4ea --- /dev/null +++ b/apps/macos/Sources/Moltbot/ClawdbotConfigFile.swift @@ -0,0 +1,217 @@ +import MoltbotProtocol +import Foundation + +enum MoltbotConfigFile { + private static let logger = Logger(subsystem: "bot.molt", category: "config") + + static func url() -> URL { + MoltbotPaths.configURL + } + + static func stateDirURL() -> URL { + MoltbotPaths.stateDirURL + } + + static func defaultWorkspaceURL() -> URL { + MoltbotPaths.workspaceURL + } + + static func loadDict() -> [String: Any] { + let url = self.url() + guard FileManager().fileExists(atPath: url.path) else { return [:] } + do { + let data = try Data(contentsOf: url) + guard let root = self.parseConfigData(data) else { + self.logger.warning("config JSON root invalid") + return [:] + } + return root + } catch { + self.logger.warning("config read failed: \(error.localizedDescription)") + return [:] + } + } + + static func saveDict(_ dict: [String: Any]) { + // Nix mode disables config writes in production, but tests rely on saving temp configs. + if ProcessInfo.processInfo.isNixMode, !ProcessInfo.processInfo.isRunningTests { return } + do { + let data = try JSONSerialization.data(withJSONObject: dict, options: [.prettyPrinted, .sortedKeys]) + let url = self.url() + try FileManager().createDirectory( + at: url.deletingLastPathComponent(), + withIntermediateDirectories: true) + try data.write(to: url, options: [.atomic]) + } catch { + self.logger.error("config save failed: \(error.localizedDescription)") + } + } + + static func loadGatewayDict() -> [String: Any] { + let root = self.loadDict() + return root["gateway"] as? [String: Any] ?? [:] + } + + static func updateGatewayDict(_ mutate: (inout [String: Any]) -> Void) { + var root = self.loadDict() + var gateway = root["gateway"] as? [String: Any] ?? [:] + mutate(&gateway) + if gateway.isEmpty { + root.removeValue(forKey: "gateway") + } else { + root["gateway"] = gateway + } + self.saveDict(root) + } + + static func browserControlEnabled(defaultValue: Bool = true) -> Bool { + let root = self.loadDict() + let browser = root["browser"] as? [String: Any] + return browser?["enabled"] as? Bool ?? defaultValue + } + + static func setBrowserControlEnabled(_ enabled: Bool) { + var root = self.loadDict() + var browser = root["browser"] as? [String: Any] ?? [:] + browser["enabled"] = enabled + root["browser"] = browser + self.saveDict(root) + self.logger.debug("browser control updated enabled=\(enabled)") + } + + static func agentWorkspace() -> String? { + let root = self.loadDict() + let agents = root["agents"] as? [String: Any] + let defaults = agents?["defaults"] as? [String: Any] + return defaults?["workspace"] as? String + } + + static func setAgentWorkspace(_ workspace: String?) { + var root = self.loadDict() + var agents = root["agents"] as? [String: Any] ?? [:] + var defaults = agents["defaults"] as? [String: Any] ?? [:] + let trimmed = workspace?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if trimmed.isEmpty { + defaults.removeValue(forKey: "workspace") + } else { + defaults["workspace"] = trimmed + } + if defaults.isEmpty { + agents.removeValue(forKey: "defaults") + } else { + agents["defaults"] = defaults + } + if agents.isEmpty { + root.removeValue(forKey: "agents") + } else { + root["agents"] = agents + } + self.saveDict(root) + self.logger.debug("agents.defaults.workspace updated set=\(!trimmed.isEmpty)") + } + + static func gatewayPassword() -> String? { + let root = self.loadDict() + guard let gateway = root["gateway"] as? [String: Any], + let remote = gateway["remote"] as? [String: Any] + else { + return nil + } + return remote["password"] as? String + } + + static func gatewayPort() -> Int? { + let root = self.loadDict() + guard let gateway = root["gateway"] as? [String: Any] else { return nil } + if let port = gateway["port"] as? Int, port > 0 { return port } + if let number = gateway["port"] as? NSNumber, number.intValue > 0 { + return number.intValue + } + if let raw = gateway["port"] as? String, + let parsed = Int(raw.trimmingCharacters(in: .whitespacesAndNewlines)), + parsed > 0 + { + return parsed + } + return nil + } + + static func remoteGatewayPort() -> Int? { + guard let url = self.remoteGatewayUrl(), + let port = url.port, + port > 0 + else { return nil } + return port + } + + static func remoteGatewayPort(matchingHost sshHost: String) -> Int? { + let trimmedSshHost = sshHost.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmedSshHost.isEmpty, + let url = self.remoteGatewayUrl(), + let port = url.port, + port > 0, + let urlHost = url.host?.trimmingCharacters(in: .whitespacesAndNewlines), + !urlHost.isEmpty + else { + return nil + } + + let sshKey = Self.hostKey(trimmedSshHost) + let urlKey = Self.hostKey(urlHost) + guard !sshKey.isEmpty, !urlKey.isEmpty, sshKey == urlKey else { return nil } + return port + } + + static func setRemoteGatewayUrl(host: String, port: Int?) { + guard let port, port > 0 else { return } + let trimmedHost = host.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmedHost.isEmpty else { return } + self.updateGatewayDict { gateway in + var remote = gateway["remote"] as? [String: Any] ?? [:] + let existingUrl = (remote["url"] as? String)? + .trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + let scheme = URL(string: existingUrl)?.scheme ?? "ws" + remote["url"] = "\(scheme)://\(trimmedHost):\(port)" + gateway["remote"] = remote + } + } + + private static func remoteGatewayUrl() -> URL? { + let root = self.loadDict() + guard let gateway = root["gateway"] as? [String: Any], + let remote = gateway["remote"] as? [String: Any], + let raw = remote["url"] as? String + else { + return nil + } + let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty, let url = URL(string: trimmed) else { return nil } + return url + } + + private static func hostKey(_ host: String) -> String { + let trimmed = host.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + guard !trimmed.isEmpty else { return "" } + if trimmed.contains(":") { return trimmed } + let digits = CharacterSet(charactersIn: "0123456789.") + if trimmed.rangeOfCharacter(from: digits.inverted) == nil { + return trimmed + } + return trimmed.split(separator: ".").first.map(String.init) ?? trimmed + } + + private static func parseConfigData(_ data: Data) -> [String: Any]? { + if let root = try? JSONSerialization.jsonObject(with: data) as? [String: Any] { + return root + } + let decoder = JSONDecoder() + if #available(macOS 12.0, *) { + decoder.allowsJSON5 = true + } + if let decoded = try? decoder.decode([String: AnyCodable].self, from: data) { + self.logger.notice("config parsed with JSON5 decoder") + return decoded.mapValues { $0.foundationValue } + } + return nil + } +} diff --git a/apps/macos/Sources/Moltbot/ConfigFileWatcher.swift b/apps/macos/Sources/Moltbot/ConfigFileWatcher.swift new file mode 100644 index 000000000..b7904f73f --- /dev/null +++ b/apps/macos/Sources/Moltbot/ConfigFileWatcher.swift @@ -0,0 +1,118 @@ +import CoreServices +import Foundation + +final class ConfigFileWatcher: @unchecked Sendable { + private let url: URL + private let queue: DispatchQueue + private var stream: FSEventStreamRef? + private var pending = false + private let onChange: () -> Void + private let watchedDir: URL + private let targetPath: String + private let targetName: String + + init(url: URL, onChange: @escaping () -> Void) { + self.url = url + self.queue = DispatchQueue(label: "bot.molt.configwatcher") + self.onChange = onChange + self.watchedDir = url.deletingLastPathComponent() + self.targetPath = url.path + self.targetName = url.lastPathComponent + } + + deinit { + self.stop() + } + + func start() { + guard self.stream == nil else { return } + + let retainedSelf = Unmanaged.passRetained(self) + var context = FSEventStreamContext( + version: 0, + info: retainedSelf.toOpaque(), + retain: nil, + release: { pointer in + guard let pointer else { return } + Unmanaged.fromOpaque(pointer).release() + }, + copyDescription: nil) + + let paths = [self.watchedDir.path] as CFArray + let flags = FSEventStreamCreateFlags( + kFSEventStreamCreateFlagFileEvents | + kFSEventStreamCreateFlagUseCFTypes | + kFSEventStreamCreateFlagNoDefer) + + guard let stream = FSEventStreamCreate( + kCFAllocatorDefault, + Self.callback, + &context, + paths, + FSEventStreamEventId(kFSEventStreamEventIdSinceNow), + 0.05, + flags) + else { + retainedSelf.release() + return + } + + self.stream = stream + FSEventStreamSetDispatchQueue(stream, self.queue) + if FSEventStreamStart(stream) == false { + self.stream = nil + FSEventStreamSetDispatchQueue(stream, nil) + FSEventStreamInvalidate(stream) + FSEventStreamRelease(stream) + } + } + + func stop() { + guard let stream = self.stream else { return } + self.stream = nil + FSEventStreamStop(stream) + FSEventStreamSetDispatchQueue(stream, nil) + FSEventStreamInvalidate(stream) + FSEventStreamRelease(stream) + } +} + +extension ConfigFileWatcher { + private static let callback: FSEventStreamCallback = { _, info, numEvents, eventPaths, eventFlags, _ in + guard let info else { return } + let watcher = Unmanaged.fromOpaque(info).takeUnretainedValue() + watcher.handleEvents( + numEvents: numEvents, + eventPaths: eventPaths, + eventFlags: eventFlags) + } + + private func handleEvents( + numEvents: Int, + eventPaths: UnsafeMutableRawPointer?, + eventFlags: UnsafePointer?) + { + guard numEvents > 0 else { return } + guard eventFlags != nil else { return } + guard self.matchesTarget(eventPaths: eventPaths) else { return } + + if self.pending { return } + self.pending = true + self.queue.asyncAfter(deadline: .now() + 0.12) { [weak self] in + guard let self else { return } + self.pending = false + self.onChange() + } + } + + private func matchesTarget(eventPaths: UnsafeMutableRawPointer?) -> Bool { + guard let eventPaths else { return true } + let paths = unsafeBitCast(eventPaths, to: NSArray.self) + for case let path as String in paths { + if path == self.targetPath { return true } + if path.hasSuffix("/\(self.targetName)") { return true } + if path == self.watchedDir.path { return true } + } + return false + } +} diff --git a/apps/macos/Sources/Moltbot/ConnectionModeCoordinator.swift b/apps/macos/Sources/Moltbot/ConnectionModeCoordinator.swift new file mode 100644 index 000000000..28bb5795b --- /dev/null +++ b/apps/macos/Sources/Moltbot/ConnectionModeCoordinator.swift @@ -0,0 +1,79 @@ +import Foundation +import OSLog + +@MainActor +final class ConnectionModeCoordinator { + static let shared = ConnectionModeCoordinator() + + private let logger = Logger(subsystem: "bot.molt", category: "connection") + private var lastMode: AppState.ConnectionMode? + + /// Apply the requested connection mode by starting/stopping local gateway, + /// managing the control-channel SSH tunnel, and cleaning up chat windows/panels. + func apply(mode: AppState.ConnectionMode, paused: Bool) async { + if let lastMode = self.lastMode, lastMode != mode { + GatewayProcessManager.shared.clearLastFailure() + NodesStore.shared.lastError = nil + } + self.lastMode = mode + switch mode { + case .unconfigured: + _ = await NodeServiceManager.stop() + NodesStore.shared.lastError = nil + await RemoteTunnelManager.shared.stopAll() + WebChatManager.shared.resetTunnels() + GatewayProcessManager.shared.stop() + await GatewayConnection.shared.shutdown() + await ControlChannel.shared.disconnect() + Task.detached { await PortGuardian.shared.sweep(mode: .unconfigured) } + + case .local: + _ = await NodeServiceManager.stop() + NodesStore.shared.lastError = nil + await RemoteTunnelManager.shared.stopAll() + WebChatManager.shared.resetTunnels() + let shouldStart = GatewayAutostartPolicy.shouldStartGateway(mode: .local, paused: paused) + if shouldStart { + GatewayProcessManager.shared.setActive(true) + if GatewayAutostartPolicy.shouldEnsureLaunchAgent( + mode: .local, + paused: paused) + { + Task { await GatewayProcessManager.shared.ensureLaunchAgentEnabledIfNeeded() } + } + _ = await GatewayProcessManager.shared.waitForGatewayReady() + } else { + GatewayProcessManager.shared.stop() + } + do { + try await ControlChannel.shared.configure(mode: .local) + } catch { + // Control channel will mark itself degraded; nothing else to do here. + self.logger.error( + "control channel local configure failed: \(error.localizedDescription, privacy: .public)") + } + Task.detached { await PortGuardian.shared.sweep(mode: .local) } + + case .remote: + // Never run a local gateway in remote mode. + GatewayProcessManager.shared.stop() + WebChatManager.shared.resetTunnels() + + do { + NodesStore.shared.lastError = nil + if let error = await NodeServiceManager.start() { + NodesStore.shared.lastError = "Node service start failed: \(error)" + } + _ = try await GatewayEndpointStore.shared.ensureRemoteControlTunnel() + let settings = CommandResolver.connectionSettings() + try await ControlChannel.shared.configure(mode: .remote( + target: settings.target, + identity: settings.identity)) + } catch { + self.logger.error("remote tunnel/configure failed: \(error.localizedDescription, privacy: .public)") + } + + Task.detached { await PortGuardian.shared.sweep(mode: .remote) } + } + } +} diff --git a/apps/macos/Sources/Moltbot/Constants.swift b/apps/macos/Sources/Moltbot/Constants.swift new file mode 100644 index 000000000..5905d3f1b --- /dev/null +++ b/apps/macos/Sources/Moltbot/Constants.swift @@ -0,0 +1,44 @@ +import Foundation + +let launchdLabel = "bot.molt.mac" +let gatewayLaunchdLabel = "bot.molt.gateway" +let onboardingVersionKey = "moltbot.onboardingVersion" +let currentOnboardingVersion = 7 +let pauseDefaultsKey = "moltbot.pauseEnabled" +let iconAnimationsEnabledKey = "moltbot.iconAnimationsEnabled" +let swabbleEnabledKey = "moltbot.swabbleEnabled" +let swabbleTriggersKey = "moltbot.swabbleTriggers" +let voiceWakeTriggerChimeKey = "moltbot.voiceWakeTriggerChime" +let voiceWakeSendChimeKey = "moltbot.voiceWakeSendChime" +let showDockIconKey = "moltbot.showDockIcon" +let defaultVoiceWakeTriggers = ["clawd", "claude"] +let voiceWakeMaxWords = 32 +let voiceWakeMaxWordLength = 64 +let voiceWakeMicKey = "moltbot.voiceWakeMicID" +let voiceWakeMicNameKey = "moltbot.voiceWakeMicName" +let voiceWakeLocaleKey = "moltbot.voiceWakeLocaleID" +let voiceWakeAdditionalLocalesKey = "moltbot.voiceWakeAdditionalLocaleIDs" +let voicePushToTalkEnabledKey = "moltbot.voicePushToTalkEnabled" +let talkEnabledKey = "moltbot.talkEnabled" +let iconOverrideKey = "moltbot.iconOverride" +let connectionModeKey = "moltbot.connectionMode" +let remoteTargetKey = "moltbot.remoteTarget" +let remoteIdentityKey = "moltbot.remoteIdentity" +let remoteProjectRootKey = "moltbot.remoteProjectRoot" +let remoteCliPathKey = "moltbot.remoteCliPath" +let canvasEnabledKey = "moltbot.canvasEnabled" +let cameraEnabledKey = "moltbot.cameraEnabled" +let systemRunPolicyKey = "moltbot.systemRunPolicy" +let systemRunAllowlistKey = "moltbot.systemRunAllowlist" +let systemRunEnabledKey = "moltbot.systemRunEnabled" +let locationModeKey = "moltbot.locationMode" +let locationPreciseKey = "moltbot.locationPreciseEnabled" +let peekabooBridgeEnabledKey = "moltbot.peekabooBridgeEnabled" +let deepLinkKeyKey = "moltbot.deepLinkKey" +let modelCatalogPathKey = "moltbot.modelCatalogPath" +let modelCatalogReloadKey = "moltbot.modelCatalogReload" +let cliInstallPromptedVersionKey = "moltbot.cliInstallPromptedVersion" +let heartbeatsEnabledKey = "moltbot.heartbeatsEnabled" +let debugFileLogEnabledKey = "moltbot.debug.fileLogEnabled" +let appLogLevelKey = "moltbot.debug.appLogLevel" +let voiceWakeSupported: Bool = ProcessInfo.processInfo.operatingSystemVersion.majorVersion >= 26 diff --git a/apps/macos/Sources/Moltbot/ControlChannel.swift b/apps/macos/Sources/Moltbot/ControlChannel.swift new file mode 100644 index 000000000..2af7c721d --- /dev/null +++ b/apps/macos/Sources/Moltbot/ControlChannel.swift @@ -0,0 +1,427 @@ +import MoltbotKit +import MoltbotProtocol +import Foundation +import Observation +import SwiftUI + +struct ControlHeartbeatEvent: Codable { + let ts: Double + let status: String + let to: String? + let preview: String? + let durationMs: Double? + let hasMedia: Bool? + let reason: String? +} + +struct ControlAgentEvent: Codable, Sendable, Identifiable { + var id: String { "\(self.runId)-\(self.seq)" } + let runId: String + let seq: Int + let stream: String + let ts: Double + let data: [String: MoltbotProtocol.AnyCodable] + let summary: String? +} + +enum ControlChannelError: Error, LocalizedError { + case disconnected + case badResponse(String) + + var errorDescription: String? { + switch self { + case .disconnected: "Control channel disconnected" + case let .badResponse(msg): msg + } + } +} + +@MainActor +@Observable +final class ControlChannel { + static let shared = ControlChannel() + + enum Mode { + case local + case remote(target: String, identity: String) + } + + enum ConnectionState: Equatable { + case disconnected + case connecting + case connected + case degraded(String) + } + + private(set) var state: ConnectionState = .disconnected { + didSet { + CanvasManager.shared.refreshDebugStatus() + guard oldValue != self.state else { return } + switch self.state { + case .connected: + self.logger.info("control channel state -> connected") + case .connecting: + self.logger.info("control channel state -> connecting") + case .disconnected: + self.logger.info("control channel state -> disconnected") + self.scheduleRecovery(reason: "disconnected") + case let .degraded(message): + let detail = message.isEmpty ? "degraded" : "degraded: \(message)" + self.logger.info("control channel state -> \(detail, privacy: .public)") + self.scheduleRecovery(reason: message) + } + } + } + + private(set) var lastPingMs: Double? + private(set) var authSourceLabel: String? + + private let logger = Logger(subsystem: "bot.molt", category: "control") + + private var eventTask: Task? + private var recoveryTask: Task? + private var lastRecoveryAt: Date? + + private init() { + self.startEventStream() + } + + func configure() async { + self.logger.info("control channel configure mode=local") + await self.refreshEndpoint(reason: "configure") + } + + func configure(mode: Mode = .local) async throws { + switch mode { + case .local: + await self.configure() + case let .remote(target, identity): + do { + _ = (target, identity) + let idSet = !identity.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty + self.logger.info( + "control channel configure mode=remote " + + "target=\(target, privacy: .public) identitySet=\(idSet, privacy: .public)") + self.state = .connecting + _ = try await GatewayEndpointStore.shared.ensureRemoteControlTunnel() + await self.refreshEndpoint(reason: "configure") + } catch { + self.state = .degraded(error.localizedDescription) + throw error + } + } + } + + func refreshEndpoint(reason: String) async { + self.logger.info("control channel refresh endpoint reason=\(reason, privacy: .public)") + self.state = .connecting + do { + try await self.establishGatewayConnection() + self.state = .connected + PresenceReporter.shared.sendImmediate(reason: "connect") + } catch { + let message = self.friendlyGatewayMessage(error) + self.state = .degraded(message) + } + } + + func disconnect() async { + await GatewayConnection.shared.shutdown() + self.state = .disconnected + self.lastPingMs = nil + self.authSourceLabel = nil + } + + func health(timeout: TimeInterval? = nil) async throws -> Data { + do { + let start = Date() + var params: [String: AnyHashable]? + if let timeout { + params = ["timeout": AnyHashable(Int(timeout * 1000))] + } + let timeoutMs = (timeout ?? 15) * 1000 + let payload = try await self.request(method: "health", params: params, timeoutMs: timeoutMs) + let ms = Date().timeIntervalSince(start) * 1000 + self.lastPingMs = ms + self.state = .connected + return payload + } catch { + let message = self.friendlyGatewayMessage(error) + self.state = .degraded(message) + throw ControlChannelError.badResponse(message) + } + } + + func lastHeartbeat() async throws -> ControlHeartbeatEvent? { + let data = try await self.request(method: "last-heartbeat") + return try JSONDecoder().decode(ControlHeartbeatEvent?.self, from: data) + } + + func request( + method: String, + params: [String: AnyHashable]? = nil, + timeoutMs: Double? = nil) async throws -> Data + { + do { + let rawParams = params?.reduce(into: [String: MoltbotKit.AnyCodable]()) { + $0[$1.key] = MoltbotKit.AnyCodable($1.value.base) + } + let data = try await GatewayConnection.shared.request( + method: method, + params: rawParams, + timeoutMs: timeoutMs) + self.state = .connected + return data + } catch { + let message = self.friendlyGatewayMessage(error) + self.state = .degraded(message) + throw ControlChannelError.badResponse(message) + } + } + + private func friendlyGatewayMessage(_ error: Error) -> String { + // Map URLSession/WS errors into user-facing, actionable text. + if let ctrlErr = error as? ControlChannelError, let desc = ctrlErr.errorDescription { + return desc + } + + // If the gateway explicitly rejects the hello (e.g., auth/token mismatch), surface it. + if let urlErr = error as? URLError, + urlErr.code == .dataNotAllowed // used for WS close 1008 auth failures + { + let reason = urlErr.failureURLString ?? urlErr.localizedDescription + let tokenKey = CommandResolver.connectionModeIsRemote() + ? "gateway.remote.token" + : "gateway.auth.token" + return + "Gateway rejected token; set \(tokenKey) (or CLAWDBOT_GATEWAY_TOKEN) " + + "or clear it on the gateway. " + + "Reason: \(reason)" + } + + // Common misfire: we connected to the configured localhost port but it is occupied + // by some other process (e.g. a local dev gateway or a stuck SSH forward). + // The gateway handshake returns something we can't parse, which currently + // surfaces as "hello failed (unexpected response)". Give the user a pointer + // to free the port instead of a vague message. + let nsError = error as NSError + if nsError.domain == "Gateway", + nsError.localizedDescription.contains("hello failed (unexpected response)") + { + let port = GatewayEnvironment.gatewayPort() + return """ + Gateway handshake got non-gateway data on localhost:\(port). + Another process is using that port or the SSH forward failed. + Stop the local gateway/port-forward on \(port) and retry Remote mode. + """ + } + + if let urlError = error as? URLError { + let port = GatewayEnvironment.gatewayPort() + switch urlError.code { + case .cancelled: + return "Gateway connection was closed; start the gateway (localhost:\(port)) and retry." + case .cannotFindHost, .cannotConnectToHost: + let isRemote = CommandResolver.connectionModeIsRemote() + if isRemote { + return """ + Cannot reach gateway at localhost:\(port). + Remote mode uses an SSH tunnel—check the SSH target and that the tunnel is running. + """ + } + return "Cannot reach gateway at localhost:\(port); ensure the gateway is running." + case .networkConnectionLost: + return "Gateway connection dropped; gateway likely restarted—retry." + case .timedOut: + return "Gateway request timed out; check gateway on localhost:\(port)." + case .notConnectedToInternet: + return "No network connectivity; cannot reach gateway." + default: + break + } + } + + if nsError.domain == "Gateway", nsError.code == 5 { + let port = GatewayEnvironment.gatewayPort() + return "Gateway request timed out; check the gateway process on localhost:\(port)." + } + + let detail = nsError.localizedDescription.isEmpty ? "unknown gateway error" : nsError.localizedDescription + let trimmed = detail.trimmingCharacters(in: .whitespacesAndNewlines) + if trimmed.lowercased().hasPrefix("gateway error:") { return trimmed } + return "Gateway error: \(trimmed)" + } + + private func scheduleRecovery(reason: String) { + let now = Date() + if let last = self.lastRecoveryAt, now.timeIntervalSince(last) < 10 { return } + guard self.recoveryTask == nil else { return } + self.lastRecoveryAt = now + + self.recoveryTask = Task { [weak self] in + guard let self else { return } + let mode = await MainActor.run { AppStateStore.shared.connectionMode } + guard mode != .unconfigured else { + self.recoveryTask = nil + return + } + + let trimmedReason = reason.trimmingCharacters(in: .whitespacesAndNewlines) + let reasonText = trimmedReason.isEmpty ? "unknown" : trimmedReason + self.logger.info( + "control channel recovery starting " + + "mode=\(String(describing: mode), privacy: .public) " + + "reason=\(reasonText, privacy: .public)") + if mode == .local { + GatewayProcessManager.shared.setActive(true) + } + if mode == .remote { + do { + let port = try await GatewayEndpointStore.shared.ensureRemoteControlTunnel() + self.logger.info("control channel recovery ensured SSH tunnel port=\(port, privacy: .public)") + } catch { + self.logger.error( + "control channel recovery tunnel failed \(error.localizedDescription, privacy: .public)") + } + } + + await self.refreshEndpoint(reason: "recovery:\(reasonText)") + if case .connected = self.state { + self.logger.info("control channel recovery finished") + } else if case let .degraded(message) = self.state { + self.logger.error("control channel recovery failed \(message, privacy: .public)") + } + + self.recoveryTask = nil + } + } + + private func establishGatewayConnection(timeoutMs: Int = 5000) async throws { + try await GatewayConnection.shared.refresh() + let ok = try await GatewayConnection.shared.healthOK(timeoutMs: timeoutMs) + if ok == false { + throw NSError( + domain: "Gateway", + code: 0, + userInfo: [NSLocalizedDescriptionKey: "gateway health not ok"]) + } + await self.refreshAuthSourceLabel() + } + + private func refreshAuthSourceLabel() async { + let isRemote = CommandResolver.connectionModeIsRemote() + let authSource = await GatewayConnection.shared.authSource() + self.authSourceLabel = Self.formatAuthSource(authSource, isRemote: isRemote) + } + + private static func formatAuthSource(_ source: GatewayAuthSource?, isRemote: Bool) -> String? { + guard let source else { return nil } + switch source { + case .deviceToken: + return "Auth: device token (paired device)" + case .sharedToken: + return "Auth: shared token (\(isRemote ? "gateway.remote.token" : "gateway.auth.token"))" + case .password: + return "Auth: password (\(isRemote ? "gateway.remote.password" : "gateway.auth.password"))" + case .none: + return "Auth: none" + } + } + + func sendSystemEvent(_ text: String, params: [String: AnyHashable] = [:]) async throws { + var merged = params + merged["text"] = AnyHashable(text) + _ = try await self.request(method: "system-event", params: merged) + } + + private func startEventStream() { + self.eventTask?.cancel() + self.eventTask = Task { [weak self] in + guard let self else { return } + let stream = await GatewayConnection.shared.subscribe() + for await push in stream { + if Task.isCancelled { return } + await MainActor.run { [weak self] in + self?.handle(push: push) + } + } + } + } + + private func handle(push: GatewayPush) { + switch push { + case let .event(evt) where evt.event == "agent": + if let payload = evt.payload, + let agent = try? GatewayPayloadDecoding.decode(payload, as: ControlAgentEvent.self) + { + AgentEventStore.shared.append(agent) + self.routeWorkActivity(from: agent) + } + case let .event(evt) where evt.event == "heartbeat": + if let payload = evt.payload, + let heartbeat = try? GatewayPayloadDecoding.decode(payload, as: ControlHeartbeatEvent.self), + let data = try? JSONEncoder().encode(heartbeat) + { + NotificationCenter.default.post(name: .controlHeartbeat, object: data) + } + case let .event(evt) where evt.event == "shutdown": + self.state = .degraded("gateway shutdown") + case .snapshot: + self.state = .connected + default: + break + } + } + + private func routeWorkActivity(from event: ControlAgentEvent) { + // We currently treat VoiceWake as the "main" session for UI purposes. + // In the future, the gateway can include a sessionKey to distinguish runs. + let sessionKey = (event.data["sessionKey"]?.value as? String) ?? "main" + + switch event.stream.lowercased() { + case "job": + if let state = event.data["state"]?.value as? String { + WorkActivityStore.shared.handleJob(sessionKey: sessionKey, state: state) + } + case "tool": + let phase = event.data["phase"]?.value as? String ?? "" + let name = event.data["name"]?.value as? String + let meta = event.data["meta"]?.value as? String + let args = Self.bridgeToProtocolArgs(event.data["args"]) + WorkActivityStore.shared.handleTool( + sessionKey: sessionKey, + phase: phase, + name: name, + meta: meta, + args: args) + default: + break + } + } + + private static func bridgeToProtocolArgs( + _ value: MoltbotProtocol.AnyCodable?) -> [String: MoltbotProtocol.AnyCodable]? + { + guard let value else { return nil } + if let dict = value.value as? [String: MoltbotProtocol.AnyCodable] { + return dict + } + if let dict = value.value as? [String: MoltbotKit.AnyCodable], + let data = try? JSONEncoder().encode(dict), + let decoded = try? JSONDecoder().decode([String: MoltbotProtocol.AnyCodable].self, from: data) + { + return decoded + } + if let data = try? JSONEncoder().encode(value), + let decoded = try? JSONDecoder().decode([String: MoltbotProtocol.AnyCodable].self, from: data) + { + return decoded + } + return nil + } +} + +extension Notification.Name { + static let controlHeartbeat = Notification.Name("moltbot.control.heartbeat") + static let controlAgentEvent = Notification.Name("moltbot.control.agent") +} diff --git a/apps/macos/Sources/Moltbot/CronJobsStore.swift b/apps/macos/Sources/Moltbot/CronJobsStore.swift new file mode 100644 index 000000000..81503921b --- /dev/null +++ b/apps/macos/Sources/Moltbot/CronJobsStore.swift @@ -0,0 +1,200 @@ +import MoltbotKit +import MoltbotProtocol +import Foundation +import Observation +import OSLog + +@MainActor +@Observable +final class CronJobsStore { + static let shared = CronJobsStore() + + var jobs: [CronJob] = [] + var selectedJobId: String? + var runEntries: [CronRunLogEntry] = [] + + var schedulerEnabled: Bool? + var schedulerStorePath: String? + var schedulerNextWakeAtMs: Int? + + var isLoadingJobs = false + var isLoadingRuns = false + var lastError: String? + var statusMessage: String? + + private let logger = Logger(subsystem: "bot.molt", category: "cron.ui") + private var refreshTask: Task? + private var runsTask: Task? + private var eventTask: Task? + private var pollTask: Task? + + private let interval: TimeInterval = 30 + private let isPreview: Bool + + init(isPreview: Bool = ProcessInfo.processInfo.isPreview) { + self.isPreview = isPreview + } + + func start() { + guard !self.isPreview else { return } + guard self.eventTask == nil else { return } + self.startGatewaySubscription() + self.pollTask = Task.detached { [weak self] in + guard let self else { return } + await self.refreshJobs() + while !Task.isCancelled { + try? await Task.sleep(nanoseconds: UInt64(self.interval * 1_000_000_000)) + await self.refreshJobs() + } + } + } + + func stop() { + self.refreshTask?.cancel() + self.refreshTask = nil + self.runsTask?.cancel() + self.runsTask = nil + self.eventTask?.cancel() + self.eventTask = nil + self.pollTask?.cancel() + self.pollTask = nil + } + + func refreshJobs() async { + guard !self.isLoadingJobs else { return } + self.isLoadingJobs = true + self.lastError = nil + self.statusMessage = nil + defer { self.isLoadingJobs = false } + + do { + if let status = try? await GatewayConnection.shared.cronStatus() { + self.schedulerEnabled = status.enabled + self.schedulerStorePath = status.storePath + self.schedulerNextWakeAtMs = status.nextWakeAtMs + } + self.jobs = try await GatewayConnection.shared.cronList(includeDisabled: true) + if self.jobs.isEmpty { + self.statusMessage = "No cron jobs yet." + } + } catch { + self.logger.error("cron.list failed \(error.localizedDescription, privacy: .public)") + self.lastError = error.localizedDescription + } + } + + func refreshRuns(jobId: String, limit: Int = 200) async { + guard !self.isLoadingRuns else { return } + self.isLoadingRuns = true + defer { self.isLoadingRuns = false } + + do { + self.runEntries = try await GatewayConnection.shared.cronRuns(jobId: jobId, limit: limit) + } catch { + self.logger.error("cron.runs failed \(error.localizedDescription, privacy: .public)") + self.lastError = error.localizedDescription + } + } + + func runJob(id: String, force: Bool = true) async { + do { + try await GatewayConnection.shared.cronRun(jobId: id, force: force) + } catch { + self.lastError = error.localizedDescription + } + } + + func removeJob(id: String) async { + do { + try await GatewayConnection.shared.cronRemove(jobId: id) + await self.refreshJobs() + if self.selectedJobId == id { + self.selectedJobId = nil + self.runEntries = [] + } + } catch { + self.lastError = error.localizedDescription + } + } + + func setJobEnabled(id: String, enabled: Bool) async { + do { + try await GatewayConnection.shared.cronUpdate( + jobId: id, + patch: ["enabled": AnyCodable(enabled)]) + await self.refreshJobs() + } catch { + self.lastError = error.localizedDescription + } + } + + func upsertJob( + id: String?, + payload: [String: AnyCodable]) async throws + { + if let id { + try await GatewayConnection.shared.cronUpdate(jobId: id, patch: payload) + } else { + try await GatewayConnection.shared.cronAdd(payload: payload) + } + await self.refreshJobs() + } + + // MARK: - Gateway events + + private func startGatewaySubscription() { + self.eventTask?.cancel() + self.eventTask = Task { [weak self] in + guard let self else { return } + let stream = await GatewayConnection.shared.subscribe() + for await push in stream { + if Task.isCancelled { return } + await MainActor.run { [weak self] in + self?.handle(push: push) + } + } + } + } + + private func handle(push: GatewayPush) { + switch push { + case let .event(evt) where evt.event == "cron": + guard let payload = evt.payload else { return } + if let cronEvt = try? GatewayPayloadDecoding.decode(payload, as: CronEvent.self) { + self.handle(cronEvent: cronEvt) + } + case .seqGap: + self.scheduleRefresh() + default: + break + } + } + + private func handle(cronEvent evt: CronEvent) { + // Keep UI in sync with the gateway scheduler. + self.scheduleRefresh(delayMs: 250) + if evt.action == "finished", let selected = self.selectedJobId, selected == evt.jobId { + self.scheduleRunsRefresh(jobId: selected, delayMs: 200) + } + } + + private func scheduleRefresh(delayMs: Int = 250) { + self.refreshTask?.cancel() + self.refreshTask = Task { [weak self] in + guard let self else { return } + try? await Task.sleep(nanoseconds: UInt64(delayMs) * 1_000_000) + await self.refreshJobs() + } + } + + private func scheduleRunsRefresh(jobId: String, delayMs: Int = 200) { + self.runsTask?.cancel() + self.runsTask = Task { [weak self] in + guard let self else { return } + try? await Task.sleep(nanoseconds: UInt64(delayMs) * 1_000_000) + await self.refreshRuns(jobId: jobId) + } + } + + // MARK: - (no additional RPC helpers) +} diff --git a/apps/macos/Sources/Moltbot/DeepLinks.swift b/apps/macos/Sources/Moltbot/DeepLinks.swift new file mode 100644 index 000000000..1d8b42d96 --- /dev/null +++ b/apps/macos/Sources/Moltbot/DeepLinks.swift @@ -0,0 +1,151 @@ +import AppKit +import MoltbotKit +import Foundation +import OSLog +import Security + +private let deepLinkLogger = Logger(subsystem: "bot.molt", category: "DeepLink") + +@MainActor +final class DeepLinkHandler { + static let shared = DeepLinkHandler() + + private var lastPromptAt: Date = .distantPast + + // Ephemeral, in-memory key used for unattended deep links originating from the in-app Canvas. + // This avoids blocking Canvas init on UserDefaults and doesn't weaken the external deep-link prompt: + // outside callers can't know this randomly generated key. + private nonisolated static let canvasUnattendedKey: String = DeepLinkHandler.generateRandomKey() + + func handle(url: URL) async { + guard let route = DeepLinkParser.parse(url) else { + deepLinkLogger.debug("ignored url \(url.absoluteString, privacy: .public)") + return + } + guard !AppStateStore.shared.isPaused else { + self.presentAlert(title: "Moltbot is paused", message: "Unpause Moltbot to run agent actions.") + return + } + + switch route { + case let .agent(link): + await self.handleAgent(link: link, originalURL: url) + } + } + + private func handleAgent(link: AgentDeepLink, originalURL: URL) async { + let messagePreview = link.message.trimmingCharacters(in: .whitespacesAndNewlines) + if messagePreview.count > 20000 { + self.presentAlert(title: "Deep link too large", message: "Message exceeds 20,000 characters.") + return + } + + let allowUnattended = link.key == Self.canvasUnattendedKey || link.key == Self.expectedKey() + if !allowUnattended { + if Date().timeIntervalSince(self.lastPromptAt) < 1.0 { + deepLinkLogger.debug("throttling deep link prompt") + return + } + self.lastPromptAt = Date() + + let trimmed = messagePreview.count > 240 ? "\(messagePreview.prefix(240))…" : messagePreview + let body = + "Run the agent with this message?\n\n\(trimmed)\n\nURL:\n\(originalURL.absoluteString)" + guard self.confirm(title: "Run Moltbot agent?", message: body) else { return } + } + + if AppStateStore.shared.connectionMode == .local { + GatewayProcessManager.shared.setActive(true) + } + + do { + let channel = GatewayAgentChannel(raw: link.channel) + let explicitSessionKey = link.sessionKey? + .trimmingCharacters(in: .whitespacesAndNewlines) + .nonEmpty + let resolvedSessionKey: String = if let explicitSessionKey { + explicitSessionKey + } else { + await GatewayConnection.shared.mainSessionKey() + } + let invocation = GatewayAgentInvocation( + message: messagePreview, + sessionKey: resolvedSessionKey, + thinking: link.thinking?.trimmingCharacters(in: .whitespacesAndNewlines).nonEmpty, + deliver: channel.shouldDeliver(link.deliver), + to: link.to?.trimmingCharacters(in: .whitespacesAndNewlines).nonEmpty, + channel: channel, + timeoutSeconds: link.timeoutSeconds, + idempotencyKey: UUID().uuidString) + + let res = await GatewayConnection.shared.sendAgent(invocation) + if !res.ok { + throw NSError( + domain: "DeepLink", + code: 1, + userInfo: [NSLocalizedDescriptionKey: res.error ?? "agent request failed"]) + } + } catch { + self.presentAlert(title: "Agent request failed", message: error.localizedDescription) + } + } + + // MARK: - Auth + + static func currentKey() -> String { + self.expectedKey() + } + + static func currentCanvasKey() -> String { + self.canvasUnattendedKey + } + + private static func expectedKey() -> String { + let defaults = UserDefaults.standard + if let key = defaults.string(forKey: deepLinkKeyKey), !key.isEmpty { + return key + } + var bytes = [UInt8](repeating: 0, count: 32) + _ = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes) + let data = Data(bytes) + let key = data + .base64EncodedString() + .replacingOccurrences(of: "+", with: "-") + .replacingOccurrences(of: "/", with: "_") + .replacingOccurrences(of: "=", with: "") + defaults.set(key, forKey: deepLinkKeyKey) + return key + } + + private nonisolated static func generateRandomKey() -> String { + var bytes = [UInt8](repeating: 0, count: 32) + _ = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes) + let data = Data(bytes) + return data + .base64EncodedString() + .replacingOccurrences(of: "+", with: "-") + .replacingOccurrences(of: "/", with: "_") + .replacingOccurrences(of: "=", with: "") + } + + // MARK: - UI + + private func confirm(title: String, message: String) -> Bool { + let alert = NSAlert() + alert.messageText = title + alert.informativeText = message + alert.addButton(withTitle: "Run") + alert.addButton(withTitle: "Cancel") + alert.alertStyle = .warning + return alert.runModal() == .alertFirstButtonReturn + } + + private func presentAlert(title: String, message: String) { + let alert = NSAlert() + alert.messageText = title + alert.informativeText = message + alert.addButton(withTitle: "OK") + alert.alertStyle = .informational + alert.runModal() + } +} diff --git a/apps/macos/Sources/Moltbot/DevicePairingApprovalPrompter.swift b/apps/macos/Sources/Moltbot/DevicePairingApprovalPrompter.swift new file mode 100644 index 000000000..39ec6d8ac --- /dev/null +++ b/apps/macos/Sources/Moltbot/DevicePairingApprovalPrompter.swift @@ -0,0 +1,334 @@ +import AppKit +import MoltbotKit +import MoltbotProtocol +import Foundation +import Observation +import OSLog + +@MainActor +@Observable +final class DevicePairingApprovalPrompter { + static let shared = DevicePairingApprovalPrompter() + + private let logger = Logger(subsystem: "bot.molt", category: "device-pairing") + private var task: Task? + private var isStopping = false + private var isPresenting = false + private var queue: [PendingRequest] = [] + var pendingCount: Int = 0 + var pendingRepairCount: Int = 0 + private var activeAlert: NSAlert? + private var activeRequestId: String? + private var alertHostWindow: NSWindow? + private var resolvedByRequestId: Set = [] + + private final class AlertHostWindow: NSWindow { + override var canBecomeKey: Bool { true } + override var canBecomeMain: Bool { true } + } + + private struct PairingList: Codable { + let pending: [PendingRequest] + let paired: [PairedDevice]? + } + + private struct PairedDevice: Codable, Equatable { + let deviceId: String + let approvedAtMs: Double? + let displayName: String? + let platform: String? + let remoteIp: String? + } + + private struct PendingRequest: Codable, Equatable, Identifiable { + let requestId: String + let deviceId: String + let publicKey: String + let displayName: String? + let platform: String? + let clientId: String? + let clientMode: String? + let role: String? + let scopes: [String]? + let remoteIp: String? + let silent: Bool? + let isRepair: Bool? + let ts: Double + + var id: String { self.requestId } + } + + private struct PairingResolvedEvent: Codable { + let requestId: String + let deviceId: String + let decision: String + let ts: Double + } + + private enum PairingResolution: String { + case approved + case rejected + } + + func start() { + guard self.task == nil else { return } + self.isStopping = false + self.task = Task { [weak self] in + guard let self else { return } + _ = try? await GatewayConnection.shared.refresh() + await self.loadPendingRequestsFromGateway() + let stream = await GatewayConnection.shared.subscribe(bufferingNewest: 200) + for await push in stream { + if Task.isCancelled { return } + await MainActor.run { [weak self] in self?.handle(push: push) } + } + } + } + + func stop() { + self.isStopping = true + self.endActiveAlert() + self.task?.cancel() + self.task = nil + self.queue.removeAll(keepingCapacity: false) + self.updatePendingCounts() + self.isPresenting = false + self.activeRequestId = nil + self.alertHostWindow?.orderOut(nil) + self.alertHostWindow?.close() + self.alertHostWindow = nil + self.resolvedByRequestId.removeAll(keepingCapacity: false) + } + + private func loadPendingRequestsFromGateway() async { + do { + let list: PairingList = try await GatewayConnection.shared.requestDecoded(method: .devicePairList) + await self.apply(list: list) + } catch { + self.logger.error("failed to load device pairing requests: \(error.localizedDescription, privacy: .public)") + } + } + + private func apply(list: PairingList) async { + self.queue = list.pending.sorted(by: { $0.ts > $1.ts }) + self.updatePendingCounts() + self.presentNextIfNeeded() + } + + private func updatePendingCounts() { + self.pendingCount = self.queue.count + self.pendingRepairCount = self.queue.count(where: { $0.isRepair == true }) + } + + private func presentNextIfNeeded() { + guard !self.isStopping else { return } + guard !self.isPresenting else { return } + guard let next = self.queue.first else { return } + self.isPresenting = true + self.presentAlert(for: next) + } + + private func presentAlert(for req: PendingRequest) { + self.logger.info("presenting device pairing alert requestId=\(req.requestId, privacy: .public)") + NSApp.activate(ignoringOtherApps: true) + + let alert = NSAlert() + alert.alertStyle = .warning + alert.messageText = "Allow device to connect?" + alert.informativeText = Self.describe(req) + alert.addButton(withTitle: "Later") + alert.addButton(withTitle: "Approve") + alert.addButton(withTitle: "Reject") + if #available(macOS 11.0, *), alert.buttons.indices.contains(2) { + alert.buttons[2].hasDestructiveAction = true + } + + self.activeAlert = alert + self.activeRequestId = req.requestId + let hostWindow = self.requireAlertHostWindow() + + let sheetSize = alert.window.frame.size + if let screen = hostWindow.screen ?? NSScreen.main { + let bounds = screen.visibleFrame + let x = bounds.midX - (sheetSize.width / 2) + let sheetOriginY = bounds.midY - (sheetSize.height / 2) + let hostY = sheetOriginY + sheetSize.height - hostWindow.frame.height + hostWindow.setFrameOrigin(NSPoint(x: x, y: hostY)) + } else { + hostWindow.center() + } + + hostWindow.makeKeyAndOrderFront(nil) + alert.beginSheetModal(for: hostWindow) { [weak self] response in + Task { @MainActor [weak self] in + guard let self else { return } + self.activeRequestId = nil + self.activeAlert = nil + await self.handleAlertResponse(response, request: req) + hostWindow.orderOut(nil) + } + } + } + + private func handleAlertResponse(_ response: NSApplication.ModalResponse, request: PendingRequest) async { + var shouldRemove = response != .alertFirstButtonReturn + defer { + if shouldRemove { + if self.queue.first == request { + self.queue.removeFirst() + } else { + self.queue.removeAll { $0 == request } + } + } + self.updatePendingCounts() + self.isPresenting = false + self.presentNextIfNeeded() + } + + guard !self.isStopping else { return } + + if self.resolvedByRequestId.remove(request.requestId) != nil { + return + } + + switch response { + case .alertFirstButtonReturn: + shouldRemove = false + if let idx = self.queue.firstIndex(of: request) { + self.queue.remove(at: idx) + } + self.queue.append(request) + return + case .alertSecondButtonReturn: + _ = await self.approve(requestId: request.requestId) + case .alertThirdButtonReturn: + await self.reject(requestId: request.requestId) + default: + return + } + } + + private func approve(requestId: String) async -> Bool { + do { + try await GatewayConnection.shared.devicePairApprove(requestId: requestId) + self.logger.info("approved device pairing requestId=\(requestId, privacy: .public)") + return true + } catch { + self.logger.error("approve failed requestId=\(requestId, privacy: .public)") + self.logger.error("approve failed: \(error.localizedDescription, privacy: .public)") + return false + } + } + + private func reject(requestId: String) async { + do { + try await GatewayConnection.shared.devicePairReject(requestId: requestId) + self.logger.info("rejected device pairing requestId=\(requestId, privacy: .public)") + } catch { + self.logger.error("reject failed requestId=\(requestId, privacy: .public)") + self.logger.error("reject failed: \(error.localizedDescription, privacy: .public)") + } + } + + private func endActiveAlert() { + guard let alert = self.activeAlert else { return } + if let parent = alert.window.sheetParent { + parent.endSheet(alert.window, returnCode: .abort) + } + self.activeAlert = nil + self.activeRequestId = nil + } + + private func requireAlertHostWindow() -> NSWindow { + if let alertHostWindow { + return alertHostWindow + } + + let window = AlertHostWindow( + contentRect: NSRect(x: 0, y: 0, width: 520, height: 1), + styleMask: [.borderless], + backing: .buffered, + defer: false) + window.title = "" + window.isReleasedWhenClosed = false + window.level = .floating + window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary] + window.isOpaque = false + window.hasShadow = false + window.backgroundColor = .clear + window.ignoresMouseEvents = true + + self.alertHostWindow = window + return window + } + + private func handle(push: GatewayPush) { + switch push { + case let .event(evt) where evt.event == "device.pair.requested": + guard let payload = evt.payload else { return } + do { + let req = try GatewayPayloadDecoding.decode(payload, as: PendingRequest.self) + self.enqueue(req) + } catch { + self.logger + .error("failed to decode device pairing request: \(error.localizedDescription, privacy: .public)") + } + case let .event(evt) where evt.event == "device.pair.resolved": + guard let payload = evt.payload else { return } + do { + let resolved = try GatewayPayloadDecoding.decode(payload, as: PairingResolvedEvent.self) + self.handleResolved(resolved) + } catch { + self.logger + .error( + "failed to decode device pairing resolution: \(error.localizedDescription, privacy: .public)") + } + default: + break + } + } + + private func enqueue(_ req: PendingRequest) { + guard !self.queue.contains(req) else { return } + self.queue.append(req) + self.updatePendingCounts() + self.presentNextIfNeeded() + } + + private func handleResolved(_ resolved: PairingResolvedEvent) { + let resolution = resolved.decision == PairingResolution.approved.rawValue ? PairingResolution + .approved : .rejected + if let activeRequestId, activeRequestId == resolved.requestId { + self.resolvedByRequestId.insert(resolved.requestId) + self.endActiveAlert() + let decision = resolution.rawValue + self.logger.info( + "device pairing resolved while active requestId=\(resolved.requestId, privacy: .public) " + + "decision=\(decision, privacy: .public)") + return + } + self.queue.removeAll { $0.requestId == resolved.requestId } + self.updatePendingCounts() + } + + private static func describe(_ req: PendingRequest) -> String { + var lines: [String] = [] + lines.append("Device: \(req.displayName ?? req.deviceId)") + if let platform = req.platform { + lines.append("Platform: \(platform)") + } + if let role = req.role { + lines.append("Role: \(role)") + } + if let scopes = req.scopes, !scopes.isEmpty { + lines.append("Scopes: \(scopes.joined(separator: ", "))") + } + if let remoteIp = req.remoteIp { + lines.append("IP: \(remoteIp)") + } + if req.isRepair == true { + lines.append("Repair: yes") + } + return lines.joined(separator: "\n") + } +} diff --git a/apps/macos/Sources/Moltbot/DockIconManager.swift b/apps/macos/Sources/Moltbot/DockIconManager.swift new file mode 100644 index 000000000..b00cfe953 --- /dev/null +++ b/apps/macos/Sources/Moltbot/DockIconManager.swift @@ -0,0 +1,116 @@ +import AppKit + +/// Central manager for Dock icon visibility. +/// Shows the Dock icon while any windows are visible, regardless of user preference. +final class DockIconManager: NSObject, @unchecked Sendable { + static let shared = DockIconManager() + + private var windowsObservation: NSKeyValueObservation? + private let logger = Logger(subsystem: "bot.molt", category: "DockIconManager") + + override private init() { + super.init() + self.setupObservers() + Task { @MainActor in + self.updateDockVisibility() + } + } + + deinit { + self.windowsObservation?.invalidate() + NotificationCenter.default.removeObserver(self) + } + + func updateDockVisibility() { + Task { @MainActor in + guard NSApp != nil else { + self.logger.warning("NSApp not ready, skipping Dock visibility update") + return + } + + let userWantsDockHidden = !UserDefaults.standard.bool(forKey: showDockIconKey) + let visibleWindows = NSApp?.windows.filter { window in + window.isVisible && + window.frame.width > 1 && + window.frame.height > 1 && + !window.isKind(of: NSPanel.self) && + "\(type(of: window))" != "NSPopupMenuWindow" && + window.contentViewController != nil + } ?? [] + + let hasVisibleWindows = !visibleWindows.isEmpty + if !userWantsDockHidden || hasVisibleWindows { + NSApp?.setActivationPolicy(.regular) + } else { + NSApp?.setActivationPolicy(.accessory) + } + } + } + + func temporarilyShowDock() { + Task { @MainActor in + guard NSApp != nil else { + self.logger.warning("NSApp not ready, cannot show Dock icon") + return + } + NSApp.setActivationPolicy(.regular) + } + } + + private func setupObservers() { + Task { @MainActor in + guard let app = NSApp else { + self.logger.warning("NSApp not ready, delaying Dock observers") + try? await Task.sleep(for: .milliseconds(200)) + self.setupObservers() + return + } + + self.windowsObservation = app.observe(\.windows, options: [.new]) { [weak self] _, _ in + Task { @MainActor in + try? await Task.sleep(for: .milliseconds(50)) + self?.updateDockVisibility() + } + } + + NotificationCenter.default.addObserver( + self, + selector: #selector(self.windowVisibilityChanged), + name: NSWindow.didBecomeKeyNotification, + object: nil) + NotificationCenter.default.addObserver( + self, + selector: #selector(self.windowVisibilityChanged), + name: NSWindow.didResignKeyNotification, + object: nil) + NotificationCenter.default.addObserver( + self, + selector: #selector(self.windowVisibilityChanged), + name: NSWindow.willCloseNotification, + object: nil) + NotificationCenter.default.addObserver( + self, + selector: #selector(self.dockPreferenceChanged), + name: UserDefaults.didChangeNotification, + object: nil) + } + } + + @objc + private func windowVisibilityChanged(_: Notification) { + Task { @MainActor in + self.updateDockVisibility() + } + } + + @objc + private func dockPreferenceChanged(_ notification: Notification) { + guard let userDefaults = notification.object as? UserDefaults, + userDefaults == UserDefaults.standard + else { return } + + Task { @MainActor in + self.updateDockVisibility() + } + } +} diff --git a/apps/macos/Sources/Moltbot/ExecApprovals.swift b/apps/macos/Sources/Moltbot/ExecApprovals.swift new file mode 100644 index 000000000..6fe92626c --- /dev/null +++ b/apps/macos/Sources/Moltbot/ExecApprovals.swift @@ -0,0 +1,790 @@ +import CryptoKit +import Foundation +import OSLog +import Security + +enum ExecSecurity: String, CaseIterable, Codable, Identifiable { + case deny + case allowlist + case full + + var id: String { self.rawValue } + + var title: String { + switch self { + case .deny: "Deny" + case .allowlist: "Allowlist" + case .full: "Always Allow" + } + } +} + +enum ExecApprovalQuickMode: String, CaseIterable, Identifiable { + case deny + case ask + case allow + + var id: String { self.rawValue } + + var title: String { + switch self { + case .deny: "Deny" + case .ask: "Always Ask" + case .allow: "Always Allow" + } + } + + var security: ExecSecurity { + switch self { + case .deny: .deny + case .ask: .allowlist + case .allow: .full + } + } + + var ask: ExecAsk { + switch self { + case .deny: .off + case .ask: .onMiss + case .allow: .off + } + } + + static func from(security: ExecSecurity, ask: ExecAsk) -> ExecApprovalQuickMode { + switch security { + case .deny: + .deny + case .full: + .allow + case .allowlist: + .ask + } + } +} + +enum ExecAsk: String, CaseIterable, Codable, Identifiable { + case off + case onMiss = "on-miss" + case always + + var id: String { self.rawValue } + + var title: String { + switch self { + case .off: "Never Ask" + case .onMiss: "Ask on Allowlist Miss" + case .always: "Always Ask" + } + } +} + +enum ExecApprovalDecision: String, Codable, Sendable { + case allowOnce = "allow-once" + case allowAlways = "allow-always" + case deny +} + +struct ExecAllowlistEntry: Codable, Hashable, Identifiable { + var id: UUID + var pattern: String + var lastUsedAt: Double? + var lastUsedCommand: String? + var lastResolvedPath: String? + + init( + id: UUID = UUID(), + pattern: String, + lastUsedAt: Double? = nil, + lastUsedCommand: String? = nil, + lastResolvedPath: String? = nil) + { + self.id = id + self.pattern = pattern + self.lastUsedAt = lastUsedAt + self.lastUsedCommand = lastUsedCommand + self.lastResolvedPath = lastResolvedPath + } + + private enum CodingKeys: String, CodingKey { + case id + case pattern + case lastUsedAt + case lastUsedCommand + case lastResolvedPath + } + + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: CodingKeys.self) + self.id = try container.decodeIfPresent(UUID.self, forKey: .id) ?? UUID() + self.pattern = try container.decode(String.self, forKey: .pattern) + self.lastUsedAt = try container.decodeIfPresent(Double.self, forKey: .lastUsedAt) + self.lastUsedCommand = try container.decodeIfPresent(String.self, forKey: .lastUsedCommand) + self.lastResolvedPath = try container.decodeIfPresent(String.self, forKey: .lastResolvedPath) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(self.id, forKey: .id) + try container.encode(self.pattern, forKey: .pattern) + try container.encodeIfPresent(self.lastUsedAt, forKey: .lastUsedAt) + try container.encodeIfPresent(self.lastUsedCommand, forKey: .lastUsedCommand) + try container.encodeIfPresent(self.lastResolvedPath, forKey: .lastResolvedPath) + } +} + +struct ExecApprovalsDefaults: Codable { + var security: ExecSecurity? + var ask: ExecAsk? + var askFallback: ExecSecurity? + var autoAllowSkills: Bool? +} + +struct ExecApprovalsAgent: Codable { + var security: ExecSecurity? + var ask: ExecAsk? + var askFallback: ExecSecurity? + var autoAllowSkills: Bool? + var allowlist: [ExecAllowlistEntry]? + + var isEmpty: Bool { + self.security == nil && self.ask == nil && self.askFallback == nil && self + .autoAllowSkills == nil && (self.allowlist?.isEmpty ?? true) + } +} + +struct ExecApprovalsSocketConfig: Codable { + var path: String? + var token: String? +} + +struct ExecApprovalsFile: Codable { + var version: Int + var socket: ExecApprovalsSocketConfig? + var defaults: ExecApprovalsDefaults? + var agents: [String: ExecApprovalsAgent]? +} + +struct ExecApprovalsSnapshot: Codable { + var path: String + var exists: Bool + var hash: String + var file: ExecApprovalsFile +} + +struct ExecApprovalsResolved { + let url: URL + let socketPath: String + let token: String + let defaults: ExecApprovalsResolvedDefaults + let agent: ExecApprovalsResolvedDefaults + let allowlist: [ExecAllowlistEntry] + var file: ExecApprovalsFile +} + +struct ExecApprovalsResolvedDefaults { + var security: ExecSecurity + var ask: ExecAsk + var askFallback: ExecSecurity + var autoAllowSkills: Bool +} + +enum ExecApprovalsStore { + private static let logger = Logger(subsystem: "bot.molt", category: "exec-approvals") + private static let defaultAgentId = "main" + private static let defaultSecurity: ExecSecurity = .deny + private static let defaultAsk: ExecAsk = .onMiss + private static let defaultAskFallback: ExecSecurity = .deny + private static let defaultAutoAllowSkills = false + + static func fileURL() -> URL { + MoltbotPaths.stateDirURL.appendingPathComponent("exec-approvals.json") + } + + static func socketPath() -> String { + MoltbotPaths.stateDirURL.appendingPathComponent("exec-approvals.sock").path + } + + static func normalizeIncoming(_ file: ExecApprovalsFile) -> ExecApprovalsFile { + let socketPath = file.socket?.path?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + let token = file.socket?.token?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + var agents = file.agents ?? [:] + if let legacyDefault = agents["default"] { + if let main = agents[self.defaultAgentId] { + agents[self.defaultAgentId] = self.mergeAgents(current: main, legacy: legacyDefault) + } else { + agents[self.defaultAgentId] = legacyDefault + } + agents.removeValue(forKey: "default") + } + return ExecApprovalsFile( + version: 1, + socket: ExecApprovalsSocketConfig( + path: socketPath.isEmpty ? nil : socketPath, + token: token.isEmpty ? nil : token), + defaults: file.defaults, + agents: agents) + } + + static func readSnapshot() -> ExecApprovalsSnapshot { + let url = self.fileURL() + guard FileManager().fileExists(atPath: url.path) else { + return ExecApprovalsSnapshot( + path: url.path, + exists: false, + hash: self.hashRaw(nil), + file: ExecApprovalsFile(version: 1, socket: nil, defaults: nil, agents: [:])) + } + let raw = try? String(contentsOf: url, encoding: .utf8) + let data = raw.flatMap { $0.data(using: .utf8) } + let decoded: ExecApprovalsFile = { + if let data, let file = try? JSONDecoder().decode(ExecApprovalsFile.self, from: data), file.version == 1 { + return file + } + return ExecApprovalsFile(version: 1, socket: nil, defaults: nil, agents: [:]) + }() + return ExecApprovalsSnapshot( + path: url.path, + exists: true, + hash: self.hashRaw(raw), + file: decoded) + } + + static func redactForSnapshot(_ file: ExecApprovalsFile) -> ExecApprovalsFile { + let socketPath = file.socket?.path?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if socketPath.isEmpty { + return ExecApprovalsFile( + version: file.version, + socket: nil, + defaults: file.defaults, + agents: file.agents) + } + return ExecApprovalsFile( + version: file.version, + socket: ExecApprovalsSocketConfig(path: socketPath, token: nil), + defaults: file.defaults, + agents: file.agents) + } + + static func loadFile() -> ExecApprovalsFile { + let url = self.fileURL() + guard FileManager().fileExists(atPath: url.path) else { + return ExecApprovalsFile(version: 1, socket: nil, defaults: nil, agents: [:]) + } + do { + let data = try Data(contentsOf: url) + let decoded = try JSONDecoder().decode(ExecApprovalsFile.self, from: data) + if decoded.version != 1 { + return ExecApprovalsFile(version: 1, socket: nil, defaults: nil, agents: [:]) + } + return decoded + } catch { + self.logger.warning("exec approvals load failed: \(error.localizedDescription, privacy: .public)") + return ExecApprovalsFile(version: 1, socket: nil, defaults: nil, agents: [:]) + } + } + + static func saveFile(_ file: ExecApprovalsFile) { + do { + let encoder = JSONEncoder() + encoder.outputFormatting = [.prettyPrinted, .sortedKeys] + let data = try encoder.encode(file) + let url = self.fileURL() + try FileManager().createDirectory( + at: url.deletingLastPathComponent(), + withIntermediateDirectories: true) + try data.write(to: url, options: [.atomic]) + try? FileManager().setAttributes([.posixPermissions: 0o600], ofItemAtPath: url.path) + } catch { + self.logger.error("exec approvals save failed: \(error.localizedDescription, privacy: .public)") + } + } + + static func ensureFile() -> ExecApprovalsFile { + var file = self.loadFile() + if file.socket == nil { file.socket = ExecApprovalsSocketConfig(path: nil, token: nil) } + let path = file.socket?.path?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if path.isEmpty { + file.socket?.path = self.socketPath() + } + let token = file.socket?.token?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if token.isEmpty { + file.socket?.token = self.generateToken() + } + if file.agents == nil { file.agents = [:] } + self.saveFile(file) + return file + } + + static func resolve(agentId: String?) -> ExecApprovalsResolved { + let file = self.ensureFile() + let defaults = file.defaults ?? ExecApprovalsDefaults() + let resolvedDefaults = ExecApprovalsResolvedDefaults( + security: defaults.security ?? self.defaultSecurity, + ask: defaults.ask ?? self.defaultAsk, + askFallback: defaults.askFallback ?? self.defaultAskFallback, + autoAllowSkills: defaults.autoAllowSkills ?? self.defaultAutoAllowSkills) + let key = self.agentKey(agentId) + let agentEntry = file.agents?[key] ?? ExecApprovalsAgent() + let wildcardEntry = file.agents?["*"] ?? ExecApprovalsAgent() + let resolvedAgent = ExecApprovalsResolvedDefaults( + security: agentEntry.security ?? wildcardEntry.security ?? resolvedDefaults.security, + ask: agentEntry.ask ?? wildcardEntry.ask ?? resolvedDefaults.ask, + askFallback: agentEntry.askFallback ?? wildcardEntry.askFallback + ?? resolvedDefaults.askFallback, + autoAllowSkills: agentEntry.autoAllowSkills ?? wildcardEntry.autoAllowSkills + ?? resolvedDefaults.autoAllowSkills) + let allowlist = ((wildcardEntry.allowlist ?? []) + (agentEntry.allowlist ?? [])) + .map { entry in + ExecAllowlistEntry( + id: entry.id, + pattern: entry.pattern.trimmingCharacters(in: .whitespacesAndNewlines), + lastUsedAt: entry.lastUsedAt, + lastUsedCommand: entry.lastUsedCommand, + lastResolvedPath: entry.lastResolvedPath) + } + .filter { !$0.pattern.isEmpty } + let socketPath = self.expandPath(file.socket?.path ?? self.socketPath()) + let token = file.socket?.token ?? "" + return ExecApprovalsResolved( + url: self.fileURL(), + socketPath: socketPath, + token: token, + defaults: resolvedDefaults, + agent: resolvedAgent, + allowlist: allowlist, + file: file) + } + + static func resolveDefaults() -> ExecApprovalsResolvedDefaults { + let file = self.ensureFile() + let defaults = file.defaults ?? ExecApprovalsDefaults() + return ExecApprovalsResolvedDefaults( + security: defaults.security ?? self.defaultSecurity, + ask: defaults.ask ?? self.defaultAsk, + askFallback: defaults.askFallback ?? self.defaultAskFallback, + autoAllowSkills: defaults.autoAllowSkills ?? self.defaultAutoAllowSkills) + } + + static func saveDefaults(_ defaults: ExecApprovalsDefaults) { + self.updateFile { file in + file.defaults = defaults + } + } + + static func updateDefaults(_ mutate: (inout ExecApprovalsDefaults) -> Void) { + self.updateFile { file in + var defaults = file.defaults ?? ExecApprovalsDefaults() + mutate(&defaults) + file.defaults = defaults + } + } + + static func saveAgent(_ agent: ExecApprovalsAgent, agentId: String?) { + self.updateFile { file in + var agents = file.agents ?? [:] + let key = self.agentKey(agentId) + if agent.isEmpty { + agents.removeValue(forKey: key) + } else { + agents[key] = agent + } + file.agents = agents.isEmpty ? nil : agents + } + } + + static func addAllowlistEntry(agentId: String?, pattern: String) { + let trimmed = pattern.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return } + self.updateFile { file in + let key = self.agentKey(agentId) + var agents = file.agents ?? [:] + var entry = agents[key] ?? ExecApprovalsAgent() + var allowlist = entry.allowlist ?? [] + if allowlist.contains(where: { $0.pattern == trimmed }) { return } + allowlist.append(ExecAllowlistEntry(pattern: trimmed, lastUsedAt: Date().timeIntervalSince1970 * 1000)) + entry.allowlist = allowlist + agents[key] = entry + file.agents = agents + } + } + + static func recordAllowlistUse( + agentId: String?, + pattern: String, + command: String, + resolvedPath: String?) + { + self.updateFile { file in + let key = self.agentKey(agentId) + var agents = file.agents ?? [:] + var entry = agents[key] ?? ExecApprovalsAgent() + let allowlist = (entry.allowlist ?? []).map { item -> ExecAllowlistEntry in + guard item.pattern == pattern else { return item } + return ExecAllowlistEntry( + id: item.id, + pattern: item.pattern, + lastUsedAt: Date().timeIntervalSince1970 * 1000, + lastUsedCommand: command, + lastResolvedPath: resolvedPath) + } + entry.allowlist = allowlist + agents[key] = entry + file.agents = agents + } + } + + static func updateAllowlist(agentId: String?, allowlist: [ExecAllowlistEntry]) { + self.updateFile { file in + let key = self.agentKey(agentId) + var agents = file.agents ?? [:] + var entry = agents[key] ?? ExecApprovalsAgent() + let cleaned = allowlist + .map { item in + ExecAllowlistEntry( + id: item.id, + pattern: item.pattern.trimmingCharacters(in: .whitespacesAndNewlines), + lastUsedAt: item.lastUsedAt, + lastUsedCommand: item.lastUsedCommand, + lastResolvedPath: item.lastResolvedPath) + } + .filter { !$0.pattern.isEmpty } + entry.allowlist = cleaned + agents[key] = entry + file.agents = agents + } + } + + static func updateAgentSettings(agentId: String?, mutate: (inout ExecApprovalsAgent) -> Void) { + self.updateFile { file in + let key = self.agentKey(agentId) + var agents = file.agents ?? [:] + var entry = agents[key] ?? ExecApprovalsAgent() + mutate(&entry) + if entry.isEmpty { + agents.removeValue(forKey: key) + } else { + agents[key] = entry + } + file.agents = agents.isEmpty ? nil : agents + } + } + + private static func updateFile(_ mutate: (inout ExecApprovalsFile) -> Void) { + var file = self.ensureFile() + mutate(&file) + self.saveFile(file) + } + + private static func generateToken() -> String { + var bytes = [UInt8](repeating: 0, count: 24) + let status = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes) + if status == errSecSuccess { + return Data(bytes) + .base64EncodedString() + .replacingOccurrences(of: "+", with: "-") + .replacingOccurrences(of: "/", with: "_") + .replacingOccurrences(of: "=", with: "") + } + return UUID().uuidString + } + + private static func hashRaw(_ raw: String?) -> String { + let data = Data((raw ?? "").utf8) + let digest = SHA256.hash(data: data) + return digest.map { String(format: "%02x", $0) }.joined() + } + + private static func expandPath(_ raw: String) -> String { + let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) + if trimmed == "~" { + return FileManager().homeDirectoryForCurrentUser.path + } + if trimmed.hasPrefix("~/") { + let suffix = trimmed.dropFirst(2) + return FileManager().homeDirectoryForCurrentUser + .appendingPathComponent(String(suffix)).path + } + return trimmed + } + + private static func agentKey(_ agentId: String?) -> String { + let trimmed = agentId?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + return trimmed.isEmpty ? self.defaultAgentId : trimmed + } + + private static func normalizedPattern(_ pattern: String?) -> String? { + let trimmed = pattern?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + return trimmed.isEmpty ? nil : trimmed.lowercased() + } + + private static func mergeAgents( + current: ExecApprovalsAgent, + legacy: ExecApprovalsAgent) -> ExecApprovalsAgent + { + var seen = Set() + var allowlist: [ExecAllowlistEntry] = [] + func append(_ entry: ExecAllowlistEntry) { + guard let key = self.normalizedPattern(entry.pattern), !seen.contains(key) else { + return + } + seen.insert(key) + allowlist.append(entry) + } + for entry in current.allowlist ?? [] { + append(entry) + } + for entry in legacy.allowlist ?? [] { + append(entry) + } + + return ExecApprovalsAgent( + security: current.security ?? legacy.security, + ask: current.ask ?? legacy.ask, + askFallback: current.askFallback ?? legacy.askFallback, + autoAllowSkills: current.autoAllowSkills ?? legacy.autoAllowSkills, + allowlist: allowlist.isEmpty ? nil : allowlist) + } +} + +struct ExecCommandResolution: Sendable { + let rawExecutable: String + let resolvedPath: String? + let executableName: String + let cwd: String? + + static func resolve( + command: [String], + rawCommand: String?, + cwd: String?, + env: [String: String]?) -> ExecCommandResolution? + { + let trimmedRaw = rawCommand?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if !trimmedRaw.isEmpty, let token = self.parseFirstToken(trimmedRaw) { + return self.resolveExecutable(rawExecutable: token, cwd: cwd, env: env) + } + return self.resolve(command: command, cwd: cwd, env: env) + } + + static func resolve(command: [String], cwd: String?, env: [String: String]?) -> ExecCommandResolution? { + guard let raw = command.first?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else { + return nil + } + return self.resolveExecutable(rawExecutable: raw, cwd: cwd, env: env) + } + + private static func resolveExecutable( + rawExecutable: String, + cwd: String?, + env: [String: String]?) -> ExecCommandResolution? + { + let expanded = rawExecutable.hasPrefix("~") ? (rawExecutable as NSString).expandingTildeInPath : rawExecutable + let hasPathSeparator = expanded.contains("/") || expanded.contains("\\") + let resolvedPath: String? = { + if hasPathSeparator { + if expanded.hasPrefix("/") { + return expanded + } + let base = cwd?.trimmingCharacters(in: .whitespacesAndNewlines) + let root = (base?.isEmpty == false) ? base! : FileManager().currentDirectoryPath + return URL(fileURLWithPath: root).appendingPathComponent(expanded).path + } + let searchPaths = self.searchPaths(from: env) + return CommandResolver.findExecutable(named: expanded, searchPaths: searchPaths) + }() + let name = resolvedPath.map { URL(fileURLWithPath: $0).lastPathComponent } ?? expanded + return ExecCommandResolution( + rawExecutable: expanded, + resolvedPath: resolvedPath, + executableName: name, + cwd: cwd) + } + + private static func parseFirstToken(_ command: String) -> String? { + let trimmed = command.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return nil } + guard let first = trimmed.first else { return nil } + if first == "\"" || first == "'" { + let rest = trimmed.dropFirst() + if let end = rest.firstIndex(of: first) { + return String(rest[.. [String] { + let raw = env?["PATH"] + if let raw, !raw.isEmpty { + return raw.split(separator: ":").map(String.init) + } + return CommandResolver.preferredPaths() + } +} + +enum ExecCommandFormatter { + static func displayString(for argv: [String]) -> String { + argv.map { arg in + let trimmed = arg.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return "\"\"" } + let needsQuotes = trimmed.contains { $0.isWhitespace || $0 == "\"" } + if !needsQuotes { return trimmed } + let escaped = trimmed.replacingOccurrences(of: "\"", with: "\\\"") + return "\"\(escaped)\"" + }.joined(separator: " ") + } + + static func displayString(for argv: [String], rawCommand: String?) -> String { + let trimmed = rawCommand?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if !trimmed.isEmpty { return trimmed } + return self.displayString(for: argv) + } +} + +enum ExecApprovalHelpers { + static func parseDecision(_ raw: String?) -> ExecApprovalDecision? { + let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + guard !trimmed.isEmpty else { return nil } + return ExecApprovalDecision(rawValue: trimmed) + } + + static func requiresAsk( + ask: ExecAsk, + security: ExecSecurity, + allowlistMatch: ExecAllowlistEntry?, + skillAllow: Bool) -> Bool + { + if ask == .always { return true } + if ask == .onMiss, security == .allowlist, allowlistMatch == nil, !skillAllow { return true } + return false + } + + static func allowlistPattern(command: [String], resolution: ExecCommandResolution?) -> String? { + let pattern = resolution?.resolvedPath ?? resolution?.rawExecutable ?? command.first ?? "" + return pattern.isEmpty ? nil : pattern + } +} + +enum ExecAllowlistMatcher { + static func match(entries: [ExecAllowlistEntry], resolution: ExecCommandResolution?) -> ExecAllowlistEntry? { + guard let resolution, !entries.isEmpty else { return nil } + let rawExecutable = resolution.rawExecutable + let resolvedPath = resolution.resolvedPath + let executableName = resolution.executableName + + for entry in entries { + let pattern = entry.pattern.trimmingCharacters(in: .whitespacesAndNewlines) + if pattern.isEmpty { continue } + let hasPath = pattern.contains("/") || pattern.contains("~") || pattern.contains("\\") + if hasPath { + let target = resolvedPath ?? rawExecutable + if self.matches(pattern: pattern, target: target) { return entry } + } else if self.matches(pattern: pattern, target: executableName) { + return entry + } + } + return nil + } + + private static func matches(pattern: String, target: String) -> Bool { + let trimmed = pattern.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return false } + let expanded = trimmed.hasPrefix("~") ? (trimmed as NSString).expandingTildeInPath : trimmed + let normalizedPattern = self.normalizeMatchTarget(expanded) + let normalizedTarget = self.normalizeMatchTarget(target) + guard let regex = self.regex(for: normalizedPattern) else { return false } + let range = NSRange(location: 0, length: normalizedTarget.utf16.count) + return regex.firstMatch(in: normalizedTarget, options: [], range: range) != nil + } + + private static func normalizeMatchTarget(_ value: String) -> String { + value.replacingOccurrences(of: "\\\\", with: "/").lowercased() + } + + private static func regex(for pattern: String) -> NSRegularExpression? { + var regex = "^" + var idx = pattern.startIndex + while idx < pattern.endIndex { + let ch = pattern[idx] + if ch == "*" { + let next = pattern.index(after: idx) + if next < pattern.endIndex, pattern[next] == "*" { + regex += ".*" + idx = pattern.index(after: next) + } else { + regex += "[^/]*" + idx = next + } + continue + } + if ch == "?" { + regex += "." + idx = pattern.index(after: idx) + continue + } + regex += NSRegularExpression.escapedPattern(for: String(ch)) + idx = pattern.index(after: idx) + } + regex += "$" + return try? NSRegularExpression(pattern: regex, options: [.caseInsensitive]) + } +} + +struct ExecEventPayload: Codable, Sendable { + var sessionKey: String + var runId: String + var host: String + var command: String? + var exitCode: Int? + var timedOut: Bool? + var success: Bool? + var output: String? + var reason: String? + + static func truncateOutput(_ raw: String, maxChars: Int = 20000) -> String? { + let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return nil } + if trimmed.count <= maxChars { return trimmed } + let suffix = trimmed.suffix(maxChars) + return "... (truncated) \(suffix)" + } +} + +actor SkillBinsCache { + static let shared = SkillBinsCache() + + private var bins: Set = [] + private var lastRefresh: Date? + private let refreshInterval: TimeInterval = 90 + + func currentBins(force: Bool = false) async -> Set { + if force || self.isStale() { + await self.refresh() + } + return self.bins + } + + func refresh() async { + do { + let report = try await GatewayConnection.shared.skillsStatus() + var next = Set() + for skill in report.skills { + for bin in skill.requirements.bins { + let trimmed = bin.trimmingCharacters(in: .whitespacesAndNewlines) + if !trimmed.isEmpty { next.insert(trimmed) } + } + } + self.bins = next + self.lastRefresh = Date() + } catch { + if self.lastRefresh == nil { + self.bins = [] + } + } + } + + private func isStale() -> Bool { + guard let lastRefresh else { return true } + return Date().timeIntervalSince(lastRefresh) > self.refreshInterval + } +} diff --git a/apps/macos/Sources/Moltbot/ExecApprovalsGatewayPrompter.swift b/apps/macos/Sources/Moltbot/ExecApprovalsGatewayPrompter.swift new file mode 100644 index 000000000..02b344b58 --- /dev/null +++ b/apps/macos/Sources/Moltbot/ExecApprovalsGatewayPrompter.swift @@ -0,0 +1,123 @@ +import MoltbotKit +import MoltbotProtocol +import CoreGraphics +import Foundation +import OSLog + +@MainActor +final class ExecApprovalsGatewayPrompter { + static let shared = ExecApprovalsGatewayPrompter() + + private let logger = Logger(subsystem: "bot.molt", category: "exec-approvals.gateway") + private var task: Task? + + struct GatewayApprovalRequest: Codable, Sendable { + var id: String + var request: ExecApprovalPromptRequest + var createdAtMs: Int + var expiresAtMs: Int + } + + func start() { + guard self.task == nil else { return } + self.task = Task { [weak self] in + await self?.run() + } + } + + func stop() { + self.task?.cancel() + self.task = nil + } + + private func run() async { + let stream = await GatewayConnection.shared.subscribe(bufferingNewest: 200) + for await push in stream { + if Task.isCancelled { return } + await self.handle(push: push) + } + } + + private func handle(push: GatewayPush) async { + guard case let .event(evt) = push else { return } + guard evt.event == "exec.approval.requested" else { return } + guard let payload = evt.payload else { return } + do { + let data = try JSONEncoder().encode(payload) + let request = try JSONDecoder().decode(GatewayApprovalRequest.self, from: data) + guard self.shouldPresent(request: request) else { return } + let decision = ExecApprovalsPromptPresenter.prompt(request.request) + try await GatewayConnection.shared.requestVoid( + method: .execApprovalResolve, + params: [ + "id": AnyCodable(request.id), + "decision": AnyCodable(decision.rawValue), + ], + timeoutMs: 10000) + } catch { + self.logger.error("exec approval handling failed \(error.localizedDescription, privacy: .public)") + } + } + + private func shouldPresent(request: GatewayApprovalRequest) -> Bool { + let mode = AppStateStore.shared.connectionMode + let activeSession = WebChatManager.shared.activeSessionKey?.trimmingCharacters(in: .whitespacesAndNewlines) + let requestSession = request.request.sessionKey?.trimmingCharacters(in: .whitespacesAndNewlines) + return Self.shouldPresent( + mode: mode, + activeSession: activeSession, + requestSession: requestSession, + lastInputSeconds: Self.lastInputSeconds(), + thresholdSeconds: 120) + } + + private static func shouldPresent( + mode: AppState.ConnectionMode, + activeSession: String?, + requestSession: String?, + lastInputSeconds: Int?, + thresholdSeconds: Int) -> Bool + { + let active = activeSession?.trimmingCharacters(in: .whitespacesAndNewlines) + let requested = requestSession?.trimmingCharacters(in: .whitespacesAndNewlines) + let recentlyActive = lastInputSeconds.map { $0 <= thresholdSeconds } ?? (mode == .local) + + if let session = requested, !session.isEmpty { + if let active, !active.isEmpty { + return active == session + } + return recentlyActive + } + + if let active, !active.isEmpty { + return true + } + return mode == .local + } + + private static func lastInputSeconds() -> Int? { + let anyEvent = CGEventType(rawValue: UInt32.max) ?? .null + let seconds = CGEventSource.secondsSinceLastEventType(.combinedSessionState, eventType: anyEvent) + if seconds.isNaN || seconds.isInfinite || seconds < 0 { return nil } + return Int(seconds.rounded()) + } +} + +#if DEBUG +extension ExecApprovalsGatewayPrompter { + static func _testShouldPresent( + mode: AppState.ConnectionMode, + activeSession: String?, + requestSession: String?, + lastInputSeconds: Int?, + thresholdSeconds: Int = 120) -> Bool + { + self.shouldPresent( + mode: mode, + activeSession: activeSession, + requestSession: requestSession, + lastInputSeconds: lastInputSeconds, + thresholdSeconds: thresholdSeconds) + } +} +#endif diff --git a/apps/macos/Sources/Moltbot/ExecApprovalsSocket.swift b/apps/macos/Sources/Moltbot/ExecApprovalsSocket.swift new file mode 100644 index 000000000..dea2bd5df --- /dev/null +++ b/apps/macos/Sources/Moltbot/ExecApprovalsSocket.swift @@ -0,0 +1,831 @@ +import AppKit +import MoltbotKit +import CryptoKit +import Darwin +import Foundation +import OSLog + +struct ExecApprovalPromptRequest: Codable, Sendable { + var command: String + var cwd: String? + var host: String? + var security: String? + var ask: String? + var agentId: String? + var resolvedPath: String? + var sessionKey: String? +} + +private struct ExecApprovalSocketRequest: Codable { + var type: String + var token: String + var id: String + var request: ExecApprovalPromptRequest +} + +private struct ExecApprovalSocketDecision: Codable { + var type: String + var id: String + var decision: ExecApprovalDecision +} + +private struct ExecHostSocketRequest: Codable { + var type: String + var id: String + var nonce: String + var ts: Int + var hmac: String + var requestJson: String +} + +private struct ExecHostRequest: Codable { + var command: [String] + var rawCommand: String? + var cwd: String? + var env: [String: String]? + var timeoutMs: Int? + var needsScreenRecording: Bool? + var agentId: String? + var sessionKey: String? + var approvalDecision: ExecApprovalDecision? +} + +private struct ExecHostRunResult: Codable { + var exitCode: Int? + var timedOut: Bool + var success: Bool + var stdout: String + var stderr: String + var error: String? +} + +private struct ExecHostError: Codable { + var code: String + var message: String + var reason: String? +} + +private struct ExecHostResponse: Codable { + var type: String + var id: String + var ok: Bool + var payload: ExecHostRunResult? + var error: ExecHostError? +} + +enum ExecApprovalsSocketClient { + private struct TimeoutError: LocalizedError { + var message: String + var errorDescription: String? { self.message } + } + + static func requestDecision( + socketPath: String, + token: String, + request: ExecApprovalPromptRequest, + timeoutMs: Int = 15000) async -> ExecApprovalDecision? + { + let trimmedPath = socketPath.trimmingCharacters(in: .whitespacesAndNewlines) + let trimmedToken = token.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmedPath.isEmpty, !trimmedToken.isEmpty else { return nil } + do { + return try await AsyncTimeout.withTimeoutMs( + timeoutMs: timeoutMs, + onTimeout: { + TimeoutError(message: "exec approvals socket timeout") + }, + operation: { + try await Task.detached { + try self.requestDecisionSync( + socketPath: trimmedPath, + token: trimmedToken, + request: request) + }.value + }) + } catch { + return nil + } + } + + private static func requestDecisionSync( + socketPath: String, + token: String, + request: ExecApprovalPromptRequest) throws -> ExecApprovalDecision? + { + let fd = socket(AF_UNIX, SOCK_STREAM, 0) + guard fd >= 0 else { + throw NSError(domain: "ExecApprovals", code: 1, userInfo: [ + NSLocalizedDescriptionKey: "socket create failed", + ]) + } + + var addr = sockaddr_un() + addr.sun_family = sa_family_t(AF_UNIX) + let maxLen = MemoryLayout.size(ofValue: addr.sun_path) + if socketPath.utf8.count >= maxLen { + throw NSError(domain: "ExecApprovals", code: 2, userInfo: [ + NSLocalizedDescriptionKey: "socket path too long", + ]) + } + socketPath.withCString { cstr in + withUnsafeMutablePointer(to: &addr.sun_path) { ptr in + let raw = UnsafeMutableRawPointer(ptr).assumingMemoryBound(to: Int8.self) + strncpy(raw, cstr, maxLen - 1) + } + } + let size = socklen_t(MemoryLayout.size(ofValue: addr)) + let result = withUnsafePointer(to: &addr) { ptr in + ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { rebound in + connect(fd, rebound, size) + } + } + if result != 0 { + throw NSError(domain: "ExecApprovals", code: 3, userInfo: [ + NSLocalizedDescriptionKey: "socket connect failed", + ]) + } + + let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true) + + let message = ExecApprovalSocketRequest( + type: "request", + token: token, + id: UUID().uuidString, + request: request) + let data = try JSONEncoder().encode(message) + var payload = data + payload.append(0x0A) + try handle.write(contentsOf: payload) + + guard let line = try self.readLine(from: handle, maxBytes: 256_000), + let lineData = line.data(using: .utf8) + else { return nil } + let response = try JSONDecoder().decode(ExecApprovalSocketDecision.self, from: lineData) + return response.decision + } + + private static func readLine(from handle: FileHandle, maxBytes: Int) throws -> String? { + var buffer = Data() + while buffer.count < maxBytes { + let chunk = try handle.read(upToCount: 4096) ?? Data() + if chunk.isEmpty { break } + buffer.append(chunk) + if buffer.contains(0x0A) { break } + } + guard let newlineIndex = buffer.firstIndex(of: 0x0A) else { + guard !buffer.isEmpty else { return nil } + return String(data: buffer, encoding: .utf8) + } + let lineData = buffer.subdata(in: 0.. ExecApprovalDecision { + NSApp.activate(ignoringOtherApps: true) + let alert = NSAlert() + alert.alertStyle = .warning + alert.messageText = "Allow this command?" + alert.informativeText = "Review the command details before allowing." + alert.accessoryView = self.buildAccessoryView(request) + + alert.addButton(withTitle: "Allow Once") + alert.addButton(withTitle: "Always Allow") + alert.addButton(withTitle: "Don't Allow") + if #available(macOS 11.0, *), alert.buttons.indices.contains(2) { + alert.buttons[2].hasDestructiveAction = true + } + + switch alert.runModal() { + case .alertFirstButtonReturn: + return .allowOnce + case .alertSecondButtonReturn: + return .allowAlways + default: + return .deny + } + } + + @MainActor + private static func buildAccessoryView(_ request: ExecApprovalPromptRequest) -> NSView { + let stack = NSStackView() + stack.orientation = .vertical + stack.spacing = 8 + stack.alignment = .leading + + let commandTitle = NSTextField(labelWithString: "Command") + commandTitle.font = NSFont.boldSystemFont(ofSize: NSFont.systemFontSize) + stack.addArrangedSubview(commandTitle) + + let commandText = NSTextView() + commandText.isEditable = false + commandText.isSelectable = true + commandText.drawsBackground = true + commandText.backgroundColor = NSColor.textBackgroundColor + commandText.font = NSFont.monospacedSystemFont(ofSize: NSFont.systemFontSize, weight: .regular) + commandText.string = request.command + commandText.textContainerInset = NSSize(width: 6, height: 6) + commandText.textContainer?.lineFragmentPadding = 0 + commandText.textContainer?.widthTracksTextView = true + commandText.isHorizontallyResizable = false + commandText.isVerticallyResizable = false + + let commandScroll = NSScrollView() + commandScroll.borderType = .lineBorder + commandScroll.hasVerticalScroller = false + commandScroll.hasHorizontalScroller = false + commandScroll.documentView = commandText + commandScroll.translatesAutoresizingMaskIntoConstraints = false + commandScroll.widthAnchor.constraint(lessThanOrEqualToConstant: 440).isActive = true + commandScroll.heightAnchor.constraint(greaterThanOrEqualToConstant: 56).isActive = true + stack.addArrangedSubview(commandScroll) + + let contextTitle = NSTextField(labelWithString: "Context") + contextTitle.font = NSFont.boldSystemFont(ofSize: NSFont.systemFontSize) + stack.addArrangedSubview(contextTitle) + + let contextStack = NSStackView() + contextStack.orientation = .vertical + contextStack.spacing = 4 + contextStack.alignment = .leading + + let trimmedCwd = request.cwd?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if !trimmedCwd.isEmpty { + self.addDetailRow(title: "Working directory", value: trimmedCwd, to: contextStack) + } + let trimmedAgent = request.agentId?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if !trimmedAgent.isEmpty { + self.addDetailRow(title: "Agent", value: trimmedAgent, to: contextStack) + } + let trimmedPath = request.resolvedPath?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if !trimmedPath.isEmpty { + self.addDetailRow(title: "Executable", value: trimmedPath, to: contextStack) + } + let trimmedHost = request.host?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if !trimmedHost.isEmpty { + self.addDetailRow(title: "Host", value: trimmedHost, to: contextStack) + } + if let security = request.security?.trimmingCharacters(in: .whitespacesAndNewlines), !security.isEmpty { + self.addDetailRow(title: "Security", value: security, to: contextStack) + } + if let ask = request.ask?.trimmingCharacters(in: .whitespacesAndNewlines), !ask.isEmpty { + self.addDetailRow(title: "Ask mode", value: ask, to: contextStack) + } + + if contextStack.arrangedSubviews.isEmpty { + let empty = NSTextField(labelWithString: "No additional context provided.") + empty.textColor = NSColor.secondaryLabelColor + empty.font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize) + contextStack.addArrangedSubview(empty) + } + + stack.addArrangedSubview(contextStack) + + let footer = NSTextField(labelWithString: "This runs on this machine.") + footer.textColor = NSColor.secondaryLabelColor + footer.font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize) + stack.addArrangedSubview(footer) + + return stack + } + + @MainActor + private static func addDetailRow(title: String, value: String, to stack: NSStackView) { + let row = NSStackView() + row.orientation = .horizontal + row.spacing = 6 + row.alignment = .firstBaseline + + let titleLabel = NSTextField(labelWithString: "\(title):") + titleLabel.font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize, weight: .semibold) + titleLabel.textColor = NSColor.secondaryLabelColor + + let valueLabel = NSTextField(labelWithString: value) + valueLabel.font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize) + valueLabel.lineBreakMode = .byTruncatingMiddle + valueLabel.setContentCompressionResistancePriority(.defaultLow, for: .horizontal) + + row.addArrangedSubview(titleLabel) + row.addArrangedSubview(valueLabel) + stack.addArrangedSubview(row) + } +} + +@MainActor +private enum ExecHostExecutor { + private struct ExecApprovalContext { + let command: [String] + let displayCommand: String + let trimmedAgent: String? + let approvals: ExecApprovalsResolved + let security: ExecSecurity + let ask: ExecAsk + let autoAllowSkills: Bool + let env: [String: String]? + let resolution: ExecCommandResolution? + let allowlistMatch: ExecAllowlistEntry? + let skillAllow: Bool + } + + private static let blockedEnvKeys: Set = [ + "PATH", + "NODE_OPTIONS", + "PYTHONHOME", + "PYTHONPATH", + "PERL5LIB", + "PERL5OPT", + "RUBYOPT", + ] + + private static let blockedEnvPrefixes: [String] = [ + "DYLD_", + "LD_", + ] + + static func handle(_ request: ExecHostRequest) async -> ExecHostResponse { + let command = request.command.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) } + guard !command.isEmpty else { + return self.errorResponse( + code: "INVALID_REQUEST", + message: "command required", + reason: "invalid") + } + + let context = await self.buildContext(request: request, command: command) + if context.security == .deny { + return self.errorResponse( + code: "UNAVAILABLE", + message: "SYSTEM_RUN_DISABLED: security=deny", + reason: "security=deny") + } + + let approvalDecision = request.approvalDecision + if approvalDecision == .deny { + return self.errorResponse( + code: "UNAVAILABLE", + message: "SYSTEM_RUN_DENIED: user denied", + reason: "user-denied") + } + + var approvedByAsk = approvalDecision != nil + if ExecApprovalHelpers.requiresAsk( + ask: context.ask, + security: context.security, + allowlistMatch: context.allowlistMatch, + skillAllow: context.skillAllow), + approvalDecision == nil + { + let decision = ExecApprovalsPromptPresenter.prompt( + ExecApprovalPromptRequest( + command: context.displayCommand, + cwd: request.cwd, + host: "node", + security: context.security.rawValue, + ask: context.ask.rawValue, + agentId: context.trimmedAgent, + resolvedPath: context.resolution?.resolvedPath, + sessionKey: request.sessionKey)) + + switch decision { + case .deny: + return self.errorResponse( + code: "UNAVAILABLE", + message: "SYSTEM_RUN_DENIED: user denied", + reason: "user-denied") + case .allowAlways: + approvedByAsk = true + self.persistAllowlistEntry(decision: decision, context: context) + case .allowOnce: + approvedByAsk = true + } + } + + self.persistAllowlistEntry(decision: approvalDecision, context: context) + + if context.security == .allowlist, + context.allowlistMatch == nil, + !context.skillAllow, + !approvedByAsk + { + return self.errorResponse( + code: "UNAVAILABLE", + message: "SYSTEM_RUN_DENIED: allowlist miss", + reason: "allowlist-miss") + } + + if let match = context.allowlistMatch { + ExecApprovalsStore.recordAllowlistUse( + agentId: context.trimmedAgent, + pattern: match.pattern, + command: context.displayCommand, + resolvedPath: context.resolution?.resolvedPath) + } + + if let errorResponse = await self.ensureScreenRecordingAccess(request.needsScreenRecording) { + return errorResponse + } + + return await self.runCommand( + command: command, + cwd: request.cwd, + env: context.env, + timeoutMs: request.timeoutMs) + } + + private static func buildContext(request: ExecHostRequest, command: [String]) async -> ExecApprovalContext { + let displayCommand = ExecCommandFormatter.displayString( + for: command, + rawCommand: request.rawCommand) + let agentId = request.agentId?.trimmingCharacters(in: .whitespacesAndNewlines) + let trimmedAgent = (agentId?.isEmpty == false) ? agentId : nil + let approvals = ExecApprovalsStore.resolve(agentId: trimmedAgent) + let security = approvals.agent.security + let ask = approvals.agent.ask + let autoAllowSkills = approvals.agent.autoAllowSkills + let env = self.sanitizedEnv(request.env) + let resolution = ExecCommandResolution.resolve( + command: command, + rawCommand: request.rawCommand, + cwd: request.cwd, + env: env) + let allowlistMatch = security == .allowlist + ? ExecAllowlistMatcher.match(entries: approvals.allowlist, resolution: resolution) + : nil + let skillAllow: Bool + if autoAllowSkills, let name = resolution?.executableName { + let bins = await SkillBinsCache.shared.currentBins() + skillAllow = bins.contains(name) + } else { + skillAllow = false + } + return ExecApprovalContext( + command: command, + displayCommand: displayCommand, + trimmedAgent: trimmedAgent, + approvals: approvals, + security: security, + ask: ask, + autoAllowSkills: autoAllowSkills, + env: env, + resolution: resolution, + allowlistMatch: allowlistMatch, + skillAllow: skillAllow) + } + + private static func persistAllowlistEntry( + decision: ExecApprovalDecision?, + context: ExecApprovalContext) + { + guard decision == .allowAlways, context.security == .allowlist else { return } + guard let pattern = ExecApprovalHelpers.allowlistPattern( + command: context.command, + resolution: context.resolution) + else { + return + } + ExecApprovalsStore.addAllowlistEntry(agentId: context.trimmedAgent, pattern: pattern) + } + + private static func ensureScreenRecordingAccess(_ needsScreenRecording: Bool?) async -> ExecHostResponse? { + guard needsScreenRecording == true else { return nil } + let authorized = await PermissionManager + .status([.screenRecording])[.screenRecording] ?? false + if authorized { return nil } + return self.errorResponse( + code: "UNAVAILABLE", + message: "PERMISSION_MISSING: screenRecording", + reason: "permission:screenRecording") + } + + private static func runCommand( + command: [String], + cwd: String?, + env: [String: String]?, + timeoutMs: Int?) async -> ExecHostResponse + { + let timeoutSec = timeoutMs.flatMap { Double($0) / 1000.0 } + let result = await Task.detached { () -> ShellExecutor.ShellResult in + await ShellExecutor.runDetailed( + command: command, + cwd: cwd, + env: env, + timeout: timeoutSec) + }.value + let payload = ExecHostRunResult( + exitCode: result.exitCode, + timedOut: result.timedOut, + success: result.success, + stdout: result.stdout, + stderr: result.stderr, + error: result.errorMessage) + return self.successResponse(payload) + } + + private static func errorResponse( + code: String, + message: String, + reason: String?) -> ExecHostResponse + { + ExecHostResponse( + type: "exec-res", + id: UUID().uuidString, + ok: false, + payload: nil, + error: ExecHostError(code: code, message: message, reason: reason)) + } + + private static func successResponse(_ payload: ExecHostRunResult) -> ExecHostResponse { + ExecHostResponse( + type: "exec-res", + id: UUID().uuidString, + ok: true, + payload: payload, + error: nil) + } + + private static func sanitizedEnv(_ overrides: [String: String]?) -> [String: String]? { + guard let overrides else { return nil } + var merged = ProcessInfo.processInfo.environment + for (rawKey, value) in overrides { + let key = rawKey.trimmingCharacters(in: .whitespacesAndNewlines) + guard !key.isEmpty else { continue } + let upper = key.uppercased() + if self.blockedEnvKeys.contains(upper) { continue } + if self.blockedEnvPrefixes.contains(where: { upper.hasPrefix($0) }) { continue } + merged[key] = value + } + return merged + } +} + +private final class ExecApprovalsSocketServer: @unchecked Sendable { + private let logger = Logger(subsystem: "bot.molt", category: "exec-approvals.socket") + private let socketPath: String + private let token: String + private let onPrompt: @Sendable (ExecApprovalPromptRequest) async -> ExecApprovalDecision + private let onExec: @Sendable (ExecHostRequest) async -> ExecHostResponse + private var socketFD: Int32 = -1 + private var acceptTask: Task? + private var isRunning = false + + init( + socketPath: String, + token: String, + onPrompt: @escaping @Sendable (ExecApprovalPromptRequest) async -> ExecApprovalDecision, + onExec: @escaping @Sendable (ExecHostRequest) async -> ExecHostResponse) + { + self.socketPath = socketPath + self.token = token + self.onPrompt = onPrompt + self.onExec = onExec + } + + func start() { + guard !self.isRunning else { return } + self.isRunning = true + self.acceptTask = Task.detached { [weak self] in + await self?.runAcceptLoop() + } + } + + func stop() { + self.isRunning = false + self.acceptTask?.cancel() + self.acceptTask = nil + if self.socketFD >= 0 { + close(self.socketFD) + self.socketFD = -1 + } + if !self.socketPath.isEmpty { + unlink(self.socketPath) + } + } + + private func runAcceptLoop() async { + let fd = self.openSocket() + guard fd >= 0 else { + self.isRunning = false + return + } + self.socketFD = fd + while self.isRunning { + var addr = sockaddr_un() + var len = socklen_t(MemoryLayout.size(ofValue: addr)) + let client = withUnsafeMutablePointer(to: &addr) { ptr in + ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { rebound in + accept(fd, rebound, &len) + } + } + if client < 0 { + if errno == EINTR { continue } + break + } + Task.detached { [weak self] in + await self?.handleClient(fd: client) + } + } + } + + private func openSocket() -> Int32 { + let fd = socket(AF_UNIX, SOCK_STREAM, 0) + guard fd >= 0 else { + self.logger.error("exec approvals socket create failed") + return -1 + } + unlink(self.socketPath) + var addr = sockaddr_un() + addr.sun_family = sa_family_t(AF_UNIX) + let maxLen = MemoryLayout.size(ofValue: addr.sun_path) + if self.socketPath.utf8.count >= maxLen { + self.logger.error("exec approvals socket path too long") + close(fd) + return -1 + } + self.socketPath.withCString { cstr in + withUnsafeMutablePointer(to: &addr.sun_path) { ptr in + let raw = UnsafeMutableRawPointer(ptr).assumingMemoryBound(to: Int8.self) + memset(raw, 0, maxLen) + strncpy(raw, cstr, maxLen - 1) + } + } + let size = socklen_t(MemoryLayout.size(ofValue: addr)) + let result = withUnsafePointer(to: &addr) { ptr in + ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { rebound in + bind(fd, rebound, size) + } + } + if result != 0 { + self.logger.error("exec approvals socket bind failed") + close(fd) + return -1 + } + if listen(fd, 16) != 0 { + self.logger.error("exec approvals socket listen failed") + close(fd) + return -1 + } + chmod(self.socketPath, 0o600) + self.logger.info("exec approvals socket listening at \(self.socketPath, privacy: .public)") + return fd + } + + private func handleClient(fd: Int32) async { + let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true) + do { + guard self.isAllowedPeer(fd: fd) else { + try self.sendApprovalResponse(handle: handle, id: UUID().uuidString, decision: .deny) + return + } + guard let line = try self.readLine(from: handle, maxBytes: 256_000), + let data = line.data(using: .utf8) + else { + return + } + guard + let envelope = try JSONSerialization.jsonObject(with: data) as? [String: Any], + let type = envelope["type"] as? String + else { + return + } + + if type == "request" { + let request = try JSONDecoder().decode(ExecApprovalSocketRequest.self, from: data) + guard request.token == self.token else { + try self.sendApprovalResponse(handle: handle, id: request.id, decision: .deny) + return + } + let decision = await self.onPrompt(request.request) + try self.sendApprovalResponse(handle: handle, id: request.id, decision: decision) + return + } + + if type == "exec" { + let request = try JSONDecoder().decode(ExecHostSocketRequest.self, from: data) + let response = await self.handleExecRequest(request) + try self.sendExecResponse(handle: handle, response: response) + return + } + } catch { + self.logger.error("exec approvals socket handling failed: \(error.localizedDescription, privacy: .public)") + } + } + + private func readLine(from handle: FileHandle, maxBytes: Int) throws -> String? { + var buffer = Data() + while buffer.count < maxBytes { + let chunk = try handle.read(upToCount: 4096) ?? Data() + if chunk.isEmpty { break } + buffer.append(chunk) + if buffer.contains(0x0A) { break } + } + guard let newlineIndex = buffer.firstIndex(of: 0x0A) else { + guard !buffer.isEmpty else { return nil } + return String(data: buffer, encoding: .utf8) + } + let lineData = buffer.subdata(in: 0.. Bool { + var uid = uid_t(0) + var gid = gid_t(0) + if getpeereid(fd, &uid, &gid) != 0 { + return false + } + return uid == geteuid() + } + + private func handleExecRequest(_ request: ExecHostSocketRequest) async -> ExecHostResponse { + let nowMs = Int(Date().timeIntervalSince1970 * 1000) + if abs(nowMs - request.ts) > 10000 { + return ExecHostResponse( + type: "exec-res", + id: request.id, + ok: false, + payload: nil, + error: ExecHostError(code: "INVALID_REQUEST", message: "expired request", reason: "ttl")) + } + let expected = self.hmacHex(nonce: request.nonce, ts: request.ts, requestJson: request.requestJson) + if expected != request.hmac { + return ExecHostResponse( + type: "exec-res", + id: request.id, + ok: false, + payload: nil, + error: ExecHostError(code: "INVALID_REQUEST", message: "invalid auth", reason: "hmac")) + } + guard let requestData = request.requestJson.data(using: .utf8), + let payload = try? JSONDecoder().decode(ExecHostRequest.self, from: requestData) + else { + return ExecHostResponse( + type: "exec-res", + id: request.id, + ok: false, + payload: nil, + error: ExecHostError(code: "INVALID_REQUEST", message: "invalid payload", reason: "json")) + } + let response = await self.onExec(payload) + return ExecHostResponse( + type: "exec-res", + id: request.id, + ok: response.ok, + payload: response.payload, + error: response.error) + } + + private func hmacHex(nonce: String, ts: Int, requestJson: String) -> String { + let key = SymmetricKey(data: Data(self.token.utf8)) + let message = "\(nonce):\(ts):\(requestJson)" + let mac = HMAC.authenticationCode(for: Data(message.utf8), using: key) + return mac.map { String(format: "%02x", $0) }.joined() + } +} diff --git a/apps/macos/Sources/Moltbot/GatewayConnection.swift b/apps/macos/Sources/Moltbot/GatewayConnection.swift new file mode 100644 index 000000000..d733c9c86 --- /dev/null +++ b/apps/macos/Sources/Moltbot/GatewayConnection.swift @@ -0,0 +1,737 @@ +import MoltbotChatUI +import MoltbotKit +import MoltbotProtocol +import Foundation +import OSLog + +private let gatewayConnectionLogger = Logger(subsystem: "bot.molt", category: "gateway.connection") + +enum GatewayAgentChannel: String, Codable, CaseIterable, Sendable { + case last + case whatsapp + case telegram + case discord + case googlechat + case slack + case signal + case imessage + case msteams + case bluebubbles + case webchat + + init(raw: String?) { + let normalized = (raw ?? "").trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + self = GatewayAgentChannel(rawValue: normalized) ?? .last + } + + var isDeliverable: Bool { self != .webchat } + + func shouldDeliver(_ deliver: Bool) -> Bool { deliver && self.isDeliverable } +} + +struct GatewayAgentInvocation: Sendable { + var message: String + var sessionKey: String = "main" + var thinking: String? + var deliver: Bool = false + var to: String? + var channel: GatewayAgentChannel = .last + var timeoutSeconds: Int? + var idempotencyKey: String = UUID().uuidString +} + +/// Single, shared Gateway websocket connection for the whole app. +/// +/// This owns exactly one `GatewayChannelActor` and reuses it across all callers +/// (ControlChannel, debug actions, SwiftUI WebChat, etc.). +actor GatewayConnection { + static let shared = GatewayConnection() + + typealias Config = (url: URL, token: String?, password: String?) + + enum Method: String, Sendable { + case agent + case status + case setHeartbeats = "set-heartbeats" + case systemEvent = "system-event" + case health + case channelsStatus = "channels.status" + case configGet = "config.get" + case configSet = "config.set" + case configPatch = "config.patch" + case configSchema = "config.schema" + case wizardStart = "wizard.start" + case wizardNext = "wizard.next" + case wizardCancel = "wizard.cancel" + case wizardStatus = "wizard.status" + case talkMode = "talk.mode" + case webLoginStart = "web.login.start" + case webLoginWait = "web.login.wait" + case channelsLogout = "channels.logout" + case modelsList = "models.list" + case chatHistory = "chat.history" + case sessionsPreview = "sessions.preview" + case chatSend = "chat.send" + case chatAbort = "chat.abort" + case skillsStatus = "skills.status" + case skillsInstall = "skills.install" + case skillsUpdate = "skills.update" + case voicewakeGet = "voicewake.get" + case voicewakeSet = "voicewake.set" + case nodePairApprove = "node.pair.approve" + case nodePairReject = "node.pair.reject" + case devicePairList = "device.pair.list" + case devicePairApprove = "device.pair.approve" + case devicePairReject = "device.pair.reject" + case execApprovalResolve = "exec.approval.resolve" + case cronList = "cron.list" + case cronRuns = "cron.runs" + case cronRun = "cron.run" + case cronRemove = "cron.remove" + case cronUpdate = "cron.update" + case cronAdd = "cron.add" + case cronStatus = "cron.status" + } + + private let configProvider: @Sendable () async throws -> Config + private let sessionBox: WebSocketSessionBox? + private let decoder = JSONDecoder() + + private var client: GatewayChannelActor? + private var configuredURL: URL? + private var configuredToken: String? + private var configuredPassword: String? + + private var subscribers: [UUID: AsyncStream.Continuation] = [:] + private var lastSnapshot: HelloOk? + + init( + configProvider: @escaping @Sendable () async throws -> Config = GatewayConnection.defaultConfigProvider, + sessionBox: WebSocketSessionBox? = nil) + { + self.configProvider = configProvider + self.sessionBox = sessionBox + } + + // MARK: - Low-level request + + func request( + method: String, + params: [String: AnyCodable]?, + timeoutMs: Double? = nil) async throws -> Data + { + let cfg = try await self.configProvider() + await self.configure(url: cfg.url, token: cfg.token, password: cfg.password) + guard let client else { + throw NSError(domain: "Gateway", code: 0, userInfo: [NSLocalizedDescriptionKey: "gateway not configured"]) + } + + do { + return try await client.request(method: method, params: params, timeoutMs: timeoutMs) + } catch { + if error is GatewayResponseError || error is GatewayDecodingError { + throw error + } + + // Auto-recover in local mode by spawning/attaching a gateway and retrying a few times. + // Canvas interactions should "just work" even if the local gateway isn't running yet. + let mode = await MainActor.run { AppStateStore.shared.connectionMode } + switch mode { + case .local: + await MainActor.run { GatewayProcessManager.shared.setActive(true) } + + var lastError: Error = error + for delayMs in [150, 400, 900] { + try await Task.sleep(nanoseconds: UInt64(delayMs) * 1_000_000) + do { + return try await client.request(method: method, params: params, timeoutMs: timeoutMs) + } catch { + lastError = error + } + } + + let nsError = lastError as NSError + if nsError.domain == URLError.errorDomain, + let fallback = await GatewayEndpointStore.shared.maybeFallbackToTailnet(from: cfg.url) + { + await self.configure(url: fallback.url, token: fallback.token, password: fallback.password) + for delayMs in [150, 400, 900] { + try await Task.sleep(nanoseconds: UInt64(delayMs) * 1_000_000) + do { + guard let client = self.client else { + throw NSError( + domain: "Gateway", + code: 0, + userInfo: [NSLocalizedDescriptionKey: "gateway not configured"]) + } + return try await client.request(method: method, params: params, timeoutMs: timeoutMs) + } catch { + lastError = error + } + } + } + + throw lastError + case .remote: + let nsError = error as NSError + guard nsError.domain == URLError.errorDomain else { throw error } + + var lastError: Error = error + await RemoteTunnelManager.shared.stopAll() + do { + _ = try await GatewayEndpointStore.shared.ensureRemoteControlTunnel() + } catch { + lastError = error + } + + for delayMs in [150, 400, 900] { + try await Task.sleep(nanoseconds: UInt64(delayMs) * 1_000_000) + do { + let cfg = try await self.configProvider() + await self.configure(url: cfg.url, token: cfg.token, password: cfg.password) + guard let client = self.client else { + throw NSError( + domain: "Gateway", + code: 0, + userInfo: [NSLocalizedDescriptionKey: "gateway not configured"]) + } + return try await client.request(method: method, params: params, timeoutMs: timeoutMs) + } catch { + lastError = error + } + } + + throw lastError + case .unconfigured: + throw error + } + } + } + + func requestRaw( + method: Method, + params: [String: AnyCodable]? = nil, + timeoutMs: Double? = nil) async throws -> Data + { + try await self.request(method: method.rawValue, params: params, timeoutMs: timeoutMs) + } + + func requestRaw( + method: String, + params: [String: AnyCodable]? = nil, + timeoutMs: Double? = nil) async throws -> Data + { + try await self.request(method: method, params: params, timeoutMs: timeoutMs) + } + + func requestDecoded( + method: Method, + params: [String: AnyCodable]? = nil, + timeoutMs: Double? = nil) async throws -> T + { + let data = try await self.requestRaw(method: method, params: params, timeoutMs: timeoutMs) + do { + return try self.decoder.decode(T.self, from: data) + } catch { + throw GatewayDecodingError(method: method.rawValue, message: error.localizedDescription) + } + } + + func requestVoid( + method: Method, + params: [String: AnyCodable]? = nil, + timeoutMs: Double? = nil) async throws + { + _ = try await self.requestRaw(method: method, params: params, timeoutMs: timeoutMs) + } + + /// Ensure the underlying socket is configured (and replaced if config changed). + func refresh() async throws { + let cfg = try await self.configProvider() + await self.configure(url: cfg.url, token: cfg.token, password: cfg.password) + } + + func authSource() async -> GatewayAuthSource? { + guard let client else { return nil } + return await client.authSource() + } + + func shutdown() async { + if let client { + await client.shutdown() + } + self.client = nil + self.configuredURL = nil + self.configuredToken = nil + self.lastSnapshot = nil + } + + func canvasHostUrl() async -> String? { + guard let snapshot = self.lastSnapshot else { return nil } + let trimmed = snapshot.canvashosturl?.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) ?? "" + return trimmed.isEmpty ? nil : trimmed + } + + private func sessionDefaultString(_ defaults: [String: MoltbotProtocol.AnyCodable]?, key: String) -> String { + let raw = defaults?[key]?.value as? String + return (raw ?? "").trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) + } + + func cachedMainSessionKey() -> String? { + guard let snapshot = self.lastSnapshot else { return nil } + let trimmed = self.sessionDefaultString(snapshot.snapshot.sessiondefaults, key: "mainSessionKey") + return trimmed.isEmpty ? nil : trimmed + } + + func cachedGatewayVersion() -> String? { + guard let snapshot = self.lastSnapshot else { return nil } + let raw = snapshot.server["version"]?.value as? String + let trimmed = raw?.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) ?? "" + return trimmed.isEmpty ? nil : trimmed + } + + func snapshotPaths() -> (configPath: String?, stateDir: String?) { + guard let snapshot = self.lastSnapshot else { return (nil, nil) } + let configPath = snapshot.snapshot.configpath?.trimmingCharacters(in: .whitespacesAndNewlines) + let stateDir = snapshot.snapshot.statedir?.trimmingCharacters(in: .whitespacesAndNewlines) + return ( + configPath?.isEmpty == false ? configPath : nil, + stateDir?.isEmpty == false ? stateDir : nil) + } + + func subscribe(bufferingNewest: Int = 100) -> AsyncStream { + let id = UUID() + let snapshot = self.lastSnapshot + let connection = self + return AsyncStream(bufferingPolicy: .bufferingNewest(bufferingNewest)) { continuation in + if let snapshot { + continuation.yield(.snapshot(snapshot)) + } + self.subscribers[id] = continuation + continuation.onTermination = { @Sendable _ in + Task { await connection.removeSubscriber(id) } + } + } + } + + private func removeSubscriber(_ id: UUID) { + self.subscribers[id] = nil + } + + private func broadcast(_ push: GatewayPush) { + if case let .snapshot(snapshot) = push { + self.lastSnapshot = snapshot + if let mainSessionKey = self.cachedMainSessionKey() { + Task { @MainActor in + WorkActivityStore.shared.setMainSessionKey(mainSessionKey) + } + } + } + for (_, continuation) in self.subscribers { + continuation.yield(push) + } + } + + private func canonicalizeSessionKey(_ raw: String) -> String { + let trimmed = raw.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) + guard !trimmed.isEmpty else { return trimmed } + guard let defaults = self.lastSnapshot?.snapshot.sessiondefaults else { return trimmed } + let mainSessionKey = self.sessionDefaultString(defaults, key: "mainSessionKey") + guard !mainSessionKey.isEmpty else { return trimmed } + let mainKey = self.sessionDefaultString(defaults, key: "mainKey") + let defaultAgentId = self.sessionDefaultString(defaults, key: "defaultAgentId") + let isMainAlias = + trimmed == "main" || + (!mainKey.isEmpty && trimmed == mainKey) || + trimmed == mainSessionKey || + (!defaultAgentId.isEmpty && + (trimmed == "agent:\(defaultAgentId):main" || + (mainKey.isEmpty == false && trimmed == "agent:\(defaultAgentId):\(mainKey)"))) + return isMainAlias ? mainSessionKey : trimmed + } + + private func configure(url: URL, token: String?, password: String?) async { + if self.client != nil, self.configuredURL == url, self.configuredToken == token, + self.configuredPassword == password + { + return + } + if let client { + await client.shutdown() + } + self.lastSnapshot = nil + self.client = GatewayChannelActor( + url: url, + token: token, + password: password, + session: self.sessionBox, + pushHandler: { [weak self] push in + await self?.handle(push: push) + }) + self.configuredURL = url + self.configuredToken = token + self.configuredPassword = password + } + + private func handle(push: GatewayPush) { + self.broadcast(push) + } + + private static func defaultConfigProvider() async throws -> Config { + try await GatewayEndpointStore.shared.requireConfig() + } +} + +// MARK: - Typed gateway API + +extension GatewayConnection { + struct ConfigGetSnapshot: Decodable, Sendable { + struct SnapshotConfig: Decodable, Sendable { + struct Session: Decodable, Sendable { + let mainKey: String? + let scope: String? + } + + let session: Session? + } + + let config: SnapshotConfig? + } + + static func mainSessionKey(fromConfigGetData data: Data) throws -> String { + let snapshot = try JSONDecoder().decode(ConfigGetSnapshot.self, from: data) + let scope = snapshot.config?.session?.scope?.trimmingCharacters(in: .whitespacesAndNewlines) + if scope == "global" { + return "global" + } + return "main" + } + + func mainSessionKey(timeoutMs: Double = 15000) async -> String { + if let cached = self.cachedMainSessionKey() { + return cached + } + do { + let data = try await self.requestRaw(method: "config.get", params: nil, timeoutMs: timeoutMs) + return try Self.mainSessionKey(fromConfigGetData: data) + } catch { + return "main" + } + } + + func status() async -> (ok: Bool, error: String?) { + do { + _ = try await self.requestRaw(method: .status) + return (true, nil) + } catch { + return (false, error.localizedDescription) + } + } + + func setHeartbeatsEnabled(_ enabled: Bool) async -> Bool { + do { + try await self.requestVoid(method: .setHeartbeats, params: ["enabled": AnyCodable(enabled)]) + return true + } catch { + gatewayConnectionLogger.error("setHeartbeatsEnabled failed \(error.localizedDescription, privacy: .public)") + return false + } + } + + func sendAgent(_ invocation: GatewayAgentInvocation) async -> (ok: Bool, error: String?) { + let trimmed = invocation.message.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return (false, "message empty") } + let sessionKey = self.canonicalizeSessionKey(invocation.sessionKey) + + var params: [String: AnyCodable] = [ + "message": AnyCodable(trimmed), + "sessionKey": AnyCodable(sessionKey), + "thinking": AnyCodable(invocation.thinking ?? "default"), + "deliver": AnyCodable(invocation.deliver), + "to": AnyCodable(invocation.to ?? ""), + "channel": AnyCodable(invocation.channel.rawValue), + "idempotencyKey": AnyCodable(invocation.idempotencyKey), + ] + if let timeout = invocation.timeoutSeconds { + params["timeout"] = AnyCodable(timeout) + } + + do { + try await self.requestVoid(method: .agent, params: params) + return (true, nil) + } catch { + return (false, error.localizedDescription) + } + } + + func sendAgent( + message: String, + thinking: String?, + sessionKey: String, + deliver: Bool, + to: String?, + channel: GatewayAgentChannel = .last, + timeoutSeconds: Int? = nil, + idempotencyKey: String = UUID().uuidString) async -> (ok: Bool, error: String?) + { + await self.sendAgent(GatewayAgentInvocation( + message: message, + sessionKey: sessionKey, + thinking: thinking, + deliver: deliver, + to: to, + channel: channel, + timeoutSeconds: timeoutSeconds, + idempotencyKey: idempotencyKey)) + } + + func sendSystemEvent(_ params: [String: AnyCodable]) async { + do { + try await self.requestVoid(method: .systemEvent, params: params) + } catch { + // Best-effort only. + } + } + + // MARK: - Health + + func healthSnapshot(timeoutMs: Double? = nil) async throws -> HealthSnapshot { + let data = try await self.requestRaw(method: .health, timeoutMs: timeoutMs) + if let snap = decodeHealthSnapshot(from: data) { return snap } + throw GatewayDecodingError(method: Method.health.rawValue, message: "failed to decode health snapshot") + } + + func healthOK(timeoutMs: Int = 8000) async throws -> Bool { + let data = try await self.requestRaw(method: .health, timeoutMs: Double(timeoutMs)) + return (try? self.decoder.decode(MoltbotGatewayHealthOK.self, from: data))?.ok ?? true + } + + // MARK: - Skills + + func skillsStatus() async throws -> SkillsStatusReport { + try await self.requestDecoded(method: .skillsStatus) + } + + func skillsInstall( + name: String, + installId: String, + timeoutMs: Int? = nil) async throws -> SkillInstallResult + { + var params: [String: AnyCodable] = [ + "name": AnyCodable(name), + "installId": AnyCodable(installId), + ] + if let timeoutMs { + params["timeoutMs"] = AnyCodable(timeoutMs) + } + return try await self.requestDecoded(method: .skillsInstall, params: params) + } + + func skillsUpdate( + skillKey: String, + enabled: Bool? = nil, + apiKey: String? = nil, + env: [String: String]? = nil) async throws -> SkillUpdateResult + { + var params: [String: AnyCodable] = [ + "skillKey": AnyCodable(skillKey), + ] + if let enabled { params["enabled"] = AnyCodable(enabled) } + if let apiKey { params["apiKey"] = AnyCodable(apiKey) } + if let env, !env.isEmpty { params["env"] = AnyCodable(env) } + return try await self.requestDecoded(method: .skillsUpdate, params: params) + } + + // MARK: - Sessions + + func sessionsPreview( + keys: [String], + limit: Int? = nil, + maxChars: Int? = nil, + timeoutMs: Int? = nil) async throws -> MoltbotSessionsPreviewPayload + { + let resolvedKeys = keys + .map { self.canonicalizeSessionKey($0) } + .filter { !$0.isEmpty } + if resolvedKeys.isEmpty { + return MoltbotSessionsPreviewPayload(ts: 0, previews: []) + } + var params: [String: AnyCodable] = ["keys": AnyCodable(resolvedKeys)] + if let limit { params["limit"] = AnyCodable(limit) } + if let maxChars { params["maxChars"] = AnyCodable(maxChars) } + let timeout = timeoutMs.map { Double($0) } + return try await self.requestDecoded( + method: .sessionsPreview, + params: params, + timeoutMs: timeout) + } + + // MARK: - Chat + + func chatHistory( + sessionKey: String, + limit: Int? = nil, + timeoutMs: Int? = nil) async throws -> MoltbotChatHistoryPayload + { + let resolvedKey = self.canonicalizeSessionKey(sessionKey) + var params: [String: AnyCodable] = ["sessionKey": AnyCodable(resolvedKey)] + if let limit { params["limit"] = AnyCodable(limit) } + let timeout = timeoutMs.map { Double($0) } + return try await self.requestDecoded( + method: .chatHistory, + params: params, + timeoutMs: timeout) + } + + func chatSend( + sessionKey: String, + message: String, + thinking: String, + idempotencyKey: String, + attachments: [MoltbotChatAttachmentPayload], + timeoutMs: Int = 30000) async throws -> MoltbotChatSendResponse + { + let resolvedKey = self.canonicalizeSessionKey(sessionKey) + var params: [String: AnyCodable] = [ + "sessionKey": AnyCodable(resolvedKey), + "message": AnyCodable(message), + "thinking": AnyCodable(thinking), + "idempotencyKey": AnyCodable(idempotencyKey), + "timeoutMs": AnyCodable(timeoutMs), + ] + + if !attachments.isEmpty { + let encoded = attachments.map { att in + [ + "type": att.type, + "mimeType": att.mimeType, + "fileName": att.fileName, + "content": att.content, + ] + } + params["attachments"] = AnyCodable(encoded) + } + + return try await self.requestDecoded( + method: .chatSend, + params: params, + timeoutMs: Double(timeoutMs)) + } + + func chatAbort(sessionKey: String, runId: String) async throws -> Bool { + let resolvedKey = self.canonicalizeSessionKey(sessionKey) + struct AbortResponse: Decodable { let ok: Bool?; let aborted: Bool? } + let res: AbortResponse = try await self.requestDecoded( + method: .chatAbort, + params: ["sessionKey": AnyCodable(resolvedKey), "runId": AnyCodable(runId)]) + return res.aborted ?? false + } + + func talkMode(enabled: Bool, phase: String? = nil) async { + var params: [String: AnyCodable] = ["enabled": AnyCodable(enabled)] + if let phase { params["phase"] = AnyCodable(phase) } + try? await self.requestVoid(method: .talkMode, params: params) + } + + // MARK: - VoiceWake + + func voiceWakeGetTriggers() async throws -> [String] { + struct VoiceWakePayload: Decodable { let triggers: [String] } + let payload: VoiceWakePayload = try await self.requestDecoded(method: .voicewakeGet) + return payload.triggers + } + + func voiceWakeSetTriggers(_ triggers: [String]) async { + do { + try await self.requestVoid( + method: .voicewakeSet, + params: ["triggers": AnyCodable(triggers)], + timeoutMs: 10000) + } catch { + // Best-effort only. + } + } + + // MARK: - Node pairing + + func nodePairApprove(requestId: String) async throws { + try await self.requestVoid( + method: .nodePairApprove, + params: ["requestId": AnyCodable(requestId)], + timeoutMs: 10000) + } + + func nodePairReject(requestId: String) async throws { + try await self.requestVoid( + method: .nodePairReject, + params: ["requestId": AnyCodable(requestId)], + timeoutMs: 10000) + } + + // MARK: - Device pairing + + func devicePairApprove(requestId: String) async throws { + try await self.requestVoid( + method: .devicePairApprove, + params: ["requestId": AnyCodable(requestId)], + timeoutMs: 10000) + } + + func devicePairReject(requestId: String) async throws { + try await self.requestVoid( + method: .devicePairReject, + params: ["requestId": AnyCodable(requestId)], + timeoutMs: 10000) + } + + // MARK: - Cron + + struct CronSchedulerStatus: Decodable, Sendable { + let enabled: Bool + let storePath: String + let jobs: Int + let nextWakeAtMs: Int? + } + + func cronStatus() async throws -> CronSchedulerStatus { + try await self.requestDecoded(method: .cronStatus) + } + + func cronList(includeDisabled: Bool = true) async throws -> [CronJob] { + let res: CronListResponse = try await self.requestDecoded( + method: .cronList, + params: ["includeDisabled": AnyCodable(includeDisabled)]) + return res.jobs + } + + func cronRuns(jobId: String, limit: Int = 200) async throws -> [CronRunLogEntry] { + let res: CronRunsResponse = try await self.requestDecoded( + method: .cronRuns, + params: ["id": AnyCodable(jobId), "limit": AnyCodable(limit)]) + return res.entries + } + + func cronRun(jobId: String, force: Bool = true) async throws { + try await self.requestVoid( + method: .cronRun, + params: [ + "id": AnyCodable(jobId), + "mode": AnyCodable(force ? "force" : "due"), + ], + timeoutMs: 20000) + } + + func cronRemove(jobId: String) async throws { + try await self.requestVoid(method: .cronRemove, params: ["id": AnyCodable(jobId)]) + } + + func cronUpdate(jobId: String, patch: [String: AnyCodable]) async throws { + try await self.requestVoid( + method: .cronUpdate, + params: ["id": AnyCodable(jobId), "patch": AnyCodable(patch)]) + } + + func cronAdd(payload: [String: AnyCodable]) async throws { + try await self.requestVoid(method: .cronAdd, params: payload) + } +} diff --git a/apps/macos/Sources/Moltbot/GatewayConnectivityCoordinator.swift b/apps/macos/Sources/Moltbot/GatewayConnectivityCoordinator.swift new file mode 100644 index 000000000..8a5f15aa0 --- /dev/null +++ b/apps/macos/Sources/Moltbot/GatewayConnectivityCoordinator.swift @@ -0,0 +1,63 @@ +import Foundation +import Observation +import OSLog + +@MainActor +@Observable +final class GatewayConnectivityCoordinator { + static let shared = GatewayConnectivityCoordinator() + + private let logger = Logger(subsystem: "bot.molt", category: "gateway.connectivity") + private var endpointTask: Task? + private var lastResolvedURL: URL? + + private(set) var endpointState: GatewayEndpointState? + private(set) var resolvedURL: URL? + private(set) var resolvedMode: AppState.ConnectionMode? + private(set) var resolvedHostLabel: String? + + private init() { + self.start() + } + + func start() { + guard self.endpointTask == nil else { return } + self.endpointTask = Task { [weak self] in + guard let self else { return } + let stream = await GatewayEndpointStore.shared.subscribe() + for await state in stream { + await MainActor.run { self.handleEndpointState(state) } + } + } + } + + var localEndpointHostLabel: String? { + guard self.resolvedMode == .local, let url = self.resolvedURL else { return nil } + return Self.hostLabel(for: url) + } + + private func handleEndpointState(_ state: GatewayEndpointState) { + self.endpointState = state + switch state { + case let .ready(mode, url, _, _): + self.resolvedMode = mode + self.resolvedURL = url + self.resolvedHostLabel = Self.hostLabel(for: url) + let urlChanged = self.lastResolvedURL?.absoluteString != url.absoluteString + if urlChanged { + self.lastResolvedURL = url + Task { await ControlChannel.shared.refreshEndpoint(reason: "endpoint changed") } + } + case let .connecting(mode, _): + self.resolvedMode = mode + case let .unavailable(mode, _): + self.resolvedMode = mode + } + } + + private static func hostLabel(for url: URL) -> String { + let host = url.host ?? url.absoluteString + if let port = url.port { return "\(host):\(port)" } + return host + } +} diff --git a/apps/macos/Sources/Moltbot/GatewayEndpointStore.swift b/apps/macos/Sources/Moltbot/GatewayEndpointStore.swift new file mode 100644 index 000000000..08c4249b0 --- /dev/null +++ b/apps/macos/Sources/Moltbot/GatewayEndpointStore.swift @@ -0,0 +1,696 @@ +import ConcurrencyExtras +import Foundation +import OSLog + +enum GatewayEndpointState: Sendable, Equatable { + case ready(mode: AppState.ConnectionMode, url: URL, token: String?, password: String?) + case connecting(mode: AppState.ConnectionMode, detail: String) + case unavailable(mode: AppState.ConnectionMode, reason: String) +} + +/// Single place to resolve (and publish) the effective gateway control endpoint. +/// +/// This is intentionally separate from `GatewayConnection`: +/// - `GatewayConnection` consumes the resolved endpoint (no tunnel side-effects). +/// - The endpoint store owns observation + explicit "ensure tunnel" actions. +actor GatewayEndpointStore { + static let shared = GatewayEndpointStore() + private static let supportedBindModes: Set = [ + "loopback", + "tailnet", + "lan", + "auto", + "custom", + ] + private static let remoteConnectingDetail = "Connecting to remote gateway…" + private static let staticLogger = Logger(subsystem: "bot.molt", category: "gateway-endpoint") + private enum EnvOverrideWarningKind: Sendable { + case token + case password + } + + private static let envOverrideWarnings = LockIsolated((token: false, password: false)) + + struct Deps: Sendable { + let mode: @Sendable () async -> AppState.ConnectionMode + let token: @Sendable () -> String? + let password: @Sendable () -> String? + let localPort: @Sendable () -> Int + let localHost: @Sendable () async -> String + let remotePortIfRunning: @Sendable () async -> UInt16? + let ensureRemoteTunnel: @Sendable () async throws -> UInt16 + + static let live = Deps( + mode: { await MainActor.run { AppStateStore.shared.connectionMode } }, + token: { + let root = MoltbotConfigFile.loadDict() + let isRemote = ConnectionModeResolver.resolve(root: root).mode == .remote + return GatewayEndpointStore.resolveGatewayToken( + isRemote: isRemote, + root: root, + env: ProcessInfo.processInfo.environment, + launchdSnapshot: GatewayLaunchAgentManager.launchdConfigSnapshot()) + }, + password: { + let root = MoltbotConfigFile.loadDict() + let isRemote = ConnectionModeResolver.resolve(root: root).mode == .remote + return GatewayEndpointStore.resolveGatewayPassword( + isRemote: isRemote, + root: root, + env: ProcessInfo.processInfo.environment, + launchdSnapshot: GatewayLaunchAgentManager.launchdConfigSnapshot()) + }, + localPort: { GatewayEnvironment.gatewayPort() }, + localHost: { + let root = MoltbotConfigFile.loadDict() + let bind = GatewayEndpointStore.resolveGatewayBindMode( + root: root, + env: ProcessInfo.processInfo.environment) + let customBindHost = GatewayEndpointStore.resolveGatewayCustomBindHost(root: root) + let tailscaleIP = await MainActor.run { TailscaleService.shared.tailscaleIP } + ?? TailscaleService.fallbackTailnetIPv4() + return GatewayEndpointStore.resolveLocalGatewayHost( + bindMode: bind, + customBindHost: customBindHost, + tailscaleIP: tailscaleIP) + }, + remotePortIfRunning: { await RemoteTunnelManager.shared.controlTunnelPortIfRunning() }, + ensureRemoteTunnel: { try await RemoteTunnelManager.shared.ensureControlTunnel() }) + } + + private static func resolveGatewayPassword( + isRemote: Bool, + root: [String: Any], + env: [String: String], + launchdSnapshot: LaunchAgentPlistSnapshot?) -> String? + { + let raw = env["CLAWDBOT_GATEWAY_PASSWORD"] ?? "" + let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) + if !trimmed.isEmpty { + if let configPassword = self.resolveConfigPassword(isRemote: isRemote, root: root), + !configPassword.isEmpty + { + self.warnEnvOverrideOnce( + kind: .password, + envVar: "CLAWDBOT_GATEWAY_PASSWORD", + configKey: isRemote ? "gateway.remote.password" : "gateway.auth.password") + } + return trimmed + } + if isRemote { + if let gateway = root["gateway"] as? [String: Any], + let remote = gateway["remote"] as? [String: Any], + let password = remote["password"] as? String + { + let pw = password.trimmingCharacters(in: .whitespacesAndNewlines) + if !pw.isEmpty { + return pw + } + } + return nil + } + if let gateway = root["gateway"] as? [String: Any], + let auth = gateway["auth"] as? [String: Any], + let password = auth["password"] as? String + { + let pw = password.trimmingCharacters(in: .whitespacesAndNewlines) + if !pw.isEmpty { + return pw + } + } + if let password = launchdSnapshot?.password?.trimmingCharacters(in: .whitespacesAndNewlines), + !password.isEmpty + { + return password + } + return nil + } + + private static func resolveConfigPassword(isRemote: Bool, root: [String: Any]) -> String? { + if isRemote { + if let gateway = root["gateway"] as? [String: Any], + let remote = gateway["remote"] as? [String: Any], + let password = remote["password"] as? String + { + return password.trimmingCharacters(in: .whitespacesAndNewlines) + } + return nil + } + + if let gateway = root["gateway"] as? [String: Any], + let auth = gateway["auth"] as? [String: Any], + let password = auth["password"] as? String + { + return password.trimmingCharacters(in: .whitespacesAndNewlines) + } + return nil + } + + private static func resolveGatewayToken( + isRemote: Bool, + root: [String: Any], + env: [String: String], + launchdSnapshot: LaunchAgentPlistSnapshot?) -> String? + { + let raw = env["CLAWDBOT_GATEWAY_TOKEN"] ?? "" + let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) + if !trimmed.isEmpty { + if let configToken = self.resolveConfigToken(isRemote: isRemote, root: root), + !configToken.isEmpty, + configToken != trimmed + { + self.warnEnvOverrideOnce( + kind: .token, + envVar: "CLAWDBOT_GATEWAY_TOKEN", + configKey: isRemote ? "gateway.remote.token" : "gateway.auth.token") + } + return trimmed + } + + if let configToken = self.resolveConfigToken(isRemote: isRemote, root: root), + !configToken.isEmpty + { + return configToken + } + + if isRemote { + return nil + } + + if let token = launchdSnapshot?.token?.trimmingCharacters(in: .whitespacesAndNewlines), + !token.isEmpty + { + return token + } + + return nil + } + + private static func resolveConfigToken(isRemote: Bool, root: [String: Any]) -> String? { + if isRemote { + if let gateway = root["gateway"] as? [String: Any], + let remote = gateway["remote"] as? [String: Any], + let token = remote["token"] as? String + { + return token.trimmingCharacters(in: .whitespacesAndNewlines) + } + return nil + } + + if let gateway = root["gateway"] as? [String: Any], + let auth = gateway["auth"] as? [String: Any], + let token = auth["token"] as? String + { + return token.trimmingCharacters(in: .whitespacesAndNewlines) + } + return nil + } + + private static func warnEnvOverrideOnce( + kind: EnvOverrideWarningKind, + envVar: String, + configKey: String) + { + let shouldWarn = Self.envOverrideWarnings.withValue { state in + switch kind { + case .token: + guard !state.token else { return false } + state.token = true + return true + case .password: + guard !state.password else { return false } + state.password = true + return true + } + } + guard shouldWarn else { return } + Self.staticLogger.warning( + "\(envVar, privacy: .public) is set and overrides \(configKey, privacy: .public). " + + "If this is unintentional, clear it with: launchctl unsetenv \(envVar, privacy: .public)") + } + + private let deps: Deps + private let logger = Logger(subsystem: "bot.molt", category: "gateway-endpoint") + + private var state: GatewayEndpointState + private var subscribers: [UUID: AsyncStream.Continuation] = [:] + private var remoteEnsure: (token: UUID, task: Task)? + + init(deps: Deps = .live) { + self.deps = deps + let modeRaw = UserDefaults.standard.string(forKey: connectionModeKey) + let initialMode: AppState.ConnectionMode + if let modeRaw { + initialMode = AppState.ConnectionMode(rawValue: modeRaw) ?? .local + } else { + let seen = UserDefaults.standard.bool(forKey: "moltbot.onboardingSeen") + initialMode = seen ? .local : .unconfigured + } + + let port = deps.localPort() + let bind = GatewayEndpointStore.resolveGatewayBindMode( + root: MoltbotConfigFile.loadDict(), + env: ProcessInfo.processInfo.environment) + let customBindHost = GatewayEndpointStore.resolveGatewayCustomBindHost(root: MoltbotConfigFile.loadDict()) + let scheme = GatewayEndpointStore.resolveGatewayScheme( + root: MoltbotConfigFile.loadDict(), + env: ProcessInfo.processInfo.environment) + let host = GatewayEndpointStore.resolveLocalGatewayHost( + bindMode: bind, + customBindHost: customBindHost, + tailscaleIP: nil) + let token = deps.token() + let password = deps.password() + switch initialMode { + case .local: + self.state = .ready( + mode: .local, + url: URL(string: "\(scheme)://\(host):\(port)")!, + token: token, + password: password) + case .remote: + self.state = .connecting(mode: .remote, detail: Self.remoteConnectingDetail) + Task { await self.setMode(.remote) } + case .unconfigured: + self.state = .unavailable(mode: .unconfigured, reason: "Gateway not configured") + } + } + + func subscribe(bufferingNewest: Int = 1) -> AsyncStream { + let id = UUID() + let initial = self.state + let store = self + return AsyncStream(bufferingPolicy: .bufferingNewest(bufferingNewest)) { continuation in + continuation.yield(initial) + self.subscribers[id] = continuation + continuation.onTermination = { @Sendable _ in + Task { await store.removeSubscriber(id) } + } + } + } + + func refresh() async { + let mode = await self.deps.mode() + await self.setMode(mode) + } + + func setMode(_ mode: AppState.ConnectionMode) async { + let token = self.deps.token() + let password = self.deps.password() + switch mode { + case .local: + self.cancelRemoteEnsure() + let port = self.deps.localPort() + let host = await self.deps.localHost() + let scheme = GatewayEndpointStore.resolveGatewayScheme( + root: MoltbotConfigFile.loadDict(), + env: ProcessInfo.processInfo.environment) + self.setState(.ready( + mode: .local, + url: URL(string: "\(scheme)://\(host):\(port)")!, + token: token, + password: password)) + case .remote: + let root = MoltbotConfigFile.loadDict() + if GatewayRemoteConfig.resolveTransport(root: root) == .direct { + guard let url = GatewayRemoteConfig.resolveGatewayUrl(root: root) else { + self.cancelRemoteEnsure() + self.setState(.unavailable( + mode: .remote, + reason: "gateway.remote.url missing or invalid for direct transport")) + return + } + self.cancelRemoteEnsure() + self.setState(.ready(mode: .remote, url: url, token: token, password: password)) + return + } + let port = await self.deps.remotePortIfRunning() + guard let port else { + self.setState(.connecting(mode: .remote, detail: Self.remoteConnectingDetail)) + self.kickRemoteEnsureIfNeeded(detail: Self.remoteConnectingDetail) + return + } + self.cancelRemoteEnsure() + let scheme = GatewayEndpointStore.resolveGatewayScheme( + root: MoltbotConfigFile.loadDict(), + env: ProcessInfo.processInfo.environment) + self.setState(.ready( + mode: .remote, + url: URL(string: "\(scheme)://127.0.0.1:\(Int(port))")!, + token: token, + password: password)) + case .unconfigured: + self.cancelRemoteEnsure() + self.setState(.unavailable(mode: .unconfigured, reason: "Gateway not configured")) + } + } + + /// Explicit action: ensure the remote control tunnel is established and publish the resolved endpoint. + func ensureRemoteControlTunnel() async throws -> UInt16 { + let mode = await self.deps.mode() + guard mode == .remote else { + throw NSError( + domain: "RemoteTunnel", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "Remote mode is not enabled"]) + } + let root = MoltbotConfigFile.loadDict() + if GatewayRemoteConfig.resolveTransport(root: root) == .direct { + guard let url = GatewayRemoteConfig.resolveGatewayUrl(root: root) else { + throw NSError( + domain: "GatewayEndpoint", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "gateway.remote.url missing or invalid"]) + } + guard let port = GatewayRemoteConfig.defaultPort(for: url), + let portInt = UInt16(exactly: port) + else { + throw NSError( + domain: "GatewayEndpoint", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "Invalid gateway.remote.url port"]) + } + self.logger.info("remote transport direct; skipping SSH tunnel") + return portInt + } + let config = try await self.ensureRemoteConfig(detail: Self.remoteConnectingDetail) + guard let portInt = config.0.port, let port = UInt16(exactly: portInt) else { + throw NSError( + domain: "GatewayEndpoint", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "Missing tunnel port"]) + } + return port + } + + func requireConfig() async throws -> GatewayConnection.Config { + await self.refresh() + switch self.state { + case let .ready(_, url, token, password): + return (url, token, password) + case let .connecting(mode, _): + guard mode == .remote else { + throw NSError(domain: "GatewayEndpoint", code: 1, userInfo: [NSLocalizedDescriptionKey: "Connecting…"]) + } + return try await self.ensureRemoteConfig(detail: Self.remoteConnectingDetail) + case let .unavailable(mode, reason): + guard mode == .remote else { + throw NSError(domain: "GatewayEndpoint", code: 1, userInfo: [NSLocalizedDescriptionKey: reason]) + } + + // Auto-recover for remote mode: if the SSH control tunnel died (or hasn't been created yet), + // recreate it on demand so callers can recover without a manual reconnect. + self.logger.info( + "endpoint unavailable; ensuring remote control tunnel reason=\(reason, privacy: .public)") + return try await self.ensureRemoteConfig(detail: Self.remoteConnectingDetail) + } + } + + private func cancelRemoteEnsure() { + self.remoteEnsure?.task.cancel() + self.remoteEnsure = nil + } + + private func kickRemoteEnsureIfNeeded(detail: String) { + if self.remoteEnsure != nil { + self.setState(.connecting(mode: .remote, detail: detail)) + return + } + + let deps = self.deps + let token = UUID() + let task = Task.detached(priority: .utility) { try await deps.ensureRemoteTunnel() } + self.remoteEnsure = (token: token, task: task) + self.setState(.connecting(mode: .remote, detail: detail)) + } + + private func ensureRemoteConfig(detail: String) async throws -> GatewayConnection.Config { + let mode = await self.deps.mode() + guard mode == .remote else { + throw NSError( + domain: "RemoteTunnel", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "Remote mode is not enabled"]) + } + + let root = MoltbotConfigFile.loadDict() + if GatewayRemoteConfig.resolveTransport(root: root) == .direct { + guard let url = GatewayRemoteConfig.resolveGatewayUrl(root: root) else { + throw NSError( + domain: "GatewayEndpoint", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "gateway.remote.url missing or invalid"]) + } + let token = self.deps.token() + let password = self.deps.password() + self.cancelRemoteEnsure() + self.setState(.ready(mode: .remote, url: url, token: token, password: password)) + return (url, token, password) + } + + self.kickRemoteEnsureIfNeeded(detail: detail) + guard let ensure = self.remoteEnsure else { + throw NSError(domain: "GatewayEndpoint", code: 1, userInfo: [NSLocalizedDescriptionKey: "Connecting…"]) + } + + do { + let forwarded = try await ensure.task.value + let stillRemote = await self.deps.mode() == .remote + guard stillRemote else { + throw NSError( + domain: "RemoteTunnel", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "Remote mode is not enabled"]) + } + + if self.remoteEnsure?.token == ensure.token { + self.remoteEnsure = nil + } + + let token = self.deps.token() + let password = self.deps.password() + let scheme = GatewayEndpointStore.resolveGatewayScheme( + root: MoltbotConfigFile.loadDict(), + env: ProcessInfo.processInfo.environment) + let url = URL(string: "\(scheme)://127.0.0.1:\(Int(forwarded))")! + self.setState(.ready(mode: .remote, url: url, token: token, password: password)) + return (url, token, password) + } catch let err as CancellationError { + if self.remoteEnsure?.token == ensure.token { + self.remoteEnsure = nil + } + throw err + } catch { + if self.remoteEnsure?.token == ensure.token { + self.remoteEnsure = nil + } + let msg = "Remote control tunnel failed (\(error.localizedDescription))" + self.setState(.unavailable(mode: .remote, reason: msg)) + self.logger.error("remote control tunnel ensure failed \(msg, privacy: .public)") + throw NSError(domain: "GatewayEndpoint", code: 1, userInfo: [NSLocalizedDescriptionKey: msg]) + } + } + + private func removeSubscriber(_ id: UUID) { + self.subscribers[id] = nil + } + + private func setState(_ next: GatewayEndpointState) { + guard next != self.state else { return } + self.state = next + for (_, continuation) in self.subscribers { + continuation.yield(next) + } + switch next { + case let .ready(mode, url, _, _): + let modeDesc = String(describing: mode) + let urlDesc = url.absoluteString + self.logger + .debug( + "resolved endpoint mode=\(modeDesc, privacy: .public) url=\(urlDesc, privacy: .public)") + case let .connecting(mode, detail): + let modeDesc = String(describing: mode) + self.logger + .debug( + "endpoint connecting mode=\(modeDesc, privacy: .public) detail=\(detail, privacy: .public)") + case let .unavailable(mode, reason): + let modeDesc = String(describing: mode) + self.logger + .debug( + "endpoint unavailable mode=\(modeDesc, privacy: .public) reason=\(reason, privacy: .public)") + } + } + + func maybeFallbackToTailnet(from currentURL: URL) async -> GatewayConnection.Config? { + let mode = await self.deps.mode() + guard mode == .local else { return nil } + + let root = MoltbotConfigFile.loadDict() + let bind = GatewayEndpointStore.resolveGatewayBindMode( + root: root, + env: ProcessInfo.processInfo.environment) + guard bind == "tailnet" else { return nil } + + let currentHost = currentURL.host?.lowercased() ?? "" + guard currentHost == "127.0.0.1" || currentHost == "localhost" else { return nil } + + let tailscaleIP = await MainActor.run { TailscaleService.shared.tailscaleIP } + ?? TailscaleService.fallbackTailnetIPv4() + guard let tailscaleIP, !tailscaleIP.isEmpty else { return nil } + + let scheme = GatewayEndpointStore.resolveGatewayScheme( + root: root, + env: ProcessInfo.processInfo.environment) + let port = self.deps.localPort() + let token = self.deps.token() + let password = self.deps.password() + let url = URL(string: "\(scheme)://\(tailscaleIP):\(port)")! + + self.logger.info("auto bind fallback to tailnet host=\(tailscaleIP, privacy: .public)") + self.setState(.ready(mode: .local, url: url, token: token, password: password)) + return (url, token, password) + } + + private static func resolveGatewayBindMode( + root: [String: Any], + env: [String: String]) -> String? + { + if let envBind = env["CLAWDBOT_GATEWAY_BIND"] { + let trimmed = envBind.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + if self.supportedBindModes.contains(trimmed) { + return trimmed + } + } + if let gateway = root["gateway"] as? [String: Any], + let bind = gateway["bind"] as? String + { + let trimmed = bind.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + if self.supportedBindModes.contains(trimmed) { + return trimmed + } + } + return nil + } + + private static func resolveGatewayCustomBindHost(root: [String: Any]) -> String? { + if let gateway = root["gateway"] as? [String: Any], + let customBindHost = gateway["customBindHost"] as? String + { + let trimmed = customBindHost.trimmingCharacters(in: .whitespacesAndNewlines) + return trimmed.isEmpty ? nil : trimmed + } + return nil + } + + private static func resolveGatewayScheme( + root: [String: Any], + env: [String: String]) -> String + { + if let envValue = env["CLAWDBOT_GATEWAY_TLS"]?.trimmingCharacters(in: .whitespacesAndNewlines), + !envValue.isEmpty + { + return (envValue == "1" || envValue.lowercased() == "true") ? "wss" : "ws" + } + if let gateway = root["gateway"] as? [String: Any], + let tls = gateway["tls"] as? [String: Any], + let enabled = tls["enabled"] as? Bool + { + return enabled ? "wss" : "ws" + } + return "ws" + } + + private static func resolveLocalGatewayHost( + bindMode: String?, + customBindHost: String?, + tailscaleIP: String?) -> String + { + switch bindMode { + case "tailnet": + tailscaleIP ?? "127.0.0.1" + case "auto": + "127.0.0.1" + case "custom": + customBindHost ?? "127.0.0.1" + default: + "127.0.0.1" + } + } +} + +extension GatewayEndpointStore { + static func dashboardURL(for config: GatewayConnection.Config) throws -> URL { + guard var components = URLComponents(url: config.url, resolvingAgainstBaseURL: false) else { + throw NSError(domain: "Dashboard", code: 1, userInfo: [ + NSLocalizedDescriptionKey: "Invalid gateway URL", + ]) + } + switch components.scheme?.lowercased() { + case "ws": + components.scheme = "http" + case "wss": + components.scheme = "https" + default: + components.scheme = "http" + } + components.path = "/" + var queryItems: [URLQueryItem] = [] + if let token = config.token?.trimmingCharacters(in: .whitespacesAndNewlines), + !token.isEmpty + { + queryItems.append(URLQueryItem(name: "token", value: token)) + } + if let password = config.password?.trimmingCharacters(in: .whitespacesAndNewlines), + !password.isEmpty + { + queryItems.append(URLQueryItem(name: "password", value: password)) + } + components.queryItems = queryItems.isEmpty ? nil : queryItems + guard let url = components.url else { + throw NSError(domain: "Dashboard", code: 2, userInfo: [ + NSLocalizedDescriptionKey: "Failed to build dashboard URL", + ]) + } + return url + } +} + +#if DEBUG +extension GatewayEndpointStore { + static func _testResolveGatewayPassword( + isRemote: Bool, + root: [String: Any], + env: [String: String], + launchdSnapshot: LaunchAgentPlistSnapshot? = nil) -> String? + { + self.resolveGatewayPassword(isRemote: isRemote, root: root, env: env, launchdSnapshot: launchdSnapshot) + } + + static func _testResolveGatewayToken( + isRemote: Bool, + root: [String: Any], + env: [String: String], + launchdSnapshot: LaunchAgentPlistSnapshot? = nil) -> String? + { + self.resolveGatewayToken(isRemote: isRemote, root: root, env: env, launchdSnapshot: launchdSnapshot) + } + + static func _testResolveGatewayBindMode( + root: [String: Any], + env: [String: String]) -> String? + { + self.resolveGatewayBindMode(root: root, env: env) + } + + static func _testResolveLocalGatewayHost( + bindMode: String?, + tailscaleIP: String?, + customBindHost: String? = nil) -> String + { + self.resolveLocalGatewayHost( + bindMode: bindMode, + customBindHost: customBindHost, + tailscaleIP: tailscaleIP) + } +} +#endif diff --git a/apps/macos/Sources/Moltbot/GatewayEnvironment.swift b/apps/macos/Sources/Moltbot/GatewayEnvironment.swift new file mode 100644 index 000000000..2689d8604 --- /dev/null +++ b/apps/macos/Sources/Moltbot/GatewayEnvironment.swift @@ -0,0 +1,342 @@ +import MoltbotIPC +import Foundation +import OSLog + +// Lightweight SemVer helper (major.minor.patch only) for gateway compatibility checks. +struct Semver: Comparable, CustomStringConvertible, Sendable { + let major: Int + let minor: Int + let patch: Int + + var description: String { "\(self.major).\(self.minor).\(self.patch)" } + + static func < (lhs: Semver, rhs: Semver) -> Bool { + if lhs.major != rhs.major { return lhs.major < rhs.major } + if lhs.minor != rhs.minor { return lhs.minor < rhs.minor } + return lhs.patch < rhs.patch + } + + static func parse(_ raw: String?) -> Semver? { + guard let raw, !raw.isEmpty else { return nil } + let cleaned = raw.trimmingCharacters(in: .whitespacesAndNewlines) + .replacingOccurrences(of: "^v", with: "", options: .regularExpression) + let parts = cleaned.split(separator: ".") + guard parts.count >= 3, + let major = Int(parts[0]), + let minor = Int(parts[1]) + else { return nil } + // Strip prerelease suffix (e.g., "11-4" → "11", "5-beta.1" → "5") + let patchRaw = String(parts[2]) + guard let patchToken = patchRaw.split(whereSeparator: { $0 == "-" || $0 == "+" }).first, + let patchNumeric = Int(patchToken) + else { + return nil + } + return Semver(major: major, minor: minor, patch: patchNumeric) + } + + func compatible(with required: Semver) -> Bool { + // Same major and not older than required. + self.major == required.major && self >= required + } +} + +enum GatewayEnvironmentKind: Equatable { + case checking + case ok + case missingNode + case missingGateway + case incompatible(found: String, required: String) + case error(String) +} + +struct GatewayEnvironmentStatus: Equatable { + let kind: GatewayEnvironmentKind + let nodeVersion: String? + let gatewayVersion: String? + let requiredGateway: String? + let message: String + + static var checking: Self { + .init(kind: .checking, nodeVersion: nil, gatewayVersion: nil, requiredGateway: nil, message: "Checking…") + } +} + +struct GatewayCommandResolution { + let status: GatewayEnvironmentStatus + let command: [String]? +} + +enum GatewayEnvironment { + private static let logger = Logger(subsystem: "bot.molt", category: "gateway.env") + private static let supportedBindModes: Set = ["loopback", "tailnet", "lan", "auto"] + + static func gatewayPort() -> Int { + if let raw = ProcessInfo.processInfo.environment["CLAWDBOT_GATEWAY_PORT"] { + let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) + if let parsed = Int(trimmed), parsed > 0 { return parsed } + } + if let configPort = MoltbotConfigFile.gatewayPort(), configPort > 0 { + return configPort + } + let stored = UserDefaults.standard.integer(forKey: "gatewayPort") + return stored > 0 ? stored : 18789 + } + + static func expectedGatewayVersion() -> Semver? { + Semver.parse(self.expectedGatewayVersionString()) + } + + static func expectedGatewayVersionString() -> String? { + let bundleVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String + let trimmed = bundleVersion?.trimmingCharacters(in: .whitespacesAndNewlines) + return (trimmed?.isEmpty == false) ? trimmed : nil + } + + // Exposed for tests so we can inject fake version checks without rewriting bundle metadata. + static func expectedGatewayVersion(from versionString: String?) -> Semver? { + Semver.parse(versionString) + } + + static func check() -> GatewayEnvironmentStatus { + let start = Date() + defer { + let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) + if elapsedMs > 500 { + self.logger.warning("gateway env check slow (\(elapsedMs, privacy: .public)ms)") + } else { + self.logger.debug("gateway env check ok (\(elapsedMs, privacy: .public)ms)") + } + } + let expected = self.expectedGatewayVersion() + let expectedString = self.expectedGatewayVersionString() + + let projectRoot = CommandResolver.projectRoot() + let projectEntrypoint = CommandResolver.gatewayEntrypoint(in: projectRoot) + + switch RuntimeLocator.resolve(searchPaths: CommandResolver.preferredPaths()) { + case let .failure(err): + return GatewayEnvironmentStatus( + kind: .missingNode, + nodeVersion: nil, + gatewayVersion: nil, + requiredGateway: expectedString, + message: RuntimeLocator.describeFailure(err)) + case let .success(runtime): + let gatewayBin = CommandResolver.clawdbotExecutable() + + if gatewayBin == nil, projectEntrypoint == nil { + return GatewayEnvironmentStatus( + kind: .missingGateway, + nodeVersion: runtime.version.description, + gatewayVersion: nil, + requiredGateway: expectedString, + message: "moltbot CLI not found in PATH; install the CLI.") + } + + let installed = gatewayBin.flatMap { self.readGatewayVersion(binary: $0) } + ?? self.readLocalGatewayVersion(projectRoot: projectRoot) + + if let expected, let installed, !installed.compatible(with: expected) { + let expectedText = expectedString ?? expected.description + return GatewayEnvironmentStatus( + kind: .incompatible(found: installed.description, required: expectedText), + nodeVersion: runtime.version.description, + gatewayVersion: installed.description, + requiredGateway: expectedText, + message: """ + Gateway version \(installed.description) is incompatible with app \(expectedText); + install or update the global package. + """) + } + + let gatewayLabel = gatewayBin != nil ? "global" : "local" + let gatewayVersionText = installed?.description ?? "unknown" + // Avoid repeating "(local)" twice; if using the local entrypoint, show the path once. + let localPathHint = gatewayBin == nil && projectEntrypoint != nil + ? " (local: \(projectEntrypoint ?? "unknown"))" + : "" + let gatewayLabelText = gatewayBin != nil + ? "(\(gatewayLabel))" + : localPathHint.isEmpty ? "(\(gatewayLabel))" : localPathHint + return GatewayEnvironmentStatus( + kind: .ok, + nodeVersion: runtime.version.description, + gatewayVersion: gatewayVersionText, + requiredGateway: expectedString, + message: "Node \(runtime.version.description); gateway \(gatewayVersionText) \(gatewayLabelText)") + } + } + + static func resolveGatewayCommand() -> GatewayCommandResolution { + let start = Date() + defer { + let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) + if elapsedMs > 500 { + self.logger.warning("gateway command resolve slow (\(elapsedMs, privacy: .public)ms)") + } else { + self.logger.debug("gateway command resolve ok (\(elapsedMs, privacy: .public)ms)") + } + } + let projectRoot = CommandResolver.projectRoot() + let projectEntrypoint = CommandResolver.gatewayEntrypoint(in: projectRoot) + let status = self.check() + let gatewayBin = CommandResolver.clawdbotExecutable() + let runtime = RuntimeLocator.resolve(searchPaths: CommandResolver.preferredPaths()) + + guard case .ok = status.kind else { + return GatewayCommandResolution(status: status, command: nil) + } + + let port = self.gatewayPort() + if let gatewayBin { + let bind = self.preferredGatewayBind() ?? "loopback" + let cmd = [gatewayBin, "gateway-daemon", "--port", "\(port)", "--bind", bind] + return GatewayCommandResolution(status: status, command: cmd) + } + + if let entry = projectEntrypoint, + case let .success(resolvedRuntime) = runtime + { + let bind = self.preferredGatewayBind() ?? "loopback" + let cmd = [resolvedRuntime.path, entry, "gateway-daemon", "--port", "\(port)", "--bind", bind] + return GatewayCommandResolution(status: status, command: cmd) + } + + return GatewayCommandResolution(status: status, command: nil) + } + + private static func preferredGatewayBind() -> String? { + if CommandResolver.connectionModeIsRemote() { + return nil + } + if let env = ProcessInfo.processInfo.environment["CLAWDBOT_GATEWAY_BIND"] { + let trimmed = env.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + if self.supportedBindModes.contains(trimmed) { + return trimmed + } + } + + let root = MoltbotConfigFile.loadDict() + if let gateway = root["gateway"] as? [String: Any], + let bind = gateway["bind"] as? String + { + let trimmed = bind.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + if self.supportedBindModes.contains(trimmed) { + return trimmed + } + } + + return nil + } + + static func installGlobal(version: Semver?, statusHandler: @escaping @Sendable (String) -> Void) async { + await self.installGlobal(versionString: version?.description, statusHandler: statusHandler) + } + + static func installGlobal(versionString: String?, statusHandler: @escaping @Sendable (String) -> Void) async { + let preferred = CommandResolver.preferredPaths().joined(separator: ":") + let trimmed = versionString?.trimmingCharacters(in: .whitespacesAndNewlines) + let target: String = if let trimmed, !trimmed.isEmpty { + trimmed + } else { + "latest" + } + let npm = CommandResolver.findExecutable(named: "npm") + let pnpm = CommandResolver.findExecutable(named: "pnpm") + let bun = CommandResolver.findExecutable(named: "bun") + let (label, cmd): (String, [String]) = + if let npm { + ("npm", [npm, "install", "-g", "moltbot@\(target)"]) + } else if let pnpm { + ("pnpm", [pnpm, "add", "-g", "moltbot@\(target)"]) + } else if let bun { + ("bun", [bun, "add", "-g", "moltbot@\(target)"]) + } else { + ("npm", ["npm", "install", "-g", "moltbot@\(target)"]) + } + + statusHandler("Installing moltbot@\(target) via \(label)…") + + func summarize(_ text: String) -> String? { + let lines = text + .split(whereSeparator: \.isNewline) + .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) } + .filter { !$0.isEmpty } + guard let last = lines.last else { return nil } + let normalized = last.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression) + return normalized.count > 200 ? String(normalized.prefix(199)) + "…" : normalized + } + + let response = await ShellExecutor.runDetailed(command: cmd, cwd: nil, env: ["PATH": preferred], timeout: 300) + if response.success { + statusHandler("Installed moltbot@\(target)") + } else { + if response.timedOut { + statusHandler("Install failed: timed out. Check your internet connection and try again.") + return + } + + let exit = response.exitCode.map { "exit \($0)" } ?? (response.errorMessage ?? "failed") + let detail = summarize(response.stderr) ?? summarize(response.stdout) + if let detail { + statusHandler("Install failed (\(exit)): \(detail)") + } else { + statusHandler("Install failed (\(exit))") + } + } + } + + // MARK: - Internals + + private static func readGatewayVersion(binary: String) -> Semver? { + let start = Date() + let process = Process() + process.executableURL = URL(fileURLWithPath: binary) + process.arguments = ["--version"] + process.environment = ["PATH": CommandResolver.preferredPaths().joined(separator: ":")] + + let pipe = Pipe() + process.standardOutput = pipe + process.standardError = pipe + do { + let data = try process.runAndReadToEnd(from: pipe) + let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) + if elapsedMs > 500 { + self.logger.warning( + """ + gateway --version slow (\(elapsedMs, privacy: .public)ms) \ + bin=\(binary, privacy: .public) + """) + } else { + self.logger.debug( + """ + gateway --version ok (\(elapsedMs, privacy: .public)ms) \ + bin=\(binary, privacy: .public) + """) + } + let raw = String(data: data, encoding: .utf8)? + .trimmingCharacters(in: .whitespacesAndNewlines) + return Semver.parse(raw) + } catch { + let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) + self.logger.error( + """ + gateway --version failed (\(elapsedMs, privacy: .public)ms) \ + bin=\(binary, privacy: .public) \ + err=\(error.localizedDescription, privacy: .public) + """) + return nil + } + } + + private static func readLocalGatewayVersion(projectRoot: URL) -> Semver? { + let pkg = projectRoot.appendingPathComponent("package.json") + guard let data = try? Data(contentsOf: pkg) else { return nil } + guard + let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any], + let version = json["version"] as? String + else { return nil } + return Semver.parse(version) + } +} diff --git a/apps/macos/Sources/Moltbot/GatewayLaunchAgentManager.swift b/apps/macos/Sources/Moltbot/GatewayLaunchAgentManager.swift new file mode 100644 index 000000000..70c5a5eec --- /dev/null +++ b/apps/macos/Sources/Moltbot/GatewayLaunchAgentManager.swift @@ -0,0 +1,203 @@ +import Foundation + +enum GatewayLaunchAgentManager { + private static let logger = Logger(subsystem: "bot.molt", category: "gateway.launchd") + private static let disableLaunchAgentMarker = ".clawdbot/disable-launchagent" + + private static var disableLaunchAgentMarkerURL: URL { + FileManager().homeDirectoryForCurrentUser + .appendingPathComponent(self.disableLaunchAgentMarker) + } + + private static var plistURL: URL { + FileManager().homeDirectoryForCurrentUser + .appendingPathComponent("Library/LaunchAgents/\(gatewayLaunchdLabel).plist") + } + + static func isLaunchAgentWriteDisabled() -> Bool { + FileManager().fileExists(atPath: self.disableLaunchAgentMarkerURL.path) + } + + static func setLaunchAgentWriteDisabled(_ disabled: Bool) -> String? { + let marker = self.disableLaunchAgentMarkerURL + if disabled { + do { + try FileManager().createDirectory( + at: marker.deletingLastPathComponent(), + withIntermediateDirectories: true) + if !FileManager().fileExists(atPath: marker.path) { + FileManager().createFile(atPath: marker.path, contents: nil) + } + } catch { + return error.localizedDescription + } + return nil + } + + if FileManager().fileExists(atPath: marker.path) { + do { + try FileManager().removeItem(at: marker) + } catch { + return error.localizedDescription + } + } + return nil + } + + static func isLoaded() async -> Bool { + guard let loaded = await self.readDaemonLoaded() else { return false } + return loaded + } + + static func set(enabled: Bool, bundlePath: String, port: Int) async -> String? { + _ = bundlePath + guard !CommandResolver.connectionModeIsRemote() else { + self.logger.info("launchd change skipped (remote mode)") + return nil + } + if enabled, self.isLaunchAgentWriteDisabled() { + self.logger.info("launchd enable skipped (disable marker set)") + return nil + } + + if enabled { + self.logger.info("launchd enable requested via CLI port=\(port)") + return await self.runDaemonCommand([ + "install", + "--force", + "--port", + "\(port)", + "--runtime", + "node", + ]) + } + + self.logger.info("launchd disable requested via CLI") + return await self.runDaemonCommand(["uninstall"]) + } + + static func kickstart() async { + _ = await self.runDaemonCommand(["restart"], timeout: 20) + } + + static func launchdConfigSnapshot() -> LaunchAgentPlistSnapshot? { + LaunchAgentPlist.snapshot(url: self.plistURL) + } + + static func launchdGatewayLogPath() -> String { + let snapshot = self.launchdConfigSnapshot() + if let stdout = snapshot?.stdoutPath?.trimmingCharacters(in: .whitespacesAndNewlines), + !stdout.isEmpty + { + return stdout + } + if let stderr = snapshot?.stderrPath?.trimmingCharacters(in: .whitespacesAndNewlines), + !stderr.isEmpty + { + return stderr + } + return LogLocator.launchdGatewayLogPath + } +} + +extension GatewayLaunchAgentManager { + private static func readDaemonLoaded() async -> Bool? { + let result = await self.runDaemonCommandResult( + ["status", "--json", "--no-probe"], + timeout: 15, + quiet: true) + guard result.success, let payload = result.payload else { return nil } + guard + let json = try? JSONSerialization.jsonObject(with: payload) as? [String: Any], + let service = json["service"] as? [String: Any], + let loaded = service["loaded"] as? Bool + else { + return nil + } + return loaded + } + + private struct CommandResult { + let success: Bool + let payload: Data? + let message: String? + } + + private struct ParsedDaemonJson { + let text: String + let object: [String: Any] + } + + private static func runDaemonCommand( + _ args: [String], + timeout: Double = 15, + quiet: Bool = false) async -> String? + { + let result = await self.runDaemonCommandResult(args, timeout: timeout, quiet: quiet) + if result.success { return nil } + return result.message ?? "Gateway daemon command failed" + } + + private static func runDaemonCommandResult( + _ args: [String], + timeout: Double, + quiet: Bool) async -> CommandResult + { + let command = CommandResolver.clawdbotCommand( + subcommand: "gateway", + extraArgs: self.withJsonFlag(args), + // Launchd management must always run locally, even if remote mode is configured. + configRoot: ["gateway": ["mode": "local"]]) + var env = ProcessInfo.processInfo.environment + env["PATH"] = CommandResolver.preferredPaths().joined(separator: ":") + let response = await ShellExecutor.runDetailed(command: command, cwd: nil, env: env, timeout: timeout) + let parsed = self.parseDaemonJson(from: response.stdout) ?? self.parseDaemonJson(from: response.stderr) + let ok = parsed?.object["ok"] as? Bool + let message = (parsed?.object["error"] as? String) ?? (parsed?.object["message"] as? String) + let payload = parsed?.text.data(using: .utf8) + ?? (response.stdout.isEmpty ? response.stderr : response.stdout).data(using: .utf8) + let success = ok ?? response.success + if success { + return CommandResult(success: true, payload: payload, message: nil) + } + + if quiet { + return CommandResult(success: false, payload: payload, message: message) + } + + let detail = message ?? self.summarize(response.stderr) ?? self.summarize(response.stdout) + let exit = response.exitCode.map { "exit \($0)" } ?? (response.errorMessage ?? "failed") + let fullMessage = detail.map { "Gateway daemon command failed (\(exit)): \($0)" } + ?? "Gateway daemon command failed (\(exit))" + self.logger.error("\(fullMessage, privacy: .public)") + return CommandResult(success: false, payload: payload, message: detail) + } + + private static func withJsonFlag(_ args: [String]) -> [String] { + if args.contains("--json") { return args } + return args + ["--json"] + } + + private static func parseDaemonJson(from raw: String) -> ParsedDaemonJson? { + let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) + guard let start = trimmed.firstIndex(of: "{"), + let end = trimmed.lastIndex(of: "}") + else { + return nil + } + let jsonText = String(trimmed[start...end]) + guard let data = jsonText.data(using: .utf8) else { return nil } + guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil } + return ParsedDaemonJson(text: jsonText, object: object) + } + + private static func summarize(_ text: String) -> String? { + let lines = text + .split(whereSeparator: \.isNewline) + .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) } + .filter { !$0.isEmpty } + guard let last = lines.last else { return nil } + let normalized = last.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression) + return normalized.count > 200 ? String(normalized.prefix(199)) + "…" : normalized + } +} diff --git a/apps/macos/Sources/Moltbot/GatewayProcessManager.swift b/apps/macos/Sources/Moltbot/GatewayProcessManager.swift new file mode 100644 index 000000000..86dfc851f --- /dev/null +++ b/apps/macos/Sources/Moltbot/GatewayProcessManager.swift @@ -0,0 +1,432 @@ +import Foundation +import Observation + +@MainActor +@Observable +final class GatewayProcessManager { + static let shared = GatewayProcessManager() + + enum Status: Equatable { + case stopped + case starting + case running(details: String?) + case attachedExisting(details: String?) + case failed(String) + + var label: String { + switch self { + case .stopped: return "Stopped" + case .starting: return "Starting…" + case let .running(details): + if let details, !details.isEmpty { return "Running (\(details))" } + return "Running" + case let .attachedExisting(details): + if let details, !details.isEmpty { + return "Using existing gateway (\(details))" + } + return "Using existing gateway" + case let .failed(reason): return "Failed: \(reason)" + } + } + } + + private(set) var status: Status = .stopped { + didSet { CanvasManager.shared.refreshDebugStatus() } + } + + private(set) var log: String = "" + private(set) var environmentStatus: GatewayEnvironmentStatus = .checking + private(set) var existingGatewayDetails: String? + private(set) var lastFailureReason: String? + private var desiredActive = false + private var environmentRefreshTask: Task? + private var lastEnvironmentRefresh: Date? + private var logRefreshTask: Task? + #if DEBUG + private var testingConnection: GatewayConnection? + #endif + private let logger = Logger(subsystem: "bot.molt", category: "gateway.process") + + private let logLimit = 20000 // characters to keep in-memory + private let environmentRefreshMinInterval: TimeInterval = 30 + private var connection: GatewayConnection { + #if DEBUG + return self.testingConnection ?? .shared + #else + return .shared + #endif + } + + func setActive(_ active: Bool) { + // Remote mode should never spawn a local gateway; treat as stopped. + if CommandResolver.connectionModeIsRemote() { + self.desiredActive = false + self.stop() + self.status = .stopped + self.appendLog("[gateway] remote mode active; skipping local gateway\n") + self.logger.info("gateway process skipped: remote mode active") + return + } + self.logger.debug("gateway active requested active=\(active)") + self.desiredActive = active + self.refreshEnvironmentStatus() + if active { + self.startIfNeeded() + } else { + self.stop() + } + } + + func ensureLaunchAgentEnabledIfNeeded() async { + guard !CommandResolver.connectionModeIsRemote() else { return } + if GatewayLaunchAgentManager.isLaunchAgentWriteDisabled() { + self.appendLog("[gateway] launchd auto-enable skipped (attach-only)\n") + self.logger.info("gateway launchd auto-enable skipped (disable marker set)") + return + } + let enabled = await GatewayLaunchAgentManager.isLoaded() + guard !enabled else { return } + let bundlePath = Bundle.main.bundleURL.path + let port = GatewayEnvironment.gatewayPort() + self.appendLog("[gateway] auto-enabling launchd job (\(gatewayLaunchdLabel)) on port \(port)\n") + let err = await GatewayLaunchAgentManager.set(enabled: true, bundlePath: bundlePath, port: port) + if let err { + self.appendLog("[gateway] launchd auto-enable failed: \(err)\n") + } + } + + func startIfNeeded() { + guard self.desiredActive else { return } + // Do not spawn in remote mode (the gateway should run on the remote host). + guard !CommandResolver.connectionModeIsRemote() else { + self.status = .stopped + return + } + // Many surfaces can call `setActive(true)` in quick succession (startup, Canvas, health checks). + // Avoid spawning multiple concurrent "start" tasks that can thrash launchd and flap the port. + switch self.status { + case .starting, .running, .attachedExisting: + return + case .stopped, .failed: + break + } + self.status = .starting + self.logger.debug("gateway start requested") + + // First try to latch onto an already-running gateway to avoid spawning a duplicate. + Task { [weak self] in + guard let self else { return } + if await self.attachExistingGatewayIfAvailable() { + return + } + await self.enableLaunchdGateway() + } + } + + func stop() { + self.desiredActive = false + self.existingGatewayDetails = nil + self.lastFailureReason = nil + self.status = .stopped + self.logger.info("gateway stop requested") + if CommandResolver.connectionModeIsRemote() { + return + } + let bundlePath = Bundle.main.bundleURL.path + Task { + _ = await GatewayLaunchAgentManager.set( + enabled: false, + bundlePath: bundlePath, + port: GatewayEnvironment.gatewayPort()) + } + } + + func clearLastFailure() { + self.lastFailureReason = nil + } + + func refreshEnvironmentStatus(force: Bool = false) { + let now = Date() + if !force { + if self.environmentRefreshTask != nil { return } + if let last = self.lastEnvironmentRefresh, + now.timeIntervalSince(last) < self.environmentRefreshMinInterval + { + return + } + } + self.lastEnvironmentRefresh = now + self.environmentRefreshTask = Task { [weak self] in + let status = await Task.detached(priority: .utility) { + GatewayEnvironment.check() + }.value + await MainActor.run { + guard let self else { return } + self.environmentStatus = status + self.environmentRefreshTask = nil + } + } + } + + func refreshLog() { + guard self.logRefreshTask == nil else { return } + let path = GatewayLaunchAgentManager.launchdGatewayLogPath() + let limit = self.logLimit + self.logRefreshTask = Task { [weak self] in + let log = await Task.detached(priority: .utility) { + Self.readGatewayLog(path: path, limit: limit) + }.value + await MainActor.run { + guard let self else { return } + if !log.isEmpty { + self.log = log + } + self.logRefreshTask = nil + } + } + } + + // MARK: - Internals + + /// Attempt to connect to an already-running gateway on the configured port. + /// If successful, mark status as attached and skip spawning a new process. + private func attachExistingGatewayIfAvailable() async -> Bool { + let port = GatewayEnvironment.gatewayPort() + let instance = await PortGuardian.shared.describe(port: port) + let instanceText = instance.map { self.describe(instance: $0) } + let hasListener = instance != nil + + let attemptAttach = { + try await self.connection.requestRaw(method: .health, timeoutMs: 2000) + } + + for attempt in 0..<(hasListener ? 3 : 1) { + do { + let data = try await attemptAttach() + let snap = decodeHealthSnapshot(from: data) + let details = self.describe(details: instanceText, port: port, snap: snap) + self.existingGatewayDetails = details + self.clearLastFailure() + self.status = .attachedExisting(details: details) + self.appendLog("[gateway] using existing instance: \(details)\n") + self.logger.info("gateway using existing instance details=\(details)") + self.refreshControlChannelIfNeeded(reason: "attach existing") + self.refreshLog() + return true + } catch { + if attempt < 2, hasListener { + try? await Task.sleep(nanoseconds: 250_000_000) + continue + } + + if hasListener { + let reason = self.describeAttachFailure(error, port: port, instance: instance) + self.existingGatewayDetails = instanceText + self.status = .failed(reason) + self.lastFailureReason = reason + self.appendLog("[gateway] existing listener on port \(port) but attach failed: \(reason)\n") + self.logger.warning("gateway attach failed reason=\(reason)") + return true + } + + // No reachable gateway (and no listener) — fall through to spawn. + self.existingGatewayDetails = nil + return false + } + } + + self.existingGatewayDetails = nil + return false + } + + private func describe(details instance: String?, port: Int, snap: HealthSnapshot?) -> String { + let instanceText = instance ?? "pid unknown" + if let snap { + let order = snap.channelOrder ?? Array(snap.channels.keys) + let linkId = order.first(where: { snap.channels[$0]?.linked == true }) + ?? order.first(where: { snap.channels[$0]?.linked != nil }) + guard let linkId else { + return "port \(port), health probe succeeded, \(instanceText)" + } + let linked = snap.channels[linkId]?.linked ?? false + let authAge = snap.channels[linkId]?.authAgeMs.flatMap(msToAge) ?? "unknown age" + let label = + snap.channelLabels?[linkId] ?? + linkId.capitalized + let linkText = linked ? "linked" : "not linked" + return "port \(port), \(label) \(linkText), auth \(authAge), \(instanceText)" + } + return "port \(port), health probe succeeded, \(instanceText)" + } + + private func describe(instance: PortGuardian.Descriptor) -> String { + let path = instance.executablePath ?? "path unknown" + return "pid \(instance.pid) \(instance.command) @ \(path)" + } + + private func describeAttachFailure(_ error: Error, port: Int, instance: PortGuardian.Descriptor?) -> String { + let ns = error as NSError + let message = ns.localizedDescription.isEmpty ? "unknown error" : ns.localizedDescription + let lower = message.lowercased() + if self.isGatewayAuthFailure(error) { + return """ + Gateway on port \(port) rejected auth. Set gateway.auth.token (or CLAWDBOT_GATEWAY_TOKEN) \ + to match the running gateway (or clear it on the gateway) and retry. + """ + } + if lower.contains("protocol mismatch") { + return "Gateway on port \(port) is incompatible (protocol mismatch). Update the app/gateway." + } + if lower.contains("unexpected response") || lower.contains("invalid response") { + return "Port \(port) returned non-gateway data; another process is using it." + } + if let instance { + let instanceText = self.describe(instance: instance) + return "Gateway listener found on port \(port) (\(instanceText)) but health check failed: \(message)" + } + return "Gateway listener found on port \(port) but health check failed: \(message)" + } + + private func isGatewayAuthFailure(_ error: Error) -> Bool { + if let urlError = error as? URLError, urlError.code == .dataNotAllowed { + return true + } + let ns = error as NSError + if ns.domain == "Gateway", ns.code == 1008 { return true } + let lower = ns.localizedDescription.lowercased() + return lower.contains("unauthorized") || lower.contains("auth") + } + + private func enableLaunchdGateway() async { + self.existingGatewayDetails = nil + let resolution = await Task.detached(priority: .utility) { + GatewayEnvironment.resolveGatewayCommand() + }.value + await MainActor.run { self.environmentStatus = resolution.status } + guard resolution.command != nil else { + await MainActor.run { + self.status = .failed(resolution.status.message) + } + self.logger.error("gateway command resolve failed: \(resolution.status.message)") + return + } + + if GatewayLaunchAgentManager.isLaunchAgentWriteDisabled() { + let message = "Launchd disabled; start the Gateway manually or disable attach-only." + self.status = .failed(message) + self.lastFailureReason = "launchd disabled" + self.appendLog("[gateway] launchd disabled; skipping auto-start\n") + self.logger.info("gateway launchd enable skipped (disable marker set)") + return + } + + let bundlePath = Bundle.main.bundleURL.path + let port = GatewayEnvironment.gatewayPort() + self.appendLog("[gateway] enabling launchd job (\(gatewayLaunchdLabel)) on port \(port)\n") + self.logger.info("gateway enabling launchd port=\(port)") + let err = await GatewayLaunchAgentManager.set(enabled: true, bundlePath: bundlePath, port: port) + if let err { + self.status = .failed(err) + self.lastFailureReason = err + self.logger.error("gateway launchd enable failed: \(err)") + return + } + + // Best-effort: wait for the gateway to accept connections. + let deadline = Date().addingTimeInterval(6) + while Date() < deadline { + if !self.desiredActive { return } + do { + _ = try await self.connection.requestRaw(method: .health, timeoutMs: 1500) + let instance = await PortGuardian.shared.describe(port: port) + let details = instance.map { "pid \($0.pid)" } + self.clearLastFailure() + self.status = .running(details: details) + self.logger.info("gateway started details=\(details ?? "ok")") + self.refreshControlChannelIfNeeded(reason: "gateway started") + self.refreshLog() + return + } catch { + try? await Task.sleep(nanoseconds: 400_000_000) + } + } + + self.status = .failed("Gateway did not start in time") + self.lastFailureReason = "launchd start timeout" + self.logger.warning("gateway start timed out") + } + + private func appendLog(_ chunk: String) { + self.log.append(chunk) + if self.log.count > self.logLimit { + self.log = String(self.log.suffix(self.logLimit)) + } + } + + private func refreshControlChannelIfNeeded(reason: String) { + switch ControlChannel.shared.state { + case .connected, .connecting: + return + case .disconnected, .degraded: + break + } + self.appendLog("[gateway] refreshing control channel (\(reason))\n") + self.logger.debug("gateway control channel refresh reason=\(reason)") + Task { await ControlChannel.shared.configure() } + } + + func waitForGatewayReady(timeout: TimeInterval = 6) async -> Bool { + let deadline = Date().addingTimeInterval(timeout) + while Date() < deadline { + if !self.desiredActive { return false } + do { + _ = try await self.connection.requestRaw(method: .health, timeoutMs: 1500) + self.clearLastFailure() + return true + } catch { + try? await Task.sleep(nanoseconds: 300_000_000) + } + } + self.appendLog("[gateway] readiness wait timed out\n") + self.logger.warning("gateway readiness wait timed out") + return false + } + + func clearLog() { + self.log = "" + try? FileManager().removeItem(atPath: GatewayLaunchAgentManager.launchdGatewayLogPath()) + self.logger.debug("gateway log cleared") + } + + func setProjectRoot(path: String) { + CommandResolver.setProjectRoot(path) + } + + func projectRootPath() -> String { + CommandResolver.projectRootPath() + } + + private nonisolated static func readGatewayLog(path: String, limit: Int) -> String { + guard FileManager().fileExists(atPath: path) else { return "" } + guard let data = try? Data(contentsOf: URL(fileURLWithPath: path)) else { return "" } + let text = String(data: data, encoding: .utf8) ?? "" + if text.count <= limit { return text } + return String(text.suffix(limit)) + } +} + +#if DEBUG +extension GatewayProcessManager { + func setTestingConnection(_ connection: GatewayConnection?) { + self.testingConnection = connection + } + + func setTestingDesiredActive(_ active: Bool) { + self.desiredActive = active + } + + func setTestingLastFailureReason(_ reason: String?) { + self.lastFailureReason = reason + } +} +#endif diff --git a/apps/macos/Sources/Moltbot/HealthStore.swift b/apps/macos/Sources/Moltbot/HealthStore.swift new file mode 100644 index 000000000..6e4c2437b --- /dev/null +++ b/apps/macos/Sources/Moltbot/HealthStore.swift @@ -0,0 +1,301 @@ +import Foundation +import Network +import Observation +import SwiftUI + +struct HealthSnapshot: Codable, Sendable { + struct ChannelSummary: Codable, Sendable { + struct Probe: Codable, Sendable { + struct Bot: Codable, Sendable { + let username: String? + } + + struct Webhook: Codable, Sendable { + let url: String? + } + + let ok: Bool? + let status: Int? + let error: String? + let elapsedMs: Double? + let bot: Bot? + let webhook: Webhook? + } + + let configured: Bool? + let linked: Bool? + let authAgeMs: Double? + let probe: Probe? + let lastProbeAt: Double? + } + + struct SessionInfo: Codable, Sendable { + let key: String + let updatedAt: Double? + let age: Double? + } + + struct Sessions: Codable, Sendable { + let path: String + let count: Int + let recent: [SessionInfo] + } + + let ok: Bool? + let ts: Double + let durationMs: Double + let channels: [String: ChannelSummary] + let channelOrder: [String]? + let channelLabels: [String: String]? + let heartbeatSeconds: Int? + let sessions: Sessions +} + +enum HealthState: Equatable { + case unknown + case ok + case linkingNeeded + case degraded(String) + + var tint: Color { + switch self { + case .ok: .green + case .linkingNeeded: .red + case .degraded: .orange + case .unknown: .secondary + } + } +} + +@MainActor +@Observable +final class HealthStore { + static let shared = HealthStore() + + private static let logger = Logger(subsystem: "bot.molt", category: "health") + + private(set) var snapshot: HealthSnapshot? + private(set) var lastSuccess: Date? + private(set) var lastError: String? + private(set) var isRefreshing = false + + private var loopTask: Task? + private let refreshInterval: TimeInterval = 60 + + private init() { + // Avoid background health polling in SwiftUI previews and tests. + if !ProcessInfo.processInfo.isPreview, !ProcessInfo.processInfo.isRunningTests { + self.start() + } + } + + // Test-only escape hatch: the HealthStore is a process-wide singleton but + // state derivation is pure from `snapshot` + `lastError`. + func __setSnapshotForTest(_ snapshot: HealthSnapshot?, lastError: String? = nil) { + self.snapshot = snapshot + self.lastError = lastError + } + + func start() { + guard self.loopTask == nil else { return } + self.loopTask = Task { [weak self] in + guard let self else { return } + while !Task.isCancelled { + await self.refresh() + try? await Task.sleep(nanoseconds: UInt64(self.refreshInterval * 1_000_000_000)) + } + } + } + + func stop() { + self.loopTask?.cancel() + self.loopTask = nil + } + + func refresh(onDemand: Bool = false) async { + guard !self.isRefreshing else { return } + self.isRefreshing = true + defer { self.isRefreshing = false } + let previousError = self.lastError + + do { + let data = try await ControlChannel.shared.health(timeout: 15) + if let decoded = decodeHealthSnapshot(from: data) { + self.snapshot = decoded + self.lastSuccess = Date() + self.lastError = nil + if previousError != nil { + Self.logger.info("health refresh recovered") + } + } else { + self.lastError = "health output not JSON" + if onDemand { self.snapshot = nil } + if previousError != self.lastError { + Self.logger.warning("health refresh failed: output not JSON") + } + } + } catch { + let desc = error.localizedDescription + self.lastError = desc + if onDemand { self.snapshot = nil } + if previousError != desc { + Self.logger.error("health refresh failed \(desc, privacy: .public)") + } + } + } + + private static func isChannelHealthy(_ summary: HealthSnapshot.ChannelSummary) -> Bool { + guard summary.configured == true else { return false } + // If probe is missing, treat it as "configured but unknown health" (not a hard fail). + return summary.probe?.ok ?? true + } + + private static func describeProbeFailure(_ probe: HealthSnapshot.ChannelSummary.Probe) -> String { + let elapsed = probe.elapsedMs.map { "\(Int($0))ms" } + if let error = probe.error, error.lowercased().contains("timeout") || probe.status == nil { + if let elapsed { return "Health check timed out (\(elapsed))" } + return "Health check timed out" + } + let code = probe.status.map { "status \($0)" } ?? "status unknown" + let reason = probe.error?.isEmpty == false ? probe.error! : "health probe failed" + if let elapsed { return "\(reason) (\(code), \(elapsed))" } + return "\(reason) (\(code))" + } + + private func resolveLinkChannel( + _ snap: HealthSnapshot) -> (id: String, summary: HealthSnapshot.ChannelSummary)? + { + let order = snap.channelOrder ?? Array(snap.channels.keys) + for id in order { + if let summary = snap.channels[id], summary.linked == true { + return (id: id, summary: summary) + } + } + for id in order { + if let summary = snap.channels[id], summary.linked != nil { + return (id: id, summary: summary) + } + } + return nil + } + + private func resolveFallbackChannel( + _ snap: HealthSnapshot, + excluding id: String?) -> (id: String, summary: HealthSnapshot.ChannelSummary)? + { + let order = snap.channelOrder ?? Array(snap.channels.keys) + for channelId in order { + if channelId == id { continue } + guard let summary = snap.channels[channelId] else { continue } + if Self.isChannelHealthy(summary) { + return (id: channelId, summary: summary) + } + } + return nil + } + + var state: HealthState { + if let error = self.lastError, !error.isEmpty { + return .degraded(error) + } + guard let snap = self.snapshot else { return .unknown } + guard let link = self.resolveLinkChannel(snap) else { return .unknown } + if link.summary.linked != true { + // Linking is optional if any other channel is healthy; don't paint the whole app red. + let fallback = self.resolveFallbackChannel(snap, excluding: link.id) + return fallback != nil ? .degraded("Not linked") : .linkingNeeded + } + // A channel can be "linked" but still unhealthy (failed probe / cannot connect). + if let probe = link.summary.probe, probe.ok == false { + return .degraded(Self.describeProbeFailure(probe)) + } + return .ok + } + + var summaryLine: String { + if self.isRefreshing { return "Health check running…" } + if let error = self.lastError { return "Health check failed: \(error)" } + guard let snap = self.snapshot else { return "Health check pending" } + guard let link = self.resolveLinkChannel(snap) else { return "Health check pending" } + if link.summary.linked != true { + if let fallback = self.resolveFallbackChannel(snap, excluding: link.id) { + let fallbackLabel = snap.channelLabels?[fallback.id] ?? fallback.id.capitalized + let fallbackState = (fallback.summary.probe?.ok ?? true) ? "ok" : "degraded" + return "\(fallbackLabel) \(fallbackState) · Not linked — run moltbot login" + } + return "Not linked — run moltbot login" + } + let auth = link.summary.authAgeMs.map { msToAge($0) } ?? "unknown" + if let probe = link.summary.probe, probe.ok == false { + let status = probe.status.map(String.init) ?? "?" + let suffix = probe.status == nil ? "probe degraded" : "probe degraded · status \(status)" + return "linked · auth \(auth) · \(suffix)" + } + return "linked · auth \(auth)" + } + + /// Short, human-friendly detail for the last failure, used in the UI. + var detailLine: String? { + if let error = self.lastError, !error.isEmpty { + let lower = error.lowercased() + if lower.contains("connection refused") { + let port = GatewayEnvironment.gatewayPort() + let host = GatewayConnectivityCoordinator.shared.localEndpointHostLabel ?? "127.0.0.1:\(port)" + return "The gateway control port (\(host)) isn’t listening — restart Moltbot to bring it back." + } + if lower.contains("timeout") { + return "Timed out waiting for the control server; the gateway may be crashed or still starting." + } + return error + } + return nil + } + + func describeFailure(from snap: HealthSnapshot, fallback: String?) -> String { + if let link = self.resolveLinkChannel(snap), link.summary.linked != true { + return "Not linked — run moltbot login" + } + if let link = self.resolveLinkChannel(snap), let probe = link.summary.probe, probe.ok == false { + return Self.describeProbeFailure(probe) + } + if let fallback, !fallback.isEmpty { + return fallback + } + return "health probe failed" + } + + var degradedSummary: String? { + guard case let .degraded(reason) = self.state else { return nil } + if reason == "[object Object]" || reason.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, + let snap = self.snapshot + { + return self.describeFailure(from: snap, fallback: reason) + } + return reason + } +} + +func msToAge(_ ms: Double) -> String { + let minutes = Int(round(ms / 60000)) + if minutes < 1 { return "just now" } + if minutes < 60 { return "\(minutes)m" } + let hours = Int(round(Double(minutes) / 60)) + if hours < 48 { return "\(hours)h" } + let days = Int(round(Double(hours) / 24)) + return "\(days)d" +} + +/// Decode a health snapshot, tolerating stray log lines before/after the JSON blob. +func decodeHealthSnapshot(from data: Data) -> HealthSnapshot? { + let decoder = JSONDecoder() + if let snap = try? decoder.decode(HealthSnapshot.self, from: data) { + return snap + } + guard let text = String(data: data, encoding: .utf8) else { return nil } + guard let firstBrace = text.firstIndex(of: "{"), let lastBrace = text.lastIndex(of: "}") else { + return nil + } + let slice = text[firstBrace...lastBrace] + let cleaned = Data(slice.utf8) + return try? decoder.decode(HealthSnapshot.self, from: cleaned) +} diff --git a/apps/macos/Sources/Moltbot/InstancesStore.swift b/apps/macos/Sources/Moltbot/InstancesStore.swift new file mode 100644 index 000000000..65b20df29 --- /dev/null +++ b/apps/macos/Sources/Moltbot/InstancesStore.swift @@ -0,0 +1,394 @@ +import MoltbotKit +import MoltbotProtocol +import Cocoa +import Foundation +import Observation +import OSLog + +struct InstanceInfo: Identifiable, Codable { + let id: String + let host: String? + let ip: String? + let version: String? + let platform: String? + let deviceFamily: String? + let modelIdentifier: String? + let lastInputSeconds: Int? + let mode: String? + let reason: String? + let text: String + let ts: Double + + var ageDescription: String { + let date = Date(timeIntervalSince1970: ts / 1000) + return age(from: date) + } + + var lastInputDescription: String { + guard let secs = lastInputSeconds else { return "unknown" } + return "\(secs)s ago" + } +} + +@MainActor +@Observable +final class InstancesStore { + static let shared = InstancesStore() + let isPreview: Bool + + var instances: [InstanceInfo] = [] + var lastError: String? + var statusMessage: String? + var isLoading = false + + private let logger = Logger(subsystem: "bot.molt", category: "instances") + private var task: Task? + private let interval: TimeInterval = 30 + private var eventTask: Task? + private var startCount = 0 + private var lastPresenceById: [String: InstanceInfo] = [:] + private var lastLoginNotifiedAtMs: [String: Double] = [:] + + private struct PresenceEventPayload: Codable { + let presence: [PresenceEntry] + } + + init(isPreview: Bool = false) { + self.isPreview = isPreview + } + + func start() { + guard !self.isPreview else { return } + self.startCount += 1 + guard self.startCount == 1 else { return } + guard self.task == nil else { return } + self.startGatewaySubscription() + self.task = Task.detached { [weak self] in + guard let self else { return } + await self.refresh() + while !Task.isCancelled { + try? await Task.sleep(nanoseconds: UInt64(self.interval * 1_000_000_000)) + await self.refresh() + } + } + } + + func stop() { + guard !self.isPreview else { return } + guard self.startCount > 0 else { return } + self.startCount -= 1 + guard self.startCount == 0 else { return } + self.task?.cancel() + self.task = nil + self.eventTask?.cancel() + self.eventTask = nil + } + + private func startGatewaySubscription() { + self.eventTask?.cancel() + self.eventTask = Task { [weak self] in + guard let self else { return } + let stream = await GatewayConnection.shared.subscribe() + for await push in stream { + if Task.isCancelled { return } + await MainActor.run { [weak self] in + self?.handle(push: push) + } + } + } + } + + private func handle(push: GatewayPush) { + switch push { + case let .event(evt) where evt.event == "presence": + if let payload = evt.payload { + self.handlePresenceEventPayload(payload) + } + case .seqGap: + Task { await self.refresh() } + case let .snapshot(hello): + self.applyPresence(hello.snapshot.presence) + default: + break + } + } + + func refresh() async { + if self.isLoading { return } + self.statusMessage = nil + self.isLoading = true + defer { self.isLoading = false } + do { + PresenceReporter.shared.sendImmediate(reason: "instances-refresh") + let data = try await ControlChannel.shared.request(method: "system-presence") + self.lastPayload = data + if data.isEmpty { + self.logger.error("instances fetch returned empty payload") + self.instances = [self.localFallbackInstance(reason: "no presence payload")] + self.lastError = nil + self.statusMessage = "No presence payload from gateway; showing local fallback + health probe." + await self.probeHealthIfNeeded(reason: "no payload") + return + } + let decoded = try JSONDecoder().decode([PresenceEntry].self, from: data) + let withIDs = self.normalizePresence(decoded) + if withIDs.isEmpty { + self.instances = [self.localFallbackInstance(reason: "no presence entries")] + self.lastError = nil + self.statusMessage = "Presence list was empty; showing local fallback + health probe." + await self.probeHealthIfNeeded(reason: "empty list") + } else { + self.instances = withIDs + self.lastError = nil + self.statusMessage = nil + } + } catch { + self.logger.error( + """ + instances fetch failed: \(error.localizedDescription, privacy: .public) \ + len=\(self.lastPayload?.count ?? 0, privacy: .public) \ + utf8=\(self.snippet(self.lastPayload), privacy: .public) + """) + self.instances = [self.localFallbackInstance(reason: "presence decode failed")] + self.lastError = nil + self.statusMessage = "Presence data invalid; showing local fallback + health probe." + await self.probeHealthIfNeeded(reason: "decode failed") + } + } + + private func localFallbackInstance(reason: String) -> InstanceInfo { + let host = Host.current().localizedName ?? "this-mac" + let ip = Self.primaryIPv4Address() + let version = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String + let osVersion = ProcessInfo.processInfo.operatingSystemVersion + let platform = "macos \(osVersion.majorVersion).\(osVersion.minorVersion).\(osVersion.patchVersion)" + let text = "Local node: \(host)\(ip.map { " (\($0))" } ?? "") · app \(version ?? "dev")" + let ts = Date().timeIntervalSince1970 * 1000 + return InstanceInfo( + id: "local-\(host)", + host: host, + ip: ip, + version: version, + platform: platform, + deviceFamily: "Mac", + modelIdentifier: InstanceIdentity.modelIdentifier, + lastInputSeconds: Self.lastInputSeconds(), + mode: "local", + reason: reason, + text: text, + ts: ts) + } + + private static func lastInputSeconds() -> Int? { + let anyEvent = CGEventType(rawValue: UInt32.max) ?? .null + let seconds = CGEventSource.secondsSinceLastEventType(.combinedSessionState, eventType: anyEvent) + if seconds.isNaN || seconds.isInfinite || seconds < 0 { return nil } + return Int(seconds.rounded()) + } + + private static func primaryIPv4Address() -> String? { + var addrList: UnsafeMutablePointer? + guard getifaddrs(&addrList) == 0, let first = addrList else { return nil } + defer { freeifaddrs(addrList) } + + var fallback: String? + var en0: String? + + for ptr in sequence(first: first, next: { $0.pointee.ifa_next }) { + let flags = Int32(ptr.pointee.ifa_flags) + let isUp = (flags & IFF_UP) != 0 + let isLoopback = (flags & IFF_LOOPBACK) != 0 + let name = String(cString: ptr.pointee.ifa_name) + let family = ptr.pointee.ifa_addr.pointee.sa_family + if !isUp || isLoopback || family != UInt8(AF_INET) { continue } + + var addr = ptr.pointee.ifa_addr.pointee + var buffer = [CChar](repeating: 0, count: Int(NI_MAXHOST)) + let result = getnameinfo( + &addr, + socklen_t(ptr.pointee.ifa_addr.pointee.sa_len), + &buffer, + socklen_t(buffer.count), + nil, + 0, + NI_NUMERICHOST) + guard result == 0 else { continue } + let len = buffer.prefix { $0 != 0 } + let bytes = len.map { UInt8(bitPattern: $0) } + guard let ip = String(bytes: bytes, encoding: .utf8) else { continue } + + if name == "en0" { en0 = ip; break } + if fallback == nil { fallback = ip } + } + + return en0 ?? fallback + } + + // MARK: - Helpers + + /// Keep the last raw payload for logging. + private var lastPayload: Data? + + private func snippet(_ data: Data?, limit: Int = 256) -> String { + guard let data else { return "" } + if data.isEmpty { return "" } + let prefix = data.prefix(limit) + if let asString = String(data: prefix, encoding: .utf8) { + return asString.replacingOccurrences(of: "\n", with: " ") + } + return "<\(data.count) bytes non-utf8>" + } + + private func probeHealthIfNeeded(reason: String? = nil) async { + do { + let data = try await ControlChannel.shared.health(timeout: 8) + guard let snap = decodeHealthSnapshot(from: data) else { return } + let linkId = snap.channelOrder?.first(where: { + if let summary = snap.channels[$0] { return summary.linked != nil } + return false + }) ?? snap.channels.keys.first(where: { + if let summary = snap.channels[$0] { return summary.linked != nil } + return false + }) + let linked = linkId.flatMap { snap.channels[$0]?.linked } ?? false + let linkLabel = + linkId.flatMap { snap.channelLabels?[$0] } ?? + linkId?.capitalized ?? + "channel" + let entry = InstanceInfo( + id: "health-\(snap.ts)", + host: "gateway (health)", + ip: nil, + version: nil, + platform: nil, + deviceFamily: nil, + modelIdentifier: nil, + lastInputSeconds: nil, + mode: "health", + reason: "health probe", + text: "Health ok · \(linkLabel) linked=\(linked)", + ts: snap.ts) + if !self.instances.contains(where: { $0.id == entry.id }) { + self.instances.insert(entry, at: 0) + } + self.lastError = nil + self.statusMessage = + "Presence unavailable (\(reason ?? "refresh")); showing health probe + local fallback." + } catch { + self.logger.error("instances health probe failed: \(error.localizedDescription, privacy: .public)") + if let reason { + self.statusMessage = + "Presence unavailable (\(reason)), health probe failed: \(error.localizedDescription)" + } + } + } + + private func decodeAndApplyPresenceData(_ data: Data) { + do { + let decoded = try JSONDecoder().decode([PresenceEntry].self, from: data) + self.applyPresence(decoded) + } catch { + self.logger.error("presence decode from event failed: \(error.localizedDescription, privacy: .public)") + self.lastError = error.localizedDescription + } + } + + func handlePresenceEventPayload(_ payload: MoltbotProtocol.AnyCodable) { + do { + let wrapper = try GatewayPayloadDecoding.decode(payload, as: PresenceEventPayload.self) + self.applyPresence(wrapper.presence) + } catch { + self.logger.error("presence event decode failed: \(error.localizedDescription, privacy: .public)") + self.lastError = error.localizedDescription + } + } + + private func normalizePresence(_ entries: [PresenceEntry]) -> [InstanceInfo] { + entries.map { entry -> InstanceInfo in + let key = entry.instanceid ?? entry.host ?? entry.ip ?? entry.text ?? "entry-\(entry.ts)" + return InstanceInfo( + id: key, + host: entry.host, + ip: entry.ip, + version: entry.version, + platform: entry.platform, + deviceFamily: entry.devicefamily, + modelIdentifier: entry.modelidentifier, + lastInputSeconds: entry.lastinputseconds, + mode: entry.mode, + reason: entry.reason, + text: entry.text ?? "Unnamed node", + ts: Double(entry.ts)) + } + } + + private func applyPresence(_ entries: [PresenceEntry]) { + let withIDs = self.normalizePresence(entries) + self.notifyOnNodeLogin(withIDs) + self.lastPresenceById = Dictionary(uniqueKeysWithValues: withIDs.map { ($0.id, $0) }) + self.instances = withIDs + self.statusMessage = nil + self.lastError = nil + } + + private func notifyOnNodeLogin(_ instances: [InstanceInfo]) { + for inst in instances { + guard let reason = inst.reason?.trimmingCharacters(in: .whitespacesAndNewlines) else { continue } + guard reason == "node-connected" else { continue } + if let mode = inst.mode?.lowercased(), mode == "local" { continue } + + let previous = self.lastPresenceById[inst.id] + if previous?.reason == "node-connected", previous?.ts == inst.ts { continue } + + let lastNotified = self.lastLoginNotifiedAtMs[inst.id] ?? 0 + if inst.ts <= lastNotified { continue } + self.lastLoginNotifiedAtMs[inst.id] = inst.ts + + let name = inst.host?.trimmingCharacters(in: .whitespacesAndNewlines) + let device = name?.isEmpty == false ? name! : inst.id + Task { @MainActor in + _ = await NotificationManager().send( + title: "Node connected", + body: device, + sound: nil, + priority: .active) + } + } + } +} + +extension InstancesStore { + static func preview(instances: [InstanceInfo] = [ + InstanceInfo( + id: "local", + host: "steipete-mac", + ip: "10.0.0.12", + version: "1.2.3", + platform: "macos 26.2.0", + deviceFamily: "Mac", + modelIdentifier: "Mac16,6", + lastInputSeconds: 12, + mode: "local", + reason: "preview", + text: "Local node: steipete-mac (10.0.0.12) · app 1.2.3", + ts: Date().timeIntervalSince1970 * 1000), + InstanceInfo( + id: "gateway", + host: "gateway", + ip: "100.64.0.2", + version: "1.2.3", + platform: "linux 6.6.0", + deviceFamily: "Linux", + modelIdentifier: "x86_64", + lastInputSeconds: 45, + mode: "remote", + reason: "preview", + text: "Gateway node · tunnel ok", + ts: Date().timeIntervalSince1970 * 1000 - 45000), + ]) -> InstancesStore { + let store = InstancesStore(isPreview: true) + store.instances = instances + store.statusMessage = "Preview data" + return store + } +} diff --git a/apps/macos/Sources/Moltbot/LaunchAgentManager.swift b/apps/macos/Sources/Moltbot/LaunchAgentManager.swift new file mode 100644 index 000000000..fdc1785ba --- /dev/null +++ b/apps/macos/Sources/Moltbot/LaunchAgentManager.swift @@ -0,0 +1,95 @@ +import Foundation + +enum LaunchAgentManager { + private static let legacyLaunchdLabels = [ + "com.steipete.clawdbot", + "com.clawdbot.mac", + ] + private static var plistURL: URL { + FileManager().homeDirectoryForCurrentUser + .appendingPathComponent("Library/LaunchAgents/bot.molt.mac.plist") + } + + private static var legacyPlistURLs: [URL] { + self.legacyLaunchdLabels.map { label in + FileManager().homeDirectoryForCurrentUser + .appendingPathComponent("Library/LaunchAgents/\(label).plist") + } + } + + static func status() async -> Bool { + guard FileManager().fileExists(atPath: self.plistURL.path) else { return false } + let result = await self.runLaunchctl(["print", "gui/\(getuid())/\(launchdLabel)"]) + return result == 0 + } + + static func set(enabled: Bool, bundlePath: String) async { + if enabled { + for legacyLabel in self.legacyLaunchdLabels { + _ = await self.runLaunchctl(["bootout", "gui/\(getuid())/\(legacyLabel)"]) + } + for legacyURL in self.legacyPlistURLs { + try? FileManager().removeItem(at: legacyURL) + } + self.writePlist(bundlePath: bundlePath) + _ = await self.runLaunchctl(["bootout", "gui/\(getuid())/\(launchdLabel)"]) + _ = await self.runLaunchctl(["bootstrap", "gui/\(getuid())", self.plistURL.path]) + _ = await self.runLaunchctl(["kickstart", "-k", "gui/\(getuid())/\(launchdLabel)"]) + } else { + // Disable autostart going forward but leave the current app running. + // bootout would terminate the launchd job immediately (and crash the app if launched via agent). + try? FileManager().removeItem(at: self.plistURL) + } + } + + private static func writePlist(bundlePath: String) { + let plist = """ + + + + + Label + bot.molt.mac + ProgramArguments + + \(bundlePath)/Contents/MacOS/Moltbot + + WorkingDirectory + \(FileManager().homeDirectoryForCurrentUser.path) + RunAtLoad + + KeepAlive + + EnvironmentVariables + + PATH + \(CommandResolver.preferredPaths().joined(separator: ":")) + + StandardOutPath + \(LogLocator.launchdLogPath) + StandardErrorPath + \(LogLocator.launchdLogPath) + + + """ + try? plist.write(to: self.plistURL, atomically: true, encoding: .utf8) + } + + @discardableResult + private static func runLaunchctl(_ args: [String]) async -> Int32 { + await Task.detached(priority: .utility) { () -> Int32 in + let process = Process() + process.launchPath = "/bin/launchctl" + process.arguments = args + let pipe = Pipe() + process.standardOutput = pipe + process.standardError = pipe + do { + _ = try process.runAndReadToEnd(from: pipe) + return process.terminationStatus + } catch { + return -1 + } + }.value + } +} diff --git a/apps/macos/Sources/Moltbot/Logging/ClawdbotLogging.swift b/apps/macos/Sources/Moltbot/Logging/ClawdbotLogging.swift new file mode 100644 index 000000000..2ac8e8003 --- /dev/null +++ b/apps/macos/Sources/Moltbot/Logging/ClawdbotLogging.swift @@ -0,0 +1,230 @@ +import Foundation +@_exported import Logging +import os +import OSLog + +typealias Logger = Logging.Logger + +enum AppLogSettings { + static let logLevelKey = appLogLevelKey + + static func logLevel() -> Logger.Level { + if let raw = UserDefaults.standard.string(forKey: self.logLevelKey), + let level = Logger.Level(rawValue: raw) + { + return level + } + return .info + } + + static func setLogLevel(_ level: Logger.Level) { + UserDefaults.standard.set(level.rawValue, forKey: self.logLevelKey) + } + + static func fileLoggingEnabled() -> Bool { + UserDefaults.standard.bool(forKey: debugFileLogEnabledKey) + } +} + +enum AppLogLevel: String, CaseIterable, Identifiable { + case trace + case debug + case info + case notice + case warning + case error + case critical + + static let `default`: AppLogLevel = .info + + var id: String { self.rawValue } + + var title: String { + switch self { + case .trace: "Trace" + case .debug: "Debug" + case .info: "Info" + case .notice: "Notice" + case .warning: "Warning" + case .error: "Error" + case .critical: "Critical" + } + } +} + +enum MoltbotLogging { + private static let labelSeparator = "::" + + private static let didBootstrap: Void = { + LoggingSystem.bootstrap { label in + let (subsystem, category) = Self.parseLabel(label) + let osHandler = MoltbotOSLogHandler(subsystem: subsystem, category: category) + let fileHandler = MoltbotFileLogHandler(label: label) + return MultiplexLogHandler([osHandler, fileHandler]) + } + }() + + static func bootstrapIfNeeded() { + _ = self.didBootstrap + } + + static func makeLabel(subsystem: String, category: String) -> String { + "\(subsystem)\(self.labelSeparator)\(category)" + } + + static func parseLabel(_ label: String) -> (String, String) { + guard let range = label.range(of: labelSeparator) else { + return ("bot.molt", label) + } + let subsystem = String(label[.. Logger.Metadata.Value? { + get { self.metadata[key] } + set { self.metadata[key] = newValue } + } + + func log( + level: Logger.Level, + message: Logger.Message, + metadata: Logger.Metadata?, + source: String, + file: String, + function: String, + line: UInt) + { + let merged = Self.mergeMetadata(self.metadata, metadata) + let rendered = Self.renderMessage(message, metadata: merged) + self.osLogger.log(level: Self.osLogType(for: level), "\(rendered, privacy: .public)") + } + + private static func osLogType(for level: Logger.Level) -> OSLogType { + switch level { + case .trace, .debug: + .debug + case .info, .notice: + .info + case .warning: + .default + case .error: + .error + case .critical: + .fault + } + } + + private static func mergeMetadata( + _ base: Logger.Metadata, + _ extra: Logger.Metadata?) -> Logger.Metadata + { + guard let extra else { return base } + return base.merging(extra, uniquingKeysWith: { _, new in new }) + } + + private static func renderMessage(_ message: Logger.Message, metadata: Logger.Metadata) -> String { + guard !metadata.isEmpty else { return message.description } + let meta = metadata + .sorted(by: { $0.key < $1.key }) + .map { "\($0.key)=\(self.stringify($0.value))" } + .joined(separator: " ") + return "\(message.description) [\(meta)]" + } + + private static func stringify(_ value: Logger.Metadata.Value) -> String { + switch value { + case let .string(text): + text + case let .stringConvertible(value): + String(describing: value) + case let .array(values): + "[" + values.map { self.stringify($0) }.joined(separator: ",") + "]" + case let .dictionary(entries): + "{" + entries.map { "\($0.key)=\(self.stringify($0.value))" }.joined(separator: ",") + "}" + } + } +} + +struct MoltbotFileLogHandler: LogHandler { + let label: String + var metadata: Logger.Metadata = [:] + + var logLevel: Logger.Level { + get { AppLogSettings.logLevel() } + set { AppLogSettings.setLogLevel(newValue) } + } + + subscript(metadataKey key: String) -> Logger.Metadata.Value? { + get { self.metadata[key] } + set { self.metadata[key] = newValue } + } + + func log( + level: Logger.Level, + message: Logger.Message, + metadata: Logger.Metadata?, + source: String, + file: String, + function: String, + line: UInt) + { + guard AppLogSettings.fileLoggingEnabled() else { return } + let (subsystem, category) = MoltbotLogging.parseLabel(self.label) + var fields: [String: String] = [ + "subsystem": subsystem, + "category": category, + "level": level.rawValue, + "source": source, + "file": file, + "function": function, + "line": "\(line)", + ] + let merged = self.metadata.merging(metadata ?? [:], uniquingKeysWith: { _, new in new }) + for (key, value) in merged { + fields["meta.\(key)"] = Self.stringify(value) + } + DiagnosticsFileLog.shared.log(category: category, event: message.description, fields: fields) + } + + private static func stringify(_ value: Logger.Metadata.Value) -> String { + switch value { + case let .string(text): + text + case let .stringConvertible(value): + String(describing: value) + case let .array(values): + "[" + values.map { self.stringify($0) }.joined(separator: ",") + "]" + case let .dictionary(entries): + "{" + entries.map { "\($0.key)=\(self.stringify($0.value))" }.joined(separator: ",") + "}" + } + } +} diff --git a/apps/macos/Sources/Moltbot/MenuBar.swift b/apps/macos/Sources/Moltbot/MenuBar.swift new file mode 100644 index 000000000..63cce602c --- /dev/null +++ b/apps/macos/Sources/Moltbot/MenuBar.swift @@ -0,0 +1,471 @@ +import AppKit +import Darwin +import Foundation +import MenuBarExtraAccess +import Observation +import OSLog +import Security +import SwiftUI + +@main +struct MoltbotApp: App { + @NSApplicationDelegateAdaptor(AppDelegate.self) private var delegate + @State private var state: AppState + private static let logger = Logger(subsystem: "bot.molt", category: "app") + private let gatewayManager = GatewayProcessManager.shared + private let controlChannel = ControlChannel.shared + private let activityStore = WorkActivityStore.shared + private let connectivityCoordinator = GatewayConnectivityCoordinator.shared + @State private var statusItem: NSStatusItem? + @State private var isMenuPresented = false + @State private var isPanelVisible = false + @State private var tailscaleService = TailscaleService.shared + + @MainActor + private func updateStatusHighlight() { + self.statusItem?.button?.highlight(self.isPanelVisible) + } + + @MainActor + private func updateHoverHUDSuppression() { + HoverHUDController.shared.setSuppressed(self.isMenuPresented || self.isPanelVisible) + } + + init() { + MoltbotLogging.bootstrapIfNeeded() + Self.applyAttachOnlyOverrideIfNeeded() + _state = State(initialValue: AppStateStore.shared) + } + + var body: some Scene { + MenuBarExtra { MenuContent(state: self.state, updater: self.delegate.updaterController) } label: { + CritterStatusLabel( + isPaused: self.state.isPaused, + isSleeping: self.isGatewaySleeping, + isWorking: self.state.isWorking, + earBoostActive: self.state.earBoostActive, + blinkTick: self.state.blinkTick, + sendCelebrationTick: self.state.sendCelebrationTick, + gatewayStatus: self.gatewayManager.status, + animationsEnabled: self.state.iconAnimationsEnabled && !self.isGatewaySleeping, + iconState: self.effectiveIconState) + } + .menuBarExtraStyle(.menu) + .menuBarExtraAccess(isPresented: self.$isMenuPresented) { item in + self.statusItem = item + MenuSessionsInjector.shared.install(into: item) + self.applyStatusItemAppearance(paused: self.state.isPaused, sleeping: self.isGatewaySleeping) + self.installStatusItemMouseHandler(for: item) + self.updateHoverHUDSuppression() + } + .onChange(of: self.state.isPaused) { _, paused in + self.applyStatusItemAppearance(paused: paused, sleeping: self.isGatewaySleeping) + if self.state.connectionMode == .local { + self.gatewayManager.setActive(!paused) + } else { + self.gatewayManager.stop() + } + } + .onChange(of: self.controlChannel.state) { _, _ in + self.applyStatusItemAppearance(paused: self.state.isPaused, sleeping: self.isGatewaySleeping) + } + .onChange(of: self.gatewayManager.status) { _, _ in + self.applyStatusItemAppearance(paused: self.state.isPaused, sleeping: self.isGatewaySleeping) + } + .onChange(of: self.state.connectionMode) { _, mode in + Task { await ConnectionModeCoordinator.shared.apply(mode: mode, paused: self.state.isPaused) } + CLIInstallPrompter.shared.checkAndPromptIfNeeded(reason: "connection-mode") + } + + Settings { + SettingsRootView(state: self.state, updater: self.delegate.updaterController) + .frame(width: SettingsTab.windowWidth, height: SettingsTab.windowHeight, alignment: .topLeading) + .environment(self.tailscaleService) + } + .defaultSize(width: SettingsTab.windowWidth, height: SettingsTab.windowHeight) + .windowResizability(.contentSize) + .onChange(of: self.isMenuPresented) { _, _ in + self.updateStatusHighlight() + self.updateHoverHUDSuppression() + } + } + + private func applyStatusItemAppearance(paused: Bool, sleeping: Bool) { + self.statusItem?.button?.appearsDisabled = paused || sleeping + } + + private static func applyAttachOnlyOverrideIfNeeded() { + let args = CommandLine.arguments + guard args.contains("--attach-only") || args.contains("--no-launchd") else { return } + if let error = GatewayLaunchAgentManager.setLaunchAgentWriteDisabled(true) { + Self.logger.error("attach-only flag failed: \(error, privacy: .public)") + return + } + Task { + _ = await GatewayLaunchAgentManager.set( + enabled: false, + bundlePath: Bundle.main.bundlePath, + port: GatewayEnvironment.gatewayPort()) + } + Self.logger.info("attach-only flag enabled") + } + + private var isGatewaySleeping: Bool { + if self.state.isPaused { return false } + switch self.state.connectionMode { + case .unconfigured: + return true + case .remote: + if case .connected = self.controlChannel.state { return false } + return true + case .local: + switch self.gatewayManager.status { + case .running, .starting, .attachedExisting: + if case .connected = self.controlChannel.state { return false } + return true + case .failed, .stopped: + return true + } + } + } + + @MainActor + private func installStatusItemMouseHandler(for item: NSStatusItem) { + guard let button = item.button else { return } + if button.subviews.contains(where: { $0 is StatusItemMouseHandlerView }) { return } + + WebChatManager.shared.onPanelVisibilityChanged = { [self] visible in + self.isPanelVisible = visible + self.updateStatusHighlight() + self.updateHoverHUDSuppression() + } + CanvasManager.shared.onPanelVisibilityChanged = { [self] visible in + self.state.canvasPanelVisible = visible + } + CanvasManager.shared.defaultAnchorProvider = { [self] in self.statusButtonScreenFrame() } + + let handler = StatusItemMouseHandlerView() + handler.translatesAutoresizingMaskIntoConstraints = false + handler.onLeftClick = { [self] in + HoverHUDController.shared.dismiss(reason: "statusItemClick") + self.toggleWebChatPanel() + } + handler.onRightClick = { [self] in + HoverHUDController.shared.dismiss(reason: "statusItemRightClick") + WebChatManager.shared.closePanel() + self.isMenuPresented = true + self.updateStatusHighlight() + } + handler.onHoverChanged = { [self] inside in + HoverHUDController.shared.statusItemHoverChanged( + inside: inside, + anchorProvider: { [self] in self.statusButtonScreenFrame() }) + } + + button.addSubview(handler) + NSLayoutConstraint.activate([ + handler.leadingAnchor.constraint(equalTo: button.leadingAnchor), + handler.trailingAnchor.constraint(equalTo: button.trailingAnchor), + handler.topAnchor.constraint(equalTo: button.topAnchor), + handler.bottomAnchor.constraint(equalTo: button.bottomAnchor), + ]) + } + + @MainActor + private func toggleWebChatPanel() { + HoverHUDController.shared.setSuppressed(true) + self.isMenuPresented = false + Task { @MainActor in + let sessionKey = await WebChatManager.shared.preferredSessionKey() + WebChatManager.shared.togglePanel( + sessionKey: sessionKey, + anchorProvider: { [self] in self.statusButtonScreenFrame() }) + } + } + + @MainActor + private func statusButtonScreenFrame() -> NSRect? { + guard let button = self.statusItem?.button, let window = button.window else { return nil } + let inWindow = button.convert(button.bounds, to: nil) + return window.convertToScreen(inWindow) + } + + private var effectiveIconState: IconState { + let selection = self.state.iconOverride + if selection == .system { + return self.activityStore.iconState + } + let overrideState = selection.toIconState() + switch overrideState { + case let .workingMain(kind): return .overridden(kind) + case let .workingOther(kind): return .overridden(kind) + case .idle: return .idle + case let .overridden(kind): return .overridden(kind) + } + } +} + +/// Transparent overlay that intercepts clicks without stealing MenuBarExtra ownership. +private final class StatusItemMouseHandlerView: NSView { + var onLeftClick: (() -> Void)? + var onRightClick: (() -> Void)? + var onHoverChanged: ((Bool) -> Void)? + private var tracking: NSTrackingArea? + + override func mouseDown(with event: NSEvent) { + if let onLeftClick { + onLeftClick() + } else { + super.mouseDown(with: event) + } + } + + override func rightMouseDown(with event: NSEvent) { + self.onRightClick?() + // Do not call super; menu will be driven by isMenuPresented binding. + } + + override func updateTrackingAreas() { + super.updateTrackingAreas() + if let tracking { + self.removeTrackingArea(tracking) + } + let options: NSTrackingArea.Options = [ + .mouseEnteredAndExited, + .activeAlways, + .inVisibleRect, + ] + let area = NSTrackingArea(rect: self.bounds, options: options, owner: self, userInfo: nil) + self.addTrackingArea(area) + self.tracking = area + } + + override func mouseEntered(with event: NSEvent) { + self.onHoverChanged?(true) + } + + override func mouseExited(with event: NSEvent) { + self.onHoverChanged?(false) + } +} + +@MainActor +final class AppDelegate: NSObject, NSApplicationDelegate { + private var state: AppState? + private let webChatAutoLogger = Logger(subsystem: "bot.molt", category: "Chat") + let updaterController: UpdaterProviding = makeUpdaterController() + + func application(_: NSApplication, open urls: [URL]) { + Task { @MainActor in + for url in urls { + await DeepLinkHandler.shared.handle(url: url) + } + } + } + + @MainActor + func applicationDidFinishLaunching(_ notification: Notification) { + if self.isDuplicateInstance() { + NSApp.terminate(nil) + return + } + self.state = AppStateStore.shared + AppActivationPolicy.apply(showDockIcon: self.state?.showDockIcon ?? false) + if let state { + Task { await ConnectionModeCoordinator.shared.apply(mode: state.connectionMode, paused: state.isPaused) } + } + TerminationSignalWatcher.shared.start() + NodePairingApprovalPrompter.shared.start() + DevicePairingApprovalPrompter.shared.start() + ExecApprovalsPromptServer.shared.start() + ExecApprovalsGatewayPrompter.shared.start() + MacNodeModeCoordinator.shared.start() + VoiceWakeGlobalSettingsSync.shared.start() + Task { PresenceReporter.shared.start() } + Task { await HealthStore.shared.refresh(onDemand: true) } + Task { await PortGuardian.shared.sweep(mode: AppStateStore.shared.connectionMode) } + Task { await PeekabooBridgeHostCoordinator.shared.setEnabled(AppStateStore.shared.peekabooBridgeEnabled) } + self.scheduleFirstRunOnboardingIfNeeded() + DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { + CLIInstallPrompter.shared.checkAndPromptIfNeeded(reason: "launch") + } + + // Developer/testing helper: auto-open chat when launched with --chat (or legacy --webchat). + if CommandLine.arguments.contains("--chat") || CommandLine.arguments.contains("--webchat") { + self.webChatAutoLogger.debug("Auto-opening chat via CLI flag") + Task { @MainActor in + let sessionKey = await WebChatManager.shared.preferredSessionKey() + WebChatManager.shared.show(sessionKey: sessionKey) + } + } + } + + func applicationWillTerminate(_ notification: Notification) { + PresenceReporter.shared.stop() + NodePairingApprovalPrompter.shared.stop() + DevicePairingApprovalPrompter.shared.stop() + ExecApprovalsPromptServer.shared.stop() + ExecApprovalsGatewayPrompter.shared.stop() + MacNodeModeCoordinator.shared.stop() + TerminationSignalWatcher.shared.stop() + VoiceWakeGlobalSettingsSync.shared.stop() + WebChatManager.shared.close() + WebChatManager.shared.resetTunnels() + Task { await RemoteTunnelManager.shared.stopAll() } + Task { await GatewayConnection.shared.shutdown() } + Task { await PeekabooBridgeHostCoordinator.shared.stop() } + } + + @MainActor + private func scheduleFirstRunOnboardingIfNeeded() { + let seenVersion = UserDefaults.standard.integer(forKey: onboardingVersionKey) + let shouldShow = seenVersion < currentOnboardingVersion || !AppStateStore.shared.onboardingSeen + guard shouldShow else { return } + DispatchQueue.main.asyncAfter(deadline: .now() + 0.6) { + OnboardingController.shared.show() + } + } + + private func isDuplicateInstance() -> Bool { + guard let bundleID = Bundle.main.bundleIdentifier else { return false } + let running = NSWorkspace.shared.runningApplications.filter { $0.bundleIdentifier == bundleID } + return running.count > 1 + } +} + +// MARK: - Sparkle updater (disabled for unsigned/dev builds) + +@MainActor +protocol UpdaterProviding: AnyObject { + var automaticallyChecksForUpdates: Bool { get set } + var automaticallyDownloadsUpdates: Bool { get set } + var isAvailable: Bool { get } + var updateStatus: UpdateStatus { get } + func checkForUpdates(_ sender: Any?) +} + +// No-op updater used for debug/dev runs to suppress Sparkle dialogs. +final class DisabledUpdaterController: UpdaterProviding { + var automaticallyChecksForUpdates: Bool = false + var automaticallyDownloadsUpdates: Bool = false + let isAvailable: Bool = false + let updateStatus = UpdateStatus() + func checkForUpdates(_: Any?) {} +} + +@MainActor +@Observable +final class UpdateStatus { + static let disabled = UpdateStatus() + var isUpdateReady: Bool + + init(isUpdateReady: Bool = false) { + self.isUpdateReady = isUpdateReady + } +} + +#if canImport(Sparkle) +import Sparkle + +@MainActor +final class SparkleUpdaterController: NSObject, UpdaterProviding { + private lazy var controller = SPUStandardUpdaterController( + startingUpdater: false, + updaterDelegate: self, + userDriverDelegate: nil) + let updateStatus = UpdateStatus() + + init(savedAutoUpdate: Bool) { + super.init() + let updater = self.controller.updater + updater.automaticallyChecksForUpdates = savedAutoUpdate + updater.automaticallyDownloadsUpdates = savedAutoUpdate + self.controller.startUpdater() + } + + var automaticallyChecksForUpdates: Bool { + get { self.controller.updater.automaticallyChecksForUpdates } + set { self.controller.updater.automaticallyChecksForUpdates = newValue } + } + + var automaticallyDownloadsUpdates: Bool { + get { self.controller.updater.automaticallyDownloadsUpdates } + set { self.controller.updater.automaticallyDownloadsUpdates = newValue } + } + + var isAvailable: Bool { true } + + func checkForUpdates(_ sender: Any?) { + self.controller.checkForUpdates(sender) + } + + func updater(_ updater: SPUUpdater, didDownloadUpdate item: SUAppcastItem) { + self.updateStatus.isUpdateReady = true + } + + func updater(_ updater: SPUUpdater, failedToDownloadUpdate item: SUAppcastItem, error: Error) { + self.updateStatus.isUpdateReady = false + } + + func userDidCancelDownload(_ updater: SPUUpdater) { + self.updateStatus.isUpdateReady = false + } + + func updater( + _ updater: SPUUpdater, + userDidMakeChoice choice: SPUUserUpdateChoice, + forUpdate updateItem: SUAppcastItem, + state: SPUUserUpdateState) + { + switch choice { + case .install, .skip: + self.updateStatus.isUpdateReady = false + case .dismiss: + self.updateStatus.isUpdateReady = (state.stage == .downloaded) + @unknown default: + self.updateStatus.isUpdateReady = false + } + } +} + +extension SparkleUpdaterController: @preconcurrency SPUUpdaterDelegate {} + +private func isDeveloperIDSigned(bundleURL: URL) -> Bool { + var staticCode: SecStaticCode? + guard SecStaticCodeCreateWithPath(bundleURL as CFURL, SecCSFlags(), &staticCode) == errSecSuccess, + let code = staticCode + else { return false } + + var infoCF: CFDictionary? + guard SecCodeCopySigningInformation(code, SecCSFlags(rawValue: kSecCSSigningInformation), &infoCF) == errSecSuccess, + let info = infoCF as? [String: Any], + let certs = info[kSecCodeInfoCertificates as String] as? [SecCertificate], + let leaf = certs.first + else { + return false + } + + if let summary = SecCertificateCopySubjectSummary(leaf) as String? { + return summary.hasPrefix("Developer ID Application:") + } + return false +} + +@MainActor +private func makeUpdaterController() -> UpdaterProviding { + let bundleURL = Bundle.main.bundleURL + let isBundledApp = bundleURL.pathExtension == "app" + guard isBundledApp, isDeveloperIDSigned(bundleURL: bundleURL) else { return DisabledUpdaterController() } + + let defaults = UserDefaults.standard + let autoUpdateKey = "autoUpdateEnabled" + // Default to true; honor the user's last choice otherwise. + let savedAutoUpdate = (defaults.object(forKey: autoUpdateKey) as? Bool) ?? true + return SparkleUpdaterController(savedAutoUpdate: savedAutoUpdate) +} +#else +@MainActor +private func makeUpdaterController() -> UpdaterProviding { + DisabledUpdaterController() +} +#endif diff --git a/apps/macos/Sources/Moltbot/MicLevelMonitor.swift b/apps/macos/Sources/Moltbot/MicLevelMonitor.swift new file mode 100644 index 000000000..654f9052a --- /dev/null +++ b/apps/macos/Sources/Moltbot/MicLevelMonitor.swift @@ -0,0 +1,97 @@ +import AVFoundation +import OSLog +import SwiftUI + +actor MicLevelMonitor { + private let logger = Logger(subsystem: "bot.molt", category: "voicewake.meter") + private var engine: AVAudioEngine? + private var update: (@Sendable (Double) -> Void)? + private var running = false + private var smoothedLevel: Double = 0 + + func start(onLevel: @Sendable @escaping (Double) -> Void) async throws { + self.update = onLevel + if self.running { return } + self.logger.info( + "mic level monitor start (\(AudioInputDeviceObserver.defaultInputDeviceSummary(), privacy: .public))") + let engine = AVAudioEngine() + self.engine = engine + let input = engine.inputNode + let format = input.outputFormat(forBus: 0) + guard format.channelCount > 0, format.sampleRate > 0 else { + self.engine = nil + throw NSError( + domain: "MicLevelMonitor", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "No audio input available"]) + } + input.removeTap(onBus: 0) + input.installTap(onBus: 0, bufferSize: 512, format: format) { [weak self] buffer, _ in + guard let self else { return } + let level = Self.normalizedLevel(from: buffer) + Task { await self.push(level: level) } + } + engine.prepare() + try engine.start() + self.running = true + } + + func stop() { + guard self.running else { return } + if let engine { + engine.inputNode.removeTap(onBus: 0) + engine.stop() + } + self.engine = nil + self.running = false + } + + private func push(level: Double) { + self.smoothedLevel = (self.smoothedLevel * 0.45) + (level * 0.55) + guard let update else { return } + let value = self.smoothedLevel + Task { @MainActor in update(value) } + } + + private static func normalizedLevel(from buffer: AVAudioPCMBuffer) -> Double { + guard let channel = buffer.floatChannelData?[0] else { return 0 } + let frameCount = Int(buffer.frameLength) + guard frameCount > 0 else { return 0 } + var sum: Float = 0 + for i in 0.. Double(idx) + RoundedRectangle(cornerRadius: 2) + .fill(fill ? self.segmentColor(for: idx) : Color.gray.opacity(0.35)) + .frame(width: 14, height: 10) + } + } + .padding(4) + .background( + RoundedRectangle(cornerRadius: 6) + .stroke(Color.gray.opacity(0.25), lineWidth: 1)) + } + + private func segmentColor(for idx: Int) -> Color { + let fraction = Double(idx + 1) / Double(self.segments) + if fraction < 0.65 { return .green } + if fraction < 0.85 { return .yellow } + return .red + } +} diff --git a/apps/macos/Sources/Moltbot/ModelCatalogLoader.swift b/apps/macos/Sources/Moltbot/ModelCatalogLoader.swift new file mode 100644 index 000000000..1ef60104e --- /dev/null +++ b/apps/macos/Sources/Moltbot/ModelCatalogLoader.swift @@ -0,0 +1,156 @@ +import Foundation +import JavaScriptCore + +enum ModelCatalogLoader { + static var defaultPath: String { self.resolveDefaultPath() } + private static let logger = Logger(subsystem: "bot.molt", category: "models") + private nonisolated static let appSupportDir: URL = { + let base = FileManager().urls(for: .applicationSupportDirectory, in: .userDomainMask).first! + return base.appendingPathComponent("Moltbot", isDirectory: true) + }() + + private static var cachePath: URL { + self.appSupportDir.appendingPathComponent("model-catalog/models.generated.js", isDirectory: false) + } + + static func load(from path: String) async throws -> [ModelChoice] { + let expanded = (path as NSString).expandingTildeInPath + guard let resolved = self.resolvePath(preferred: expanded) else { + self.logger.error("model catalog load failed: file not found") + throw NSError( + domain: "ModelCatalogLoader", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "Model catalog file not found"]) + } + self.logger.debug("model catalog load start file=\(URL(fileURLWithPath: resolved.path).lastPathComponent)") + let source = try String(contentsOfFile: resolved.path, encoding: .utf8) + let sanitized = self.sanitize(source: source) + + let ctx = JSContext() + ctx?.exceptionHandler = { _, exception in + if let exception { + self.logger.warning("model catalog JS exception: \(exception)") + } + } + ctx?.evaluateScript(sanitized) + guard let rawModels = ctx?.objectForKeyedSubscript("MODELS")?.toDictionary() as? [String: Any] else { + self.logger.error("model catalog parse failed: MODELS missing") + throw NSError( + domain: "ModelCatalogLoader", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "Failed to parse models.generated.ts"]) + } + + var choices: [ModelChoice] = [] + for (provider, value) in rawModels { + guard let models = value as? [String: Any] else { continue } + for (id, payload) in models { + guard let dict = payload as? [String: Any] else { continue } + let name = dict["name"] as? String ?? id + let ctxWindow = dict["contextWindow"] as? Int + choices.append(ModelChoice(id: id, name: name, provider: provider, contextWindow: ctxWindow)) + } + } + + let sorted = choices.sorted { lhs, rhs in + if lhs.provider == rhs.provider { + return lhs.name.localizedCaseInsensitiveCompare(rhs.name) == .orderedAscending + } + return lhs.provider.localizedCaseInsensitiveCompare(rhs.provider) == .orderedAscending + } + self.logger.debug("model catalog loaded providers=\(rawModels.count) models=\(sorted.count)") + if resolved.shouldCache { + self.cacheCatalog(sourcePath: resolved.path) + } + return sorted + } + + private static func resolveDefaultPath() -> String { + let cache = self.cachePath.path + if FileManager().isReadableFile(atPath: cache) { return cache } + if let bundlePath = self.bundleCatalogPath() { return bundlePath } + if let nodePath = self.nodeModulesCatalogPath() { return nodePath } + return cache + } + + private static func resolvePath(preferred: String) -> (path: String, shouldCache: Bool)? { + if FileManager().isReadableFile(atPath: preferred) { + return (preferred, preferred != self.cachePath.path) + } + + if let bundlePath = self.bundleCatalogPath(), bundlePath != preferred { + self.logger.warning("model catalog path missing; falling back to bundled catalog") + return (bundlePath, true) + } + + let cache = self.cachePath.path + if cache != preferred, FileManager().isReadableFile(atPath: cache) { + self.logger.warning("model catalog path missing; falling back to cached catalog") + return (cache, false) + } + + if let nodePath = self.nodeModulesCatalogPath(), nodePath != preferred { + self.logger.warning("model catalog path missing; falling back to node_modules catalog") + return (nodePath, true) + } + + return nil + } + + private static func bundleCatalogPath() -> String? { + guard let url = Bundle.main.url(forResource: "models.generated", withExtension: "js") else { + return nil + } + return url.path + } + + private static func nodeModulesCatalogPath() -> String? { + let roots = [ + URL(fileURLWithPath: CommandResolver.projectRootPath()), + URL(fileURLWithPath: FileManager().currentDirectoryPath), + ] + for root in roots { + let candidate = root + .appendingPathComponent("node_modules/@mariozechner/pi-ai/dist/models.generated.js") + if FileManager().isReadableFile(atPath: candidate.path) { + return candidate.path + } + } + return nil + } + + private static func cacheCatalog(sourcePath: String) { + let destination = self.cachePath + do { + try FileManager().createDirectory( + at: destination.deletingLastPathComponent(), + withIntermediateDirectories: true) + if FileManager().fileExists(atPath: destination.path) { + try FileManager().removeItem(at: destination) + } + try FileManager().copyItem(atPath: sourcePath, toPath: destination.path) + self.logger.debug("model catalog cached file=\(destination.lastPathComponent)") + } catch { + self.logger.warning("model catalog cache failed: \(error.localizedDescription)") + } + } + + private static func sanitize(source: String) -> String { + guard let exportRange = source.range(of: "export const MODELS"), + let firstBrace = source[exportRange.upperBound...].firstIndex(of: "{"), + let lastBrace = source.lastIndex(of: "}") + else { + return "var MODELS = {}" + } + var body = String(source[firstBrace...lastBrace]) + body = body.replacingOccurrences( + of: #"(?m)\bsatisfies\s+[^,}\n]+"#, + with: "", + options: .regularExpression) + body = body.replacingOccurrences( + of: #"(?m)\bas\s+[^;,\n]+"#, + with: "", + options: .regularExpression) + return "var MODELS = \(body);" + } +} diff --git a/apps/macos/Sources/Moltbot/NodeMode/MacNodeModeCoordinator.swift b/apps/macos/Sources/Moltbot/NodeMode/MacNodeModeCoordinator.swift new file mode 100644 index 000000000..3d619f53b --- /dev/null +++ b/apps/macos/Sources/Moltbot/NodeMode/MacNodeModeCoordinator.swift @@ -0,0 +1,171 @@ +import MoltbotKit +import Foundation +import OSLog + +@MainActor +final class MacNodeModeCoordinator { + static let shared = MacNodeModeCoordinator() + + private let logger = Logger(subsystem: "bot.molt", category: "mac-node") + private var task: Task? + private let runtime = MacNodeRuntime() + private let session = GatewayNodeSession() + + func start() { + guard self.task == nil else { return } + self.task = Task { [weak self] in + await self?.run() + } + } + + func stop() { + self.task?.cancel() + self.task = nil + Task { await self.session.disconnect() } + } + + func setPreferredGatewayStableID(_ stableID: String?) { + GatewayDiscoveryPreferences.setPreferredStableID(stableID) + Task { await self.session.disconnect() } + } + + private func run() async { + var retryDelay: UInt64 = 1_000_000_000 + var lastCameraEnabled: Bool? + let defaults = UserDefaults.standard + + while !Task.isCancelled { + if await MainActor.run(body: { AppStateStore.shared.isPaused }) { + try? await Task.sleep(nanoseconds: 1_000_000_000) + continue + } + + let cameraEnabled = defaults.object(forKey: cameraEnabledKey) as? Bool ?? false + if lastCameraEnabled == nil { + lastCameraEnabled = cameraEnabled + } else if lastCameraEnabled != cameraEnabled { + lastCameraEnabled = cameraEnabled + await self.session.disconnect() + try? await Task.sleep(nanoseconds: 200_000_000) + } + + do { + let config = try await GatewayEndpointStore.shared.requireConfig() + let caps = self.currentCaps() + let commands = self.currentCommands(caps: caps) + let permissions = await self.currentPermissions() + let connectOptions = GatewayConnectOptions( + role: "node", + scopes: [], + caps: caps, + commands: commands, + permissions: permissions, + clientId: "moltbot-macos", + clientMode: "node", + clientDisplayName: InstanceIdentity.displayName) + let sessionBox = self.buildSessionBox(url: config.url) + + try await self.session.connect( + url: config.url, + token: config.token, + password: config.password, + connectOptions: connectOptions, + sessionBox: sessionBox, + onConnected: { [weak self] in + guard let self else { return } + self.logger.info("mac node connected to gateway") + let mainSessionKey = await GatewayConnection.shared.mainSessionKey() + await self.runtime.updateMainSessionKey(mainSessionKey) + await self.runtime.setEventSender { [weak self] event, payload in + guard let self else { return } + await self.session.sendEvent(event: event, payloadJSON: payload) + } + }, + onDisconnected: { [weak self] reason in + guard let self else { return } + await self.runtime.setEventSender(nil) + self.logger.error("mac node disconnected: \(reason, privacy: .public)") + }, + onInvoke: { [weak self] req in + guard let self else { + return BridgeInvokeResponse( + id: req.id, + ok: false, + error: MoltbotNodeError(code: .unavailable, message: "UNAVAILABLE: node not ready")) + } + return await self.runtime.handleInvoke(req) + }) + + retryDelay = 1_000_000_000 + try? await Task.sleep(nanoseconds: 1_000_000_000) + } catch { + self.logger.error("mac node gateway connect failed: \(error.localizedDescription, privacy: .public)") + try? await Task.sleep(nanoseconds: min(retryDelay, 10_000_000_000)) + retryDelay = min(retryDelay * 2, 10_000_000_000) + } + } + } + + private func currentCaps() -> [String] { + var caps: [String] = [MoltbotCapability.canvas.rawValue, MoltbotCapability.screen.rawValue] + if UserDefaults.standard.object(forKey: cameraEnabledKey) as? Bool ?? false { + caps.append(MoltbotCapability.camera.rawValue) + } + let rawLocationMode = UserDefaults.standard.string(forKey: locationModeKey) ?? "off" + if MoltbotLocationMode(rawValue: rawLocationMode) != .off { + caps.append(MoltbotCapability.location.rawValue) + } + return caps + } + + private func currentPermissions() async -> [String: Bool] { + let statuses = await PermissionManager.status() + return Dictionary(uniqueKeysWithValues: statuses.map { ($0.key.rawValue, $0.value) }) + } + + private func currentCommands(caps: [String]) -> [String] { + var commands: [String] = [ + MoltbotCanvasCommand.present.rawValue, + MoltbotCanvasCommand.hide.rawValue, + MoltbotCanvasCommand.navigate.rawValue, + MoltbotCanvasCommand.evalJS.rawValue, + MoltbotCanvasCommand.snapshot.rawValue, + MoltbotCanvasA2UICommand.push.rawValue, + MoltbotCanvasA2UICommand.pushJSONL.rawValue, + MoltbotCanvasA2UICommand.reset.rawValue, + MacNodeScreenCommand.record.rawValue, + MoltbotSystemCommand.notify.rawValue, + MoltbotSystemCommand.which.rawValue, + MoltbotSystemCommand.run.rawValue, + MoltbotSystemCommand.execApprovalsGet.rawValue, + MoltbotSystemCommand.execApprovalsSet.rawValue, + ] + + let capsSet = Set(caps) + if capsSet.contains(MoltbotCapability.camera.rawValue) { + commands.append(MoltbotCameraCommand.list.rawValue) + commands.append(MoltbotCameraCommand.snap.rawValue) + commands.append(MoltbotCameraCommand.clip.rawValue) + } + if capsSet.contains(MoltbotCapability.location.rawValue) { + commands.append(MoltbotLocationCommand.get.rawValue) + } + + return commands + } + + private func buildSessionBox(url: URL) -> WebSocketSessionBox? { + guard url.scheme?.lowercased() == "wss" else { return nil } + let host = url.host ?? "gateway" + let port = url.port ?? 443 + let stableID = "\(host):\(port)" + let stored = GatewayTLSStore.loadFingerprint(stableID: stableID) + let params = GatewayTLSParams( + required: true, + expectedFingerprint: stored, + allowTOFU: stored == nil, + storeKey: stableID) + let session = GatewayTLSPinningSession(params: params) + return WebSocketSessionBox(session: session) + } +} diff --git a/apps/macos/Sources/Moltbot/NodePairingApprovalPrompter.swift b/apps/macos/Sources/Moltbot/NodePairingApprovalPrompter.swift new file mode 100644 index 000000000..3f2aff19d --- /dev/null +++ b/apps/macos/Sources/Moltbot/NodePairingApprovalPrompter.swift @@ -0,0 +1,708 @@ +import AppKit +import MoltbotDiscovery +import MoltbotIPC +import MoltbotKit +import MoltbotProtocol +import Foundation +import Observation +import OSLog +import UserNotifications + +enum NodePairingReconcilePolicy { + static let activeIntervalMs: UInt64 = 15000 + static let resyncDelayMs: UInt64 = 250 + + static func shouldPoll(pendingCount: Int, isPresenting: Bool) -> Bool { + pendingCount > 0 || isPresenting + } +} + +@MainActor +@Observable +final class NodePairingApprovalPrompter { + static let shared = NodePairingApprovalPrompter() + + private let logger = Logger(subsystem: "bot.molt", category: "node-pairing") + private var task: Task? + private var reconcileTask: Task? + private var reconcileOnceTask: Task? + private var reconcileInFlight = false + private var isStopping = false + private var isPresenting = false + private var queue: [PendingRequest] = [] + var pendingCount: Int = 0 + var pendingRepairCount: Int = 0 + private var activeAlert: NSAlert? + private var activeRequestId: String? + private var alertHostWindow: NSWindow? + private var remoteResolutionsByRequestId: [String: PairingResolution] = [:] + private var autoApproveAttempts: Set = [] + + private final class AlertHostWindow: NSWindow { + override var canBecomeKey: Bool { true } + override var canBecomeMain: Bool { true } + } + + private struct PairingList: Codable { + let pending: [PendingRequest] + let paired: [PairedNode]? + } + + private struct PairedNode: Codable, Equatable { + let nodeId: String + let approvedAtMs: Double? + let displayName: String? + let platform: String? + let version: String? + let remoteIp: String? + } + + private struct PendingRequest: Codable, Equatable, Identifiable { + let requestId: String + let nodeId: String + let displayName: String? + let platform: String? + let version: String? + let remoteIp: String? + let isRepair: Bool? + let silent: Bool? + let ts: Double + + var id: String { self.requestId } + } + + private struct PairingResolvedEvent: Codable { + let requestId: String + let nodeId: String + let decision: String + let ts: Double + } + + private enum PairingResolution: String { + case approved + case rejected + } + + func start() { + guard self.task == nil else { return } + self.isStopping = false + self.reconcileTask?.cancel() + self.reconcileTask = nil + self.task = Task { [weak self] in + guard let self else { return } + _ = try? await GatewayConnection.shared.refresh() + await self.loadPendingRequestsFromGateway() + let stream = await GatewayConnection.shared.subscribe(bufferingNewest: 200) + for await push in stream { + if Task.isCancelled { return } + await MainActor.run { [weak self] in self?.handle(push: push) } + } + } + } + + func stop() { + self.isStopping = true + self.endActiveAlert() + self.task?.cancel() + self.task = nil + self.reconcileTask?.cancel() + self.reconcileTask = nil + self.reconcileOnceTask?.cancel() + self.reconcileOnceTask = nil + self.queue.removeAll(keepingCapacity: false) + self.updatePendingCounts() + self.isPresenting = false + self.activeRequestId = nil + self.alertHostWindow?.orderOut(nil) + self.alertHostWindow?.close() + self.alertHostWindow = nil + self.remoteResolutionsByRequestId.removeAll(keepingCapacity: false) + self.autoApproveAttempts.removeAll(keepingCapacity: false) + } + + private func loadPendingRequestsFromGateway() async { + // The gateway process may start slightly after the app. Retry a bit so + // pending pairing prompts are still shown on launch. + var delayMs: UInt64 = 200 + for attempt in 1...8 { + if Task.isCancelled { return } + do { + let data = try await GatewayConnection.shared.request( + method: "node.pair.list", + params: nil, + timeoutMs: 6000) + guard !data.isEmpty else { return } + let list = try JSONDecoder().decode(PairingList.self, from: data) + let pendingCount = list.pending.count + guard pendingCount > 0 else { return } + self.logger.info( + "loaded \(pendingCount, privacy: .public) pending node pairing request(s) on startup") + await self.apply(list: list) + return + } catch { + if attempt == 8 { + self.logger + .error( + "failed to load pending pairing requests: \(error.localizedDescription, privacy: .public)") + return + } + try? await Task.sleep(nanoseconds: delayMs * 1_000_000) + delayMs = min(delayMs * 2, 2000) + } + } + } + + private func reconcileLoop() async { + // Reconcile requests periodically so multiple running apps stay in sync + // (e.g. close dialogs + notify if another machine approves/rejects via app or CLI). + while !Task.isCancelled { + if self.isStopping { break } + if !self.shouldPoll { + self.reconcileTask = nil + return + } + await self.reconcileOnce(timeoutMs: 2500) + try? await Task.sleep( + nanoseconds: NodePairingReconcilePolicy.activeIntervalMs * 1_000_000) + } + self.reconcileTask = nil + } + + private func fetchPairingList(timeoutMs: Double) async throws -> PairingList { + let data = try await GatewayConnection.shared.request( + method: "node.pair.list", + params: nil, + timeoutMs: timeoutMs) + return try JSONDecoder().decode(PairingList.self, from: data) + } + + private func apply(list: PairingList) async { + if self.isStopping { return } + + let pendingById = Dictionary( + uniqueKeysWithValues: list.pending.map { ($0.requestId, $0) }) + + // Enqueue any missing requests (covers missed pushes while reconnecting). + for req in list.pending.sorted(by: { $0.ts < $1.ts }) { + self.enqueue(req) + } + + // Detect resolved requests (approved/rejected elsewhere). + let queued = self.queue + for req in queued { + if pendingById[req.requestId] != nil { continue } + let resolution = self.inferResolution(for: req, list: list) + + if self.activeRequestId == req.requestId, self.activeAlert != nil { + self.remoteResolutionsByRequestId[req.requestId] = resolution + self.logger.info( + """ + pairing request resolved elsewhere; closing dialog \ + requestId=\(req.requestId, privacy: .public) \ + resolution=\(resolution.rawValue, privacy: .public) + """) + self.endActiveAlert() + continue + } + + self.logger.info( + """ + pairing request resolved elsewhere requestId=\(req.requestId, privacy: .public) \ + resolution=\(resolution.rawValue, privacy: .public) + """) + self.queue.removeAll { $0 == req } + Task { @MainActor in + await self.notify(resolution: resolution, request: req, via: "remote") + } + } + + if self.queue.isEmpty { + self.isPresenting = false + } + self.presentNextIfNeeded() + self.updateReconcileLoop() + } + + private func inferResolution(for request: PendingRequest, list: PairingList) -> PairingResolution { + let paired = list.paired ?? [] + guard let node = paired.first(where: { $0.nodeId == request.nodeId }) else { + return .rejected + } + if request.isRepair == true, let approvedAtMs = node.approvedAtMs { + return approvedAtMs >= request.ts ? .approved : .rejected + } + return .approved + } + + private func endActiveAlert() { + guard let alert = self.activeAlert else { return } + if let parent = alert.window.sheetParent { + parent.endSheet(alert.window, returnCode: .abort) + } + self.activeAlert = nil + self.activeRequestId = nil + } + + private func requireAlertHostWindow() -> NSWindow { + if let alertHostWindow { + return alertHostWindow + } + + let window = AlertHostWindow( + contentRect: NSRect(x: 0, y: 0, width: 520, height: 1), + styleMask: [.borderless], + backing: .buffered, + defer: false) + window.title = "" + window.isReleasedWhenClosed = false + window.level = .floating + window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary] + window.isOpaque = false + window.hasShadow = false + window.backgroundColor = .clear + window.ignoresMouseEvents = true + + self.alertHostWindow = window + return window + } + + private func handle(push: GatewayPush) { + switch push { + case let .event(evt) where evt.event == "node.pair.requested": + guard let payload = evt.payload else { return } + do { + let req = try GatewayPayloadDecoding.decode(payload, as: PendingRequest.self) + self.enqueue(req) + } catch { + self.logger + .error("failed to decode pairing request: \(error.localizedDescription, privacy: .public)") + } + case let .event(evt) where evt.event == "node.pair.resolved": + guard let payload = evt.payload else { return } + do { + let resolved = try GatewayPayloadDecoding.decode(payload, as: PairingResolvedEvent.self) + self.handleResolved(resolved) + } catch { + self.logger + .error( + "failed to decode pairing resolution: \(error.localizedDescription, privacy: .public)") + } + case .snapshot: + self.scheduleReconcileOnce(delayMs: 0) + case .seqGap: + self.scheduleReconcileOnce() + default: + return + } + } + + private func enqueue(_ req: PendingRequest) { + if self.queue.contains(req) { return } + self.queue.append(req) + self.updatePendingCounts() + self.presentNextIfNeeded() + self.updateReconcileLoop() + } + + private func presentNextIfNeeded() { + guard !self.isStopping else { return } + guard !self.isPresenting else { return } + guard let next = self.queue.first else { return } + self.isPresenting = true + Task { @MainActor [weak self] in + guard let self else { return } + if await self.trySilentApproveIfPossible(next) { + return + } + self.presentAlert(for: next) + } + } + + private func presentAlert(for req: PendingRequest) { + self.logger.info("presenting node pairing alert requestId=\(req.requestId, privacy: .public)") + NSApp.activate(ignoringOtherApps: true) + + let alert = NSAlert() + alert.alertStyle = .warning + alert.messageText = "Allow node to connect?" + alert.informativeText = Self.describe(req) + // Fail-safe ordering: if the dialog can't be presented, default to "Later". + alert.addButton(withTitle: "Later") + alert.addButton(withTitle: "Approve") + alert.addButton(withTitle: "Reject") + if #available(macOS 11.0, *), alert.buttons.indices.contains(2) { + alert.buttons[2].hasDestructiveAction = true + } + + self.activeAlert = alert + self.activeRequestId = req.requestId + let hostWindow = self.requireAlertHostWindow() + + // Position the hidden host window so the sheet appears centered on screen. + // (Sheets attach to the top edge of their parent window; if the parent is tiny, it looks "anchored".) + let sheetSize = alert.window.frame.size + if let screen = hostWindow.screen ?? NSScreen.main { + let bounds = screen.visibleFrame + let x = bounds.midX - (sheetSize.width / 2) + let sheetOriginY = bounds.midY - (sheetSize.height / 2) + let hostY = sheetOriginY + sheetSize.height - hostWindow.frame.height + hostWindow.setFrameOrigin(NSPoint(x: x, y: hostY)) + } else { + hostWindow.center() + } + + hostWindow.makeKeyAndOrderFront(nil) + alert.beginSheetModal(for: hostWindow) { [weak self] response in + Task { @MainActor [weak self] in + guard let self else { return } + self.activeRequestId = nil + self.activeAlert = nil + await self.handleAlertResponse(response, request: req) + hostWindow.orderOut(nil) + } + } + } + + private func handleAlertResponse(_ response: NSApplication.ModalResponse, request: PendingRequest) async { + defer { + if self.queue.first == request { + self.queue.removeFirst() + } else { + self.queue.removeAll { $0 == request } + } + self.updatePendingCounts() + self.isPresenting = false + self.presentNextIfNeeded() + self.updateReconcileLoop() + } + + // Never approve/reject while shutting down (alerts can get dismissed during app termination). + guard !self.isStopping else { return } + + if let resolved = self.remoteResolutionsByRequestId.removeValue(forKey: request.requestId) { + await self.notify(resolution: resolved, request: request, via: "remote") + return + } + + switch response { + case .alertFirstButtonReturn: + // Later: leave as pending (CLI can approve/reject). Request will expire on the gateway TTL. + return + case .alertSecondButtonReturn: + _ = await self.approve(requestId: request.requestId) + await self.notify(resolution: .approved, request: request, via: "local") + case .alertThirdButtonReturn: + await self.reject(requestId: request.requestId) + await self.notify(resolution: .rejected, request: request, via: "local") + default: + return + } + } + + private func approve(requestId: String) async -> Bool { + do { + try await GatewayConnection.shared.nodePairApprove(requestId: requestId) + self.logger.info("approved node pairing requestId=\(requestId, privacy: .public)") + return true + } catch { + self.logger.error("approve failed requestId=\(requestId, privacy: .public)") + self.logger.error("approve failed: \(error.localizedDescription, privacy: .public)") + return false + } + } + + private func reject(requestId: String) async { + do { + try await GatewayConnection.shared.nodePairReject(requestId: requestId) + self.logger.info("rejected node pairing requestId=\(requestId, privacy: .public)") + } catch { + self.logger.error("reject failed requestId=\(requestId, privacy: .public)") + self.logger.error("reject failed: \(error.localizedDescription, privacy: .public)") + } + } + + private static func describe(_ req: PendingRequest) -> String { + let name = req.displayName?.trimmingCharacters(in: .whitespacesAndNewlines) + let platform = self.prettyPlatform(req.platform) + let version = req.version?.trimmingCharacters(in: .whitespacesAndNewlines) + let ip = self.prettyIP(req.remoteIp) + + var lines: [String] = [] + lines.append("Name: \(name?.isEmpty == false ? name! : "Unknown")") + lines.append("Node ID: \(req.nodeId)") + if let platform, !platform.isEmpty { lines.append("Platform: \(platform)") } + if let version, !version.isEmpty { lines.append("App: \(version)") } + if let ip, !ip.isEmpty { lines.append("IP: \(ip)") } + if req.isRepair == true { lines.append("Note: Repair request (token will rotate).") } + return lines.joined(separator: "\n") + } + + private static func prettyIP(_ ip: String?) -> String? { + let trimmed = ip?.trimmingCharacters(in: .whitespacesAndNewlines) + guard let trimmed, !trimmed.isEmpty else { return nil } + return trimmed.replacingOccurrences(of: "::ffff:", with: "") + } + + private static func prettyPlatform(_ platform: String?) -> String? { + let raw = platform?.trimmingCharacters(in: .whitespacesAndNewlines) + guard let raw, !raw.isEmpty else { return nil } + if raw.lowercased() == "ios" { return "iOS" } + if raw.lowercased() == "macos" { return "macOS" } + return raw + } + + private func notify(resolution: PairingResolution, request: PendingRequest, via: String) async { + let center = UNUserNotificationCenter.current() + let settings = await center.notificationSettings() + guard settings.authorizationStatus == .authorized || + settings.authorizationStatus == .provisional + else { + return + } + + let title = resolution == .approved ? "Node pairing approved" : "Node pairing rejected" + let name = request.displayName?.trimmingCharacters(in: .whitespacesAndNewlines) + let device = name?.isEmpty == false ? name! : request.nodeId + let body = "\(device)\n(via \(via))" + + _ = await NotificationManager().send( + title: title, + body: body, + sound: nil, + priority: .active) + } + + private struct SSHTarget { + let host: String + let port: Int + } + + private func trySilentApproveIfPossible(_ req: PendingRequest) async -> Bool { + guard req.silent == true else { return false } + if self.autoApproveAttempts.contains(req.requestId) { return false } + self.autoApproveAttempts.insert(req.requestId) + + guard let target = await self.resolveSSHTarget() else { + self.logger.info("silent pairing skipped (no ssh target) requestId=\(req.requestId, privacy: .public)") + return false + } + + let user = NSUserName().trimmingCharacters(in: .whitespacesAndNewlines) + guard !user.isEmpty else { + self.logger.info("silent pairing skipped (missing local user) requestId=\(req.requestId, privacy: .public)") + return false + } + + let ok = await Self.probeSSH(user: user, host: target.host, port: target.port) + if !ok { + self.logger.info("silent pairing probe failed requestId=\(req.requestId, privacy: .public)") + return false + } + + guard await self.approve(requestId: req.requestId) else { + self.logger.info("silent pairing approve failed requestId=\(req.requestId, privacy: .public)") + return false + } + + await self.notify(resolution: .approved, request: req, via: "silent-ssh") + if self.queue.first == req { + self.queue.removeFirst() + } else { + self.queue.removeAll { $0 == req } + } + + self.updatePendingCounts() + self.isPresenting = false + self.presentNextIfNeeded() + self.updateReconcileLoop() + return true + } + + private func resolveSSHTarget() async -> SSHTarget? { + let settings = CommandResolver.connectionSettings() + if !settings.target.isEmpty, let parsed = CommandResolver.parseSSHTarget(settings.target) { + let user = NSUserName().trimmingCharacters(in: .whitespacesAndNewlines) + if let targetUser = parsed.user, + !targetUser.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, + targetUser != user + { + self.logger.info("silent pairing skipped (ssh user mismatch)") + return nil + } + let host = parsed.host.trimmingCharacters(in: .whitespacesAndNewlines) + guard !host.isEmpty else { return nil } + let port = parsed.port > 0 ? parsed.port : 22 + return SSHTarget(host: host, port: port) + } + + let model = GatewayDiscoveryModel(localDisplayName: InstanceIdentity.displayName) + model.start() + defer { model.stop() } + + let deadline = Date().addingTimeInterval(5.0) + while model.gateways.isEmpty, Date() < deadline { + try? await Task.sleep(nanoseconds: 200_000_000) + } + + let preferred = GatewayDiscoveryPreferences.preferredStableID() + let gateway = model.gateways.first { $0.stableID == preferred } ?? model.gateways.first + guard let gateway else { return nil } + let host = (gateway.tailnetDns?.trimmingCharacters(in: .whitespacesAndNewlines).nonEmpty ?? + gateway.lanHost?.trimmingCharacters(in: .whitespacesAndNewlines).nonEmpty) + guard let host, !host.isEmpty else { return nil } + let port = gateway.sshPort > 0 ? gateway.sshPort : 22 + return SSHTarget(host: host, port: port) + } + + private static func probeSSH(user: String, host: String, port: Int) async -> Bool { + await Task.detached(priority: .utility) { + let process = Process() + process.executableURL = URL(fileURLWithPath: "/usr/bin/ssh") + + let options = [ + "-o", "BatchMode=yes", + "-o", "ConnectTimeout=5", + "-o", "NumberOfPasswordPrompts=0", + "-o", "PreferredAuthentications=publickey", + "-o", "StrictHostKeyChecking=accept-new", + ] + guard let target = CommandResolver.makeSSHTarget(user: user, host: host, port: port) else { + return false + } + let args = CommandResolver.sshArguments( + target: target, + identity: "", + options: options, + remoteCommand: ["/usr/bin/true"]) + process.arguments = args + let pipe = Pipe() + process.standardOutput = pipe + process.standardError = pipe + + do { + _ = try process.runAndReadToEnd(from: pipe) + } catch { + return false + } + return process.terminationStatus == 0 + }.value + } + + private var shouldPoll: Bool { + NodePairingReconcilePolicy.shouldPoll( + pendingCount: self.queue.count, + isPresenting: self.isPresenting) + } + + private func updateReconcileLoop() { + guard !self.isStopping else { return } + if self.shouldPoll { + if self.reconcileTask == nil { + self.reconcileTask = Task { [weak self] in + await self?.reconcileLoop() + } + } + } else { + self.reconcileTask?.cancel() + self.reconcileTask = nil + } + } + + private func updatePendingCounts() { + // Keep a cheap observable summary for the menu bar status line. + self.pendingCount = self.queue.count + self.pendingRepairCount = self.queue.count(where: { $0.isRepair == true }) + } + + private func reconcileOnce(timeoutMs: Double) async { + if self.isStopping { return } + if self.reconcileInFlight { return } + self.reconcileInFlight = true + defer { self.reconcileInFlight = false } + do { + let list = try await self.fetchPairingList(timeoutMs: timeoutMs) + await self.apply(list: list) + } catch { + // best effort: ignore transient connectivity failures + } + } + + private func scheduleReconcileOnce(delayMs: UInt64 = NodePairingReconcilePolicy.resyncDelayMs) { + self.reconcileOnceTask?.cancel() + self.reconcileOnceTask = Task { [weak self] in + guard let self else { return } + if delayMs > 0 { + try? await Task.sleep(nanoseconds: delayMs * 1_000_000) + } + await self.reconcileOnce(timeoutMs: 2500) + } + } + + private func handleResolved(_ resolved: PairingResolvedEvent) { + let resolution: PairingResolution = + resolved.decision == PairingResolution.approved.rawValue ? .approved : .rejected + + if self.activeRequestId == resolved.requestId, self.activeAlert != nil { + self.remoteResolutionsByRequestId[resolved.requestId] = resolution + self.logger.info( + """ + pairing request resolved elsewhere; closing dialog \ + requestId=\(resolved.requestId, privacy: .public) \ + resolution=\(resolution.rawValue, privacy: .public) + """) + self.endActiveAlert() + return + } + + guard let request = self.queue.first(where: { $0.requestId == resolved.requestId }) else { + return + } + self.queue.removeAll { $0.requestId == resolved.requestId } + self.updatePendingCounts() + Task { @MainActor in + await self.notify(resolution: resolution, request: request, via: "remote") + } + if self.queue.isEmpty { + self.isPresenting = false + } + self.presentNextIfNeeded() + self.updateReconcileLoop() + } +} + +#if DEBUG +@MainActor +extension NodePairingApprovalPrompter { + static func exerciseForTesting() async { + let prompter = NodePairingApprovalPrompter() + let pending = PendingRequest( + requestId: "req-1", + nodeId: "node-1", + displayName: "Node One", + platform: "macos", + version: "1.0.0", + remoteIp: "127.0.0.1", + isRepair: false, + silent: true, + ts: 1_700_000_000_000) + let paired = PairedNode( + nodeId: "node-1", + approvedAtMs: 1_700_000_000_000, + displayName: "Node One", + platform: "macOS", + version: "1.0.0", + remoteIp: "127.0.0.1") + let list = PairingList(pending: [pending], paired: [paired]) + + _ = Self.describe(pending) + _ = Self.prettyIP(pending.remoteIp) + _ = Self.prettyPlatform(pending.platform) + _ = prompter.inferResolution(for: pending, list: list) + + prompter.queue = [pending] + _ = prompter.shouldPoll + _ = await prompter.trySilentApproveIfPossible(pending) + prompter.queue.removeAll() + } +} +#endif diff --git a/apps/macos/Sources/Moltbot/NodeServiceManager.swift b/apps/macos/Sources/Moltbot/NodeServiceManager.swift new file mode 100644 index 000000000..bceba7c39 --- /dev/null +++ b/apps/macos/Sources/Moltbot/NodeServiceManager.swift @@ -0,0 +1,150 @@ +import Foundation +import OSLog + +enum NodeServiceManager { + private static let logger = Logger(subsystem: "bot.molt", category: "node.service") + + static func start() async -> String? { + let result = await self.runServiceCommandResult( + ["node", "start"], + timeout: 20, + quiet: false) + if let error = self.errorMessage(from: result, treatNotLoadedAsError: true) { + self.logger.error("node service start failed: \(error, privacy: .public)") + return error + } + return nil + } + + static func stop() async -> String? { + let result = await self.runServiceCommandResult( + ["node", "stop"], + timeout: 15, + quiet: false) + if let error = self.errorMessage(from: result, treatNotLoadedAsError: false) { + self.logger.error("node service stop failed: \(error, privacy: .public)") + return error + } + return nil + } +} + +extension NodeServiceManager { + private struct CommandResult { + let success: Bool + let payload: Data? + let message: String? + let parsed: ParsedServiceJson? + } + + private struct ParsedServiceJson { + let text: String + let object: [String: Any] + let ok: Bool? + let result: String? + let message: String? + let error: String? + let hints: [String] + } + + private static func runServiceCommandResult( + _ args: [String], + timeout: Double, + quiet: Bool) async -> CommandResult + { + let command = CommandResolver.clawdbotCommand( + subcommand: "service", + extraArgs: self.withJsonFlag(args), + // Service management must always run locally, even if remote mode is configured. + configRoot: ["gateway": ["mode": "local"]]) + var env = ProcessInfo.processInfo.environment + env["PATH"] = CommandResolver.preferredPaths().joined(separator: ":") + let response = await ShellExecutor.runDetailed(command: command, cwd: nil, env: env, timeout: timeout) + let parsed = self.parseServiceJson(from: response.stdout) ?? self.parseServiceJson(from: response.stderr) + let ok = parsed?.ok + let message = parsed?.error ?? parsed?.message + let payload = parsed?.text.data(using: .utf8) + ?? (response.stdout.isEmpty ? response.stderr : response.stdout).data(using: .utf8) + let success = ok ?? response.success + if success { + return CommandResult(success: true, payload: payload, message: nil, parsed: parsed) + } + + if quiet { + return CommandResult(success: false, payload: payload, message: message, parsed: parsed) + } + + let detail = message ?? self.summarize(response.stderr) ?? self.summarize(response.stdout) + let exit = response.exitCode.map { "exit \($0)" } ?? (response.errorMessage ?? "failed") + let fullMessage = detail.map { "Node service command failed (\(exit)): \($0)" } + ?? "Node service command failed (\(exit))" + self.logger.error("\(fullMessage, privacy: .public)") + return CommandResult(success: false, payload: payload, message: detail, parsed: parsed) + } + + private static func errorMessage(from result: CommandResult, treatNotLoadedAsError: Bool) -> String? { + if !result.success { + return result.message ?? "Node service command failed" + } + guard let parsed = result.parsed else { return nil } + if parsed.ok == false { + return self.mergeHints(message: parsed.error ?? parsed.message, hints: parsed.hints) + } + if treatNotLoadedAsError, parsed.result == "not-loaded" { + let base = parsed.message ?? "Node service not loaded." + return self.mergeHints(message: base, hints: parsed.hints) + } + return nil + } + + private static func withJsonFlag(_ args: [String]) -> [String] { + if args.contains("--json") { return args } + return args + ["--json"] + } + + private static func parseServiceJson(from raw: String) -> ParsedServiceJson? { + let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) + guard let start = trimmed.firstIndex(of: "{"), + let end = trimmed.lastIndex(of: "}") + else { + return nil + } + let jsonText = String(trimmed[start...end]) + guard let data = jsonText.data(using: .utf8) else { return nil } + guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil } + let ok = object["ok"] as? Bool + let result = object["result"] as? String + let message = object["message"] as? String + let error = object["error"] as? String + let hints = (object["hints"] as? [String]) ?? [] + return ParsedServiceJson( + text: jsonText, + object: object, + ok: ok, + result: result, + message: message, + error: error, + hints: hints) + } + + private static func mergeHints(message: String?, hints: [String]) -> String? { + let trimmed = message?.trimmingCharacters(in: .whitespacesAndNewlines) + let nonEmpty = trimmed?.isEmpty == false ? trimmed : nil + guard !hints.isEmpty else { return nonEmpty } + let hintText = hints.prefix(2).joined(separator: " · ") + if let nonEmpty { + return "\(nonEmpty) (\(hintText))" + } + return hintText + } + + private static func summarize(_ text: String) -> String? { + let lines = text + .split(whereSeparator: \.isNewline) + .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) } + .filter { !$0.isEmpty } + guard let last = lines.last else { return nil } + let normalized = last.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression) + return normalized.count > 200 ? String(normalized.prefix(199)) + "…" : normalized + } +} diff --git a/apps/macos/Sources/Moltbot/NodesStore.swift b/apps/macos/Sources/Moltbot/NodesStore.swift new file mode 100644 index 000000000..ae21a902c --- /dev/null +++ b/apps/macos/Sources/Moltbot/NodesStore.swift @@ -0,0 +1,102 @@ +import Foundation +import Observation +import OSLog + +struct NodeInfo: Identifiable, Codable { + let nodeId: String + let displayName: String? + let platform: String? + let version: String? + let coreVersion: String? + let uiVersion: String? + let deviceFamily: String? + let modelIdentifier: String? + let remoteIp: String? + let caps: [String]? + let commands: [String]? + let permissions: [String: Bool]? + let paired: Bool? + let connected: Bool? + + var id: String { self.nodeId } + var isConnected: Bool { self.connected ?? false } + var isPaired: Bool { self.paired ?? false } +} + +private struct NodeListResponse: Codable { + let ts: Double? + let nodes: [NodeInfo] +} + +@MainActor +@Observable +final class NodesStore { + static let shared = NodesStore() + + var nodes: [NodeInfo] = [] + var lastError: String? + var statusMessage: String? + var isLoading = false + + private let logger = Logger(subsystem: "bot.molt", category: "nodes") + private var task: Task? + private let interval: TimeInterval = 30 + private var startCount = 0 + + func start() { + self.startCount += 1 + guard self.startCount == 1 else { return } + guard self.task == nil else { return } + self.task = Task.detached { [weak self] in + guard let self else { return } + await self.refresh() + while !Task.isCancelled { + try? await Task.sleep(nanoseconds: UInt64(self.interval * 1_000_000_000)) + await self.refresh() + } + } + } + + func stop() { + guard self.startCount > 0 else { return } + self.startCount -= 1 + guard self.startCount == 0 else { return } + self.task?.cancel() + self.task = nil + } + + func refresh() async { + if self.isLoading { return } + self.statusMessage = nil + self.isLoading = true + defer { self.isLoading = false } + do { + let data = try await GatewayConnection.shared.requestRaw(method: "node.list", params: nil, timeoutMs: 8000) + let decoded = try JSONDecoder().decode(NodeListResponse.self, from: data) + self.nodes = decoded.nodes + self.lastError = nil + self.statusMessage = nil + } catch { + if Self.isCancelled(error) { + self.logger.debug("node.list cancelled; keeping last nodes") + if self.nodes.isEmpty { + self.statusMessage = "Refreshing devices…" + } + self.lastError = nil + return + } + self.logger.error("node.list failed \(error.localizedDescription, privacy: .public)") + self.nodes = [] + self.lastError = error.localizedDescription + self.statusMessage = nil + } + } + + private static func isCancelled(_ error: Error) -> Bool { + if error is CancellationError { return true } + if let urlError = error as? URLError, urlError.code == .cancelled { return true } + let nsError = error as NSError + if nsError.domain == NSURLErrorDomain, nsError.code == NSURLErrorCancelled { return true } + return false + } +} diff --git a/apps/macos/Sources/Moltbot/NotificationManager.swift b/apps/macos/Sources/Moltbot/NotificationManager.swift new file mode 100644 index 000000000..53659e15d --- /dev/null +++ b/apps/macos/Sources/Moltbot/NotificationManager.swift @@ -0,0 +1,66 @@ +import MoltbotIPC +import Foundation +import Security +import UserNotifications + +@MainActor +struct NotificationManager { + private let logger = Logger(subsystem: "bot.molt", category: "notifications") + + private static let hasTimeSensitiveEntitlement: Bool = { + guard let task = SecTaskCreateFromSelf(nil) else { return false } + let key = "com.apple.developer.usernotifications.time-sensitive" as CFString + guard let val = SecTaskCopyValueForEntitlement(task, key, nil) else { return false } + return (val as? Bool) == true + }() + + func send(title: String, body: String, sound: String?, priority: NotificationPriority? = nil) async -> Bool { + let center = UNUserNotificationCenter.current() + let status = await center.notificationSettings() + if status.authorizationStatus == .notDetermined { + let granted = try? await center.requestAuthorization(options: [.alert, .sound, .badge]) + if granted != true { + self.logger.warning("notification permission denied (request)") + return false + } + } else if status.authorizationStatus != .authorized { + self.logger.warning("notification permission denied status=\(status.authorizationStatus.rawValue)") + return false + } + + let content = UNMutableNotificationContent() + content.title = title + content.body = body + if let soundName = sound, !soundName.isEmpty { + content.sound = UNNotificationSound(named: UNNotificationSoundName(soundName)) + } + + // Set interruption level based on priority + if let priority { + switch priority { + case .passive: + content.interruptionLevel = .passive + case .active: + content.interruptionLevel = .active + case .timeSensitive: + if Self.hasTimeSensitiveEntitlement { + content.interruptionLevel = .timeSensitive + } else { + self.logger.debug( + "time-sensitive notification requested without entitlement; falling back to active") + content.interruptionLevel = .active + } + } + } + + let req = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil) + do { + try await center.add(req) + self.logger.debug("notification queued") + return true + } catch { + self.logger.error("notification send failed: \(error.localizedDescription)") + return false + } + } +} diff --git a/apps/macos/Sources/Moltbot/OnboardingWizard.swift b/apps/macos/Sources/Moltbot/OnboardingWizard.swift new file mode 100644 index 000000000..f06636071 --- /dev/null +++ b/apps/macos/Sources/Moltbot/OnboardingWizard.swift @@ -0,0 +1,412 @@ +import MoltbotKit +import MoltbotProtocol +import Foundation +import Observation +import OSLog +import SwiftUI + +private let onboardingWizardLogger = Logger(subsystem: "bot.molt", category: "onboarding.wizard") + +// MARK: - Swift 6 AnyCodable Bridging Helpers + +// Bridge between MoltbotProtocol.AnyCodable and the local module to avoid +// Swift 6 strict concurrency type conflicts. + +private typealias ProtocolAnyCodable = MoltbotProtocol.AnyCodable + +private func bridgeToLocal(_ value: ProtocolAnyCodable) -> AnyCodable { + if let data = try? JSONEncoder().encode(value), + let decoded = try? JSONDecoder().decode(AnyCodable.self, from: data) + { + return decoded + } + return AnyCodable(value.value) +} + +private func bridgeToLocal(_ value: ProtocolAnyCodable?) -> AnyCodable? { + value.map(bridgeToLocal) +} + +@MainActor +@Observable +final class OnboardingWizardModel { + private(set) var sessionId: String? + private(set) var currentStep: WizardStep? + private(set) var status: String? + private(set) var errorMessage: String? + var isStarting = false + var isSubmitting = false + private var lastStartMode: AppState.ConnectionMode? + private var lastStartWorkspace: String? + private var restartAttempts = 0 + private let maxRestartAttempts = 1 + + var isComplete: Bool { self.status == "done" } + var isRunning: Bool { self.status == "running" } + + func reset() { + self.sessionId = nil + self.currentStep = nil + self.status = nil + self.errorMessage = nil + self.isStarting = false + self.isSubmitting = false + self.restartAttempts = 0 + self.lastStartMode = nil + self.lastStartWorkspace = nil + } + + func startIfNeeded(mode: AppState.ConnectionMode, workspace: String? = nil) async { + guard self.sessionId == nil, !self.isStarting else { return } + guard mode == .local else { return } + if self.shouldSkipWizard() { + self.sessionId = nil + self.currentStep = nil + self.status = "done" + self.errorMessage = nil + return + } + self.isStarting = true + self.errorMessage = nil + self.lastStartMode = mode + self.lastStartWorkspace = workspace + defer { self.isStarting = false } + + do { + GatewayProcessManager.shared.setActive(true) + if await GatewayProcessManager.shared.waitForGatewayReady(timeout: 12) == false { + throw NSError( + domain: "Gateway", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "Gateway did not become ready. Check that it is running."]) + } + var params: [String: AnyCodable] = ["mode": AnyCodable("local")] + if let workspace, !workspace.isEmpty { + params["workspace"] = AnyCodable(workspace) + } + let res: WizardStartResult = try await GatewayConnection.shared.requestDecoded( + method: .wizardStart, + params: params) + self.applyStartResult(res) + } catch { + self.status = "error" + self.errorMessage = error.localizedDescription + onboardingWizardLogger.error("start failed: \(error.localizedDescription, privacy: .public)") + } + } + + func submit(step: WizardStep, value: AnyCodable?) async { + guard let sessionId, !self.isSubmitting else { return } + self.isSubmitting = true + self.errorMessage = nil + defer { self.isSubmitting = false } + + do { + var params: [String: AnyCodable] = ["sessionId": AnyCodable(sessionId)] + var answer: [String: AnyCodable] = ["stepId": AnyCodable(step.id)] + if let value { + answer["value"] = value + } + params["answer"] = AnyCodable(answer) + let res: WizardNextResult = try await GatewayConnection.shared.requestDecoded( + method: .wizardNext, + params: params) + self.applyNextResult(res) + } catch { + if self.restartIfSessionLost(error: error) { + return + } + self.status = "error" + self.errorMessage = error.localizedDescription + onboardingWizardLogger.error("submit failed: \(error.localizedDescription, privacy: .public)") + } + } + + func cancelIfRunning() async { + guard let sessionId, self.isRunning else { return } + do { + let res: WizardStatusResult = try await GatewayConnection.shared.requestDecoded( + method: .wizardCancel, + params: ["sessionId": AnyCodable(sessionId)]) + self.applyStatusResult(res) + } catch { + self.status = "error" + self.errorMessage = error.localizedDescription + onboardingWizardLogger.error("cancel failed: \(error.localizedDescription, privacy: .public)") + } + } + + private func applyStartResult(_ res: WizardStartResult) { + self.sessionId = res.sessionid + self.status = wizardStatusString(res.status) ?? (res.done ? "done" : "running") + self.errorMessage = res.error + self.currentStep = decodeWizardStep(res.step) + if self.currentStep == nil, res.step != nil { + onboardingWizardLogger.error("wizard step decode failed") + } + if res.done { self.currentStep = nil } + self.restartAttempts = 0 + } + + private func applyNextResult(_ res: WizardNextResult) { + let status = wizardStatusString(res.status) + self.status = status ?? self.status + self.errorMessage = res.error + self.currentStep = decodeWizardStep(res.step) + if self.currentStep == nil, res.step != nil { + onboardingWizardLogger.error("wizard step decode failed") + } + if res.done { self.currentStep = nil } + if res.done || status == "done" || status == "cancelled" || status == "error" { + self.sessionId = nil + } + } + + private func applyStatusResult(_ res: WizardStatusResult) { + self.status = wizardStatusString(res.status) ?? "unknown" + self.errorMessage = res.error + self.currentStep = nil + self.sessionId = nil + } + + private func restartIfSessionLost(error: Error) -> Bool { + guard let gatewayError = error as? GatewayResponseError else { return false } + guard gatewayError.code == ErrorCode.invalidRequest.rawValue else { return false } + let message = gatewayError.message.lowercased() + guard message.contains("wizard not found") || message.contains("wizard not running") else { return false } + guard let mode = self.lastStartMode, self.restartAttempts < self.maxRestartAttempts else { + return false + } + self.restartAttempts += 1 + self.sessionId = nil + self.currentStep = nil + self.status = nil + self.errorMessage = "Wizard session lost. Restarting…" + Task { await self.startIfNeeded(mode: mode, workspace: self.lastStartWorkspace) } + return true + } + + private func shouldSkipWizard() -> Bool { + let root = MoltbotConfigFile.loadDict() + if let wizard = root["wizard"] as? [String: Any], !wizard.isEmpty { + return true + } + if let gateway = root["gateway"] as? [String: Any], + let auth = gateway["auth"] as? [String: Any] + { + if let mode = auth["mode"] as? String, + !mode.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty + { + return true + } + if let token = auth["token"] as? String, + !token.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty + { + return true + } + if let password = auth["password"] as? String, + !password.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty + { + return true + } + } + return false + } +} + +struct OnboardingWizardStepView: View { + let step: WizardStep + let isSubmitting: Bool + let onStepSubmit: (AnyCodable?) -> Void + + @State private var textValue: String + @State private var confirmValue: Bool + @State private var selectedIndex: Int + @State private var selectedIndices: Set + + private let optionItems: [WizardOptionItem] + + init(step: WizardStep, isSubmitting: Bool, onSubmit: @escaping (AnyCodable?) -> Void) { + self.step = step + self.isSubmitting = isSubmitting + self.onStepSubmit = onSubmit + let options = parseWizardOptions(step.options).enumerated().map { index, option in + WizardOptionItem(index: index, option: option) + } + self.optionItems = options + let initialText = anyCodableString(step.initialvalue) + let initialConfirm = anyCodableBool(step.initialvalue) + let initialIndex = options.firstIndex(where: { anyCodableEqual($0.option.value, step.initialvalue) }) ?? 0 + let initialMulti = Set( + options.filter { option in + anyCodableArray(step.initialvalue).contains { anyCodableEqual($0, option.option.value) } + }.map(\.index)) + + _textValue = State(initialValue: initialText) + _confirmValue = State(initialValue: initialConfirm) + _selectedIndex = State(initialValue: initialIndex) + _selectedIndices = State(initialValue: initialMulti) + } + + var body: some View { + VStack(alignment: .leading, spacing: 12) { + if let title = step.title, !title.isEmpty { + Text(title) + .font(.title2.weight(.semibold)) + } + if let message = step.message, !message.isEmpty { + Text(message) + .font(.body) + .foregroundStyle(.secondary) + .fixedSize(horizontal: false, vertical: true) + } + + switch wizardStepType(self.step) { + case "note": + EmptyView() + case "text": + self.textField + case "confirm": + Toggle("", isOn: self.$confirmValue) + .toggleStyle(.switch) + case "select": + self.selectOptions + case "multiselect": + self.multiselectOptions + case "progress": + ProgressView() + .controlSize(.small) + case "action": + EmptyView() + default: + Text("Unsupported step type") + .foregroundStyle(.secondary) + } + + Button(action: self.submit) { + Text(wizardStepType(self.step) == "action" ? "Run" : "Continue") + .frame(minWidth: 120) + } + .buttonStyle(.borderedProminent) + .disabled(self.isSubmitting || self.isBlocked) + } + .frame(maxWidth: .infinity, alignment: .leading) + } + + @ViewBuilder + private var textField: some View { + let isSensitive = self.step.sensitive == true + if isSensitive { + SecureField(self.step.placeholder ?? "", text: self.$textValue) + .textFieldStyle(.roundedBorder) + .frame(maxWidth: 360) + } else { + TextField(self.step.placeholder ?? "", text: self.$textValue) + .textFieldStyle(.roundedBorder) + .frame(maxWidth: 360) + } + } + + private var selectOptions: some View { + VStack(alignment: .leading, spacing: 8) { + ForEach(self.optionItems, id: \.index) { item in + self.selectOptionRow(item) + } + } + } + + private var multiselectOptions: some View { + VStack(alignment: .leading, spacing: 8) { + ForEach(self.optionItems, id: \.index) { item in + self.multiselectOptionRow(item) + } + } + } + + private func selectOptionRow(_ item: WizardOptionItem) -> some View { + Button { + self.selectedIndex = item.index + } label: { + HStack(alignment: .top, spacing: 8) { + Image(systemName: self.selectedIndex == item.index ? "largecircle.fill.circle" : "circle") + .foregroundStyle(Color.accentColor) + VStack(alignment: .leading, spacing: 2) { + Text(item.option.label) + .foregroundStyle(.primary) + if let hint = item.option.hint, !hint.isEmpty { + Text(hint) + .font(.caption) + .foregroundStyle(.secondary) + } + } + } + } + .buttonStyle(.plain) + } + + private func multiselectOptionRow(_ item: WizardOptionItem) -> some View { + Toggle(isOn: self.bindingForOption(item)) { + VStack(alignment: .leading, spacing: 2) { + Text(item.option.label) + if let hint = item.option.hint, !hint.isEmpty { + Text(hint) + .font(.caption) + .foregroundStyle(.secondary) + } + } + } + } + + private func bindingForOption(_ item: WizardOptionItem) -> Binding { + Binding(get: { + self.selectedIndices.contains(item.index) + }, set: { newValue in + if newValue { + self.selectedIndices.insert(item.index) + } else { + self.selectedIndices.remove(item.index) + } + }) + } + + private var isBlocked: Bool { + let type = wizardStepType(step) + if type == "select" { return self.optionItems.isEmpty } + if type == "multiselect" { return self.optionItems.isEmpty } + return false + } + + private func submit() { + switch wizardStepType(self.step) { + case "note", "progress": + self.onStepSubmit(nil) + case "text": + self.onStepSubmit(AnyCodable(self.textValue)) + case "confirm": + self.onStepSubmit(AnyCodable(self.confirmValue)) + case "select": + guard self.optionItems.indices.contains(self.selectedIndex) else { + self.onStepSubmit(nil) + return + } + let option = self.optionItems[self.selectedIndex].option + self.onStepSubmit(bridgeToLocal(option.value) ?? AnyCodable(option.label)) + case "multiselect": + let values = self.optionItems + .filter { self.selectedIndices.contains($0.index) } + .map { bridgeToLocal($0.option.value) ?? AnyCodable($0.option.label) } + self.onStepSubmit(AnyCodable(values)) + case "action": + self.onStepSubmit(AnyCodable(true)) + default: + self.onStepSubmit(nil) + } + } +} + +private struct WizardOptionItem: Identifiable { + let index: Int + let option: WizardOption + + var id: Int { self.index } +} diff --git a/apps/macos/Sources/Moltbot/PeekabooBridgeHostCoordinator.swift b/apps/macos/Sources/Moltbot/PeekabooBridgeHostCoordinator.swift new file mode 100644 index 000000000..16f5f554e --- /dev/null +++ b/apps/macos/Sources/Moltbot/PeekabooBridgeHostCoordinator.swift @@ -0,0 +1,130 @@ +import Foundation +import os +import PeekabooAutomationKit +import PeekabooBridge +import PeekabooFoundation +import Security + +@MainActor +final class PeekabooBridgeHostCoordinator { + static let shared = PeekabooBridgeHostCoordinator() + + private let logger = Logger(subsystem: "bot.molt", category: "PeekabooBridge") + + private var host: PeekabooBridgeHost? + private var services: MoltbotPeekabooBridgeServices? + + func setEnabled(_ enabled: Bool) async { + if enabled { + await self.startIfNeeded() + } else { + await self.stop() + } + } + + func stop() async { + guard let host else { return } + await host.stop() + self.host = nil + self.services = nil + self.logger.info("PeekabooBridge host stopped") + } + + private func startIfNeeded() async { + guard self.host == nil else { return } + + var allowlistedTeamIDs: Set = ["Y5PE65HELJ"] + if let teamID = Self.currentTeamID() { + allowlistedTeamIDs.insert(teamID) + } + let allowlistedBundles: Set = [] + + let services = MoltbotPeekabooBridgeServices() + let server = PeekabooBridgeServer( + services: services, + hostKind: .gui, + allowlistedTeams: allowlistedTeamIDs, + allowlistedBundles: allowlistedBundles) + + let host = PeekabooBridgeHost( + socketPath: PeekabooBridgeConstants.clawdbotSocketPath, + server: server, + allowedTeamIDs: allowlistedTeamIDs, + requestTimeoutSec: 10) + + self.services = services + self.host = host + + await host.start() + self.logger + .info("PeekabooBridge host started at \(PeekabooBridgeConstants.clawdbotSocketPath, privacy: .public)") + } + + private static func currentTeamID() -> String? { + var code: SecCode? + guard SecCodeCopySelf(SecCSFlags(), &code) == errSecSuccess, + let code + else { + return nil + } + + var staticCode: SecStaticCode? + guard SecCodeCopyStaticCode(code, SecCSFlags(), &staticCode) == errSecSuccess, + let staticCode + else { + return nil + } + + var infoCF: CFDictionary? + guard SecCodeCopySigningInformation( + staticCode, + SecCSFlags(rawValue: kSecCSSigningInformation), + &infoCF) == errSecSuccess, + let info = infoCF as? [String: Any] + else { + return nil + } + + return info[kSecCodeInfoTeamIdentifier as String] as? String + } +} + +@MainActor +private final class MoltbotPeekabooBridgeServices: PeekabooBridgeServiceProviding { + let permissions: PermissionsService + let screenCapture: any ScreenCaptureServiceProtocol + let automation: any UIAutomationServiceProtocol + let windows: any WindowManagementServiceProtocol + let applications: any ApplicationServiceProtocol + let menu: any MenuServiceProtocol + let dock: any DockServiceProtocol + let dialogs: any DialogServiceProtocol + let snapshots: any SnapshotManagerProtocol + + init() { + let logging = LoggingService(subsystem: "bot.molt.peekaboo") + let feedbackClient: any AutomationFeedbackClient = NoopAutomationFeedbackClient() + + let snapshots = InMemorySnapshotManager(options: .init( + snapshotValidityWindow: 600, + maxSnapshots: 50, + deleteArtifactsOnCleanup: false)) + let applications = ApplicationService(feedbackClient: feedbackClient) + + let screenCapture = ScreenCaptureService(loggingService: logging) + + self.permissions = PermissionsService() + self.snapshots = snapshots + self.applications = applications + self.screenCapture = screenCapture + self.automation = UIAutomationService( + snapshotManager: snapshots, + loggingService: logging, + searchPolicy: .balanced, + feedbackClient: feedbackClient) + self.windows = WindowManagementService(applicationService: applications, feedbackClient: feedbackClient) + self.menu = MenuService(applicationService: applications, feedbackClient: feedbackClient) + self.dock = DockService(feedbackClient: feedbackClient) + self.dialogs = DialogService(feedbackClient: feedbackClient) + } +} diff --git a/apps/macos/Sources/Moltbot/PermissionManager.swift b/apps/macos/Sources/Moltbot/PermissionManager.swift new file mode 100644 index 000000000..f001827a0 --- /dev/null +++ b/apps/macos/Sources/Moltbot/PermissionManager.swift @@ -0,0 +1,506 @@ +import AppKit +import ApplicationServices +import AVFoundation +import MoltbotIPC +import CoreGraphics +import CoreLocation +import Foundation +import Observation +import Speech +import UserNotifications + +enum PermissionManager { + static func isLocationAuthorized(status: CLAuthorizationStatus, requireAlways: Bool) -> Bool { + if requireAlways { return status == .authorizedAlways } + switch status { + case .authorizedAlways, .authorizedWhenInUse: + return true + case .authorized: // deprecated, but still shows up on some macOS versions + return true + default: + return false + } + } + + static func ensure(_ caps: [Capability], interactive: Bool) async -> [Capability: Bool] { + var results: [Capability: Bool] = [:] + for cap in caps { + results[cap] = await self.ensureCapability(cap, interactive: interactive) + } + return results + } + + private static func ensureCapability(_ cap: Capability, interactive: Bool) async -> Bool { + switch cap { + case .notifications: + await self.ensureNotifications(interactive: interactive) + case .appleScript: + await self.ensureAppleScript(interactive: interactive) + case .accessibility: + await self.ensureAccessibility(interactive: interactive) + case .screenRecording: + await self.ensureScreenRecording(interactive: interactive) + case .microphone: + await self.ensureMicrophone(interactive: interactive) + case .speechRecognition: + await self.ensureSpeechRecognition(interactive: interactive) + case .camera: + await self.ensureCamera(interactive: interactive) + case .location: + await self.ensureLocation(interactive: interactive) + } + } + + private static func ensureNotifications(interactive: Bool) async -> Bool { + let center = UNUserNotificationCenter.current() + let settings = await center.notificationSettings() + + switch settings.authorizationStatus { + case .authorized, .provisional, .ephemeral: + return true + case .notDetermined: + guard interactive else { return false } + let granted = await (try? center.requestAuthorization(options: [.alert, .sound, .badge])) ?? false + let updated = await center.notificationSettings() + return granted && + (updated.authorizationStatus == .authorized || updated.authorizationStatus == .provisional) + case .denied: + if interactive { + NotificationPermissionHelper.openSettings() + } + return false + @unknown default: + return false + } + } + + private static func ensureAppleScript(interactive: Bool) async -> Bool { + let granted = await MainActor.run { AppleScriptPermission.isAuthorized() } + if interactive, !granted { + await AppleScriptPermission.requestAuthorization() + } + return await MainActor.run { AppleScriptPermission.isAuthorized() } + } + + private static func ensureAccessibility(interactive: Bool) async -> Bool { + let trusted = await MainActor.run { AXIsProcessTrusted() } + if interactive, !trusted { + await MainActor.run { + let opts: NSDictionary = ["AXTrustedCheckOptionPrompt": true] + _ = AXIsProcessTrustedWithOptions(opts) + } + } + return await MainActor.run { AXIsProcessTrusted() } + } + + private static func ensureScreenRecording(interactive: Bool) async -> Bool { + let granted = ScreenRecordingProbe.isAuthorized() + if interactive, !granted { + await ScreenRecordingProbe.requestAuthorization() + } + return ScreenRecordingProbe.isAuthorized() + } + + private static func ensureMicrophone(interactive: Bool) async -> Bool { + let status = AVCaptureDevice.authorizationStatus(for: .audio) + switch status { + case .authorized: + return true + case .notDetermined: + guard interactive else { return false } + return await AVCaptureDevice.requestAccess(for: .audio) + case .denied, .restricted: + if interactive { + MicrophonePermissionHelper.openSettings() + } + return false + @unknown default: + return false + } + } + + private static func ensureSpeechRecognition(interactive: Bool) async -> Bool { + let status = SFSpeechRecognizer.authorizationStatus() + if status == .notDetermined, interactive { + await withUnsafeContinuation { (cont: UnsafeContinuation) in + SFSpeechRecognizer.requestAuthorization { _ in + DispatchQueue.main.async { cont.resume() } + } + } + } + return SFSpeechRecognizer.authorizationStatus() == .authorized + } + + private static func ensureCamera(interactive: Bool) async -> Bool { + let status = AVCaptureDevice.authorizationStatus(for: .video) + switch status { + case .authorized: + return true + case .notDetermined: + guard interactive else { return false } + return await AVCaptureDevice.requestAccess(for: .video) + case .denied, .restricted: + if interactive { + CameraPermissionHelper.openSettings() + } + return false + @unknown default: + return false + } + } + + private static func ensureLocation(interactive: Bool) async -> Bool { + guard CLLocationManager.locationServicesEnabled() else { + if interactive { + await MainActor.run { LocationPermissionHelper.openSettings() } + } + return false + } + let status = CLLocationManager().authorizationStatus + switch status { + case .authorizedAlways, .authorizedWhenInUse, .authorized: + return true + case .notDetermined: + guard interactive else { return false } + let updated = await LocationPermissionRequester.shared.request(always: false) + return self.isLocationAuthorized(status: updated, requireAlways: false) + case .denied, .restricted: + if interactive { + await MainActor.run { LocationPermissionHelper.openSettings() } + } + return false + @unknown default: + return false + } + } + + static func voiceWakePermissionsGranted() -> Bool { + let mic = AVCaptureDevice.authorizationStatus(for: .audio) == .authorized + let speech = SFSpeechRecognizer.authorizationStatus() == .authorized + return mic && speech + } + + static func ensureVoiceWakePermissions(interactive: Bool) async -> Bool { + let results = await self.ensure([.microphone, .speechRecognition], interactive: interactive) + return results[.microphone] == true && results[.speechRecognition] == true + } + + static func status(_ caps: [Capability] = Capability.allCases) async -> [Capability: Bool] { + var results: [Capability: Bool] = [:] + for cap in caps { + switch cap { + case .notifications: + let center = UNUserNotificationCenter.current() + let settings = await center.notificationSettings() + results[cap] = settings.authorizationStatus == .authorized + || settings.authorizationStatus == .provisional + + case .appleScript: + results[cap] = await MainActor.run { AppleScriptPermission.isAuthorized() } + + case .accessibility: + results[cap] = await MainActor.run { AXIsProcessTrusted() } + + case .screenRecording: + if #available(macOS 10.15, *) { + results[cap] = CGPreflightScreenCaptureAccess() + } else { + results[cap] = true + } + + case .microphone: + results[cap] = AVCaptureDevice.authorizationStatus(for: .audio) == .authorized + + case .speechRecognition: + results[cap] = SFSpeechRecognizer.authorizationStatus() == .authorized + + case .camera: + results[cap] = AVCaptureDevice.authorizationStatus(for: .video) == .authorized + + case .location: + let status = CLLocationManager().authorizationStatus + results[cap] = CLLocationManager.locationServicesEnabled() + && self.isLocationAuthorized(status: status, requireAlways: false) + } + } + return results + } +} + +enum NotificationPermissionHelper { + static func openSettings() { + let candidates = [ + "x-apple.systempreferences:com.apple.Notifications-Settings.extension", + "x-apple.systempreferences:com.apple.preference.notifications", + ] + + for candidate in candidates { + if let url = URL(string: candidate), NSWorkspace.shared.open(url) { + return + } + } + } +} + +enum MicrophonePermissionHelper { + static func openSettings() { + let candidates = [ + "x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone", + "x-apple.systempreferences:com.apple.preference.security", + ] + + for candidate in candidates { + if let url = URL(string: candidate), NSWorkspace.shared.open(url) { + return + } + } + } +} + +enum CameraPermissionHelper { + static func openSettings() { + let candidates = [ + "x-apple.systempreferences:com.apple.preference.security?Privacy_Camera", + "x-apple.systempreferences:com.apple.preference.security", + ] + + for candidate in candidates { + if let url = URL(string: candidate), NSWorkspace.shared.open(url) { + return + } + } + } +} + +enum LocationPermissionHelper { + static func openSettings() { + let candidates = [ + "x-apple.systempreferences:com.apple.preference.security?Privacy_LocationServices", + "x-apple.systempreferences:com.apple.preference.security", + ] + + for candidate in candidates { + if let url = URL(string: candidate), NSWorkspace.shared.open(url) { + return + } + } + } +} + +@MainActor +final class LocationPermissionRequester: NSObject, CLLocationManagerDelegate { + static let shared = LocationPermissionRequester() + private let manager = CLLocationManager() + private var continuation: CheckedContinuation? + private var timeoutTask: Task? + + override init() { + super.init() + self.manager.delegate = self + } + + func request(always: Bool) async -> CLAuthorizationStatus { + let current = self.manager.authorizationStatus + if PermissionManager.isLocationAuthorized(status: current, requireAlways: always) { + return current + } + + return await withCheckedContinuation { cont in + self.continuation = cont + self.timeoutTask?.cancel() + self.timeoutTask = Task { [weak self] in + try? await Task.sleep(nanoseconds: 3_000_000_000) + await MainActor.run { [weak self] in + guard let self else { return } + guard self.continuation != nil else { return } + LocationPermissionHelper.openSettings() + self.finish(status: self.manager.authorizationStatus) + } + } + if always { + self.manager.requestAlwaysAuthorization() + } else { + self.manager.requestWhenInUseAuthorization() + } + + // On macOS, requesting an actual fix makes the prompt more reliable. + self.manager.requestLocation() + } + } + + private func finish(status: CLAuthorizationStatus) { + self.timeoutTask?.cancel() + self.timeoutTask = nil + guard let cont = self.continuation else { return } + self.continuation = nil + cont.resume(returning: status) + } + + // nonisolated for Swift 6 strict concurrency compatibility + nonisolated func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) { + let status = manager.authorizationStatus + Task { @MainActor in + self.finish(status: status) + } + } + + // Legacy callback (still used on some macOS versions / configurations). + nonisolated func locationManager( + _ manager: CLLocationManager, + didChangeAuthorization status: CLAuthorizationStatus) + { + Task { @MainActor in + self.finish(status: status) + } + } + + nonisolated func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) { + let status = manager.authorizationStatus + Task { @MainActor in + if status == .denied || status == .restricted { + LocationPermissionHelper.openSettings() + } + self.finish(status: status) + } + } + + nonisolated func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) { + let status = manager.authorizationStatus + Task { @MainActor in + self.finish(status: status) + } + } +} + +enum AppleScriptPermission { + private static let logger = Logger(subsystem: "bot.molt", category: "AppleScriptPermission") + + /// Sends a benign AppleScript to Terminal to verify Automation permission. + @MainActor + static func isAuthorized() -> Bool { + let script = """ + tell application "Terminal" + return "moltbot-ok" + end tell + """ + + var error: NSDictionary? + let appleScript = NSAppleScript(source: script) + let result = appleScript?.executeAndReturnError(&error) + + if let error, let code = error["NSAppleScriptErrorNumber"] as? Int { + if code == -1743 { // errAEEventWouldRequireUserConsent + Self.logger.debug("AppleScript permission denied (-1743)") + return false + } + Self.logger.debug("AppleScript check failed with code \(code)") + } + + return result != nil + } + + /// Triggers the TCC prompt and opens System Settings → Privacy & Security → Automation. + @MainActor + static func requestAuthorization() async { + _ = self.isAuthorized() // first attempt triggers the dialog if not granted + + // Open the Automation pane to help the user if the prompt was dismissed. + let urlStrings = [ + "x-apple.systempreferences:com.apple.preference.security?Privacy_Automation", + "x-apple.systempreferences:com.apple.preference.security", + ] + + for candidate in urlStrings { + if let url = URL(string: candidate), NSWorkspace.shared.open(url) { + break + } + } + } +} + +@MainActor +@Observable +final class PermissionMonitor { + static let shared = PermissionMonitor() + + private(set) var status: [Capability: Bool] = [:] + + private var monitorTimer: Timer? + private var isChecking = false + private var registrations = 0 + private var lastCheck: Date? + private let minimumCheckInterval: TimeInterval = 0.5 + + func register() { + self.registrations += 1 + if self.registrations == 1 { + self.startMonitoring() + } + } + + func unregister() { + guard self.registrations > 0 else { return } + self.registrations -= 1 + if self.registrations == 0 { + self.stopMonitoring() + } + } + + func refreshNow() async { + await self.checkStatus(force: true) + } + + private func startMonitoring() { + Task { await self.checkStatus(force: true) } + + if ProcessInfo.processInfo.isRunningTests { + return + } + self.monitorTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in + guard let self else { return } + Task { @MainActor in + await self.checkStatus(force: false) + } + } + } + + private func stopMonitoring() { + self.monitorTimer?.invalidate() + self.monitorTimer = nil + self.lastCheck = nil + } + + private func checkStatus(force: Bool) async { + if self.isChecking { return } + let now = Date() + if !force, let lastCheck, now.timeIntervalSince(lastCheck) < self.minimumCheckInterval { + return + } + + self.isChecking = true + + let latest = await PermissionManager.status() + if latest != self.status { + self.status = latest + } + self.lastCheck = Date() + + self.isChecking = false + } +} + +enum ScreenRecordingProbe { + static func isAuthorized() -> Bool { + if #available(macOS 10.15, *) { + return CGPreflightScreenCaptureAccess() + } + return true + } + + @MainActor + static func requestAuthorization() async { + if #available(macOS 10.15, *) { + _ = CGRequestScreenCaptureAccess() + } + } +} diff --git a/apps/macos/Sources/Moltbot/PortGuardian.swift b/apps/macos/Sources/Moltbot/PortGuardian.swift new file mode 100644 index 000000000..c96b66802 --- /dev/null +++ b/apps/macos/Sources/Moltbot/PortGuardian.swift @@ -0,0 +1,418 @@ +import Foundation +import OSLog +#if canImport(Darwin) +import Darwin +#endif + +actor PortGuardian { + static let shared = PortGuardian() + + struct Record: Codable { + let port: Int + let pid: Int32 + let command: String + let mode: String + let timestamp: TimeInterval + } + + struct Descriptor: Sendable { + let pid: Int32 + let command: String + let executablePath: String? + } + + private var records: [Record] = [] + private let logger = Logger(subsystem: "bot.molt", category: "portguard") + private nonisolated static let appSupportDir: URL = { + let base = FileManager().urls(for: .applicationSupportDirectory, in: .userDomainMask).first! + return base.appendingPathComponent("Moltbot", isDirectory: true) + }() + + private nonisolated static var recordPath: URL { + self.appSupportDir.appendingPathComponent("port-guard.json", isDirectory: false) + } + + init() { + self.records = Self.loadRecords(from: Self.recordPath) + } + + func sweep(mode: AppState.ConnectionMode) async { + self.logger.info("port sweep starting (mode=\(mode.rawValue, privacy: .public))") + guard mode != .unconfigured else { + self.logger.info("port sweep skipped (mode=unconfigured)") + return + } + let ports = [GatewayEnvironment.gatewayPort()] + for port in ports { + let listeners = await self.listeners(on: port) + guard !listeners.isEmpty else { continue } + for listener in listeners { + if self.isExpected(listener, port: port, mode: mode) { + let message = """ + port \(port) already served by expected \(listener.command) + (pid \(listener.pid)) — keeping + """ + self.logger.info("\(message, privacy: .public)") + continue + } + let killed = await self.kill(listener.pid) + if killed { + let message = """ + port \(port) was held by \(listener.command) + (pid \(listener.pid)); terminated + """ + self.logger.error("\(message, privacy: .public)") + } else { + self.logger.error("failed to terminate pid \(listener.pid) on port \(port, privacy: .public)") + } + } + } + self.logger.info("port sweep done") + } + + func record(port: Int, pid: Int32, command: String, mode: AppState.ConnectionMode) async { + try? FileManager().createDirectory(at: Self.appSupportDir, withIntermediateDirectories: true) + self.records.removeAll { $0.pid == pid } + self.records.append( + Record( + port: port, + pid: pid, + command: command, + mode: mode.rawValue, + timestamp: Date().timeIntervalSince1970)) + self.save() + } + + func removeRecord(pid: Int32) { + let before = self.records.count + self.records.removeAll { $0.pid == pid } + if self.records.count != before { + self.save() + } + } + + struct PortReport: Identifiable { + enum Status { + case ok(String) + case missing(String) + case interference(String, offenders: [ReportListener]) + } + + let port: Int + let expected: String + let status: Status + let listeners: [ReportListener] + + var id: Int { self.port } + + var offenders: [ReportListener] { + if case let .interference(_, offenders) = self.status { return offenders } + return [] + } + + var summary: String { + switch self.status { + case let .ok(text): text + case let .missing(text): text + case let .interference(text, _): text + } + } + } + + func describe(port: Int) async -> Descriptor? { + guard let listener = await self.listeners(on: port).first else { return nil } + let path = Self.executablePath(for: listener.pid) + return Descriptor(pid: listener.pid, command: listener.command, executablePath: path) + } + + // MARK: - Internals + + private struct Listener { + let pid: Int32 + let command: String + let fullCommand: String + let user: String? + } + + struct ReportListener: Identifiable { + let pid: Int32 + let command: String + let fullCommand: String + let user: String? + let expected: Bool + + var id: Int32 { self.pid } + } + + func diagnose(mode: AppState.ConnectionMode) async -> [PortReport] { + if mode == .unconfigured { + return [] + } + let ports = [GatewayEnvironment.gatewayPort()] + var reports: [PortReport] = [] + + for port in ports { + let listeners = await self.listeners(on: port) + let tunnelHealthy = await self.probeGatewayHealthIfNeeded( + port: port, + mode: mode, + listeners: listeners) + reports.append(Self.buildReport( + port: port, + listeners: listeners, + mode: mode, + tunnelHealthy: tunnelHealthy)) + } + + return reports + } + + func probeGatewayHealth(port: Int, timeout: TimeInterval = 2.0) async -> Bool { + let url = URL(string: "http://127.0.0.1:\(port)/")! + let config = URLSessionConfiguration.ephemeral + config.timeoutIntervalForRequest = timeout + config.timeoutIntervalForResource = timeout + let session = URLSession(configuration: config) + var request = URLRequest(url: url) + request.cachePolicy = .reloadIgnoringLocalCacheData + request.timeoutInterval = timeout + do { + let (_, response) = try await session.data(for: request) + return response is HTTPURLResponse + } catch { + return false + } + } + + func isListening(port: Int, pid: Int32? = nil) async -> Bool { + let listeners = await self.listeners(on: port) + if let pid { + return listeners.contains(where: { $0.pid == pid }) + } + return !listeners.isEmpty + } + + private func listeners(on port: Int) async -> [Listener] { + let res = await ShellExecutor.run( + command: ["lsof", "-nP", "-iTCP:\(port)", "-sTCP:LISTEN", "-Fpcn"], + cwd: nil, + env: nil, + timeout: 5) + guard res.ok, let data = res.payload, !data.isEmpty else { return [] } + let text = String(data: data, encoding: .utf8) ?? "" + return Self.parseListeners(from: text) + } + + private static func readFullCommand(pid: Int32) -> String? { + let proc = Process() + proc.executableURL = URL(fileURLWithPath: "/bin/ps") + proc.arguments = ["-p", "\(pid)", "-o", "command="] + let pipe = Pipe() + proc.standardOutput = pipe + proc.standardError = Pipe() + do { + let data = try proc.runAndReadToEnd(from: pipe) + guard !data.isEmpty else { return nil } + return String(data: data, encoding: .utf8)? + .trimmingCharacters(in: .whitespacesAndNewlines) + } catch { + return nil + } + } + + private static func parseListeners(from text: String) -> [Listener] { + var listeners: [Listener] = [] + var currentPid: Int32? + var currentCmd: String? + var currentUser: String? + + func flush() { + if let pid = currentPid, let cmd = currentCmd { + let full = Self.readFullCommand(pid: pid) ?? cmd + listeners.append(Listener(pid: pid, command: cmd, fullCommand: full, user: currentUser)) + } + currentPid = nil + currentCmd = nil + currentUser = nil + } + + for line in text.split(separator: "\n") { + guard let prefix = line.first else { continue } + let value = String(line.dropFirst()) + switch prefix { + case "p": + flush() + currentPid = Int32(value) ?? 0 + case "c": + currentCmd = value + case "u": + currentUser = value + default: + continue + } + } + flush() + return listeners + } + + private static func buildReport( + port: Int, + listeners: [Listener], + mode: AppState.ConnectionMode, + tunnelHealthy: Bool?) -> PortReport + { + let expectedDesc: String + let okPredicate: (Listener) -> Bool + let expectedCommands = ["node", "moltbot", "tsx", "pnpm", "bun"] + + switch mode { + case .remote: + expectedDesc = "SSH tunnel to remote gateway" + okPredicate = { $0.command.lowercased().contains("ssh") } + case .local: + expectedDesc = "Gateway websocket (node/tsx)" + okPredicate = { listener in + let c = listener.command.lowercased() + return expectedCommands.contains { c.contains($0) } + } + case .unconfigured: + expectedDesc = "Gateway not configured" + okPredicate = { _ in false } + } + + if listeners.isEmpty { + let text = "Nothing is listening on \(port) (\(expectedDesc))." + return .init(port: port, expected: expectedDesc, status: .missing(text), listeners: []) + } + + let tunnelUnhealthy = + mode == .remote && port == GatewayEnvironment.gatewayPort() && tunnelHealthy == false + let reportListeners = listeners.map { listener in + var expected = okPredicate(listener) + if tunnelUnhealthy, expected { expected = false } + return ReportListener( + pid: listener.pid, + command: listener.command, + fullCommand: listener.fullCommand, + user: listener.user, + expected: expected) + } + + let offenders = reportListeners.filter { !$0.expected } + if tunnelUnhealthy { + let list = listeners.map { "\($0.command) (\($0.pid))" }.joined(separator: ", ") + let reason = "Port \(port) is served by \(list), but the SSH tunnel is unhealthy." + return .init( + port: port, + expected: expectedDesc, + status: .interference(reason, offenders: offenders), + listeners: reportListeners) + } + if offenders.isEmpty { + let list = listeners.map { "\($0.command) (\($0.pid))" }.joined(separator: ", ") + let okText = "Port \(port) is served by \(list)." + return .init( + port: port, + expected: expectedDesc, + status: .ok(okText), + listeners: reportListeners) + } + + let list = offenders.map { "\($0.command) (\($0.pid))" }.joined(separator: ", ") + let reason = "Port \(port) is held by \(list), expected \(expectedDesc)." + return .init( + port: port, + expected: expectedDesc, + status: .interference(reason, offenders: offenders), + listeners: reportListeners) + } + + private static func executablePath(for pid: Int32) -> String? { + #if canImport(Darwin) + var buffer = [CChar](repeating: 0, count: Int(PATH_MAX)) + let length = proc_pidpath(pid, &buffer, UInt32(buffer.count)) + guard length > 0 else { return nil } + // Drop trailing null and decode as UTF-8. + let trimmed = buffer.prefix { $0 != 0 } + let bytes = trimmed.map { UInt8(bitPattern: $0) } + return String(bytes: bytes, encoding: .utf8) + #else + return nil + #endif + } + + private func kill(_ pid: Int32) async -> Bool { + let term = await ShellExecutor.run(command: ["kill", "-TERM", "\(pid)"], cwd: nil, env: nil, timeout: 2) + if term.ok { return true } + let sigkill = await ShellExecutor.run(command: ["kill", "-KILL", "\(pid)"], cwd: nil, env: nil, timeout: 2) + return sigkill.ok + } + + private func isExpected(_ listener: Listener, port: Int, mode: AppState.ConnectionMode) -> Bool { + let cmd = listener.command.lowercased() + let full = listener.fullCommand.lowercased() + switch mode { + case .remote: + // Remote mode expects an SSH tunnel for the gateway WebSocket port. + if port == GatewayEnvironment.gatewayPort() { return cmd.contains("ssh") } + return false + case .local: + // The gateway daemon may listen as `moltbot` or as its runtime (`node`, `bun`, etc). + if full.contains("gateway-daemon") { return true } + // If args are unavailable, treat a moltbot listener as expected. + if cmd.contains("moltbot"), full == cmd { return true } + return false + case .unconfigured: + return false + } + } + + private func probeGatewayHealthIfNeeded( + port: Int, + mode: AppState.ConnectionMode, + listeners: [Listener]) async -> Bool? + { + guard mode == .remote, port == GatewayEnvironment.gatewayPort(), !listeners.isEmpty else { return nil } + let hasSsh = listeners.contains { $0.command.lowercased().contains("ssh") } + guard hasSsh else { return nil } + return await self.probeGatewayHealth(port: port) + } + + private static func loadRecords(from url: URL) -> [Record] { + guard let data = try? Data(contentsOf: url), + let decoded = try? JSONDecoder().decode([Record].self, from: data) + else { return [] } + return decoded + } + + private func save() { + guard let data = try? JSONEncoder().encode(self.records) else { return } + try? data.write(to: Self.recordPath, options: [.atomic]) + } +} + +#if DEBUG +extension PortGuardian { + static func _testParseListeners(_ text: String) -> [( + pid: Int32, + command: String, + fullCommand: String, + user: String?)] + { + self.parseListeners(from: text).map { ($0.pid, $0.command, $0.fullCommand, $0.user) } + } + + static func _testBuildReport( + port: Int, + mode: AppState.ConnectionMode, + listeners: [(pid: Int32, command: String, fullCommand: String, user: String?)]) -> PortReport + { + let mapped = listeners.map { Listener( + pid: $0.pid, + command: $0.command, + fullCommand: $0.fullCommand, + user: $0.user) } + return Self.buildReport(port: port, listeners: mapped, mode: mode, tunnelHealthy: nil) + } +} +#endif diff --git a/apps/macos/Sources/Moltbot/PresenceReporter.swift b/apps/macos/Sources/Moltbot/PresenceReporter.swift new file mode 100644 index 000000000..369e277d6 --- /dev/null +++ b/apps/macos/Sources/Moltbot/PresenceReporter.swift @@ -0,0 +1,158 @@ +import Cocoa +import Darwin +import Foundation +import OSLog + +@MainActor +final class PresenceReporter { + static let shared = PresenceReporter() + + private let logger = Logger(subsystem: "bot.molt", category: "presence") + private var task: Task? + private let interval: TimeInterval = 180 // a few minutes + private let instanceId: String = InstanceIdentity.instanceId + + func start() { + guard self.task == nil else { return } + self.task = Task.detached { [weak self] in + guard let self else { return } + await self.push(reason: "launch") + while !Task.isCancelled { + try? await Task.sleep(nanoseconds: UInt64(self.interval * 1_000_000_000)) + await self.push(reason: "periodic") + } + } + } + + func stop() { + self.task?.cancel() + self.task = nil + } + + @Sendable + private func push(reason: String) async { + let mode = await MainActor.run { AppStateStore.shared.connectionMode.rawValue } + let host = InstanceIdentity.displayName + let ip = Self.primaryIPv4Address() ?? "ip-unknown" + let version = Self.appVersionString() + let platform = Self.platformString() + let lastInput = Self.lastInputSeconds() + let text = Self.composePresenceSummary(mode: mode, reason: reason) + var params: [String: AnyHashable] = [ + "instanceId": AnyHashable(self.instanceId), + "host": AnyHashable(host), + "ip": AnyHashable(ip), + "mode": AnyHashable(mode), + "version": AnyHashable(version), + "platform": AnyHashable(platform), + "deviceFamily": AnyHashable("Mac"), + "reason": AnyHashable(reason), + ] + if let model = InstanceIdentity.modelIdentifier { params["modelIdentifier"] = AnyHashable(model) } + if let lastInput { params["lastInputSeconds"] = AnyHashable(lastInput) } + do { + try await ControlChannel.shared.sendSystemEvent(text, params: params) + } catch { + self.logger.error("presence send failed: \(error.localizedDescription, privacy: .public)") + } + } + + /// Fire an immediate presence beacon (e.g., right after connecting). + func sendImmediate(reason: String = "connect") { + Task { await self.push(reason: reason) } + } + + private static func composePresenceSummary(mode: String, reason: String) -> String { + let host = InstanceIdentity.displayName + let ip = Self.primaryIPv4Address() ?? "ip-unknown" + let version = Self.appVersionString() + let lastInput = Self.lastInputSeconds() + let lastLabel = lastInput.map { "last input \($0)s ago" } ?? "last input unknown" + return "Node: \(host) (\(ip)) · app \(version) · \(lastLabel) · mode \(mode) · reason \(reason)" + } + + private static func appVersionString() -> String { + let version = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String ?? "dev" + if let build = Bundle.main.object(forInfoDictionaryKey: "CFBundleVersion") as? String { + let trimmed = build.trimmingCharacters(in: .whitespacesAndNewlines) + if !trimmed.isEmpty, trimmed != version { + return "\(version) (\(trimmed))" + } + } + return version + } + + private static func platformString() -> String { + let v = ProcessInfo.processInfo.operatingSystemVersion + return "macos \(v.majorVersion).\(v.minorVersion).\(v.patchVersion)" + } + + private static func lastInputSeconds() -> Int? { + let anyEvent = CGEventType(rawValue: UInt32.max) ?? .null + let seconds = CGEventSource.secondsSinceLastEventType(.combinedSessionState, eventType: anyEvent) + if seconds.isNaN || seconds.isInfinite || seconds < 0 { return nil } + return Int(seconds.rounded()) + } + + private static func primaryIPv4Address() -> String? { + var addrList: UnsafeMutablePointer? + guard getifaddrs(&addrList) == 0, let first = addrList else { return nil } + defer { freeifaddrs(addrList) } + + var fallback: String? + var en0: String? + + for ptr in sequence(first: first, next: { $0.pointee.ifa_next }) { + let flags = Int32(ptr.pointee.ifa_flags) + let isUp = (flags & IFF_UP) != 0 + let isLoopback = (flags & IFF_LOOPBACK) != 0 + let name = String(cString: ptr.pointee.ifa_name) + let family = ptr.pointee.ifa_addr.pointee.sa_family + if !isUp || isLoopback || family != UInt8(AF_INET) { continue } + + var addr = ptr.pointee.ifa_addr.pointee + var buffer = [CChar](repeating: 0, count: Int(NI_MAXHOST)) + let result = getnameinfo( + &addr, + socklen_t(ptr.pointee.ifa_addr.pointee.sa_len), + &buffer, + socklen_t(buffer.count), + nil, + 0, + NI_NUMERICHOST) + guard result == 0 else { continue } + let len = buffer.prefix { $0 != 0 } + let bytes = len.map { UInt8(bitPattern: $0) } + guard let ip = String(bytes: bytes, encoding: .utf8) else { continue } + + if name == "en0" { en0 = ip; break } + if fallback == nil { fallback = ip } + } + + return en0 ?? fallback + } +} + +#if DEBUG +extension PresenceReporter { + static func _testComposePresenceSummary(mode: String, reason: String) -> String { + self.composePresenceSummary(mode: mode, reason: reason) + } + + static func _testAppVersionString() -> String { + self.appVersionString() + } + + static func _testPlatformString() -> String { + self.platformString() + } + + static func _testLastInputSeconds() -> Int? { + self.lastInputSeconds() + } + + static func _testPrimaryIPv4Address() -> String? { + self.primaryIPv4Address() + } +} +#endif diff --git a/apps/macos/Sources/Moltbot/RemotePortTunnel.swift b/apps/macos/Sources/Moltbot/RemotePortTunnel.swift new file mode 100644 index 000000000..8c6db89a3 --- /dev/null +++ b/apps/macos/Sources/Moltbot/RemotePortTunnel.swift @@ -0,0 +1,317 @@ +import Foundation +import Network +import OSLog +#if canImport(Darwin) +import Darwin +#endif + +/// Port forwarding tunnel for remote mode. +/// +/// Uses `ssh -N -L` to forward the remote gateway ports to localhost. +final class RemotePortTunnel { + private static let logger = Logger(subsystem: "bot.molt", category: "remote.tunnel") + + let process: Process + let localPort: UInt16? + private let stderrHandle: FileHandle? + + private init(process: Process, localPort: UInt16?, stderrHandle: FileHandle?) { + self.process = process + self.localPort = localPort + self.stderrHandle = stderrHandle + } + + deinit { + Self.cleanupStderr(self.stderrHandle) + let pid = self.process.processIdentifier + self.process.terminate() + Task { await PortGuardian.shared.removeRecord(pid: pid) } + } + + func terminate() { + Self.cleanupStderr(self.stderrHandle) + let pid = self.process.processIdentifier + if self.process.isRunning { + self.process.terminate() + self.process.waitUntilExit() + } + Task { await PortGuardian.shared.removeRecord(pid: pid) } + } + + static func create( + remotePort: Int, + preferredLocalPort: UInt16? = nil, + allowRemoteUrlOverride: Bool = true, + allowRandomLocalPort: Bool = true) async throws -> RemotePortTunnel + { + let settings = CommandResolver.connectionSettings() + guard settings.mode == .remote, let parsed = CommandResolver.parseSSHTarget(settings.target) else { + throw NSError( + domain: "RemotePortTunnel", + code: 3, + userInfo: [NSLocalizedDescriptionKey: "Remote mode is not configured"]) + } + + let localPort = try await Self.findPort( + preferred: preferredLocalPort, + allowRandom: allowRandomLocalPort) + let sshHost = parsed.host.trimmingCharacters(in: .whitespacesAndNewlines) + let remotePortOverride = + allowRemoteUrlOverride && remotePort == GatewayEnvironment.gatewayPort() + ? Self.resolveRemotePortOverride(for: sshHost) + : nil + let resolvedRemotePort = remotePortOverride ?? remotePort + if let override = remotePortOverride { + Self.logger.info( + "ssh tunnel remote port override " + + "host=\(sshHost, privacy: .public) port=\(override, privacy: .public)") + } else { + Self.logger.debug( + "ssh tunnel using default remote port " + + "host=\(sshHost, privacy: .public) port=\(remotePort, privacy: .public)") + } + let options: [String] = [ + "-o", "BatchMode=yes", + "-o", "ExitOnForwardFailure=yes", + "-o", "StrictHostKeyChecking=accept-new", + "-o", "UpdateHostKeys=yes", + "-o", "ServerAliveInterval=15", + "-o", "ServerAliveCountMax=3", + "-o", "TCPKeepAlive=yes", + "-N", + "-L", "\(localPort):127.0.0.1:\(resolvedRemotePort)", + ] + let identity = settings.identity.trimmingCharacters(in: .whitespacesAndNewlines) + let args = CommandResolver.sshArguments( + target: parsed, + identity: identity, + options: options) + + let process = Process() + process.executableURL = URL(fileURLWithPath: "/usr/bin/ssh") + process.arguments = args + + let pipe = Pipe() + process.standardError = pipe + let stderrHandle = pipe.fileHandleForReading + + // Consume stderr so ssh cannot block if it logs. + stderrHandle.readabilityHandler = { handle in + let data = handle.readSafely(upToCount: 64 * 1024) + guard !data.isEmpty else { + // EOF (or read failure): stop monitoring to avoid spinning on a closed pipe. + Self.cleanupStderr(handle) + return + } + guard let line = String(data: data, encoding: .utf8)? + .trimmingCharacters(in: .whitespacesAndNewlines), + !line.isEmpty + else { return } + Self.logger.error("ssh tunnel stderr: \(line, privacy: .public)") + } + process.terminationHandler = { _ in + Self.cleanupStderr(stderrHandle) + } + + try process.run() + + // If ssh exits immediately (e.g. local port already in use), surface stderr and ensure we stop monitoring. + try? await Task.sleep(nanoseconds: 150_000_000) // 150ms + if !process.isRunning { + let stderr = Self.drainStderr(stderrHandle) + let msg = stderr.isEmpty ? "ssh tunnel exited immediately" : "ssh tunnel failed: \(stderr)" + throw NSError(domain: "RemotePortTunnel", code: 4, userInfo: [NSLocalizedDescriptionKey: msg]) + } + + // Track tunnel so we can clean up stale listeners on restart. + Task { + await PortGuardian.shared.record( + port: Int(localPort), + pid: process.processIdentifier, + command: process.executableURL?.path ?? "ssh", + mode: CommandResolver.connectionSettings().mode) + } + + return RemotePortTunnel(process: process, localPort: localPort, stderrHandle: stderrHandle) + } + + private static func resolveRemotePortOverride(for sshHost: String) -> Int? { + let root = MoltbotConfigFile.loadDict() + guard let gateway = root["gateway"] as? [String: Any], + let remote = gateway["remote"] as? [String: Any], + let urlRaw = remote["url"] as? String + else { + return nil + } + let trimmed = urlRaw.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty, let url = URL(string: trimmed), let port = url.port else { + return nil + } + guard let host = url.host?.trimmingCharacters(in: .whitespacesAndNewlines), + !host.isEmpty + else { + return nil + } + let sshKey = Self.hostKey(sshHost) + let urlKey = Self.hostKey(host) + guard !sshKey.isEmpty, !urlKey.isEmpty else { return nil } + guard sshKey == urlKey else { + Self.logger.debug( + "remote url host mismatch sshHost=\(sshHost, privacy: .public) urlHost=\(host, privacy: .public)") + return nil + } + return port + } + + private static func hostKey(_ host: String) -> String { + let trimmed = host.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + guard !trimmed.isEmpty else { return "" } + if trimmed.contains(":") { return trimmed } + let digits = CharacterSet(charactersIn: "0123456789.") + if trimmed.rangeOfCharacter(from: digits.inverted) == nil { + return trimmed + } + return trimmed.split(separator: ".").first.map(String.init) ?? trimmed + } + + private static func findPort(preferred: UInt16?, allowRandom: Bool) async throws -> UInt16 { + if let preferred, self.portIsFree(preferred) { return preferred } + if let preferred, !allowRandom { + throw NSError( + domain: "RemotePortTunnel", + code: 5, + userInfo: [ + NSLocalizedDescriptionKey: "Local port \(preferred) is unavailable", + ]) + } + + return try await withCheckedThrowingContinuation { cont in + let queue = DispatchQueue(label: "bot.molt.remote.tunnel.port", qos: .utility) + do { + let listener = try NWListener(using: .tcp, on: .any) + listener.newConnectionHandler = { connection in connection.cancel() } + listener.stateUpdateHandler = { state in + switch state { + case .ready: + if let port = listener.port?.rawValue { + listener.stateUpdateHandler = nil + listener.cancel() + cont.resume(returning: port) + } + case let .failed(error): + listener.stateUpdateHandler = nil + listener.cancel() + cont.resume(throwing: error) + default: + break + } + } + listener.start(queue: queue) + } catch { + cont.resume(throwing: error) + } + } + } + + private static func portIsFree(_ port: UInt16) -> Bool { + #if canImport(Darwin) + // NWListener can succeed even when only one address family is held. Mirror what ssh needs by checking + // both 127.0.0.1 and ::1 for availability. + return self.canBindIPv4(port) && self.canBindIPv6(port) + #else + do { + let listener = try NWListener(using: .tcp, on: NWEndpoint.Port(rawValue: port)!) + listener.cancel() + return true + } catch { + return false + } + #endif + } + + #if canImport(Darwin) + private static func canBindIPv4(_ port: UInt16) -> Bool { + let fd = socket(AF_INET, SOCK_STREAM, 0) + guard fd >= 0 else { return false } + defer { _ = Darwin.close(fd) } + + var one: Int32 = 1 + _ = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, socklen_t(MemoryLayout.size(ofValue: one))) + + var addr = sockaddr_in() + addr.sin_len = UInt8(MemoryLayout.size) + addr.sin_family = sa_family_t(AF_INET) + addr.sin_port = port.bigEndian + addr.sin_addr = in_addr(s_addr: inet_addr("127.0.0.1")) + + let result = withUnsafePointer(to: &addr) { ptr in + ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in + Darwin.bind(fd, sa, socklen_t(MemoryLayout.size)) + } + } + return result == 0 + } + + private static func canBindIPv6(_ port: UInt16) -> Bool { + let fd = socket(AF_INET6, SOCK_STREAM, 0) + guard fd >= 0 else { return false } + defer { _ = Darwin.close(fd) } + + var one: Int32 = 1 + _ = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, socklen_t(MemoryLayout.size(ofValue: one))) + + var addr = sockaddr_in6() + addr.sin6_len = UInt8(MemoryLayout.size) + addr.sin6_family = sa_family_t(AF_INET6) + addr.sin6_port = port.bigEndian + var loopback = in6_addr() + _ = withUnsafeMutablePointer(to: &loopback) { ptr in + inet_pton(AF_INET6, "::1", ptr) + } + addr.sin6_addr = loopback + + let result = withUnsafePointer(to: &addr) { ptr in + ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in + Darwin.bind(fd, sa, socklen_t(MemoryLayout.size)) + } + } + return result == 0 + } + #endif + + private static func cleanupStderr(_ handle: FileHandle?) { + guard let handle else { return } + Self.cleanupStderr(handle) + } + + private static func cleanupStderr(_ handle: FileHandle) { + if handle.readabilityHandler != nil { + handle.readabilityHandler = nil + } + try? handle.close() + } + + private static func drainStderr(_ handle: FileHandle) -> String { + handle.readabilityHandler = nil + defer { try? handle.close() } + + do { + let data = try handle.readToEnd() ?? Data() + return String(data: data, encoding: .utf8)? + .trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + } catch { + self.logger.debug("Failed to drain ssh stderr: \(error, privacy: .public)") + return "" + } + } + + #if SWIFT_PACKAGE + static func _testPortIsFree(_ port: UInt16) -> Bool { + self.portIsFree(port) + } + + static func _testDrainStderr(_ handle: FileHandle) -> String { + self.drainStderr(handle) + } + #endif +} diff --git a/apps/macos/Sources/Moltbot/RemoteTunnelManager.swift b/apps/macos/Sources/Moltbot/RemoteTunnelManager.swift new file mode 100644 index 000000000..f199ff9fe --- /dev/null +++ b/apps/macos/Sources/Moltbot/RemoteTunnelManager.swift @@ -0,0 +1,122 @@ +import Foundation +import OSLog + +/// Manages the SSH tunnel that forwards the remote gateway/control port to localhost. +actor RemoteTunnelManager { + static let shared = RemoteTunnelManager() + + private let logger = Logger(subsystem: "bot.molt", category: "remote-tunnel") + private var controlTunnel: RemotePortTunnel? + private var restartInFlight = false + private var lastRestartAt: Date? + private let restartBackoffSeconds: TimeInterval = 2.0 + + func controlTunnelPortIfRunning() async -> UInt16? { + if self.restartInFlight { + self.logger.info("control tunnel restart in flight; skipping reuse check") + return nil + } + if let tunnel = self.controlTunnel, + tunnel.process.isRunning, + let local = tunnel.localPort + { + let pid = tunnel.process.processIdentifier + if await PortGuardian.shared.isListening(port: Int(local), pid: pid) { + self.logger.info("reusing active SSH tunnel localPort=\(local, privacy: .public)") + return local + } + self.logger.error( + "active SSH tunnel on port \(local, privacy: .public) is not listening; restarting") + await self.beginRestart() + tunnel.terminate() + self.controlTunnel = nil + } + // If a previous Moltbot run already has an SSH listener on the expected port (common after restarts), + // reuse it instead of spawning new ssh processes that immediately fail with "Address already in use". + let desiredPort = UInt16(GatewayEnvironment.gatewayPort()) + if let desc = await PortGuardian.shared.describe(port: Int(desiredPort)), + self.isSshProcess(desc) + { + self.logger.info( + "reusing existing SSH tunnel listener " + + "localPort=\(desiredPort, privacy: .public) " + + "pid=\(desc.pid, privacy: .public)") + return desiredPort + } + return nil + } + + /// Ensure an SSH tunnel is running for the gateway control port. + /// Returns the local forwarded port (usually the configured gateway port). + func ensureControlTunnel() async throws -> UInt16 { + let settings = CommandResolver.connectionSettings() + guard settings.mode == .remote else { + throw NSError( + domain: "RemoteTunnel", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "Remote mode is not enabled"]) + } + + let identitySet = !settings.identity.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty + self.logger.info( + "ensure SSH tunnel target=\(settings.target, privacy: .public) " + + "identitySet=\(identitySet, privacy: .public)") + + if let local = await self.controlTunnelPortIfRunning() { return local } + await self.waitForRestartBackoffIfNeeded() + + let desiredPort = UInt16(GatewayEnvironment.gatewayPort()) + let tunnel = try await RemotePortTunnel.create( + remotePort: GatewayEnvironment.gatewayPort(), + preferredLocalPort: desiredPort, + allowRandomLocalPort: false) + self.controlTunnel = tunnel + self.endRestart() + let resolvedPort = tunnel.localPort ?? desiredPort + self.logger.info("ssh tunnel ready localPort=\(resolvedPort, privacy: .public)") + return tunnel.localPort ?? desiredPort + } + + func stopAll() { + self.controlTunnel?.terminate() + self.controlTunnel = nil + } + + private func isSshProcess(_ desc: PortGuardian.Descriptor) -> Bool { + let cmd = desc.command.lowercased() + if cmd.contains("ssh") { return true } + if let path = desc.executablePath?.lowercased(), path.contains("/ssh") { return true } + return false + } + + private func beginRestart() async { + guard !self.restartInFlight else { return } + self.restartInFlight = true + self.lastRestartAt = Date() + self.logger.info("control tunnel restart started") + Task { [weak self] in + guard let self else { return } + try? await Task.sleep(nanoseconds: UInt64(self.restartBackoffSeconds * 1_000_000_000)) + await self.endRestart() + } + } + + private func endRestart() { + if self.restartInFlight { + self.restartInFlight = false + self.logger.info("control tunnel restart finished") + } + } + + private func waitForRestartBackoffIfNeeded() async { + guard let last = self.lastRestartAt else { return } + let elapsed = Date().timeIntervalSince(last) + let remaining = self.restartBackoffSeconds - elapsed + guard remaining > 0 else { return } + self.logger.info( + "control tunnel restart backoff \(remaining, privacy: .public)s") + try? await Task.sleep(nanoseconds: UInt64(remaining * 1_000_000_000)) + } + + // Keep tunnel reuse lightweight; restart only when the listener disappears. +} diff --git a/apps/macos/Sources/Moltbot/Resources/Info.plist b/apps/macos/Sources/Moltbot/Resources/Info.plist new file mode 100644 index 000000000..89c5a2d9e --- /dev/null +++ b/apps/macos/Sources/Moltbot/Resources/Info.plist @@ -0,0 +1,79 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + Moltbot + CFBundleIdentifier + bot.molt.mac + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + Moltbot + CFBundlePackageType + APPL + CFBundleShortVersionString + 2026.1.26 + CFBundleVersion + 202601260 + CFBundleIconFile + Moltbot + CFBundleURLTypes + + + CFBundleURLName + bot.molt.mac.deeplink + CFBundleURLSchemes + + moltbot + + + + LSMinimumSystemVersion + 15.0 + LSUIElement + + + MoltbotBuildTimestamp + + MoltbotGitCommit + + + NSUserNotificationUsageDescription + Moltbot needs notification permission to show alerts for agent actions. + NSScreenCaptureDescription + Moltbot captures the screen when the agent needs screenshots for context. + NSCameraUsageDescription + Moltbot can capture photos or short video clips when requested by the agent. + NSLocationUsageDescription + Moltbot can share your location when requested by the agent. + NSLocationWhenInUseUsageDescription + Moltbot can share your location when requested by the agent. + NSLocationAlwaysAndWhenInUseUsageDescription + Moltbot can share your location when requested by the agent. + NSMicrophoneUsageDescription + Moltbot needs the mic for Voice Wake tests and agent audio capture. + NSSpeechRecognitionUsageDescription + Moltbot uses speech recognition to detect your Voice Wake trigger phrase. + NSAppleEventsUsageDescription + Moltbot needs Automation (AppleScript) permission to drive Terminal and other apps for agent actions. + + NSAppTransportSecurity + + NSAllowsArbitraryLoadsInWebContent + + NSExceptionDomains + + 100.100.100.100 + + NSExceptionAllowsInsecureHTTPLoads + + NSIncludesSubdomains + + + + + + diff --git a/apps/macos/Sources/Moltbot/RuntimeLocator.swift b/apps/macos/Sources/Moltbot/RuntimeLocator.swift new file mode 100644 index 000000000..270e209d3 --- /dev/null +++ b/apps/macos/Sources/Moltbot/RuntimeLocator.swift @@ -0,0 +1,167 @@ +import Foundation +import OSLog + +enum RuntimeKind: String { + case node +} + +struct RuntimeVersion: Comparable, CustomStringConvertible { + let major: Int + let minor: Int + let patch: Int + + var description: String { "\(self.major).\(self.minor).\(self.patch)" } + + static func < (lhs: RuntimeVersion, rhs: RuntimeVersion) -> Bool { + if lhs.major != rhs.major { return lhs.major < rhs.major } + if lhs.minor != rhs.minor { return lhs.minor < rhs.minor } + return lhs.patch < rhs.patch + } + + static func from(string: String) -> RuntimeVersion? { + // Accept optional leading "v" and ignore trailing metadata. + let pattern = #"(\d+)\.(\d+)\.(\d+)"# + guard let match = string.range(of: pattern, options: .regularExpression) else { return nil } + let versionString = String(string[match]) + let parts = versionString.split(separator: ".") + guard parts.count == 3, + let major = Int(parts[0]), + let minor = Int(parts[1]), + let patch = Int(parts[2]) + else { return nil } + return RuntimeVersion(major: major, minor: minor, patch: patch) + } +} + +struct RuntimeResolution { + let kind: RuntimeKind + let path: String + let version: RuntimeVersion +} + +enum RuntimeResolutionError: Error { + case notFound(searchPaths: [String]) + case unsupported( + kind: RuntimeKind, + found: RuntimeVersion, + required: RuntimeVersion, + path: String, + searchPaths: [String]) + case versionParse(kind: RuntimeKind, raw: String, path: String, searchPaths: [String]) +} + +enum RuntimeLocator { + private static let logger = Logger(subsystem: "bot.molt", category: "runtime") + private static let minNode = RuntimeVersion(major: 22, minor: 0, patch: 0) + + static func resolve( + searchPaths: [String] = CommandResolver.preferredPaths()) -> Result + { + let pathEnv = searchPaths.joined(separator: ":") + let runtime: RuntimeKind = .node + + guard let binary = findExecutable(named: runtime.binaryName, searchPaths: searchPaths) else { + return .failure(.notFound(searchPaths: searchPaths)) + } + guard let rawVersion = readVersion(of: binary, pathEnv: pathEnv) else { + return .failure(.versionParse( + kind: runtime, + raw: "(unreadable)", + path: binary, + searchPaths: searchPaths)) + } + guard let parsed = RuntimeVersion.from(string: rawVersion) else { + return .failure(.versionParse(kind: runtime, raw: rawVersion, path: binary, searchPaths: searchPaths)) + } + guard parsed >= self.minNode else { + return .failure(.unsupported( + kind: runtime, + found: parsed, + required: self.minNode, + path: binary, + searchPaths: searchPaths)) + } + + return .success(RuntimeResolution(kind: runtime, path: binary, version: parsed)) + } + + static func describeFailure(_ error: RuntimeResolutionError) -> String { + switch error { + case let .notFound(searchPaths): + [ + "moltbot needs Node >=22.0.0 but found no runtime.", + "PATH searched: \(searchPaths.joined(separator: ":"))", + "Install Node: https://nodejs.org/en/download", + ].joined(separator: "\n") + case let .unsupported(kind, found, required, path, searchPaths): + [ + "Found \(kind.rawValue) \(found) at \(path) but need >= \(required).", + "PATH searched: \(searchPaths.joined(separator: ":"))", + "Upgrade Node and rerun moltbot.", + ].joined(separator: "\n") + case let .versionParse(kind, raw, path, searchPaths): + [ + "Could not parse \(kind.rawValue) version output \"\(raw)\" from \(path).", + "PATH searched: \(searchPaths.joined(separator: ":"))", + "Try reinstalling or pinning a supported version (Node >=22.0.0).", + ].joined(separator: "\n") + } + } + + // MARK: - Internals + + private static func findExecutable(named name: String, searchPaths: [String]) -> String? { + let fm = FileManager() + for dir in searchPaths { + let candidate = (dir as NSString).appendingPathComponent(name) + if fm.isExecutableFile(atPath: candidate) { + return candidate + } + } + return nil + } + + private static func readVersion(of binary: String, pathEnv: String) -> String? { + let start = Date() + let process = Process() + process.executableURL = URL(fileURLWithPath: binary) + process.arguments = ["--version"] + process.environment = ["PATH": pathEnv] + + let pipe = Pipe() + process.standardOutput = pipe + process.standardError = pipe + + do { + let data = try process.runAndReadToEnd(from: pipe) + let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) + if elapsedMs > 500 { + self.logger.warning( + """ + runtime --version slow (\(elapsedMs, privacy: .public)ms) \ + bin=\(binary, privacy: .public) + """) + } else { + self.logger.debug( + """ + runtime --version ok (\(elapsedMs, privacy: .public)ms) \ + bin=\(binary, privacy: .public) + """) + } + return String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) + } catch { + let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) + self.logger.error( + """ + runtime --version failed (\(elapsedMs, privacy: .public)ms) \ + bin=\(binary, privacy: .public) \ + err=\(error.localizedDescription, privacy: .public) + """) + return nil + } + } +} + +extension RuntimeKind { + fileprivate var binaryName: String { "node" } +} diff --git a/apps/macos/Sources/Moltbot/ScreenRecordService.swift b/apps/macos/Sources/Moltbot/ScreenRecordService.swift new file mode 100644 index 000000000..a46f00780 --- /dev/null +++ b/apps/macos/Sources/Moltbot/ScreenRecordService.swift @@ -0,0 +1,266 @@ +import AVFoundation +import Foundation +import OSLog +@preconcurrency import ScreenCaptureKit + +@MainActor +final class ScreenRecordService { + enum ScreenRecordError: LocalizedError { + case noDisplays + case invalidScreenIndex(Int) + case noFramesCaptured + case writeFailed(String) + + var errorDescription: String? { + switch self { + case .noDisplays: + "No displays available for screen recording" + case let .invalidScreenIndex(idx): + "Invalid screen index \(idx)" + case .noFramesCaptured: + "No frames captured" + case let .writeFailed(msg): + msg + } + } + } + + private let logger = Logger(subsystem: "bot.molt", category: "screenRecord") + + func record( + screenIndex: Int?, + durationMs: Int?, + fps: Double?, + includeAudio: Bool?, + outPath: String?) async throws -> (path: String, hasAudio: Bool) + { + let durationMs = Self.clampDurationMs(durationMs) + let fps = Self.clampFps(fps) + let includeAudio = includeAudio ?? false + + let outURL: URL = { + if let outPath, !outPath.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { + return URL(fileURLWithPath: outPath) + } + return FileManager().temporaryDirectory + .appendingPathComponent("moltbot-screen-record-\(UUID().uuidString).mp4") + }() + try? FileManager().removeItem(at: outURL) + + let content = try await SCShareableContent.current + let displays = content.displays.sorted { $0.displayID < $1.displayID } + guard !displays.isEmpty else { throw ScreenRecordError.noDisplays } + + let idx = screenIndex ?? 0 + guard idx >= 0, idx < displays.count else { throw ScreenRecordError.invalidScreenIndex(idx) } + let display = displays[idx] + + let filter = SCContentFilter(display: display, excludingWindows: []) + let config = SCStreamConfiguration() + config.width = display.width + config.height = display.height + config.queueDepth = 8 + config.showsCursor = true + config.minimumFrameInterval = CMTime(value: 1, timescale: CMTimeScale(max(1, Int32(fps.rounded())))) + if includeAudio { + config.capturesAudio = true + } + + let recorder = try StreamRecorder( + outputURL: outURL, + width: display.width, + height: display.height, + includeAudio: includeAudio, + logger: self.logger) + + let stream = SCStream(filter: filter, configuration: config, delegate: recorder) + try stream.addStreamOutput(recorder, type: .screen, sampleHandlerQueue: recorder.queue) + if includeAudio { + try stream.addStreamOutput(recorder, type: .audio, sampleHandlerQueue: recorder.queue) + } + + self.logger.info( + "screen record start idx=\(idx) durationMs=\(durationMs) fps=\(fps) out=\(outURL.path, privacy: .public)") + + var started = false + do { + try await stream.startCapture() + started = true + try await Task.sleep(nanoseconds: UInt64(durationMs) * 1_000_000) + try await stream.stopCapture() + } catch { + if started { try? await stream.stopCapture() } + throw error + } + + try await recorder.finish() + return (path: outURL.path, hasAudio: recorder.hasAudio) + } + + private nonisolated static func clampDurationMs(_ ms: Int?) -> Int { + let v = ms ?? 10000 + return min(60000, max(250, v)) + } + + private nonisolated static func clampFps(_ fps: Double?) -> Double { + let v = fps ?? 10 + if !v.isFinite { return 10 } + return min(60, max(1, v)) + } +} + +private final class StreamRecorder: NSObject, SCStreamOutput, SCStreamDelegate, @unchecked Sendable { + let queue = DispatchQueue(label: "bot.molt.screenRecord.writer") + + private let logger: Logger + private let writer: AVAssetWriter + private let input: AVAssetWriterInput + private let audioInput: AVAssetWriterInput? + let hasAudio: Bool + + private var started = false + private var sawFrame = false + private var didFinish = false + private var pendingErrorMessage: String? + + init(outputURL: URL, width: Int, height: Int, includeAudio: Bool, logger: Logger) throws { + self.logger = logger + self.writer = try AVAssetWriter(outputURL: outputURL, fileType: .mp4) + + let settings: [String: Any] = [ + AVVideoCodecKey: AVVideoCodecType.h264, + AVVideoWidthKey: width, + AVVideoHeightKey: height, + ] + self.input = AVAssetWriterInput(mediaType: .video, outputSettings: settings) + self.input.expectsMediaDataInRealTime = true + + guard self.writer.canAdd(self.input) else { + throw ScreenRecordService.ScreenRecordError.writeFailed("Cannot add video input") + } + self.writer.add(self.input) + + if includeAudio { + let audioSettings: [String: Any] = [ + AVFormatIDKey: kAudioFormatMPEG4AAC, + AVNumberOfChannelsKey: 1, + AVSampleRateKey: 44100, + AVEncoderBitRateKey: 96000, + ] + let audioInput = AVAssetWriterInput(mediaType: .audio, outputSettings: audioSettings) + audioInput.expectsMediaDataInRealTime = true + if self.writer.canAdd(audioInput) { + self.writer.add(audioInput) + self.audioInput = audioInput + self.hasAudio = true + } else { + self.audioInput = nil + self.hasAudio = false + } + } else { + self.audioInput = nil + self.hasAudio = false + } + super.init() + } + + func stream(_ stream: SCStream, didStopWithError error: any Error) { + self.queue.async { + let msg = String(describing: error) + self.pendingErrorMessage = msg + self.logger.error("screen record stream stopped with error: \(msg, privacy: .public)") + _ = stream + } + } + + func stream( + _ stream: SCStream, + didOutputSampleBuffer sampleBuffer: CMSampleBuffer, + of type: SCStreamOutputType) + { + guard CMSampleBufferDataIsReady(sampleBuffer) else { return } + // Callback runs on `sampleHandlerQueue` (`self.queue`). + switch type { + case .screen: + self.handleVideo(sampleBuffer: sampleBuffer) + case .audio: + self.handleAudio(sampleBuffer: sampleBuffer) + case .microphone: + break + @unknown default: + break + } + _ = stream + } + + private func handleVideo(sampleBuffer: CMSampleBuffer) { + if let msg = self.pendingErrorMessage { + self.logger.error("screen record aborting due to prior error: \(msg, privacy: .public)") + return + } + if self.didFinish { return } + + if !self.started { + guard self.writer.startWriting() else { + self.pendingErrorMessage = self.writer.error?.localizedDescription ?? "Failed to start writer" + return + } + let pts = CMSampleBufferGetPresentationTimeStamp(sampleBuffer) + self.writer.startSession(atSourceTime: pts) + self.started = true + } + + self.sawFrame = true + if self.input.isReadyForMoreMediaData { + _ = self.input.append(sampleBuffer) + } + } + + private func handleAudio(sampleBuffer: CMSampleBuffer) { + guard let audioInput else { return } + if let msg = self.pendingErrorMessage { + self.logger.error("screen record audio aborting due to prior error: \(msg, privacy: .public)") + return + } + if self.didFinish || !self.started { return } + if audioInput.isReadyForMoreMediaData { + _ = audioInput.append(sampleBuffer) + } + } + + func finish() async throws { + try await withCheckedThrowingContinuation { (cont: CheckedContinuation) in + self.queue.async { + if let msg = self.pendingErrorMessage { + cont.resume(throwing: ScreenRecordService.ScreenRecordError.writeFailed(msg)) + return + } + guard self.started, self.sawFrame else { + cont.resume(throwing: ScreenRecordService.ScreenRecordError.noFramesCaptured) + return + } + if self.didFinish { + cont.resume() + return + } + self.didFinish = true + + self.input.markAsFinished() + self.audioInput?.markAsFinished() + self.writer.finishWriting { + if let err = self.writer.error { + cont + .resume(throwing: ScreenRecordService.ScreenRecordError + .writeFailed(err.localizedDescription)) + } else if self.writer.status != .completed { + cont + .resume(throwing: ScreenRecordService.ScreenRecordError + .writeFailed("Failed to finalize video")) + } else { + cont.resume() + } + } + } + } + } +} diff --git a/apps/macos/Sources/Moltbot/SessionMenuPreviewView.swift b/apps/macos/Sources/Moltbot/SessionMenuPreviewView.swift new file mode 100644 index 000000000..a60a9616c --- /dev/null +++ b/apps/macos/Sources/Moltbot/SessionMenuPreviewView.swift @@ -0,0 +1,495 @@ +import MoltbotChatUI +import MoltbotKit +import MoltbotProtocol +import OSLog +import SwiftUI + +struct SessionPreviewItem: Identifiable, Sendable { + let id: String + let role: PreviewRole + let text: String +} + +enum PreviewRole: String, Sendable { + case user + case assistant + case tool + case system + case other + + var label: String { + switch self { + case .user: "User" + case .assistant: "Agent" + case .tool: "Tool" + case .system: "System" + case .other: "Other" + } + } +} + +actor SessionPreviewCache { + static let shared = SessionPreviewCache() + + private struct CacheEntry { + let snapshot: SessionMenuPreviewSnapshot + let updatedAt: Date + } + + private var entries: [String: CacheEntry] = [:] + + func cachedSnapshot(for sessionKey: String, maxAge: TimeInterval) -> SessionMenuPreviewSnapshot? { + guard let entry = self.entries[sessionKey] else { return nil } + guard Date().timeIntervalSince(entry.updatedAt) < maxAge else { return nil } + return entry.snapshot + } + + func store(snapshot: SessionMenuPreviewSnapshot, for sessionKey: String) { + self.entries[sessionKey] = CacheEntry(snapshot: snapshot, updatedAt: Date()) + } + + func lastSnapshot(for sessionKey: String) -> SessionMenuPreviewSnapshot? { + self.entries[sessionKey]?.snapshot + } +} + +actor SessionPreviewLimiter { + static let shared = SessionPreviewLimiter(maxConcurrent: 2) + + private let maxConcurrent: Int + private var available: Int + private var waitQueue: [UUID] = [] + private var waiters: [UUID: CheckedContinuation] = [:] + + init(maxConcurrent: Int) { + let normalized = max(1, maxConcurrent) + self.maxConcurrent = normalized + self.available = normalized + } + + func withPermit(_ operation: () async throws -> T) async throws -> T { + await self.acquire() + defer { self.release() } + if Task.isCancelled { throw CancellationError() } + return try await operation() + } + + private func acquire() async { + if self.available > 0 { + self.available -= 1 + return + } + let id = UUID() + await withCheckedContinuation { cont in + self.waitQueue.append(id) + self.waiters[id] = cont + } + } + + private func release() { + if let id = self.waitQueue.first { + self.waitQueue.removeFirst() + if let cont = self.waiters.removeValue(forKey: id) { + cont.resume() + } + return + } + self.available = min(self.available + 1, self.maxConcurrent) + } +} + +#if DEBUG +extension SessionPreviewCache { + func _testSet( + snapshot: SessionMenuPreviewSnapshot, + for sessionKey: String, + updatedAt: Date = Date()) + { + self.entries[sessionKey] = CacheEntry(snapshot: snapshot, updatedAt: updatedAt) + } + + func _testReset() { + self.entries = [:] + } +} +#endif + +struct SessionMenuPreviewSnapshot: Sendable { + let items: [SessionPreviewItem] + let status: SessionMenuPreviewView.LoadStatus +} + +struct SessionMenuPreviewView: View { + let width: CGFloat + let maxLines: Int + let title: String + let items: [SessionPreviewItem] + let status: LoadStatus + + @Environment(\.menuItemHighlighted) private var isHighlighted + + enum LoadStatus: Equatable { + case loading + case ready + case empty + case error(String) + } + + private var primaryColor: Color { + if self.isHighlighted { + return Color(nsColor: .selectedMenuItemTextColor) + } + return Color(nsColor: .labelColor) + } + + private var secondaryColor: Color { + if self.isHighlighted { + return Color(nsColor: .selectedMenuItemTextColor).opacity(0.85) + } + return Color(nsColor: .secondaryLabelColor) + } + + var body: some View { + VStack(alignment: .leading, spacing: 8) { + HStack(alignment: .firstTextBaseline, spacing: 4) { + Text(self.title) + .font(.caption.weight(.semibold)) + .foregroundStyle(self.secondaryColor) + Spacer(minLength: 8) + } + + switch self.status { + case .loading: + self.placeholder("Loading preview…") + case .empty: + self.placeholder("No recent messages") + case let .error(message): + self.placeholder(message) + case .ready: + if self.items.isEmpty { + self.placeholder("No recent messages") + } else { + VStack(alignment: .leading, spacing: 6) { + ForEach(self.items) { item in + self.previewRow(item) + } + } + } + } + } + .padding(.vertical, 6) + .padding(.leading, 16) + .padding(.trailing, 11) + .frame(width: max(1, self.width), alignment: .leading) + } + + @ViewBuilder + private func previewRow(_ item: SessionPreviewItem) -> some View { + HStack(alignment: .top, spacing: 4) { + Text(item.role.label) + .font(.caption2.monospacedDigit()) + .foregroundStyle(self.roleColor(item.role)) + .frame(width: 50, alignment: .leading) + + Text(item.text) + .font(.caption) + .foregroundStyle(self.primaryColor) + .multilineTextAlignment(.leading) + .lineLimit(self.maxLines) + .truncationMode(.tail) + .fixedSize(horizontal: false, vertical: true) + } + } + + private func roleColor(_ role: PreviewRole) -> Color { + if self.isHighlighted { return Color(nsColor: .selectedMenuItemTextColor).opacity(0.9) } + switch role { + case .user: return .accentColor + case .assistant: return .secondary + case .tool: return .orange + case .system: return .gray + case .other: return .secondary + } + } + + @ViewBuilder + private func placeholder(_ text: String) -> some View { + Text(text) + .font(.caption) + .foregroundStyle(self.primaryColor) + } +} + +enum SessionMenuPreviewLoader { + private static let logger = Logger(subsystem: "bot.molt", category: "SessionPreview") + private static let previewTimeoutSeconds: Double = 4 + private static let cacheMaxAgeSeconds: TimeInterval = 30 + private static let previewMaxChars = 240 + + private struct PreviewTimeoutError: LocalizedError { + var errorDescription: String? { "preview timeout" } + } + + static func prewarm(sessionKeys: [String], maxItems: Int) async { + let keys = self.uniqueKeys(sessionKeys) + guard !keys.isEmpty else { return } + do { + let payload = try await self.requestPreview(keys: keys, maxItems: maxItems) + await self.cache(payload: payload, maxItems: maxItems) + } catch { + if self.isUnknownMethodError(error) { return } + let errorDescription = String(describing: error) + Self.logger.debug( + "Session preview prewarm failed count=\(keys.count, privacy: .public) " + + "error=\(errorDescription, privacy: .public)") + } + } + + static func load(sessionKey: String, maxItems: Int) async -> SessionMenuPreviewSnapshot { + if let cached = await SessionPreviewCache.shared.cachedSnapshot( + for: sessionKey, + maxAge: cacheMaxAgeSeconds) + { + return cached + } + + do { + let snapshot = try await self.fetchSnapshot(sessionKey: sessionKey, maxItems: maxItems) + await SessionPreviewCache.shared.store(snapshot: snapshot, for: sessionKey) + return snapshot + } catch is CancellationError { + return SessionMenuPreviewSnapshot(items: [], status: .loading) + } catch { + if let fallback = await SessionPreviewCache.shared.lastSnapshot(for: sessionKey) { + return fallback + } + let errorDescription = String(describing: error) + Self.logger.warning( + "Session preview failed session=\(sessionKey, privacy: .public) " + + "error=\(errorDescription, privacy: .public)") + return SessionMenuPreviewSnapshot(items: [], status: .error("Preview unavailable")) + } + } + + private static func fetchSnapshot(sessionKey: String, maxItems: Int) async throws -> SessionMenuPreviewSnapshot { + do { + let payload = try await self.requestPreview(keys: [sessionKey], maxItems: maxItems) + if let entry = payload.previews.first(where: { $0.key == sessionKey }) ?? payload.previews.first { + return self.snapshot(from: entry, maxItems: maxItems) + } + return SessionMenuPreviewSnapshot(items: [], status: .error("Preview unavailable")) + } catch { + if self.isUnknownMethodError(error) { + return try await self.fetchHistorySnapshot(sessionKey: sessionKey, maxItems: maxItems) + } + throw error + } + } + + private static func requestPreview( + keys: [String], + maxItems: Int) async throws -> MoltbotSessionsPreviewPayload + { + let boundedItems = self.normalizeMaxItems(maxItems) + let timeoutMs = Int(self.previewTimeoutSeconds * 1000) + return try await SessionPreviewLimiter.shared.withPermit { + try await AsyncTimeout.withTimeout( + seconds: self.previewTimeoutSeconds, + onTimeout: { PreviewTimeoutError() }, + operation: { + try await GatewayConnection.shared.sessionsPreview( + keys: keys, + limit: boundedItems, + maxChars: self.previewMaxChars, + timeoutMs: timeoutMs) + }) + } + } + + private static func fetchHistorySnapshot( + sessionKey: String, + maxItems: Int) async throws -> SessionMenuPreviewSnapshot + { + let timeoutMs = Int(self.previewTimeoutSeconds * 1000) + let payload = try await SessionPreviewLimiter.shared.withPermit { + try await AsyncTimeout.withTimeout( + seconds: self.previewTimeoutSeconds, + onTimeout: { PreviewTimeoutError() }, + operation: { + try await GatewayConnection.shared.chatHistory( + sessionKey: sessionKey, + limit: self.previewLimit(for: maxItems), + timeoutMs: timeoutMs) + }) + } + let built = Self.previewItems(from: payload, maxItems: maxItems) + return Self.snapshot(from: built) + } + + private static func snapshot(from items: [SessionPreviewItem]) -> SessionMenuPreviewSnapshot { + SessionMenuPreviewSnapshot(items: items, status: items.isEmpty ? .empty : .ready) + } + + private static func snapshot( + from entry: MoltbotSessionPreviewEntry, + maxItems: Int) -> SessionMenuPreviewSnapshot + { + let items = self.previewItems(from: entry, maxItems: maxItems) + let normalized = entry.status.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + switch normalized { + case "ok": + return SessionMenuPreviewSnapshot(items: items, status: items.isEmpty ? .empty : .ready) + case "empty": + return SessionMenuPreviewSnapshot(items: items, status: .empty) + case "missing": + return SessionMenuPreviewSnapshot(items: items, status: .error("Session missing")) + default: + return SessionMenuPreviewSnapshot(items: items, status: .error("Preview unavailable")) + } + } + + private static func cache(payload: MoltbotSessionsPreviewPayload, maxItems: Int) async { + for entry in payload.previews { + let snapshot = self.snapshot(from: entry, maxItems: maxItems) + await SessionPreviewCache.shared.store(snapshot: snapshot, for: entry.key) + } + } + + private static func previewLimit(for maxItems: Int) -> Int { + let boundedItems = self.normalizeMaxItems(maxItems) + return min(max(boundedItems * 3, 20), 120) + } + + private static func normalizeMaxItems(_ maxItems: Int) -> Int { + max(1, min(maxItems, 50)) + } + + private static func previewItems( + from entry: MoltbotSessionPreviewEntry, + maxItems: Int) -> [SessionPreviewItem] + { + let boundedItems = self.normalizeMaxItems(maxItems) + let built: [SessionPreviewItem] = entry.items.enumerated().compactMap { index, item in + let text = item.text.trimmingCharacters(in: .whitespacesAndNewlines) + guard !text.isEmpty else { return nil } + let role = self.previewRoleFromRaw(item.role) + return SessionPreviewItem(id: "\(entry.key)-\(index)", role: role, text: text) + } + + let trimmed = built.suffix(boundedItems) + return Array(trimmed.reversed()) + } + + private static func previewItems( + from payload: MoltbotChatHistoryPayload, + maxItems: Int) -> [SessionPreviewItem] + { + let boundedItems = self.normalizeMaxItems(maxItems) + let raw: [MoltbotKit.AnyCodable] = payload.messages ?? [] + let messages = self.decodeMessages(raw) + let built = messages.compactMap { message -> SessionPreviewItem? in + guard let text = self.previewText(for: message) else { return nil } + let isTool = self.isToolCall(message) + let role = self.previewRole(message.role, isTool: isTool) + let id = "\(message.timestamp ?? 0)-\(UUID().uuidString)" + return SessionPreviewItem(id: id, role: role, text: text) + } + + let trimmed = built.suffix(boundedItems) + return Array(trimmed.reversed()) + } + + private static func decodeMessages(_ raw: [MoltbotKit.AnyCodable]) -> [MoltbotChatMessage] { + raw.compactMap { item in + guard let data = try? JSONEncoder().encode(item) else { return nil } + return try? JSONDecoder().decode(MoltbotChatMessage.self, from: data) + } + } + + private static func previewRole(_ raw: String, isTool: Bool) -> PreviewRole { + if isTool { return .tool } + return self.previewRoleFromRaw(raw) + } + + private static func previewRoleFromRaw(_ raw: String) -> PreviewRole { + switch raw.lowercased() { + case "user": .user + case "assistant": .assistant + case "system": .system + case "tool": .tool + default: .other + } + } + + private static func previewText(for message: MoltbotChatMessage) -> String? { + let text = message.content.compactMap(\.text).joined(separator: "\n") + .trimmingCharacters(in: .whitespacesAndNewlines) + if !text.isEmpty { return text } + + let toolNames = self.toolNames(for: message) + if !toolNames.isEmpty { + let shown = toolNames.prefix(2) + let overflow = toolNames.count - shown.count + var label = "call \(shown.joined(separator: ", "))" + if overflow > 0 { label += " +\(overflow)" } + return label + } + + if let media = self.mediaSummary(for: message) { + return media + } + + return nil + } + + private static func isToolCall(_ message: MoltbotChatMessage) -> Bool { + if message.toolName?.nonEmpty != nil { return true } + return message.content.contains { $0.name?.nonEmpty != nil || $0.type?.lowercased() == "toolcall" } + } + + private static func toolNames(for message: MoltbotChatMessage) -> [String] { + var names: [String] = [] + for content in message.content { + if let name = content.name?.nonEmpty { + names.append(name) + } + } + if let toolName = message.toolName?.nonEmpty { + names.append(toolName) + } + return Self.dedupePreservingOrder(names) + } + + private static func mediaSummary(for message: MoltbotChatMessage) -> String? { + let types = message.content.compactMap { content -> String? in + let raw = content.type?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + guard let raw, !raw.isEmpty else { return nil } + if raw == "text" || raw == "toolcall" { return nil } + return raw + } + guard let first = types.first else { return nil } + return "[\(first)]" + } + + private static func dedupePreservingOrder(_ values: [String]) -> [String] { + var seen = Set() + var result: [String] = [] + for value in values where !seen.contains(value) { + seen.insert(value) + result.append(value) + } + return result + } + + private static func uniqueKeys(_ keys: [String]) -> [String] { + let trimmed = keys.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) } + return self.dedupePreservingOrder(trimmed.filter { !$0.isEmpty }) + } + + private static func isUnknownMethodError(_ error: Error) -> Bool { + guard let response = error as? GatewayResponseError else { return false } + guard response.code == ErrorCode.invalidRequest.rawValue else { return false } + let message = response.message.lowercased() + return message.contains("unknown method") + } +} diff --git a/apps/macos/Sources/Moltbot/TailscaleService.swift b/apps/macos/Sources/Moltbot/TailscaleService.swift new file mode 100644 index 000000000..299045e5a --- /dev/null +++ b/apps/macos/Sources/Moltbot/TailscaleService.swift @@ -0,0 +1,226 @@ +import AppKit +import Foundation +import Observation +import os +#if canImport(Darwin) +import Darwin +#endif + +/// Manages Tailscale integration and status checking. +@Observable +@MainActor +final class TailscaleService { + static let shared = TailscaleService() + + /// Tailscale local API endpoint. + private static let tailscaleAPIEndpoint = "http://100.100.100.100/api/data" + + /// API request timeout in seconds. + private static let apiTimeoutInterval: TimeInterval = 5.0 + + private let logger = Logger(subsystem: "bot.molt", category: "tailscale") + + /// Indicates if the Tailscale app is installed on the system. + private(set) var isInstalled = false + + /// Indicates if Tailscale is currently running. + private(set) var isRunning = false + + /// The Tailscale hostname for this device (e.g., "my-mac.tailnet.ts.net"). + private(set) var tailscaleHostname: String? + + /// The Tailscale IPv4 address for this device. + private(set) var tailscaleIP: String? + + /// Error message if status check fails. + private(set) var statusError: String? + + private init() { + Task { await self.checkTailscaleStatus() } + } + + #if DEBUG + init( + isInstalled: Bool, + isRunning: Bool, + tailscaleHostname: String? = nil, + tailscaleIP: String? = nil, + statusError: String? = nil) + { + self.isInstalled = isInstalled + self.isRunning = isRunning + self.tailscaleHostname = tailscaleHostname + self.tailscaleIP = tailscaleIP + self.statusError = statusError + } + #endif + + func checkAppInstallation() -> Bool { + let installed = FileManager().fileExists(atPath: "/Applications/Tailscale.app") + self.logger.info("Tailscale app installed: \(installed)") + return installed + } + + private struct TailscaleAPIResponse: Codable { + let status: String + let deviceName: String + let tailnetName: String + let iPv4: String? + + private enum CodingKeys: String, CodingKey { + case status = "Status" + case deviceName = "DeviceName" + case tailnetName = "TailnetName" + case iPv4 = "IPv4" + } + } + + private func fetchTailscaleStatus() async -> TailscaleAPIResponse? { + guard let url = URL(string: Self.tailscaleAPIEndpoint) else { + self.logger.error("Invalid Tailscale API URL") + return nil + } + + do { + let configuration = URLSessionConfiguration.default + configuration.timeoutIntervalForRequest = Self.apiTimeoutInterval + let session = URLSession(configuration: configuration) + + let (data, response) = try await session.data(from: url) + guard let httpResponse = response as? HTTPURLResponse, + httpResponse.statusCode == 200 + else { + self.logger.warning("Tailscale API returned non-200 status") + return nil + } + + let decoder = JSONDecoder() + return try decoder.decode(TailscaleAPIResponse.self, from: data) + } catch { + self.logger.debug("Failed to fetch Tailscale status: \(String(describing: error))") + return nil + } + } + + func checkTailscaleStatus() async { + let previousIP = self.tailscaleIP + self.isInstalled = self.checkAppInstallation() + if !self.isInstalled { + self.isRunning = false + self.tailscaleHostname = nil + self.tailscaleIP = nil + self.statusError = "Tailscale is not installed" + } else if let apiResponse = await fetchTailscaleStatus() { + self.isRunning = apiResponse.status.lowercased() == "running" + + if self.isRunning { + let deviceName = apiResponse.deviceName + .lowercased() + .replacingOccurrences(of: " ", with: "-") + let tailnetName = apiResponse.tailnetName + .replacingOccurrences(of: ".ts.net", with: "") + .replacingOccurrences(of: ".tailscale.net", with: "") + + self.tailscaleHostname = "\(deviceName).\(tailnetName).ts.net" + self.tailscaleIP = apiResponse.iPv4 + self.statusError = nil + + self.logger.info( + "Tailscale running host=\(self.tailscaleHostname ?? "nil") ip=\(self.tailscaleIP ?? "nil")") + } else { + self.tailscaleHostname = nil + self.tailscaleIP = nil + self.statusError = "Tailscale is not running" + } + } else { + self.isRunning = false + self.tailscaleHostname = nil + self.tailscaleIP = nil + self.statusError = "Please start the Tailscale app" + self.logger.info("Tailscale API not responding; app likely not running") + } + + if self.tailscaleIP == nil, let fallback = Self.detectTailnetIPv4() { + self.tailscaleIP = fallback + if !self.isRunning { + self.isRunning = true + } + self.statusError = nil + self.logger.info("Tailscale interface IP detected (fallback) ip=\(fallback, privacy: .public)") + } + + if previousIP != self.tailscaleIP { + await GatewayEndpointStore.shared.refresh() + } + } + + func openTailscaleApp() { + if let url = URL(string: "file:///Applications/Tailscale.app") { + NSWorkspace.shared.open(url) + } + } + + func openAppStore() { + if let url = URL(string: "https://apps.apple.com/us/app/tailscale/id1475387142") { + NSWorkspace.shared.open(url) + } + } + + func openDownloadPage() { + if let url = URL(string: "https://tailscale.com/download/macos") { + NSWorkspace.shared.open(url) + } + } + + func openSetupGuide() { + if let url = URL(string: "https://tailscale.com/kb/1017/install/") { + NSWorkspace.shared.open(url) + } + } + + private nonisolated static func isTailnetIPv4(_ address: String) -> Bool { + let parts = address.split(separator: ".") + guard parts.count == 4 else { return false } + let octets = parts.compactMap { Int($0) } + guard octets.count == 4 else { return false } + let a = octets[0] + let b = octets[1] + return a == 100 && b >= 64 && b <= 127 + } + + private nonisolated static func detectTailnetIPv4() -> String? { + var addrList: UnsafeMutablePointer? + guard getifaddrs(&addrList) == 0, let first = addrList else { return nil } + defer { freeifaddrs(addrList) } + + for ptr in sequence(first: first, next: { $0.pointee.ifa_next }) { + let flags = Int32(ptr.pointee.ifa_flags) + let isUp = (flags & IFF_UP) != 0 + let isLoopback = (flags & IFF_LOOPBACK) != 0 + let family = ptr.pointee.ifa_addr.pointee.sa_family + if !isUp || isLoopback || family != UInt8(AF_INET) { continue } + + var addr = ptr.pointee.ifa_addr.pointee + var buffer = [CChar](repeating: 0, count: Int(NI_MAXHOST)) + let result = getnameinfo( + &addr, + socklen_t(ptr.pointee.ifa_addr.pointee.sa_len), + &buffer, + socklen_t(buffer.count), + nil, + 0, + NI_NUMERICHOST) + guard result == 0 else { continue } + let len = buffer.prefix { $0 != 0 } + let bytes = len.map { UInt8(bitPattern: $0) } + guard let ip = String(bytes: bytes, encoding: .utf8) else { continue } + if Self.isTailnetIPv4(ip) { return ip } + } + + return nil + } + + nonisolated static func fallbackTailnetIPv4() -> String? { + self.detectTailnetIPv4() + } +} diff --git a/apps/macos/Sources/Moltbot/TalkAudioPlayer.swift b/apps/macos/Sources/Moltbot/TalkAudioPlayer.swift new file mode 100644 index 000000000..b137994a3 --- /dev/null +++ b/apps/macos/Sources/Moltbot/TalkAudioPlayer.swift @@ -0,0 +1,158 @@ +import AVFoundation +import Foundation +import OSLog + +@MainActor +final class TalkAudioPlayer: NSObject, @preconcurrency AVAudioPlayerDelegate { + static let shared = TalkAudioPlayer() + + private let logger = Logger(subsystem: "bot.molt", category: "talk.tts") + private var player: AVAudioPlayer? + private var playback: Playback? + + private final class Playback: @unchecked Sendable { + private let lock = NSLock() + private var finished = false + private var continuation: CheckedContinuation? + private var watchdog: Task? + + func setContinuation(_ continuation: CheckedContinuation) { + self.lock.lock() + defer { self.lock.unlock() } + self.continuation = continuation + } + + func setWatchdog(_ task: Task?) { + self.lock.lock() + let old = self.watchdog + self.watchdog = task + self.lock.unlock() + old?.cancel() + } + + func cancelWatchdog() { + self.setWatchdog(nil) + } + + func finish(_ result: TalkPlaybackResult) { + let continuation: CheckedContinuation? + self.lock.lock() + if self.finished { + continuation = nil + } else { + self.finished = true + continuation = self.continuation + self.continuation = nil + } + self.lock.unlock() + continuation?.resume(returning: result) + } + } + + func play(data: Data) async -> TalkPlaybackResult { + self.stopInternal() + + let playback = Playback() + self.playback = playback + + return await withCheckedContinuation { continuation in + playback.setContinuation(continuation) + do { + let player = try AVAudioPlayer(data: data) + self.player = player + + player.delegate = self + player.prepareToPlay() + + self.armWatchdog(playback: playback) + + let ok = player.play() + if !ok { + self.logger.error("talk audio player refused to play") + self.finish(playback: playback, result: TalkPlaybackResult(finished: false, interruptedAt: nil)) + } + } catch { + self.logger.error("talk audio player failed: \(error.localizedDescription, privacy: .public)") + self.finish(playback: playback, result: TalkPlaybackResult(finished: false, interruptedAt: nil)) + } + } + } + + func stop() -> Double? { + guard let player else { return nil } + let time = player.currentTime + self.stopInternal(interruptedAt: time) + return time + } + + func audioPlayerDidFinishPlaying(_: AVAudioPlayer, successfully flag: Bool) { + self.stopInternal(finished: flag) + } + + private func stopInternal(finished: Bool = false, interruptedAt: Double? = nil) { + guard let playback else { return } + let result = TalkPlaybackResult(finished: finished, interruptedAt: interruptedAt) + self.finish(playback: playback, result: result) + } + + private func finish(playback: Playback, result: TalkPlaybackResult) { + playback.cancelWatchdog() + playback.finish(result) + + guard self.playback === playback else { return } + self.playback = nil + self.player?.stop() + self.player = nil + } + + private func stopInternal() { + if let playback = self.playback { + let interruptedAt = self.player?.currentTime + self.finish( + playback: playback, + result: TalkPlaybackResult(finished: false, interruptedAt: interruptedAt)) + return + } + self.player?.stop() + self.player = nil + } + + private func armWatchdog(playback: Playback) { + playback.setWatchdog(Task { @MainActor [weak self] in + guard let self else { return } + + do { + try await Task.sleep(nanoseconds: 650_000_000) + } catch { + return + } + if Task.isCancelled { return } + + guard self.playback === playback else { return } + if self.player?.isPlaying != true { + self.logger.error("talk audio player did not start playing") + self.finish(playback: playback, result: TalkPlaybackResult(finished: false, interruptedAt: nil)) + return + } + + let duration = self.player?.duration ?? 0 + let timeoutSeconds = min(max(2.0, duration + 2.0), 5 * 60.0) + do { + try await Task.sleep(nanoseconds: UInt64(timeoutSeconds * 1_000_000_000)) + } catch { + return + } + if Task.isCancelled { return } + + guard self.playback === playback else { return } + guard self.player?.isPlaying == true else { return } + self.logger.error("talk audio player watchdog fired") + self.finish(playback: playback, result: TalkPlaybackResult(finished: false, interruptedAt: nil)) + }) + } +} + +struct TalkPlaybackResult: Sendable { + let finished: Bool + let interruptedAt: Double? +} diff --git a/apps/macos/Sources/Moltbot/TalkModeController.swift b/apps/macos/Sources/Moltbot/TalkModeController.swift new file mode 100644 index 000000000..89eac593b --- /dev/null +++ b/apps/macos/Sources/Moltbot/TalkModeController.swift @@ -0,0 +1,69 @@ +import Observation + +@MainActor +@Observable +final class TalkModeController { + static let shared = TalkModeController() + + private let logger = Logger(subsystem: "bot.molt", category: "talk.controller") + + private(set) var phase: TalkModePhase = .idle + private(set) var isPaused: Bool = false + + func setEnabled(_ enabled: Bool) async { + self.logger.info("talk enabled=\(enabled)") + if enabled { + TalkOverlayController.shared.present() + } else { + TalkOverlayController.shared.dismiss() + } + await TalkModeRuntime.shared.setEnabled(enabled) + } + + func updatePhase(_ phase: TalkModePhase) { + self.phase = phase + TalkOverlayController.shared.updatePhase(phase) + let effectivePhase = self.isPaused ? "paused" : phase.rawValue + Task { + await GatewayConnection.shared.talkMode( + enabled: AppStateStore.shared.talkEnabled, + phase: effectivePhase) + } + } + + func updateLevel(_ level: Double) { + TalkOverlayController.shared.updateLevel(level) + } + + func setPaused(_ paused: Bool) { + guard self.isPaused != paused else { return } + self.logger.info("talk paused=\(paused)") + self.isPaused = paused + TalkOverlayController.shared.updatePaused(paused) + let effectivePhase = paused ? "paused" : self.phase.rawValue + Task { + await GatewayConnection.shared.talkMode( + enabled: AppStateStore.shared.talkEnabled, + phase: effectivePhase) + } + Task { await TalkModeRuntime.shared.setPaused(paused) } + } + + func togglePaused() { + self.setPaused(!self.isPaused) + } + + func stopSpeaking(reason: TalkStopReason = .userTap) { + Task { await TalkModeRuntime.shared.stopSpeaking(reason: reason) } + } + + func exitTalkMode() { + Task { await AppStateStore.shared.setTalkEnabled(false) } + } +} + +enum TalkStopReason { + case userTap + case speech + case manual +} diff --git a/apps/macos/Sources/Moltbot/TalkModeRuntime.swift b/apps/macos/Sources/Moltbot/TalkModeRuntime.swift new file mode 100644 index 000000000..5c33cdb34 --- /dev/null +++ b/apps/macos/Sources/Moltbot/TalkModeRuntime.swift @@ -0,0 +1,953 @@ +import AVFoundation +import MoltbotChatUI +import MoltbotKit +import Foundation +import OSLog +import Speech + +actor TalkModeRuntime { + static let shared = TalkModeRuntime() + + private let logger = Logger(subsystem: "bot.molt", category: "talk.runtime") + private let ttsLogger = Logger(subsystem: "bot.molt", category: "talk.tts") + private static let defaultModelIdFallback = "eleven_v3" + + private final class RMSMeter: @unchecked Sendable { + private let lock = NSLock() + private var latestRMS: Double = 0 + + func set(_ rms: Double) { + self.lock.lock() + self.latestRMS = rms + self.lock.unlock() + } + + func get() -> Double { + self.lock.lock() + let value = self.latestRMS + self.lock.unlock() + return value + } + } + + private var recognizer: SFSpeechRecognizer? + private var audioEngine: AVAudioEngine? + private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest? + private var recognitionTask: SFSpeechRecognitionTask? + private var recognitionGeneration: Int = 0 + private var rmsTask: Task? + private let rmsMeter = RMSMeter() + + private var captureTask: Task? + private var silenceTask: Task? + private var phase: TalkModePhase = .idle + private var isEnabled = false + private var isPaused = false + private var lifecycleGeneration: Int = 0 + + private var lastHeard: Date? + private var noiseFloorRMS: Double = 1e-4 + private var lastTranscript: String = "" + private var lastSpeechEnergyAt: Date? + + private var defaultVoiceId: String? + private var currentVoiceId: String? + private var defaultModelId: String? + private var currentModelId: String? + private var voiceOverrideActive = false + private var modelOverrideActive = false + private var defaultOutputFormat: String? + private var interruptOnSpeech: Bool = true + private var lastInterruptedAtSeconds: Double? + private var voiceAliases: [String: String] = [:] + private var lastSpokenText: String? + private var apiKey: String? + private var fallbackVoiceId: String? + private var lastPlaybackWasPCM: Bool = false + + private let silenceWindow: TimeInterval = 0.7 + private let minSpeechRMS: Double = 1e-3 + private let speechBoostFactor: Double = 6.0 + + // MARK: - Lifecycle + + func setEnabled(_ enabled: Bool) async { + guard enabled != self.isEnabled else { return } + self.isEnabled = enabled + self.lifecycleGeneration &+= 1 + if enabled { + await self.start() + } else { + await self.stop() + } + } + + func setPaused(_ paused: Bool) async { + guard paused != self.isPaused else { return } + self.isPaused = paused + await MainActor.run { TalkModeController.shared.updateLevel(0) } + + guard self.isEnabled else { return } + + if paused { + self.lastTranscript = "" + self.lastHeard = nil + self.lastSpeechEnergyAt = nil + await self.stopRecognition() + return + } + + if self.phase == .idle || self.phase == .listening { + await self.startRecognition() + self.phase = .listening + await MainActor.run { TalkModeController.shared.updatePhase(.listening) } + self.startSilenceMonitor() + } + } + + private func isCurrent(_ generation: Int) -> Bool { + generation == self.lifecycleGeneration && self.isEnabled + } + + private func start() async { + let gen = self.lifecycleGeneration + guard voiceWakeSupported else { return } + guard PermissionManager.voiceWakePermissionsGranted() else { + self.logger.debug("talk runtime not starting: permissions missing") + return + } + await self.reloadConfig() + guard self.isCurrent(gen) else { return } + if self.isPaused { + self.phase = .idle + await MainActor.run { + TalkModeController.shared.updateLevel(0) + TalkModeController.shared.updatePhase(.idle) + } + return + } + await self.startRecognition() + guard self.isCurrent(gen) else { return } + self.phase = .listening + await MainActor.run { TalkModeController.shared.updatePhase(.listening) } + self.startSilenceMonitor() + } + + private func stop() async { + self.captureTask?.cancel() + self.captureTask = nil + self.silenceTask?.cancel() + self.silenceTask = nil + + // Stop audio before changing phase (stopSpeaking is gated on .speaking). + await self.stopSpeaking(reason: .manual) + + self.lastTranscript = "" + self.lastHeard = nil + self.lastSpeechEnergyAt = nil + self.phase = .idle + await self.stopRecognition() + await MainActor.run { + TalkModeController.shared.updateLevel(0) + TalkModeController.shared.updatePhase(.idle) + } + } + + // MARK: - Speech recognition + + private struct RecognitionUpdate { + let transcript: String? + let hasConfidence: Bool + let isFinal: Bool + let errorDescription: String? + let generation: Int + } + + private func startRecognition() async { + await self.stopRecognition() + self.recognitionGeneration &+= 1 + let generation = self.recognitionGeneration + + let locale = await MainActor.run { AppStateStore.shared.voiceWakeLocaleID } + self.recognizer = SFSpeechRecognizer(locale: Locale(identifier: locale)) + guard let recognizer, recognizer.isAvailable else { + self.logger.error("talk recognizer unavailable") + return + } + + self.recognitionRequest = SFSpeechAudioBufferRecognitionRequest() + self.recognitionRequest?.shouldReportPartialResults = true + guard let request = self.recognitionRequest else { return } + + if self.audioEngine == nil { + self.audioEngine = AVAudioEngine() + } + guard let audioEngine = self.audioEngine else { return } + + let input = audioEngine.inputNode + let format = input.outputFormat(forBus: 0) + input.removeTap(onBus: 0) + let meter = self.rmsMeter + input.installTap(onBus: 0, bufferSize: 2048, format: format) { [weak request, meter] buffer, _ in + request?.append(buffer) + if let rms = Self.rmsLevel(buffer: buffer) { + meter.set(rms) + } + } + + audioEngine.prepare() + do { + try audioEngine.start() + } catch { + self.logger.error("talk audio engine start failed: \(error.localizedDescription, privacy: .public)") + return + } + + self.startRMSTicker(meter: meter) + + self.recognitionTask = recognizer.recognitionTask(with: request) { [weak self, generation] result, error in + guard let self else { return } + let segments = result?.bestTranscription.segments ?? [] + let transcript = result?.bestTranscription.formattedString + let update = RecognitionUpdate( + transcript: transcript, + hasConfidence: segments.contains { $0.confidence > 0.6 }, + isFinal: result?.isFinal ?? false, + errorDescription: error?.localizedDescription, + generation: generation) + Task { await self.handleRecognition(update) } + } + } + + private func stopRecognition() async { + self.recognitionGeneration &+= 1 + self.recognitionTask?.cancel() + self.recognitionTask = nil + self.recognitionRequest?.endAudio() + self.recognitionRequest = nil + self.audioEngine?.inputNode.removeTap(onBus: 0) + self.audioEngine?.stop() + self.audioEngine = nil + self.recognizer = nil + self.rmsTask?.cancel() + self.rmsTask = nil + } + + private func startRMSTicker(meter: RMSMeter) { + self.rmsTask?.cancel() + self.rmsTask = Task { [weak self, meter] in + while let self { + try? await Task.sleep(nanoseconds: 50_000_000) + if Task.isCancelled { return } + await self.noteAudioLevel(rms: meter.get()) + } + } + } + + private func handleRecognition(_ update: RecognitionUpdate) async { + guard update.generation == self.recognitionGeneration else { return } + guard !self.isPaused else { return } + if let errorDescription = update.errorDescription { + self.logger.debug("talk recognition error: \(errorDescription, privacy: .public)") + } + guard let transcript = update.transcript else { return } + + let trimmed = transcript.trimmingCharacters(in: .whitespacesAndNewlines) + if self.phase == .speaking, self.interruptOnSpeech { + if await self.shouldInterrupt(transcript: trimmed, hasConfidence: update.hasConfidence) { + await self.stopSpeaking(reason: .speech) + self.lastTranscript = "" + self.lastHeard = nil + await self.startListening() + } + return + } + + guard self.phase == .listening else { return } + + if !trimmed.isEmpty { + self.lastTranscript = trimmed + self.lastHeard = Date() + } + + if update.isFinal { + self.lastTranscript = trimmed + } + } + + // MARK: - Silence handling + + private func startSilenceMonitor() { + self.silenceTask?.cancel() + self.silenceTask = Task { [weak self] in + await self?.silenceLoop() + } + } + + private func silenceLoop() async { + while self.isEnabled { + try? await Task.sleep(nanoseconds: 200_000_000) + await self.checkSilence() + } + } + + private func checkSilence() async { + guard !self.isPaused else { return } + guard self.phase == .listening else { return } + let transcript = self.lastTranscript.trimmingCharacters(in: .whitespacesAndNewlines) + guard !transcript.isEmpty else { return } + guard let lastHeard else { return } + let elapsed = Date().timeIntervalSince(lastHeard) + guard elapsed >= self.silenceWindow else { return } + await self.finalizeTranscript(transcript) + } + + private func startListening() async { + self.phase = .listening + self.lastTranscript = "" + self.lastHeard = nil + await MainActor.run { + TalkModeController.shared.updatePhase(.listening) + TalkModeController.shared.updateLevel(0) + } + } + + private func finalizeTranscript(_ text: String) async { + self.lastTranscript = "" + self.lastHeard = nil + self.phase = .thinking + await MainActor.run { TalkModeController.shared.updatePhase(.thinking) } + await self.stopRecognition() + await self.sendAndSpeak(text) + } + + // MARK: - Gateway + TTS + + private func sendAndSpeak(_ transcript: String) async { + let gen = self.lifecycleGeneration + await self.reloadConfig() + guard self.isCurrent(gen) else { return } + let prompt = self.buildPrompt(transcript: transcript) + let activeSessionKey = await MainActor.run { WebChatManager.shared.activeSessionKey } + let sessionKey: String = if let activeSessionKey { + activeSessionKey + } else { + await GatewayConnection.shared.mainSessionKey() + } + let runId = UUID().uuidString + let startedAt = Date().timeIntervalSince1970 + self.logger.info( + "talk send start runId=\(runId, privacy: .public) " + + "session=\(sessionKey, privacy: .public) " + + "chars=\(prompt.count, privacy: .public)") + + do { + let response = try await GatewayConnection.shared.chatSend( + sessionKey: sessionKey, + message: prompt, + thinking: "low", + idempotencyKey: runId, + attachments: []) + guard self.isCurrent(gen) else { return } + self.logger.info( + "talk chat.send ok runId=\(response.runId, privacy: .public) " + + "session=\(sessionKey, privacy: .public)") + + guard let assistantText = await self.waitForAssistantText( + sessionKey: sessionKey, + since: startedAt, + timeoutSeconds: 45) + else { + self.logger.warning("talk assistant text missing after timeout") + await self.startListening() + await self.startRecognition() + return + } + guard self.isCurrent(gen) else { return } + + self.logger.info("talk assistant text len=\(assistantText.count, privacy: .public)") + await self.playAssistant(text: assistantText) + guard self.isCurrent(gen) else { return } + await self.resumeListeningIfNeeded() + return + } catch { + self.logger.error("talk chat.send failed: \(error.localizedDescription, privacy: .public)") + await self.resumeListeningIfNeeded() + return + } + } + + private func resumeListeningIfNeeded() async { + if self.isPaused { + self.lastTranscript = "" + self.lastHeard = nil + self.lastSpeechEnergyAt = nil + await MainActor.run { + TalkModeController.shared.updateLevel(0) + } + return + } + await self.startListening() + await self.startRecognition() + } + + private func buildPrompt(transcript: String) -> String { + let interrupted = self.lastInterruptedAtSeconds + self.lastInterruptedAtSeconds = nil + return TalkPromptBuilder.build(transcript: transcript, interruptedAtSeconds: interrupted) + } + + private func waitForAssistantText( + sessionKey: String, + since: Double, + timeoutSeconds: Int) async -> String? + { + let deadline = Date().addingTimeInterval(TimeInterval(timeoutSeconds)) + while Date() < deadline { + if let text = await self.latestAssistantText(sessionKey: sessionKey, since: since) { + return text + } + try? await Task.sleep(nanoseconds: 300_000_000) + } + return nil + } + + private func latestAssistantText(sessionKey: String, since: Double? = nil) async -> String? { + do { + let history = try await GatewayConnection.shared.chatHistory(sessionKey: sessionKey) + let messages = history.messages ?? [] + let decoded: [MoltbotChatMessage] = messages.compactMap { item in + guard let data = try? JSONEncoder().encode(item) else { return nil } + return try? JSONDecoder().decode(MoltbotChatMessage.self, from: data) + } + let assistant = decoded.last { message in + guard message.role == "assistant" else { return false } + guard let since else { return true } + guard let timestamp = message.timestamp else { return false } + return TalkHistoryTimestamp.isAfter(timestamp, sinceSeconds: since) + } + guard let assistant else { return nil } + let text = assistant.content.compactMap(\.text).joined(separator: "\n") + let trimmed = text.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) + return trimmed.isEmpty ? nil : trimmed + } catch { + self.logger.error("talk history fetch failed: \(error.localizedDescription, privacy: .public)") + return nil + } + } + + private func playAssistant(text: String) async { + guard let input = await self.preparePlaybackInput(text: text) else { return } + do { + if let apiKey = input.apiKey, !apiKey.isEmpty, let voiceId = input.voiceId { + try await self.playElevenLabs(input: input, apiKey: apiKey, voiceId: voiceId) + } else { + try await self.playSystemVoice(input: input) + } + } catch { + self.ttsLogger + .error( + "talk TTS failed: \(error.localizedDescription, privacy: .public); " + + "falling back to system voice") + do { + try await self.playSystemVoice(input: input) + } catch { + self.ttsLogger.error("talk system voice failed: \(error.localizedDescription, privacy: .public)") + } + } + + if self.phase == .speaking { + self.phase = .thinking + await MainActor.run { TalkModeController.shared.updatePhase(.thinking) } + } + } + + private struct TalkPlaybackInput { + let generation: Int + let cleanedText: String + let directive: TalkDirective? + let apiKey: String? + let voiceId: String? + let language: String? + let synthTimeoutSeconds: Double + } + + private func preparePlaybackInput(text: String) async -> TalkPlaybackInput? { + let gen = self.lifecycleGeneration + let parse = TalkDirectiveParser.parse(text) + let directive = parse.directive + let cleaned = parse.stripped.trimmingCharacters(in: .whitespacesAndNewlines) + guard !cleaned.isEmpty else { return nil } + guard self.isCurrent(gen) else { return nil } + + if !parse.unknownKeys.isEmpty { + self.logger + .warning( + "talk directive ignored keys: " + + "\(parse.unknownKeys.joined(separator: ","), privacy: .public)") + } + + let requestedVoice = directive?.voiceId?.trimmingCharacters(in: .whitespacesAndNewlines) + let resolvedVoice = self.resolveVoiceAlias(requestedVoice) + if let requestedVoice, !requestedVoice.isEmpty, resolvedVoice == nil { + self.logger.warning("talk unknown voice alias \(requestedVoice, privacy: .public)") + } + if let voice = resolvedVoice { + if directive?.once == true { + self.logger.info("talk voice override (once) voiceId=\(voice, privacy: .public)") + } else { + self.currentVoiceId = voice + self.voiceOverrideActive = true + self.logger.info("talk voice override voiceId=\(voice, privacy: .public)") + } + } + + if let model = directive?.modelId { + if directive?.once == true { + self.logger.info("talk model override (once) modelId=\(model, privacy: .public)") + } else { + self.currentModelId = model + self.modelOverrideActive = true + } + } + + let apiKey = self.apiKey?.trimmingCharacters(in: .whitespacesAndNewlines) + let preferredVoice = + resolvedVoice ?? + self.currentVoiceId ?? + self.defaultVoiceId + + let language = ElevenLabsTTSClient.validatedLanguage(directive?.language) + + let voiceId: String? = if let apiKey, !apiKey.isEmpty { + await self.resolveVoiceId(preferred: preferredVoice, apiKey: apiKey) + } else { + nil + } + + if apiKey?.isEmpty != false { + self.ttsLogger.warning("talk missing ELEVENLABS_API_KEY; falling back to system voice") + } else if voiceId == nil { + self.ttsLogger.warning("talk missing voiceId; falling back to system voice") + } else if let voiceId { + self.ttsLogger + .info( + "talk TTS request voiceId=\(voiceId, privacy: .public) " + + "chars=\(cleaned.count, privacy: .public)") + } + self.lastSpokenText = cleaned + + let synthTimeoutSeconds = max(20.0, min(90.0, Double(cleaned.count) * 0.12)) + + guard self.isCurrent(gen) else { return nil } + + return TalkPlaybackInput( + generation: gen, + cleanedText: cleaned, + directive: directive, + apiKey: apiKey, + voiceId: voiceId, + language: language, + synthTimeoutSeconds: synthTimeoutSeconds) + } + + private func playElevenLabs(input: TalkPlaybackInput, apiKey: String, voiceId: String) async throws { + let desiredOutputFormat = input.directive?.outputFormat ?? self.defaultOutputFormat ?? "pcm_44100" + let outputFormat = ElevenLabsTTSClient.validatedOutputFormat(desiredOutputFormat) + if outputFormat == nil, !desiredOutputFormat.isEmpty { + self.logger + .warning( + "talk output_format unsupported for local playback: " + + "\(desiredOutputFormat, privacy: .public)") + } + + let modelId = input.directive?.modelId ?? self.currentModelId ?? self.defaultModelId + func makeRequest(outputFormat: String?) -> ElevenLabsTTSRequest { + ElevenLabsTTSRequest( + text: input.cleanedText, + modelId: modelId, + outputFormat: outputFormat, + speed: TalkTTSValidation.resolveSpeed( + speed: input.directive?.speed, + rateWPM: input.directive?.rateWPM), + stability: TalkTTSValidation.validatedStability( + input.directive?.stability, + modelId: modelId), + similarity: TalkTTSValidation.validatedUnit(input.directive?.similarity), + style: TalkTTSValidation.validatedUnit(input.directive?.style), + speakerBoost: input.directive?.speakerBoost, + seed: TalkTTSValidation.validatedSeed(input.directive?.seed), + normalize: ElevenLabsTTSClient.validatedNormalize(input.directive?.normalize), + language: input.language, + latencyTier: TalkTTSValidation.validatedLatencyTier(input.directive?.latencyTier)) + } + + let request = makeRequest(outputFormat: outputFormat) + self.ttsLogger.info("talk TTS synth timeout=\(input.synthTimeoutSeconds, privacy: .public)s") + let client = ElevenLabsTTSClient(apiKey: apiKey) + let stream = client.streamSynthesize(voiceId: voiceId, request: request) + guard self.isCurrent(input.generation) else { return } + + if self.interruptOnSpeech { + guard await self.prepareForPlayback(generation: input.generation) else { return } + } + + await MainActor.run { TalkModeController.shared.updatePhase(.speaking) } + self.phase = .speaking + + let result = await self.playRemoteStream( + client: client, + voiceId: voiceId, + outputFormat: outputFormat, + makeRequest: makeRequest, + stream: stream) + self.ttsLogger + .info( + "talk audio result finished=\(result.finished, privacy: .public) " + + "interruptedAt=\(String(describing: result.interruptedAt), privacy: .public)") + if !result.finished, result.interruptedAt == nil { + throw NSError(domain: "StreamingAudioPlayer", code: 1, userInfo: [ + NSLocalizedDescriptionKey: "audio playback failed", + ]) + } + if !result.finished, let interruptedAt = result.interruptedAt, self.phase == .speaking { + if self.interruptOnSpeech { + self.lastInterruptedAtSeconds = interruptedAt + } + } + } + + private func playRemoteStream( + client: ElevenLabsTTSClient, + voiceId: String, + outputFormat: String?, + makeRequest: (String?) -> ElevenLabsTTSRequest, + stream: AsyncThrowingStream) async -> StreamingPlaybackResult + { + let sampleRate = TalkTTSValidation.pcmSampleRate(from: outputFormat) + if let sampleRate { + self.lastPlaybackWasPCM = true + let result = await self.playPCM(stream: stream, sampleRate: sampleRate) + if result.finished || result.interruptedAt != nil { + return result + } + let mp3Format = ElevenLabsTTSClient.validatedOutputFormat("mp3_44100") + self.ttsLogger.warning("talk pcm playback failed; retrying mp3") + self.lastPlaybackWasPCM = false + let mp3Stream = client.streamSynthesize( + voiceId: voiceId, + request: makeRequest(mp3Format)) + return await self.playMP3(stream: mp3Stream) + } + self.lastPlaybackWasPCM = false + return await self.playMP3(stream: stream) + } + + private func playSystemVoice(input: TalkPlaybackInput) async throws { + self.ttsLogger.info("talk system voice start chars=\(input.cleanedText.count, privacy: .public)") + if self.interruptOnSpeech { + guard await self.prepareForPlayback(generation: input.generation) else { return } + } + await MainActor.run { TalkModeController.shared.updatePhase(.speaking) } + self.phase = .speaking + await TalkSystemSpeechSynthesizer.shared.stop() + try await TalkSystemSpeechSynthesizer.shared.speak( + text: input.cleanedText, + language: input.language) + self.ttsLogger.info("talk system voice done") + } + + private func prepareForPlayback(generation: Int) async -> Bool { + await self.startRecognition() + return self.isCurrent(generation) + } + + private func resolveVoiceId(preferred: String?, apiKey: String) async -> String? { + let trimmed = preferred?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + if !trimmed.isEmpty { + if let resolved = self.resolveVoiceAlias(trimmed) { return resolved } + self.ttsLogger.warning("talk unknown voice alias \(trimmed, privacy: .public)") + } + if let fallbackVoiceId { return fallbackVoiceId } + + do { + let voices = try await ElevenLabsTTSClient(apiKey: apiKey).listVoices() + guard let first = voices.first else { + self.ttsLogger.error("elevenlabs voices list empty") + return nil + } + self.fallbackVoiceId = first.voiceId + if self.defaultVoiceId == nil { + self.defaultVoiceId = first.voiceId + } + if !self.voiceOverrideActive { + self.currentVoiceId = first.voiceId + } + let name = first.name ?? "unknown" + self.ttsLogger + .info("talk default voice selected \(name, privacy: .public) (\(first.voiceId, privacy: .public))") + return first.voiceId + } catch { + self.ttsLogger.error("elevenlabs list voices failed: \(error.localizedDescription, privacy: .public)") + return nil + } + } + + private func resolveVoiceAlias(_ value: String?) -> String? { + let trimmed = (value ?? "").trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return nil } + let normalized = trimmed.lowercased() + if let mapped = self.voiceAliases[normalized] { return mapped } + if self.voiceAliases.values.contains(where: { $0.caseInsensitiveCompare(trimmed) == .orderedSame }) { + return trimmed + } + return Self.isLikelyVoiceId(trimmed) ? trimmed : nil + } + + private static func isLikelyVoiceId(_ value: String) -> Bool { + guard value.count >= 10 else { return false } + return value.allSatisfy { $0.isLetter || $0.isNumber || $0 == "-" || $0 == "_" } + } + + func stopSpeaking(reason: TalkStopReason) async { + let usePCM = self.lastPlaybackWasPCM + let interruptedAt = usePCM ? await self.stopPCM() : await self.stopMP3() + _ = usePCM ? await self.stopMP3() : await self.stopPCM() + await TalkSystemSpeechSynthesizer.shared.stop() + guard self.phase == .speaking else { return } + if reason == .speech, let interruptedAt { + self.lastInterruptedAtSeconds = interruptedAt + } + if reason == .manual { + return + } + if reason == .speech || reason == .userTap { + await self.startListening() + return + } + self.phase = .thinking + await MainActor.run { TalkModeController.shared.updatePhase(.thinking) } + } +} + +extension TalkModeRuntime { + // MARK: - Audio playback (MainActor helpers) + + @MainActor + private func playPCM( + stream: AsyncThrowingStream, + sampleRate: Double) async -> StreamingPlaybackResult + { + await PCMStreamingAudioPlayer.shared.play(stream: stream, sampleRate: sampleRate) + } + + @MainActor + private func playMP3(stream: AsyncThrowingStream) async -> StreamingPlaybackResult { + await StreamingAudioPlayer.shared.play(stream: stream) + } + + @MainActor + private func stopPCM() -> Double? { + PCMStreamingAudioPlayer.shared.stop() + } + + @MainActor + private func stopMP3() -> Double? { + StreamingAudioPlayer.shared.stop() + } + + // MARK: - Config + + private func reloadConfig() async { + let cfg = await self.fetchTalkConfig() + self.defaultVoiceId = cfg.voiceId + self.voiceAliases = cfg.voiceAliases + if !self.voiceOverrideActive { + self.currentVoiceId = cfg.voiceId + } + self.defaultModelId = cfg.modelId + if !self.modelOverrideActive { + self.currentModelId = cfg.modelId + } + self.defaultOutputFormat = cfg.outputFormat + self.interruptOnSpeech = cfg.interruptOnSpeech + self.apiKey = cfg.apiKey + let hasApiKey = (cfg.apiKey?.isEmpty == false) + let voiceLabel = (cfg.voiceId?.isEmpty == false) ? cfg.voiceId! : "none" + let modelLabel = (cfg.modelId?.isEmpty == false) ? cfg.modelId! : "none" + self.logger + .info( + "talk config voiceId=\(voiceLabel, privacy: .public) " + + "modelId=\(modelLabel, privacy: .public) " + + "apiKey=\(hasApiKey, privacy: .public) " + + "interrupt=\(cfg.interruptOnSpeech, privacy: .public)") + } + + private struct TalkRuntimeConfig { + let voiceId: String? + let voiceAliases: [String: String] + let modelId: String? + let outputFormat: String? + let interruptOnSpeech: Bool + let apiKey: String? + } + + private func fetchTalkConfig() async -> TalkRuntimeConfig { + let env = ProcessInfo.processInfo.environment + let envVoice = env["ELEVENLABS_VOICE_ID"]?.trimmingCharacters(in: .whitespacesAndNewlines) + let sagVoice = env["SAG_VOICE_ID"]?.trimmingCharacters(in: .whitespacesAndNewlines) + let envApiKey = env["ELEVENLABS_API_KEY"]?.trimmingCharacters(in: .whitespacesAndNewlines) + + do { + let snap: ConfigSnapshot = try await GatewayConnection.shared.requestDecoded( + method: .configGet, + params: nil, + timeoutMs: 8000) + let talk = snap.config?["talk"]?.dictionaryValue + let ui = snap.config?["ui"]?.dictionaryValue + let rawSeam = ui?["seamColor"]?.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + await MainActor.run { + AppStateStore.shared.seamColorHex = rawSeam.isEmpty ? nil : rawSeam + } + let voice = talk?["voiceId"]?.stringValue + let rawAliases = talk?["voiceAliases"]?.dictionaryValue + let resolvedAliases: [String: String] = + rawAliases?.reduce(into: [:]) { acc, entry in + let key = entry.key.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + let value = entry.value.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + guard !key.isEmpty, !value.isEmpty else { return } + acc[key] = value + } ?? [:] + let model = talk?["modelId"]?.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines) + let resolvedModel = (model?.isEmpty == false) ? model! : Self.defaultModelIdFallback + let outputFormat = talk?["outputFormat"]?.stringValue + let interrupt = talk?["interruptOnSpeech"]?.boolValue + let apiKey = talk?["apiKey"]?.stringValue + let resolvedVoice = + (voice?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false ? voice : nil) ?? + (envVoice?.isEmpty == false ? envVoice : nil) ?? + (sagVoice?.isEmpty == false ? sagVoice : nil) + let resolvedApiKey = + (envApiKey?.isEmpty == false ? envApiKey : nil) ?? + (apiKey?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false ? apiKey : nil) + return TalkRuntimeConfig( + voiceId: resolvedVoice, + voiceAliases: resolvedAliases, + modelId: resolvedModel, + outputFormat: outputFormat, + interruptOnSpeech: interrupt ?? true, + apiKey: resolvedApiKey) + } catch { + let resolvedVoice = + (envVoice?.isEmpty == false ? envVoice : nil) ?? + (sagVoice?.isEmpty == false ? sagVoice : nil) + let resolvedApiKey = envApiKey?.isEmpty == false ? envApiKey : nil + return TalkRuntimeConfig( + voiceId: resolvedVoice, + voiceAliases: [:], + modelId: Self.defaultModelIdFallback, + outputFormat: nil, + interruptOnSpeech: true, + apiKey: resolvedApiKey) + } + } + + // MARK: - Audio level handling + + private func noteAudioLevel(rms: Double) async { + if self.phase != .listening, self.phase != .speaking { return } + let alpha: Double = rms < self.noiseFloorRMS ? 0.08 : 0.01 + self.noiseFloorRMS = max(1e-7, self.noiseFloorRMS + (rms - self.noiseFloorRMS) * alpha) + + let threshold = max(self.minSpeechRMS, self.noiseFloorRMS * self.speechBoostFactor) + if rms >= threshold { + let now = Date() + self.lastHeard = now + self.lastSpeechEnergyAt = now + } + + if self.phase == .listening { + let clamped = min(1.0, max(0.0, rms / max(self.minSpeechRMS, threshold))) + await MainActor.run { TalkModeController.shared.updateLevel(clamped) } + } + } + + private static func rmsLevel(buffer: AVAudioPCMBuffer) -> Double? { + guard let channelData = buffer.floatChannelData?.pointee else { return nil } + let frameCount = Int(buffer.frameLength) + guard frameCount > 0 else { return nil } + var sum: Double = 0 + for i in 0.. Bool { + let trimmed = transcript.trimmingCharacters(in: .whitespacesAndNewlines) + guard trimmed.count >= 3 else { return false } + if self.isLikelyEcho(of: trimmed) { return false } + let now = Date() + if let lastSpeechEnergyAt, now.timeIntervalSince(lastSpeechEnergyAt) > 0.35 { + return false + } + return hasConfidence + } + + private func isLikelyEcho(of transcript: String) -> Bool { + guard let spoken = self.lastSpokenText?.lowercased(), !spoken.isEmpty else { return false } + let probe = transcript.lowercased() + if probe.count < 6 { + return spoken.contains(probe) + } + return spoken.contains(probe) + } + + private static func resolveSpeed(speed: Double?, rateWPM: Int?, logger: Logger) -> Double? { + if let rateWPM, rateWPM > 0 { + let resolved = Double(rateWPM) / 175.0 + if resolved <= 0.5 || resolved >= 2.0 { + logger.warning("talk rateWPM out of range: \(rateWPM, privacy: .public)") + return nil + } + return resolved + } + if let speed { + if speed <= 0.5 || speed >= 2.0 { + logger.warning("talk speed out of range: \(speed, privacy: .public)") + return nil + } + return speed + } + return nil + } + + private static func validatedUnit(_ value: Double?, name: String, logger: Logger) -> Double? { + guard let value else { return nil } + if value < 0 || value > 1 { + logger.warning("talk \(name, privacy: .public) out of range: \(value, privacy: .public)") + return nil + } + return value + } + + private static func validatedSeed(_ value: Int?, logger: Logger) -> UInt32? { + guard let value else { return nil } + if value < 0 || value > 4_294_967_295 { + logger.warning("talk seed out of range: \(value, privacy: .public)") + return nil + } + return UInt32(value) + } + + private static func validatedNormalize(_ value: String?, logger: Logger) -> String? { + guard let value else { return nil } + let normalized = value.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + guard ["auto", "on", "off"].contains(normalized) else { + logger.warning("talk normalize invalid: \(normalized, privacy: .public)") + return nil + } + return normalized + } +} diff --git a/apps/macos/Sources/Moltbot/TalkOverlay.swift b/apps/macos/Sources/Moltbot/TalkOverlay.swift new file mode 100644 index 000000000..b9d2f6a24 --- /dev/null +++ b/apps/macos/Sources/Moltbot/TalkOverlay.swift @@ -0,0 +1,146 @@ +import AppKit +import Observation +import OSLog +import SwiftUI + +@MainActor +@Observable +final class TalkOverlayController { + static let shared = TalkOverlayController() + static let overlaySize: CGFloat = 440 + static let orbSize: CGFloat = 96 + static let orbPadding: CGFloat = 12 + static let orbHitSlop: CGFloat = 10 + + private let logger = Logger(subsystem: "bot.molt", category: "talk.overlay") + + struct Model { + var isVisible: Bool = false + var phase: TalkModePhase = .idle + var isPaused: Bool = false + var level: Double = 0 + } + + var model = Model() + private var window: NSPanel? + private var hostingView: NSHostingView? + private let screenInset: CGFloat = 0 + + func present() { + self.ensureWindow() + self.hostingView?.rootView = TalkOverlayView(controller: self) + let target = self.targetFrame() + + guard let window else { return } + if !self.model.isVisible { + self.model.isVisible = true + let start = target.offsetBy(dx: 0, dy: -6) + window.setFrame(start, display: true) + window.alphaValue = 0 + window.orderFrontRegardless() + NSAnimationContext.runAnimationGroup { context in + context.duration = 0.18 + context.timingFunction = CAMediaTimingFunction(name: .easeOut) + window.animator().setFrame(target, display: true) + window.animator().alphaValue = 1 + } + } else { + window.setFrame(target, display: true) + window.orderFrontRegardless() + } + } + + func dismiss() { + guard let window else { + self.model.isVisible = false + return + } + + let target = window.frame.offsetBy(dx: 6, dy: 6) + NSAnimationContext.runAnimationGroup { context in + context.duration = 0.16 + context.timingFunction = CAMediaTimingFunction(name: .easeOut) + window.animator().setFrame(target, display: true) + window.animator().alphaValue = 0 + } completionHandler: { + Task { @MainActor in + window.orderOut(nil) + self.model.isVisible = false + } + } + } + + func updatePhase(_ phase: TalkModePhase) { + guard self.model.phase != phase else { return } + self.logger.info("talk overlay phase=\(phase.rawValue, privacy: .public)") + self.model.phase = phase + } + + func updatePaused(_ paused: Bool) { + guard self.model.isPaused != paused else { return } + self.logger.info("talk overlay paused=\(paused)") + self.model.isPaused = paused + } + + func updateLevel(_ level: Double) { + guard self.model.isVisible else { return } + self.model.level = max(0, min(1, level)) + } + + func currentWindowOrigin() -> CGPoint? { + self.window?.frame.origin + } + + func setWindowOrigin(_ origin: CGPoint) { + guard let window else { return } + window.setFrameOrigin(origin) + } + + // MARK: - Private + + private func ensureWindow() { + if self.window != nil { return } + let panel = NSPanel( + contentRect: NSRect(x: 0, y: 0, width: Self.overlaySize, height: Self.overlaySize), + styleMask: [.nonactivatingPanel, .borderless], + backing: .buffered, + defer: false) + panel.isOpaque = false + panel.backgroundColor = .clear + panel.hasShadow = false + panel.level = NSWindow.Level(rawValue: NSWindow.Level.popUpMenu.rawValue - 4) + panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .transient] + panel.hidesOnDeactivate = false + panel.isMovable = false + panel.acceptsMouseMovedEvents = true + panel.isFloatingPanel = true + panel.becomesKeyOnlyIfNeeded = true + panel.titleVisibility = .hidden + panel.titlebarAppearsTransparent = true + + let host = TalkOverlayHostingView(rootView: TalkOverlayView(controller: self)) + host.translatesAutoresizingMaskIntoConstraints = false + panel.contentView = host + self.hostingView = host + self.window = panel + } + + private func targetFrame() -> NSRect { + let screen = self.window?.screen + ?? NSScreen.main + ?? NSScreen.screens.first + guard let screen else { return .zero } + let size = NSSize(width: Self.overlaySize, height: Self.overlaySize) + let visible = screen.visibleFrame + let origin = CGPoint( + x: visible.maxX - size.width - self.screenInset, + y: visible.maxY - size.height - self.screenInset) + return NSRect(origin: origin, size: size) + } +} + +private final class TalkOverlayHostingView: NSHostingView { + override func acceptsFirstMouse(for event: NSEvent?) -> Bool { + true + } +} diff --git a/apps/macos/Sources/Moltbot/TerminationSignalWatcher.swift b/apps/macos/Sources/Moltbot/TerminationSignalWatcher.swift new file mode 100644 index 000000000..dca6916ac --- /dev/null +++ b/apps/macos/Sources/Moltbot/TerminationSignalWatcher.swift @@ -0,0 +1,53 @@ +import AppKit +import Foundation +import OSLog + +@MainActor +final class TerminationSignalWatcher { + static let shared = TerminationSignalWatcher() + + private let logger = Logger(subsystem: "bot.molt", category: "lifecycle") + private var sources: [DispatchSourceSignal] = [] + private var terminationRequested = false + + func start() { + guard self.sources.isEmpty else { return } + self.install(SIGTERM) + self.install(SIGINT) + } + + func stop() { + for s in self.sources { + s.cancel() + } + self.sources.removeAll(keepingCapacity: false) + self.terminationRequested = false + } + + private func install(_ sig: Int32) { + // Make sure the default action doesn't kill the process before we can gracefully shut down. + signal(sig, SIG_IGN) + let source = DispatchSource.makeSignalSource(signal: sig, queue: .main) + source.setEventHandler { [weak self] in + self?.handle(sig) + } + source.resume() + self.sources.append(source) + } + + private func handle(_ sig: Int32) { + guard !self.terminationRequested else { return } + self.terminationRequested = true + + self.logger.info("received signal \(sig, privacy: .public); terminating") + // Ensure any pairing prompt can't accidentally approve during shutdown. + NodePairingApprovalPrompter.shared.stop() + DevicePairingApprovalPrompter.shared.stop() + NSApp.terminate(nil) + + // Safety net: don't hang forever if something blocks termination. + DispatchQueue.main.asyncAfter(deadline: .now() + 3) { + exit(0) + } + } +} diff --git a/apps/macos/Sources/Moltbot/VoicePushToTalk.swift b/apps/macos/Sources/Moltbot/VoicePushToTalk.swift new file mode 100644 index 000000000..fb454a5fe --- /dev/null +++ b/apps/macos/Sources/Moltbot/VoicePushToTalk.swift @@ -0,0 +1,421 @@ +import AppKit +import AVFoundation +import Dispatch +import OSLog +import Speech + +/// Observes right Option and starts a push-to-talk capture while it is held. +final class VoicePushToTalkHotkey: @unchecked Sendable { + static let shared = VoicePushToTalkHotkey() + + private var globalMonitor: Any? + private var localMonitor: Any? + private var optionDown = false // right option only + private var active = false + + private let beginAction: @Sendable () async -> Void + private let endAction: @Sendable () async -> Void + + init( + beginAction: @escaping @Sendable () async -> Void = { await VoicePushToTalk.shared.begin() }, + endAction: @escaping @Sendable () async -> Void = { await VoicePushToTalk.shared.end() }) + { + self.beginAction = beginAction + self.endAction = endAction + } + + func setEnabled(_ enabled: Bool) { + if ProcessInfo.processInfo.isRunningTests { return } + self.withMainThread { [weak self] in + guard let self else { return } + if enabled { + self.startMonitoring() + } else { + self.stopMonitoring() + } + } + } + + private func startMonitoring() { + // assert(Thread.isMainThread) - Removed for Swift 6 + guard self.globalMonitor == nil, self.localMonitor == nil else { return } + // Listen-only global monitor; we rely on Input Monitoring permission to receive events. + self.globalMonitor = NSEvent.addGlobalMonitorForEvents(matching: .flagsChanged) { [weak self] event in + let keyCode = event.keyCode + let flags = event.modifierFlags + self?.handleFlagsChanged(keyCode: keyCode, modifierFlags: flags) + } + // Also listen locally so we still catch events when the app is active/focused. + self.localMonitor = NSEvent.addLocalMonitorForEvents(matching: .flagsChanged) { [weak self] event in + let keyCode = event.keyCode + let flags = event.modifierFlags + self?.handleFlagsChanged(keyCode: keyCode, modifierFlags: flags) + return event + } + } + + private func stopMonitoring() { + // assert(Thread.isMainThread) - Removed for Swift 6 + if let globalMonitor { + NSEvent.removeMonitor(globalMonitor) + self.globalMonitor = nil + } + if let localMonitor { + NSEvent.removeMonitor(localMonitor) + self.localMonitor = nil + } + self.optionDown = false + self.active = false + } + + private func handleFlagsChanged(keyCode: UInt16, modifierFlags: NSEvent.ModifierFlags) { + self.withMainThread { [weak self] in + self?.updateModifierState(keyCode: keyCode, modifierFlags: modifierFlags) + } + } + + private func withMainThread(_ block: @escaping @Sendable () -> Void) { + DispatchQueue.main.async(execute: block) + } + + private func updateModifierState(keyCode: UInt16, modifierFlags: NSEvent.ModifierFlags) { + // assert(Thread.isMainThread) - Removed for Swift 6 + // Right Option (keyCode 61) acts as a hold-to-talk modifier. + if keyCode == 61 { + self.optionDown = modifierFlags.contains(.option) + } + + let chordActive = self.optionDown + if chordActive, !self.active { + self.active = true + Task { + Logger(subsystem: "bot.molt", category: "voicewake.ptt") + .info("ptt hotkey down") + await self.beginAction() + } + } else if !chordActive, self.active { + self.active = false + Task { + Logger(subsystem: "bot.molt", category: "voicewake.ptt") + .info("ptt hotkey up") + await self.endAction() + } + } + } + + func _testUpdateModifierState(keyCode: UInt16, modifierFlags: NSEvent.ModifierFlags) { + self.updateModifierState(keyCode: keyCode, modifierFlags: modifierFlags) + } +} + +/// Short-lived speech recognizer that records while the hotkey is held. +actor VoicePushToTalk { + static let shared = VoicePushToTalk() + + private let logger = Logger(subsystem: "bot.molt", category: "voicewake.ptt") + + private var recognizer: SFSpeechRecognizer? + // Lazily created on begin() to avoid creating an AVAudioEngine at app launch, which can switch Bluetooth + // headphones into the low-quality headset profile even if push-to-talk is never used. + private var audioEngine: AVAudioEngine? + private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest? + private var recognitionTask: SFSpeechRecognitionTask? + private var tapInstalled = false + + // Session token used to drop stale callbacks when a new capture starts. + private var sessionID = UUID() + + private var committed: String = "" + private var volatile: String = "" + private var activeConfig: Config? + private var isCapturing = false + private var triggerChimePlayed = false + private var finalized = false + private var timeoutTask: Task? + private var overlayToken: UUID? + private var adoptedPrefix: String = "" + + private struct Config { + let micID: String? + let localeID: String? + let triggerChime: VoiceWakeChime + let sendChime: VoiceWakeChime + } + + func begin() async { + guard voiceWakeSupported else { return } + guard !self.isCapturing else { return } + + // Start a fresh session and invalidate any in-flight callbacks tied to an older one. + let sessionID = UUID() + self.sessionID = sessionID + + // Ensure permissions up front. + let granted = await PermissionManager.ensureVoiceWakePermissions(interactive: true) + guard granted else { return } + + let config = await MainActor.run { self.makeConfig() } + self.activeConfig = config + self.isCapturing = true + self.triggerChimePlayed = false + self.finalized = false + self.timeoutTask?.cancel(); self.timeoutTask = nil + let snapshot = await MainActor.run { VoiceSessionCoordinator.shared.snapshot() } + self.adoptedPrefix = snapshot.visible ? snapshot.text.trimmingCharacters(in: .whitespacesAndNewlines) : "" + self.logger.info("ptt begin adopted_prefix_len=\(self.adoptedPrefix.count, privacy: .public)") + if config.triggerChime != .none { + self.triggerChimePlayed = true + await MainActor.run { VoiceWakeChimePlayer.play(config.triggerChime, reason: "ptt.trigger") } + } + // Pause the always-on wake word recognizer so both pipelines don't fight over the mic tap. + await VoiceWakeRuntime.shared.pauseForPushToTalk() + let adoptedPrefix = self.adoptedPrefix + let adoptedAttributed: NSAttributedString? = adoptedPrefix.isEmpty ? nil : Self.makeAttributed( + committed: adoptedPrefix, + volatile: "", + isFinal: false) + self.overlayToken = await MainActor.run { + VoiceSessionCoordinator.shared.startSession( + source: .pushToTalk, + text: adoptedPrefix, + attributed: adoptedAttributed, + forwardEnabled: true) + } + + do { + try await self.startRecognition(localeID: config.localeID, sessionID: sessionID) + } catch { + await MainActor.run { + VoiceWakeOverlayController.shared.dismiss() + } + self.isCapturing = false + // If push-to-talk fails to start after pausing wake-word, ensure we resume listening. + await VoiceWakeRuntime.shared.applyPushToTalkCooldown() + await VoiceWakeRuntime.shared.refresh(state: AppStateStore.shared) + } + } + + func end() async { + guard self.isCapturing else { return } + self.isCapturing = false + let sessionID = self.sessionID + + // Stop feeding Speech buffers first, then end the request. Stopping the engine here can race with + // Speech draining its converter chain (and we already stop/cancel in finalize). + if self.tapInstalled { + self.audioEngine?.inputNode.removeTap(onBus: 0) + self.tapInstalled = false + } + self.recognitionRequest?.endAudio() + + // If we captured nothing, dismiss immediately when the user lets go. + if self.committed.isEmpty, self.volatile.isEmpty, self.adoptedPrefix.isEmpty { + await self.finalize(transcriptOverride: "", reason: "emptyOnRelease", sessionID: sessionID) + return + } + + // Otherwise, give Speech a brief window to deliver the final result; then fall back. + self.timeoutTask?.cancel() + self.timeoutTask = Task { [weak self] in + try? await Task.sleep(nanoseconds: 1_500_000_000) // 1.5s grace period to await final result + await self?.finalize(transcriptOverride: nil, reason: "timeout", sessionID: sessionID) + } + } + + // MARK: - Private + + private func startRecognition(localeID: String?, sessionID: UUID) async throws { + let locale = localeID.flatMap { Locale(identifier: $0) } ?? Locale(identifier: Locale.current.identifier) + self.recognizer = SFSpeechRecognizer(locale: locale) + guard let recognizer, recognizer.isAvailable else { + throw NSError( + domain: "VoicePushToTalk", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "Recognizer unavailable"]) + } + + self.recognitionRequest = SFSpeechAudioBufferRecognitionRequest() + self.recognitionRequest?.shouldReportPartialResults = true + guard let request = self.recognitionRequest else { return } + + // Lazily create the engine here so app launch doesn't grab audio resources / trigger Bluetooth HFP. + if self.audioEngine == nil { + self.audioEngine = AVAudioEngine() + } + guard let audioEngine = self.audioEngine else { return } + + let input = audioEngine.inputNode + let format = input.outputFormat(forBus: 0) + if self.tapInstalled { + input.removeTap(onBus: 0) + self.tapInstalled = false + } + // Pipe raw mic buffers into the Speech request while the chord is held. + input.installTap(onBus: 0, bufferSize: 2048, format: format) { [weak request] buffer, _ in + request?.append(buffer) + } + self.tapInstalled = true + + audioEngine.prepare() + try audioEngine.start() + + self.recognitionTask = recognizer.recognitionTask(with: request) { [weak self] result, error in + guard let self else { return } + if let error { + self.logger.debug("push-to-talk error: \(error.localizedDescription, privacy: .public)") + } + let transcript = result?.bestTranscription.formattedString + let isFinal = result?.isFinal ?? false + // Hop to a Task so UI updates stay off the Speech callback thread. + Task.detached { [weak self, transcript, isFinal, sessionID] in + guard let self else { return } + await self.handle(transcript: transcript, isFinal: isFinal, sessionID: sessionID) + } + } + } + + private func handle(transcript: String?, isFinal: Bool, sessionID: UUID) async { + guard sessionID == self.sessionID else { + self.logger.debug("push-to-talk drop transcript for stale session") + return + } + guard let transcript else { return } + if isFinal { + self.committed = transcript + self.volatile = "" + } else { + self.volatile = Self.delta(after: self.committed, current: transcript) + } + + let committedWithPrefix = Self.join(self.adoptedPrefix, self.committed) + let snapshot = Self.join(committedWithPrefix, self.volatile) + let attributed = Self.makeAttributed(committed: committedWithPrefix, volatile: self.volatile, isFinal: isFinal) + if let token = self.overlayToken { + await MainActor.run { + VoiceSessionCoordinator.shared.updatePartial( + token: token, + text: snapshot, + attributed: attributed) + } + } + } + + private func finalize(transcriptOverride: String?, reason: String, sessionID: UUID?) async { + if self.finalized { return } + if let sessionID, sessionID != self.sessionID { + self.logger.debug("push-to-talk drop finalize for stale session") + return + } + self.finalized = true + self.isCapturing = false + self.timeoutTask?.cancel(); self.timeoutTask = nil + + let finalRecognized: String = { + if let override = transcriptOverride?.trimmingCharacters(in: .whitespacesAndNewlines) { + return override + } + return (self.committed + self.volatile).trimmingCharacters(in: .whitespacesAndNewlines) + }() + let finalText = Self.join(self.adoptedPrefix, finalRecognized) + let chime = finalText.isEmpty ? .none : (self.activeConfig?.sendChime ?? .none) + + let token = self.overlayToken + let logger = self.logger + await MainActor.run { + logger.info("ptt finalize reason=\(reason, privacy: .public) len=\(finalText.count, privacy: .public)") + if let token { + VoiceSessionCoordinator.shared.finalize( + token: token, + text: finalText, + sendChime: chime, + autoSendAfter: nil) + VoiceSessionCoordinator.shared.sendNow(token: token, reason: reason) + } else if !finalText.isEmpty { + if chime != .none { + VoiceWakeChimePlayer.play(chime, reason: "ptt.fallback_send") + } + Task.detached { + await VoiceWakeForwarder.forward(transcript: finalText) + } + } + } + + self.recognitionTask?.cancel() + self.recognitionRequest = nil + self.recognitionTask = nil + if self.tapInstalled { + self.audioEngine?.inputNode.removeTap(onBus: 0) + self.tapInstalled = false + } + if self.audioEngine?.isRunning == true { + self.audioEngine?.stop() + self.audioEngine?.reset() + } + // Release the engine so we also release any audio session/resources when push-to-talk ends. + self.audioEngine = nil + + self.committed = "" + self.volatile = "" + self.activeConfig = nil + self.triggerChimePlayed = false + self.overlayToken = nil + self.adoptedPrefix = "" + + // Resume the wake-word runtime after push-to-talk finishes. + await VoiceWakeRuntime.shared.applyPushToTalkCooldown() + _ = await MainActor.run { Task { await VoiceWakeRuntime.shared.refresh(state: AppStateStore.shared) } } + } + + @MainActor + private func makeConfig() -> Config { + let state = AppStateStore.shared + return Config( + micID: state.voiceWakeMicID.isEmpty ? nil : state.voiceWakeMicID, + localeID: state.voiceWakeLocaleID, + triggerChime: state.voiceWakeTriggerChime, + sendChime: state.voiceWakeSendChime) + } + + // MARK: - Test helpers + + static func _testDelta(committed: String, current: String) -> String { + self.delta(after: committed, current: current) + } + + static func _testAttributedColors(isFinal: Bool) -> (NSColor, NSColor) { + let sample = self.makeAttributed(committed: "a", volatile: "b", isFinal: isFinal) + let committedColor = sample.attribute(.foregroundColor, at: 0, effectiveRange: nil) as? NSColor ?? .clear + let volatileColor = sample.attribute(.foregroundColor, at: 1, effectiveRange: nil) as? NSColor ?? .clear + return (committedColor, volatileColor) + } + + private static func join(_ prefix: String, _ suffix: String) -> String { + if prefix.isEmpty { return suffix } + if suffix.isEmpty { return prefix } + return "\(prefix) \(suffix)" + } + + private static func delta(after committed: String, current: String) -> String { + if current.hasPrefix(committed) { + let start = current.index(current.startIndex, offsetBy: committed.count) + return String(current[start...]) + } + return current + } + + private static func makeAttributed(committed: String, volatile: String, isFinal: Bool) -> NSAttributedString { + let full = NSMutableAttributedString() + let committedAttr: [NSAttributedString.Key: Any] = [ + .foregroundColor: NSColor.labelColor, + .font: NSFont.systemFont(ofSize: 13, weight: .regular), + ] + full.append(NSAttributedString(string: committed, attributes: committedAttr)) + let volatileColor: NSColor = isFinal ? .labelColor : NSColor.tertiaryLabelColor + let volatileAttr: [NSAttributedString.Key: Any] = [ + .foregroundColor: volatileColor, + .font: NSFont.systemFont(ofSize: 13, weight: .regular), + ] + full.append(NSAttributedString(string: volatile, attributes: volatileAttr)) + return full + } +} diff --git a/apps/macos/Sources/Moltbot/VoiceSessionCoordinator.swift b/apps/macos/Sources/Moltbot/VoiceSessionCoordinator.swift new file mode 100644 index 000000000..244d1da28 --- /dev/null +++ b/apps/macos/Sources/Moltbot/VoiceSessionCoordinator.swift @@ -0,0 +1,134 @@ +import AppKit +import Foundation +import Observation + +@MainActor +@Observable +final class VoiceSessionCoordinator { + static let shared = VoiceSessionCoordinator() + + enum Source: String { case wakeWord, pushToTalk } + + struct Session { + let token: UUID + let source: Source + var text: String + var attributed: NSAttributedString? + var isFinal: Bool + var sendChime: VoiceWakeChime + var autoSendDelay: TimeInterval? + } + + private let logger = Logger(subsystem: "bot.molt", category: "voicewake.coordinator") + private var session: Session? + + // MARK: - API + + func startSession( + source: Source, + text: String, + attributed: NSAttributedString? = nil, + forwardEnabled: Bool = false) -> UUID + { + let token = UUID() + self.logger.info("coordinator start token=\(token.uuidString) source=\(source.rawValue) len=\(text.count)") + let attributedText = attributed ?? VoiceWakeOverlayController.shared.makeAttributed(from: text) + let session = Session( + token: token, + source: source, + text: text, + attributed: attributedText, + isFinal: false, + sendChime: .none, + autoSendDelay: nil) + self.session = session + VoiceWakeOverlayController.shared.startSession( + token: token, + source: VoiceWakeOverlayController.Source(rawValue: source.rawValue) ?? .wakeWord, + transcript: text, + attributed: attributedText, + forwardEnabled: forwardEnabled, + isFinal: false) + return token + } + + func updatePartial(token: UUID, text: String, attributed: NSAttributedString? = nil) { + guard let session, session.token == token else { return } + self.session?.text = text + self.session?.attributed = attributed + VoiceWakeOverlayController.shared.updatePartial(token: token, transcript: text, attributed: attributed) + } + + func finalize( + token: UUID, + text: String, + sendChime: VoiceWakeChime, + autoSendAfter: TimeInterval?) + { + guard let session, session.token == token else { return } + self.logger + .info( + "coordinator finalize token=\(token.uuidString) len=\(text.count) autoSendAfter=\(autoSendAfter ?? -1)") + self.session?.text = text + self.session?.isFinal = true + self.session?.sendChime = sendChime + self.session?.autoSendDelay = autoSendAfter + + let attributed = VoiceWakeOverlayController.shared.makeAttributed(from: text) + VoiceWakeOverlayController.shared.presentFinal( + token: token, + transcript: text, + autoSendAfter: autoSendAfter, + sendChime: sendChime, + attributed: attributed) + } + + func sendNow(token: UUID, reason: String = "explicit") { + guard let session, session.token == token else { return } + let text = session.text.trimmingCharacters(in: .whitespacesAndNewlines) + guard !text.isEmpty else { + self.logger.info("coordinator sendNow \(reason) empty -> dismiss") + VoiceWakeOverlayController.shared.dismiss(token: token, reason: .empty, outcome: .empty) + self.clearSession() + return + } + VoiceWakeOverlayController.shared.beginSendUI(token: token, sendChime: session.sendChime) + Task.detached { + _ = await VoiceWakeForwarder.forward(transcript: text) + } + } + + func dismiss( + token: UUID, + reason: VoiceWakeOverlayController.DismissReason, + outcome: VoiceWakeOverlayController.SendOutcome) + { + guard let session, session.token == token else { return } + VoiceWakeOverlayController.shared.dismiss(token: token, reason: reason, outcome: outcome) + self.clearSession() + } + + func updateLevel(token: UUID, _ level: Double) { + guard let session, session.token == token else { return } + VoiceWakeOverlayController.shared.updateLevel(token: token, level) + } + + func snapshot() -> (token: UUID?, text: String, visible: Bool) { + (self.session?.token, self.session?.text ?? "", VoiceWakeOverlayController.shared.isVisible) + } + + // MARK: - Private + + private func clearSession() { + self.session = nil + } + + /// Overlay dismiss completion callback (manual X, empty, auto-dismiss after send). + /// Ensures the wake-word recognizer is resumed if Voice Wake is enabled. + func overlayDidDismiss(token: UUID?) { + if let token, self.session?.token == token { + self.clearSession() + } + Task { await VoiceWakeRuntime.shared.refresh(state: AppStateStore.shared) } + } +} diff --git a/apps/macos/Sources/Moltbot/VoiceWakeChime.swift b/apps/macos/Sources/Moltbot/VoiceWakeChime.swift new file mode 100644 index 000000000..ca74d22dd --- /dev/null +++ b/apps/macos/Sources/Moltbot/VoiceWakeChime.swift @@ -0,0 +1,74 @@ +import AppKit +import Foundation +import OSLog + +enum VoiceWakeChime: Codable, Equatable, Sendable { + case none + case system(name: String) + case custom(displayName: String, bookmark: Data) + + var systemName: String? { + if case let .system(name) = self { + return name + } + return nil + } + + var displayLabel: String { + switch self { + case .none: + "No Sound" + case let .system(name): + VoiceWakeChimeCatalog.displayName(for: name) + case let .custom(displayName, _): + displayName + } + } +} + +enum VoiceWakeChimeCatalog { + /// Options shown in the picker. + static var systemOptions: [String] { SoundEffectCatalog.systemOptions } + + static func displayName(for raw: String) -> String { + SoundEffectCatalog.displayName(for: raw) + } + + static func url(for name: String) -> URL? { + SoundEffectCatalog.url(for: name) + } +} + +@MainActor +enum VoiceWakeChimePlayer { + private static let logger = Logger(subsystem: "bot.molt", category: "voicewake.chime") + private static var lastSound: NSSound? + + static func play(_ chime: VoiceWakeChime, reason: String? = nil) { + guard let sound = self.sound(for: chime) else { return } + if let reason { + self.logger.log(level: .info, "chime play reason=\(reason, privacy: .public)") + } else { + self.logger.log(level: .info, "chime play") + } + DiagnosticsFileLog.shared.log(category: "voicewake.chime", event: "play", fields: [ + "reason": reason ?? "", + "chime": chime.displayLabel, + "systemName": chime.systemName ?? "", + ]) + SoundEffectPlayer.play(sound) + } + + private static func sound(for chime: VoiceWakeChime) -> NSSound? { + switch chime { + case .none: + nil + + case let .system(name): + SoundEffectPlayer.sound(named: name) + + case let .custom(_, bookmark): + SoundEffectPlayer.sound(from: bookmark) + } + } +} diff --git a/apps/macos/Sources/Moltbot/VoiceWakeForwarder.swift b/apps/macos/Sources/Moltbot/VoiceWakeForwarder.swift new file mode 100644 index 000000000..7192f2bf4 --- /dev/null +++ b/apps/macos/Sources/Moltbot/VoiceWakeForwarder.swift @@ -0,0 +1,73 @@ +import Foundation +import OSLog + +enum VoiceWakeForwarder { + private static let logger = Logger(subsystem: "bot.molt", category: "voicewake.forward") + + static func prefixedTranscript(_ transcript: String, machineName: String? = nil) -> String { + let resolvedMachine = machineName + .flatMap { name -> String? in + let trimmed = name.trimmingCharacters(in: .whitespacesAndNewlines) + return trimmed.isEmpty ? nil : trimmed + } + ?? Host.current().localizedName + ?? ProcessInfo.processInfo.hostName + + let safeMachine = resolvedMachine.isEmpty ? "this Mac" : resolvedMachine + return """ + User talked via voice recognition on \(safeMachine) - repeat prompt first \ + + remember some words might be incorrectly transcribed. + + \(transcript) + """ + } + + enum VoiceWakeForwardError: LocalizedError, Equatable { + case rpcFailed(String) + + var errorDescription: String? { + switch self { + case let .rpcFailed(message): message + } + } + } + + struct ForwardOptions: Sendable { + var sessionKey: String = "main" + var thinking: String = "low" + var deliver: Bool = true + var to: String? + var channel: GatewayAgentChannel = .last + } + + @discardableResult + static func forward( + transcript: String, + options: ForwardOptions = ForwardOptions()) async -> Result + { + let payload = Self.prefixedTranscript(transcript) + let deliver = options.channel.shouldDeliver(options.deliver) + let result = await GatewayConnection.shared.sendAgent(GatewayAgentInvocation( + message: payload, + sessionKey: options.sessionKey, + thinking: options.thinking, + deliver: deliver, + to: options.to, + channel: options.channel)) + + if result.ok { + self.logger.info("voice wake forward ok") + return .success(()) + } + + let message = result.error ?? "agent rpc unavailable" + self.logger.error("voice wake forward failed: \(message, privacy: .public)") + return .failure(.rpcFailed(message)) + } + + static func checkConnection() async -> Result { + let status = await GatewayConnection.shared.status() + if status.ok { return .success(()) } + return .failure(.rpcFailed(status.error ?? "agent rpc unreachable")) + } +} diff --git a/apps/macos/Sources/Moltbot/VoiceWakeGlobalSettingsSync.swift b/apps/macos/Sources/Moltbot/VoiceWakeGlobalSettingsSync.swift new file mode 100644 index 000000000..b60d07597 --- /dev/null +++ b/apps/macos/Sources/Moltbot/VoiceWakeGlobalSettingsSync.swift @@ -0,0 +1,66 @@ +import MoltbotKit +import Foundation +import OSLog + +@MainActor +final class VoiceWakeGlobalSettingsSync { + static let shared = VoiceWakeGlobalSettingsSync() + + private let logger = Logger(subsystem: "bot.molt", category: "voicewake.sync") + private var task: Task? + + private struct VoiceWakePayload: Codable, Equatable { + let triggers: [String] + } + + func start() { + guard self.task == nil else { return } + self.task = Task { [weak self] in + guard let self else { return } + while !Task.isCancelled { + do { + try await GatewayConnection.shared.refresh() + } catch { + // Not configured / not reachable yet. + } + + await self.refreshFromGateway() + + let stream = await GatewayConnection.shared.subscribe(bufferingNewest: 200) + for await push in stream { + if Task.isCancelled { return } + await self.handle(push: push) + } + + // If the stream finishes (gateway shutdown / reconnect), loop and resubscribe. + try? await Task.sleep(nanoseconds: 600_000_000) + } + } + } + + func stop() { + self.task?.cancel() + self.task = nil + } + + private func refreshFromGateway() async { + do { + let triggers = try await GatewayConnection.shared.voiceWakeGetTriggers() + AppStateStore.shared.applyGlobalVoiceWakeTriggers(triggers) + } catch { + // Best-effort only. + } + } + + func handle(push: GatewayPush) async { + guard case let .event(evt) = push else { return } + guard evt.event == "voicewake.changed" else { return } + guard let payload = evt.payload else { return } + do { + let decoded = try GatewayPayloadDecoding.decode(payload, as: VoiceWakePayload.self) + AppStateStore.shared.applyGlobalVoiceWakeTriggers(decoded.triggers) + } catch { + self.logger.error("failed to decode voicewake.changed: \(error.localizedDescription, privacy: .public)") + } + } +} diff --git a/apps/macos/Sources/Moltbot/VoiceWakeOverlay.swift b/apps/macos/Sources/Moltbot/VoiceWakeOverlay.swift new file mode 100644 index 000000000..dcbd25621 --- /dev/null +++ b/apps/macos/Sources/Moltbot/VoiceWakeOverlay.swift @@ -0,0 +1,60 @@ +import AppKit +import Observation +import SwiftUI + +/// Lightweight, borderless panel that shows the current voice wake transcript near the menu bar. +@MainActor +@Observable +final class VoiceWakeOverlayController { + static let shared = VoiceWakeOverlayController() + + let logger = Logger(subsystem: "bot.molt", category: "voicewake.overlay") + let enableUI: Bool + + /// Keep the voice wake overlay above any other Moltbot windows, but below the system’s pop-up menus. + /// (Menu bar menus typically live at `.popUpMenu`.) + static let preferredWindowLevel = NSWindow.Level(rawValue: NSWindow.Level.popUpMenu.rawValue - 4) + + enum Source: String { case wakeWord, pushToTalk } + + var model = Model() + var isVisible: Bool { self.model.isVisible } + + struct Model { + var text: String = "" + var isFinal: Bool = false + var isVisible: Bool = false + var forwardEnabled: Bool = false + var isSending: Bool = false + var attributed: NSAttributedString = .init(string: "") + var isOverflowing: Bool = false + var isEditing: Bool = false + var level: Double = 0 // normalized 0...1 speech level for UI + } + + var window: NSPanel? + var hostingView: NSHostingView? + var autoSendTask: Task? + var autoSendToken: UUID? + var activeToken: UUID? + var activeSource: Source? + var lastLevelUpdate: TimeInterval = 0 + + let width: CGFloat = 360 + let padding: CGFloat = 10 + let buttonWidth: CGFloat = 36 + let spacing: CGFloat = 8 + let verticalPadding: CGFloat = 8 + let maxHeight: CGFloat = 400 + let minHeight: CGFloat = 48 + let closeOverflow: CGFloat = 10 + let levelUpdateInterval: TimeInterval = 1.0 / 12.0 + + enum DismissReason { case explicit, empty } + enum SendOutcome { case sent, empty } + enum GuardOutcome { case accept, dropMismatch, dropNoActive } + + init(enableUI: Bool = true) { + self.enableUI = enableUI + } +} diff --git a/apps/macos/Sources/Moltbot/VoiceWakeRuntime.swift b/apps/macos/Sources/Moltbot/VoiceWakeRuntime.swift new file mode 100644 index 000000000..805211122 --- /dev/null +++ b/apps/macos/Sources/Moltbot/VoiceWakeRuntime.swift @@ -0,0 +1,804 @@ +import AVFoundation +import Foundation +import OSLog +import Speech +import SwabbleKit +#if canImport(AppKit) +import AppKit +#endif + +/// Background listener that keeps the voice-wake pipeline alive outside the settings test view. +actor VoiceWakeRuntime { + static let shared = VoiceWakeRuntime() + + enum ListeningState { case idle, voiceWake, pushToTalk } + + private let logger = Logger(subsystem: "bot.molt", category: "voicewake.runtime") + + private var recognizer: SFSpeechRecognizer? + // Lazily created on start to avoid creating an AVAudioEngine at app launch, which can switch Bluetooth + // headphones into the low-quality headset profile even if Voice Wake is disabled. + private var audioEngine: AVAudioEngine? + private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest? + private var recognitionTask: SFSpeechRecognitionTask? + private var recognitionGeneration: Int = 0 // drop stale callbacks after restarts + private var lastHeard: Date? + private var noiseFloorRMS: Double = 1e-4 + private var captureStartedAt: Date? + private var captureTask: Task? + private var capturedTranscript: String = "" + private var isCapturing: Bool = false + private var heardBeyondTrigger: Bool = false + private var triggerChimePlayed: Bool = false + private var committedTranscript: String = "" + private var volatileTranscript: String = "" + private var cooldownUntil: Date? + private var currentConfig: RuntimeConfig? + private var listeningState: ListeningState = .idle + private var overlayToken: UUID? + private var activeTriggerEndTime: TimeInterval? + private var scheduledRestartTask: Task? + private var lastLoggedText: String? + private var lastLoggedAt: Date? + private var lastTapLogAt: Date? + private var lastCallbackLogAt: Date? + private var lastTranscript: String? + private var lastTranscriptAt: Date? + private var preDetectTask: Task? + private var isStarting: Bool = false + private var triggerOnlyTask: Task? + + // Tunables + // Silence threshold once we've captured user speech (post-trigger). + private let silenceWindow: TimeInterval = 2.0 + // Silence threshold when we only heard the trigger but no post-trigger speech yet. + private let triggerOnlySilenceWindow: TimeInterval = 5.0 + // Maximum capture duration from trigger until we force-send, to avoid runaway sessions. + private let captureHardStop: TimeInterval = 120.0 + private let debounceAfterSend: TimeInterval = 0.35 + // Voice activity detection parameters (RMS-based). + private let minSpeechRMS: Double = 1e-3 + private let speechBoostFactor: Double = 6.0 // how far above noise floor we require to mark speech + private let preDetectSilenceWindow: TimeInterval = 1.0 + private let triggerPauseWindow: TimeInterval = 0.55 + + /// Stops the active Speech pipeline without clearing the stored config, so we can restart cleanly. + private func haltRecognitionPipeline() { + // Bump generation first so any in-flight callbacks from the cancelled task get dropped. + self.recognitionGeneration &+= 1 + self.recognitionTask?.cancel() + self.recognitionTask = nil + self.recognitionRequest?.endAudio() + self.recognitionRequest = nil + self.audioEngine?.inputNode.removeTap(onBus: 0) + self.audioEngine?.stop() + // Release the engine so we also release any audio session/resources when Voice Wake is idle. + self.audioEngine = nil + } + + struct RuntimeConfig: Equatable { + let triggers: [String] + let micID: String? + let localeID: String? + let triggerChime: VoiceWakeChime + let sendChime: VoiceWakeChime + } + + private struct RecognitionUpdate { + let transcript: String? + let segments: [WakeWordSegment] + let isFinal: Bool + let error: Error? + let generation: Int + } + + func refresh(state: AppState) async { + let snapshot = await MainActor.run { () -> (Bool, RuntimeConfig) in + let enabled = state.swabbleEnabled + let config = RuntimeConfig( + triggers: sanitizeVoiceWakeTriggers(state.swabbleTriggerWords), + micID: state.voiceWakeMicID.isEmpty ? nil : state.voiceWakeMicID, + localeID: state.voiceWakeLocaleID.isEmpty ? nil : state.voiceWakeLocaleID, + triggerChime: state.voiceWakeTriggerChime, + sendChime: state.voiceWakeSendChime) + return (enabled, config) + } + + guard voiceWakeSupported, snapshot.0 else { + self.stop() + return + } + + guard PermissionManager.voiceWakePermissionsGranted() else { + self.logger.debug("voicewake runtime not starting: permissions missing") + self.stop() + return + } + + let config = snapshot.1 + + if self.isStarting { + return + } + + if self.scheduledRestartTask != nil, config == self.currentConfig, self.recognitionTask == nil { + return + } + + if self.scheduledRestartTask != nil { + self.scheduledRestartTask?.cancel() + self.scheduledRestartTask = nil + } + + if config == self.currentConfig, self.recognitionTask != nil { + return + } + + self.stop() + await self.start(with: config) + } + + private func start(with config: RuntimeConfig) async { + if self.isStarting { + return + } + self.isStarting = true + defer { self.isStarting = false } + do { + self.recognitionGeneration &+= 1 + let generation = self.recognitionGeneration + + self.configureSession(localeID: config.localeID) + + guard let recognizer, recognizer.isAvailable else { + self.logger.error("voicewake runtime: speech recognizer unavailable") + return + } + + self.recognitionRequest = SFSpeechAudioBufferRecognitionRequest() + self.recognitionRequest?.shouldReportPartialResults = true + self.recognitionRequest?.taskHint = .dictation + guard let request = self.recognitionRequest else { return } + + // Lazily create the engine here so app launch doesn't grab audio resources / trigger Bluetooth HFP. + if self.audioEngine == nil { + self.audioEngine = AVAudioEngine() + } + guard let audioEngine = self.audioEngine else { return } + + let input = audioEngine.inputNode + let format = input.outputFormat(forBus: 0) + guard format.channelCount > 0, format.sampleRate > 0 else { + throw NSError( + domain: "VoiceWakeRuntime", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "No audio input available"]) + } + input.removeTap(onBus: 0) + input.installTap(onBus: 0, bufferSize: 2048, format: format) { [weak self, weak request] buffer, _ in + request?.append(buffer) + guard let rms = Self.rmsLevel(buffer: buffer) else { return } + Task.detached { [weak self] in + await self?.noteAudioLevel(rms: rms) + await self?.noteAudioTap(rms: rms) + } + } + + audioEngine.prepare() + try audioEngine.start() + + self.currentConfig = config + self.lastHeard = Date() + // Preserve any existing cooldownUntil so the debounce after send isn't wiped by a restart. + + self.recognitionTask = recognizer.recognitionTask(with: request) { [weak self, generation] result, error in + guard let self else { return } + let transcript = result?.bestTranscription.formattedString + let segments = result.flatMap { result in + transcript + .map { WakeWordSpeechSegments.from(transcription: result.bestTranscription, transcript: $0) } + } ?? [] + let isFinal = result?.isFinal ?? false + Task { await self.noteRecognitionCallback(transcript: transcript, isFinal: isFinal, error: error) } + let update = RecognitionUpdate( + transcript: transcript, + segments: segments, + isFinal: isFinal, + error: error, + generation: generation) + Task { await self.handleRecognition(update, config: config) } + } + + let preferred = config.micID?.isEmpty == false ? config.micID! : "system-default" + self.logger.info( + "voicewake runtime input preferred=\(preferred, privacy: .public) " + + "\(AudioInputDeviceObserver.defaultInputDeviceSummary(), privacy: .public)") + self.logger.info("voicewake runtime started") + DiagnosticsFileLog.shared.log(category: "voicewake.runtime", event: "started", fields: [ + "locale": config.localeID ?? "", + "micID": config.micID ?? "", + ]) + } catch { + self.logger.error("voicewake runtime failed to start: \(error.localizedDescription, privacy: .public)") + self.stop() + } + } + + private func stop(dismissOverlay: Bool = true, cancelScheduledRestart: Bool = true) { + if cancelScheduledRestart { + self.scheduledRestartTask?.cancel() + self.scheduledRestartTask = nil + } + self.captureTask?.cancel() + self.captureTask = nil + self.isCapturing = false + self.capturedTranscript = "" + self.captureStartedAt = nil + self.triggerChimePlayed = false + self.lastTranscript = nil + self.lastTranscriptAt = nil + self.preDetectTask?.cancel() + self.preDetectTask = nil + self.triggerOnlyTask?.cancel() + self.triggerOnlyTask = nil + self.haltRecognitionPipeline() + self.recognizer = nil + self.currentConfig = nil + self.listeningState = .idle + self.activeTriggerEndTime = nil + self.logger.debug("voicewake runtime stopped") + DiagnosticsFileLog.shared.log(category: "voicewake.runtime", event: "stopped") + + let token = self.overlayToken + self.overlayToken = nil + guard dismissOverlay else { return } + Task { @MainActor in + if let token { + VoiceSessionCoordinator.shared.dismiss(token: token, reason: .explicit, outcome: .empty) + } else { + VoiceWakeOverlayController.shared.dismiss() + } + } + } + + private func configureSession(localeID: String?) { + let locale = localeID.flatMap { Locale(identifier: $0) } ?? Locale(identifier: Locale.current.identifier) + self.recognizer = SFSpeechRecognizer(locale: locale) + self.recognizer?.defaultTaskHint = .dictation + } + + private func handleRecognition(_ update: RecognitionUpdate, config: RuntimeConfig) async { + if update.generation != self.recognitionGeneration { + return // stale callback from a superseded recognizer session + } + if let error = update.error { + self.logger.debug("voicewake recognition error: \(error.localizedDescription, privacy: .public)") + } + + guard let transcript = update.transcript else { return } + + let now = Date() + if !transcript.isEmpty { + self.lastHeard = now + if !self.isCapturing { + self.lastTranscript = transcript + self.lastTranscriptAt = now + } + if self.isCapturing { + self.maybeLogRecognition( + transcript: transcript, + segments: update.segments, + triggers: config.triggers, + isFinal: update.isFinal, + match: nil, + usedFallback: false, + capturing: true) + let trimmed = Self.commandAfterTrigger( + transcript: transcript, + segments: update.segments, + triggerEndTime: self.activeTriggerEndTime, + triggers: config.triggers) + self.capturedTranscript = trimmed + self.updateHeardBeyondTrigger(withTrimmed: trimmed) + if update.isFinal { + self.committedTranscript = trimmed + self.volatileTranscript = "" + } else { + self.volatileTranscript = Self.delta(after: self.committedTranscript, current: trimmed) + } + + let attributed = Self.makeAttributed( + committed: self.committedTranscript, + volatile: self.volatileTranscript, + isFinal: update.isFinal) + let snapshot = self.committedTranscript + self.volatileTranscript + if let token = self.overlayToken { + await MainActor.run { + VoiceSessionCoordinator.shared.updatePartial( + token: token, + text: snapshot, + attributed: attributed) + } + } + } + } + + if self.isCapturing { return } + + let gateConfig = WakeWordGateConfig(triggers: config.triggers) + var usedFallback = false + var match = WakeWordGate.match(transcript: transcript, segments: update.segments, config: gateConfig) + if match == nil, update.isFinal { + match = self.textOnlyFallbackMatch( + transcript: transcript, + triggers: config.triggers, + config: gateConfig) + usedFallback = match != nil + } + self.maybeLogRecognition( + transcript: transcript, + segments: update.segments, + triggers: config.triggers, + isFinal: update.isFinal, + match: match, + usedFallback: usedFallback, + capturing: false) + + if let match { + if let cooldown = cooldownUntil, now < cooldown { + return + } + if usedFallback { + self.logger.info("voicewake runtime detected (text-only fallback) len=\(match.command.count)") + } else { + self.logger.info("voicewake runtime detected len=\(match.command.count)") + } + await self.beginCapture(command: match.command, triggerEndTime: match.triggerEndTime, config: config) + } else if !transcript.isEmpty, update.error == nil { + if self.isTriggerOnly(transcript: transcript, triggers: config.triggers) { + self.preDetectTask?.cancel() + self.preDetectTask = nil + self.scheduleTriggerOnlyPauseCheck(triggers: config.triggers, config: config) + } else { + self.triggerOnlyTask?.cancel() + self.triggerOnlyTask = nil + self.schedulePreDetectSilenceCheck( + triggers: config.triggers, + gateConfig: gateConfig, + config: config) + } + } + } + + private func maybeLogRecognition( + transcript: String, + segments: [WakeWordSegment], + triggers: [String], + isFinal: Bool, + match: WakeWordGateMatch?, + usedFallback: Bool, + capturing: Bool) + { + guard !transcript.isEmpty else { return } + let level = self.logger.logLevel + guard level == .debug || level == .trace else { return } + if transcript == self.lastLoggedText, !isFinal { + if let last = self.lastLoggedAt, Date().timeIntervalSince(last) < 0.25 { + return + } + } + self.lastLoggedText = transcript + self.lastLoggedAt = Date() + + let textOnly = WakeWordGate.matchesTextOnly(text: transcript, triggers: triggers) + let timingCount = segments.count(where: { $0.start > 0 || $0.duration > 0 }) + let matchSummary = match.map { + "match=true gap=\(String(format: "%.2f", $0.postGap))s cmdLen=\($0.command.count)" + } ?? "match=false" + let segmentSummary = segments.map { seg in + let start = String(format: "%.2f", seg.start) + let end = String(format: "%.2f", seg.end) + return "\(seg.text)@\(start)-\(end)" + }.joined(separator: ", ") + + self.logger.debug( + "voicewake runtime transcript='\(transcript, privacy: .private)' textOnly=\(textOnly) " + + "isFinal=\(isFinal) timing=\(timingCount)/\(segments.count) " + + "capturing=\(capturing) fallback=\(usedFallback) " + + "\(matchSummary) segments=[\(segmentSummary, privacy: .private)]") + } + + private func noteAudioTap(rms: Double) { + let now = Date() + if let last = self.lastTapLogAt, now.timeIntervalSince(last) < 1.0 { + return + } + self.lastTapLogAt = now + let db = 20 * log10(max(rms, 1e-7)) + self.logger.debug( + "voicewake runtime audio tap rms=\(String(format: "%.6f", rms)) " + + "db=\(String(format: "%.1f", db)) capturing=\(self.isCapturing)") + } + + private func noteRecognitionCallback(transcript: String?, isFinal: Bool, error: Error?) { + guard transcript?.isEmpty ?? true else { return } + let now = Date() + if let last = self.lastCallbackLogAt, now.timeIntervalSince(last) < 1.0 { + return + } + self.lastCallbackLogAt = now + let errorSummary = error?.localizedDescription ?? "none" + self.logger.debug( + "voicewake runtime callback empty transcript isFinal=\(isFinal) error=\(errorSummary, privacy: .public)") + } + + private func scheduleTriggerOnlyPauseCheck(triggers: [String], config: RuntimeConfig) { + self.triggerOnlyTask?.cancel() + let lastSeenAt = self.lastTranscriptAt + let lastText = self.lastTranscript + let windowNanos = UInt64(self.triggerPauseWindow * 1_000_000_000) + self.triggerOnlyTask = Task { [weak self, lastSeenAt, lastText] in + try? await Task.sleep(nanoseconds: windowNanos) + guard let self else { return } + await self.triggerOnlyPauseCheck( + lastSeenAt: lastSeenAt, + lastText: lastText, + triggers: triggers, + config: config) + } + } + + private func schedulePreDetectSilenceCheck( + triggers: [String], + gateConfig: WakeWordGateConfig, + config: RuntimeConfig) + { + self.preDetectTask?.cancel() + let lastSeenAt = self.lastTranscriptAt + let lastText = self.lastTranscript + let windowNanos = UInt64(self.preDetectSilenceWindow * 1_000_000_000) + self.preDetectTask = Task { [weak self, lastSeenAt, lastText] in + try? await Task.sleep(nanoseconds: windowNanos) + guard let self else { return } + await self.preDetectSilenceCheck( + lastSeenAt: lastSeenAt, + lastText: lastText, + triggers: triggers, + gateConfig: gateConfig, + config: config) + } + } + + private func triggerOnlyPauseCheck( + lastSeenAt: Date?, + lastText: String?, + triggers: [String], + config: RuntimeConfig) async + { + guard !Task.isCancelled else { return } + guard !self.isCapturing else { return } + guard let lastSeenAt, let lastText else { return } + guard self.lastTranscriptAt == lastSeenAt, self.lastTranscript == lastText else { return } + guard self.isTriggerOnly(transcript: lastText, triggers: triggers) else { return } + if let cooldown = self.cooldownUntil, Date() < cooldown { + return + } + self.logger.info("voicewake runtime detected (trigger-only pause)") + await self.beginCapture(command: "", triggerEndTime: nil, config: config) + } + + private func textOnlyFallbackMatch( + transcript: String, + triggers: [String], + config: WakeWordGateConfig) -> WakeWordGateMatch? + { + guard let command = VoiceWakeTextUtils.textOnlyCommand( + transcript: transcript, + triggers: triggers, + minCommandLength: config.minCommandLength, + trimWake: Self.trimmedAfterTrigger) + else { return nil } + return WakeWordGateMatch(triggerEndTime: 0, postGap: 0, command: command) + } + + private func isTriggerOnly(transcript: String, triggers: [String]) -> Bool { + guard WakeWordGate.matchesTextOnly(text: transcript, triggers: triggers) else { return false } + guard VoiceWakeTextUtils.startsWithTrigger(transcript: transcript, triggers: triggers) else { return false } + return Self.trimmedAfterTrigger(transcript, triggers: triggers).isEmpty + } + + private func preDetectSilenceCheck( + lastSeenAt: Date?, + lastText: String?, + triggers: [String], + gateConfig: WakeWordGateConfig, + config: RuntimeConfig) async + { + guard !Task.isCancelled else { return } + guard !self.isCapturing else { return } + guard let lastSeenAt, let lastText else { return } + guard self.lastTranscriptAt == lastSeenAt, self.lastTranscript == lastText else { return } + guard let match = self.textOnlyFallbackMatch( + transcript: lastText, + triggers: triggers, + config: gateConfig) + else { return } + if let cooldown = self.cooldownUntil, Date() < cooldown { + return + } + self.logger.info("voicewake runtime detected (silence fallback) len=\(match.command.count)") + await self.beginCapture( + command: match.command, + triggerEndTime: match.triggerEndTime, + config: config) + } + + private func beginCapture(command: String, triggerEndTime: TimeInterval?, config: RuntimeConfig) async { + self.listeningState = .voiceWake + self.isCapturing = true + DiagnosticsFileLog.shared.log(category: "voicewake.runtime", event: "beginCapture") + self.capturedTranscript = command + self.committedTranscript = "" + self.volatileTranscript = command + self.captureStartedAt = Date() + self.cooldownUntil = nil + self.heardBeyondTrigger = !command.isEmpty + self.triggerChimePlayed = false + self.activeTriggerEndTime = triggerEndTime + self.preDetectTask?.cancel() + self.preDetectTask = nil + self.triggerOnlyTask?.cancel() + self.triggerOnlyTask = nil + + if config.triggerChime != .none, !self.triggerChimePlayed { + self.triggerChimePlayed = true + await MainActor.run { VoiceWakeChimePlayer.play(config.triggerChime, reason: "voicewake.trigger") } + } + + let snapshot = self.committedTranscript + self.volatileTranscript + let attributed = Self.makeAttributed( + committed: self.committedTranscript, + volatile: self.volatileTranscript, + isFinal: false) + self.overlayToken = await MainActor.run { + VoiceSessionCoordinator.shared.startSession( + source: .wakeWord, + text: snapshot, + attributed: attributed, + forwardEnabled: true) + } + + // Keep the "ears" boosted for the capture window so the status icon animates while recording. + await MainActor.run { AppStateStore.shared.triggerVoiceEars(ttl: nil) } + + self.captureTask?.cancel() + self.captureTask = Task { [weak self] in + guard let self else { return } + await self.monitorCapture(config: config) + } + } + + private func monitorCapture(config: RuntimeConfig) async { + let start = self.captureStartedAt ?? Date() + let hardStop = start.addingTimeInterval(self.captureHardStop) + + while self.isCapturing { + let now = Date() + if now >= hardStop { + // Hard-stop after a maximum duration so we never leave the recognizer pinned open. + await self.finalizeCapture(config: config) + return + } + + let silenceThreshold = self.heardBeyondTrigger ? self.silenceWindow : self.triggerOnlySilenceWindow + if let last = self.lastHeard, now.timeIntervalSince(last) >= silenceThreshold { + await self.finalizeCapture(config: config) + return + } + + try? await Task.sleep(nanoseconds: 200_000_000) + } + } + + private func finalizeCapture(config: RuntimeConfig) async { + guard self.isCapturing else { return } + self.isCapturing = false + // Disarm trigger matching immediately (before halting recognition) to avoid double-trigger + // races from late callbacks that arrive after isCapturing is cleared. + self.cooldownUntil = Date().addingTimeInterval(self.debounceAfterSend) + self.captureTask?.cancel() + self.captureTask = nil + + let finalTranscript = self.capturedTranscript.trimmingCharacters(in: .whitespacesAndNewlines) + DiagnosticsFileLog.shared.log(category: "voicewake.runtime", event: "finalizeCapture", fields: [ + "finalLen": "\(finalTranscript.count)", + ]) + // Stop further recognition events so we don't retrigger immediately with buffered audio. + self.haltRecognitionPipeline() + self.capturedTranscript = "" + self.captureStartedAt = nil + self.lastHeard = nil + self.heardBeyondTrigger = false + self.triggerChimePlayed = false + self.activeTriggerEndTime = nil + self.lastTranscript = nil + self.lastTranscriptAt = nil + self.preDetectTask?.cancel() + self.preDetectTask = nil + self.triggerOnlyTask?.cancel() + self.triggerOnlyTask = nil + + await MainActor.run { AppStateStore.shared.stopVoiceEars() } + if let token = self.overlayToken { + await MainActor.run { VoiceSessionCoordinator.shared.updateLevel(token: token, 0) } + } + + let delay: TimeInterval = 0.0 + let sendChime = finalTranscript.isEmpty ? .none : config.sendChime + if let token = self.overlayToken { + await MainActor.run { + VoiceSessionCoordinator.shared.finalize( + token: token, + text: finalTranscript, + sendChime: sendChime, + autoSendAfter: delay) + } + } else if !finalTranscript.isEmpty { + if sendChime != .none { + await MainActor.run { VoiceWakeChimePlayer.play(sendChime, reason: "voicewake.send") } + } + Task.detached { + await VoiceWakeForwarder.forward(transcript: finalTranscript) + } + } + self.overlayToken = nil + self.scheduleRestartRecognizer() + } + + // MARK: - Audio level handling + + private func noteAudioLevel(rms: Double) { + guard self.isCapturing else { return } + + // Update adaptive noise floor: faster when lower energy (quiet), slower when loud. + let alpha: Double = rms < self.noiseFloorRMS ? 0.08 : 0.01 + self.noiseFloorRMS = max(1e-7, self.noiseFloorRMS + (rms - self.noiseFloorRMS) * alpha) + + let threshold = max(self.minSpeechRMS, self.noiseFloorRMS * self.speechBoostFactor) + if rms >= threshold { + self.lastHeard = Date() + } + + // Normalize against the adaptive threshold so the UI meter stays roughly 0...1 across devices. + let clamped = min(1.0, max(0.0, rms / max(self.minSpeechRMS, threshold))) + if let token = self.overlayToken { + Task { @MainActor in + VoiceSessionCoordinator.shared.updateLevel(token: token, clamped) + } + } + } + + private static func rmsLevel(buffer: AVAudioPCMBuffer) -> Double? { + guard let channelData = buffer.floatChannelData?.pointee else { return nil } + let frameCount = Int(buffer.frameLength) + guard frameCount > 0 else { return nil } + var sum: Double = 0 + for i in 0.. String { + let lower = text.lowercased() + for trigger in triggers { + let token = trigger.lowercased().trimmingCharacters(in: .whitespacesAndNewlines) + guard !token.isEmpty, let range = lower.range(of: token) else { continue } + let after = range.upperBound + let trimmed = text[after...].trimmingCharacters(in: .whitespacesAndNewlines) + return String(trimmed) + } + return text + } + + private static func commandAfterTrigger( + transcript: String, + segments: [WakeWordSegment], + triggerEndTime: TimeInterval?, + triggers: [String]) -> String + { + guard let triggerEndTime else { + return self.trimmedAfterTrigger(transcript, triggers: triggers) + } + let trimmed = WakeWordGate.commandText( + transcript: transcript, + segments: segments, + triggerEndTime: triggerEndTime) + return trimmed.isEmpty ? self.trimmedAfterTrigger(transcript, triggers: triggers) : trimmed + } + + #if DEBUG + static func _testTrimmedAfterTrigger(_ text: String, triggers: [String]) -> String { + self.trimmedAfterTrigger(text, triggers: triggers) + } + + static func _testHasContentAfterTrigger(_ text: String, triggers: [String]) -> Bool { + !self.trimmedAfterTrigger(text, triggers: triggers).isEmpty + } + + static func _testAttributedColor(isFinal: Bool) -> NSColor { + self.makeAttributed(committed: "sample", volatile: "", isFinal: isFinal) + .attribute(.foregroundColor, at: 0, effectiveRange: nil) as? NSColor ?? .clear + } + + #endif + + private static func delta(after committed: String, current: String) -> String { + if current.hasPrefix(committed) { + let start = current.index(current.startIndex, offsetBy: committed.count) + return String(current[start...]) + } + return current + } + + private static func makeAttributed(committed: String, volatile: String, isFinal: Bool) -> NSAttributedString { + let full = NSMutableAttributedString() + let committedAttr: [NSAttributedString.Key: Any] = [ + .foregroundColor: NSColor.labelColor, + .font: NSFont.systemFont(ofSize: 13, weight: .regular), + ] + full.append(NSAttributedString(string: committed, attributes: committedAttr)) + let volatileColor: NSColor = isFinal ? .labelColor : NSColor.tertiaryLabelColor + let volatileAttr: [NSAttributedString.Key: Any] = [ + .foregroundColor: volatileColor, + .font: NSFont.systemFont(ofSize: 13, weight: .regular), + ] + full.append(NSAttributedString(string: volatile, attributes: volatileAttr)) + return full + } +} diff --git a/apps/macos/Sources/Moltbot/VoiceWakeTester.swift b/apps/macos/Sources/Moltbot/VoiceWakeTester.swift new file mode 100644 index 000000000..05c8148b6 --- /dev/null +++ b/apps/macos/Sources/Moltbot/VoiceWakeTester.swift @@ -0,0 +1,473 @@ +import AVFoundation +import Foundation +import Speech +import SwabbleKit + +enum VoiceWakeTestState: Equatable { + case idle + case requesting + case listening + case hearing(String) + case finalizing + case detected(String) + case failed(String) +} + +final class VoiceWakeTester { + private let recognizer: SFSpeechRecognizer? + private var audioEngine: AVAudioEngine? + private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest? + private var recognitionTask: SFSpeechRecognitionTask? + private var isStopping = false + private var isFinalizing = false + private var detectionStart: Date? + private var lastHeard: Date? + private var lastLoggedText: String? + private var lastLoggedAt: Date? + private var lastTranscript: String? + private var lastTranscriptAt: Date? + private var silenceTask: Task? + private var currentTriggers: [String] = [] + private var holdingAfterDetect = false + private var detectedText: String? + private let logger = Logger(subsystem: "bot.molt", category: "voicewake") + private let silenceWindow: TimeInterval = 1.0 + + init(locale: Locale = .current) { + self.recognizer = SFSpeechRecognizer(locale: locale) + } + + func start( + triggers: [String], + micID: String?, + localeID: String?, + onUpdate: @escaping @Sendable (VoiceWakeTestState) -> Void) async throws + { + guard self.recognitionTask == nil else { return } + self.isStopping = false + self.isFinalizing = false + self.holdingAfterDetect = false + self.detectedText = nil + self.lastHeard = nil + self.lastLoggedText = nil + self.lastLoggedAt = nil + self.lastTranscript = nil + self.lastTranscriptAt = nil + self.silenceTask?.cancel() + self.silenceTask = nil + self.currentTriggers = triggers + let chosenLocale = localeID.flatMap { Locale(identifier: $0) } ?? Locale.current + let recognizer = SFSpeechRecognizer(locale: chosenLocale) + guard let recognizer, recognizer.isAvailable else { + throw NSError( + domain: "VoiceWakeTester", + code: 1, + userInfo: [NSLocalizedDescriptionKey: "Speech recognition unavailable"]) + } + recognizer.defaultTaskHint = .dictation + + guard Self.hasPrivacyStrings else { + throw NSError( + domain: "VoiceWakeTester", + code: 3, + userInfo: [ + NSLocalizedDescriptionKey: """ + Missing mic/speech privacy strings. Rebuild the mac app (scripts/restart-mac.sh) \ + to include usage descriptions. + """, + ]) + } + + let granted = try await Self.ensurePermissions() + guard granted else { + throw NSError( + domain: "VoiceWakeTester", + code: 2, + userInfo: [NSLocalizedDescriptionKey: "Microphone or speech permission denied"]) + } + + self.logInputSelection(preferredMicID: micID) + self.configureSession(preferredMicID: micID) + + let engine = AVAudioEngine() + self.audioEngine = engine + + self.recognitionRequest = SFSpeechAudioBufferRecognitionRequest() + self.recognitionRequest?.shouldReportPartialResults = true + self.recognitionRequest?.taskHint = .dictation + let request = self.recognitionRequest + + let inputNode = engine.inputNode + let format = inputNode.outputFormat(forBus: 0) + guard format.channelCount > 0, format.sampleRate > 0 else { + self.audioEngine = nil + throw NSError( + domain: "VoiceWakeTester", + code: 4, + userInfo: [NSLocalizedDescriptionKey: "No audio input available"]) + } + inputNode.removeTap(onBus: 0) + inputNode.installTap(onBus: 0, bufferSize: 2048, format: format) { [weak request] buffer, _ in + request?.append(buffer) + } + + engine.prepare() + try engine.start() + DispatchQueue.main.async { + onUpdate(.listening) + } + + self.detectionStart = Date() + self.lastHeard = self.detectionStart + + guard let request = recognitionRequest else { return } + + self.recognitionTask = recognizer.recognitionTask(with: request) { [weak self] result, error in + guard let self, !self.isStopping else { return } + let text = result?.bestTranscription.formattedString ?? "" + let segments = result.map { WakeWordSpeechSegments.from( + transcription: $0.bestTranscription, + transcript: text) } ?? [] + let isFinal = result?.isFinal ?? false + let gateConfig = WakeWordGateConfig(triggers: triggers) + var match = WakeWordGate.match(transcript: text, segments: segments, config: gateConfig) + if match == nil, isFinal { + match = self.textOnlyFallbackMatch( + transcript: text, + triggers: triggers, + config: gateConfig) + } + self.maybeLogDebug( + transcript: text, + segments: segments, + triggers: triggers, + match: match, + isFinal: isFinal) + let errorMessage = error?.localizedDescription + + Task { [weak self] in + guard let self, !self.isStopping else { return } + await self.handleResult( + match: match, + text: text, + isFinal: isFinal, + errorMessage: errorMessage, + onUpdate: onUpdate) + } + } + } + + func stop() { + self.stop(force: true) + } + + func finalize(timeout: TimeInterval = 1.5) { + guard self.recognitionTask != nil else { + self.stop(force: true) + return + } + self.isFinalizing = true + self.recognitionRequest?.endAudio() + if let engine = self.audioEngine { + engine.inputNode.removeTap(onBus: 0) + engine.stop() + } + Task { [weak self] in + guard let self else { return } + try? await Task.sleep(nanoseconds: UInt64(timeout * 1_000_000_000)) + if !self.isStopping { + self.stop(force: true) + } + } + } + + private func stop(force: Bool) { + if force { self.isStopping = true } + self.isFinalizing = false + self.recognitionRequest?.endAudio() + self.recognitionTask?.cancel() + self.recognitionTask = nil + self.recognitionRequest = nil + if let engine = self.audioEngine { + engine.inputNode.removeTap(onBus: 0) + engine.stop() + } + self.audioEngine = nil + self.holdingAfterDetect = false + self.detectedText = nil + self.lastHeard = nil + self.detectionStart = nil + self.lastLoggedText = nil + self.lastLoggedAt = nil + self.lastTranscript = nil + self.lastTranscriptAt = nil + self.silenceTask?.cancel() + self.silenceTask = nil + self.currentTriggers = [] + } + + private func handleResult( + match: WakeWordGateMatch?, + text: String, + isFinal: Bool, + errorMessage: String?, + onUpdate: @escaping @Sendable (VoiceWakeTestState) -> Void) async + { + if !text.isEmpty { + self.lastHeard = Date() + self.lastTranscript = text + self.lastTranscriptAt = Date() + } + if self.holdingAfterDetect { + return + } + if let match, !match.command.isEmpty { + self.holdingAfterDetect = true + self.detectedText = match.command + self.logger.info("voice wake detected (test) (len=\(match.command.count))") + await MainActor.run { AppStateStore.shared.triggerVoiceEars(ttl: nil) } + self.stop() + await MainActor.run { + AppStateStore.shared.stopVoiceEars() + onUpdate(.detected(match.command)) + } + return + } + if !isFinal, !text.isEmpty { + self.scheduleSilenceCheck( + triggers: self.currentTriggers, + onUpdate: onUpdate) + } + if self.isFinalizing { + Task { @MainActor in onUpdate(.finalizing) } + } + if let errorMessage { + self.stop(force: true) + Task { @MainActor in onUpdate(.failed(errorMessage)) } + return + } + if isFinal { + self.stop(force: true) + let state: VoiceWakeTestState = text.isEmpty + ? .failed("No speech detected") + : .failed("No trigger heard: “\(text)”") + Task { @MainActor in onUpdate(state) } + } else { + let state: VoiceWakeTestState = text.isEmpty ? .listening : .hearing(text) + Task { @MainActor in onUpdate(state) } + } + } + + private func maybeLogDebug( + transcript: String, + segments: [WakeWordSegment], + triggers: [String], + match: WakeWordGateMatch?, + isFinal: Bool) + { + guard !transcript.isEmpty else { return } + let level = self.logger.logLevel + guard level == .debug || level == .trace else { return } + if transcript == self.lastLoggedText, !isFinal { + if let last = self.lastLoggedAt, Date().timeIntervalSince(last) < 0.25 { + return + } + } + self.lastLoggedText = transcript + self.lastLoggedAt = Date() + + let textOnly = WakeWordGate.matchesTextOnly(text: transcript, triggers: triggers) + let gaps = Self.debugCandidateGaps(triggers: triggers, segments: segments) + let segmentSummary = Self.debugSegments(segments) + let timingCount = segments.count(where: { $0.start > 0 || $0.duration > 0 }) + let matchSummary = match.map { + "match=true gap=\(String(format: "%.2f", $0.postGap))s cmdLen=\($0.command.count)" + } ?? "match=false" + + self.logger.debug( + "voicewake test transcript='\(transcript, privacy: .private)' textOnly=\(textOnly) " + + "isFinal=\(isFinal) timing=\(timingCount)/\(segments.count) " + + "\(matchSummary) gaps=[\(gaps, privacy: .private)] segments=[\(segmentSummary, privacy: .private)]") + } + + private static func debugSegments(_ segments: [WakeWordSegment]) -> String { + segments.map { seg in + let start = String(format: "%.2f", seg.start) + let end = String(format: "%.2f", seg.end) + return "\(seg.text)@\(start)-\(end)" + }.joined(separator: ", ") + } + + private static func debugCandidateGaps(triggers: [String], segments: [WakeWordSegment]) -> String { + let tokens = self.normalizeSegments(segments) + guard !tokens.isEmpty else { return "" } + let triggerTokens = self.normalizeTriggers(triggers) + var gaps: [String] = [] + + for trigger in triggerTokens { + let count = trigger.tokens.count + guard count > 0, tokens.count > count else { continue } + for i in 0...(tokens.count - count - 1) { + let matched = (0.. [DebugTriggerTokens] { + var output: [DebugTriggerTokens] = [] + for trigger in triggers { + let tokens = trigger + .split(whereSeparator: { $0.isWhitespace }) + .map { VoiceWakeTextUtils.normalizeToken(String($0)) } + .filter { !$0.isEmpty } + if tokens.isEmpty { continue } + output.append(DebugTriggerTokens(tokens: tokens)) + } + return output + } + + private static func normalizeSegments(_ segments: [WakeWordSegment]) -> [DebugToken] { + segments.compactMap { segment in + let normalized = VoiceWakeTextUtils.normalizeToken(segment.text) + guard !normalized.isEmpty else { return nil } + return DebugToken( + normalized: normalized, + start: segment.start, + end: segment.end) + } + } + + private func textOnlyFallbackMatch( + transcript: String, + triggers: [String], + config: WakeWordGateConfig) -> WakeWordGateMatch? + { + guard let command = VoiceWakeTextUtils.textOnlyCommand( + transcript: transcript, + triggers: triggers, + minCommandLength: config.minCommandLength, + trimWake: { WakeWordGate.stripWake(text: $0, triggers: $1) }) + else { return nil } + return WakeWordGateMatch(triggerEndTime: 0, postGap: 0, command: command) + } + + private func holdUntilSilence(onUpdate: @escaping @Sendable (VoiceWakeTestState) -> Void) { + Task { [weak self] in + guard let self else { return } + let detectedAt = Date() + let hardStop = detectedAt.addingTimeInterval(6) // cap overall listen after trigger + + while !self.isStopping { + let now = Date() + if now >= hardStop { break } + if let last = self.lastHeard, now.timeIntervalSince(last) >= silenceWindow { + break + } + try? await Task.sleep(nanoseconds: 200_000_000) + } + if !self.isStopping { + self.stop() + await MainActor.run { AppStateStore.shared.stopVoiceEars() } + if let detectedText { + self.logger.info("voice wake hold finished; len=\(detectedText.count)") + Task { @MainActor in onUpdate(.detected(detectedText)) } + } + } + } + } + + private func scheduleSilenceCheck( + triggers: [String], + onUpdate: @escaping @Sendable (VoiceWakeTestState) -> Void) + { + self.silenceTask?.cancel() + let lastSeenAt = self.lastTranscriptAt + let lastText = self.lastTranscript + self.silenceTask = Task { [weak self] in + guard let self else { return } + try? await Task.sleep(nanoseconds: UInt64(self.silenceWindow * 1_000_000_000)) + guard !Task.isCancelled else { return } + guard !self.isStopping, !self.holdingAfterDetect else { return } + guard let lastSeenAt, let lastText else { return } + guard self.lastTranscriptAt == lastSeenAt, self.lastTranscript == lastText else { return } + guard let match = self.textOnlyFallbackMatch( + transcript: lastText, + triggers: triggers, + config: WakeWordGateConfig(triggers: triggers)) else { return } + self.holdingAfterDetect = true + self.detectedText = match.command + self.logger.info("voice wake detected (test, silence) (len=\(match.command.count))") + await MainActor.run { AppStateStore.shared.triggerVoiceEars(ttl: nil) } + self.stop() + await MainActor.run { + AppStateStore.shared.stopVoiceEars() + onUpdate(.detected(match.command)) + } + } + } + + private func configureSession(preferredMicID: String?) { + _ = preferredMicID + } + + private func logInputSelection(preferredMicID: String?) { + let preferred = (preferredMicID?.isEmpty == false) ? preferredMicID! : "system-default" + self.logger.info( + "voicewake test input preferred=\(preferred, privacy: .public) " + + "\(AudioInputDeviceObserver.defaultInputDeviceSummary(), privacy: .public)") + } + + private nonisolated static func ensurePermissions() async throws -> Bool { + let speechStatus = SFSpeechRecognizer.authorizationStatus() + if speechStatus == .notDetermined { + let granted = await withCheckedContinuation { continuation in + SFSpeechRecognizer.requestAuthorization { status in + continuation.resume(returning: status == .authorized) + } + } + guard granted else { return false } + } else if speechStatus != .authorized { + return false + } + + let micStatus = AVCaptureDevice.authorizationStatus(for: .audio) + switch micStatus { + case .authorized: return true + + case .notDetermined: + return await withCheckedContinuation { continuation in + AVCaptureDevice.requestAccess(for: .audio) { granted in + continuation.resume(returning: granted) + } + } + + default: + return false + } + } + + private static var hasPrivacyStrings: Bool { + let speech = Bundle.main.object(forInfoDictionaryKey: "NSSpeechRecognitionUsageDescription") as? String + let mic = Bundle.main.object(forInfoDictionaryKey: "NSMicrophoneUsageDescription") as? String + return speech?.isEmpty == false && mic?.isEmpty == false + } +} + +extension VoiceWakeTester: @unchecked Sendable {} diff --git a/apps/macos/Sources/Moltbot/WebChatSwiftUI.swift b/apps/macos/Sources/Moltbot/WebChatSwiftUI.swift new file mode 100644 index 000000000..c457ceb2a --- /dev/null +++ b/apps/macos/Sources/Moltbot/WebChatSwiftUI.swift @@ -0,0 +1,374 @@ +import AppKit +import MoltbotChatUI +import MoltbotKit +import MoltbotProtocol +import Foundation +import OSLog +import QuartzCore +import SwiftUI + +private let webChatSwiftLogger = Logger(subsystem: "bot.molt", category: "WebChatSwiftUI") + +private enum WebChatSwiftUILayout { + static let windowSize = NSSize(width: 500, height: 840) + static let panelSize = NSSize(width: 480, height: 640) + static let windowMinSize = NSSize(width: 480, height: 360) + static let anchorPadding: CGFloat = 8 +} + +struct MacGatewayChatTransport: MoltbotChatTransport, Sendable { + func requestHistory(sessionKey: String) async throws -> MoltbotChatHistoryPayload { + try await GatewayConnection.shared.chatHistory(sessionKey: sessionKey) + } + + func abortRun(sessionKey: String, runId: String) async throws { + _ = try await GatewayConnection.shared.request( + method: "chat.abort", + params: [ + "sessionKey": AnyCodable(sessionKey), + "runId": AnyCodable(runId), + ], + timeoutMs: 10000) + } + + func listSessions(limit: Int?) async throws -> MoltbotChatSessionsListResponse { + var params: [String: AnyCodable] = [ + "includeGlobal": AnyCodable(true), + "includeUnknown": AnyCodable(false), + ] + if let limit { + params["limit"] = AnyCodable(limit) + } + let data = try await GatewayConnection.shared.request( + method: "sessions.list", + params: params, + timeoutMs: 15000) + return try JSONDecoder().decode(MoltbotChatSessionsListResponse.self, from: data) + } + + func sendMessage( + sessionKey: String, + message: String, + thinking: String, + idempotencyKey: String, + attachments: [MoltbotChatAttachmentPayload]) async throws -> MoltbotChatSendResponse + { + try await GatewayConnection.shared.chatSend( + sessionKey: sessionKey, + message: message, + thinking: thinking, + idempotencyKey: idempotencyKey, + attachments: attachments) + } + + func requestHealth(timeoutMs: Int) async throws -> Bool { + try await GatewayConnection.shared.healthOK(timeoutMs: timeoutMs) + } + + func events() -> AsyncStream { + AsyncStream { continuation in + let task = Task { + do { + try await GatewayConnection.shared.refresh() + } catch { + webChatSwiftLogger.error("gateway refresh failed \(error.localizedDescription, privacy: .public)") + } + + let stream = await GatewayConnection.shared.subscribe() + for await push in stream { + if Task.isCancelled { return } + if let evt = Self.mapPushToTransportEvent(push) { + continuation.yield(evt) + } + } + } + + continuation.onTermination = { @Sendable _ in + task.cancel() + } + } + } + + static func mapPushToTransportEvent(_ push: GatewayPush) -> MoltbotChatTransportEvent? { + switch push { + case let .snapshot(hello): + let ok = (try? JSONDecoder().decode( + MoltbotGatewayHealthOK.self, + from: JSONEncoder().encode(hello.snapshot.health)))?.ok ?? true + return .health(ok: ok) + + case let .event(evt): + switch evt.event { + case "health": + guard let payload = evt.payload else { return nil } + let ok = (try? JSONDecoder().decode( + MoltbotGatewayHealthOK.self, + from: JSONEncoder().encode(payload)))?.ok ?? true + return .health(ok: ok) + case "tick": + return .tick + case "chat": + guard let payload = evt.payload else { return nil } + guard let chat = try? JSONDecoder().decode( + MoltbotChatEventPayload.self, + from: JSONEncoder().encode(payload)) + else { + return nil + } + return .chat(chat) + case "agent": + guard let payload = evt.payload else { return nil } + guard let agent = try? JSONDecoder().decode( + MoltbotAgentEventPayload.self, + from: JSONEncoder().encode(payload)) + else { + return nil + } + return .agent(agent) + default: + return nil + } + + case .seqGap: + return .seqGap + } + } +} + +// MARK: - Window controller + +@MainActor +final class WebChatSwiftUIWindowController { + private let presentation: WebChatPresentation + private let sessionKey: String + private let hosting: NSHostingController + private let contentController: NSViewController + private var window: NSWindow? + private var dismissMonitor: Any? + var onClosed: (() -> Void)? + var onVisibilityChanged: ((Bool) -> Void)? + + convenience init(sessionKey: String, presentation: WebChatPresentation) { + self.init(sessionKey: sessionKey, presentation: presentation, transport: MacGatewayChatTransport()) + } + + init(sessionKey: String, presentation: WebChatPresentation, transport: any MoltbotChatTransport) { + self.sessionKey = sessionKey + self.presentation = presentation + let vm = MoltbotChatViewModel(sessionKey: sessionKey, transport: transport) + let accent = Self.color(fromHex: AppStateStore.shared.seamColorHex) + self.hosting = NSHostingController(rootView: MoltbotChatView( + viewModel: vm, + showsSessionSwitcher: true, + userAccent: accent)) + self.contentController = Self.makeContentController(for: presentation, hosting: self.hosting) + self.window = Self.makeWindow(for: presentation, contentViewController: self.contentController) + } + + deinit {} + + var isVisible: Bool { + self.window?.isVisible ?? false + } + + func show() { + guard let window else { return } + self.ensureWindowSize() + window.makeKeyAndOrderFront(nil) + NSApp.activate(ignoringOtherApps: true) + self.onVisibilityChanged?(true) + } + + func presentAnchored(anchorProvider: () -> NSRect?) { + guard case .panel = self.presentation, let window else { return } + self.installDismissMonitor() + let target = self.reposition(using: anchorProvider) + + if !self.isVisible { + let start = target.offsetBy(dx: 0, dy: 8) + window.setFrame(start, display: true) + window.alphaValue = 0 + window.makeKeyAndOrderFront(nil) + NSApp.activate(ignoringOtherApps: true) + NSAnimationContext.runAnimationGroup { context in + context.duration = 0.18 + context.timingFunction = CAMediaTimingFunction(name: .easeOut) + window.animator().setFrame(target, display: true) + window.animator().alphaValue = 1 + } + } else { + window.makeKeyAndOrderFront(nil) + NSApp.activate(ignoringOtherApps: true) + } + + self.onVisibilityChanged?(true) + } + + func close() { + self.window?.orderOut(nil) + self.onVisibilityChanged?(false) + self.onClosed?() + self.removeDismissMonitor() + } + + @discardableResult + private func reposition(using anchorProvider: () -> NSRect?) -> NSRect { + guard let window else { return .zero } + guard let anchor = anchorProvider() else { + let frame = WindowPlacement.topRightFrame( + size: WebChatSwiftUILayout.panelSize, + padding: WebChatSwiftUILayout.anchorPadding) + window.setFrame(frame, display: false) + return frame + } + let screen = NSScreen.screens.first { screen in + screen.frame.contains(anchor.origin) || screen.frame.contains(NSPoint(x: anchor.midX, y: anchor.midY)) + } ?? NSScreen.main + let bounds = (screen?.visibleFrame ?? .zero).insetBy( + dx: WebChatSwiftUILayout.anchorPadding, + dy: WebChatSwiftUILayout.anchorPadding) + let frame = WindowPlacement.anchoredBelowFrame( + size: WebChatSwiftUILayout.panelSize, + anchor: anchor, + padding: WebChatSwiftUILayout.anchorPadding, + in: bounds) + window.setFrame(frame, display: false) + return frame + } + + private func installDismissMonitor() { + if ProcessInfo.processInfo.isRunningTests { return } + guard self.dismissMonitor == nil, self.window != nil else { return } + self.dismissMonitor = NSEvent.addGlobalMonitorForEvents( + matching: [.leftMouseDown, .rightMouseDown, .otherMouseDown]) + { [weak self] _ in + guard let self, let win = self.window else { return } + let pt = NSEvent.mouseLocation + if !win.frame.contains(pt) { + self.close() + } + } + } + + private func removeDismissMonitor() { + if let monitor = self.dismissMonitor { + NSEvent.removeMonitor(monitor) + self.dismissMonitor = nil + } + } + + private static func makeWindow( + for presentation: WebChatPresentation, + contentViewController: NSViewController) -> NSWindow + { + switch presentation { + case .window: + let window = NSWindow( + contentRect: NSRect(origin: .zero, size: WebChatSwiftUILayout.windowSize), + styleMask: [.titled, .closable, .resizable, .miniaturizable], + backing: .buffered, + defer: false) + window.title = "Moltbot Chat" + window.contentViewController = contentViewController + window.isReleasedWhenClosed = false + window.titleVisibility = .visible + window.titlebarAppearsTransparent = false + window.backgroundColor = .clear + window.isOpaque = false + window.center() + WindowPlacement.ensureOnScreen(window: window, defaultSize: WebChatSwiftUILayout.windowSize) + window.minSize = WebChatSwiftUILayout.windowMinSize + window.contentView?.wantsLayer = true + window.contentView?.layer?.backgroundColor = NSColor.clear.cgColor + return window + case .panel: + let panel = WebChatPanel( + contentRect: NSRect(origin: .zero, size: WebChatSwiftUILayout.panelSize), + styleMask: [.borderless], + backing: .buffered, + defer: false) + panel.level = .statusBar + panel.hidesOnDeactivate = true + panel.hasShadow = true + panel.isMovable = false + panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary] + panel.titleVisibility = .hidden + panel.titlebarAppearsTransparent = true + panel.backgroundColor = .clear + panel.isOpaque = false + panel.contentViewController = contentViewController + panel.becomesKeyOnlyIfNeeded = true + panel.contentView?.wantsLayer = true + panel.contentView?.layer?.backgroundColor = NSColor.clear.cgColor + panel.setFrame( + WindowPlacement.topRightFrame( + size: WebChatSwiftUILayout.panelSize, + padding: WebChatSwiftUILayout.anchorPadding), + display: false) + return panel + } + } + + private static func makeContentController( + for presentation: WebChatPresentation, + hosting: NSHostingController) -> NSViewController + { + let controller = NSViewController() + let effectView = NSVisualEffectView() + effectView.material = .sidebar + effectView.blendingMode = .behindWindow + effectView.state = .active + effectView.wantsLayer = true + effectView.layer?.cornerCurve = .continuous + let cornerRadius: CGFloat = switch presentation { + case .panel: + 16 + case .window: + 0 + } + effectView.layer?.cornerRadius = cornerRadius + effectView.layer?.masksToBounds = true + + effectView.translatesAutoresizingMaskIntoConstraints = true + effectView.autoresizingMask = [.width, .height] + let rootView = effectView + + hosting.view.translatesAutoresizingMaskIntoConstraints = false + hosting.view.wantsLayer = true + hosting.view.layer?.backgroundColor = NSColor.clear.cgColor + + controller.addChild(hosting) + effectView.addSubview(hosting.view) + controller.view = rootView + + NSLayoutConstraint.activate([ + hosting.view.leadingAnchor.constraint(equalTo: effectView.leadingAnchor), + hosting.view.trailingAnchor.constraint(equalTo: effectView.trailingAnchor), + hosting.view.topAnchor.constraint(equalTo: effectView.topAnchor), + hosting.view.bottomAnchor.constraint(equalTo: effectView.bottomAnchor), + ]) + + return controller + } + + private func ensureWindowSize() { + guard case .window = self.presentation, let window else { return } + let current = window.frame.size + let min = WebChatSwiftUILayout.windowMinSize + if current.width < min.width || current.height < min.height { + let frame = WindowPlacement.centeredFrame(size: WebChatSwiftUILayout.windowSize) + window.setFrame(frame, display: false) + } + } + + private static func color(fromHex raw: String?) -> Color? { + let trimmed = (raw ?? "").trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return nil } + let hex = trimmed.hasPrefix("#") ? String(trimmed.dropFirst()) : trimmed + guard hex.count == 6, let value = Int(hex, radix: 16) else { return nil } + let r = Double((value >> 16) & 0xFF) / 255.0 + let g = Double((value >> 8) & 0xFF) / 255.0 + let b = Double(value & 0xFF) / 255.0 + return Color(red: r, green: g, blue: b) + } +} diff --git a/apps/macos/Sources/MoltbotDiscovery/GatewayDiscoveryModel.swift b/apps/macos/Sources/MoltbotDiscovery/GatewayDiscoveryModel.swift new file mode 100644 index 000000000..69d8978ec --- /dev/null +++ b/apps/macos/Sources/MoltbotDiscovery/GatewayDiscoveryModel.swift @@ -0,0 +1,683 @@ +import MoltbotKit +import Foundation +import Network +import Observation +import OSLog + +@MainActor +@Observable +public final class GatewayDiscoveryModel { + public struct LocalIdentity: Equatable, Sendable { + public var hostTokens: Set + public var displayTokens: Set + + public init(hostTokens: Set, displayTokens: Set) { + self.hostTokens = hostTokens + self.displayTokens = displayTokens + } + } + + public struct DiscoveredGateway: Identifiable, Equatable, Sendable { + public var id: String { self.stableID } + public var displayName: String + public var lanHost: String? + public var tailnetDns: String? + public var sshPort: Int + public var gatewayPort: Int? + public var cliPath: String? + public var stableID: String + public var debugID: String + public var isLocal: Bool + + public init( + displayName: String, + lanHost: String? = nil, + tailnetDns: String? = nil, + sshPort: Int, + gatewayPort: Int? = nil, + cliPath: String? = nil, + stableID: String, + debugID: String, + isLocal: Bool) + { + self.displayName = displayName + self.lanHost = lanHost + self.tailnetDns = tailnetDns + self.sshPort = sshPort + self.gatewayPort = gatewayPort + self.cliPath = cliPath + self.stableID = stableID + self.debugID = debugID + self.isLocal = isLocal + } + } + + public var gateways: [DiscoveredGateway] = [] + public var statusText: String = "Idle" + + private var browsers: [String: NWBrowser] = [:] + private var resultsByDomain: [String: Set] = [:] + private var gatewaysByDomain: [String: [DiscoveredGateway]] = [:] + private var statesByDomain: [String: NWBrowser.State] = [:] + private var localIdentity: LocalIdentity + private let localDisplayName: String? + private let filterLocalGateways: Bool + private var resolvedTXTByID: [String: [String: String]] = [:] + private var pendingTXTResolvers: [String: GatewayTXTResolver] = [:] + private var wideAreaFallbackTask: Task? + private var wideAreaFallbackGateways: [DiscoveredGateway] = [] + private let logger = Logger(subsystem: "bot.molt", category: "gateway-discovery") + + public init( + localDisplayName: String? = nil, + filterLocalGateways: Bool = true) + { + self.localDisplayName = localDisplayName + self.filterLocalGateways = filterLocalGateways + self.localIdentity = Self.buildLocalIdentityFast(displayName: localDisplayName) + self.refreshLocalIdentity() + } + + public func start() { + if !self.browsers.isEmpty { return } + + for domain in MoltbotBonjour.gatewayServiceDomains { + let params = NWParameters.tcp + params.includePeerToPeer = true + let browser = NWBrowser( + for: .bonjour(type: MoltbotBonjour.gatewayServiceType, domain: domain), + using: params) + + browser.stateUpdateHandler = { [weak self] state in + Task { @MainActor in + guard let self else { return } + self.statesByDomain[domain] = state + self.updateStatusText() + } + } + + browser.browseResultsChangedHandler = { [weak self] results, _ in + Task { @MainActor in + guard let self else { return } + self.resultsByDomain[domain] = results + self.updateGateways(for: domain) + self.recomputeGateways() + } + } + + self.browsers[domain] = browser + browser.start(queue: DispatchQueue(label: "bot.molt.macos.gateway-discovery.\(domain)")) + } + + self.scheduleWideAreaFallback() + } + + public func refreshWideAreaFallbackNow(timeoutSeconds: TimeInterval = 5.0) { + let domain = MoltbotBonjour.wideAreaGatewayServiceDomain + Task.detached(priority: .utility) { [weak self] in + guard let self else { return } + let beacons = WideAreaGatewayDiscovery.discover(timeoutSeconds: timeoutSeconds) + await MainActor.run { [weak self] in + guard let self else { return } + self.wideAreaFallbackGateways = self.mapWideAreaBeacons(beacons, domain: domain) + self.recomputeGateways() + } + } + } + + public func stop() { + for browser in self.browsers.values { + browser.cancel() + } + self.browsers = [:] + self.resultsByDomain = [:] + self.gatewaysByDomain = [:] + self.statesByDomain = [:] + self.resolvedTXTByID = [:] + self.pendingTXTResolvers.values.forEach { $0.cancel() } + self.pendingTXTResolvers = [:] + self.wideAreaFallbackTask?.cancel() + self.wideAreaFallbackTask = nil + self.wideAreaFallbackGateways = [] + self.gateways = [] + self.statusText = "Stopped" + } + + private func mapWideAreaBeacons(_ beacons: [WideAreaGatewayBeacon], domain: String) -> [DiscoveredGateway] { + beacons.map { beacon in + let stableID = "wide-area|\(domain)|\(beacon.instanceName)" + let isLocal = Self.isLocalGateway( + lanHost: beacon.lanHost, + tailnetDns: beacon.tailnetDns, + displayName: beacon.displayName, + serviceName: beacon.instanceName, + local: self.localIdentity) + return DiscoveredGateway( + displayName: beacon.displayName, + lanHost: beacon.lanHost, + tailnetDns: beacon.tailnetDns, + sshPort: beacon.sshPort ?? 22, + gatewayPort: beacon.gatewayPort, + cliPath: beacon.cliPath, + stableID: stableID, + debugID: "\(beacon.instanceName)@\(beacon.host):\(beacon.port)", + isLocal: isLocal) + } + } + + private func recomputeGateways() { + let primary = self.sortedDeduped(gateways: self.gatewaysByDomain.values.flatMap(\.self)) + let primaryFiltered = self.filterLocalGateways ? primary.filter { !$0.isLocal } : primary + if !primaryFiltered.isEmpty { + self.gateways = primaryFiltered + return + } + + // Bonjour can return only "local" results for the wide-area domain (or no results at all), + // which makes onboarding look empty even though Tailscale DNS-SD can already see gateways. + guard !self.wideAreaFallbackGateways.isEmpty else { + self.gateways = primaryFiltered + return + } + + let combined = self.sortedDeduped(gateways: primary + self.wideAreaFallbackGateways) + self.gateways = self.filterLocalGateways ? combined.filter { !$0.isLocal } : combined + } + + private func updateGateways(for domain: String) { + guard let results = self.resultsByDomain[domain] else { + self.gatewaysByDomain[domain] = [] + return + } + + self.gatewaysByDomain[domain] = results.compactMap { result -> DiscoveredGateway? in + guard case let .service(name, type, resultDomain, _) = result.endpoint else { return nil } + + let decodedName = BonjourEscapes.decode(name) + let stableID = GatewayEndpointID.stableID(result.endpoint) + let resolvedTXT = self.resolvedTXTByID[stableID] ?? [:] + let txt = Self.txtDictionary(from: result).merging( + resolvedTXT, + uniquingKeysWith: { _, new in new }) + + let advertisedName = txt["displayName"] + .map(Self.prettifyInstanceName) + .flatMap { $0.isEmpty ? nil : $0 } + let prettyName = + advertisedName ?? Self.prettifyServiceName(decodedName) + + let parsedTXT = Self.parseGatewayTXT(txt) + + if parsedTXT.lanHost == nil || parsedTXT.tailnetDns == nil { + self.ensureTXTResolution( + stableID: stableID, + serviceName: name, + type: type, + domain: resultDomain) + } + + let isLocal = Self.isLocalGateway( + lanHost: parsedTXT.lanHost, + tailnetDns: parsedTXT.tailnetDns, + displayName: prettyName, + serviceName: decodedName, + local: self.localIdentity) + return DiscoveredGateway( + displayName: prettyName, + lanHost: parsedTXT.lanHost, + tailnetDns: parsedTXT.tailnetDns, + sshPort: parsedTXT.sshPort, + gatewayPort: parsedTXT.gatewayPort, + cliPath: parsedTXT.cliPath, + stableID: stableID, + debugID: GatewayEndpointID.prettyDescription(result.endpoint), + isLocal: isLocal) + } + .sorted { $0.displayName.localizedCaseInsensitiveCompare($1.displayName) == .orderedAscending } + + if domain == MoltbotBonjour.wideAreaGatewayServiceDomain, + self.hasUsableWideAreaResults + { + self.wideAreaFallbackGateways = [] + } + } + + private func scheduleWideAreaFallback() { + let domain = MoltbotBonjour.wideAreaGatewayServiceDomain + if Self.isRunningTests { return } + guard self.wideAreaFallbackTask == nil else { return } + self.wideAreaFallbackTask = Task.detached(priority: .utility) { [weak self] in + guard let self else { return } + var attempt = 0 + let startedAt = Date() + while !Task.isCancelled, Date().timeIntervalSince(startedAt) < 35.0 { + let hasResults = await MainActor.run { + self.hasUsableWideAreaResults + } + if hasResults { return } + + // Wide-area discovery can be racy (Tailscale not yet up, DNS zone not + // published yet). Retry with a short backoff while onboarding is open. + let beacons = WideAreaGatewayDiscovery.discover(timeoutSeconds: 2.0) + if !beacons.isEmpty { + await MainActor.run { [weak self] in + guard let self else { return } + self.wideAreaFallbackGateways = self.mapWideAreaBeacons(beacons, domain: domain) + self.recomputeGateways() + } + return + } + + attempt += 1 + let backoff = min(8.0, 0.6 + (Double(attempt) * 0.7)) + try? await Task.sleep(nanoseconds: UInt64(backoff * 1_000_000_000)) + } + } + } + + private var hasUsableWideAreaResults: Bool { + let domain = MoltbotBonjour.wideAreaGatewayServiceDomain + guard let gateways = self.gatewaysByDomain[domain], !gateways.isEmpty else { return false } + if !self.filterLocalGateways { return true } + return gateways.contains(where: { !$0.isLocal }) + } + + private func sortedDeduped(gateways: [DiscoveredGateway]) -> [DiscoveredGateway] { + var seen = Set() + let deduped = gateways.filter { gateway in + if seen.contains(gateway.stableID) { return false } + seen.insert(gateway.stableID) + return true + } + return deduped.sorted { + $0.displayName.localizedCaseInsensitiveCompare($1.displayName) == .orderedAscending + } + } + + private nonisolated static var isRunningTests: Bool { + // Keep discovery background work from running forever during SwiftPM test runs. + if Bundle.allBundles.contains(where: { $0.bundleURL.pathExtension == "xctest" }) { return true } + + let env = ProcessInfo.processInfo.environment + return env["XCTestConfigurationFilePath"] != nil + || env["XCTestBundlePath"] != nil + || env["XCTestSessionIdentifier"] != nil + } + + private func updateGatewaysForAllDomains() { + for domain in self.resultsByDomain.keys { + self.updateGateways(for: domain) + } + } + + private func updateStatusText() { + let states = Array(self.statesByDomain.values) + if states.isEmpty { + self.statusText = self.browsers.isEmpty ? "Idle" : "Setup" + return + } + + if let failed = states.first(where: { state in + if case .failed = state { return true } + return false + }) { + if case let .failed(err) = failed { + self.statusText = "Failed: \(err)" + return + } + } + + if let waiting = states.first(where: { state in + if case .waiting = state { return true } + return false + }) { + if case let .waiting(err) = waiting { + self.statusText = "Waiting: \(err)" + return + } + } + + if states.contains(where: { if case .ready = $0 { true } else { false } }) { + self.statusText = "Searching…" + return + } + + if states.contains(where: { if case .setup = $0 { true } else { false } }) { + self.statusText = "Setup" + return + } + + self.statusText = "Searching…" + } + + private static func txtDictionary(from result: NWBrowser.Result) -> [String: String] { + var merged: [String: String] = [:] + + if case let .bonjour(txt) = result.metadata { + merged.merge(txt.dictionary, uniquingKeysWith: { _, new in new }) + } + + if let endpointTxt = result.endpoint.txtRecord?.dictionary { + merged.merge(endpointTxt, uniquingKeysWith: { _, new in new }) + } + + return merged + } + + public struct GatewayTXT: Equatable { + public var lanHost: String? + public var tailnetDns: String? + public var sshPort: Int + public var gatewayPort: Int? + public var cliPath: String? + } + + public static func parseGatewayTXT(_ txt: [String: String]) -> GatewayTXT { + var lanHost: String? + var tailnetDns: String? + var sshPort = 22 + var gatewayPort: Int? + var cliPath: String? + + if let value = txt["lanHost"] { + let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines) + lanHost = trimmed.isEmpty ? nil : trimmed + } + if let value = txt["tailnetDns"] { + let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines) + tailnetDns = trimmed.isEmpty ? nil : trimmed + } + if let value = txt["sshPort"], + let parsed = Int(value.trimmingCharacters(in: .whitespacesAndNewlines)), + parsed > 0 + { + sshPort = parsed + } + if let value = txt["gatewayPort"], + let parsed = Int(value.trimmingCharacters(in: .whitespacesAndNewlines)), + parsed > 0 + { + gatewayPort = parsed + } + if let value = txt["cliPath"] { + let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines) + cliPath = trimmed.isEmpty ? nil : trimmed + } + + return GatewayTXT( + lanHost: lanHost, + tailnetDns: tailnetDns, + sshPort: sshPort, + gatewayPort: gatewayPort, + cliPath: cliPath) + } + + public static func buildSSHTarget(user: String, host: String, port: Int) -> String { + var target = "\(user)@\(host)" + if port != 22 { + target += ":\(port)" + } + return target + } + + private func ensureTXTResolution( + stableID: String, + serviceName: String, + type: String, + domain: String) + { + guard self.resolvedTXTByID[stableID] == nil else { return } + guard self.pendingTXTResolvers[stableID] == nil else { return } + + let resolver = GatewayTXTResolver( + name: serviceName, + type: type, + domain: domain, + logger: self.logger) + { [weak self] result in + Task { @MainActor in + guard let self else { return } + self.pendingTXTResolvers[stableID] = nil + switch result { + case let .success(txt): + self.resolvedTXTByID[stableID] = txt + self.updateGatewaysForAllDomains() + self.recomputeGateways() + case .failure: + break + } + } + } + + self.pendingTXTResolvers[stableID] = resolver + resolver.start() + } + + private nonisolated static func prettifyInstanceName(_ decodedName: String) -> String { + let normalized = decodedName.split(whereSeparator: \.isWhitespace).joined(separator: " ") + let stripped = normalized.replacingOccurrences(of: " (Moltbot)", with: "") + .replacingOccurrences(of: #"\s+\(\d+\)$"#, with: "", options: .regularExpression) + return stripped.trimmingCharacters(in: .whitespacesAndNewlines) + } + + private nonisolated static func prettifyServiceName(_ decodedName: String) -> String { + let normalized = Self.prettifyInstanceName(decodedName) + var cleaned = normalized.replacingOccurrences(of: #"\s*-?gateway$"#, with: "", options: .regularExpression) + cleaned = cleaned + .replacingOccurrences(of: "_", with: " ") + .replacingOccurrences(of: "-", with: " ") + .replacingOccurrences(of: #"\s+"#, with: " ", options: .regularExpression) + .trimmingCharacters(in: .whitespacesAndNewlines) + if cleaned.isEmpty { + cleaned = normalized + } + let words = cleaned.split(separator: " ") + let titled = words.map { word -> String in + let lower = word.lowercased() + guard let first = lower.first else { return "" } + return String(first).uppercased() + lower.dropFirst() + }.joined(separator: " ") + return titled.isEmpty ? normalized : titled + } + + public nonisolated static func isLocalGateway( + lanHost: String?, + tailnetDns: String?, + displayName: String?, + serviceName: String?, + local: LocalIdentity) -> Bool + { + if let host = normalizeHostToken(lanHost), + local.hostTokens.contains(host) + { + return true + } + if let host = normalizeHostToken(tailnetDns), + local.hostTokens.contains(host) + { + return true + } + if let name = normalizeDisplayToken(displayName), + local.displayTokens.contains(name) + { + return true + } + if let serviceHost = normalizeServiceHostToken(serviceName), + local.hostTokens.contains(serviceHost) + { + return true + } + return false + } + + private func refreshLocalIdentity() { + let fastIdentity = self.localIdentity + let displayName = self.localDisplayName + Task.detached(priority: .utility) { + let slowIdentity = Self.buildLocalIdentitySlow(displayName: displayName) + let merged = Self.mergeLocalIdentity(fast: fastIdentity, slow: slowIdentity) + await MainActor.run { [weak self] in + guard let self else { return } + guard self.localIdentity != merged else { return } + self.localIdentity = merged + self.recomputeGateways() + } + } + } + + private nonisolated static func mergeLocalIdentity( + fast: LocalIdentity, + slow: LocalIdentity) -> LocalIdentity + { + LocalIdentity( + hostTokens: fast.hostTokens.union(slow.hostTokens), + displayTokens: fast.displayTokens.union(slow.displayTokens)) + } + + private nonisolated static func buildLocalIdentityFast(displayName: String?) -> LocalIdentity { + var hostTokens: Set = [] + var displayTokens: Set = [] + + let hostName = ProcessInfo.processInfo.hostName + if let token = normalizeHostToken(hostName) { + hostTokens.insert(token) + } + + if let token = normalizeDisplayToken(displayName) { + displayTokens.insert(token) + } + + return LocalIdentity(hostTokens: hostTokens, displayTokens: displayTokens) + } + + private nonisolated static func buildLocalIdentitySlow(displayName: String?) -> LocalIdentity { + var hostTokens: Set = [] + var displayTokens: Set = [] + + if let host = Host.current().name, + let token = normalizeHostToken(host) + { + hostTokens.insert(token) + } + + if let token = normalizeDisplayToken(displayName) { + displayTokens.insert(token) + } + + if let token = normalizeDisplayToken(Host.current().localizedName) { + displayTokens.insert(token) + } + + return LocalIdentity(hostTokens: hostTokens, displayTokens: displayTokens) + } + + private nonisolated static func normalizeHostToken(_ raw: String?) -> String? { + guard let raw else { return nil } + let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) + if trimmed.isEmpty { return nil } + let lower = trimmed.lowercased() + let strippedTrailingDot = lower.hasSuffix(".") + ? String(lower.dropLast()) + : lower + let withoutLocal = strippedTrailingDot.hasSuffix(".local") + ? String(strippedTrailingDot.dropLast(6)) + : strippedTrailingDot + let firstLabel = withoutLocal.split(separator: ".").first.map(String.init) + let token = (firstLabel ?? withoutLocal).trimmingCharacters(in: .whitespacesAndNewlines) + return token.isEmpty ? nil : token + } + + private nonisolated static func normalizeDisplayToken(_ raw: String?) -> String? { + guard let raw else { return nil } + let prettified = Self.prettifyInstanceName(raw) + let trimmed = prettified.trimmingCharacters(in: .whitespacesAndNewlines) + if trimmed.isEmpty { return nil } + return trimmed.lowercased() + } + + private nonisolated static func normalizeServiceHostToken(_ raw: String?) -> String? { + guard let raw else { return nil } + let prettified = Self.prettifyInstanceName(raw) + let strippedGateway = prettified.replacingOccurrences( + of: #"\s*-?\s*gateway$"#, + with: "", + options: .regularExpression) + return self.normalizeHostToken(strippedGateway) + } +} + +final class GatewayTXTResolver: NSObject, NetServiceDelegate { + private let service: NetService + private let completion: (Result<[String: String], Error>) -> Void + private let logger: Logger + private var didFinish = false + + init( + name: String, + type: String, + domain: String, + logger: Logger, + completion: @escaping (Result<[String: String], Error>) -> Void) + { + self.service = NetService(domain: domain, type: type, name: name) + self.completion = completion + self.logger = logger + super.init() + self.service.delegate = self + } + + func start(timeout: TimeInterval = 2.0) { + self.service.schedule(in: .main, forMode: .common) + self.service.resolve(withTimeout: timeout) + } + + func cancel() { + self.finish(result: .failure(GatewayTXTResolverError.cancelled)) + } + + func netServiceDidResolveAddress(_ sender: NetService) { + let txt = Self.decodeTXT(sender.txtRecordData()) + if !txt.isEmpty { + let payload = self.formatTXT(txt) + self.logger.debug( + "discovery: resolved TXT for \(sender.name, privacy: .public): \(payload, privacy: .public)") + } + self.finish(result: .success(txt)) + } + + func netService(_ sender: NetService, didNotResolve errorDict: [String: NSNumber]) { + self.finish(result: .failure(GatewayTXTResolverError.resolveFailed(errorDict))) + } + + private func finish(result: Result<[String: String], Error>) { + guard !self.didFinish else { return } + self.didFinish = true + self.service.stop() + self.service.remove(from: .main, forMode: .common) + self.completion(result) + } + + private static func decodeTXT(_ data: Data?) -> [String: String] { + guard let data else { return [:] } + let dict = NetService.dictionary(fromTXTRecord: data) + var out: [String: String] = [:] + out.reserveCapacity(dict.count) + for (key, value) in dict { + if let str = String(data: value, encoding: .utf8) { + out[key] = str + } + } + return out + } + + private func formatTXT(_ txt: [String: String]) -> String { + txt.sorted(by: { $0.key < $1.key }) + .map { "\($0.key)=\($0.value)" } + .joined(separator: " ") + } +} + +enum GatewayTXTResolverError: Error { + case cancelled + case resolveFailed([String: NSNumber]) +} diff --git a/apps/shared/MoltbotKit/Package.swift b/apps/shared/MoltbotKit/Package.swift new file mode 100644 index 000000000..b821755a6 --- /dev/null +++ b/apps/shared/MoltbotKit/Package.swift @@ -0,0 +1,61 @@ +// swift-tools-version: 6.2 + +import PackageDescription + +let package = Package( + name: "MoltbotKit", + platforms: [ + .iOS(.v18), + .macOS(.v15), + ], + products: [ + .library(name: "MoltbotProtocol", targets: ["MoltbotProtocol"]), + .library(name: "MoltbotKit", targets: ["MoltbotKit"]), + .library(name: "MoltbotChatUI", targets: ["MoltbotChatUI"]), + ], + dependencies: [ + .package(url: "https://github.com/steipete/ElevenLabsKit", exact: "0.1.0"), + .package(url: "https://github.com/gonzalezreal/textual", exact: "0.3.1"), + ], + targets: [ + .target( + name: "MoltbotProtocol", + path: "Sources/MoltbotProtocol", + swiftSettings: [ + .enableUpcomingFeature("StrictConcurrency"), + ]), + .target( + name: "MoltbotKit", + path: "Sources/MoltbotKit", + dependencies: [ + "MoltbotProtocol", + .product(name: "ElevenLabsKit", package: "ElevenLabsKit"), + ], + resources: [ + .process("Resources"), + ], + swiftSettings: [ + .enableUpcomingFeature("StrictConcurrency"), + ]), + .target( + name: "MoltbotChatUI", + path: "Sources/MoltbotChatUI", + dependencies: [ + "MoltbotKit", + .product( + name: "Textual", + package: "textual", + condition: .when(platforms: [.macOS, .iOS])), + ], + swiftSettings: [ + .enableUpcomingFeature("StrictConcurrency"), + ]), + .testTarget( + name: "MoltbotKitTests", + dependencies: ["MoltbotKit", "MoltbotChatUI"], + path: "Tests/MoltbotKitTests", + swiftSettings: [ + .enableUpcomingFeature("StrictConcurrency"), + .enableExperimentalFeature("SwiftTesting"), + ]), + ]) diff --git a/docs/concepts/typebox.md b/docs/concepts/typebox.md index 5ee4346cd..892ba1b2d 100644 --- a/docs/concepts/typebox.md +++ b/docs/concepts/typebox.md @@ -58,7 +58,7 @@ Authoritative list lives in `src/gateway/server.ts` (`METHODS`, `EVENTS`). - Server handshake + method dispatch: `src/gateway/server.ts` - Node client: `src/gateway/client.ts` - Generated JSON Schema: `dist/protocol.schema.json` -- Generated Swift models: `apps/macos/Sources/ClawdbotProtocol/GatewayModels.swift` +- Generated Swift models: `apps/macos/Sources/MoltbotProtocol/GatewayModels.swift` ## Current pipeline diff --git a/package.json b/package.json index f91af8199..7c05bd9b4 100644 --- a/package.json +++ b/package.json @@ -115,7 +115,7 @@ "lint:all": "pnpm lint && pnpm lint:swift", "lint:fix": "pnpm format:fix && oxlint --type-aware --fix src test", "format": "oxfmt --check src test", - "format:swift": "swiftformat --lint --config .swiftformat apps/macos/Sources apps/ios/Sources apps/shared/ClawdbotKit/Sources", + "format:swift": "swiftformat --lint --config .swiftformat apps/macos/Sources apps/ios/Sources apps/shared/MoltbotKit/Sources", "format:all": "pnpm format && pnpm format:swift", "format:fix": "oxfmt --write src test", "test": "node scripts/test-parallel.mjs", @@ -141,7 +141,7 @@ "test:install:e2e:anthropic": "CLAWDBOT_E2E_MODELS=anthropic bash scripts/test-install-sh-e2e-docker.sh", "protocol:gen": "node --import tsx scripts/protocol-gen.ts", "protocol:gen:swift": "node --import tsx scripts/protocol-gen-swift.ts", - "protocol:check": "pnpm protocol:gen && pnpm protocol:gen:swift && git diff --exit-code -- dist/protocol.schema.json apps/macos/Sources/ClawdbotProtocol/GatewayModels.swift", + "protocol:check": "pnpm protocol:gen && pnpm protocol:gen:swift && git diff --exit-code -- dist/protocol.schema.json apps/macos/Sources/MoltbotProtocol/GatewayModels.swift", "canvas:a2ui:bundle": "bash scripts/bundle-a2ui.sh", "check:loc": "node --import tsx scripts/check-ts-max-loc.ts --max 500" }, diff --git a/scripts/bundle-a2ui.sh b/scripts/bundle-a2ui.sh index 75844ec6d..e04648090 100755 --- a/scripts/bundle-a2ui.sh +++ b/scripts/bundle-a2ui.sh @@ -11,7 +11,7 @@ ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" HASH_FILE="$ROOT_DIR/src/canvas-host/a2ui/.bundle.hash" OUTPUT_FILE="$ROOT_DIR/src/canvas-host/a2ui/a2ui.bundle.js" A2UI_RENDERER_DIR="$ROOT_DIR/vendor/a2ui/renderers/lit" -A2UI_APP_DIR="$ROOT_DIR/apps/shared/ClawdbotKit/Tools/CanvasA2UI" +A2UI_APP_DIR="$ROOT_DIR/apps/shared/MoltbotKit/Tools/CanvasA2UI" # Docker builds exclude vendor/apps via .dockerignore. # In that environment we must keep the prebuilt bundle. diff --git a/scripts/protocol-gen-swift.ts b/scripts/protocol-gen-swift.ts index b4310d9b8..0c2ca5066 100644 --- a/scripts/protocol-gen-swift.ts +++ b/scripts/protocol-gen-swift.ts @@ -24,16 +24,16 @@ const outPaths = [ "apps", "macos", "Sources", - "ClawdbotProtocol", + "MoltbotProtocol", "GatewayModels.swift", ), path.join( repoRoot, "apps", "shared", - "ClawdbotKit", + "MoltbotKit", "Sources", - "ClawdbotProtocol", + "MoltbotProtocol", "GatewayModels.swift", ), ]; From c1a7917de73c001330b04e3e51d3ac7a8b8ed87f Mon Sep 17 00:00:00 2001 From: Shadow Date: Tue, 27 Jan 2026 14:12:47 -0600 Subject: [PATCH 035/101] Mac: finish Moltbot rename (paths) --- .../Sources/Clawdbot/AgentWorkspace.swift | 340 ------- .../Sources/Clawdbot/AnthropicOAuth.swift | 384 ------- .../Clawdbot/AudioInputDeviceObserver.swift | 216 ---- .../Sources/Clawdbot/CLIInstallPrompter.swift | 84 -- .../Clawdbot/CameraCaptureService.swift | 425 -------- .../Sources/Clawdbot/CanvasFileWatcher.swift | 94 -- .../Sources/Clawdbot/CanvasManager.swift | 342 ------- .../Clawdbot/CanvasSchemeHandler.swift | 259 ----- .../macos/Sources/Clawdbot/CanvasWindow.swift | 26 - .../Sources/Clawdbot/ClawdbotConfigFile.swift | 217 ---- .../Sources/Clawdbot/ConfigFileWatcher.swift | 118 --- .../Clawdbot/ConnectionModeCoordinator.swift | 79 -- apps/macos/Sources/Clawdbot/Constants.swift | 44 - .../Sources/Clawdbot/ControlChannel.swift | 427 -------- .../Sources/Clawdbot/CronJobsStore.swift | 200 ---- apps/macos/Sources/Clawdbot/DeepLinks.swift | 151 --- .../DevicePairingApprovalPrompter.swift | 334 ------ .../Sources/Clawdbot/DockIconManager.swift | 116 --- .../Sources/Clawdbot/ExecApprovals.swift | 790 --------------- .../ExecApprovalsGatewayPrompter.swift | 123 --- .../Clawdbot/ExecApprovalsSocket.swift | 831 --------------- .../Sources/Clawdbot/GatewayConnection.swift | 737 -------------- .../GatewayConnectivityCoordinator.swift | 63 -- .../Clawdbot/GatewayEndpointStore.swift | 696 ------------- .../Sources/Clawdbot/GatewayEnvironment.swift | 342 ------- .../Clawdbot/GatewayLaunchAgentManager.swift | 203 ---- .../Clawdbot/GatewayProcessManager.swift | 432 -------- apps/macos/Sources/Clawdbot/HealthStore.swift | 301 ------ .../Sources/Clawdbot/InstancesStore.swift | 394 -------- .../Sources/Clawdbot/LaunchAgentManager.swift | 86 -- .../Clawdbot/Logging/ClawdbotLogging.swift | 230 ----- apps/macos/Sources/Clawdbot/MenuBar.swift | 471 --------- .../Sources/Clawdbot/MicLevelMonitor.swift | 97 -- .../Sources/Clawdbot/ModelCatalogLoader.swift | 156 --- .../NodeMode/MacNodeModeCoordinator.swift | 171 ---- .../NodePairingApprovalPrompter.swift | 708 ------------- .../Sources/Clawdbot/NodeServiceManager.swift | 150 --- apps/macos/Sources/Clawdbot/NodesStore.swift | 102 -- .../Clawdbot/NotificationManager.swift | 66 -- .../Sources/Clawdbot/OnboardingWizard.swift | 412 -------- .../PeekabooBridgeHostCoordinator.swift | 130 --- .../Sources/Clawdbot/PermissionManager.swift | 506 ---------- .../macos/Sources/Clawdbot/PortGuardian.swift | 418 -------- .../Sources/Clawdbot/PresenceReporter.swift | 158 --- .../Sources/Clawdbot/RemotePortTunnel.swift | 317 ------ .../Clawdbot/RemoteTunnelManager.swift | 122 --- .../Sources/Clawdbot/Resources/Info.plist | 79 -- .../Sources/Clawdbot/RuntimeLocator.swift | 167 --- .../Clawdbot/ScreenRecordService.swift | 266 ----- .../Clawdbot/SessionMenuPreviewView.swift | 495 --------- .../Sources/Clawdbot/TailscaleService.swift | 226 ----- .../Sources/Clawdbot/TalkAudioPlayer.swift | 158 --- .../Sources/Clawdbot/TalkModeController.swift | 69 -- .../Sources/Clawdbot/TalkModeRuntime.swift | 953 ------------------ apps/macos/Sources/Clawdbot/TalkOverlay.swift | 146 --- .../Clawdbot/TerminationSignalWatcher.swift | 53 - .../Sources/Clawdbot/VoicePushToTalk.swift | 421 -------- .../Clawdbot/VoiceSessionCoordinator.swift | 134 --- .../Sources/Clawdbot/VoiceWakeChime.swift | 74 -- .../Sources/Clawdbot/VoiceWakeForwarder.swift | 73 -- .../VoiceWakeGlobalSettingsSync.swift | 66 -- .../Sources/Clawdbot/VoiceWakeOverlay.swift | 60 -- .../Sources/Clawdbot/VoiceWakeRuntime.swift | 804 --------------- .../Sources/Clawdbot/VoiceWakeTester.swift | 473 --------- .../Sources/Clawdbot/WebChatSwiftUI.swift | 374 ------- .../GatewayDiscoveryModel.swift | 683 ------------- .../{Clawdbot => Moltbot}/AboutSettings.swift | 0 .../{Clawdbot => Moltbot}/AgeFormatting.swift | 0 .../AgentEventStore.swift | 0 .../AgentEventsWindow.swift | 0 .../AnthropicAuthControls.swift | 0 .../AnthropicOAuthCodeState.swift | 0 .../AnyCodable+Helpers.swift | 0 .../{Clawdbot => Moltbot}/AppState.swift | 0 .../{Clawdbot => Moltbot}/CLIInstaller.swift | 0 .../CanvasA2UIActionMessageHandler.swift | 0 .../CanvasChromeContainerView.swift | 0 .../{Clawdbot => Moltbot}/CanvasScheme.swift | 0 .../CanvasWindowController+Helpers.swift | 0 .../CanvasWindowController+Navigation.swift | 0 .../CanvasWindowController+Testing.swift | 0 .../CanvasWindowController+Window.swift | 0 .../CanvasWindowController.swift | 0 .../ChannelConfigForm.swift | 0 .../ChannelsSettings+ChannelSections.swift | 0 .../ChannelsSettings+ChannelState.swift | 0 .../ChannelsSettings+Helpers.swift | 0 .../ChannelsSettings+View.swift | 0 .../ChannelsSettings.swift | 0 .../ChannelsStore+Config.swift | 0 .../ChannelsStore+Lifecycle.swift | 0 .../{Clawdbot => Moltbot}/ChannelsStore.swift | 0 .../{Clawdbot => Moltbot}/ClawdbotPaths.swift | 0 .../CommandResolver.swift | 0 .../ConfigSchemaSupport.swift | 0 .../ConfigSettings.swift | 0 .../{Clawdbot => Moltbot}/ConfigStore.swift | 0 .../ConnectionModeResolver.swift | 0 .../ContextMenuCardView.swift | 0 .../ContextUsageBar.swift | 0 .../CostUsageMenuView.swift | 0 .../CritterIconRenderer.swift | 0 .../CritterStatusLabel+Behavior.swift | 0 .../CritterStatusLabel.swift | 0 .../CronJobEditor+Helpers.swift | 0 .../CronJobEditor+Testing.swift | 0 .../{Clawdbot => Moltbot}/CronJobEditor.swift | 0 .../{Clawdbot => Moltbot}/CronModels.swift | 0 .../CronSettings+Actions.swift | 0 .../CronSettings+Helpers.swift | 0 .../CronSettings+Layout.swift | 0 .../CronSettings+Rows.swift | 0 .../CronSettings+Testing.swift | 0 .../{Clawdbot => Moltbot}/CronSettings.swift | 0 .../{Clawdbot => Moltbot}/DebugActions.swift | 0 .../{Clawdbot => Moltbot}/DebugSettings.swift | 0 .../DeviceModelCatalog.swift | 0 .../DiagnosticsFileLog.swift | 0 .../FileHandle+SafeRead.swift | 0 .../GatewayAutostartPolicy.swift | 0 .../GatewayDiscoveryHelpers.swift | 0 .../GatewayDiscoveryMenu.swift | 0 .../GatewayDiscoveryPreferences.swift | 0 .../GatewayRemoteConfig.swift | 0 .../GeneralSettings.swift | 0 .../HeartbeatStore.swift | 0 .../{Clawdbot => Moltbot}/HoverHUD.swift | 0 .../{Clawdbot => Moltbot}/IconState.swift | 0 .../InstancesSettings.swift | 0 .../{Clawdbot => Moltbot}/Launchctl.swift | 0 .../LaunchdManager.swift | 0 .../{Clawdbot => Moltbot}/LogLocator.swift | 0 .../MenuContentView.swift | 0 .../MenuContextCardInjector.swift | 0 .../MenuHighlightedHostView.swift | 0 .../MenuHostedItem.swift | 0 .../MenuSessionsHeaderView.swift | 0 .../MenuSessionsInjector.swift | 0 .../MenuUsageHeaderView.swift | 0 .../NSAttributedString+VoiceWake.swift | 0 .../NodeMode/MacNodeLocationService.swift | 0 .../NodeMode/MacNodeRuntime.swift | 0 .../MacNodeRuntimeMainActorServices.swift | 0 .../NodeMode/MacNodeScreenCommands.swift | 0 .../{Clawdbot => Moltbot}/NodesMenu.swift | 0 .../{Clawdbot => Moltbot}/NotifyOverlay.swift | 0 .../{Clawdbot => Moltbot}/Onboarding.swift | 0 .../OnboardingView+Actions.swift | 0 .../OnboardingView+Chat.swift | 0 .../OnboardingView+Layout.swift | 0 .../OnboardingView+Monitoring.swift | 0 .../OnboardingView+Pages.swift | 0 .../OnboardingView+Testing.swift | 0 .../OnboardingView+Wizard.swift | 0 .../OnboardingView+Workspace.swift | 0 .../OnboardingWidgets.swift | 0 .../PermissionsSettings.swift | 0 .../PointingHandCursor.swift | 0 .../Process+PipeRead.swift | 0 .../ProcessInfo+Clawdbot.swift | 0 .../Resources/Clawdbot.icns | Bin .../LICENSE.apple-device-identifiers.txt | 0 .../Resources/DeviceModels/NOTICE.md | 0 .../DeviceModels/ios-device-identifiers.json | 0 .../DeviceModels/mac-device-identifiers.json | 0 .../ScreenshotSize.swift | 0 .../SessionActions.swift | 0 .../{Clawdbot => Moltbot}/SessionData.swift | 0 .../SessionMenuLabelView.swift | 0 .../SessionsSettings.swift | 0 .../SettingsComponents.swift | 0 .../SettingsRootView.swift | 0 .../SettingsWindowOpener.swift | 0 .../{Clawdbot => Moltbot}/ShellExecutor.swift | 0 .../{Clawdbot => Moltbot}/SkillsModels.swift | 0 .../SkillsSettings.swift | 0 .../{Clawdbot => Moltbot}/SoundEffects.swift | 0 .../{Clawdbot => Moltbot}/StatusPill.swift | 0 .../String+NonEmpty.swift | 0 .../SystemRunSettingsView.swift | 0 .../TailscaleIntegrationSection.swift | 0 .../{Clawdbot => Moltbot}/TalkModeTypes.swift | 0 .../TalkOverlayView.swift | 0 .../{Clawdbot => Moltbot}/UsageCostData.swift | 0 .../{Clawdbot => Moltbot}/UsageData.swift | 0 .../UsageMenuLabelView.swift | 0 .../{Clawdbot => Moltbot}/ViewMetrics.swift | 0 .../VisualEffectView.swift | 0 .../VoiceWakeHelpers.swift | 0 .../VoiceWakeOverlayController+Session.swift | 0 .../VoiceWakeOverlayController+Testing.swift | 0 .../VoiceWakeOverlayController+Window.swift | 0 .../VoiceWakeOverlayTextViews.swift | 0 .../VoiceWakeOverlayView.swift | 0 .../VoiceWakeSettings.swift | 0 .../VoiceWakeTestCard.swift | 0 .../VoiceWakeTextUtils.swift | 0 .../WebChatManager.swift | 0 .../WindowPlacement.swift | 0 .../WorkActivityStore.swift | 0 .../WideAreaGatewayDiscovery.swift | 0 .../{ClawdbotIPC => MoltbotIPC}/IPC.swift | 0 .../ConnectCommand.swift | 0 .../DiscoverCommand.swift | 0 .../EntryPoint.swift | 0 .../GatewayConfig.swift | 0 .../TypeAliases.swift | 0 .../WizardCommand.swift | 0 .../GatewayModels.swift | 0 .../AgentEventStoreTests.swift | 0 .../AgentWorkspaceTests.swift | 0 .../AnthropicAuthControlsSmokeTests.swift | 0 .../AnthropicAuthResolverTests.swift | 0 .../AnthropicOAuthCodeStateTests.swift | 0 .../AnyCodableEncodingTests.swift | 0 .../CLIInstallerTests.swift | 0 .../CameraCaptureServiceTests.swift | 0 .../CameraIPCTests.swift | 0 .../CanvasFileWatcherTests.swift | 0 .../CanvasIPCTests.swift | 0 .../CanvasWindowSmokeTests.swift | 0 .../ChannelsSettingsSmokeTests.swift | 0 .../ClawdbotConfigFileTests.swift | 0 .../ClawdbotOAuthStoreTests.swift | 0 .../CommandResolverTests.swift | 0 .../ConfigStoreTests.swift | 0 .../CoverageDumpTests.swift | 0 .../CritterIconRendererTests.swift | 0 .../CronJobEditorSmokeTests.swift | 0 .../CronModelsTests.swift | 0 .../DeviceModelCatalogTests.swift | 0 .../ExecAllowlistTests.swift | 0 .../ExecApprovalHelpersTests.swift | 0 .../ExecApprovalsGatewayPrompterTests.swift | 0 .../FileHandleLegacyAPIGuardTests.swift | 0 .../FileHandleSafeReadTests.swift | 0 .../GatewayAgentChannelTests.swift | 0 .../GatewayAutostartPolicyTests.swift | 0 .../GatewayChannelConfigureTests.swift | 0 .../GatewayChannelConnectTests.swift | 0 .../GatewayChannelRequestTests.swift | 0 .../GatewayChannelShutdownTests.swift | 0 .../GatewayConnectionControlTests.swift | 0 .../GatewayDiscoveryModelTests.swift | 0 .../GatewayEndpointStoreTests.swift | 0 .../GatewayEnvironmentTests.swift | 0 .../GatewayFrameDecodeTests.swift | 0 .../GatewayLaunchAgentManagerTests.swift | 0 .../GatewayProcessManagerTests.swift | 0 .../HealthDecodeTests.swift | 0 .../HealthStoreStateTests.swift | 0 .../HoverHUDControllerTests.swift | 0 .../InstancesSettingsSmokeTests.swift | 0 .../InstancesStoreTests.swift | 0 .../LogLocatorTests.swift | 0 .../LowCoverageHelperTests.swift | 0 .../LowCoverageViewSmokeTests.swift | 0 .../MacGatewayChatTransportMappingTests.swift | 0 .../MacNodeRuntimeTests.swift | 0 .../MasterDiscoveryMenuSmokeTests.swift | 0 .../MenuContentSmokeTests.swift | 0 .../MenuSessionsInjectorTests.swift | 0 .../ModelCatalogLoaderTests.swift | 0 .../NodeManagerPathsTests.swift | 0 .../NodePairingApprovalPrompterTests.swift | 0 .../NodePairingReconcilePolicyTests.swift | 0 .../OnboardingCoverageTests.swift | 0 .../OnboardingViewSmokeTests.swift | 0 .../OnboardingWizardStepViewTests.swift | 0 .../PermissionManagerLocationTests.swift | 0 .../PermissionManagerTests.swift | 0 .../Placeholder.swift | 0 .../RemotePortTunnelTests.swift | 0 .../RuntimeLocatorTests.swift | 0 .../ScreenshotSizeTests.swift | 0 .../SemverTests.swift | 0 .../SessionDataTests.swift | 0 .../SessionMenuPreviewTests.swift | 0 .../SettingsViewSmokeTests.swift | 0 .../SkillsSettingsSmokeTests.swift | 0 .../TailscaleIntegrationSectionTests.swift | 0 .../TalkAudioPlayerTests.swift | 0 .../TestIsolation.swift | 0 .../UtilitiesTests.swift | 0 .../VoicePushToTalkHotkeyTests.swift | 0 .../VoicePushToTalkTests.swift | 0 .../VoiceWakeForwarderTests.swift | 0 .../VoiceWakeGlobalSettingsSyncTests.swift | 0 .../VoiceWakeHelpersTests.swift | 0 .../VoiceWakeOverlayControllerTests.swift | 0 .../VoiceWakeOverlayTests.swift | 0 .../VoiceWakeOverlayViewSmokeTests.swift | 0 .../VoiceWakeRuntimeTests.swift | 0 .../VoiceWakeTesterTests.swift | 0 .../WebChatMainSessionKeyTests.swift | 0 .../WebChatManagerTests.swift | 0 .../WebChatSwiftUISmokeTests.swift | 0 .../WideAreaGatewayDiscoveryTests.swift | 0 .../WindowPlacementTests.swift | 0 .../WorkActivityStoreTests.swift | 0 apps/shared/ClawdbotKit/Package.swift | 61 -- .../MoltbotChatUI}/AssistantTextParser.swift | 0 .../Sources/MoltbotChatUI}/ChatComposer.swift | 0 .../ChatMarkdownPreprocessor.swift | 0 .../MoltbotChatUI}/ChatMarkdownRenderer.swift | 0 .../MoltbotChatUI}/ChatMessageViews.swift | 0 .../Sources/MoltbotChatUI}/ChatModels.swift | 0 .../MoltbotChatUI}/ChatPayloadDecoding.swift | 0 .../Sources/MoltbotChatUI}/ChatSessions.swift | 0 .../Sources/MoltbotChatUI}/ChatSheets.swift | 0 .../Sources/MoltbotChatUI}/ChatTheme.swift | 0 .../MoltbotChatUI}/ChatTransport.swift | 0 .../Sources/MoltbotChatUI}/ChatView.swift | 0 .../MoltbotChatUI}/ChatViewModel.swift | 0 .../Sources/MoltbotKit}/AnyCodable.swift | 0 .../Sources/MoltbotKit}/AsyncTimeout.swift | 0 .../MoltbotKit}/AudioStreamingProtocols.swift | 0 .../Sources/MoltbotKit}/BonjourEscapes.swift | 0 .../Sources/MoltbotKit}/BonjourTypes.swift | 0 .../Sources/MoltbotKit}/BridgeFrames.swift | 0 .../Sources/MoltbotKit}/CameraCommands.swift | 0 .../MoltbotKit}/CanvasA2UIAction.swift | 0 .../MoltbotKit}/CanvasA2UICommands.swift | 0 .../Sources/MoltbotKit}/CanvasA2UIJSONL.swift | 0 .../MoltbotKit}/CanvasCommandParams.swift | 0 .../Sources/MoltbotKit}/CanvasCommands.swift | 0 .../Sources/MoltbotKit}/Capabilities.swift | 0 .../MoltbotKit}/ClawdbotKitResources.swift | 0 .../Sources/MoltbotKit}/DeepLinks.swift | 0 .../Sources/MoltbotKit}/DeviceAuthStore.swift | 0 .../Sources/MoltbotKit}/DeviceIdentity.swift | 0 .../MoltbotKit}/ElevenLabsKitShim.swift | 0 .../Sources/MoltbotKit}/GatewayChannel.swift | 0 .../MoltbotKit}/GatewayEndpointID.swift | 0 .../Sources/MoltbotKit}/GatewayErrors.swift | 0 .../MoltbotKit}/GatewayNodeSession.swift | 0 .../MoltbotKit}/GatewayPayloadDecoding.swift | 0 .../Sources/MoltbotKit}/GatewayPush.swift | 0 .../MoltbotKit}/GatewayTLSPinning.swift | 0 .../MoltbotKit}/InstanceIdentity.swift | 0 .../Sources/MoltbotKit}/JPEGTranscoder.swift | 0 .../MoltbotKit}/LocationCommands.swift | 0 .../MoltbotKit}/LocationSettings.swift | 0 .../Sources/MoltbotKit}/NodeError.swift | 0 .../Resources/CanvasScaffold/scaffold.html | 0 .../MoltbotKit}/Resources/tool-display.json | 0 .../Sources/MoltbotKit}/ScreenCommands.swift | 0 .../Sources/MoltbotKit}/StoragePaths.swift | 0 .../Sources/MoltbotKit}/SystemCommands.swift | 0 .../Sources/MoltbotKit}/TalkDirective.swift | 0 .../MoltbotKit}/TalkHistoryTimestamp.swift | 0 .../MoltbotKit}/TalkPromptBuilder.swift | 0 .../TalkSystemSpeechSynthesizer.swift | 0 .../Sources/MoltbotKit}/ToolDisplay.swift | 0 .../Sources/MoltbotProtocol}/AnyCodable.swift | 0 .../MoltbotProtocol}/GatewayModels.swift | 0 .../MoltbotProtocol}/WizardHelpers.swift | 0 .../AssistantTextParserTests.swift | 0 .../BonjourEscapesTests.swift | 0 .../CanvasA2UIActionTests.swift | 0 .../MoltbotKitTests}/CanvasA2UITests.swift | 0 .../CanvasSnapshotFormatTests.swift | 0 .../ChatMarkdownPreprocessorTests.swift | 0 .../MoltbotKitTests}/ChatThemeTests.swift | 0 .../MoltbotKitTests}/ChatViewModelTests.swift | 0 .../ElevenLabsTTSValidationTests.swift | 0 .../GatewayNodeSessionTests.swift | 0 .../JPEGTranscoderTests.swift | 0 .../MoltbotKitTests}/TalkDirectiveTests.swift | 0 .../TalkHistoryTimestampTests.swift | 0 .../TalkPromptBuilderTests.swift | 0 .../ToolDisplayRegistryTests.swift | 0 .../Tools/CanvasA2UI/bootstrap.js | 0 .../Tools/CanvasA2UI/rolldown.config.mjs | 0 374 files changed, 18903 deletions(-) delete mode 100644 apps/macos/Sources/Clawdbot/AgentWorkspace.swift delete mode 100644 apps/macos/Sources/Clawdbot/AnthropicOAuth.swift delete mode 100644 apps/macos/Sources/Clawdbot/AudioInputDeviceObserver.swift delete mode 100644 apps/macos/Sources/Clawdbot/CLIInstallPrompter.swift delete mode 100644 apps/macos/Sources/Clawdbot/CameraCaptureService.swift delete mode 100644 apps/macos/Sources/Clawdbot/CanvasFileWatcher.swift delete mode 100644 apps/macos/Sources/Clawdbot/CanvasManager.swift delete mode 100644 apps/macos/Sources/Clawdbot/CanvasSchemeHandler.swift delete mode 100644 apps/macos/Sources/Clawdbot/CanvasWindow.swift delete mode 100644 apps/macos/Sources/Clawdbot/ClawdbotConfigFile.swift delete mode 100644 apps/macos/Sources/Clawdbot/ConfigFileWatcher.swift delete mode 100644 apps/macos/Sources/Clawdbot/ConnectionModeCoordinator.swift delete mode 100644 apps/macos/Sources/Clawdbot/Constants.swift delete mode 100644 apps/macos/Sources/Clawdbot/ControlChannel.swift delete mode 100644 apps/macos/Sources/Clawdbot/CronJobsStore.swift delete mode 100644 apps/macos/Sources/Clawdbot/DeepLinks.swift delete mode 100644 apps/macos/Sources/Clawdbot/DevicePairingApprovalPrompter.swift delete mode 100644 apps/macos/Sources/Clawdbot/DockIconManager.swift delete mode 100644 apps/macos/Sources/Clawdbot/ExecApprovals.swift delete mode 100644 apps/macos/Sources/Clawdbot/ExecApprovalsGatewayPrompter.swift delete mode 100644 apps/macos/Sources/Clawdbot/ExecApprovalsSocket.swift delete mode 100644 apps/macos/Sources/Clawdbot/GatewayConnection.swift delete mode 100644 apps/macos/Sources/Clawdbot/GatewayConnectivityCoordinator.swift delete mode 100644 apps/macos/Sources/Clawdbot/GatewayEndpointStore.swift delete mode 100644 apps/macos/Sources/Clawdbot/GatewayEnvironment.swift delete mode 100644 apps/macos/Sources/Clawdbot/GatewayLaunchAgentManager.swift delete mode 100644 apps/macos/Sources/Clawdbot/GatewayProcessManager.swift delete mode 100644 apps/macos/Sources/Clawdbot/HealthStore.swift delete mode 100644 apps/macos/Sources/Clawdbot/InstancesStore.swift delete mode 100644 apps/macos/Sources/Clawdbot/LaunchAgentManager.swift delete mode 100644 apps/macos/Sources/Clawdbot/Logging/ClawdbotLogging.swift delete mode 100644 apps/macos/Sources/Clawdbot/MenuBar.swift delete mode 100644 apps/macos/Sources/Clawdbot/MicLevelMonitor.swift delete mode 100644 apps/macos/Sources/Clawdbot/ModelCatalogLoader.swift delete mode 100644 apps/macos/Sources/Clawdbot/NodeMode/MacNodeModeCoordinator.swift delete mode 100644 apps/macos/Sources/Clawdbot/NodePairingApprovalPrompter.swift delete mode 100644 apps/macos/Sources/Clawdbot/NodeServiceManager.swift delete mode 100644 apps/macos/Sources/Clawdbot/NodesStore.swift delete mode 100644 apps/macos/Sources/Clawdbot/NotificationManager.swift delete mode 100644 apps/macos/Sources/Clawdbot/OnboardingWizard.swift delete mode 100644 apps/macos/Sources/Clawdbot/PeekabooBridgeHostCoordinator.swift delete mode 100644 apps/macos/Sources/Clawdbot/PermissionManager.swift delete mode 100644 apps/macos/Sources/Clawdbot/PortGuardian.swift delete mode 100644 apps/macos/Sources/Clawdbot/PresenceReporter.swift delete mode 100644 apps/macos/Sources/Clawdbot/RemotePortTunnel.swift delete mode 100644 apps/macos/Sources/Clawdbot/RemoteTunnelManager.swift delete mode 100644 apps/macos/Sources/Clawdbot/Resources/Info.plist delete mode 100644 apps/macos/Sources/Clawdbot/RuntimeLocator.swift delete mode 100644 apps/macos/Sources/Clawdbot/ScreenRecordService.swift delete mode 100644 apps/macos/Sources/Clawdbot/SessionMenuPreviewView.swift delete mode 100644 apps/macos/Sources/Clawdbot/TailscaleService.swift delete mode 100644 apps/macos/Sources/Clawdbot/TalkAudioPlayer.swift delete mode 100644 apps/macos/Sources/Clawdbot/TalkModeController.swift delete mode 100644 apps/macos/Sources/Clawdbot/TalkModeRuntime.swift delete mode 100644 apps/macos/Sources/Clawdbot/TalkOverlay.swift delete mode 100644 apps/macos/Sources/Clawdbot/TerminationSignalWatcher.swift delete mode 100644 apps/macos/Sources/Clawdbot/VoicePushToTalk.swift delete mode 100644 apps/macos/Sources/Clawdbot/VoiceSessionCoordinator.swift delete mode 100644 apps/macos/Sources/Clawdbot/VoiceWakeChime.swift delete mode 100644 apps/macos/Sources/Clawdbot/VoiceWakeForwarder.swift delete mode 100644 apps/macos/Sources/Clawdbot/VoiceWakeGlobalSettingsSync.swift delete mode 100644 apps/macos/Sources/Clawdbot/VoiceWakeOverlay.swift delete mode 100644 apps/macos/Sources/Clawdbot/VoiceWakeRuntime.swift delete mode 100644 apps/macos/Sources/Clawdbot/VoiceWakeTester.swift delete mode 100644 apps/macos/Sources/Clawdbot/WebChatSwiftUI.swift delete mode 100644 apps/macos/Sources/ClawdbotDiscovery/GatewayDiscoveryModel.swift rename apps/macos/Sources/{Clawdbot => Moltbot}/AboutSettings.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/AgeFormatting.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/AgentEventStore.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/AgentEventsWindow.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/AnthropicAuthControls.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/AnthropicOAuthCodeState.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/AnyCodable+Helpers.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/AppState.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CLIInstaller.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CanvasA2UIActionMessageHandler.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CanvasChromeContainerView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CanvasScheme.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CanvasWindowController+Helpers.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CanvasWindowController+Navigation.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CanvasWindowController+Testing.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CanvasWindowController+Window.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CanvasWindowController.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ChannelConfigForm.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ChannelsSettings+ChannelSections.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ChannelsSettings+ChannelState.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ChannelsSettings+Helpers.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ChannelsSettings+View.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ChannelsSettings.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ChannelsStore+Config.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ChannelsStore+Lifecycle.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ChannelsStore.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ClawdbotPaths.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CommandResolver.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ConfigSchemaSupport.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ConfigSettings.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ConfigStore.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ConnectionModeResolver.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ContextMenuCardView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ContextUsageBar.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CostUsageMenuView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CritterIconRenderer.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CritterStatusLabel+Behavior.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CritterStatusLabel.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CronJobEditor+Helpers.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CronJobEditor+Testing.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CronJobEditor.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CronModels.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CronSettings+Actions.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CronSettings+Helpers.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CronSettings+Layout.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CronSettings+Rows.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CronSettings+Testing.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/CronSettings.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/DebugActions.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/DebugSettings.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/DeviceModelCatalog.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/DiagnosticsFileLog.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/FileHandle+SafeRead.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/GatewayAutostartPolicy.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/GatewayDiscoveryHelpers.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/GatewayDiscoveryMenu.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/GatewayDiscoveryPreferences.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/GatewayRemoteConfig.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/GeneralSettings.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/HeartbeatStore.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/HoverHUD.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/IconState.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/InstancesSettings.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/Launchctl.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/LaunchdManager.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/LogLocator.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/MenuContentView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/MenuContextCardInjector.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/MenuHighlightedHostView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/MenuHostedItem.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/MenuSessionsHeaderView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/MenuSessionsInjector.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/MenuUsageHeaderView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/NSAttributedString+VoiceWake.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/NodeMode/MacNodeLocationService.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/NodeMode/MacNodeRuntime.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/NodeMode/MacNodeRuntimeMainActorServices.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/NodeMode/MacNodeScreenCommands.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/NodesMenu.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/NotifyOverlay.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/Onboarding.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/OnboardingView+Actions.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/OnboardingView+Chat.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/OnboardingView+Layout.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/OnboardingView+Monitoring.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/OnboardingView+Pages.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/OnboardingView+Testing.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/OnboardingView+Wizard.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/OnboardingView+Workspace.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/OnboardingWidgets.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/PermissionsSettings.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/PointingHandCursor.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/Process+PipeRead.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ProcessInfo+Clawdbot.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/Resources/Clawdbot.icns (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/Resources/DeviceModels/LICENSE.apple-device-identifiers.txt (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/Resources/DeviceModels/NOTICE.md (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/Resources/DeviceModels/ios-device-identifiers.json (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/Resources/DeviceModels/mac-device-identifiers.json (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ScreenshotSize.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/SessionActions.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/SessionData.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/SessionMenuLabelView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/SessionsSettings.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/SettingsComponents.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/SettingsRootView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/SettingsWindowOpener.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ShellExecutor.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/SkillsModels.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/SkillsSettings.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/SoundEffects.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/StatusPill.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/String+NonEmpty.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/SystemRunSettingsView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/TailscaleIntegrationSection.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/TalkModeTypes.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/TalkOverlayView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/UsageCostData.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/UsageData.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/UsageMenuLabelView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/ViewMetrics.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/VisualEffectView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/VoiceWakeHelpers.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/VoiceWakeOverlayController+Session.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/VoiceWakeOverlayController+Testing.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/VoiceWakeOverlayController+Window.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/VoiceWakeOverlayTextViews.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/VoiceWakeOverlayView.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/VoiceWakeSettings.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/VoiceWakeTestCard.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/VoiceWakeTextUtils.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/WebChatManager.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/WindowPlacement.swift (100%) rename apps/macos/Sources/{Clawdbot => Moltbot}/WorkActivityStore.swift (100%) rename apps/macos/Sources/{ClawdbotDiscovery => MoltbotDiscovery}/WideAreaGatewayDiscovery.swift (100%) rename apps/macos/Sources/{ClawdbotIPC => MoltbotIPC}/IPC.swift (100%) rename apps/macos/Sources/{ClawdbotMacCLI => MoltbotMacCLI}/ConnectCommand.swift (100%) rename apps/macos/Sources/{ClawdbotMacCLI => MoltbotMacCLI}/DiscoverCommand.swift (100%) rename apps/macos/Sources/{ClawdbotMacCLI => MoltbotMacCLI}/EntryPoint.swift (100%) rename apps/macos/Sources/{ClawdbotMacCLI => MoltbotMacCLI}/GatewayConfig.swift (100%) rename apps/macos/Sources/{ClawdbotMacCLI => MoltbotMacCLI}/TypeAliases.swift (100%) rename apps/macos/Sources/{ClawdbotMacCLI => MoltbotMacCLI}/WizardCommand.swift (100%) rename apps/macos/Sources/{ClawdbotProtocol => MoltbotProtocol}/GatewayModels.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/AgentEventStoreTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/AgentWorkspaceTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/AnthropicAuthControlsSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/AnthropicAuthResolverTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/AnthropicOAuthCodeStateTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/AnyCodableEncodingTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/CLIInstallerTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/CameraCaptureServiceTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/CameraIPCTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/CanvasFileWatcherTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/CanvasIPCTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/CanvasWindowSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/ChannelsSettingsSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/ClawdbotConfigFileTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/ClawdbotOAuthStoreTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/CommandResolverTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/ConfigStoreTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/CoverageDumpTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/CritterIconRendererTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/CronJobEditorSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/CronModelsTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/DeviceModelCatalogTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/ExecAllowlistTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/ExecApprovalHelpersTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/ExecApprovalsGatewayPrompterTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/FileHandleLegacyAPIGuardTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/FileHandleSafeReadTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayAgentChannelTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayAutostartPolicyTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayChannelConfigureTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayChannelConnectTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayChannelRequestTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayChannelShutdownTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayConnectionControlTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayDiscoveryModelTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayEndpointStoreTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayEnvironmentTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayFrameDecodeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayLaunchAgentManagerTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/GatewayProcessManagerTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/HealthDecodeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/HealthStoreStateTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/HoverHUDControllerTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/InstancesSettingsSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/InstancesStoreTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/LogLocatorTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/LowCoverageHelperTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/LowCoverageViewSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/MacGatewayChatTransportMappingTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/MacNodeRuntimeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/MasterDiscoveryMenuSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/MenuContentSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/MenuSessionsInjectorTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/ModelCatalogLoaderTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/NodeManagerPathsTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/NodePairingApprovalPrompterTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/NodePairingReconcilePolicyTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/OnboardingCoverageTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/OnboardingViewSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/OnboardingWizardStepViewTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/PermissionManagerLocationTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/PermissionManagerTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/Placeholder.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/RemotePortTunnelTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/RuntimeLocatorTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/ScreenshotSizeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/SemverTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/SessionDataTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/SessionMenuPreviewTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/SettingsViewSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/SkillsSettingsSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/TailscaleIntegrationSectionTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/TalkAudioPlayerTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/TestIsolation.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/UtilitiesTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/VoicePushToTalkHotkeyTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/VoicePushToTalkTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/VoiceWakeForwarderTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/VoiceWakeGlobalSettingsSyncTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/VoiceWakeHelpersTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/VoiceWakeOverlayControllerTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/VoiceWakeOverlayTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/VoiceWakeOverlayViewSmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/VoiceWakeRuntimeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/VoiceWakeTesterTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/WebChatMainSessionKeyTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/WebChatManagerTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/WebChatSwiftUISmokeTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/WideAreaGatewayDiscoveryTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/WindowPlacementTests.swift (100%) rename apps/macos/Tests/{ClawdbotIPCTests => MoltbotIPCTests}/WorkActivityStoreTests.swift (100%) delete mode 100644 apps/shared/ClawdbotKit/Package.swift rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/AssistantTextParser.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatComposer.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatMarkdownPreprocessor.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatMarkdownRenderer.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatMessageViews.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatModels.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatPayloadDecoding.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatSessions.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatSheets.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatTheme.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatTransport.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatView.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotChatUI => MoltbotKit/Sources/MoltbotChatUI}/ChatViewModel.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/AnyCodable.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/AsyncTimeout.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/AudioStreamingProtocols.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/BonjourEscapes.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/BonjourTypes.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/BridgeFrames.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/CameraCommands.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/CanvasA2UIAction.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/CanvasA2UICommands.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/CanvasA2UIJSONL.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/CanvasCommandParams.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/CanvasCommands.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/Capabilities.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/ClawdbotKitResources.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/DeepLinks.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/DeviceAuthStore.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/DeviceIdentity.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/ElevenLabsKitShim.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/GatewayChannel.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/GatewayEndpointID.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/GatewayErrors.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/GatewayNodeSession.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/GatewayPayloadDecoding.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/GatewayPush.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/GatewayTLSPinning.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/InstanceIdentity.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/JPEGTranscoder.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/LocationCommands.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/LocationSettings.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/NodeError.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/Resources/CanvasScaffold/scaffold.html (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/Resources/tool-display.json (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/ScreenCommands.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/StoragePaths.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/SystemCommands.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/TalkDirective.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/TalkHistoryTimestamp.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/TalkPromptBuilder.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/TalkSystemSpeechSynthesizer.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotKit => MoltbotKit/Sources/MoltbotKit}/ToolDisplay.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotProtocol => MoltbotKit/Sources/MoltbotProtocol}/AnyCodable.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotProtocol => MoltbotKit/Sources/MoltbotProtocol}/GatewayModels.swift (100%) rename apps/shared/{ClawdbotKit/Sources/ClawdbotProtocol => MoltbotKit/Sources/MoltbotProtocol}/WizardHelpers.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/AssistantTextParserTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/BonjourEscapesTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/CanvasA2UIActionTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/CanvasA2UITests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/CanvasSnapshotFormatTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/ChatMarkdownPreprocessorTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/ChatThemeTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/ChatViewModelTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/ElevenLabsTTSValidationTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/GatewayNodeSessionTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/JPEGTranscoderTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/TalkDirectiveTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/TalkHistoryTimestampTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/TalkPromptBuilderTests.swift (100%) rename apps/shared/{ClawdbotKit/Tests/ClawdbotKitTests => MoltbotKit/Tests/MoltbotKitTests}/ToolDisplayRegistryTests.swift (100%) rename apps/shared/{ClawdbotKit => MoltbotKit}/Tools/CanvasA2UI/bootstrap.js (100%) rename apps/shared/{ClawdbotKit => MoltbotKit}/Tools/CanvasA2UI/rolldown.config.mjs (100%) diff --git a/apps/macos/Sources/Clawdbot/AgentWorkspace.swift b/apps/macos/Sources/Clawdbot/AgentWorkspace.swift deleted file mode 100644 index bad27d3b7..000000000 --- a/apps/macos/Sources/Clawdbot/AgentWorkspace.swift +++ /dev/null @@ -1,340 +0,0 @@ -import Foundation -import OSLog - -enum AgentWorkspace { - private static let logger = Logger(subsystem: "com.clawdbot", category: "workspace") - static let agentsFilename = "AGENTS.md" - static let soulFilename = "SOUL.md" - static let identityFilename = "IDENTITY.md" - static let userFilename = "USER.md" - static let bootstrapFilename = "BOOTSTRAP.md" - private static let templateDirname = "templates" - private static let ignoredEntries: Set = [".DS_Store", ".git", ".gitignore"] - private static let templateEntries: Set = [ - AgentWorkspace.agentsFilename, - AgentWorkspace.soulFilename, - AgentWorkspace.identityFilename, - AgentWorkspace.userFilename, - AgentWorkspace.bootstrapFilename, - ] - enum BootstrapSafety: Equatable { - case safe - case unsafe(reason: String) - } - - static func displayPath(for url: URL) -> String { - let home = FileManager().homeDirectoryForCurrentUser.path - let path = url.path - if path == home { return "~" } - if path.hasPrefix(home + "/") { - return "~/" + String(path.dropFirst(home.count + 1)) - } - return path - } - - static func resolveWorkspaceURL(from userInput: String?) -> URL { - let trimmed = userInput?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if trimmed.isEmpty { return MoltbotConfigFile.defaultWorkspaceURL() } - let expanded = (trimmed as NSString).expandingTildeInPath - return URL(fileURLWithPath: expanded, isDirectory: true) - } - - static func agentsURL(workspaceURL: URL) -> URL { - workspaceURL.appendingPathComponent(self.agentsFilename) - } - - static func workspaceEntries(workspaceURL: URL) throws -> [String] { - let contents = try FileManager().contentsOfDirectory(atPath: workspaceURL.path) - return contents.filter { !self.ignoredEntries.contains($0) } - } - - static func isWorkspaceEmpty(workspaceURL: URL) -> Bool { - let fm = FileManager() - var isDir: ObjCBool = false - if !fm.fileExists(atPath: workspaceURL.path, isDirectory: &isDir) { - return true - } - guard isDir.boolValue else { return false } - guard let entries = try? self.workspaceEntries(workspaceURL: workspaceURL) else { return false } - return entries.isEmpty - } - - static func isTemplateOnlyWorkspace(workspaceURL: URL) -> Bool { - guard let entries = try? self.workspaceEntries(workspaceURL: workspaceURL) else { return false } - guard !entries.isEmpty else { return true } - return Set(entries).isSubset(of: self.templateEntries) - } - - static func bootstrapSafety(for workspaceURL: URL) -> BootstrapSafety { - let fm = FileManager() - var isDir: ObjCBool = false - if !fm.fileExists(atPath: workspaceURL.path, isDirectory: &isDir) { - return .safe - } - if !isDir.boolValue { - return .unsafe(reason: "Workspace path points to a file.") - } - let agentsURL = self.agentsURL(workspaceURL: workspaceURL) - if fm.fileExists(atPath: agentsURL.path) { - return .safe - } - do { - let entries = try self.workspaceEntries(workspaceURL: workspaceURL) - return entries.isEmpty - ? .safe - : .unsafe(reason: "Folder isn't empty. Choose a new folder or add AGENTS.md first.") - } catch { - return .unsafe(reason: "Couldn't inspect the workspace folder.") - } - } - - static func bootstrap(workspaceURL: URL) throws -> URL { - let shouldSeedBootstrap = self.isWorkspaceEmpty(workspaceURL: workspaceURL) - try FileManager().createDirectory(at: workspaceURL, withIntermediateDirectories: true) - let agentsURL = self.agentsURL(workspaceURL: workspaceURL) - if !FileManager().fileExists(atPath: agentsURL.path) { - try self.defaultTemplate().write(to: agentsURL, atomically: true, encoding: .utf8) - self.logger.info("Created AGENTS.md at \(agentsURL.path, privacy: .public)") - } - let soulURL = workspaceURL.appendingPathComponent(self.soulFilename) - if !FileManager().fileExists(atPath: soulURL.path) { - try self.defaultSoulTemplate().write(to: soulURL, atomically: true, encoding: .utf8) - self.logger.info("Created SOUL.md at \(soulURL.path, privacy: .public)") - } - let identityURL = workspaceURL.appendingPathComponent(self.identityFilename) - if !FileManager().fileExists(atPath: identityURL.path) { - try self.defaultIdentityTemplate().write(to: identityURL, atomically: true, encoding: .utf8) - self.logger.info("Created IDENTITY.md at \(identityURL.path, privacy: .public)") - } - let userURL = workspaceURL.appendingPathComponent(self.userFilename) - if !FileManager().fileExists(atPath: userURL.path) { - try self.defaultUserTemplate().write(to: userURL, atomically: true, encoding: .utf8) - self.logger.info("Created USER.md at \(userURL.path, privacy: .public)") - } - let bootstrapURL = workspaceURL.appendingPathComponent(self.bootstrapFilename) - if shouldSeedBootstrap, !FileManager().fileExists(atPath: bootstrapURL.path) { - try self.defaultBootstrapTemplate().write(to: bootstrapURL, atomically: true, encoding: .utf8) - self.logger.info("Created BOOTSTRAP.md at \(bootstrapURL.path, privacy: .public)") - } - return agentsURL - } - - static func needsBootstrap(workspaceURL: URL) -> Bool { - let fm = FileManager() - var isDir: ObjCBool = false - if !fm.fileExists(atPath: workspaceURL.path, isDirectory: &isDir) { - return true - } - guard isDir.boolValue else { return true } - if self.hasIdentity(workspaceURL: workspaceURL) { - return false - } - let bootstrapURL = workspaceURL.appendingPathComponent(self.bootstrapFilename) - guard fm.fileExists(atPath: bootstrapURL.path) else { return false } - return self.isTemplateOnlyWorkspace(workspaceURL: workspaceURL) - } - - static func hasIdentity(workspaceURL: URL) -> Bool { - let identityURL = workspaceURL.appendingPathComponent(self.identityFilename) - guard let contents = try? String(contentsOf: identityURL, encoding: .utf8) else { return false } - return self.identityLinesHaveValues(contents) - } - - private static func identityLinesHaveValues(_ content: String) -> Bool { - for line in content.split(separator: "\n") { - let trimmed = line.trimmingCharacters(in: .whitespacesAndNewlines) - guard trimmed.hasPrefix("-"), let colon = trimmed.firstIndex(of: ":") else { continue } - let value = trimmed[trimmed.index(after: colon)...].trimmingCharacters(in: .whitespacesAndNewlines) - if !value.isEmpty { - return true - } - } - return false - } - - static func defaultTemplate() -> String { - let fallback = """ - # AGENTS.md - Moltbot Workspace - - This folder is the assistant's working directory. - - ## First run (one-time) - - If BOOTSTRAP.md exists, follow its ritual and delete it once complete. - - Your agent identity lives in IDENTITY.md. - - Your profile lives in USER.md. - - ## Backup tip (recommended) - If you treat this workspace as the agent's "memory", make it a git repo (ideally private) so identity - and notes are backed up. - - ```bash - git init - git add AGENTS.md - git commit -m "Add agent workspace" - ``` - - ## Safety defaults - - Don't exfiltrate secrets or private data. - - Don't run destructive commands unless explicitly asked. - - Be concise in chat; write longer output to files in this workspace. - - ## Daily memory (recommended) - - Keep a short daily log at memory/YYYY-MM-DD.md (create memory/ if needed). - - On session start, read today + yesterday if present. - - Capture durable facts, preferences, and decisions; avoid secrets. - - ## Customize - - Add your preferred style, rules, and "memory" here. - """ - return self.loadTemplate(named: self.agentsFilename, fallback: fallback) - } - - static func defaultSoulTemplate() -> String { - let fallback = """ - # SOUL.md - Persona & Boundaries - - Describe who the assistant is, tone, and boundaries. - - - Keep replies concise and direct. - - Ask clarifying questions when needed. - - Never send streaming/partial replies to external messaging surfaces. - """ - return self.loadTemplate(named: self.soulFilename, fallback: fallback) - } - - static func defaultIdentityTemplate() -> String { - let fallback = """ - # IDENTITY.md - Agent Identity - - - Name: - - Creature: - - Vibe: - - Emoji: - """ - return self.loadTemplate(named: self.identityFilename, fallback: fallback) - } - - static func defaultUserTemplate() -> String { - let fallback = """ - # USER.md - User Profile - - - Name: - - Preferred address: - - Pronouns (optional): - - Timezone (optional): - - Notes: - """ - return self.loadTemplate(named: self.userFilename, fallback: fallback) - } - - static func defaultBootstrapTemplate() -> String { - let fallback = """ - # BOOTSTRAP.md - First Run Ritual (delete after) - - Hello. I was just born. - - ## Your mission - Start a short, playful conversation and learn: - - Who am I? - - What am I? - - Who are you? - - How should I call you? - - ## How to ask (cute + helpful) - Say: - "Hello! I was just born. Who am I? What am I? Who are you? How should I call you?" - - Then offer suggestions: - - 3-5 name ideas. - - 3-5 creature/vibe combos. - - 5 emoji ideas. - - ## Write these files - After the user chooses, update: - - 1) IDENTITY.md - - Name - - Creature - - Vibe - - Emoji - - 2) USER.md - - Name - - Preferred address - - Pronouns (optional) - - Timezone (optional) - - Notes - - 3) ~/.clawdbot/moltbot.json - Set identity.name, identity.theme, identity.emoji to match IDENTITY.md. - - ## Cleanup - Delete BOOTSTRAP.md once this is complete. - """ - return self.loadTemplate(named: self.bootstrapFilename, fallback: fallback) - } - - private static func loadTemplate(named: String, fallback: String) -> String { - for url in self.templateURLs(named: named) { - if let content = try? String(contentsOf: url, encoding: .utf8) { - let stripped = self.stripFrontMatter(content) - if !stripped.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { - return stripped - } - } - } - return fallback - } - - private static func templateURLs(named: String) -> [URL] { - var urls: [URL] = [] - if let resource = Bundle.main.url( - forResource: named.replacingOccurrences(of: ".md", with: ""), - withExtension: "md", - subdirectory: self.templateDirname) - { - urls.append(resource) - } - if let resource = Bundle.main.url( - forResource: named, - withExtension: nil, - subdirectory: self.templateDirname) - { - urls.append(resource) - } - if let dev = self.devTemplateURL(named: named) { - urls.append(dev) - } - let cwd = URL(fileURLWithPath: FileManager().currentDirectoryPath) - urls.append(cwd.appendingPathComponent("docs") - .appendingPathComponent(self.templateDirname) - .appendingPathComponent(named)) - return urls - } - - private static func devTemplateURL(named: String) -> URL? { - let sourceURL = URL(fileURLWithPath: #filePath) - let repoRoot = sourceURL - .deletingLastPathComponent() - .deletingLastPathComponent() - .deletingLastPathComponent() - .deletingLastPathComponent() - .deletingLastPathComponent() - return repoRoot.appendingPathComponent("docs") - .appendingPathComponent(self.templateDirname) - .appendingPathComponent(named) - } - - private static func stripFrontMatter(_ content: String) -> String { - guard content.hasPrefix("---") else { return content } - let start = content.index(content.startIndex, offsetBy: 3) - guard let range = content.range(of: "\n---", range: start.. AnthropicAuthMode - { - if oauthStatus.isConnected { return .oauthFile } - - if let token = environment["ANTHROPIC_OAUTH_TOKEN"]?.trimmingCharacters(in: .whitespacesAndNewlines), - !token.isEmpty - { - return .oauthEnv - } - - if let key = environment["ANTHROPIC_API_KEY"]?.trimmingCharacters(in: .whitespacesAndNewlines), - !key.isEmpty - { - return .apiKeyEnv - } - - return .missing - } -} - -enum AnthropicOAuth { - private static let logger = Logger(subsystem: "com.clawdbot", category: "anthropic-oauth") - - private static let clientId = "9d1c250a-e61b-44d9-88ed-5944d1962f5e" - private static let authorizeURL = URL(string: "https://claude.ai/oauth/authorize")! - private static let tokenURL = URL(string: "https://console.anthropic.com/v1/oauth/token")! - private static let redirectURI = "https://console.anthropic.com/oauth/code/callback" - private static let scopes = "org:create_api_key user:profile user:inference" - - struct PKCE { - let verifier: String - let challenge: String - } - - static func generatePKCE() throws -> PKCE { - var bytes = [UInt8](repeating: 0, count: 32) - let status = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes) - guard status == errSecSuccess else { - throw NSError(domain: NSOSStatusErrorDomain, code: Int(status)) - } - let verifier = Data(bytes).base64URLEncodedString() - let hash = SHA256.hash(data: Data(verifier.utf8)) - let challenge = Data(hash).base64URLEncodedString() - return PKCE(verifier: verifier, challenge: challenge) - } - - static func buildAuthorizeURL(pkce: PKCE) -> URL { - var components = URLComponents(url: self.authorizeURL, resolvingAgainstBaseURL: false)! - components.queryItems = [ - URLQueryItem(name: "code", value: "true"), - URLQueryItem(name: "client_id", value: self.clientId), - URLQueryItem(name: "response_type", value: "code"), - URLQueryItem(name: "redirect_uri", value: self.redirectURI), - URLQueryItem(name: "scope", value: self.scopes), - URLQueryItem(name: "code_challenge", value: pkce.challenge), - URLQueryItem(name: "code_challenge_method", value: "S256"), - // Match legacy flow: state is the verifier. - URLQueryItem(name: "state", value: pkce.verifier), - ] - return components.url! - } - - static func exchangeCode( - code: String, - state: String, - verifier: String) async throws -> AnthropicOAuthCredentials - { - let payload: [String: Any] = [ - "grant_type": "authorization_code", - "client_id": self.clientId, - "code": code, - "state": state, - "redirect_uri": self.redirectURI, - "code_verifier": verifier, - ] - let body = try JSONSerialization.data(withJSONObject: payload, options: []) - - var request = URLRequest(url: self.tokenURL) - request.httpMethod = "POST" - request.httpBody = body - request.setValue("application/json", forHTTPHeaderField: "Content-Type") - - let (data, response) = try await URLSession.shared.data(for: request) - guard let http = response as? HTTPURLResponse else { - throw URLError(.badServerResponse) - } - guard (200..<300).contains(http.statusCode) else { - let text = String(data: data, encoding: .utf8) ?? "" - throw NSError( - domain: "AnthropicOAuth", - code: http.statusCode, - userInfo: [NSLocalizedDescriptionKey: "Token exchange failed: \(text)"]) - } - - let decoded = try JSONSerialization.jsonObject(with: data) as? [String: Any] - let access = decoded?["access_token"] as? String - let refresh = decoded?["refresh_token"] as? String - let expiresIn = decoded?["expires_in"] as? Double - guard let access, let refresh, let expiresIn else { - throw NSError(domain: "AnthropicOAuth", code: 0, userInfo: [ - NSLocalizedDescriptionKey: "Unexpected token response.", - ]) - } - - // Match legacy flow: expiresAt = now + expires_in - 5 minutes. - let expiresAtMs = Int64(Date().timeIntervalSince1970 * 1000) - + Int64(expiresIn * 1000) - - Int64(5 * 60 * 1000) - - self.logger.info("Anthropic OAuth exchange ok; expiresAtMs=\(expiresAtMs, privacy: .public)") - return AnthropicOAuthCredentials(type: "oauth", refresh: refresh, access: access, expires: expiresAtMs) - } - - static func refresh(refreshToken: String) async throws -> AnthropicOAuthCredentials { - let payload: [String: Any] = [ - "grant_type": "refresh_token", - "client_id": self.clientId, - "refresh_token": refreshToken, - ] - let body = try JSONSerialization.data(withJSONObject: payload, options: []) - - var request = URLRequest(url: self.tokenURL) - request.httpMethod = "POST" - request.httpBody = body - request.setValue("application/json", forHTTPHeaderField: "Content-Type") - - let (data, response) = try await URLSession.shared.data(for: request) - guard let http = response as? HTTPURLResponse else { - throw URLError(.badServerResponse) - } - guard (200..<300).contains(http.statusCode) else { - let text = String(data: data, encoding: .utf8) ?? "" - throw NSError( - domain: "AnthropicOAuth", - code: http.statusCode, - userInfo: [NSLocalizedDescriptionKey: "Token refresh failed: \(text)"]) - } - - let decoded = try JSONSerialization.jsonObject(with: data) as? [String: Any] - let access = decoded?["access_token"] as? String - let refresh = (decoded?["refresh_token"] as? String) ?? refreshToken - let expiresIn = decoded?["expires_in"] as? Double - guard let access, let expiresIn else { - throw NSError(domain: "AnthropicOAuth", code: 0, userInfo: [ - NSLocalizedDescriptionKey: "Unexpected token response.", - ]) - } - - let expiresAtMs = Int64(Date().timeIntervalSince1970 * 1000) - + Int64(expiresIn * 1000) - - Int64(5 * 60 * 1000) - - self.logger.info("Anthropic OAuth refresh ok; expiresAtMs=\(expiresAtMs, privacy: .public)") - return AnthropicOAuthCredentials(type: "oauth", refresh: refresh, access: access, expires: expiresAtMs) - } -} - -enum MoltbotOAuthStore { - static let oauthFilename = "oauth.json" - private static let providerKey = "anthropic" - private static let moltbotOAuthDirEnv = "CLAWDBOT_OAUTH_DIR" - private static let legacyPiDirEnv = "PI_CODING_AGENT_DIR" - - enum AnthropicOAuthStatus: Equatable { - case missingFile - case unreadableFile - case invalidJSON - case missingProviderEntry - case missingTokens - case connected(expiresAtMs: Int64?) - - var isConnected: Bool { - if case .connected = self { return true } - return false - } - - var shortDescription: String { - switch self { - case .missingFile: "Moltbot OAuth token file not found" - case .unreadableFile: "Moltbot OAuth token file not readable" - case .invalidJSON: "Moltbot OAuth token file invalid" - case .missingProviderEntry: "No Anthropic entry in Moltbot OAuth token file" - case .missingTokens: "Anthropic entry missing tokens" - case .connected: "Moltbot OAuth credentials found" - } - } - } - - static func oauthDir() -> URL { - if let override = ProcessInfo.processInfo.environment[self.clawdbotOAuthDirEnv]? - .trimmingCharacters(in: .whitespacesAndNewlines), - !override.isEmpty - { - let expanded = NSString(string: override).expandingTildeInPath - return URL(fileURLWithPath: expanded, isDirectory: true) - } - - return FileManager().homeDirectoryForCurrentUser - .appendingPathComponent(".clawdbot", isDirectory: true) - .appendingPathComponent("credentials", isDirectory: true) - } - - static func oauthURL() -> URL { - self.oauthDir().appendingPathComponent(self.oauthFilename) - } - - static func legacyOAuthURLs() -> [URL] { - var urls: [URL] = [] - let env = ProcessInfo.processInfo.environment - if let override = env[self.legacyPiDirEnv]?.trimmingCharacters(in: .whitespacesAndNewlines), - !override.isEmpty - { - let expanded = NSString(string: override).expandingTildeInPath - urls.append(URL(fileURLWithPath: expanded, isDirectory: true).appendingPathComponent(self.oauthFilename)) - } - - let home = FileManager().homeDirectoryForCurrentUser - urls.append(home.appendingPathComponent(".pi/agent/\(self.oauthFilename)")) - urls.append(home.appendingPathComponent(".claude/\(self.oauthFilename)")) - urls.append(home.appendingPathComponent(".config/claude/\(self.oauthFilename)")) - urls.append(home.appendingPathComponent(".config/anthropic/\(self.oauthFilename)")) - - var seen = Set() - return urls.filter { url in - let path = url.standardizedFileURL.path - if seen.contains(path) { return false } - seen.insert(path) - return true - } - } - - static func importLegacyAnthropicOAuthIfNeeded() -> URL? { - let dest = self.oauthURL() - guard !FileManager().fileExists(atPath: dest.path) else { return nil } - - for url in self.legacyOAuthURLs() { - guard FileManager().fileExists(atPath: url.path) else { continue } - guard self.anthropicOAuthStatus(at: url).isConnected else { continue } - guard let storage = self.loadStorage(at: url) else { continue } - do { - try self.saveStorage(storage) - return url - } catch { - continue - } - } - - return nil - } - - static func anthropicOAuthStatus() -> AnthropicOAuthStatus { - self.anthropicOAuthStatus(at: self.oauthURL()) - } - - static func hasAnthropicOAuth() -> Bool { - self.anthropicOAuthStatus().isConnected - } - - static func anthropicOAuthStatus(at url: URL) -> AnthropicOAuthStatus { - guard FileManager().fileExists(atPath: url.path) else { return .missingFile } - - guard let data = try? Data(contentsOf: url) else { return .unreadableFile } - guard let json = try? JSONSerialization.jsonObject(with: data, options: []) else { return .invalidJSON } - guard let storage = json as? [String: Any] else { return .invalidJSON } - guard let rawEntry = storage[self.providerKey] else { return .missingProviderEntry } - guard let entry = rawEntry as? [String: Any] else { return .invalidJSON } - - let refresh = self.firstString(in: entry, keys: ["refresh", "refresh_token", "refreshToken"]) - let access = self.firstString(in: entry, keys: ["access", "access_token", "accessToken"]) - guard refresh?.isEmpty == false, access?.isEmpty == false else { return .missingTokens } - - let expiresAny = entry["expires"] ?? entry["expires_at"] ?? entry["expiresAt"] - let expiresAtMs: Int64? = if let ms = expiresAny as? Int64 { - ms - } else if let number = expiresAny as? NSNumber { - number.int64Value - } else if let ms = expiresAny as? Double { - Int64(ms) - } else { - nil - } - - return .connected(expiresAtMs: expiresAtMs) - } - - static func loadAnthropicOAuthRefreshToken() -> String? { - let url = self.oauthURL() - guard let storage = self.loadStorage(at: url) else { return nil } - guard let rawEntry = storage[self.providerKey] as? [String: Any] else { return nil } - let refresh = self.firstString(in: rawEntry, keys: ["refresh", "refresh_token", "refreshToken"]) - return refresh?.trimmingCharacters(in: .whitespacesAndNewlines) - } - - private static func firstString(in dict: [String: Any], keys: [String]) -> String? { - for key in keys { - if let value = dict[key] as? String { return value } - } - return nil - } - - private static func loadStorage(at url: URL) -> [String: Any]? { - guard let data = try? Data(contentsOf: url) else { return nil } - guard let json = try? JSONSerialization.jsonObject(with: data, options: []) else { return nil } - return json as? [String: Any] - } - - static func saveAnthropicOAuth(_ creds: AnthropicOAuthCredentials) throws { - let url = self.oauthURL() - let existing: [String: Any] = self.loadStorage(at: url) ?? [:] - - var updated = existing - updated[self.providerKey] = [ - "type": creds.type, - "refresh": creds.refresh, - "access": creds.access, - "expires": creds.expires, - ] - - try self.saveStorage(updated) - } - - private static func saveStorage(_ storage: [String: Any]) throws { - let dir = self.oauthDir() - try FileManager().createDirectory( - at: dir, - withIntermediateDirectories: true, - attributes: [.posixPermissions: 0o700]) - - let url = self.oauthURL() - let data = try JSONSerialization.data( - withJSONObject: storage, - options: [.prettyPrinted, .sortedKeys]) - try data.write(to: url, options: [.atomic]) - try FileManager().setAttributes([.posixPermissions: 0o600], ofItemAtPath: url.path) - } -} - -extension Data { - fileprivate func base64URLEncodedString() -> String { - self.base64EncodedString() - .replacingOccurrences(of: "+", with: "-") - .replacingOccurrences(of: "/", with: "_") - .replacingOccurrences(of: "=", with: "") - } -} diff --git a/apps/macos/Sources/Clawdbot/AudioInputDeviceObserver.swift b/apps/macos/Sources/Clawdbot/AudioInputDeviceObserver.swift deleted file mode 100644 index bc296972c..000000000 --- a/apps/macos/Sources/Clawdbot/AudioInputDeviceObserver.swift +++ /dev/null @@ -1,216 +0,0 @@ -import CoreAudio -import Foundation -import OSLog - -final class AudioInputDeviceObserver { - private let logger = Logger(subsystem: "com.clawdbot", category: "audio.devices") - private var isActive = false - private var devicesListener: AudioObjectPropertyListenerBlock? - private var defaultInputListener: AudioObjectPropertyListenerBlock? - - static func defaultInputDeviceUID() -> String? { - let systemObject = AudioObjectID(kAudioObjectSystemObject) - var address = AudioObjectPropertyAddress( - mSelector: kAudioHardwarePropertyDefaultInputDevice, - mScope: kAudioObjectPropertyScopeGlobal, - mElement: kAudioObjectPropertyElementMain) - var deviceID = AudioObjectID(0) - var size = UInt32(MemoryLayout.size) - let status = AudioObjectGetPropertyData( - systemObject, - &address, - 0, - nil, - &size, - &deviceID) - guard status == noErr, deviceID != 0 else { return nil } - return self.deviceUID(for: deviceID) - } - - static func aliveInputDeviceUIDs() -> Set { - let systemObject = AudioObjectID(kAudioObjectSystemObject) - var address = AudioObjectPropertyAddress( - mSelector: kAudioHardwarePropertyDevices, - mScope: kAudioObjectPropertyScopeGlobal, - mElement: kAudioObjectPropertyElementMain) - var size: UInt32 = 0 - var status = AudioObjectGetPropertyDataSize(systemObject, &address, 0, nil, &size) - guard status == noErr, size > 0 else { return [] } - - let count = Int(size) / MemoryLayout.size - var deviceIDs = [AudioObjectID](repeating: 0, count: count) - status = AudioObjectGetPropertyData(systemObject, &address, 0, nil, &size, &deviceIDs) - guard status == noErr else { return [] } - - var output = Set() - for deviceID in deviceIDs { - guard self.deviceIsAlive(deviceID) else { continue } - guard self.deviceHasInput(deviceID) else { continue } - if let uid = self.deviceUID(for: deviceID) { - output.insert(uid) - } - } - return output - } - - static func defaultInputDeviceSummary() -> String { - let systemObject = AudioObjectID(kAudioObjectSystemObject) - var address = AudioObjectPropertyAddress( - mSelector: kAudioHardwarePropertyDefaultInputDevice, - mScope: kAudioObjectPropertyScopeGlobal, - mElement: kAudioObjectPropertyElementMain) - var deviceID = AudioObjectID(0) - var size = UInt32(MemoryLayout.size) - let status = AudioObjectGetPropertyData( - systemObject, - &address, - 0, - nil, - &size, - &deviceID) - guard status == noErr, deviceID != 0 else { - return "defaultInput=unknown" - } - let uid = self.deviceUID(for: deviceID) ?? "unknown" - let name = self.deviceName(for: deviceID) ?? "unknown" - return "defaultInput=\(name) (\(uid))" - } - - func start(onChange: @escaping @Sendable () -> Void) { - guard !self.isActive else { return } - self.isActive = true - - let systemObject = AudioObjectID(kAudioObjectSystemObject) - let queue = DispatchQueue.main - - var devicesAddress = AudioObjectPropertyAddress( - mSelector: kAudioHardwarePropertyDevices, - mScope: kAudioObjectPropertyScopeGlobal, - mElement: kAudioObjectPropertyElementMain) - let devicesListener: AudioObjectPropertyListenerBlock = { _, _ in - self.logDefaultInputChange(reason: "devices") - onChange() - } - let devicesStatus = AudioObjectAddPropertyListenerBlock( - systemObject, - &devicesAddress, - queue, - devicesListener) - - var defaultInputAddress = AudioObjectPropertyAddress( - mSelector: kAudioHardwarePropertyDefaultInputDevice, - mScope: kAudioObjectPropertyScopeGlobal, - mElement: kAudioObjectPropertyElementMain) - let defaultInputListener: AudioObjectPropertyListenerBlock = { _, _ in - self.logDefaultInputChange(reason: "default") - onChange() - } - let defaultStatus = AudioObjectAddPropertyListenerBlock( - systemObject, - &defaultInputAddress, - queue, - defaultInputListener) - - if devicesStatus != noErr || defaultStatus != noErr { - self.logger.error("audio device observer install failed devices=\(devicesStatus) default=\(defaultStatus)") - } - - self.logger.info("audio device observer started (\(Self.defaultInputDeviceSummary(), privacy: .public))") - - self.devicesListener = devicesListener - self.defaultInputListener = defaultInputListener - } - - func stop() { - guard self.isActive else { return } - self.isActive = false - let systemObject = AudioObjectID(kAudioObjectSystemObject) - - if let devicesListener { - var devicesAddress = AudioObjectPropertyAddress( - mSelector: kAudioHardwarePropertyDevices, - mScope: kAudioObjectPropertyScopeGlobal, - mElement: kAudioObjectPropertyElementMain) - _ = AudioObjectRemovePropertyListenerBlock( - systemObject, - &devicesAddress, - DispatchQueue.main, - devicesListener) - } - - if let defaultInputListener { - var defaultInputAddress = AudioObjectPropertyAddress( - mSelector: kAudioHardwarePropertyDefaultInputDevice, - mScope: kAudioObjectPropertyScopeGlobal, - mElement: kAudioObjectPropertyElementMain) - _ = AudioObjectRemovePropertyListenerBlock( - systemObject, - &defaultInputAddress, - DispatchQueue.main, - defaultInputListener) - } - - self.devicesListener = nil - self.defaultInputListener = nil - } - - private static func deviceUID(for deviceID: AudioObjectID) -> String? { - var address = AudioObjectPropertyAddress( - mSelector: kAudioDevicePropertyDeviceUID, - mScope: kAudioObjectPropertyScopeGlobal, - mElement: kAudioObjectPropertyElementMain) - var uid: Unmanaged? - var size = UInt32(MemoryLayout?>.size) - let status = AudioObjectGetPropertyData(deviceID, &address, 0, nil, &size, &uid) - guard status == noErr, let uid else { return nil } - return uid.takeUnretainedValue() as String - } - - private static func deviceName(for deviceID: AudioObjectID) -> String? { - var address = AudioObjectPropertyAddress( - mSelector: kAudioObjectPropertyName, - mScope: kAudioObjectPropertyScopeGlobal, - mElement: kAudioObjectPropertyElementMain) - var name: Unmanaged? - var size = UInt32(MemoryLayout?>.size) - let status = AudioObjectGetPropertyData(deviceID, &address, 0, nil, &size, &name) - guard status == noErr, let name else { return nil } - return name.takeUnretainedValue() as String - } - - private static func deviceIsAlive(_ deviceID: AudioObjectID) -> Bool { - var address = AudioObjectPropertyAddress( - mSelector: kAudioDevicePropertyDeviceIsAlive, - mScope: kAudioObjectPropertyScopeGlobal, - mElement: kAudioObjectPropertyElementMain) - var alive: UInt32 = 0 - var size = UInt32(MemoryLayout.size) - let status = AudioObjectGetPropertyData(deviceID, &address, 0, nil, &size, &alive) - return status == noErr && alive != 0 - } - - private static func deviceHasInput(_ deviceID: AudioObjectID) -> Bool { - var address = AudioObjectPropertyAddress( - mSelector: kAudioDevicePropertyStreamConfiguration, - mScope: kAudioDevicePropertyScopeInput, - mElement: kAudioObjectPropertyElementMain) - var size: UInt32 = 0 - var status = AudioObjectGetPropertyDataSize(deviceID, &address, 0, nil, &size) - guard status == noErr, size > 0 else { return false } - - let raw = UnsafeMutableRawPointer.allocate( - byteCount: Int(size), - alignment: MemoryLayout.alignment) - defer { raw.deallocate() } - let bufferList = raw.bindMemory(to: AudioBufferList.self, capacity: 1) - status = AudioObjectGetPropertyData(deviceID, &address, 0, nil, &size, bufferList) - guard status == noErr else { return false } - - let buffers = UnsafeMutableAudioBufferListPointer(bufferList) - return buffers.contains(where: { $0.mNumberChannels > 0 }) - } - - private func logDefaultInputChange(reason: StaticString) { - self.logger.info("audio input changed (\(reason)) (\(Self.defaultInputDeviceSummary(), privacy: .public))") - } -} diff --git a/apps/macos/Sources/Clawdbot/CLIInstallPrompter.swift b/apps/macos/Sources/Clawdbot/CLIInstallPrompter.swift deleted file mode 100644 index 75c0b04d4..000000000 --- a/apps/macos/Sources/Clawdbot/CLIInstallPrompter.swift +++ /dev/null @@ -1,84 +0,0 @@ -import AppKit -import Foundation -import OSLog - -@MainActor -final class CLIInstallPrompter { - static let shared = CLIInstallPrompter() - private let logger = Logger(subsystem: "com.clawdbot", category: "cli.prompt") - private var isPrompting = false - - func checkAndPromptIfNeeded(reason: String) { - guard self.shouldPrompt() else { return } - guard let version = Self.appVersion() else { return } - self.isPrompting = true - UserDefaults.standard.set(version, forKey: cliInstallPromptedVersionKey) - - let alert = NSAlert() - alert.messageText = "Install Moltbot CLI?" - alert.informativeText = "Local mode needs the CLI so launchd can run the gateway." - alert.addButton(withTitle: "Install CLI") - alert.addButton(withTitle: "Not now") - alert.addButton(withTitle: "Open Settings") - let response = alert.runModal() - - switch response { - case .alertFirstButtonReturn: - Task { await self.installCLI() } - case .alertThirdButtonReturn: - self.openSettings(tab: .general) - default: - break - } - - self.logger.debug("cli install prompt handled reason=\(reason, privacy: .public)") - self.isPrompting = false - } - - private func shouldPrompt() -> Bool { - guard !self.isPrompting else { return false } - guard AppStateStore.shared.onboardingSeen else { return false } - guard AppStateStore.shared.connectionMode == .local else { return false } - guard CLIInstaller.installedLocation() == nil else { return false } - guard let version = Self.appVersion() else { return false } - let lastPrompt = UserDefaults.standard.string(forKey: cliInstallPromptedVersionKey) - return lastPrompt != version - } - - private func installCLI() async { - let status = StatusBox() - await CLIInstaller.install { message in - await status.set(message) - } - if let message = await status.get() { - let alert = NSAlert() - alert.messageText = "CLI install finished" - alert.informativeText = message - alert.runModal() - } - } - - private func openSettings(tab: SettingsTab) { - SettingsTabRouter.request(tab) - SettingsWindowOpener.shared.open() - DispatchQueue.main.async { - NotificationCenter.default.post(name: .clawdbotSelectSettingsTab, object: tab) - } - } - - private static func appVersion() -> String? { - Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String - } -} - -private actor StatusBox { - private var value: String? - - func set(_ value: String) { - self.value = value - } - - func get() -> String? { - self.value - } -} diff --git a/apps/macos/Sources/Clawdbot/CameraCaptureService.swift b/apps/macos/Sources/Clawdbot/CameraCaptureService.swift deleted file mode 100644 index 49a15262e..000000000 --- a/apps/macos/Sources/Clawdbot/CameraCaptureService.swift +++ /dev/null @@ -1,425 +0,0 @@ -import AVFoundation -import MoltbotIPC -import MoltbotKit -import CoreGraphics -import Foundation -import OSLog - -actor CameraCaptureService { - struct CameraDeviceInfo: Encodable, Sendable { - let id: String - let name: String - let position: String - let deviceType: String - } - - enum CameraError: LocalizedError, Sendable { - case cameraUnavailable - case microphoneUnavailable - case permissionDenied(kind: String) - case captureFailed(String) - case exportFailed(String) - - var errorDescription: String? { - switch self { - case .cameraUnavailable: - "Camera unavailable" - case .microphoneUnavailable: - "Microphone unavailable" - case let .permissionDenied(kind): - "\(kind) permission denied" - case let .captureFailed(msg): - msg - case let .exportFailed(msg): - msg - } - } - } - - private let logger = Logger(subsystem: "com.clawdbot", category: "camera") - - func listDevices() -> [CameraDeviceInfo] { - Self.availableCameras().map { device in - CameraDeviceInfo( - id: device.uniqueID, - name: device.localizedName, - position: Self.positionLabel(device.position), - deviceType: device.deviceType.rawValue) - } - } - - func snap( - facing: CameraFacing?, - maxWidth: Int?, - quality: Double?, - deviceId: String?, - delayMs: Int) async throws -> (data: Data, size: CGSize) - { - let facing = facing ?? .front - let normalized = Self.normalizeSnap(maxWidth: maxWidth, quality: quality) - let maxWidth = normalized.maxWidth - let quality = normalized.quality - let delayMs = max(0, delayMs) - let deviceId = deviceId?.trimmingCharacters(in: .whitespacesAndNewlines) - - try await self.ensureAccess(for: .video) - - let session = AVCaptureSession() - session.sessionPreset = .photo - - guard let device = Self.pickCamera(facing: facing, deviceId: deviceId) else { - throw CameraError.cameraUnavailable - } - - let input = try AVCaptureDeviceInput(device: device) - guard session.canAddInput(input) else { - throw CameraError.captureFailed("Failed to add camera input") - } - session.addInput(input) - - let output = AVCapturePhotoOutput() - guard session.canAddOutput(output) else { - throw CameraError.captureFailed("Failed to add photo output") - } - session.addOutput(output) - output.maxPhotoQualityPrioritization = .quality - - session.startRunning() - defer { session.stopRunning() } - await Self.warmUpCaptureSession() - await self.waitForExposureAndWhiteBalance(device: device) - await self.sleepDelayMs(delayMs) - - let settings: AVCapturePhotoSettings = { - if output.availablePhotoCodecTypes.contains(.jpeg) { - return AVCapturePhotoSettings(format: [AVVideoCodecKey: AVVideoCodecType.jpeg]) - } - return AVCapturePhotoSettings() - }() - settings.photoQualityPrioritization = .quality - - var delegate: PhotoCaptureDelegate? - let rawData: Data = try await withCheckedThrowingContinuation { cont in - let d = PhotoCaptureDelegate(cont) - delegate = d - output.capturePhoto(with: settings, delegate: d) - } - withExtendedLifetime(delegate) {} - - let maxPayloadBytes = 5 * 1024 * 1024 - // Base64 inflates payloads by ~4/3; cap encoded bytes so the payload stays under 5MB (API limit). - let maxEncodedBytes = (maxPayloadBytes / 4) * 3 - let res = try JPEGTranscoder.transcodeToJPEG( - imageData: rawData, - maxWidthPx: maxWidth, - quality: quality, - maxBytes: maxEncodedBytes) - return (data: res.data, size: CGSize(width: res.widthPx, height: res.heightPx)) - } - - func clip( - facing: CameraFacing?, - durationMs: Int?, - includeAudio: Bool, - deviceId: String?, - outPath: String?) async throws -> (path: String, durationMs: Int, hasAudio: Bool) - { - let facing = facing ?? .front - let durationMs = Self.clampDurationMs(durationMs) - let deviceId = deviceId?.trimmingCharacters(in: .whitespacesAndNewlines) - - try await self.ensureAccess(for: .video) - if includeAudio { - try await self.ensureAccess(for: .audio) - } - - let session = AVCaptureSession() - session.sessionPreset = .high - - guard let camera = Self.pickCamera(facing: facing, deviceId: deviceId) else { - throw CameraError.cameraUnavailable - } - let cameraInput = try AVCaptureDeviceInput(device: camera) - guard session.canAddInput(cameraInput) else { - throw CameraError.captureFailed("Failed to add camera input") - } - session.addInput(cameraInput) - - if includeAudio { - guard let mic = AVCaptureDevice.default(for: .audio) else { - throw CameraError.microphoneUnavailable - } - let micInput = try AVCaptureDeviceInput(device: mic) - guard session.canAddInput(micInput) else { - throw CameraError.captureFailed("Failed to add microphone input") - } - session.addInput(micInput) - } - - let output = AVCaptureMovieFileOutput() - guard session.canAddOutput(output) else { - throw CameraError.captureFailed("Failed to add movie output") - } - session.addOutput(output) - output.maxRecordedDuration = CMTime(value: Int64(durationMs), timescale: 1000) - - session.startRunning() - defer { session.stopRunning() } - await Self.warmUpCaptureSession() - - let tmpMovURL = FileManager().temporaryDirectory - .appendingPathComponent("moltbot-camera-\(UUID().uuidString).mov") - defer { try? FileManager().removeItem(at: tmpMovURL) } - - let outputURL: URL = { - if let outPath, !outPath.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { - return URL(fileURLWithPath: outPath) - } - return FileManager().temporaryDirectory - .appendingPathComponent("moltbot-camera-\(UUID().uuidString).mp4") - }() - - // Ensure we don't fail exporting due to an existing file. - try? FileManager().removeItem(at: outputURL) - - let logger = self.logger - var delegate: MovieFileDelegate? - let recordedURL: URL = try await withCheckedThrowingContinuation { cont in - let d = MovieFileDelegate(cont, logger: logger) - delegate = d - output.startRecording(to: tmpMovURL, recordingDelegate: d) - } - withExtendedLifetime(delegate) {} - - try await Self.exportToMP4(inputURL: recordedURL, outputURL: outputURL) - return (path: outputURL.path, durationMs: durationMs, hasAudio: includeAudio) - } - - private func ensureAccess(for mediaType: AVMediaType) async throws { - let status = AVCaptureDevice.authorizationStatus(for: mediaType) - switch status { - case .authorized: - return - case .notDetermined: - let ok = await withCheckedContinuation(isolation: nil) { cont in - AVCaptureDevice.requestAccess(for: mediaType) { granted in - cont.resume(returning: granted) - } - } - if !ok { - throw CameraError.permissionDenied(kind: mediaType == .video ? "Camera" : "Microphone") - } - case .denied, .restricted: - throw CameraError.permissionDenied(kind: mediaType == .video ? "Camera" : "Microphone") - @unknown default: - throw CameraError.permissionDenied(kind: mediaType == .video ? "Camera" : "Microphone") - } - } - - private nonisolated static func availableCameras() -> [AVCaptureDevice] { - var types: [AVCaptureDevice.DeviceType] = [ - .builtInWideAngleCamera, - .continuityCamera, - ] - if let external = externalDeviceType() { - types.append(external) - } - let session = AVCaptureDevice.DiscoverySession( - deviceTypes: types, - mediaType: .video, - position: .unspecified) - return session.devices - } - - private nonisolated static func externalDeviceType() -> AVCaptureDevice.DeviceType? { - if #available(macOS 14.0, *) { - return .external - } - // Use raw value to avoid deprecated symbol in the SDK. - return AVCaptureDevice.DeviceType(rawValue: "AVCaptureDeviceTypeExternalUnknown") - } - - private nonisolated static func pickCamera( - facing: CameraFacing, - deviceId: String?) -> AVCaptureDevice? - { - if let deviceId, !deviceId.isEmpty { - if let match = availableCameras().first(where: { $0.uniqueID == deviceId }) { - return match - } - } - let position: AVCaptureDevice.Position = (facing == .front) ? .front : .back - - if let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: position) { - return device - } - - // Many macOS cameras report `unspecified` position; fall back to any default. - return AVCaptureDevice.default(for: .video) - } - - private nonisolated static func clampQuality(_ quality: Double?) -> Double { - let q = quality ?? 0.9 - return min(1.0, max(0.05, q)) - } - - nonisolated static func normalizeSnap(maxWidth: Int?, quality: Double?) -> (maxWidth: Int, quality: Double) { - // Default to a reasonable max width to keep downstream payload sizes manageable. - // If you need full-res, explicitly request a larger maxWidth. - let maxWidth = maxWidth.flatMap { $0 > 0 ? $0 : nil } ?? 1600 - let quality = Self.clampQuality(quality) - return (maxWidth: maxWidth, quality: quality) - } - - private nonisolated static func clampDurationMs(_ ms: Int?) -> Int { - let v = ms ?? 3000 - return min(60000, max(250, v)) - } - - private nonisolated static func exportToMP4(inputURL: URL, outputURL: URL) async throws { - let asset = AVURLAsset(url: inputURL) - guard let export = AVAssetExportSession(asset: asset, presetName: AVAssetExportPresetMediumQuality) else { - throw CameraError.exportFailed("Failed to create export session") - } - export.shouldOptimizeForNetworkUse = true - - if #available(macOS 15.0, *) { - do { - try await export.export(to: outputURL, as: .mp4) - return - } catch { - throw CameraError.exportFailed(error.localizedDescription) - } - } else { - export.outputURL = outputURL - export.outputFileType = .mp4 - - try await withCheckedThrowingContinuation(isolation: nil) { (cont: CheckedContinuation) in - export.exportAsynchronously { - cont.resume(returning: ()) - } - } - - switch export.status { - case .completed: - return - case .failed: - throw CameraError.exportFailed(export.error?.localizedDescription ?? "export failed") - case .cancelled: - throw CameraError.exportFailed("export cancelled") - default: - throw CameraError.exportFailed("export did not complete (\(export.status.rawValue))") - } - } - } - - private nonisolated static func warmUpCaptureSession() async { - // A short delay after `startRunning()` significantly reduces "blank first frame" captures on some devices. - try? await Task.sleep(nanoseconds: 150_000_000) // 150ms - } - - private func waitForExposureAndWhiteBalance(device: AVCaptureDevice) async { - let stepNs: UInt64 = 50_000_000 - let maxSteps = 30 // ~1.5s - for _ in 0.. 0 else { return } - let ns = UInt64(min(delayMs, 10000)) * 1_000_000 - try? await Task.sleep(nanoseconds: ns) - } - - private nonisolated static func positionLabel(_ position: AVCaptureDevice.Position) -> String { - switch position { - case .front: "front" - case .back: "back" - default: "unspecified" - } - } -} - -private final class PhotoCaptureDelegate: NSObject, AVCapturePhotoCaptureDelegate { - private var cont: CheckedContinuation? - private var didResume = false - - init(_ cont: CheckedContinuation) { - self.cont = cont - } - - func photoOutput( - _ output: AVCapturePhotoOutput, - didFinishProcessingPhoto photo: AVCapturePhoto, - error: Error?) - { - guard !self.didResume, let cont else { return } - self.didResume = true - self.cont = nil - if let error { - cont.resume(throwing: error) - return - } - guard let data = photo.fileDataRepresentation() else { - cont.resume(throwing: CameraCaptureService.CameraError.captureFailed("No photo data")) - return - } - if data.isEmpty { - cont.resume(throwing: CameraCaptureService.CameraError.captureFailed("Photo data empty")) - return - } - cont.resume(returning: data) - } - - func photoOutput( - _ output: AVCapturePhotoOutput, - didFinishCaptureFor resolvedSettings: AVCaptureResolvedPhotoSettings, - error: Error?) - { - guard let error else { return } - guard !self.didResume, let cont else { return } - self.didResume = true - self.cont = nil - cont.resume(throwing: error) - } -} - -private final class MovieFileDelegate: NSObject, AVCaptureFileOutputRecordingDelegate { - private var cont: CheckedContinuation? - private let logger: Logger - - init(_ cont: CheckedContinuation, logger: Logger) { - self.cont = cont - self.logger = logger - } - - func fileOutput( - _ output: AVCaptureFileOutput, - didFinishRecordingTo outputFileURL: URL, - from connections: [AVCaptureConnection], - error: Error?) - { - guard let cont else { return } - self.cont = nil - - if let error { - let ns = error as NSError - if ns.domain == AVFoundationErrorDomain, - ns.code == AVError.maximumDurationReached.rawValue - { - cont.resume(returning: outputFileURL) - return - } - - self.logger.error("camera record failed: \(error.localizedDescription, privacy: .public)") - cont.resume(throwing: error) - return - } - - cont.resume(returning: outputFileURL) - } -} diff --git a/apps/macos/Sources/Clawdbot/CanvasFileWatcher.swift b/apps/macos/Sources/Clawdbot/CanvasFileWatcher.swift deleted file mode 100644 index 131e68748..000000000 --- a/apps/macos/Sources/Clawdbot/CanvasFileWatcher.swift +++ /dev/null @@ -1,94 +0,0 @@ -import CoreServices -import Foundation - -final class CanvasFileWatcher: @unchecked Sendable { - private let url: URL - private let queue: DispatchQueue - private var stream: FSEventStreamRef? - private var pending = false - private let onChange: () -> Void - - init(url: URL, onChange: @escaping () -> Void) { - self.url = url - self.queue = DispatchQueue(label: "com.clawdbot.canvaswatcher") - self.onChange = onChange - } - - deinit { - self.stop() - } - - func start() { - guard self.stream == nil else { return } - - let retainedSelf = Unmanaged.passRetained(self) - var context = FSEventStreamContext( - version: 0, - info: retainedSelf.toOpaque(), - retain: nil, - release: { pointer in - guard let pointer else { return } - Unmanaged.fromOpaque(pointer).release() - }, - copyDescription: nil) - - let paths = [self.url.path] as CFArray - let flags = FSEventStreamCreateFlags( - kFSEventStreamCreateFlagFileEvents | - kFSEventStreamCreateFlagUseCFTypes | - kFSEventStreamCreateFlagNoDefer) - - guard let stream = FSEventStreamCreate( - kCFAllocatorDefault, - Self.callback, - &context, - paths, - FSEventStreamEventId(kFSEventStreamEventIdSinceNow), - 0.05, - flags) - else { - retainedSelf.release() - return - } - - self.stream = stream - FSEventStreamSetDispatchQueue(stream, self.queue) - if FSEventStreamStart(stream) == false { - self.stream = nil - FSEventStreamSetDispatchQueue(stream, nil) - FSEventStreamInvalidate(stream) - FSEventStreamRelease(stream) - } - } - - func stop() { - guard let stream = self.stream else { return } - self.stream = nil - FSEventStreamStop(stream) - FSEventStreamSetDispatchQueue(stream, nil) - FSEventStreamInvalidate(stream) - FSEventStreamRelease(stream) - } -} - -extension CanvasFileWatcher { - private static let callback: FSEventStreamCallback = { _, info, numEvents, _, eventFlags, _ in - guard let info else { return } - let watcher = Unmanaged.fromOpaque(info).takeUnretainedValue() - watcher.handleEvents(numEvents: numEvents, eventFlags: eventFlags) - } - - private func handleEvents(numEvents: Int, eventFlags: UnsafePointer?) { - guard numEvents > 0 else { return } - guard eventFlags != nil else { return } - - // Coalesce rapid changes (common during builds/atomic saves). - if self.pending { return } - self.pending = true - self.queue.asyncAfter(deadline: .now() + 0.12) { [weak self] in - guard let self else { return } - self.pending = false - self.onChange() - } - } -} diff --git a/apps/macos/Sources/Clawdbot/CanvasManager.swift b/apps/macos/Sources/Clawdbot/CanvasManager.swift deleted file mode 100644 index 9a0f32d61..000000000 --- a/apps/macos/Sources/Clawdbot/CanvasManager.swift +++ /dev/null @@ -1,342 +0,0 @@ -import AppKit -import MoltbotIPC -import MoltbotKit -import Foundation -import OSLog - -@MainActor -final class CanvasManager { - static let shared = CanvasManager() - - private static let logger = Logger(subsystem: "com.clawdbot", category: "CanvasManager") - - private var panelController: CanvasWindowController? - private var panelSessionKey: String? - private var lastAutoA2UIUrl: String? - private var gatewayWatchTask: Task? - - private init() { - self.startGatewayObserver() - } - - var onPanelVisibilityChanged: ((Bool) -> Void)? - - /// Optional anchor provider (e.g. menu bar status item). If nil, Canvas anchors to the mouse cursor. - var defaultAnchorProvider: (() -> NSRect?)? - - private nonisolated static let canvasRoot: URL = { - let base = FileManager().urls(for: .applicationSupportDirectory, in: .userDomainMask).first! - return base.appendingPathComponent("Moltbot/canvas", isDirectory: true) - }() - - func show(sessionKey: String, path: String? = nil, placement: CanvasPlacement? = nil) throws -> String { - try self.showDetailed(sessionKey: sessionKey, target: path, placement: placement).directory - } - - func showDetailed( - sessionKey: String, - target: String? = nil, - placement: CanvasPlacement? = nil) throws -> CanvasShowResult - { - Self.logger.debug( - """ - showDetailed start session=\(sessionKey, privacy: .public) \ - target=\(target ?? "", privacy: .public) \ - placement=\(placement != nil) - """) - let anchorProvider = self.defaultAnchorProvider ?? Self.mouseAnchorProvider - let session = sessionKey.trimmingCharacters(in: .whitespacesAndNewlines) - let normalizedTarget = target? - .trimmingCharacters(in: .whitespacesAndNewlines) - .nonEmpty - - if let controller = self.panelController, self.panelSessionKey == session { - Self.logger.debug("showDetailed reuse existing session=\(session, privacy: .public)") - controller.onVisibilityChanged = { [weak self] visible in - self?.onPanelVisibilityChanged?(visible) - } - controller.presentAnchoredPanel(anchorProvider: anchorProvider) - controller.applyPreferredPlacement(placement) - self.refreshDebugStatus() - - // Existing session: only navigate when an explicit target was provided. - if let normalizedTarget { - controller.load(target: normalizedTarget) - return self.makeShowResult( - directory: controller.directoryPath, - target: target, - effectiveTarget: normalizedTarget) - } - - self.maybeAutoNavigateToA2UIAsync(controller: controller) - return CanvasShowResult( - directory: controller.directoryPath, - target: target, - effectiveTarget: nil, - status: .shown, - url: nil) - } - - Self.logger.debug("showDetailed creating new session=\(session, privacy: .public)") - self.panelController?.close() - self.panelController = nil - self.panelSessionKey = nil - - Self.logger.debug("showDetailed ensure canvas root dir") - try FileManager().createDirectory(at: Self.canvasRoot, withIntermediateDirectories: true) - Self.logger.debug("showDetailed init CanvasWindowController") - let controller = try CanvasWindowController( - sessionKey: session, - root: Self.canvasRoot, - presentation: .panel(anchorProvider: anchorProvider)) - Self.logger.debug("showDetailed CanvasWindowController init done") - controller.onVisibilityChanged = { [weak self] visible in - self?.onPanelVisibilityChanged?(visible) - } - self.panelController = controller - self.panelSessionKey = session - controller.applyPreferredPlacement(placement) - - // New session: default to "/" so the user sees either the welcome page or `index.html`. - let effectiveTarget = normalizedTarget ?? "/" - Self.logger.debug("showDetailed showCanvas effectiveTarget=\(effectiveTarget, privacy: .public)") - controller.showCanvas(path: effectiveTarget) - Self.logger.debug("showDetailed showCanvas done") - if normalizedTarget == nil { - self.maybeAutoNavigateToA2UIAsync(controller: controller) - } - self.refreshDebugStatus() - - return self.makeShowResult( - directory: controller.directoryPath, - target: target, - effectiveTarget: effectiveTarget) - } - - func hide(sessionKey: String) { - let session = sessionKey.trimmingCharacters(in: .whitespacesAndNewlines) - guard self.panelSessionKey == session else { return } - self.panelController?.hideCanvas() - } - - func hideAll() { - self.panelController?.hideCanvas() - } - - func eval(sessionKey: String, javaScript: String) async throws -> String { - _ = try self.show(sessionKey: sessionKey, path: nil) - guard let controller = self.panelController else { return "" } - return try await controller.eval(javaScript: javaScript) - } - - func snapshot(sessionKey: String, outPath: String?) async throws -> String { - _ = try self.show(sessionKey: sessionKey, path: nil) - guard let controller = self.panelController else { - throw NSError(domain: "Canvas", code: 21, userInfo: [NSLocalizedDescriptionKey: "canvas not available"]) - } - return try await controller.snapshot(to: outPath) - } - - // MARK: - Gateway A2UI auto-nav - - private func startGatewayObserver() { - self.gatewayWatchTask?.cancel() - self.gatewayWatchTask = Task { [weak self] in - guard let self else { return } - let stream = await GatewayConnection.shared.subscribe(bufferingNewest: 1) - for await push in stream { - self.handleGatewayPush(push) - } - } - } - - private func handleGatewayPush(_ push: GatewayPush) { - guard case let .snapshot(snapshot) = push else { return } - let raw = snapshot.canvashosturl?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if raw.isEmpty { - Self.logger.debug("canvas host url missing in gateway snapshot") - } else { - Self.logger.debug("canvas host url snapshot=\(raw, privacy: .public)") - } - let a2uiUrl = Self.resolveA2UIHostUrl(from: raw) - if a2uiUrl == nil, !raw.isEmpty { - Self.logger.debug("canvas host url invalid; cannot resolve A2UI") - } - guard let controller = self.panelController else { - if a2uiUrl != nil { - Self.logger.debug("canvas panel not visible; skipping auto-nav") - } - return - } - self.maybeAutoNavigateToA2UI(controller: controller, a2uiUrl: a2uiUrl) - } - - private func maybeAutoNavigateToA2UIAsync(controller: CanvasWindowController) { - Task { [weak self] in - guard let self else { return } - let a2uiUrl = await self.resolveA2UIHostUrl() - await MainActor.run { - guard self.panelController === controller else { return } - self.maybeAutoNavigateToA2UI(controller: controller, a2uiUrl: a2uiUrl) - } - } - } - - private func maybeAutoNavigateToA2UI(controller: CanvasWindowController, a2uiUrl: String?) { - guard let a2uiUrl else { return } - let shouldNavigate = controller.shouldAutoNavigateToA2UI(lastAutoTarget: self.lastAutoA2UIUrl) - guard shouldNavigate else { - Self.logger.debug("canvas auto-nav skipped; target unchanged") - return - } - Self.logger.debug("canvas auto-nav -> \(a2uiUrl, privacy: .public)") - controller.load(target: a2uiUrl) - self.lastAutoA2UIUrl = a2uiUrl - } - - private func resolveA2UIHostUrl() async -> String? { - let raw = await GatewayConnection.shared.canvasHostUrl() - return Self.resolveA2UIHostUrl(from: raw) - } - - func refreshDebugStatus() { - guard let controller = self.panelController else { return } - let enabled = AppStateStore.shared.debugPaneEnabled - let mode = AppStateStore.shared.connectionMode - let title: String? - let subtitle: String? - switch mode { - case .remote: - title = "Remote control" - switch ControlChannel.shared.state { - case .connected: - subtitle = "Connected" - case .connecting: - subtitle = "Connecting…" - case .disconnected: - subtitle = "Disconnected" - case let .degraded(message): - subtitle = message.isEmpty ? "Degraded" : message - } - case .local: - title = GatewayProcessManager.shared.status.label - subtitle = mode.rawValue - case .unconfigured: - title = "Unconfigured" - subtitle = mode.rawValue - } - controller.updateDebugStatus(enabled: enabled, title: title, subtitle: subtitle) - } - - private static func resolveA2UIHostUrl(from raw: String?) -> String? { - let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - guard !trimmed.isEmpty, let base = URL(string: trimmed) else { return nil } - return base.appendingPathComponent("__moltbot__/a2ui/").absoluteString + "?platform=macos" - } - - // MARK: - Anchoring - - private static func mouseAnchorProvider() -> NSRect? { - let pt = NSEvent.mouseLocation - return NSRect(x: pt.x, y: pt.y, width: 1, height: 1) - } - - // placement interpretation is handled by the window controller. - - // MARK: - Helpers - - private static func directURL(for target: String?) -> URL? { - guard let target else { return nil } - let trimmed = target.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty else { return nil } - - if let url = URL(string: trimmed), let scheme = url.scheme?.lowercased() { - if scheme == "https" || scheme == "http" || scheme == "file" { return url } - } - - // Convenience: existing absolute *file* paths resolve as local files. - // (Avoid treating Canvas routes like "/" as filesystem paths.) - if trimmed.hasPrefix("/") { - var isDir: ObjCBool = false - if FileManager().fileExists(atPath: trimmed, isDirectory: &isDir), !isDir.boolValue { - return URL(fileURLWithPath: trimmed) - } - } - - return nil - } - - private func makeShowResult( - directory: String, - target: String?, - effectiveTarget: String) -> CanvasShowResult - { - if let url = Self.directURL(for: effectiveTarget) { - return CanvasShowResult( - directory: directory, - target: target, - effectiveTarget: effectiveTarget, - status: .web, - url: url.absoluteString) - } - - let sessionDir = URL(fileURLWithPath: directory) - let status = Self.localStatus(sessionDir: sessionDir, target: effectiveTarget) - let host = sessionDir.lastPathComponent - let canvasURL = CanvasScheme.makeURL(session: host, path: effectiveTarget)?.absoluteString - return CanvasShowResult( - directory: directory, - target: target, - effectiveTarget: effectiveTarget, - status: status, - url: canvasURL) - } - - private static func localStatus(sessionDir: URL, target: String) -> CanvasShowStatus { - let fm = FileManager() - let trimmed = target.trimmingCharacters(in: .whitespacesAndNewlines) - let withoutQuery = trimmed.split(separator: "?", maxSplits: 1, omittingEmptySubsequences: false).first - .map(String.init) ?? trimmed - var path = withoutQuery - if path.hasPrefix("/") { path.removeFirst() } - path = path.removingPercentEncoding ?? path - - // Root special-case: built-in scaffold page when no index exists. - if path.isEmpty { - let a = sessionDir.appendingPathComponent("index.html", isDirectory: false) - let b = sessionDir.appendingPathComponent("index.htm", isDirectory: false) - if fm.fileExists(atPath: a.path) || fm.fileExists(atPath: b.path) { return .ok } - return .welcome - } - - // Direct file or directory. - var candidate = sessionDir.appendingPathComponent(path, isDirectory: false) - var isDir: ObjCBool = false - if fm.fileExists(atPath: candidate.path, isDirectory: &isDir) { - if isDir.boolValue { - return Self.indexExists(in: candidate) ? .ok : .notFound - } - return .ok - } - - // Directory index behavior ("/yolo" -> "yolo/index.html") if directory exists. - if !path.isEmpty, !path.hasSuffix("/") { - candidate = sessionDir.appendingPathComponent(path, isDirectory: true) - if fm.fileExists(atPath: candidate.path, isDirectory: &isDir), isDir.boolValue { - return Self.indexExists(in: candidate) ? .ok : .notFound - } - } - - return .notFound - } - - private static func indexExists(in dir: URL) -> Bool { - let fm = FileManager() - let a = dir.appendingPathComponent("index.html", isDirectory: false) - if fm.fileExists(atPath: a.path) { return true } - let b = dir.appendingPathComponent("index.htm", isDirectory: false) - return fm.fileExists(atPath: b.path) - } - - // no bundled A2UI shell; scaffold fallback is purely visual -} diff --git a/apps/macos/Sources/Clawdbot/CanvasSchemeHandler.swift b/apps/macos/Sources/Clawdbot/CanvasSchemeHandler.swift deleted file mode 100644 index 92bc8e71b..000000000 --- a/apps/macos/Sources/Clawdbot/CanvasSchemeHandler.swift +++ /dev/null @@ -1,259 +0,0 @@ -import MoltbotKit -import Foundation -import OSLog -import WebKit - -private let canvasLogger = Logger(subsystem: "com.clawdbot", category: "Canvas") - -final class CanvasSchemeHandler: NSObject, WKURLSchemeHandler { - private let root: URL - - init(root: URL) { - self.root = root - } - - func webView(_: WKWebView, start urlSchemeTask: WKURLSchemeTask) { - guard let url = urlSchemeTask.request.url else { - urlSchemeTask.didFailWithError(NSError(domain: "Canvas", code: 1, userInfo: [ - NSLocalizedDescriptionKey: "missing url", - ])) - return - } - - let response = self.response(for: url) - let mime = response.mime - let data = response.data - let encoding = self.textEncodingName(forMimeType: mime) - - let urlResponse = URLResponse( - url: url, - mimeType: mime, - expectedContentLength: data.count, - textEncodingName: encoding) - urlSchemeTask.didReceive(urlResponse) - urlSchemeTask.didReceive(data) - urlSchemeTask.didFinish() - } - - func webView(_: WKWebView, stop _: WKURLSchemeTask) { - // no-op - } - - private struct CanvasResponse { - let mime: String - let data: Data - } - - private func response(for url: URL) -> CanvasResponse { - guard url.scheme == CanvasScheme.scheme else { - return self.html("Invalid scheme.") - } - guard let session = url.host, !session.isEmpty else { - return self.html("Missing session.") - } - - // Keep session component safe; don't allow slashes or traversal. - if session.contains("/") || session.contains("..") { - return self.html("Invalid session.") - } - - let sessionRoot = self.root.appendingPathComponent(session, isDirectory: true) - - // Path mapping: request path maps directly into the session dir. - var path = url.path - if let qIdx = path.firstIndex(of: "?") { path = String(path[.. \(servedPath, privacy: .public)") - return CanvasResponse(mime: mime, data: data) - } catch { - let failedPath = standardizedFile.path - let errorText = error.localizedDescription - canvasLogger - .error( - "failed reading \(failedPath, privacy: .public): \(errorText, privacy: .public)") - return self.html("Failed to read file.", title: "Canvas error") - } - } - - private func resolveFileURL(sessionRoot: URL, requestPath: String) -> URL? { - let fm = FileManager() - var candidate = sessionRoot.appendingPathComponent(requestPath, isDirectory: false) - - var isDir: ObjCBool = false - if fm.fileExists(atPath: candidate.path, isDirectory: &isDir) { - if isDir.boolValue { - if let idx = self.resolveIndex(in: candidate) { return idx } - return nil - } - return candidate - } - - // Directory index behavior: - // - "/yolo" serves "/index.html" if that directory exists. - if !requestPath.isEmpty, !requestPath.hasSuffix("/") { - candidate = sessionRoot.appendingPathComponent(requestPath, isDirectory: true) - if fm.fileExists(atPath: candidate.path, isDirectory: &isDir), isDir.boolValue { - if let idx = self.resolveIndex(in: candidate) { return idx } - } - } - - // Root fallback: - // - "/" serves "/index.html" if present. - if requestPath.isEmpty { - return self.resolveIndex(in: sessionRoot) - } - - return nil - } - - private func resolveIndex(in dir: URL) -> URL? { - let fm = FileManager() - let a = dir.appendingPathComponent("index.html", isDirectory: false) - if fm.fileExists(atPath: a.path) { return a } - let b = dir.appendingPathComponent("index.htm", isDirectory: false) - if fm.fileExists(atPath: b.path) { return b } - return nil - } - - private func html(_ body: String, title: String = "Canvas") -> CanvasResponse { - let html = """ - - - - - - \(title) - - - -
    -
    \(body)
    -
    - - - """ - return CanvasResponse(mime: "text/html", data: Data(html.utf8)) - } - - private func welcomePage(sessionRoot: URL) -> CanvasResponse { - let escaped = sessionRoot.path - .replacingOccurrences(of: "&", with: "&") - .replacingOccurrences(of: "<", with: "<") - .replacingOccurrences(of: ">", with: ">") - let body = """ -
    Canvas is ready.
    -
    Create index.html in:
    -
    \(escaped)
    - """ - return self.html(body, title: "Canvas") - } - - private func scaffoldPage(sessionRoot: URL) -> CanvasResponse { - // Default Canvas UX: when no index exists, show the built-in scaffold page. - if let data = self.loadBundledResourceData(relativePath: "CanvasScaffold/scaffold.html") { - return CanvasResponse(mime: "text/html", data: data) - } - - // Fallback for dev misconfiguration: show the classic welcome page. - return self.welcomePage(sessionRoot: sessionRoot) - } - - private func loadBundledResourceData(relativePath: String) -> Data? { - let trimmed = relativePath.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty else { return nil } - if trimmed.contains("..") || trimmed.contains("\\") { return nil } - - let parts = trimmed.split(separator: "/") - guard let filename = parts.last else { return nil } - let subdirectory = - parts.count > 1 ? parts.dropLast().joined(separator: "/") : nil - let fileURL = URL(fileURLWithPath: String(filename)) - let ext = fileURL.pathExtension - let name = fileURL.deletingPathExtension().lastPathComponent - guard !name.isEmpty, !ext.isEmpty else { return nil } - - let bundle = MoltbotKitResources.bundle - let resourceURL = - bundle.url(forResource: name, withExtension: ext, subdirectory: subdirectory) - ?? bundle.url(forResource: name, withExtension: ext) - guard let resourceURL else { return nil } - return try? Data(contentsOf: resourceURL) - } - - private func textEncodingName(forMimeType mimeType: String) -> String? { - if mimeType.hasPrefix("text/") { return "utf-8" } - switch mimeType { - case "application/javascript", "application/json", "image/svg+xml": - return "utf-8" - default: - return nil - } - } -} - -#if DEBUG -extension CanvasSchemeHandler { - func _testResponse(for url: URL) -> (mime: String, data: Data) { - let response = self.response(for: url) - return (response.mime, response.data) - } - - func _testResolveFileURL(sessionRoot: URL, requestPath: String) -> URL? { - self.resolveFileURL(sessionRoot: sessionRoot, requestPath: requestPath) - } - - func _testTextEncodingName(for mimeType: String) -> String? { - self.textEncodingName(forMimeType: mimeType) - } -} -#endif diff --git a/apps/macos/Sources/Clawdbot/CanvasWindow.swift b/apps/macos/Sources/Clawdbot/CanvasWindow.swift deleted file mode 100644 index 47e0a4128..000000000 --- a/apps/macos/Sources/Clawdbot/CanvasWindow.swift +++ /dev/null @@ -1,26 +0,0 @@ -import AppKit - -let canvasWindowLogger = Logger(subsystem: "com.clawdbot", category: "Canvas") - -enum CanvasLayout { - static let panelSize = NSSize(width: 520, height: 680) - static let windowSize = NSSize(width: 1120, height: 840) - static let anchorPadding: CGFloat = 8 - static let defaultPadding: CGFloat = 10 - static let minPanelSize = NSSize(width: 360, height: 360) -} - -final class CanvasPanel: NSPanel { - override var canBecomeKey: Bool { true } - override var canBecomeMain: Bool { true } -} - -enum CanvasPresentation { - case window - case panel(anchorProvider: () -> NSRect?) - - var isPanel: Bool { - if case .panel = self { return true } - return false - } -} diff --git a/apps/macos/Sources/Clawdbot/ClawdbotConfigFile.swift b/apps/macos/Sources/Clawdbot/ClawdbotConfigFile.swift deleted file mode 100644 index 0ca77af30..000000000 --- a/apps/macos/Sources/Clawdbot/ClawdbotConfigFile.swift +++ /dev/null @@ -1,217 +0,0 @@ -import MoltbotProtocol -import Foundation - -enum MoltbotConfigFile { - private static let logger = Logger(subsystem: "com.clawdbot", category: "config") - - static func url() -> URL { - MoltbotPaths.configURL - } - - static func stateDirURL() -> URL { - MoltbotPaths.stateDirURL - } - - static func defaultWorkspaceURL() -> URL { - MoltbotPaths.workspaceURL - } - - static func loadDict() -> [String: Any] { - let url = self.url() - guard FileManager().fileExists(atPath: url.path) else { return [:] } - do { - let data = try Data(contentsOf: url) - guard let root = self.parseConfigData(data) else { - self.logger.warning("config JSON root invalid") - return [:] - } - return root - } catch { - self.logger.warning("config read failed: \(error.localizedDescription)") - return [:] - } - } - - static func saveDict(_ dict: [String: Any]) { - // Nix mode disables config writes in production, but tests rely on saving temp configs. - if ProcessInfo.processInfo.isNixMode, !ProcessInfo.processInfo.isRunningTests { return } - do { - let data = try JSONSerialization.data(withJSONObject: dict, options: [.prettyPrinted, .sortedKeys]) - let url = self.url() - try FileManager().createDirectory( - at: url.deletingLastPathComponent(), - withIntermediateDirectories: true) - try data.write(to: url, options: [.atomic]) - } catch { - self.logger.error("config save failed: \(error.localizedDescription)") - } - } - - static func loadGatewayDict() -> [String: Any] { - let root = self.loadDict() - return root["gateway"] as? [String: Any] ?? [:] - } - - static func updateGatewayDict(_ mutate: (inout [String: Any]) -> Void) { - var root = self.loadDict() - var gateway = root["gateway"] as? [String: Any] ?? [:] - mutate(&gateway) - if gateway.isEmpty { - root.removeValue(forKey: "gateway") - } else { - root["gateway"] = gateway - } - self.saveDict(root) - } - - static func browserControlEnabled(defaultValue: Bool = true) -> Bool { - let root = self.loadDict() - let browser = root["browser"] as? [String: Any] - return browser?["enabled"] as? Bool ?? defaultValue - } - - static func setBrowserControlEnabled(_ enabled: Bool) { - var root = self.loadDict() - var browser = root["browser"] as? [String: Any] ?? [:] - browser["enabled"] = enabled - root["browser"] = browser - self.saveDict(root) - self.logger.debug("browser control updated enabled=\(enabled)") - } - - static func agentWorkspace() -> String? { - let root = self.loadDict() - let agents = root["agents"] as? [String: Any] - let defaults = agents?["defaults"] as? [String: Any] - return defaults?["workspace"] as? String - } - - static func setAgentWorkspace(_ workspace: String?) { - var root = self.loadDict() - var agents = root["agents"] as? [String: Any] ?? [:] - var defaults = agents["defaults"] as? [String: Any] ?? [:] - let trimmed = workspace?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if trimmed.isEmpty { - defaults.removeValue(forKey: "workspace") - } else { - defaults["workspace"] = trimmed - } - if defaults.isEmpty { - agents.removeValue(forKey: "defaults") - } else { - agents["defaults"] = defaults - } - if agents.isEmpty { - root.removeValue(forKey: "agents") - } else { - root["agents"] = agents - } - self.saveDict(root) - self.logger.debug("agents.defaults.workspace updated set=\(!trimmed.isEmpty)") - } - - static func gatewayPassword() -> String? { - let root = self.loadDict() - guard let gateway = root["gateway"] as? [String: Any], - let remote = gateway["remote"] as? [String: Any] - else { - return nil - } - return remote["password"] as? String - } - - static func gatewayPort() -> Int? { - let root = self.loadDict() - guard let gateway = root["gateway"] as? [String: Any] else { return nil } - if let port = gateway["port"] as? Int, port > 0 { return port } - if let number = gateway["port"] as? NSNumber, number.intValue > 0 { - return number.intValue - } - if let raw = gateway["port"] as? String, - let parsed = Int(raw.trimmingCharacters(in: .whitespacesAndNewlines)), - parsed > 0 - { - return parsed - } - return nil - } - - static func remoteGatewayPort() -> Int? { - guard let url = self.remoteGatewayUrl(), - let port = url.port, - port > 0 - else { return nil } - return port - } - - static func remoteGatewayPort(matchingHost sshHost: String) -> Int? { - let trimmedSshHost = sshHost.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmedSshHost.isEmpty, - let url = self.remoteGatewayUrl(), - let port = url.port, - port > 0, - let urlHost = url.host?.trimmingCharacters(in: .whitespacesAndNewlines), - !urlHost.isEmpty - else { - return nil - } - - let sshKey = Self.hostKey(trimmedSshHost) - let urlKey = Self.hostKey(urlHost) - guard !sshKey.isEmpty, !urlKey.isEmpty, sshKey == urlKey else { return nil } - return port - } - - static func setRemoteGatewayUrl(host: String, port: Int?) { - guard let port, port > 0 else { return } - let trimmedHost = host.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmedHost.isEmpty else { return } - self.updateGatewayDict { gateway in - var remote = gateway["remote"] as? [String: Any] ?? [:] - let existingUrl = (remote["url"] as? String)? - .trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - let scheme = URL(string: existingUrl)?.scheme ?? "ws" - remote["url"] = "\(scheme)://\(trimmedHost):\(port)" - gateway["remote"] = remote - } - } - - private static func remoteGatewayUrl() -> URL? { - let root = self.loadDict() - guard let gateway = root["gateway"] as? [String: Any], - let remote = gateway["remote"] as? [String: Any], - let raw = remote["url"] as? String - else { - return nil - } - let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty, let url = URL(string: trimmed) else { return nil } - return url - } - - private static func hostKey(_ host: String) -> String { - let trimmed = host.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() - guard !trimmed.isEmpty else { return "" } - if trimmed.contains(":") { return trimmed } - let digits = CharacterSet(charactersIn: "0123456789.") - if trimmed.rangeOfCharacter(from: digits.inverted) == nil { - return trimmed - } - return trimmed.split(separator: ".").first.map(String.init) ?? trimmed - } - - private static func parseConfigData(_ data: Data) -> [String: Any]? { - if let root = try? JSONSerialization.jsonObject(with: data) as? [String: Any] { - return root - } - let decoder = JSONDecoder() - if #available(macOS 12.0, *) { - decoder.allowsJSON5 = true - } - if let decoded = try? decoder.decode([String: AnyCodable].self, from: data) { - self.logger.notice("config parsed with JSON5 decoder") - return decoded.mapValues { $0.foundationValue } - } - return nil - } -} diff --git a/apps/macos/Sources/Clawdbot/ConfigFileWatcher.swift b/apps/macos/Sources/Clawdbot/ConfigFileWatcher.swift deleted file mode 100644 index c21b002a7..000000000 --- a/apps/macos/Sources/Clawdbot/ConfigFileWatcher.swift +++ /dev/null @@ -1,118 +0,0 @@ -import CoreServices -import Foundation - -final class ConfigFileWatcher: @unchecked Sendable { - private let url: URL - private let queue: DispatchQueue - private var stream: FSEventStreamRef? - private var pending = false - private let onChange: () -> Void - private let watchedDir: URL - private let targetPath: String - private let targetName: String - - init(url: URL, onChange: @escaping () -> Void) { - self.url = url - self.queue = DispatchQueue(label: "com.clawdbot.configwatcher") - self.onChange = onChange - self.watchedDir = url.deletingLastPathComponent() - self.targetPath = url.path - self.targetName = url.lastPathComponent - } - - deinit { - self.stop() - } - - func start() { - guard self.stream == nil else { return } - - let retainedSelf = Unmanaged.passRetained(self) - var context = FSEventStreamContext( - version: 0, - info: retainedSelf.toOpaque(), - retain: nil, - release: { pointer in - guard let pointer else { return } - Unmanaged.fromOpaque(pointer).release() - }, - copyDescription: nil) - - let paths = [self.watchedDir.path] as CFArray - let flags = FSEventStreamCreateFlags( - kFSEventStreamCreateFlagFileEvents | - kFSEventStreamCreateFlagUseCFTypes | - kFSEventStreamCreateFlagNoDefer) - - guard let stream = FSEventStreamCreate( - kCFAllocatorDefault, - Self.callback, - &context, - paths, - FSEventStreamEventId(kFSEventStreamEventIdSinceNow), - 0.05, - flags) - else { - retainedSelf.release() - return - } - - self.stream = stream - FSEventStreamSetDispatchQueue(stream, self.queue) - if FSEventStreamStart(stream) == false { - self.stream = nil - FSEventStreamSetDispatchQueue(stream, nil) - FSEventStreamInvalidate(stream) - FSEventStreamRelease(stream) - } - } - - func stop() { - guard let stream = self.stream else { return } - self.stream = nil - FSEventStreamStop(stream) - FSEventStreamSetDispatchQueue(stream, nil) - FSEventStreamInvalidate(stream) - FSEventStreamRelease(stream) - } -} - -extension ConfigFileWatcher { - private static let callback: FSEventStreamCallback = { _, info, numEvents, eventPaths, eventFlags, _ in - guard let info else { return } - let watcher = Unmanaged.fromOpaque(info).takeUnretainedValue() - watcher.handleEvents( - numEvents: numEvents, - eventPaths: eventPaths, - eventFlags: eventFlags) - } - - private func handleEvents( - numEvents: Int, - eventPaths: UnsafeMutableRawPointer?, - eventFlags: UnsafePointer?) - { - guard numEvents > 0 else { return } - guard eventFlags != nil else { return } - guard self.matchesTarget(eventPaths: eventPaths) else { return } - - if self.pending { return } - self.pending = true - self.queue.asyncAfter(deadline: .now() + 0.12) { [weak self] in - guard let self else { return } - self.pending = false - self.onChange() - } - } - - private func matchesTarget(eventPaths: UnsafeMutableRawPointer?) -> Bool { - guard let eventPaths else { return true } - let paths = unsafeBitCast(eventPaths, to: NSArray.self) - for case let path as String in paths { - if path == self.targetPath { return true } - if path.hasSuffix("/\(self.targetName)") { return true } - if path == self.watchedDir.path { return true } - } - return false - } -} diff --git a/apps/macos/Sources/Clawdbot/ConnectionModeCoordinator.swift b/apps/macos/Sources/Clawdbot/ConnectionModeCoordinator.swift deleted file mode 100644 index 00f93bd85..000000000 --- a/apps/macos/Sources/Clawdbot/ConnectionModeCoordinator.swift +++ /dev/null @@ -1,79 +0,0 @@ -import Foundation -import OSLog - -@MainActor -final class ConnectionModeCoordinator { - static let shared = ConnectionModeCoordinator() - - private let logger = Logger(subsystem: "com.clawdbot", category: "connection") - private var lastMode: AppState.ConnectionMode? - - /// Apply the requested connection mode by starting/stopping local gateway, - /// managing the control-channel SSH tunnel, and cleaning up chat windows/panels. - func apply(mode: AppState.ConnectionMode, paused: Bool) async { - if let lastMode = self.lastMode, lastMode != mode { - GatewayProcessManager.shared.clearLastFailure() - NodesStore.shared.lastError = nil - } - self.lastMode = mode - switch mode { - case .unconfigured: - _ = await NodeServiceManager.stop() - NodesStore.shared.lastError = nil - await RemoteTunnelManager.shared.stopAll() - WebChatManager.shared.resetTunnels() - GatewayProcessManager.shared.stop() - await GatewayConnection.shared.shutdown() - await ControlChannel.shared.disconnect() - Task.detached { await PortGuardian.shared.sweep(mode: .unconfigured) } - - case .local: - _ = await NodeServiceManager.stop() - NodesStore.shared.lastError = nil - await RemoteTunnelManager.shared.stopAll() - WebChatManager.shared.resetTunnels() - let shouldStart = GatewayAutostartPolicy.shouldStartGateway(mode: .local, paused: paused) - if shouldStart { - GatewayProcessManager.shared.setActive(true) - if GatewayAutostartPolicy.shouldEnsureLaunchAgent( - mode: .local, - paused: paused) - { - Task { await GatewayProcessManager.shared.ensureLaunchAgentEnabledIfNeeded() } - } - _ = await GatewayProcessManager.shared.waitForGatewayReady() - } else { - GatewayProcessManager.shared.stop() - } - do { - try await ControlChannel.shared.configure(mode: .local) - } catch { - // Control channel will mark itself degraded; nothing else to do here. - self.logger.error( - "control channel local configure failed: \(error.localizedDescription, privacy: .public)") - } - Task.detached { await PortGuardian.shared.sweep(mode: .local) } - - case .remote: - // Never run a local gateway in remote mode. - GatewayProcessManager.shared.stop() - WebChatManager.shared.resetTunnels() - - do { - NodesStore.shared.lastError = nil - if let error = await NodeServiceManager.start() { - NodesStore.shared.lastError = "Node service start failed: \(error)" - } - _ = try await GatewayEndpointStore.shared.ensureRemoteControlTunnel() - let settings = CommandResolver.connectionSettings() - try await ControlChannel.shared.configure(mode: .remote( - target: settings.target, - identity: settings.identity)) - } catch { - self.logger.error("remote tunnel/configure failed: \(error.localizedDescription, privacy: .public)") - } - - Task.detached { await PortGuardian.shared.sweep(mode: .remote) } - } - } -} diff --git a/apps/macos/Sources/Clawdbot/Constants.swift b/apps/macos/Sources/Clawdbot/Constants.swift deleted file mode 100644 index dcb36d4a9..000000000 --- a/apps/macos/Sources/Clawdbot/Constants.swift +++ /dev/null @@ -1,44 +0,0 @@ -import Foundation - -let launchdLabel = "com.clawdbot.mac" -let gatewayLaunchdLabel = "com.clawdbot.gateway" -let onboardingVersionKey = "moltbot.onboardingVersion" -let currentOnboardingVersion = 7 -let pauseDefaultsKey = "moltbot.pauseEnabled" -let iconAnimationsEnabledKey = "moltbot.iconAnimationsEnabled" -let swabbleEnabledKey = "moltbot.swabbleEnabled" -let swabbleTriggersKey = "moltbot.swabbleTriggers" -let voiceWakeTriggerChimeKey = "moltbot.voiceWakeTriggerChime" -let voiceWakeSendChimeKey = "moltbot.voiceWakeSendChime" -let showDockIconKey = "moltbot.showDockIcon" -let defaultVoiceWakeTriggers = ["clawd", "claude"] -let voiceWakeMaxWords = 32 -let voiceWakeMaxWordLength = 64 -let voiceWakeMicKey = "moltbot.voiceWakeMicID" -let voiceWakeMicNameKey = "moltbot.voiceWakeMicName" -let voiceWakeLocaleKey = "moltbot.voiceWakeLocaleID" -let voiceWakeAdditionalLocalesKey = "moltbot.voiceWakeAdditionalLocaleIDs" -let voicePushToTalkEnabledKey = "moltbot.voicePushToTalkEnabled" -let talkEnabledKey = "moltbot.talkEnabled" -let iconOverrideKey = "moltbot.iconOverride" -let connectionModeKey = "moltbot.connectionMode" -let remoteTargetKey = "moltbot.remoteTarget" -let remoteIdentityKey = "moltbot.remoteIdentity" -let remoteProjectRootKey = "moltbot.remoteProjectRoot" -let remoteCliPathKey = "moltbot.remoteCliPath" -let canvasEnabledKey = "moltbot.canvasEnabled" -let cameraEnabledKey = "moltbot.cameraEnabled" -let systemRunPolicyKey = "moltbot.systemRunPolicy" -let systemRunAllowlistKey = "moltbot.systemRunAllowlist" -let systemRunEnabledKey = "moltbot.systemRunEnabled" -let locationModeKey = "moltbot.locationMode" -let locationPreciseKey = "moltbot.locationPreciseEnabled" -let peekabooBridgeEnabledKey = "moltbot.peekabooBridgeEnabled" -let deepLinkKeyKey = "moltbot.deepLinkKey" -let modelCatalogPathKey = "moltbot.modelCatalogPath" -let modelCatalogReloadKey = "moltbot.modelCatalogReload" -let cliInstallPromptedVersionKey = "moltbot.cliInstallPromptedVersion" -let heartbeatsEnabledKey = "moltbot.heartbeatsEnabled" -let debugFileLogEnabledKey = "moltbot.debug.fileLogEnabled" -let appLogLevelKey = "moltbot.debug.appLogLevel" -let voiceWakeSupported: Bool = ProcessInfo.processInfo.operatingSystemVersion.majorVersion >= 26 diff --git a/apps/macos/Sources/Clawdbot/ControlChannel.swift b/apps/macos/Sources/Clawdbot/ControlChannel.swift deleted file mode 100644 index 02f7e7686..000000000 --- a/apps/macos/Sources/Clawdbot/ControlChannel.swift +++ /dev/null @@ -1,427 +0,0 @@ -import MoltbotKit -import MoltbotProtocol -import Foundation -import Observation -import SwiftUI - -struct ControlHeartbeatEvent: Codable { - let ts: Double - let status: String - let to: String? - let preview: String? - let durationMs: Double? - let hasMedia: Bool? - let reason: String? -} - -struct ControlAgentEvent: Codable, Sendable, Identifiable { - var id: String { "\(self.runId)-\(self.seq)" } - let runId: String - let seq: Int - let stream: String - let ts: Double - let data: [String: MoltbotProtocol.AnyCodable] - let summary: String? -} - -enum ControlChannelError: Error, LocalizedError { - case disconnected - case badResponse(String) - - var errorDescription: String? { - switch self { - case .disconnected: "Control channel disconnected" - case let .badResponse(msg): msg - } - } -} - -@MainActor -@Observable -final class ControlChannel { - static let shared = ControlChannel() - - enum Mode { - case local - case remote(target: String, identity: String) - } - - enum ConnectionState: Equatable { - case disconnected - case connecting - case connected - case degraded(String) - } - - private(set) var state: ConnectionState = .disconnected { - didSet { - CanvasManager.shared.refreshDebugStatus() - guard oldValue != self.state else { return } - switch self.state { - case .connected: - self.logger.info("control channel state -> connected") - case .connecting: - self.logger.info("control channel state -> connecting") - case .disconnected: - self.logger.info("control channel state -> disconnected") - self.scheduleRecovery(reason: "disconnected") - case let .degraded(message): - let detail = message.isEmpty ? "degraded" : "degraded: \(message)" - self.logger.info("control channel state -> \(detail, privacy: .public)") - self.scheduleRecovery(reason: message) - } - } - } - - private(set) var lastPingMs: Double? - private(set) var authSourceLabel: String? - - private let logger = Logger(subsystem: "com.clawdbot", category: "control") - - private var eventTask: Task? - private var recoveryTask: Task? - private var lastRecoveryAt: Date? - - private init() { - self.startEventStream() - } - - func configure() async { - self.logger.info("control channel configure mode=local") - await self.refreshEndpoint(reason: "configure") - } - - func configure(mode: Mode = .local) async throws { - switch mode { - case .local: - await self.configure() - case let .remote(target, identity): - do { - _ = (target, identity) - let idSet = !identity.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty - self.logger.info( - "control channel configure mode=remote " + - "target=\(target, privacy: .public) identitySet=\(idSet, privacy: .public)") - self.state = .connecting - _ = try await GatewayEndpointStore.shared.ensureRemoteControlTunnel() - await self.refreshEndpoint(reason: "configure") - } catch { - self.state = .degraded(error.localizedDescription) - throw error - } - } - } - - func refreshEndpoint(reason: String) async { - self.logger.info("control channel refresh endpoint reason=\(reason, privacy: .public)") - self.state = .connecting - do { - try await self.establishGatewayConnection() - self.state = .connected - PresenceReporter.shared.sendImmediate(reason: "connect") - } catch { - let message = self.friendlyGatewayMessage(error) - self.state = .degraded(message) - } - } - - func disconnect() async { - await GatewayConnection.shared.shutdown() - self.state = .disconnected - self.lastPingMs = nil - self.authSourceLabel = nil - } - - func health(timeout: TimeInterval? = nil) async throws -> Data { - do { - let start = Date() - var params: [String: AnyHashable]? - if let timeout { - params = ["timeout": AnyHashable(Int(timeout * 1000))] - } - let timeoutMs = (timeout ?? 15) * 1000 - let payload = try await self.request(method: "health", params: params, timeoutMs: timeoutMs) - let ms = Date().timeIntervalSince(start) * 1000 - self.lastPingMs = ms - self.state = .connected - return payload - } catch { - let message = self.friendlyGatewayMessage(error) - self.state = .degraded(message) - throw ControlChannelError.badResponse(message) - } - } - - func lastHeartbeat() async throws -> ControlHeartbeatEvent? { - let data = try await self.request(method: "last-heartbeat") - return try JSONDecoder().decode(ControlHeartbeatEvent?.self, from: data) - } - - func request( - method: String, - params: [String: AnyHashable]? = nil, - timeoutMs: Double? = nil) async throws -> Data - { - do { - let rawParams = params?.reduce(into: [String: MoltbotKit.AnyCodable]()) { - $0[$1.key] = MoltbotKit.AnyCodable($1.value.base) - } - let data = try await GatewayConnection.shared.request( - method: method, - params: rawParams, - timeoutMs: timeoutMs) - self.state = .connected - return data - } catch { - let message = self.friendlyGatewayMessage(error) - self.state = .degraded(message) - throw ControlChannelError.badResponse(message) - } - } - - private func friendlyGatewayMessage(_ error: Error) -> String { - // Map URLSession/WS errors into user-facing, actionable text. - if let ctrlErr = error as? ControlChannelError, let desc = ctrlErr.errorDescription { - return desc - } - - // If the gateway explicitly rejects the hello (e.g., auth/token mismatch), surface it. - if let urlErr = error as? URLError, - urlErr.code == .dataNotAllowed // used for WS close 1008 auth failures - { - let reason = urlErr.failureURLString ?? urlErr.localizedDescription - let tokenKey = CommandResolver.connectionModeIsRemote() - ? "gateway.remote.token" - : "gateway.auth.token" - return - "Gateway rejected token; set \(tokenKey) (or CLAWDBOT_GATEWAY_TOKEN) " + - "or clear it on the gateway. " + - "Reason: \(reason)" - } - - // Common misfire: we connected to the configured localhost port but it is occupied - // by some other process (e.g. a local dev gateway or a stuck SSH forward). - // The gateway handshake returns something we can't parse, which currently - // surfaces as "hello failed (unexpected response)". Give the user a pointer - // to free the port instead of a vague message. - let nsError = error as NSError - if nsError.domain == "Gateway", - nsError.localizedDescription.contains("hello failed (unexpected response)") - { - let port = GatewayEnvironment.gatewayPort() - return """ - Gateway handshake got non-gateway data on localhost:\(port). - Another process is using that port or the SSH forward failed. - Stop the local gateway/port-forward on \(port) and retry Remote mode. - """ - } - - if let urlError = error as? URLError { - let port = GatewayEnvironment.gatewayPort() - switch urlError.code { - case .cancelled: - return "Gateway connection was closed; start the gateway (localhost:\(port)) and retry." - case .cannotFindHost, .cannotConnectToHost: - let isRemote = CommandResolver.connectionModeIsRemote() - if isRemote { - return """ - Cannot reach gateway at localhost:\(port). - Remote mode uses an SSH tunnel—check the SSH target and that the tunnel is running. - """ - } - return "Cannot reach gateway at localhost:\(port); ensure the gateway is running." - case .networkConnectionLost: - return "Gateway connection dropped; gateway likely restarted—retry." - case .timedOut: - return "Gateway request timed out; check gateway on localhost:\(port)." - case .notConnectedToInternet: - return "No network connectivity; cannot reach gateway." - default: - break - } - } - - if nsError.domain == "Gateway", nsError.code == 5 { - let port = GatewayEnvironment.gatewayPort() - return "Gateway request timed out; check the gateway process on localhost:\(port)." - } - - let detail = nsError.localizedDescription.isEmpty ? "unknown gateway error" : nsError.localizedDescription - let trimmed = detail.trimmingCharacters(in: .whitespacesAndNewlines) - if trimmed.lowercased().hasPrefix("gateway error:") { return trimmed } - return "Gateway error: \(trimmed)" - } - - private func scheduleRecovery(reason: String) { - let now = Date() - if let last = self.lastRecoveryAt, now.timeIntervalSince(last) < 10 { return } - guard self.recoveryTask == nil else { return } - self.lastRecoveryAt = now - - self.recoveryTask = Task { [weak self] in - guard let self else { return } - let mode = await MainActor.run { AppStateStore.shared.connectionMode } - guard mode != .unconfigured else { - self.recoveryTask = nil - return - } - - let trimmedReason = reason.trimmingCharacters(in: .whitespacesAndNewlines) - let reasonText = trimmedReason.isEmpty ? "unknown" : trimmedReason - self.logger.info( - "control channel recovery starting " + - "mode=\(String(describing: mode), privacy: .public) " + - "reason=\(reasonText, privacy: .public)") - if mode == .local { - GatewayProcessManager.shared.setActive(true) - } - if mode == .remote { - do { - let port = try await GatewayEndpointStore.shared.ensureRemoteControlTunnel() - self.logger.info("control channel recovery ensured SSH tunnel port=\(port, privacy: .public)") - } catch { - self.logger.error( - "control channel recovery tunnel failed \(error.localizedDescription, privacy: .public)") - } - } - - await self.refreshEndpoint(reason: "recovery:\(reasonText)") - if case .connected = self.state { - self.logger.info("control channel recovery finished") - } else if case let .degraded(message) = self.state { - self.logger.error("control channel recovery failed \(message, privacy: .public)") - } - - self.recoveryTask = nil - } - } - - private func establishGatewayConnection(timeoutMs: Int = 5000) async throws { - try await GatewayConnection.shared.refresh() - let ok = try await GatewayConnection.shared.healthOK(timeoutMs: timeoutMs) - if ok == false { - throw NSError( - domain: "Gateway", - code: 0, - userInfo: [NSLocalizedDescriptionKey: "gateway health not ok"]) - } - await self.refreshAuthSourceLabel() - } - - private func refreshAuthSourceLabel() async { - let isRemote = CommandResolver.connectionModeIsRemote() - let authSource = await GatewayConnection.shared.authSource() - self.authSourceLabel = Self.formatAuthSource(authSource, isRemote: isRemote) - } - - private static func formatAuthSource(_ source: GatewayAuthSource?, isRemote: Bool) -> String? { - guard let source else { return nil } - switch source { - case .deviceToken: - return "Auth: device token (paired device)" - case .sharedToken: - return "Auth: shared token (\(isRemote ? "gateway.remote.token" : "gateway.auth.token"))" - case .password: - return "Auth: password (\(isRemote ? "gateway.remote.password" : "gateway.auth.password"))" - case .none: - return "Auth: none" - } - } - - func sendSystemEvent(_ text: String, params: [String: AnyHashable] = [:]) async throws { - var merged = params - merged["text"] = AnyHashable(text) - _ = try await self.request(method: "system-event", params: merged) - } - - private func startEventStream() { - self.eventTask?.cancel() - self.eventTask = Task { [weak self] in - guard let self else { return } - let stream = await GatewayConnection.shared.subscribe() - for await push in stream { - if Task.isCancelled { return } - await MainActor.run { [weak self] in - self?.handle(push: push) - } - } - } - } - - private func handle(push: GatewayPush) { - switch push { - case let .event(evt) where evt.event == "agent": - if let payload = evt.payload, - let agent = try? GatewayPayloadDecoding.decode(payload, as: ControlAgentEvent.self) - { - AgentEventStore.shared.append(agent) - self.routeWorkActivity(from: agent) - } - case let .event(evt) where evt.event == "heartbeat": - if let payload = evt.payload, - let heartbeat = try? GatewayPayloadDecoding.decode(payload, as: ControlHeartbeatEvent.self), - let data = try? JSONEncoder().encode(heartbeat) - { - NotificationCenter.default.post(name: .controlHeartbeat, object: data) - } - case let .event(evt) where evt.event == "shutdown": - self.state = .degraded("gateway shutdown") - case .snapshot: - self.state = .connected - default: - break - } - } - - private func routeWorkActivity(from event: ControlAgentEvent) { - // We currently treat VoiceWake as the "main" session for UI purposes. - // In the future, the gateway can include a sessionKey to distinguish runs. - let sessionKey = (event.data["sessionKey"]?.value as? String) ?? "main" - - switch event.stream.lowercased() { - case "job": - if let state = event.data["state"]?.value as? String { - WorkActivityStore.shared.handleJob(sessionKey: sessionKey, state: state) - } - case "tool": - let phase = event.data["phase"]?.value as? String ?? "" - let name = event.data["name"]?.value as? String - let meta = event.data["meta"]?.value as? String - let args = Self.bridgeToProtocolArgs(event.data["args"]) - WorkActivityStore.shared.handleTool( - sessionKey: sessionKey, - phase: phase, - name: name, - meta: meta, - args: args) - default: - break - } - } - - private static func bridgeToProtocolArgs( - _ value: MoltbotProtocol.AnyCodable?) -> [String: MoltbotProtocol.AnyCodable]? - { - guard let value else { return nil } - if let dict = value.value as? [String: MoltbotProtocol.AnyCodable] { - return dict - } - if let dict = value.value as? [String: MoltbotKit.AnyCodable], - let data = try? JSONEncoder().encode(dict), - let decoded = try? JSONDecoder().decode([String: MoltbotProtocol.AnyCodable].self, from: data) - { - return decoded - } - if let data = try? JSONEncoder().encode(value), - let decoded = try? JSONDecoder().decode([String: MoltbotProtocol.AnyCodable].self, from: data) - { - return decoded - } - return nil - } -} - -extension Notification.Name { - static let controlHeartbeat = Notification.Name("moltbot.control.heartbeat") - static let controlAgentEvent = Notification.Name("moltbot.control.agent") -} diff --git a/apps/macos/Sources/Clawdbot/CronJobsStore.swift b/apps/macos/Sources/Clawdbot/CronJobsStore.swift deleted file mode 100644 index 36a8b95a3..000000000 --- a/apps/macos/Sources/Clawdbot/CronJobsStore.swift +++ /dev/null @@ -1,200 +0,0 @@ -import MoltbotKit -import MoltbotProtocol -import Foundation -import Observation -import OSLog - -@MainActor -@Observable -final class CronJobsStore { - static let shared = CronJobsStore() - - var jobs: [CronJob] = [] - var selectedJobId: String? - var runEntries: [CronRunLogEntry] = [] - - var schedulerEnabled: Bool? - var schedulerStorePath: String? - var schedulerNextWakeAtMs: Int? - - var isLoadingJobs = false - var isLoadingRuns = false - var lastError: String? - var statusMessage: String? - - private let logger = Logger(subsystem: "com.clawdbot", category: "cron.ui") - private var refreshTask: Task? - private var runsTask: Task? - private var eventTask: Task? - private var pollTask: Task? - - private let interval: TimeInterval = 30 - private let isPreview: Bool - - init(isPreview: Bool = ProcessInfo.processInfo.isPreview) { - self.isPreview = isPreview - } - - func start() { - guard !self.isPreview else { return } - guard self.eventTask == nil else { return } - self.startGatewaySubscription() - self.pollTask = Task.detached { [weak self] in - guard let self else { return } - await self.refreshJobs() - while !Task.isCancelled { - try? await Task.sleep(nanoseconds: UInt64(self.interval * 1_000_000_000)) - await self.refreshJobs() - } - } - } - - func stop() { - self.refreshTask?.cancel() - self.refreshTask = nil - self.runsTask?.cancel() - self.runsTask = nil - self.eventTask?.cancel() - self.eventTask = nil - self.pollTask?.cancel() - self.pollTask = nil - } - - func refreshJobs() async { - guard !self.isLoadingJobs else { return } - self.isLoadingJobs = true - self.lastError = nil - self.statusMessage = nil - defer { self.isLoadingJobs = false } - - do { - if let status = try? await GatewayConnection.shared.cronStatus() { - self.schedulerEnabled = status.enabled - self.schedulerStorePath = status.storePath - self.schedulerNextWakeAtMs = status.nextWakeAtMs - } - self.jobs = try await GatewayConnection.shared.cronList(includeDisabled: true) - if self.jobs.isEmpty { - self.statusMessage = "No cron jobs yet." - } - } catch { - self.logger.error("cron.list failed \(error.localizedDescription, privacy: .public)") - self.lastError = error.localizedDescription - } - } - - func refreshRuns(jobId: String, limit: Int = 200) async { - guard !self.isLoadingRuns else { return } - self.isLoadingRuns = true - defer { self.isLoadingRuns = false } - - do { - self.runEntries = try await GatewayConnection.shared.cronRuns(jobId: jobId, limit: limit) - } catch { - self.logger.error("cron.runs failed \(error.localizedDescription, privacy: .public)") - self.lastError = error.localizedDescription - } - } - - func runJob(id: String, force: Bool = true) async { - do { - try await GatewayConnection.shared.cronRun(jobId: id, force: force) - } catch { - self.lastError = error.localizedDescription - } - } - - func removeJob(id: String) async { - do { - try await GatewayConnection.shared.cronRemove(jobId: id) - await self.refreshJobs() - if self.selectedJobId == id { - self.selectedJobId = nil - self.runEntries = [] - } - } catch { - self.lastError = error.localizedDescription - } - } - - func setJobEnabled(id: String, enabled: Bool) async { - do { - try await GatewayConnection.shared.cronUpdate( - jobId: id, - patch: ["enabled": AnyCodable(enabled)]) - await self.refreshJobs() - } catch { - self.lastError = error.localizedDescription - } - } - - func upsertJob( - id: String?, - payload: [String: AnyCodable]) async throws - { - if let id { - try await GatewayConnection.shared.cronUpdate(jobId: id, patch: payload) - } else { - try await GatewayConnection.shared.cronAdd(payload: payload) - } - await self.refreshJobs() - } - - // MARK: - Gateway events - - private func startGatewaySubscription() { - self.eventTask?.cancel() - self.eventTask = Task { [weak self] in - guard let self else { return } - let stream = await GatewayConnection.shared.subscribe() - for await push in stream { - if Task.isCancelled { return } - await MainActor.run { [weak self] in - self?.handle(push: push) - } - } - } - } - - private func handle(push: GatewayPush) { - switch push { - case let .event(evt) where evt.event == "cron": - guard let payload = evt.payload else { return } - if let cronEvt = try? GatewayPayloadDecoding.decode(payload, as: CronEvent.self) { - self.handle(cronEvent: cronEvt) - } - case .seqGap: - self.scheduleRefresh() - default: - break - } - } - - private func handle(cronEvent evt: CronEvent) { - // Keep UI in sync with the gateway scheduler. - self.scheduleRefresh(delayMs: 250) - if evt.action == "finished", let selected = self.selectedJobId, selected == evt.jobId { - self.scheduleRunsRefresh(jobId: selected, delayMs: 200) - } - } - - private func scheduleRefresh(delayMs: Int = 250) { - self.refreshTask?.cancel() - self.refreshTask = Task { [weak self] in - guard let self else { return } - try? await Task.sleep(nanoseconds: UInt64(delayMs) * 1_000_000) - await self.refreshJobs() - } - } - - private func scheduleRunsRefresh(jobId: String, delayMs: Int = 200) { - self.runsTask?.cancel() - self.runsTask = Task { [weak self] in - guard let self else { return } - try? await Task.sleep(nanoseconds: UInt64(delayMs) * 1_000_000) - await self.refreshRuns(jobId: jobId) - } - } - - // MARK: - (no additional RPC helpers) -} diff --git a/apps/macos/Sources/Clawdbot/DeepLinks.swift b/apps/macos/Sources/Clawdbot/DeepLinks.swift deleted file mode 100644 index 4308cf47f..000000000 --- a/apps/macos/Sources/Clawdbot/DeepLinks.swift +++ /dev/null @@ -1,151 +0,0 @@ -import AppKit -import MoltbotKit -import Foundation -import OSLog -import Security - -private let deepLinkLogger = Logger(subsystem: "com.clawdbot", category: "DeepLink") - -@MainActor -final class DeepLinkHandler { - static let shared = DeepLinkHandler() - - private var lastPromptAt: Date = .distantPast - - // Ephemeral, in-memory key used for unattended deep links originating from the in-app Canvas. - // This avoids blocking Canvas init on UserDefaults and doesn't weaken the external deep-link prompt: - // outside callers can't know this randomly generated key. - private nonisolated static let canvasUnattendedKey: String = DeepLinkHandler.generateRandomKey() - - func handle(url: URL) async { - guard let route = DeepLinkParser.parse(url) else { - deepLinkLogger.debug("ignored url \(url.absoluteString, privacy: .public)") - return - } - guard !AppStateStore.shared.isPaused else { - self.presentAlert(title: "Moltbot is paused", message: "Unpause Moltbot to run agent actions.") - return - } - - switch route { - case let .agent(link): - await self.handleAgent(link: link, originalURL: url) - } - } - - private func handleAgent(link: AgentDeepLink, originalURL: URL) async { - let messagePreview = link.message.trimmingCharacters(in: .whitespacesAndNewlines) - if messagePreview.count > 20000 { - self.presentAlert(title: "Deep link too large", message: "Message exceeds 20,000 characters.") - return - } - - let allowUnattended = link.key == Self.canvasUnattendedKey || link.key == Self.expectedKey() - if !allowUnattended { - if Date().timeIntervalSince(self.lastPromptAt) < 1.0 { - deepLinkLogger.debug("throttling deep link prompt") - return - } - self.lastPromptAt = Date() - - let trimmed = messagePreview.count > 240 ? "\(messagePreview.prefix(240))…" : messagePreview - let body = - "Run the agent with this message?\n\n\(trimmed)\n\nURL:\n\(originalURL.absoluteString)" - guard self.confirm(title: "Run Moltbot agent?", message: body) else { return } - } - - if AppStateStore.shared.connectionMode == .local { - GatewayProcessManager.shared.setActive(true) - } - - do { - let channel = GatewayAgentChannel(raw: link.channel) - let explicitSessionKey = link.sessionKey? - .trimmingCharacters(in: .whitespacesAndNewlines) - .nonEmpty - let resolvedSessionKey: String = if let explicitSessionKey { - explicitSessionKey - } else { - await GatewayConnection.shared.mainSessionKey() - } - let invocation = GatewayAgentInvocation( - message: messagePreview, - sessionKey: resolvedSessionKey, - thinking: link.thinking?.trimmingCharacters(in: .whitespacesAndNewlines).nonEmpty, - deliver: channel.shouldDeliver(link.deliver), - to: link.to?.trimmingCharacters(in: .whitespacesAndNewlines).nonEmpty, - channel: channel, - timeoutSeconds: link.timeoutSeconds, - idempotencyKey: UUID().uuidString) - - let res = await GatewayConnection.shared.sendAgent(invocation) - if !res.ok { - throw NSError( - domain: "DeepLink", - code: 1, - userInfo: [NSLocalizedDescriptionKey: res.error ?? "agent request failed"]) - } - } catch { - self.presentAlert(title: "Agent request failed", message: error.localizedDescription) - } - } - - // MARK: - Auth - - static func currentKey() -> String { - self.expectedKey() - } - - static func currentCanvasKey() -> String { - self.canvasUnattendedKey - } - - private static func expectedKey() -> String { - let defaults = UserDefaults.standard - if let key = defaults.string(forKey: deepLinkKeyKey), !key.isEmpty { - return key - } - var bytes = [UInt8](repeating: 0, count: 32) - _ = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes) - let data = Data(bytes) - let key = data - .base64EncodedString() - .replacingOccurrences(of: "+", with: "-") - .replacingOccurrences(of: "/", with: "_") - .replacingOccurrences(of: "=", with: "") - defaults.set(key, forKey: deepLinkKeyKey) - return key - } - - private nonisolated static func generateRandomKey() -> String { - var bytes = [UInt8](repeating: 0, count: 32) - _ = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes) - let data = Data(bytes) - return data - .base64EncodedString() - .replacingOccurrences(of: "+", with: "-") - .replacingOccurrences(of: "/", with: "_") - .replacingOccurrences(of: "=", with: "") - } - - // MARK: - UI - - private func confirm(title: String, message: String) -> Bool { - let alert = NSAlert() - alert.messageText = title - alert.informativeText = message - alert.addButton(withTitle: "Run") - alert.addButton(withTitle: "Cancel") - alert.alertStyle = .warning - return alert.runModal() == .alertFirstButtonReturn - } - - private func presentAlert(title: String, message: String) { - let alert = NSAlert() - alert.messageText = title - alert.informativeText = message - alert.addButton(withTitle: "OK") - alert.alertStyle = .informational - alert.runModal() - } -} diff --git a/apps/macos/Sources/Clawdbot/DevicePairingApprovalPrompter.swift b/apps/macos/Sources/Clawdbot/DevicePairingApprovalPrompter.swift deleted file mode 100644 index b282a394b..000000000 --- a/apps/macos/Sources/Clawdbot/DevicePairingApprovalPrompter.swift +++ /dev/null @@ -1,334 +0,0 @@ -import AppKit -import MoltbotKit -import MoltbotProtocol -import Foundation -import Observation -import OSLog - -@MainActor -@Observable -final class DevicePairingApprovalPrompter { - static let shared = DevicePairingApprovalPrompter() - - private let logger = Logger(subsystem: "com.clawdbot", category: "device-pairing") - private var task: Task? - private var isStopping = false - private var isPresenting = false - private var queue: [PendingRequest] = [] - var pendingCount: Int = 0 - var pendingRepairCount: Int = 0 - private var activeAlert: NSAlert? - private var activeRequestId: String? - private var alertHostWindow: NSWindow? - private var resolvedByRequestId: Set = [] - - private final class AlertHostWindow: NSWindow { - override var canBecomeKey: Bool { true } - override var canBecomeMain: Bool { true } - } - - private struct PairingList: Codable { - let pending: [PendingRequest] - let paired: [PairedDevice]? - } - - private struct PairedDevice: Codable, Equatable { - let deviceId: String - let approvedAtMs: Double? - let displayName: String? - let platform: String? - let remoteIp: String? - } - - private struct PendingRequest: Codable, Equatable, Identifiable { - let requestId: String - let deviceId: String - let publicKey: String - let displayName: String? - let platform: String? - let clientId: String? - let clientMode: String? - let role: String? - let scopes: [String]? - let remoteIp: String? - let silent: Bool? - let isRepair: Bool? - let ts: Double - - var id: String { self.requestId } - } - - private struct PairingResolvedEvent: Codable { - let requestId: String - let deviceId: String - let decision: String - let ts: Double - } - - private enum PairingResolution: String { - case approved - case rejected - } - - func start() { - guard self.task == nil else { return } - self.isStopping = false - self.task = Task { [weak self] in - guard let self else { return } - _ = try? await GatewayConnection.shared.refresh() - await self.loadPendingRequestsFromGateway() - let stream = await GatewayConnection.shared.subscribe(bufferingNewest: 200) - for await push in stream { - if Task.isCancelled { return } - await MainActor.run { [weak self] in self?.handle(push: push) } - } - } - } - - func stop() { - self.isStopping = true - self.endActiveAlert() - self.task?.cancel() - self.task = nil - self.queue.removeAll(keepingCapacity: false) - self.updatePendingCounts() - self.isPresenting = false - self.activeRequestId = nil - self.alertHostWindow?.orderOut(nil) - self.alertHostWindow?.close() - self.alertHostWindow = nil - self.resolvedByRequestId.removeAll(keepingCapacity: false) - } - - private func loadPendingRequestsFromGateway() async { - do { - let list: PairingList = try await GatewayConnection.shared.requestDecoded(method: .devicePairList) - await self.apply(list: list) - } catch { - self.logger.error("failed to load device pairing requests: \(error.localizedDescription, privacy: .public)") - } - } - - private func apply(list: PairingList) async { - self.queue = list.pending.sorted(by: { $0.ts > $1.ts }) - self.updatePendingCounts() - self.presentNextIfNeeded() - } - - private func updatePendingCounts() { - self.pendingCount = self.queue.count - self.pendingRepairCount = self.queue.count(where: { $0.isRepair == true }) - } - - private func presentNextIfNeeded() { - guard !self.isStopping else { return } - guard !self.isPresenting else { return } - guard let next = self.queue.first else { return } - self.isPresenting = true - self.presentAlert(for: next) - } - - private func presentAlert(for req: PendingRequest) { - self.logger.info("presenting device pairing alert requestId=\(req.requestId, privacy: .public)") - NSApp.activate(ignoringOtherApps: true) - - let alert = NSAlert() - alert.alertStyle = .warning - alert.messageText = "Allow device to connect?" - alert.informativeText = Self.describe(req) - alert.addButton(withTitle: "Later") - alert.addButton(withTitle: "Approve") - alert.addButton(withTitle: "Reject") - if #available(macOS 11.0, *), alert.buttons.indices.contains(2) { - alert.buttons[2].hasDestructiveAction = true - } - - self.activeAlert = alert - self.activeRequestId = req.requestId - let hostWindow = self.requireAlertHostWindow() - - let sheetSize = alert.window.frame.size - if let screen = hostWindow.screen ?? NSScreen.main { - let bounds = screen.visibleFrame - let x = bounds.midX - (sheetSize.width / 2) - let sheetOriginY = bounds.midY - (sheetSize.height / 2) - let hostY = sheetOriginY + sheetSize.height - hostWindow.frame.height - hostWindow.setFrameOrigin(NSPoint(x: x, y: hostY)) - } else { - hostWindow.center() - } - - hostWindow.makeKeyAndOrderFront(nil) - alert.beginSheetModal(for: hostWindow) { [weak self] response in - Task { @MainActor [weak self] in - guard let self else { return } - self.activeRequestId = nil - self.activeAlert = nil - await self.handleAlertResponse(response, request: req) - hostWindow.orderOut(nil) - } - } - } - - private func handleAlertResponse(_ response: NSApplication.ModalResponse, request: PendingRequest) async { - var shouldRemove = response != .alertFirstButtonReturn - defer { - if shouldRemove { - if self.queue.first == request { - self.queue.removeFirst() - } else { - self.queue.removeAll { $0 == request } - } - } - self.updatePendingCounts() - self.isPresenting = false - self.presentNextIfNeeded() - } - - guard !self.isStopping else { return } - - if self.resolvedByRequestId.remove(request.requestId) != nil { - return - } - - switch response { - case .alertFirstButtonReturn: - shouldRemove = false - if let idx = self.queue.firstIndex(of: request) { - self.queue.remove(at: idx) - } - self.queue.append(request) - return - case .alertSecondButtonReturn: - _ = await self.approve(requestId: request.requestId) - case .alertThirdButtonReturn: - await self.reject(requestId: request.requestId) - default: - return - } - } - - private func approve(requestId: String) async -> Bool { - do { - try await GatewayConnection.shared.devicePairApprove(requestId: requestId) - self.logger.info("approved device pairing requestId=\(requestId, privacy: .public)") - return true - } catch { - self.logger.error("approve failed requestId=\(requestId, privacy: .public)") - self.logger.error("approve failed: \(error.localizedDescription, privacy: .public)") - return false - } - } - - private func reject(requestId: String) async { - do { - try await GatewayConnection.shared.devicePairReject(requestId: requestId) - self.logger.info("rejected device pairing requestId=\(requestId, privacy: .public)") - } catch { - self.logger.error("reject failed requestId=\(requestId, privacy: .public)") - self.logger.error("reject failed: \(error.localizedDescription, privacy: .public)") - } - } - - private func endActiveAlert() { - guard let alert = self.activeAlert else { return } - if let parent = alert.window.sheetParent { - parent.endSheet(alert.window, returnCode: .abort) - } - self.activeAlert = nil - self.activeRequestId = nil - } - - private func requireAlertHostWindow() -> NSWindow { - if let alertHostWindow { - return alertHostWindow - } - - let window = AlertHostWindow( - contentRect: NSRect(x: 0, y: 0, width: 520, height: 1), - styleMask: [.borderless], - backing: .buffered, - defer: false) - window.title = "" - window.isReleasedWhenClosed = false - window.level = .floating - window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary] - window.isOpaque = false - window.hasShadow = false - window.backgroundColor = .clear - window.ignoresMouseEvents = true - - self.alertHostWindow = window - return window - } - - private func handle(push: GatewayPush) { - switch push { - case let .event(evt) where evt.event == "device.pair.requested": - guard let payload = evt.payload else { return } - do { - let req = try GatewayPayloadDecoding.decode(payload, as: PendingRequest.self) - self.enqueue(req) - } catch { - self.logger - .error("failed to decode device pairing request: \(error.localizedDescription, privacy: .public)") - } - case let .event(evt) where evt.event == "device.pair.resolved": - guard let payload = evt.payload else { return } - do { - let resolved = try GatewayPayloadDecoding.decode(payload, as: PairingResolvedEvent.self) - self.handleResolved(resolved) - } catch { - self.logger - .error( - "failed to decode device pairing resolution: \(error.localizedDescription, privacy: .public)") - } - default: - break - } - } - - private func enqueue(_ req: PendingRequest) { - guard !self.queue.contains(req) else { return } - self.queue.append(req) - self.updatePendingCounts() - self.presentNextIfNeeded() - } - - private func handleResolved(_ resolved: PairingResolvedEvent) { - let resolution = resolved.decision == PairingResolution.approved.rawValue ? PairingResolution - .approved : .rejected - if let activeRequestId, activeRequestId == resolved.requestId { - self.resolvedByRequestId.insert(resolved.requestId) - self.endActiveAlert() - let decision = resolution.rawValue - self.logger.info( - "device pairing resolved while active requestId=\(resolved.requestId, privacy: .public) " + - "decision=\(decision, privacy: .public)") - return - } - self.queue.removeAll { $0.requestId == resolved.requestId } - self.updatePendingCounts() - } - - private static func describe(_ req: PendingRequest) -> String { - var lines: [String] = [] - lines.append("Device: \(req.displayName ?? req.deviceId)") - if let platform = req.platform { - lines.append("Platform: \(platform)") - } - if let role = req.role { - lines.append("Role: \(role)") - } - if let scopes = req.scopes, !scopes.isEmpty { - lines.append("Scopes: \(scopes.joined(separator: ", "))") - } - if let remoteIp = req.remoteIp { - lines.append("IP: \(remoteIp)") - } - if req.isRepair == true { - lines.append("Repair: yes") - } - return lines.joined(separator: "\n") - } -} diff --git a/apps/macos/Sources/Clawdbot/DockIconManager.swift b/apps/macos/Sources/Clawdbot/DockIconManager.swift deleted file mode 100644 index 59eacee29..000000000 --- a/apps/macos/Sources/Clawdbot/DockIconManager.swift +++ /dev/null @@ -1,116 +0,0 @@ -import AppKit - -/// Central manager for Dock icon visibility. -/// Shows the Dock icon while any windows are visible, regardless of user preference. -final class DockIconManager: NSObject, @unchecked Sendable { - static let shared = DockIconManager() - - private var windowsObservation: NSKeyValueObservation? - private let logger = Logger(subsystem: "com.clawdbot", category: "DockIconManager") - - override private init() { - super.init() - self.setupObservers() - Task { @MainActor in - self.updateDockVisibility() - } - } - - deinit { - self.windowsObservation?.invalidate() - NotificationCenter.default.removeObserver(self) - } - - func updateDockVisibility() { - Task { @MainActor in - guard NSApp != nil else { - self.logger.warning("NSApp not ready, skipping Dock visibility update") - return - } - - let userWantsDockHidden = !UserDefaults.standard.bool(forKey: showDockIconKey) - let visibleWindows = NSApp?.windows.filter { window in - window.isVisible && - window.frame.width > 1 && - window.frame.height > 1 && - !window.isKind(of: NSPanel.self) && - "\(type(of: window))" != "NSPopupMenuWindow" && - window.contentViewController != nil - } ?? [] - - let hasVisibleWindows = !visibleWindows.isEmpty - if !userWantsDockHidden || hasVisibleWindows { - NSApp?.setActivationPolicy(.regular) - } else { - NSApp?.setActivationPolicy(.accessory) - } - } - } - - func temporarilyShowDock() { - Task { @MainActor in - guard NSApp != nil else { - self.logger.warning("NSApp not ready, cannot show Dock icon") - return - } - NSApp.setActivationPolicy(.regular) - } - } - - private func setupObservers() { - Task { @MainActor in - guard let app = NSApp else { - self.logger.warning("NSApp not ready, delaying Dock observers") - try? await Task.sleep(for: .milliseconds(200)) - self.setupObservers() - return - } - - self.windowsObservation = app.observe(\.windows, options: [.new]) { [weak self] _, _ in - Task { @MainActor in - try? await Task.sleep(for: .milliseconds(50)) - self?.updateDockVisibility() - } - } - - NotificationCenter.default.addObserver( - self, - selector: #selector(self.windowVisibilityChanged), - name: NSWindow.didBecomeKeyNotification, - object: nil) - NotificationCenter.default.addObserver( - self, - selector: #selector(self.windowVisibilityChanged), - name: NSWindow.didResignKeyNotification, - object: nil) - NotificationCenter.default.addObserver( - self, - selector: #selector(self.windowVisibilityChanged), - name: NSWindow.willCloseNotification, - object: nil) - NotificationCenter.default.addObserver( - self, - selector: #selector(self.dockPreferenceChanged), - name: UserDefaults.didChangeNotification, - object: nil) - } - } - - @objc - private func windowVisibilityChanged(_: Notification) { - Task { @MainActor in - self.updateDockVisibility() - } - } - - @objc - private func dockPreferenceChanged(_ notification: Notification) { - guard let userDefaults = notification.object as? UserDefaults, - userDefaults == UserDefaults.standard - else { return } - - Task { @MainActor in - self.updateDockVisibility() - } - } -} diff --git a/apps/macos/Sources/Clawdbot/ExecApprovals.swift b/apps/macos/Sources/Clawdbot/ExecApprovals.swift deleted file mode 100644 index c79c96e84..000000000 --- a/apps/macos/Sources/Clawdbot/ExecApprovals.swift +++ /dev/null @@ -1,790 +0,0 @@ -import CryptoKit -import Foundation -import OSLog -import Security - -enum ExecSecurity: String, CaseIterable, Codable, Identifiable { - case deny - case allowlist - case full - - var id: String { self.rawValue } - - var title: String { - switch self { - case .deny: "Deny" - case .allowlist: "Allowlist" - case .full: "Always Allow" - } - } -} - -enum ExecApprovalQuickMode: String, CaseIterable, Identifiable { - case deny - case ask - case allow - - var id: String { self.rawValue } - - var title: String { - switch self { - case .deny: "Deny" - case .ask: "Always Ask" - case .allow: "Always Allow" - } - } - - var security: ExecSecurity { - switch self { - case .deny: .deny - case .ask: .allowlist - case .allow: .full - } - } - - var ask: ExecAsk { - switch self { - case .deny: .off - case .ask: .onMiss - case .allow: .off - } - } - - static func from(security: ExecSecurity, ask: ExecAsk) -> ExecApprovalQuickMode { - switch security { - case .deny: - .deny - case .full: - .allow - case .allowlist: - .ask - } - } -} - -enum ExecAsk: String, CaseIterable, Codable, Identifiable { - case off - case onMiss = "on-miss" - case always - - var id: String { self.rawValue } - - var title: String { - switch self { - case .off: "Never Ask" - case .onMiss: "Ask on Allowlist Miss" - case .always: "Always Ask" - } - } -} - -enum ExecApprovalDecision: String, Codable, Sendable { - case allowOnce = "allow-once" - case allowAlways = "allow-always" - case deny -} - -struct ExecAllowlistEntry: Codable, Hashable, Identifiable { - var id: UUID - var pattern: String - var lastUsedAt: Double? - var lastUsedCommand: String? - var lastResolvedPath: String? - - init( - id: UUID = UUID(), - pattern: String, - lastUsedAt: Double? = nil, - lastUsedCommand: String? = nil, - lastResolvedPath: String? = nil) - { - self.id = id - self.pattern = pattern - self.lastUsedAt = lastUsedAt - self.lastUsedCommand = lastUsedCommand - self.lastResolvedPath = lastResolvedPath - } - - private enum CodingKeys: String, CodingKey { - case id - case pattern - case lastUsedAt - case lastUsedCommand - case lastResolvedPath - } - - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: CodingKeys.self) - self.id = try container.decodeIfPresent(UUID.self, forKey: .id) ?? UUID() - self.pattern = try container.decode(String.self, forKey: .pattern) - self.lastUsedAt = try container.decodeIfPresent(Double.self, forKey: .lastUsedAt) - self.lastUsedCommand = try container.decodeIfPresent(String.self, forKey: .lastUsedCommand) - self.lastResolvedPath = try container.decodeIfPresent(String.self, forKey: .lastResolvedPath) - } - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(self.id, forKey: .id) - try container.encode(self.pattern, forKey: .pattern) - try container.encodeIfPresent(self.lastUsedAt, forKey: .lastUsedAt) - try container.encodeIfPresent(self.lastUsedCommand, forKey: .lastUsedCommand) - try container.encodeIfPresent(self.lastResolvedPath, forKey: .lastResolvedPath) - } -} - -struct ExecApprovalsDefaults: Codable { - var security: ExecSecurity? - var ask: ExecAsk? - var askFallback: ExecSecurity? - var autoAllowSkills: Bool? -} - -struct ExecApprovalsAgent: Codable { - var security: ExecSecurity? - var ask: ExecAsk? - var askFallback: ExecSecurity? - var autoAllowSkills: Bool? - var allowlist: [ExecAllowlistEntry]? - - var isEmpty: Bool { - self.security == nil && self.ask == nil && self.askFallback == nil && self - .autoAllowSkills == nil && (self.allowlist?.isEmpty ?? true) - } -} - -struct ExecApprovalsSocketConfig: Codable { - var path: String? - var token: String? -} - -struct ExecApprovalsFile: Codable { - var version: Int - var socket: ExecApprovalsSocketConfig? - var defaults: ExecApprovalsDefaults? - var agents: [String: ExecApprovalsAgent]? -} - -struct ExecApprovalsSnapshot: Codable { - var path: String - var exists: Bool - var hash: String - var file: ExecApprovalsFile -} - -struct ExecApprovalsResolved { - let url: URL - let socketPath: String - let token: String - let defaults: ExecApprovalsResolvedDefaults - let agent: ExecApprovalsResolvedDefaults - let allowlist: [ExecAllowlistEntry] - var file: ExecApprovalsFile -} - -struct ExecApprovalsResolvedDefaults { - var security: ExecSecurity - var ask: ExecAsk - var askFallback: ExecSecurity - var autoAllowSkills: Bool -} - -enum ExecApprovalsStore { - private static let logger = Logger(subsystem: "com.clawdbot", category: "exec-approvals") - private static let defaultAgentId = "main" - private static let defaultSecurity: ExecSecurity = .deny - private static let defaultAsk: ExecAsk = .onMiss - private static let defaultAskFallback: ExecSecurity = .deny - private static let defaultAutoAllowSkills = false - - static func fileURL() -> URL { - MoltbotPaths.stateDirURL.appendingPathComponent("exec-approvals.json") - } - - static func socketPath() -> String { - MoltbotPaths.stateDirURL.appendingPathComponent("exec-approvals.sock").path - } - - static func normalizeIncoming(_ file: ExecApprovalsFile) -> ExecApprovalsFile { - let socketPath = file.socket?.path?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - let token = file.socket?.token?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - var agents = file.agents ?? [:] - if let legacyDefault = agents["default"] { - if let main = agents[self.defaultAgentId] { - agents[self.defaultAgentId] = self.mergeAgents(current: main, legacy: legacyDefault) - } else { - agents[self.defaultAgentId] = legacyDefault - } - agents.removeValue(forKey: "default") - } - return ExecApprovalsFile( - version: 1, - socket: ExecApprovalsSocketConfig( - path: socketPath.isEmpty ? nil : socketPath, - token: token.isEmpty ? nil : token), - defaults: file.defaults, - agents: agents) - } - - static func readSnapshot() -> ExecApprovalsSnapshot { - let url = self.fileURL() - guard FileManager().fileExists(atPath: url.path) else { - return ExecApprovalsSnapshot( - path: url.path, - exists: false, - hash: self.hashRaw(nil), - file: ExecApprovalsFile(version: 1, socket: nil, defaults: nil, agents: [:])) - } - let raw = try? String(contentsOf: url, encoding: .utf8) - let data = raw.flatMap { $0.data(using: .utf8) } - let decoded: ExecApprovalsFile = { - if let data, let file = try? JSONDecoder().decode(ExecApprovalsFile.self, from: data), file.version == 1 { - return file - } - return ExecApprovalsFile(version: 1, socket: nil, defaults: nil, agents: [:]) - }() - return ExecApprovalsSnapshot( - path: url.path, - exists: true, - hash: self.hashRaw(raw), - file: decoded) - } - - static func redactForSnapshot(_ file: ExecApprovalsFile) -> ExecApprovalsFile { - let socketPath = file.socket?.path?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if socketPath.isEmpty { - return ExecApprovalsFile( - version: file.version, - socket: nil, - defaults: file.defaults, - agents: file.agents) - } - return ExecApprovalsFile( - version: file.version, - socket: ExecApprovalsSocketConfig(path: socketPath, token: nil), - defaults: file.defaults, - agents: file.agents) - } - - static func loadFile() -> ExecApprovalsFile { - let url = self.fileURL() - guard FileManager().fileExists(atPath: url.path) else { - return ExecApprovalsFile(version: 1, socket: nil, defaults: nil, agents: [:]) - } - do { - let data = try Data(contentsOf: url) - let decoded = try JSONDecoder().decode(ExecApprovalsFile.self, from: data) - if decoded.version != 1 { - return ExecApprovalsFile(version: 1, socket: nil, defaults: nil, agents: [:]) - } - return decoded - } catch { - self.logger.warning("exec approvals load failed: \(error.localizedDescription, privacy: .public)") - return ExecApprovalsFile(version: 1, socket: nil, defaults: nil, agents: [:]) - } - } - - static func saveFile(_ file: ExecApprovalsFile) { - do { - let encoder = JSONEncoder() - encoder.outputFormatting = [.prettyPrinted, .sortedKeys] - let data = try encoder.encode(file) - let url = self.fileURL() - try FileManager().createDirectory( - at: url.deletingLastPathComponent(), - withIntermediateDirectories: true) - try data.write(to: url, options: [.atomic]) - try? FileManager().setAttributes([.posixPermissions: 0o600], ofItemAtPath: url.path) - } catch { - self.logger.error("exec approvals save failed: \(error.localizedDescription, privacy: .public)") - } - } - - static func ensureFile() -> ExecApprovalsFile { - var file = self.loadFile() - if file.socket == nil { file.socket = ExecApprovalsSocketConfig(path: nil, token: nil) } - let path = file.socket?.path?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if path.isEmpty { - file.socket?.path = self.socketPath() - } - let token = file.socket?.token?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if token.isEmpty { - file.socket?.token = self.generateToken() - } - if file.agents == nil { file.agents = [:] } - self.saveFile(file) - return file - } - - static func resolve(agentId: String?) -> ExecApprovalsResolved { - let file = self.ensureFile() - let defaults = file.defaults ?? ExecApprovalsDefaults() - let resolvedDefaults = ExecApprovalsResolvedDefaults( - security: defaults.security ?? self.defaultSecurity, - ask: defaults.ask ?? self.defaultAsk, - askFallback: defaults.askFallback ?? self.defaultAskFallback, - autoAllowSkills: defaults.autoAllowSkills ?? self.defaultAutoAllowSkills) - let key = self.agentKey(agentId) - let agentEntry = file.agents?[key] ?? ExecApprovalsAgent() - let wildcardEntry = file.agents?["*"] ?? ExecApprovalsAgent() - let resolvedAgent = ExecApprovalsResolvedDefaults( - security: agentEntry.security ?? wildcardEntry.security ?? resolvedDefaults.security, - ask: agentEntry.ask ?? wildcardEntry.ask ?? resolvedDefaults.ask, - askFallback: agentEntry.askFallback ?? wildcardEntry.askFallback - ?? resolvedDefaults.askFallback, - autoAllowSkills: agentEntry.autoAllowSkills ?? wildcardEntry.autoAllowSkills - ?? resolvedDefaults.autoAllowSkills) - let allowlist = ((wildcardEntry.allowlist ?? []) + (agentEntry.allowlist ?? [])) - .map { entry in - ExecAllowlistEntry( - id: entry.id, - pattern: entry.pattern.trimmingCharacters(in: .whitespacesAndNewlines), - lastUsedAt: entry.lastUsedAt, - lastUsedCommand: entry.lastUsedCommand, - lastResolvedPath: entry.lastResolvedPath) - } - .filter { !$0.pattern.isEmpty } - let socketPath = self.expandPath(file.socket?.path ?? self.socketPath()) - let token = file.socket?.token ?? "" - return ExecApprovalsResolved( - url: self.fileURL(), - socketPath: socketPath, - token: token, - defaults: resolvedDefaults, - agent: resolvedAgent, - allowlist: allowlist, - file: file) - } - - static func resolveDefaults() -> ExecApprovalsResolvedDefaults { - let file = self.ensureFile() - let defaults = file.defaults ?? ExecApprovalsDefaults() - return ExecApprovalsResolvedDefaults( - security: defaults.security ?? self.defaultSecurity, - ask: defaults.ask ?? self.defaultAsk, - askFallback: defaults.askFallback ?? self.defaultAskFallback, - autoAllowSkills: defaults.autoAllowSkills ?? self.defaultAutoAllowSkills) - } - - static func saveDefaults(_ defaults: ExecApprovalsDefaults) { - self.updateFile { file in - file.defaults = defaults - } - } - - static func updateDefaults(_ mutate: (inout ExecApprovalsDefaults) -> Void) { - self.updateFile { file in - var defaults = file.defaults ?? ExecApprovalsDefaults() - mutate(&defaults) - file.defaults = defaults - } - } - - static func saveAgent(_ agent: ExecApprovalsAgent, agentId: String?) { - self.updateFile { file in - var agents = file.agents ?? [:] - let key = self.agentKey(agentId) - if agent.isEmpty { - agents.removeValue(forKey: key) - } else { - agents[key] = agent - } - file.agents = agents.isEmpty ? nil : agents - } - } - - static func addAllowlistEntry(agentId: String?, pattern: String) { - let trimmed = pattern.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty else { return } - self.updateFile { file in - let key = self.agentKey(agentId) - var agents = file.agents ?? [:] - var entry = agents[key] ?? ExecApprovalsAgent() - var allowlist = entry.allowlist ?? [] - if allowlist.contains(where: { $0.pattern == trimmed }) { return } - allowlist.append(ExecAllowlistEntry(pattern: trimmed, lastUsedAt: Date().timeIntervalSince1970 * 1000)) - entry.allowlist = allowlist - agents[key] = entry - file.agents = agents - } - } - - static func recordAllowlistUse( - agentId: String?, - pattern: String, - command: String, - resolvedPath: String?) - { - self.updateFile { file in - let key = self.agentKey(agentId) - var agents = file.agents ?? [:] - var entry = agents[key] ?? ExecApprovalsAgent() - let allowlist = (entry.allowlist ?? []).map { item -> ExecAllowlistEntry in - guard item.pattern == pattern else { return item } - return ExecAllowlistEntry( - id: item.id, - pattern: item.pattern, - lastUsedAt: Date().timeIntervalSince1970 * 1000, - lastUsedCommand: command, - lastResolvedPath: resolvedPath) - } - entry.allowlist = allowlist - agents[key] = entry - file.agents = agents - } - } - - static func updateAllowlist(agentId: String?, allowlist: [ExecAllowlistEntry]) { - self.updateFile { file in - let key = self.agentKey(agentId) - var agents = file.agents ?? [:] - var entry = agents[key] ?? ExecApprovalsAgent() - let cleaned = allowlist - .map { item in - ExecAllowlistEntry( - id: item.id, - pattern: item.pattern.trimmingCharacters(in: .whitespacesAndNewlines), - lastUsedAt: item.lastUsedAt, - lastUsedCommand: item.lastUsedCommand, - lastResolvedPath: item.lastResolvedPath) - } - .filter { !$0.pattern.isEmpty } - entry.allowlist = cleaned - agents[key] = entry - file.agents = agents - } - } - - static func updateAgentSettings(agentId: String?, mutate: (inout ExecApprovalsAgent) -> Void) { - self.updateFile { file in - let key = self.agentKey(agentId) - var agents = file.agents ?? [:] - var entry = agents[key] ?? ExecApprovalsAgent() - mutate(&entry) - if entry.isEmpty { - agents.removeValue(forKey: key) - } else { - agents[key] = entry - } - file.agents = agents.isEmpty ? nil : agents - } - } - - private static func updateFile(_ mutate: (inout ExecApprovalsFile) -> Void) { - var file = self.ensureFile() - mutate(&file) - self.saveFile(file) - } - - private static func generateToken() -> String { - var bytes = [UInt8](repeating: 0, count: 24) - let status = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes) - if status == errSecSuccess { - return Data(bytes) - .base64EncodedString() - .replacingOccurrences(of: "+", with: "-") - .replacingOccurrences(of: "/", with: "_") - .replacingOccurrences(of: "=", with: "") - } - return UUID().uuidString - } - - private static func hashRaw(_ raw: String?) -> String { - let data = Data((raw ?? "").utf8) - let digest = SHA256.hash(data: data) - return digest.map { String(format: "%02x", $0) }.joined() - } - - private static func expandPath(_ raw: String) -> String { - let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) - if trimmed == "~" { - return FileManager().homeDirectoryForCurrentUser.path - } - if trimmed.hasPrefix("~/") { - let suffix = trimmed.dropFirst(2) - return FileManager().homeDirectoryForCurrentUser - .appendingPathComponent(String(suffix)).path - } - return trimmed - } - - private static func agentKey(_ agentId: String?) -> String { - let trimmed = agentId?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - return trimmed.isEmpty ? self.defaultAgentId : trimmed - } - - private static func normalizedPattern(_ pattern: String?) -> String? { - let trimmed = pattern?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - return trimmed.isEmpty ? nil : trimmed.lowercased() - } - - private static func mergeAgents( - current: ExecApprovalsAgent, - legacy: ExecApprovalsAgent) -> ExecApprovalsAgent - { - var seen = Set() - var allowlist: [ExecAllowlistEntry] = [] - func append(_ entry: ExecAllowlistEntry) { - guard let key = self.normalizedPattern(entry.pattern), !seen.contains(key) else { - return - } - seen.insert(key) - allowlist.append(entry) - } - for entry in current.allowlist ?? [] { - append(entry) - } - for entry in legacy.allowlist ?? [] { - append(entry) - } - - return ExecApprovalsAgent( - security: current.security ?? legacy.security, - ask: current.ask ?? legacy.ask, - askFallback: current.askFallback ?? legacy.askFallback, - autoAllowSkills: current.autoAllowSkills ?? legacy.autoAllowSkills, - allowlist: allowlist.isEmpty ? nil : allowlist) - } -} - -struct ExecCommandResolution: Sendable { - let rawExecutable: String - let resolvedPath: String? - let executableName: String - let cwd: String? - - static func resolve( - command: [String], - rawCommand: String?, - cwd: String?, - env: [String: String]?) -> ExecCommandResolution? - { - let trimmedRaw = rawCommand?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if !trimmedRaw.isEmpty, let token = self.parseFirstToken(trimmedRaw) { - return self.resolveExecutable(rawExecutable: token, cwd: cwd, env: env) - } - return self.resolve(command: command, cwd: cwd, env: env) - } - - static func resolve(command: [String], cwd: String?, env: [String: String]?) -> ExecCommandResolution? { - guard let raw = command.first?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else { - return nil - } - return self.resolveExecutable(rawExecutable: raw, cwd: cwd, env: env) - } - - private static func resolveExecutable( - rawExecutable: String, - cwd: String?, - env: [String: String]?) -> ExecCommandResolution? - { - let expanded = rawExecutable.hasPrefix("~") ? (rawExecutable as NSString).expandingTildeInPath : rawExecutable - let hasPathSeparator = expanded.contains("/") || expanded.contains("\\") - let resolvedPath: String? = { - if hasPathSeparator { - if expanded.hasPrefix("/") { - return expanded - } - let base = cwd?.trimmingCharacters(in: .whitespacesAndNewlines) - let root = (base?.isEmpty == false) ? base! : FileManager().currentDirectoryPath - return URL(fileURLWithPath: root).appendingPathComponent(expanded).path - } - let searchPaths = self.searchPaths(from: env) - return CommandResolver.findExecutable(named: expanded, searchPaths: searchPaths) - }() - let name = resolvedPath.map { URL(fileURLWithPath: $0).lastPathComponent } ?? expanded - return ExecCommandResolution( - rawExecutable: expanded, - resolvedPath: resolvedPath, - executableName: name, - cwd: cwd) - } - - private static func parseFirstToken(_ command: String) -> String? { - let trimmed = command.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty else { return nil } - guard let first = trimmed.first else { return nil } - if first == "\"" || first == "'" { - let rest = trimmed.dropFirst() - if let end = rest.firstIndex(of: first) { - return String(rest[.. [String] { - let raw = env?["PATH"] - if let raw, !raw.isEmpty { - return raw.split(separator: ":").map(String.init) - } - return CommandResolver.preferredPaths() - } -} - -enum ExecCommandFormatter { - static func displayString(for argv: [String]) -> String { - argv.map { arg in - let trimmed = arg.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty else { return "\"\"" } - let needsQuotes = trimmed.contains { $0.isWhitespace || $0 == "\"" } - if !needsQuotes { return trimmed } - let escaped = trimmed.replacingOccurrences(of: "\"", with: "\\\"") - return "\"\(escaped)\"" - }.joined(separator: " ") - } - - static func displayString(for argv: [String], rawCommand: String?) -> String { - let trimmed = rawCommand?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if !trimmed.isEmpty { return trimmed } - return self.displayString(for: argv) - } -} - -enum ExecApprovalHelpers { - static func parseDecision(_ raw: String?) -> ExecApprovalDecision? { - let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - guard !trimmed.isEmpty else { return nil } - return ExecApprovalDecision(rawValue: trimmed) - } - - static func requiresAsk( - ask: ExecAsk, - security: ExecSecurity, - allowlistMatch: ExecAllowlistEntry?, - skillAllow: Bool) -> Bool - { - if ask == .always { return true } - if ask == .onMiss, security == .allowlist, allowlistMatch == nil, !skillAllow { return true } - return false - } - - static func allowlistPattern(command: [String], resolution: ExecCommandResolution?) -> String? { - let pattern = resolution?.resolvedPath ?? resolution?.rawExecutable ?? command.first ?? "" - return pattern.isEmpty ? nil : pattern - } -} - -enum ExecAllowlistMatcher { - static func match(entries: [ExecAllowlistEntry], resolution: ExecCommandResolution?) -> ExecAllowlistEntry? { - guard let resolution, !entries.isEmpty else { return nil } - let rawExecutable = resolution.rawExecutable - let resolvedPath = resolution.resolvedPath - let executableName = resolution.executableName - - for entry in entries { - let pattern = entry.pattern.trimmingCharacters(in: .whitespacesAndNewlines) - if pattern.isEmpty { continue } - let hasPath = pattern.contains("/") || pattern.contains("~") || pattern.contains("\\") - if hasPath { - let target = resolvedPath ?? rawExecutable - if self.matches(pattern: pattern, target: target) { return entry } - } else if self.matches(pattern: pattern, target: executableName) { - return entry - } - } - return nil - } - - private static func matches(pattern: String, target: String) -> Bool { - let trimmed = pattern.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty else { return false } - let expanded = trimmed.hasPrefix("~") ? (trimmed as NSString).expandingTildeInPath : trimmed - let normalizedPattern = self.normalizeMatchTarget(expanded) - let normalizedTarget = self.normalizeMatchTarget(target) - guard let regex = self.regex(for: normalizedPattern) else { return false } - let range = NSRange(location: 0, length: normalizedTarget.utf16.count) - return regex.firstMatch(in: normalizedTarget, options: [], range: range) != nil - } - - private static func normalizeMatchTarget(_ value: String) -> String { - value.replacingOccurrences(of: "\\\\", with: "/").lowercased() - } - - private static func regex(for pattern: String) -> NSRegularExpression? { - var regex = "^" - var idx = pattern.startIndex - while idx < pattern.endIndex { - let ch = pattern[idx] - if ch == "*" { - let next = pattern.index(after: idx) - if next < pattern.endIndex, pattern[next] == "*" { - regex += ".*" - idx = pattern.index(after: next) - } else { - regex += "[^/]*" - idx = next - } - continue - } - if ch == "?" { - regex += "." - idx = pattern.index(after: idx) - continue - } - regex += NSRegularExpression.escapedPattern(for: String(ch)) - idx = pattern.index(after: idx) - } - regex += "$" - return try? NSRegularExpression(pattern: regex, options: [.caseInsensitive]) - } -} - -struct ExecEventPayload: Codable, Sendable { - var sessionKey: String - var runId: String - var host: String - var command: String? - var exitCode: Int? - var timedOut: Bool? - var success: Bool? - var output: String? - var reason: String? - - static func truncateOutput(_ raw: String, maxChars: Int = 20000) -> String? { - let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty else { return nil } - if trimmed.count <= maxChars { return trimmed } - let suffix = trimmed.suffix(maxChars) - return "... (truncated) \(suffix)" - } -} - -actor SkillBinsCache { - static let shared = SkillBinsCache() - - private var bins: Set = [] - private var lastRefresh: Date? - private let refreshInterval: TimeInterval = 90 - - func currentBins(force: Bool = false) async -> Set { - if force || self.isStale() { - await self.refresh() - } - return self.bins - } - - func refresh() async { - do { - let report = try await GatewayConnection.shared.skillsStatus() - var next = Set() - for skill in report.skills { - for bin in skill.requirements.bins { - let trimmed = bin.trimmingCharacters(in: .whitespacesAndNewlines) - if !trimmed.isEmpty { next.insert(trimmed) } - } - } - self.bins = next - self.lastRefresh = Date() - } catch { - if self.lastRefresh == nil { - self.bins = [] - } - } - } - - private func isStale() -> Bool { - guard let lastRefresh else { return true } - return Date().timeIntervalSince(lastRefresh) > self.refreshInterval - } -} diff --git a/apps/macos/Sources/Clawdbot/ExecApprovalsGatewayPrompter.swift b/apps/macos/Sources/Clawdbot/ExecApprovalsGatewayPrompter.swift deleted file mode 100644 index 29d1be50b..000000000 --- a/apps/macos/Sources/Clawdbot/ExecApprovalsGatewayPrompter.swift +++ /dev/null @@ -1,123 +0,0 @@ -import MoltbotKit -import MoltbotProtocol -import CoreGraphics -import Foundation -import OSLog - -@MainActor -final class ExecApprovalsGatewayPrompter { - static let shared = ExecApprovalsGatewayPrompter() - - private let logger = Logger(subsystem: "com.clawdbot", category: "exec-approvals.gateway") - private var task: Task? - - struct GatewayApprovalRequest: Codable, Sendable { - var id: String - var request: ExecApprovalPromptRequest - var createdAtMs: Int - var expiresAtMs: Int - } - - func start() { - guard self.task == nil else { return } - self.task = Task { [weak self] in - await self?.run() - } - } - - func stop() { - self.task?.cancel() - self.task = nil - } - - private func run() async { - let stream = await GatewayConnection.shared.subscribe(bufferingNewest: 200) - for await push in stream { - if Task.isCancelled { return } - await self.handle(push: push) - } - } - - private func handle(push: GatewayPush) async { - guard case let .event(evt) = push else { return } - guard evt.event == "exec.approval.requested" else { return } - guard let payload = evt.payload else { return } - do { - let data = try JSONEncoder().encode(payload) - let request = try JSONDecoder().decode(GatewayApprovalRequest.self, from: data) - guard self.shouldPresent(request: request) else { return } - let decision = ExecApprovalsPromptPresenter.prompt(request.request) - try await GatewayConnection.shared.requestVoid( - method: .execApprovalResolve, - params: [ - "id": AnyCodable(request.id), - "decision": AnyCodable(decision.rawValue), - ], - timeoutMs: 10000) - } catch { - self.logger.error("exec approval handling failed \(error.localizedDescription, privacy: .public)") - } - } - - private func shouldPresent(request: GatewayApprovalRequest) -> Bool { - let mode = AppStateStore.shared.connectionMode - let activeSession = WebChatManager.shared.activeSessionKey?.trimmingCharacters(in: .whitespacesAndNewlines) - let requestSession = request.request.sessionKey?.trimmingCharacters(in: .whitespacesAndNewlines) - return Self.shouldPresent( - mode: mode, - activeSession: activeSession, - requestSession: requestSession, - lastInputSeconds: Self.lastInputSeconds(), - thresholdSeconds: 120) - } - - private static func shouldPresent( - mode: AppState.ConnectionMode, - activeSession: String?, - requestSession: String?, - lastInputSeconds: Int?, - thresholdSeconds: Int) -> Bool - { - let active = activeSession?.trimmingCharacters(in: .whitespacesAndNewlines) - let requested = requestSession?.trimmingCharacters(in: .whitespacesAndNewlines) - let recentlyActive = lastInputSeconds.map { $0 <= thresholdSeconds } ?? (mode == .local) - - if let session = requested, !session.isEmpty { - if let active, !active.isEmpty { - return active == session - } - return recentlyActive - } - - if let active, !active.isEmpty { - return true - } - return mode == .local - } - - private static func lastInputSeconds() -> Int? { - let anyEvent = CGEventType(rawValue: UInt32.max) ?? .null - let seconds = CGEventSource.secondsSinceLastEventType(.combinedSessionState, eventType: anyEvent) - if seconds.isNaN || seconds.isInfinite || seconds < 0 { return nil } - return Int(seconds.rounded()) - } -} - -#if DEBUG -extension ExecApprovalsGatewayPrompter { - static func _testShouldPresent( - mode: AppState.ConnectionMode, - activeSession: String?, - requestSession: String?, - lastInputSeconds: Int?, - thresholdSeconds: Int = 120) -> Bool - { - self.shouldPresent( - mode: mode, - activeSession: activeSession, - requestSession: requestSession, - lastInputSeconds: lastInputSeconds, - thresholdSeconds: thresholdSeconds) - } -} -#endif diff --git a/apps/macos/Sources/Clawdbot/ExecApprovalsSocket.swift b/apps/macos/Sources/Clawdbot/ExecApprovalsSocket.swift deleted file mode 100644 index b5591dbd6..000000000 --- a/apps/macos/Sources/Clawdbot/ExecApprovalsSocket.swift +++ /dev/null @@ -1,831 +0,0 @@ -import AppKit -import MoltbotKit -import CryptoKit -import Darwin -import Foundation -import OSLog - -struct ExecApprovalPromptRequest: Codable, Sendable { - var command: String - var cwd: String? - var host: String? - var security: String? - var ask: String? - var agentId: String? - var resolvedPath: String? - var sessionKey: String? -} - -private struct ExecApprovalSocketRequest: Codable { - var type: String - var token: String - var id: String - var request: ExecApprovalPromptRequest -} - -private struct ExecApprovalSocketDecision: Codable { - var type: String - var id: String - var decision: ExecApprovalDecision -} - -private struct ExecHostSocketRequest: Codable { - var type: String - var id: String - var nonce: String - var ts: Int - var hmac: String - var requestJson: String -} - -private struct ExecHostRequest: Codable { - var command: [String] - var rawCommand: String? - var cwd: String? - var env: [String: String]? - var timeoutMs: Int? - var needsScreenRecording: Bool? - var agentId: String? - var sessionKey: String? - var approvalDecision: ExecApprovalDecision? -} - -private struct ExecHostRunResult: Codable { - var exitCode: Int? - var timedOut: Bool - var success: Bool - var stdout: String - var stderr: String - var error: String? -} - -private struct ExecHostError: Codable { - var code: String - var message: String - var reason: String? -} - -private struct ExecHostResponse: Codable { - var type: String - var id: String - var ok: Bool - var payload: ExecHostRunResult? - var error: ExecHostError? -} - -enum ExecApprovalsSocketClient { - private struct TimeoutError: LocalizedError { - var message: String - var errorDescription: String? { self.message } - } - - static func requestDecision( - socketPath: String, - token: String, - request: ExecApprovalPromptRequest, - timeoutMs: Int = 15000) async -> ExecApprovalDecision? - { - let trimmedPath = socketPath.trimmingCharacters(in: .whitespacesAndNewlines) - let trimmedToken = token.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmedPath.isEmpty, !trimmedToken.isEmpty else { return nil } - do { - return try await AsyncTimeout.withTimeoutMs( - timeoutMs: timeoutMs, - onTimeout: { - TimeoutError(message: "exec approvals socket timeout") - }, - operation: { - try await Task.detached { - try self.requestDecisionSync( - socketPath: trimmedPath, - token: trimmedToken, - request: request) - }.value - }) - } catch { - return nil - } - } - - private static func requestDecisionSync( - socketPath: String, - token: String, - request: ExecApprovalPromptRequest) throws -> ExecApprovalDecision? - { - let fd = socket(AF_UNIX, SOCK_STREAM, 0) - guard fd >= 0 else { - throw NSError(domain: "ExecApprovals", code: 1, userInfo: [ - NSLocalizedDescriptionKey: "socket create failed", - ]) - } - - var addr = sockaddr_un() - addr.sun_family = sa_family_t(AF_UNIX) - let maxLen = MemoryLayout.size(ofValue: addr.sun_path) - if socketPath.utf8.count >= maxLen { - throw NSError(domain: "ExecApprovals", code: 2, userInfo: [ - NSLocalizedDescriptionKey: "socket path too long", - ]) - } - socketPath.withCString { cstr in - withUnsafeMutablePointer(to: &addr.sun_path) { ptr in - let raw = UnsafeMutableRawPointer(ptr).assumingMemoryBound(to: Int8.self) - strncpy(raw, cstr, maxLen - 1) - } - } - let size = socklen_t(MemoryLayout.size(ofValue: addr)) - let result = withUnsafePointer(to: &addr) { ptr in - ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { rebound in - connect(fd, rebound, size) - } - } - if result != 0 { - throw NSError(domain: "ExecApprovals", code: 3, userInfo: [ - NSLocalizedDescriptionKey: "socket connect failed", - ]) - } - - let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true) - - let message = ExecApprovalSocketRequest( - type: "request", - token: token, - id: UUID().uuidString, - request: request) - let data = try JSONEncoder().encode(message) - var payload = data - payload.append(0x0A) - try handle.write(contentsOf: payload) - - guard let line = try self.readLine(from: handle, maxBytes: 256_000), - let lineData = line.data(using: .utf8) - else { return nil } - let response = try JSONDecoder().decode(ExecApprovalSocketDecision.self, from: lineData) - return response.decision - } - - private static func readLine(from handle: FileHandle, maxBytes: Int) throws -> String? { - var buffer = Data() - while buffer.count < maxBytes { - let chunk = try handle.read(upToCount: 4096) ?? Data() - if chunk.isEmpty { break } - buffer.append(chunk) - if buffer.contains(0x0A) { break } - } - guard let newlineIndex = buffer.firstIndex(of: 0x0A) else { - guard !buffer.isEmpty else { return nil } - return String(data: buffer, encoding: .utf8) - } - let lineData = buffer.subdata(in: 0.. ExecApprovalDecision { - NSApp.activate(ignoringOtherApps: true) - let alert = NSAlert() - alert.alertStyle = .warning - alert.messageText = "Allow this command?" - alert.informativeText = "Review the command details before allowing." - alert.accessoryView = self.buildAccessoryView(request) - - alert.addButton(withTitle: "Allow Once") - alert.addButton(withTitle: "Always Allow") - alert.addButton(withTitle: "Don't Allow") - if #available(macOS 11.0, *), alert.buttons.indices.contains(2) { - alert.buttons[2].hasDestructiveAction = true - } - - switch alert.runModal() { - case .alertFirstButtonReturn: - return .allowOnce - case .alertSecondButtonReturn: - return .allowAlways - default: - return .deny - } - } - - @MainActor - private static func buildAccessoryView(_ request: ExecApprovalPromptRequest) -> NSView { - let stack = NSStackView() - stack.orientation = .vertical - stack.spacing = 8 - stack.alignment = .leading - - let commandTitle = NSTextField(labelWithString: "Command") - commandTitle.font = NSFont.boldSystemFont(ofSize: NSFont.systemFontSize) - stack.addArrangedSubview(commandTitle) - - let commandText = NSTextView() - commandText.isEditable = false - commandText.isSelectable = true - commandText.drawsBackground = true - commandText.backgroundColor = NSColor.textBackgroundColor - commandText.font = NSFont.monospacedSystemFont(ofSize: NSFont.systemFontSize, weight: .regular) - commandText.string = request.command - commandText.textContainerInset = NSSize(width: 6, height: 6) - commandText.textContainer?.lineFragmentPadding = 0 - commandText.textContainer?.widthTracksTextView = true - commandText.isHorizontallyResizable = false - commandText.isVerticallyResizable = false - - let commandScroll = NSScrollView() - commandScroll.borderType = .lineBorder - commandScroll.hasVerticalScroller = false - commandScroll.hasHorizontalScroller = false - commandScroll.documentView = commandText - commandScroll.translatesAutoresizingMaskIntoConstraints = false - commandScroll.widthAnchor.constraint(lessThanOrEqualToConstant: 440).isActive = true - commandScroll.heightAnchor.constraint(greaterThanOrEqualToConstant: 56).isActive = true - stack.addArrangedSubview(commandScroll) - - let contextTitle = NSTextField(labelWithString: "Context") - contextTitle.font = NSFont.boldSystemFont(ofSize: NSFont.systemFontSize) - stack.addArrangedSubview(contextTitle) - - let contextStack = NSStackView() - contextStack.orientation = .vertical - contextStack.spacing = 4 - contextStack.alignment = .leading - - let trimmedCwd = request.cwd?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if !trimmedCwd.isEmpty { - self.addDetailRow(title: "Working directory", value: trimmedCwd, to: contextStack) - } - let trimmedAgent = request.agentId?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if !trimmedAgent.isEmpty { - self.addDetailRow(title: "Agent", value: trimmedAgent, to: contextStack) - } - let trimmedPath = request.resolvedPath?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if !trimmedPath.isEmpty { - self.addDetailRow(title: "Executable", value: trimmedPath, to: contextStack) - } - let trimmedHost = request.host?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if !trimmedHost.isEmpty { - self.addDetailRow(title: "Host", value: trimmedHost, to: contextStack) - } - if let security = request.security?.trimmingCharacters(in: .whitespacesAndNewlines), !security.isEmpty { - self.addDetailRow(title: "Security", value: security, to: contextStack) - } - if let ask = request.ask?.trimmingCharacters(in: .whitespacesAndNewlines), !ask.isEmpty { - self.addDetailRow(title: "Ask mode", value: ask, to: contextStack) - } - - if contextStack.arrangedSubviews.isEmpty { - let empty = NSTextField(labelWithString: "No additional context provided.") - empty.textColor = NSColor.secondaryLabelColor - empty.font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize) - contextStack.addArrangedSubview(empty) - } - - stack.addArrangedSubview(contextStack) - - let footer = NSTextField(labelWithString: "This runs on this machine.") - footer.textColor = NSColor.secondaryLabelColor - footer.font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize) - stack.addArrangedSubview(footer) - - return stack - } - - @MainActor - private static func addDetailRow(title: String, value: String, to stack: NSStackView) { - let row = NSStackView() - row.orientation = .horizontal - row.spacing = 6 - row.alignment = .firstBaseline - - let titleLabel = NSTextField(labelWithString: "\(title):") - titleLabel.font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize, weight: .semibold) - titleLabel.textColor = NSColor.secondaryLabelColor - - let valueLabel = NSTextField(labelWithString: value) - valueLabel.font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize) - valueLabel.lineBreakMode = .byTruncatingMiddle - valueLabel.setContentCompressionResistancePriority(.defaultLow, for: .horizontal) - - row.addArrangedSubview(titleLabel) - row.addArrangedSubview(valueLabel) - stack.addArrangedSubview(row) - } -} - -@MainActor -private enum ExecHostExecutor { - private struct ExecApprovalContext { - let command: [String] - let displayCommand: String - let trimmedAgent: String? - let approvals: ExecApprovalsResolved - let security: ExecSecurity - let ask: ExecAsk - let autoAllowSkills: Bool - let env: [String: String]? - let resolution: ExecCommandResolution? - let allowlistMatch: ExecAllowlistEntry? - let skillAllow: Bool - } - - private static let blockedEnvKeys: Set = [ - "PATH", - "NODE_OPTIONS", - "PYTHONHOME", - "PYTHONPATH", - "PERL5LIB", - "PERL5OPT", - "RUBYOPT", - ] - - private static let blockedEnvPrefixes: [String] = [ - "DYLD_", - "LD_", - ] - - static func handle(_ request: ExecHostRequest) async -> ExecHostResponse { - let command = request.command.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) } - guard !command.isEmpty else { - return self.errorResponse( - code: "INVALID_REQUEST", - message: "command required", - reason: "invalid") - } - - let context = await self.buildContext(request: request, command: command) - if context.security == .deny { - return self.errorResponse( - code: "UNAVAILABLE", - message: "SYSTEM_RUN_DISABLED: security=deny", - reason: "security=deny") - } - - let approvalDecision = request.approvalDecision - if approvalDecision == .deny { - return self.errorResponse( - code: "UNAVAILABLE", - message: "SYSTEM_RUN_DENIED: user denied", - reason: "user-denied") - } - - var approvedByAsk = approvalDecision != nil - if ExecApprovalHelpers.requiresAsk( - ask: context.ask, - security: context.security, - allowlistMatch: context.allowlistMatch, - skillAllow: context.skillAllow), - approvalDecision == nil - { - let decision = ExecApprovalsPromptPresenter.prompt( - ExecApprovalPromptRequest( - command: context.displayCommand, - cwd: request.cwd, - host: "node", - security: context.security.rawValue, - ask: context.ask.rawValue, - agentId: context.trimmedAgent, - resolvedPath: context.resolution?.resolvedPath, - sessionKey: request.sessionKey)) - - switch decision { - case .deny: - return self.errorResponse( - code: "UNAVAILABLE", - message: "SYSTEM_RUN_DENIED: user denied", - reason: "user-denied") - case .allowAlways: - approvedByAsk = true - self.persistAllowlistEntry(decision: decision, context: context) - case .allowOnce: - approvedByAsk = true - } - } - - self.persistAllowlistEntry(decision: approvalDecision, context: context) - - if context.security == .allowlist, - context.allowlistMatch == nil, - !context.skillAllow, - !approvedByAsk - { - return self.errorResponse( - code: "UNAVAILABLE", - message: "SYSTEM_RUN_DENIED: allowlist miss", - reason: "allowlist-miss") - } - - if let match = context.allowlistMatch { - ExecApprovalsStore.recordAllowlistUse( - agentId: context.trimmedAgent, - pattern: match.pattern, - command: context.displayCommand, - resolvedPath: context.resolution?.resolvedPath) - } - - if let errorResponse = await self.ensureScreenRecordingAccess(request.needsScreenRecording) { - return errorResponse - } - - return await self.runCommand( - command: command, - cwd: request.cwd, - env: context.env, - timeoutMs: request.timeoutMs) - } - - private static func buildContext(request: ExecHostRequest, command: [String]) async -> ExecApprovalContext { - let displayCommand = ExecCommandFormatter.displayString( - for: command, - rawCommand: request.rawCommand) - let agentId = request.agentId?.trimmingCharacters(in: .whitespacesAndNewlines) - let trimmedAgent = (agentId?.isEmpty == false) ? agentId : nil - let approvals = ExecApprovalsStore.resolve(agentId: trimmedAgent) - let security = approvals.agent.security - let ask = approvals.agent.ask - let autoAllowSkills = approvals.agent.autoAllowSkills - let env = self.sanitizedEnv(request.env) - let resolution = ExecCommandResolution.resolve( - command: command, - rawCommand: request.rawCommand, - cwd: request.cwd, - env: env) - let allowlistMatch = security == .allowlist - ? ExecAllowlistMatcher.match(entries: approvals.allowlist, resolution: resolution) - : nil - let skillAllow: Bool - if autoAllowSkills, let name = resolution?.executableName { - let bins = await SkillBinsCache.shared.currentBins() - skillAllow = bins.contains(name) - } else { - skillAllow = false - } - return ExecApprovalContext( - command: command, - displayCommand: displayCommand, - trimmedAgent: trimmedAgent, - approvals: approvals, - security: security, - ask: ask, - autoAllowSkills: autoAllowSkills, - env: env, - resolution: resolution, - allowlistMatch: allowlistMatch, - skillAllow: skillAllow) - } - - private static func persistAllowlistEntry( - decision: ExecApprovalDecision?, - context: ExecApprovalContext) - { - guard decision == .allowAlways, context.security == .allowlist else { return } - guard let pattern = ExecApprovalHelpers.allowlistPattern( - command: context.command, - resolution: context.resolution) - else { - return - } - ExecApprovalsStore.addAllowlistEntry(agentId: context.trimmedAgent, pattern: pattern) - } - - private static func ensureScreenRecordingAccess(_ needsScreenRecording: Bool?) async -> ExecHostResponse? { - guard needsScreenRecording == true else { return nil } - let authorized = await PermissionManager - .status([.screenRecording])[.screenRecording] ?? false - if authorized { return nil } - return self.errorResponse( - code: "UNAVAILABLE", - message: "PERMISSION_MISSING: screenRecording", - reason: "permission:screenRecording") - } - - private static func runCommand( - command: [String], - cwd: String?, - env: [String: String]?, - timeoutMs: Int?) async -> ExecHostResponse - { - let timeoutSec = timeoutMs.flatMap { Double($0) / 1000.0 } - let result = await Task.detached { () -> ShellExecutor.ShellResult in - await ShellExecutor.runDetailed( - command: command, - cwd: cwd, - env: env, - timeout: timeoutSec) - }.value - let payload = ExecHostRunResult( - exitCode: result.exitCode, - timedOut: result.timedOut, - success: result.success, - stdout: result.stdout, - stderr: result.stderr, - error: result.errorMessage) - return self.successResponse(payload) - } - - private static func errorResponse( - code: String, - message: String, - reason: String?) -> ExecHostResponse - { - ExecHostResponse( - type: "exec-res", - id: UUID().uuidString, - ok: false, - payload: nil, - error: ExecHostError(code: code, message: message, reason: reason)) - } - - private static func successResponse(_ payload: ExecHostRunResult) -> ExecHostResponse { - ExecHostResponse( - type: "exec-res", - id: UUID().uuidString, - ok: true, - payload: payload, - error: nil) - } - - private static func sanitizedEnv(_ overrides: [String: String]?) -> [String: String]? { - guard let overrides else { return nil } - var merged = ProcessInfo.processInfo.environment - for (rawKey, value) in overrides { - let key = rawKey.trimmingCharacters(in: .whitespacesAndNewlines) - guard !key.isEmpty else { continue } - let upper = key.uppercased() - if self.blockedEnvKeys.contains(upper) { continue } - if self.blockedEnvPrefixes.contains(where: { upper.hasPrefix($0) }) { continue } - merged[key] = value - } - return merged - } -} - -private final class ExecApprovalsSocketServer: @unchecked Sendable { - private let logger = Logger(subsystem: "com.clawdbot", category: "exec-approvals.socket") - private let socketPath: String - private let token: String - private let onPrompt: @Sendable (ExecApprovalPromptRequest) async -> ExecApprovalDecision - private let onExec: @Sendable (ExecHostRequest) async -> ExecHostResponse - private var socketFD: Int32 = -1 - private var acceptTask: Task? - private var isRunning = false - - init( - socketPath: String, - token: String, - onPrompt: @escaping @Sendable (ExecApprovalPromptRequest) async -> ExecApprovalDecision, - onExec: @escaping @Sendable (ExecHostRequest) async -> ExecHostResponse) - { - self.socketPath = socketPath - self.token = token - self.onPrompt = onPrompt - self.onExec = onExec - } - - func start() { - guard !self.isRunning else { return } - self.isRunning = true - self.acceptTask = Task.detached { [weak self] in - await self?.runAcceptLoop() - } - } - - func stop() { - self.isRunning = false - self.acceptTask?.cancel() - self.acceptTask = nil - if self.socketFD >= 0 { - close(self.socketFD) - self.socketFD = -1 - } - if !self.socketPath.isEmpty { - unlink(self.socketPath) - } - } - - private func runAcceptLoop() async { - let fd = self.openSocket() - guard fd >= 0 else { - self.isRunning = false - return - } - self.socketFD = fd - while self.isRunning { - var addr = sockaddr_un() - var len = socklen_t(MemoryLayout.size(ofValue: addr)) - let client = withUnsafeMutablePointer(to: &addr) { ptr in - ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { rebound in - accept(fd, rebound, &len) - } - } - if client < 0 { - if errno == EINTR { continue } - break - } - Task.detached { [weak self] in - await self?.handleClient(fd: client) - } - } - } - - private func openSocket() -> Int32 { - let fd = socket(AF_UNIX, SOCK_STREAM, 0) - guard fd >= 0 else { - self.logger.error("exec approvals socket create failed") - return -1 - } - unlink(self.socketPath) - var addr = sockaddr_un() - addr.sun_family = sa_family_t(AF_UNIX) - let maxLen = MemoryLayout.size(ofValue: addr.sun_path) - if self.socketPath.utf8.count >= maxLen { - self.logger.error("exec approvals socket path too long") - close(fd) - return -1 - } - self.socketPath.withCString { cstr in - withUnsafeMutablePointer(to: &addr.sun_path) { ptr in - let raw = UnsafeMutableRawPointer(ptr).assumingMemoryBound(to: Int8.self) - memset(raw, 0, maxLen) - strncpy(raw, cstr, maxLen - 1) - } - } - let size = socklen_t(MemoryLayout.size(ofValue: addr)) - let result = withUnsafePointer(to: &addr) { ptr in - ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { rebound in - bind(fd, rebound, size) - } - } - if result != 0 { - self.logger.error("exec approvals socket bind failed") - close(fd) - return -1 - } - if listen(fd, 16) != 0 { - self.logger.error("exec approvals socket listen failed") - close(fd) - return -1 - } - chmod(self.socketPath, 0o600) - self.logger.info("exec approvals socket listening at \(self.socketPath, privacy: .public)") - return fd - } - - private func handleClient(fd: Int32) async { - let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true) - do { - guard self.isAllowedPeer(fd: fd) else { - try self.sendApprovalResponse(handle: handle, id: UUID().uuidString, decision: .deny) - return - } - guard let line = try self.readLine(from: handle, maxBytes: 256_000), - let data = line.data(using: .utf8) - else { - return - } - guard - let envelope = try JSONSerialization.jsonObject(with: data) as? [String: Any], - let type = envelope["type"] as? String - else { - return - } - - if type == "request" { - let request = try JSONDecoder().decode(ExecApprovalSocketRequest.self, from: data) - guard request.token == self.token else { - try self.sendApprovalResponse(handle: handle, id: request.id, decision: .deny) - return - } - let decision = await self.onPrompt(request.request) - try self.sendApprovalResponse(handle: handle, id: request.id, decision: decision) - return - } - - if type == "exec" { - let request = try JSONDecoder().decode(ExecHostSocketRequest.self, from: data) - let response = await self.handleExecRequest(request) - try self.sendExecResponse(handle: handle, response: response) - return - } - } catch { - self.logger.error("exec approvals socket handling failed: \(error.localizedDescription, privacy: .public)") - } - } - - private func readLine(from handle: FileHandle, maxBytes: Int) throws -> String? { - var buffer = Data() - while buffer.count < maxBytes { - let chunk = try handle.read(upToCount: 4096) ?? Data() - if chunk.isEmpty { break } - buffer.append(chunk) - if buffer.contains(0x0A) { break } - } - guard let newlineIndex = buffer.firstIndex(of: 0x0A) else { - guard !buffer.isEmpty else { return nil } - return String(data: buffer, encoding: .utf8) - } - let lineData = buffer.subdata(in: 0.. Bool { - var uid = uid_t(0) - var gid = gid_t(0) - if getpeereid(fd, &uid, &gid) != 0 { - return false - } - return uid == geteuid() - } - - private func handleExecRequest(_ request: ExecHostSocketRequest) async -> ExecHostResponse { - let nowMs = Int(Date().timeIntervalSince1970 * 1000) - if abs(nowMs - request.ts) > 10000 { - return ExecHostResponse( - type: "exec-res", - id: request.id, - ok: false, - payload: nil, - error: ExecHostError(code: "INVALID_REQUEST", message: "expired request", reason: "ttl")) - } - let expected = self.hmacHex(nonce: request.nonce, ts: request.ts, requestJson: request.requestJson) - if expected != request.hmac { - return ExecHostResponse( - type: "exec-res", - id: request.id, - ok: false, - payload: nil, - error: ExecHostError(code: "INVALID_REQUEST", message: "invalid auth", reason: "hmac")) - } - guard let requestData = request.requestJson.data(using: .utf8), - let payload = try? JSONDecoder().decode(ExecHostRequest.self, from: requestData) - else { - return ExecHostResponse( - type: "exec-res", - id: request.id, - ok: false, - payload: nil, - error: ExecHostError(code: "INVALID_REQUEST", message: "invalid payload", reason: "json")) - } - let response = await self.onExec(payload) - return ExecHostResponse( - type: "exec-res", - id: request.id, - ok: response.ok, - payload: response.payload, - error: response.error) - } - - private func hmacHex(nonce: String, ts: Int, requestJson: String) -> String { - let key = SymmetricKey(data: Data(self.token.utf8)) - let message = "\(nonce):\(ts):\(requestJson)" - let mac = HMAC.authenticationCode(for: Data(message.utf8), using: key) - return mac.map { String(format: "%02x", $0) }.joined() - } -} diff --git a/apps/macos/Sources/Clawdbot/GatewayConnection.swift b/apps/macos/Sources/Clawdbot/GatewayConnection.swift deleted file mode 100644 index 5b655d3ac..000000000 --- a/apps/macos/Sources/Clawdbot/GatewayConnection.swift +++ /dev/null @@ -1,737 +0,0 @@ -import MoltbotChatUI -import MoltbotKit -import MoltbotProtocol -import Foundation -import OSLog - -private let gatewayConnectionLogger = Logger(subsystem: "com.clawdbot", category: "gateway.connection") - -enum GatewayAgentChannel: String, Codable, CaseIterable, Sendable { - case last - case whatsapp - case telegram - case discord - case googlechat - case slack - case signal - case imessage - case msteams - case bluebubbles - case webchat - - init(raw: String?) { - let normalized = (raw ?? "").trimmingCharacters(in: .whitespacesAndNewlines).lowercased() - self = GatewayAgentChannel(rawValue: normalized) ?? .last - } - - var isDeliverable: Bool { self != .webchat } - - func shouldDeliver(_ deliver: Bool) -> Bool { deliver && self.isDeliverable } -} - -struct GatewayAgentInvocation: Sendable { - var message: String - var sessionKey: String = "main" - var thinking: String? - var deliver: Bool = false - var to: String? - var channel: GatewayAgentChannel = .last - var timeoutSeconds: Int? - var idempotencyKey: String = UUID().uuidString -} - -/// Single, shared Gateway websocket connection for the whole app. -/// -/// This owns exactly one `GatewayChannelActor` and reuses it across all callers -/// (ControlChannel, debug actions, SwiftUI WebChat, etc.). -actor GatewayConnection { - static let shared = GatewayConnection() - - typealias Config = (url: URL, token: String?, password: String?) - - enum Method: String, Sendable { - case agent - case status - case setHeartbeats = "set-heartbeats" - case systemEvent = "system-event" - case health - case channelsStatus = "channels.status" - case configGet = "config.get" - case configSet = "config.set" - case configPatch = "config.patch" - case configSchema = "config.schema" - case wizardStart = "wizard.start" - case wizardNext = "wizard.next" - case wizardCancel = "wizard.cancel" - case wizardStatus = "wizard.status" - case talkMode = "talk.mode" - case webLoginStart = "web.login.start" - case webLoginWait = "web.login.wait" - case channelsLogout = "channels.logout" - case modelsList = "models.list" - case chatHistory = "chat.history" - case sessionsPreview = "sessions.preview" - case chatSend = "chat.send" - case chatAbort = "chat.abort" - case skillsStatus = "skills.status" - case skillsInstall = "skills.install" - case skillsUpdate = "skills.update" - case voicewakeGet = "voicewake.get" - case voicewakeSet = "voicewake.set" - case nodePairApprove = "node.pair.approve" - case nodePairReject = "node.pair.reject" - case devicePairList = "device.pair.list" - case devicePairApprove = "device.pair.approve" - case devicePairReject = "device.pair.reject" - case execApprovalResolve = "exec.approval.resolve" - case cronList = "cron.list" - case cronRuns = "cron.runs" - case cronRun = "cron.run" - case cronRemove = "cron.remove" - case cronUpdate = "cron.update" - case cronAdd = "cron.add" - case cronStatus = "cron.status" - } - - private let configProvider: @Sendable () async throws -> Config - private let sessionBox: WebSocketSessionBox? - private let decoder = JSONDecoder() - - private var client: GatewayChannelActor? - private var configuredURL: URL? - private var configuredToken: String? - private var configuredPassword: String? - - private var subscribers: [UUID: AsyncStream.Continuation] = [:] - private var lastSnapshot: HelloOk? - - init( - configProvider: @escaping @Sendable () async throws -> Config = GatewayConnection.defaultConfigProvider, - sessionBox: WebSocketSessionBox? = nil) - { - self.configProvider = configProvider - self.sessionBox = sessionBox - } - - // MARK: - Low-level request - - func request( - method: String, - params: [String: AnyCodable]?, - timeoutMs: Double? = nil) async throws -> Data - { - let cfg = try await self.configProvider() - await self.configure(url: cfg.url, token: cfg.token, password: cfg.password) - guard let client else { - throw NSError(domain: "Gateway", code: 0, userInfo: [NSLocalizedDescriptionKey: "gateway not configured"]) - } - - do { - return try await client.request(method: method, params: params, timeoutMs: timeoutMs) - } catch { - if error is GatewayResponseError || error is GatewayDecodingError { - throw error - } - - // Auto-recover in local mode by spawning/attaching a gateway and retrying a few times. - // Canvas interactions should "just work" even if the local gateway isn't running yet. - let mode = await MainActor.run { AppStateStore.shared.connectionMode } - switch mode { - case .local: - await MainActor.run { GatewayProcessManager.shared.setActive(true) } - - var lastError: Error = error - for delayMs in [150, 400, 900] { - try await Task.sleep(nanoseconds: UInt64(delayMs) * 1_000_000) - do { - return try await client.request(method: method, params: params, timeoutMs: timeoutMs) - } catch { - lastError = error - } - } - - let nsError = lastError as NSError - if nsError.domain == URLError.errorDomain, - let fallback = await GatewayEndpointStore.shared.maybeFallbackToTailnet(from: cfg.url) - { - await self.configure(url: fallback.url, token: fallback.token, password: fallback.password) - for delayMs in [150, 400, 900] { - try await Task.sleep(nanoseconds: UInt64(delayMs) * 1_000_000) - do { - guard let client = self.client else { - throw NSError( - domain: "Gateway", - code: 0, - userInfo: [NSLocalizedDescriptionKey: "gateway not configured"]) - } - return try await client.request(method: method, params: params, timeoutMs: timeoutMs) - } catch { - lastError = error - } - } - } - - throw lastError - case .remote: - let nsError = error as NSError - guard nsError.domain == URLError.errorDomain else { throw error } - - var lastError: Error = error - await RemoteTunnelManager.shared.stopAll() - do { - _ = try await GatewayEndpointStore.shared.ensureRemoteControlTunnel() - } catch { - lastError = error - } - - for delayMs in [150, 400, 900] { - try await Task.sleep(nanoseconds: UInt64(delayMs) * 1_000_000) - do { - let cfg = try await self.configProvider() - await self.configure(url: cfg.url, token: cfg.token, password: cfg.password) - guard let client = self.client else { - throw NSError( - domain: "Gateway", - code: 0, - userInfo: [NSLocalizedDescriptionKey: "gateway not configured"]) - } - return try await client.request(method: method, params: params, timeoutMs: timeoutMs) - } catch { - lastError = error - } - } - - throw lastError - case .unconfigured: - throw error - } - } - } - - func requestRaw( - method: Method, - params: [String: AnyCodable]? = nil, - timeoutMs: Double? = nil) async throws -> Data - { - try await self.request(method: method.rawValue, params: params, timeoutMs: timeoutMs) - } - - func requestRaw( - method: String, - params: [String: AnyCodable]? = nil, - timeoutMs: Double? = nil) async throws -> Data - { - try await self.request(method: method, params: params, timeoutMs: timeoutMs) - } - - func requestDecoded( - method: Method, - params: [String: AnyCodable]? = nil, - timeoutMs: Double? = nil) async throws -> T - { - let data = try await self.requestRaw(method: method, params: params, timeoutMs: timeoutMs) - do { - return try self.decoder.decode(T.self, from: data) - } catch { - throw GatewayDecodingError(method: method.rawValue, message: error.localizedDescription) - } - } - - func requestVoid( - method: Method, - params: [String: AnyCodable]? = nil, - timeoutMs: Double? = nil) async throws - { - _ = try await self.requestRaw(method: method, params: params, timeoutMs: timeoutMs) - } - - /// Ensure the underlying socket is configured (and replaced if config changed). - func refresh() async throws { - let cfg = try await self.configProvider() - await self.configure(url: cfg.url, token: cfg.token, password: cfg.password) - } - - func authSource() async -> GatewayAuthSource? { - guard let client else { return nil } - return await client.authSource() - } - - func shutdown() async { - if let client { - await client.shutdown() - } - self.client = nil - self.configuredURL = nil - self.configuredToken = nil - self.lastSnapshot = nil - } - - func canvasHostUrl() async -> String? { - guard let snapshot = self.lastSnapshot else { return nil } - let trimmed = snapshot.canvashosturl?.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) ?? "" - return trimmed.isEmpty ? nil : trimmed - } - - private func sessionDefaultString(_ defaults: [String: MoltbotProtocol.AnyCodable]?, key: String) -> String { - let raw = defaults?[key]?.value as? String - return (raw ?? "").trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) - } - - func cachedMainSessionKey() -> String? { - guard let snapshot = self.lastSnapshot else { return nil } - let trimmed = self.sessionDefaultString(snapshot.snapshot.sessiondefaults, key: "mainSessionKey") - return trimmed.isEmpty ? nil : trimmed - } - - func cachedGatewayVersion() -> String? { - guard let snapshot = self.lastSnapshot else { return nil } - let raw = snapshot.server["version"]?.value as? String - let trimmed = raw?.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) ?? "" - return trimmed.isEmpty ? nil : trimmed - } - - func snapshotPaths() -> (configPath: String?, stateDir: String?) { - guard let snapshot = self.lastSnapshot else { return (nil, nil) } - let configPath = snapshot.snapshot.configpath?.trimmingCharacters(in: .whitespacesAndNewlines) - let stateDir = snapshot.snapshot.statedir?.trimmingCharacters(in: .whitespacesAndNewlines) - return ( - configPath?.isEmpty == false ? configPath : nil, - stateDir?.isEmpty == false ? stateDir : nil) - } - - func subscribe(bufferingNewest: Int = 100) -> AsyncStream { - let id = UUID() - let snapshot = self.lastSnapshot - let connection = self - return AsyncStream(bufferingPolicy: .bufferingNewest(bufferingNewest)) { continuation in - if let snapshot { - continuation.yield(.snapshot(snapshot)) - } - self.subscribers[id] = continuation - continuation.onTermination = { @Sendable _ in - Task { await connection.removeSubscriber(id) } - } - } - } - - private func removeSubscriber(_ id: UUID) { - self.subscribers[id] = nil - } - - private func broadcast(_ push: GatewayPush) { - if case let .snapshot(snapshot) = push { - self.lastSnapshot = snapshot - if let mainSessionKey = self.cachedMainSessionKey() { - Task { @MainActor in - WorkActivityStore.shared.setMainSessionKey(mainSessionKey) - } - } - } - for (_, continuation) in self.subscribers { - continuation.yield(push) - } - } - - private func canonicalizeSessionKey(_ raw: String) -> String { - let trimmed = raw.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) - guard !trimmed.isEmpty else { return trimmed } - guard let defaults = self.lastSnapshot?.snapshot.sessiondefaults else { return trimmed } - let mainSessionKey = self.sessionDefaultString(defaults, key: "mainSessionKey") - guard !mainSessionKey.isEmpty else { return trimmed } - let mainKey = self.sessionDefaultString(defaults, key: "mainKey") - let defaultAgentId = self.sessionDefaultString(defaults, key: "defaultAgentId") - let isMainAlias = - trimmed == "main" || - (!mainKey.isEmpty && trimmed == mainKey) || - trimmed == mainSessionKey || - (!defaultAgentId.isEmpty && - (trimmed == "agent:\(defaultAgentId):main" || - (mainKey.isEmpty == false && trimmed == "agent:\(defaultAgentId):\(mainKey)"))) - return isMainAlias ? mainSessionKey : trimmed - } - - private func configure(url: URL, token: String?, password: String?) async { - if self.client != nil, self.configuredURL == url, self.configuredToken == token, - self.configuredPassword == password - { - return - } - if let client { - await client.shutdown() - } - self.lastSnapshot = nil - self.client = GatewayChannelActor( - url: url, - token: token, - password: password, - session: self.sessionBox, - pushHandler: { [weak self] push in - await self?.handle(push: push) - }) - self.configuredURL = url - self.configuredToken = token - self.configuredPassword = password - } - - private func handle(push: GatewayPush) { - self.broadcast(push) - } - - private static func defaultConfigProvider() async throws -> Config { - try await GatewayEndpointStore.shared.requireConfig() - } -} - -// MARK: - Typed gateway API - -extension GatewayConnection { - struct ConfigGetSnapshot: Decodable, Sendable { - struct SnapshotConfig: Decodable, Sendable { - struct Session: Decodable, Sendable { - let mainKey: String? - let scope: String? - } - - let session: Session? - } - - let config: SnapshotConfig? - } - - static func mainSessionKey(fromConfigGetData data: Data) throws -> String { - let snapshot = try JSONDecoder().decode(ConfigGetSnapshot.self, from: data) - let scope = snapshot.config?.session?.scope?.trimmingCharacters(in: .whitespacesAndNewlines) - if scope == "global" { - return "global" - } - return "main" - } - - func mainSessionKey(timeoutMs: Double = 15000) async -> String { - if let cached = self.cachedMainSessionKey() { - return cached - } - do { - let data = try await self.requestRaw(method: "config.get", params: nil, timeoutMs: timeoutMs) - return try Self.mainSessionKey(fromConfigGetData: data) - } catch { - return "main" - } - } - - func status() async -> (ok: Bool, error: String?) { - do { - _ = try await self.requestRaw(method: .status) - return (true, nil) - } catch { - return (false, error.localizedDescription) - } - } - - func setHeartbeatsEnabled(_ enabled: Bool) async -> Bool { - do { - try await self.requestVoid(method: .setHeartbeats, params: ["enabled": AnyCodable(enabled)]) - return true - } catch { - gatewayConnectionLogger.error("setHeartbeatsEnabled failed \(error.localizedDescription, privacy: .public)") - return false - } - } - - func sendAgent(_ invocation: GatewayAgentInvocation) async -> (ok: Bool, error: String?) { - let trimmed = invocation.message.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty else { return (false, "message empty") } - let sessionKey = self.canonicalizeSessionKey(invocation.sessionKey) - - var params: [String: AnyCodable] = [ - "message": AnyCodable(trimmed), - "sessionKey": AnyCodable(sessionKey), - "thinking": AnyCodable(invocation.thinking ?? "default"), - "deliver": AnyCodable(invocation.deliver), - "to": AnyCodable(invocation.to ?? ""), - "channel": AnyCodable(invocation.channel.rawValue), - "idempotencyKey": AnyCodable(invocation.idempotencyKey), - ] - if let timeout = invocation.timeoutSeconds { - params["timeout"] = AnyCodable(timeout) - } - - do { - try await self.requestVoid(method: .agent, params: params) - return (true, nil) - } catch { - return (false, error.localizedDescription) - } - } - - func sendAgent( - message: String, - thinking: String?, - sessionKey: String, - deliver: Bool, - to: String?, - channel: GatewayAgentChannel = .last, - timeoutSeconds: Int? = nil, - idempotencyKey: String = UUID().uuidString) async -> (ok: Bool, error: String?) - { - await self.sendAgent(GatewayAgentInvocation( - message: message, - sessionKey: sessionKey, - thinking: thinking, - deliver: deliver, - to: to, - channel: channel, - timeoutSeconds: timeoutSeconds, - idempotencyKey: idempotencyKey)) - } - - func sendSystemEvent(_ params: [String: AnyCodable]) async { - do { - try await self.requestVoid(method: .systemEvent, params: params) - } catch { - // Best-effort only. - } - } - - // MARK: - Health - - func healthSnapshot(timeoutMs: Double? = nil) async throws -> HealthSnapshot { - let data = try await self.requestRaw(method: .health, timeoutMs: timeoutMs) - if let snap = decodeHealthSnapshot(from: data) { return snap } - throw GatewayDecodingError(method: Method.health.rawValue, message: "failed to decode health snapshot") - } - - func healthOK(timeoutMs: Int = 8000) async throws -> Bool { - let data = try await self.requestRaw(method: .health, timeoutMs: Double(timeoutMs)) - return (try? self.decoder.decode(MoltbotGatewayHealthOK.self, from: data))?.ok ?? true - } - - // MARK: - Skills - - func skillsStatus() async throws -> SkillsStatusReport { - try await self.requestDecoded(method: .skillsStatus) - } - - func skillsInstall( - name: String, - installId: String, - timeoutMs: Int? = nil) async throws -> SkillInstallResult - { - var params: [String: AnyCodable] = [ - "name": AnyCodable(name), - "installId": AnyCodable(installId), - ] - if let timeoutMs { - params["timeoutMs"] = AnyCodable(timeoutMs) - } - return try await self.requestDecoded(method: .skillsInstall, params: params) - } - - func skillsUpdate( - skillKey: String, - enabled: Bool? = nil, - apiKey: String? = nil, - env: [String: String]? = nil) async throws -> SkillUpdateResult - { - var params: [String: AnyCodable] = [ - "skillKey": AnyCodable(skillKey), - ] - if let enabled { params["enabled"] = AnyCodable(enabled) } - if let apiKey { params["apiKey"] = AnyCodable(apiKey) } - if let env, !env.isEmpty { params["env"] = AnyCodable(env) } - return try await self.requestDecoded(method: .skillsUpdate, params: params) - } - - // MARK: - Sessions - - func sessionsPreview( - keys: [String], - limit: Int? = nil, - maxChars: Int? = nil, - timeoutMs: Int? = nil) async throws -> MoltbotSessionsPreviewPayload - { - let resolvedKeys = keys - .map { self.canonicalizeSessionKey($0) } - .filter { !$0.isEmpty } - if resolvedKeys.isEmpty { - return MoltbotSessionsPreviewPayload(ts: 0, previews: []) - } - var params: [String: AnyCodable] = ["keys": AnyCodable(resolvedKeys)] - if let limit { params["limit"] = AnyCodable(limit) } - if let maxChars { params["maxChars"] = AnyCodable(maxChars) } - let timeout = timeoutMs.map { Double($0) } - return try await self.requestDecoded( - method: .sessionsPreview, - params: params, - timeoutMs: timeout) - } - - // MARK: - Chat - - func chatHistory( - sessionKey: String, - limit: Int? = nil, - timeoutMs: Int? = nil) async throws -> MoltbotChatHistoryPayload - { - let resolvedKey = self.canonicalizeSessionKey(sessionKey) - var params: [String: AnyCodable] = ["sessionKey": AnyCodable(resolvedKey)] - if let limit { params["limit"] = AnyCodable(limit) } - let timeout = timeoutMs.map { Double($0) } - return try await self.requestDecoded( - method: .chatHistory, - params: params, - timeoutMs: timeout) - } - - func chatSend( - sessionKey: String, - message: String, - thinking: String, - idempotencyKey: String, - attachments: [MoltbotChatAttachmentPayload], - timeoutMs: Int = 30000) async throws -> MoltbotChatSendResponse - { - let resolvedKey = self.canonicalizeSessionKey(sessionKey) - var params: [String: AnyCodable] = [ - "sessionKey": AnyCodable(resolvedKey), - "message": AnyCodable(message), - "thinking": AnyCodable(thinking), - "idempotencyKey": AnyCodable(idempotencyKey), - "timeoutMs": AnyCodable(timeoutMs), - ] - - if !attachments.isEmpty { - let encoded = attachments.map { att in - [ - "type": att.type, - "mimeType": att.mimeType, - "fileName": att.fileName, - "content": att.content, - ] - } - params["attachments"] = AnyCodable(encoded) - } - - return try await self.requestDecoded( - method: .chatSend, - params: params, - timeoutMs: Double(timeoutMs)) - } - - func chatAbort(sessionKey: String, runId: String) async throws -> Bool { - let resolvedKey = self.canonicalizeSessionKey(sessionKey) - struct AbortResponse: Decodable { let ok: Bool?; let aborted: Bool? } - let res: AbortResponse = try await self.requestDecoded( - method: .chatAbort, - params: ["sessionKey": AnyCodable(resolvedKey), "runId": AnyCodable(runId)]) - return res.aborted ?? false - } - - func talkMode(enabled: Bool, phase: String? = nil) async { - var params: [String: AnyCodable] = ["enabled": AnyCodable(enabled)] - if let phase { params["phase"] = AnyCodable(phase) } - try? await self.requestVoid(method: .talkMode, params: params) - } - - // MARK: - VoiceWake - - func voiceWakeGetTriggers() async throws -> [String] { - struct VoiceWakePayload: Decodable { let triggers: [String] } - let payload: VoiceWakePayload = try await self.requestDecoded(method: .voicewakeGet) - return payload.triggers - } - - func voiceWakeSetTriggers(_ triggers: [String]) async { - do { - try await self.requestVoid( - method: .voicewakeSet, - params: ["triggers": AnyCodable(triggers)], - timeoutMs: 10000) - } catch { - // Best-effort only. - } - } - - // MARK: - Node pairing - - func nodePairApprove(requestId: String) async throws { - try await self.requestVoid( - method: .nodePairApprove, - params: ["requestId": AnyCodable(requestId)], - timeoutMs: 10000) - } - - func nodePairReject(requestId: String) async throws { - try await self.requestVoid( - method: .nodePairReject, - params: ["requestId": AnyCodable(requestId)], - timeoutMs: 10000) - } - - // MARK: - Device pairing - - func devicePairApprove(requestId: String) async throws { - try await self.requestVoid( - method: .devicePairApprove, - params: ["requestId": AnyCodable(requestId)], - timeoutMs: 10000) - } - - func devicePairReject(requestId: String) async throws { - try await self.requestVoid( - method: .devicePairReject, - params: ["requestId": AnyCodable(requestId)], - timeoutMs: 10000) - } - - // MARK: - Cron - - struct CronSchedulerStatus: Decodable, Sendable { - let enabled: Bool - let storePath: String - let jobs: Int - let nextWakeAtMs: Int? - } - - func cronStatus() async throws -> CronSchedulerStatus { - try await self.requestDecoded(method: .cronStatus) - } - - func cronList(includeDisabled: Bool = true) async throws -> [CronJob] { - let res: CronListResponse = try await self.requestDecoded( - method: .cronList, - params: ["includeDisabled": AnyCodable(includeDisabled)]) - return res.jobs - } - - func cronRuns(jobId: String, limit: Int = 200) async throws -> [CronRunLogEntry] { - let res: CronRunsResponse = try await self.requestDecoded( - method: .cronRuns, - params: ["id": AnyCodable(jobId), "limit": AnyCodable(limit)]) - return res.entries - } - - func cronRun(jobId: String, force: Bool = true) async throws { - try await self.requestVoid( - method: .cronRun, - params: [ - "id": AnyCodable(jobId), - "mode": AnyCodable(force ? "force" : "due"), - ], - timeoutMs: 20000) - } - - func cronRemove(jobId: String) async throws { - try await self.requestVoid(method: .cronRemove, params: ["id": AnyCodable(jobId)]) - } - - func cronUpdate(jobId: String, patch: [String: AnyCodable]) async throws { - try await self.requestVoid( - method: .cronUpdate, - params: ["id": AnyCodable(jobId), "patch": AnyCodable(patch)]) - } - - func cronAdd(payload: [String: AnyCodable]) async throws { - try await self.requestVoid(method: .cronAdd, params: payload) - } -} diff --git a/apps/macos/Sources/Clawdbot/GatewayConnectivityCoordinator.swift b/apps/macos/Sources/Clawdbot/GatewayConnectivityCoordinator.swift deleted file mode 100644 index ac65ec0ac..000000000 --- a/apps/macos/Sources/Clawdbot/GatewayConnectivityCoordinator.swift +++ /dev/null @@ -1,63 +0,0 @@ -import Foundation -import Observation -import OSLog - -@MainActor -@Observable -final class GatewayConnectivityCoordinator { - static let shared = GatewayConnectivityCoordinator() - - private let logger = Logger(subsystem: "com.clawdbot", category: "gateway.connectivity") - private var endpointTask: Task? - private var lastResolvedURL: URL? - - private(set) var endpointState: GatewayEndpointState? - private(set) var resolvedURL: URL? - private(set) var resolvedMode: AppState.ConnectionMode? - private(set) var resolvedHostLabel: String? - - private init() { - self.start() - } - - func start() { - guard self.endpointTask == nil else { return } - self.endpointTask = Task { [weak self] in - guard let self else { return } - let stream = await GatewayEndpointStore.shared.subscribe() - for await state in stream { - await MainActor.run { self.handleEndpointState(state) } - } - } - } - - var localEndpointHostLabel: String? { - guard self.resolvedMode == .local, let url = self.resolvedURL else { return nil } - return Self.hostLabel(for: url) - } - - private func handleEndpointState(_ state: GatewayEndpointState) { - self.endpointState = state - switch state { - case let .ready(mode, url, _, _): - self.resolvedMode = mode - self.resolvedURL = url - self.resolvedHostLabel = Self.hostLabel(for: url) - let urlChanged = self.lastResolvedURL?.absoluteString != url.absoluteString - if urlChanged { - self.lastResolvedURL = url - Task { await ControlChannel.shared.refreshEndpoint(reason: "endpoint changed") } - } - case let .connecting(mode, _): - self.resolvedMode = mode - case let .unavailable(mode, _): - self.resolvedMode = mode - } - } - - private static func hostLabel(for url: URL) -> String { - let host = url.host ?? url.absoluteString - if let port = url.port { return "\(host):\(port)" } - return host - } -} diff --git a/apps/macos/Sources/Clawdbot/GatewayEndpointStore.swift b/apps/macos/Sources/Clawdbot/GatewayEndpointStore.swift deleted file mode 100644 index a5c3a756e..000000000 --- a/apps/macos/Sources/Clawdbot/GatewayEndpointStore.swift +++ /dev/null @@ -1,696 +0,0 @@ -import ConcurrencyExtras -import Foundation -import OSLog - -enum GatewayEndpointState: Sendable, Equatable { - case ready(mode: AppState.ConnectionMode, url: URL, token: String?, password: String?) - case connecting(mode: AppState.ConnectionMode, detail: String) - case unavailable(mode: AppState.ConnectionMode, reason: String) -} - -/// Single place to resolve (and publish) the effective gateway control endpoint. -/// -/// This is intentionally separate from `GatewayConnection`: -/// - `GatewayConnection` consumes the resolved endpoint (no tunnel side-effects). -/// - The endpoint store owns observation + explicit "ensure tunnel" actions. -actor GatewayEndpointStore { - static let shared = GatewayEndpointStore() - private static let supportedBindModes: Set = [ - "loopback", - "tailnet", - "lan", - "auto", - "custom", - ] - private static let remoteConnectingDetail = "Connecting to remote gateway…" - private static let staticLogger = Logger(subsystem: "com.clawdbot", category: "gateway-endpoint") - private enum EnvOverrideWarningKind: Sendable { - case token - case password - } - - private static let envOverrideWarnings = LockIsolated((token: false, password: false)) - - struct Deps: Sendable { - let mode: @Sendable () async -> AppState.ConnectionMode - let token: @Sendable () -> String? - let password: @Sendable () -> String? - let localPort: @Sendable () -> Int - let localHost: @Sendable () async -> String - let remotePortIfRunning: @Sendable () async -> UInt16? - let ensureRemoteTunnel: @Sendable () async throws -> UInt16 - - static let live = Deps( - mode: { await MainActor.run { AppStateStore.shared.connectionMode } }, - token: { - let root = MoltbotConfigFile.loadDict() - let isRemote = ConnectionModeResolver.resolve(root: root).mode == .remote - return GatewayEndpointStore.resolveGatewayToken( - isRemote: isRemote, - root: root, - env: ProcessInfo.processInfo.environment, - launchdSnapshot: GatewayLaunchAgentManager.launchdConfigSnapshot()) - }, - password: { - let root = MoltbotConfigFile.loadDict() - let isRemote = ConnectionModeResolver.resolve(root: root).mode == .remote - return GatewayEndpointStore.resolveGatewayPassword( - isRemote: isRemote, - root: root, - env: ProcessInfo.processInfo.environment, - launchdSnapshot: GatewayLaunchAgentManager.launchdConfigSnapshot()) - }, - localPort: { GatewayEnvironment.gatewayPort() }, - localHost: { - let root = MoltbotConfigFile.loadDict() - let bind = GatewayEndpointStore.resolveGatewayBindMode( - root: root, - env: ProcessInfo.processInfo.environment) - let customBindHost = GatewayEndpointStore.resolveGatewayCustomBindHost(root: root) - let tailscaleIP = await MainActor.run { TailscaleService.shared.tailscaleIP } - ?? TailscaleService.fallbackTailnetIPv4() - return GatewayEndpointStore.resolveLocalGatewayHost( - bindMode: bind, - customBindHost: customBindHost, - tailscaleIP: tailscaleIP) - }, - remotePortIfRunning: { await RemoteTunnelManager.shared.controlTunnelPortIfRunning() }, - ensureRemoteTunnel: { try await RemoteTunnelManager.shared.ensureControlTunnel() }) - } - - private static func resolveGatewayPassword( - isRemote: Bool, - root: [String: Any], - env: [String: String], - launchdSnapshot: LaunchAgentPlistSnapshot?) -> String? - { - let raw = env["CLAWDBOT_GATEWAY_PASSWORD"] ?? "" - let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) - if !trimmed.isEmpty { - if let configPassword = self.resolveConfigPassword(isRemote: isRemote, root: root), - !configPassword.isEmpty - { - self.warnEnvOverrideOnce( - kind: .password, - envVar: "CLAWDBOT_GATEWAY_PASSWORD", - configKey: isRemote ? "gateway.remote.password" : "gateway.auth.password") - } - return trimmed - } - if isRemote { - if let gateway = root["gateway"] as? [String: Any], - let remote = gateway["remote"] as? [String: Any], - let password = remote["password"] as? String - { - let pw = password.trimmingCharacters(in: .whitespacesAndNewlines) - if !pw.isEmpty { - return pw - } - } - return nil - } - if let gateway = root["gateway"] as? [String: Any], - let auth = gateway["auth"] as? [String: Any], - let password = auth["password"] as? String - { - let pw = password.trimmingCharacters(in: .whitespacesAndNewlines) - if !pw.isEmpty { - return pw - } - } - if let password = launchdSnapshot?.password?.trimmingCharacters(in: .whitespacesAndNewlines), - !password.isEmpty - { - return password - } - return nil - } - - private static func resolveConfigPassword(isRemote: Bool, root: [String: Any]) -> String? { - if isRemote { - if let gateway = root["gateway"] as? [String: Any], - let remote = gateway["remote"] as? [String: Any], - let password = remote["password"] as? String - { - return password.trimmingCharacters(in: .whitespacesAndNewlines) - } - return nil - } - - if let gateway = root["gateway"] as? [String: Any], - let auth = gateway["auth"] as? [String: Any], - let password = auth["password"] as? String - { - return password.trimmingCharacters(in: .whitespacesAndNewlines) - } - return nil - } - - private static func resolveGatewayToken( - isRemote: Bool, - root: [String: Any], - env: [String: String], - launchdSnapshot: LaunchAgentPlistSnapshot?) -> String? - { - let raw = env["CLAWDBOT_GATEWAY_TOKEN"] ?? "" - let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) - if !trimmed.isEmpty { - if let configToken = self.resolveConfigToken(isRemote: isRemote, root: root), - !configToken.isEmpty, - configToken != trimmed - { - self.warnEnvOverrideOnce( - kind: .token, - envVar: "CLAWDBOT_GATEWAY_TOKEN", - configKey: isRemote ? "gateway.remote.token" : "gateway.auth.token") - } - return trimmed - } - - if let configToken = self.resolveConfigToken(isRemote: isRemote, root: root), - !configToken.isEmpty - { - return configToken - } - - if isRemote { - return nil - } - - if let token = launchdSnapshot?.token?.trimmingCharacters(in: .whitespacesAndNewlines), - !token.isEmpty - { - return token - } - - return nil - } - - private static func resolveConfigToken(isRemote: Bool, root: [String: Any]) -> String? { - if isRemote { - if let gateway = root["gateway"] as? [String: Any], - let remote = gateway["remote"] as? [String: Any], - let token = remote["token"] as? String - { - return token.trimmingCharacters(in: .whitespacesAndNewlines) - } - return nil - } - - if let gateway = root["gateway"] as? [String: Any], - let auth = gateway["auth"] as? [String: Any], - let token = auth["token"] as? String - { - return token.trimmingCharacters(in: .whitespacesAndNewlines) - } - return nil - } - - private static func warnEnvOverrideOnce( - kind: EnvOverrideWarningKind, - envVar: String, - configKey: String) - { - let shouldWarn = Self.envOverrideWarnings.withValue { state in - switch kind { - case .token: - guard !state.token else { return false } - state.token = true - return true - case .password: - guard !state.password else { return false } - state.password = true - return true - } - } - guard shouldWarn else { return } - Self.staticLogger.warning( - "\(envVar, privacy: .public) is set and overrides \(configKey, privacy: .public). " + - "If this is unintentional, clear it with: launchctl unsetenv \(envVar, privacy: .public)") - } - - private let deps: Deps - private let logger = Logger(subsystem: "com.clawdbot", category: "gateway-endpoint") - - private var state: GatewayEndpointState - private var subscribers: [UUID: AsyncStream.Continuation] = [:] - private var remoteEnsure: (token: UUID, task: Task)? - - init(deps: Deps = .live) { - self.deps = deps - let modeRaw = UserDefaults.standard.string(forKey: connectionModeKey) - let initialMode: AppState.ConnectionMode - if let modeRaw { - initialMode = AppState.ConnectionMode(rawValue: modeRaw) ?? .local - } else { - let seen = UserDefaults.standard.bool(forKey: "moltbot.onboardingSeen") - initialMode = seen ? .local : .unconfigured - } - - let port = deps.localPort() - let bind = GatewayEndpointStore.resolveGatewayBindMode( - root: MoltbotConfigFile.loadDict(), - env: ProcessInfo.processInfo.environment) - let customBindHost = GatewayEndpointStore.resolveGatewayCustomBindHost(root: MoltbotConfigFile.loadDict()) - let scheme = GatewayEndpointStore.resolveGatewayScheme( - root: MoltbotConfigFile.loadDict(), - env: ProcessInfo.processInfo.environment) - let host = GatewayEndpointStore.resolveLocalGatewayHost( - bindMode: bind, - customBindHost: customBindHost, - tailscaleIP: nil) - let token = deps.token() - let password = deps.password() - switch initialMode { - case .local: - self.state = .ready( - mode: .local, - url: URL(string: "\(scheme)://\(host):\(port)")!, - token: token, - password: password) - case .remote: - self.state = .connecting(mode: .remote, detail: Self.remoteConnectingDetail) - Task { await self.setMode(.remote) } - case .unconfigured: - self.state = .unavailable(mode: .unconfigured, reason: "Gateway not configured") - } - } - - func subscribe(bufferingNewest: Int = 1) -> AsyncStream { - let id = UUID() - let initial = self.state - let store = self - return AsyncStream(bufferingPolicy: .bufferingNewest(bufferingNewest)) { continuation in - continuation.yield(initial) - self.subscribers[id] = continuation - continuation.onTermination = { @Sendable _ in - Task { await store.removeSubscriber(id) } - } - } - } - - func refresh() async { - let mode = await self.deps.mode() - await self.setMode(mode) - } - - func setMode(_ mode: AppState.ConnectionMode) async { - let token = self.deps.token() - let password = self.deps.password() - switch mode { - case .local: - self.cancelRemoteEnsure() - let port = self.deps.localPort() - let host = await self.deps.localHost() - let scheme = GatewayEndpointStore.resolveGatewayScheme( - root: MoltbotConfigFile.loadDict(), - env: ProcessInfo.processInfo.environment) - self.setState(.ready( - mode: .local, - url: URL(string: "\(scheme)://\(host):\(port)")!, - token: token, - password: password)) - case .remote: - let root = MoltbotConfigFile.loadDict() - if GatewayRemoteConfig.resolveTransport(root: root) == .direct { - guard let url = GatewayRemoteConfig.resolveGatewayUrl(root: root) else { - self.cancelRemoteEnsure() - self.setState(.unavailable( - mode: .remote, - reason: "gateway.remote.url missing or invalid for direct transport")) - return - } - self.cancelRemoteEnsure() - self.setState(.ready(mode: .remote, url: url, token: token, password: password)) - return - } - let port = await self.deps.remotePortIfRunning() - guard let port else { - self.setState(.connecting(mode: .remote, detail: Self.remoteConnectingDetail)) - self.kickRemoteEnsureIfNeeded(detail: Self.remoteConnectingDetail) - return - } - self.cancelRemoteEnsure() - let scheme = GatewayEndpointStore.resolveGatewayScheme( - root: MoltbotConfigFile.loadDict(), - env: ProcessInfo.processInfo.environment) - self.setState(.ready( - mode: .remote, - url: URL(string: "\(scheme)://127.0.0.1:\(Int(port))")!, - token: token, - password: password)) - case .unconfigured: - self.cancelRemoteEnsure() - self.setState(.unavailable(mode: .unconfigured, reason: "Gateway not configured")) - } - } - - /// Explicit action: ensure the remote control tunnel is established and publish the resolved endpoint. - func ensureRemoteControlTunnel() async throws -> UInt16 { - let mode = await self.deps.mode() - guard mode == .remote else { - throw NSError( - domain: "RemoteTunnel", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "Remote mode is not enabled"]) - } - let root = MoltbotConfigFile.loadDict() - if GatewayRemoteConfig.resolveTransport(root: root) == .direct { - guard let url = GatewayRemoteConfig.resolveGatewayUrl(root: root) else { - throw NSError( - domain: "GatewayEndpoint", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "gateway.remote.url missing or invalid"]) - } - guard let port = GatewayRemoteConfig.defaultPort(for: url), - let portInt = UInt16(exactly: port) - else { - throw NSError( - domain: "GatewayEndpoint", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "Invalid gateway.remote.url port"]) - } - self.logger.info("remote transport direct; skipping SSH tunnel") - return portInt - } - let config = try await self.ensureRemoteConfig(detail: Self.remoteConnectingDetail) - guard let portInt = config.0.port, let port = UInt16(exactly: portInt) else { - throw NSError( - domain: "GatewayEndpoint", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "Missing tunnel port"]) - } - return port - } - - func requireConfig() async throws -> GatewayConnection.Config { - await self.refresh() - switch self.state { - case let .ready(_, url, token, password): - return (url, token, password) - case let .connecting(mode, _): - guard mode == .remote else { - throw NSError(domain: "GatewayEndpoint", code: 1, userInfo: [NSLocalizedDescriptionKey: "Connecting…"]) - } - return try await self.ensureRemoteConfig(detail: Self.remoteConnectingDetail) - case let .unavailable(mode, reason): - guard mode == .remote else { - throw NSError(domain: "GatewayEndpoint", code: 1, userInfo: [NSLocalizedDescriptionKey: reason]) - } - - // Auto-recover for remote mode: if the SSH control tunnel died (or hasn't been created yet), - // recreate it on demand so callers can recover without a manual reconnect. - self.logger.info( - "endpoint unavailable; ensuring remote control tunnel reason=\(reason, privacy: .public)") - return try await self.ensureRemoteConfig(detail: Self.remoteConnectingDetail) - } - } - - private func cancelRemoteEnsure() { - self.remoteEnsure?.task.cancel() - self.remoteEnsure = nil - } - - private func kickRemoteEnsureIfNeeded(detail: String) { - if self.remoteEnsure != nil { - self.setState(.connecting(mode: .remote, detail: detail)) - return - } - - let deps = self.deps - let token = UUID() - let task = Task.detached(priority: .utility) { try await deps.ensureRemoteTunnel() } - self.remoteEnsure = (token: token, task: task) - self.setState(.connecting(mode: .remote, detail: detail)) - } - - private func ensureRemoteConfig(detail: String) async throws -> GatewayConnection.Config { - let mode = await self.deps.mode() - guard mode == .remote else { - throw NSError( - domain: "RemoteTunnel", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "Remote mode is not enabled"]) - } - - let root = MoltbotConfigFile.loadDict() - if GatewayRemoteConfig.resolveTransport(root: root) == .direct { - guard let url = GatewayRemoteConfig.resolveGatewayUrl(root: root) else { - throw NSError( - domain: "GatewayEndpoint", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "gateway.remote.url missing or invalid"]) - } - let token = self.deps.token() - let password = self.deps.password() - self.cancelRemoteEnsure() - self.setState(.ready(mode: .remote, url: url, token: token, password: password)) - return (url, token, password) - } - - self.kickRemoteEnsureIfNeeded(detail: detail) - guard let ensure = self.remoteEnsure else { - throw NSError(domain: "GatewayEndpoint", code: 1, userInfo: [NSLocalizedDescriptionKey: "Connecting…"]) - } - - do { - let forwarded = try await ensure.task.value - let stillRemote = await self.deps.mode() == .remote - guard stillRemote else { - throw NSError( - domain: "RemoteTunnel", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "Remote mode is not enabled"]) - } - - if self.remoteEnsure?.token == ensure.token { - self.remoteEnsure = nil - } - - let token = self.deps.token() - let password = self.deps.password() - let scheme = GatewayEndpointStore.resolveGatewayScheme( - root: MoltbotConfigFile.loadDict(), - env: ProcessInfo.processInfo.environment) - let url = URL(string: "\(scheme)://127.0.0.1:\(Int(forwarded))")! - self.setState(.ready(mode: .remote, url: url, token: token, password: password)) - return (url, token, password) - } catch let err as CancellationError { - if self.remoteEnsure?.token == ensure.token { - self.remoteEnsure = nil - } - throw err - } catch { - if self.remoteEnsure?.token == ensure.token { - self.remoteEnsure = nil - } - let msg = "Remote control tunnel failed (\(error.localizedDescription))" - self.setState(.unavailable(mode: .remote, reason: msg)) - self.logger.error("remote control tunnel ensure failed \(msg, privacy: .public)") - throw NSError(domain: "GatewayEndpoint", code: 1, userInfo: [NSLocalizedDescriptionKey: msg]) - } - } - - private func removeSubscriber(_ id: UUID) { - self.subscribers[id] = nil - } - - private func setState(_ next: GatewayEndpointState) { - guard next != self.state else { return } - self.state = next - for (_, continuation) in self.subscribers { - continuation.yield(next) - } - switch next { - case let .ready(mode, url, _, _): - let modeDesc = String(describing: mode) - let urlDesc = url.absoluteString - self.logger - .debug( - "resolved endpoint mode=\(modeDesc, privacy: .public) url=\(urlDesc, privacy: .public)") - case let .connecting(mode, detail): - let modeDesc = String(describing: mode) - self.logger - .debug( - "endpoint connecting mode=\(modeDesc, privacy: .public) detail=\(detail, privacy: .public)") - case let .unavailable(mode, reason): - let modeDesc = String(describing: mode) - self.logger - .debug( - "endpoint unavailable mode=\(modeDesc, privacy: .public) reason=\(reason, privacy: .public)") - } - } - - func maybeFallbackToTailnet(from currentURL: URL) async -> GatewayConnection.Config? { - let mode = await self.deps.mode() - guard mode == .local else { return nil } - - let root = MoltbotConfigFile.loadDict() - let bind = GatewayEndpointStore.resolveGatewayBindMode( - root: root, - env: ProcessInfo.processInfo.environment) - guard bind == "tailnet" else { return nil } - - let currentHost = currentURL.host?.lowercased() ?? "" - guard currentHost == "127.0.0.1" || currentHost == "localhost" else { return nil } - - let tailscaleIP = await MainActor.run { TailscaleService.shared.tailscaleIP } - ?? TailscaleService.fallbackTailnetIPv4() - guard let tailscaleIP, !tailscaleIP.isEmpty else { return nil } - - let scheme = GatewayEndpointStore.resolveGatewayScheme( - root: root, - env: ProcessInfo.processInfo.environment) - let port = self.deps.localPort() - let token = self.deps.token() - let password = self.deps.password() - let url = URL(string: "\(scheme)://\(tailscaleIP):\(port)")! - - self.logger.info("auto bind fallback to tailnet host=\(tailscaleIP, privacy: .public)") - self.setState(.ready(mode: .local, url: url, token: token, password: password)) - return (url, token, password) - } - - private static func resolveGatewayBindMode( - root: [String: Any], - env: [String: String]) -> String? - { - if let envBind = env["CLAWDBOT_GATEWAY_BIND"] { - let trimmed = envBind.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() - if self.supportedBindModes.contains(trimmed) { - return trimmed - } - } - if let gateway = root["gateway"] as? [String: Any], - let bind = gateway["bind"] as? String - { - let trimmed = bind.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() - if self.supportedBindModes.contains(trimmed) { - return trimmed - } - } - return nil - } - - private static func resolveGatewayCustomBindHost(root: [String: Any]) -> String? { - if let gateway = root["gateway"] as? [String: Any], - let customBindHost = gateway["customBindHost"] as? String - { - let trimmed = customBindHost.trimmingCharacters(in: .whitespacesAndNewlines) - return trimmed.isEmpty ? nil : trimmed - } - return nil - } - - private static func resolveGatewayScheme( - root: [String: Any], - env: [String: String]) -> String - { - if let envValue = env["CLAWDBOT_GATEWAY_TLS"]?.trimmingCharacters(in: .whitespacesAndNewlines), - !envValue.isEmpty - { - return (envValue == "1" || envValue.lowercased() == "true") ? "wss" : "ws" - } - if let gateway = root["gateway"] as? [String: Any], - let tls = gateway["tls"] as? [String: Any], - let enabled = tls["enabled"] as? Bool - { - return enabled ? "wss" : "ws" - } - return "ws" - } - - private static func resolveLocalGatewayHost( - bindMode: String?, - customBindHost: String?, - tailscaleIP: String?) -> String - { - switch bindMode { - case "tailnet": - tailscaleIP ?? "127.0.0.1" - case "auto": - "127.0.0.1" - case "custom": - customBindHost ?? "127.0.0.1" - default: - "127.0.0.1" - } - } -} - -extension GatewayEndpointStore { - static func dashboardURL(for config: GatewayConnection.Config) throws -> URL { - guard var components = URLComponents(url: config.url, resolvingAgainstBaseURL: false) else { - throw NSError(domain: "Dashboard", code: 1, userInfo: [ - NSLocalizedDescriptionKey: "Invalid gateway URL", - ]) - } - switch components.scheme?.lowercased() { - case "ws": - components.scheme = "http" - case "wss": - components.scheme = "https" - default: - components.scheme = "http" - } - components.path = "/" - var queryItems: [URLQueryItem] = [] - if let token = config.token?.trimmingCharacters(in: .whitespacesAndNewlines), - !token.isEmpty - { - queryItems.append(URLQueryItem(name: "token", value: token)) - } - if let password = config.password?.trimmingCharacters(in: .whitespacesAndNewlines), - !password.isEmpty - { - queryItems.append(URLQueryItem(name: "password", value: password)) - } - components.queryItems = queryItems.isEmpty ? nil : queryItems - guard let url = components.url else { - throw NSError(domain: "Dashboard", code: 2, userInfo: [ - NSLocalizedDescriptionKey: "Failed to build dashboard URL", - ]) - } - return url - } -} - -#if DEBUG -extension GatewayEndpointStore { - static func _testResolveGatewayPassword( - isRemote: Bool, - root: [String: Any], - env: [String: String], - launchdSnapshot: LaunchAgentPlistSnapshot? = nil) -> String? - { - self.resolveGatewayPassword(isRemote: isRemote, root: root, env: env, launchdSnapshot: launchdSnapshot) - } - - static func _testResolveGatewayToken( - isRemote: Bool, - root: [String: Any], - env: [String: String], - launchdSnapshot: LaunchAgentPlistSnapshot? = nil) -> String? - { - self.resolveGatewayToken(isRemote: isRemote, root: root, env: env, launchdSnapshot: launchdSnapshot) - } - - static func _testResolveGatewayBindMode( - root: [String: Any], - env: [String: String]) -> String? - { - self.resolveGatewayBindMode(root: root, env: env) - } - - static func _testResolveLocalGatewayHost( - bindMode: String?, - tailscaleIP: String?, - customBindHost: String? = nil) -> String - { - self.resolveLocalGatewayHost( - bindMode: bindMode, - customBindHost: customBindHost, - tailscaleIP: tailscaleIP) - } -} -#endif diff --git a/apps/macos/Sources/Clawdbot/GatewayEnvironment.swift b/apps/macos/Sources/Clawdbot/GatewayEnvironment.swift deleted file mode 100644 index ff92f308c..000000000 --- a/apps/macos/Sources/Clawdbot/GatewayEnvironment.swift +++ /dev/null @@ -1,342 +0,0 @@ -import MoltbotIPC -import Foundation -import OSLog - -// Lightweight SemVer helper (major.minor.patch only) for gateway compatibility checks. -struct Semver: Comparable, CustomStringConvertible, Sendable { - let major: Int - let minor: Int - let patch: Int - - var description: String { "\(self.major).\(self.minor).\(self.patch)" } - - static func < (lhs: Semver, rhs: Semver) -> Bool { - if lhs.major != rhs.major { return lhs.major < rhs.major } - if lhs.minor != rhs.minor { return lhs.minor < rhs.minor } - return lhs.patch < rhs.patch - } - - static func parse(_ raw: String?) -> Semver? { - guard let raw, !raw.isEmpty else { return nil } - let cleaned = raw.trimmingCharacters(in: .whitespacesAndNewlines) - .replacingOccurrences(of: "^v", with: "", options: .regularExpression) - let parts = cleaned.split(separator: ".") - guard parts.count >= 3, - let major = Int(parts[0]), - let minor = Int(parts[1]) - else { return nil } - // Strip prerelease suffix (e.g., "11-4" → "11", "5-beta.1" → "5") - let patchRaw = String(parts[2]) - guard let patchToken = patchRaw.split(whereSeparator: { $0 == "-" || $0 == "+" }).first, - let patchNumeric = Int(patchToken) - else { - return nil - } - return Semver(major: major, minor: minor, patch: patchNumeric) - } - - func compatible(with required: Semver) -> Bool { - // Same major and not older than required. - self.major == required.major && self >= required - } -} - -enum GatewayEnvironmentKind: Equatable { - case checking - case ok - case missingNode - case missingGateway - case incompatible(found: String, required: String) - case error(String) -} - -struct GatewayEnvironmentStatus: Equatable { - let kind: GatewayEnvironmentKind - let nodeVersion: String? - let gatewayVersion: String? - let requiredGateway: String? - let message: String - - static var checking: Self { - .init(kind: .checking, nodeVersion: nil, gatewayVersion: nil, requiredGateway: nil, message: "Checking…") - } -} - -struct GatewayCommandResolution { - let status: GatewayEnvironmentStatus - let command: [String]? -} - -enum GatewayEnvironment { - private static let logger = Logger(subsystem: "com.clawdbot", category: "gateway.env") - private static let supportedBindModes: Set = ["loopback", "tailnet", "lan", "auto"] - - static func gatewayPort() -> Int { - if let raw = ProcessInfo.processInfo.environment["CLAWDBOT_GATEWAY_PORT"] { - let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) - if let parsed = Int(trimmed), parsed > 0 { return parsed } - } - if let configPort = MoltbotConfigFile.gatewayPort(), configPort > 0 { - return configPort - } - let stored = UserDefaults.standard.integer(forKey: "gatewayPort") - return stored > 0 ? stored : 18789 - } - - static func expectedGatewayVersion() -> Semver? { - Semver.parse(self.expectedGatewayVersionString()) - } - - static func expectedGatewayVersionString() -> String? { - let bundleVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String - let trimmed = bundleVersion?.trimmingCharacters(in: .whitespacesAndNewlines) - return (trimmed?.isEmpty == false) ? trimmed : nil - } - - // Exposed for tests so we can inject fake version checks without rewriting bundle metadata. - static func expectedGatewayVersion(from versionString: String?) -> Semver? { - Semver.parse(versionString) - } - - static func check() -> GatewayEnvironmentStatus { - let start = Date() - defer { - let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) - if elapsedMs > 500 { - self.logger.warning("gateway env check slow (\(elapsedMs, privacy: .public)ms)") - } else { - self.logger.debug("gateway env check ok (\(elapsedMs, privacy: .public)ms)") - } - } - let expected = self.expectedGatewayVersion() - let expectedString = self.expectedGatewayVersionString() - - let projectRoot = CommandResolver.projectRoot() - let projectEntrypoint = CommandResolver.gatewayEntrypoint(in: projectRoot) - - switch RuntimeLocator.resolve(searchPaths: CommandResolver.preferredPaths()) { - case let .failure(err): - return GatewayEnvironmentStatus( - kind: .missingNode, - nodeVersion: nil, - gatewayVersion: nil, - requiredGateway: expectedString, - message: RuntimeLocator.describeFailure(err)) - case let .success(runtime): - let gatewayBin = CommandResolver.clawdbotExecutable() - - if gatewayBin == nil, projectEntrypoint == nil { - return GatewayEnvironmentStatus( - kind: .missingGateway, - nodeVersion: runtime.version.description, - gatewayVersion: nil, - requiredGateway: expectedString, - message: "moltbot CLI not found in PATH; install the CLI.") - } - - let installed = gatewayBin.flatMap { self.readGatewayVersion(binary: $0) } - ?? self.readLocalGatewayVersion(projectRoot: projectRoot) - - if let expected, let installed, !installed.compatible(with: expected) { - let expectedText = expectedString ?? expected.description - return GatewayEnvironmentStatus( - kind: .incompatible(found: installed.description, required: expectedText), - nodeVersion: runtime.version.description, - gatewayVersion: installed.description, - requiredGateway: expectedText, - message: """ - Gateway version \(installed.description) is incompatible with app \(expectedText); - install or update the global package. - """) - } - - let gatewayLabel = gatewayBin != nil ? "global" : "local" - let gatewayVersionText = installed?.description ?? "unknown" - // Avoid repeating "(local)" twice; if using the local entrypoint, show the path once. - let localPathHint = gatewayBin == nil && projectEntrypoint != nil - ? " (local: \(projectEntrypoint ?? "unknown"))" - : "" - let gatewayLabelText = gatewayBin != nil - ? "(\(gatewayLabel))" - : localPathHint.isEmpty ? "(\(gatewayLabel))" : localPathHint - return GatewayEnvironmentStatus( - kind: .ok, - nodeVersion: runtime.version.description, - gatewayVersion: gatewayVersionText, - requiredGateway: expectedString, - message: "Node \(runtime.version.description); gateway \(gatewayVersionText) \(gatewayLabelText)") - } - } - - static func resolveGatewayCommand() -> GatewayCommandResolution { - let start = Date() - defer { - let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) - if elapsedMs > 500 { - self.logger.warning("gateway command resolve slow (\(elapsedMs, privacy: .public)ms)") - } else { - self.logger.debug("gateway command resolve ok (\(elapsedMs, privacy: .public)ms)") - } - } - let projectRoot = CommandResolver.projectRoot() - let projectEntrypoint = CommandResolver.gatewayEntrypoint(in: projectRoot) - let status = self.check() - let gatewayBin = CommandResolver.clawdbotExecutable() - let runtime = RuntimeLocator.resolve(searchPaths: CommandResolver.preferredPaths()) - - guard case .ok = status.kind else { - return GatewayCommandResolution(status: status, command: nil) - } - - let port = self.gatewayPort() - if let gatewayBin { - let bind = self.preferredGatewayBind() ?? "loopback" - let cmd = [gatewayBin, "gateway-daemon", "--port", "\(port)", "--bind", bind] - return GatewayCommandResolution(status: status, command: cmd) - } - - if let entry = projectEntrypoint, - case let .success(resolvedRuntime) = runtime - { - let bind = self.preferredGatewayBind() ?? "loopback" - let cmd = [resolvedRuntime.path, entry, "gateway-daemon", "--port", "\(port)", "--bind", bind] - return GatewayCommandResolution(status: status, command: cmd) - } - - return GatewayCommandResolution(status: status, command: nil) - } - - private static func preferredGatewayBind() -> String? { - if CommandResolver.connectionModeIsRemote() { - return nil - } - if let env = ProcessInfo.processInfo.environment["CLAWDBOT_GATEWAY_BIND"] { - let trimmed = env.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() - if self.supportedBindModes.contains(trimmed) { - return trimmed - } - } - - let root = MoltbotConfigFile.loadDict() - if let gateway = root["gateway"] as? [String: Any], - let bind = gateway["bind"] as? String - { - let trimmed = bind.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() - if self.supportedBindModes.contains(trimmed) { - return trimmed - } - } - - return nil - } - - static func installGlobal(version: Semver?, statusHandler: @escaping @Sendable (String) -> Void) async { - await self.installGlobal(versionString: version?.description, statusHandler: statusHandler) - } - - static func installGlobal(versionString: String?, statusHandler: @escaping @Sendable (String) -> Void) async { - let preferred = CommandResolver.preferredPaths().joined(separator: ":") - let trimmed = versionString?.trimmingCharacters(in: .whitespacesAndNewlines) - let target: String = if let trimmed, !trimmed.isEmpty { - trimmed - } else { - "latest" - } - let npm = CommandResolver.findExecutable(named: "npm") - let pnpm = CommandResolver.findExecutable(named: "pnpm") - let bun = CommandResolver.findExecutable(named: "bun") - let (label, cmd): (String, [String]) = - if let npm { - ("npm", [npm, "install", "-g", "moltbot@\(target)"]) - } else if let pnpm { - ("pnpm", [pnpm, "add", "-g", "moltbot@\(target)"]) - } else if let bun { - ("bun", [bun, "add", "-g", "moltbot@\(target)"]) - } else { - ("npm", ["npm", "install", "-g", "moltbot@\(target)"]) - } - - statusHandler("Installing moltbot@\(target) via \(label)…") - - func summarize(_ text: String) -> String? { - let lines = text - .split(whereSeparator: \.isNewline) - .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) } - .filter { !$0.isEmpty } - guard let last = lines.last else { return nil } - let normalized = last.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression) - return normalized.count > 200 ? String(normalized.prefix(199)) + "…" : normalized - } - - let response = await ShellExecutor.runDetailed(command: cmd, cwd: nil, env: ["PATH": preferred], timeout: 300) - if response.success { - statusHandler("Installed moltbot@\(target)") - } else { - if response.timedOut { - statusHandler("Install failed: timed out. Check your internet connection and try again.") - return - } - - let exit = response.exitCode.map { "exit \($0)" } ?? (response.errorMessage ?? "failed") - let detail = summarize(response.stderr) ?? summarize(response.stdout) - if let detail { - statusHandler("Install failed (\(exit)): \(detail)") - } else { - statusHandler("Install failed (\(exit))") - } - } - } - - // MARK: - Internals - - private static func readGatewayVersion(binary: String) -> Semver? { - let start = Date() - let process = Process() - process.executableURL = URL(fileURLWithPath: binary) - process.arguments = ["--version"] - process.environment = ["PATH": CommandResolver.preferredPaths().joined(separator: ":")] - - let pipe = Pipe() - process.standardOutput = pipe - process.standardError = pipe - do { - let data = try process.runAndReadToEnd(from: pipe) - let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) - if elapsedMs > 500 { - self.logger.warning( - """ - gateway --version slow (\(elapsedMs, privacy: .public)ms) \ - bin=\(binary, privacy: .public) - """) - } else { - self.logger.debug( - """ - gateway --version ok (\(elapsedMs, privacy: .public)ms) \ - bin=\(binary, privacy: .public) - """) - } - let raw = String(data: data, encoding: .utf8)? - .trimmingCharacters(in: .whitespacesAndNewlines) - return Semver.parse(raw) - } catch { - let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) - self.logger.error( - """ - gateway --version failed (\(elapsedMs, privacy: .public)ms) \ - bin=\(binary, privacy: .public) \ - err=\(error.localizedDescription, privacy: .public) - """) - return nil - } - } - - private static func readLocalGatewayVersion(projectRoot: URL) -> Semver? { - let pkg = projectRoot.appendingPathComponent("package.json") - guard let data = try? Data(contentsOf: pkg) else { return nil } - guard - let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any], - let version = json["version"] as? String - else { return nil } - return Semver.parse(version) - } -} diff --git a/apps/macos/Sources/Clawdbot/GatewayLaunchAgentManager.swift b/apps/macos/Sources/Clawdbot/GatewayLaunchAgentManager.swift deleted file mode 100644 index f0896e691..000000000 --- a/apps/macos/Sources/Clawdbot/GatewayLaunchAgentManager.swift +++ /dev/null @@ -1,203 +0,0 @@ -import Foundation - -enum GatewayLaunchAgentManager { - private static let logger = Logger(subsystem: "com.clawdbot", category: "gateway.launchd") - private static let disableLaunchAgentMarker = ".clawdbot/disable-launchagent" - - private static var disableLaunchAgentMarkerURL: URL { - FileManager().homeDirectoryForCurrentUser - .appendingPathComponent(self.disableLaunchAgentMarker) - } - - private static var plistURL: URL { - FileManager().homeDirectoryForCurrentUser - .appendingPathComponent("Library/LaunchAgents/\(gatewayLaunchdLabel).plist") - } - - static func isLaunchAgentWriteDisabled() -> Bool { - FileManager().fileExists(atPath: self.disableLaunchAgentMarkerURL.path) - } - - static func setLaunchAgentWriteDisabled(_ disabled: Bool) -> String? { - let marker = self.disableLaunchAgentMarkerURL - if disabled { - do { - try FileManager().createDirectory( - at: marker.deletingLastPathComponent(), - withIntermediateDirectories: true) - if !FileManager().fileExists(atPath: marker.path) { - FileManager().createFile(atPath: marker.path, contents: nil) - } - } catch { - return error.localizedDescription - } - return nil - } - - if FileManager().fileExists(atPath: marker.path) { - do { - try FileManager().removeItem(at: marker) - } catch { - return error.localizedDescription - } - } - return nil - } - - static func isLoaded() async -> Bool { - guard let loaded = await self.readDaemonLoaded() else { return false } - return loaded - } - - static func set(enabled: Bool, bundlePath: String, port: Int) async -> String? { - _ = bundlePath - guard !CommandResolver.connectionModeIsRemote() else { - self.logger.info("launchd change skipped (remote mode)") - return nil - } - if enabled, self.isLaunchAgentWriteDisabled() { - self.logger.info("launchd enable skipped (disable marker set)") - return nil - } - - if enabled { - self.logger.info("launchd enable requested via CLI port=\(port)") - return await self.runDaemonCommand([ - "install", - "--force", - "--port", - "\(port)", - "--runtime", - "node", - ]) - } - - self.logger.info("launchd disable requested via CLI") - return await self.runDaemonCommand(["uninstall"]) - } - - static func kickstart() async { - _ = await self.runDaemonCommand(["restart"], timeout: 20) - } - - static func launchdConfigSnapshot() -> LaunchAgentPlistSnapshot? { - LaunchAgentPlist.snapshot(url: self.plistURL) - } - - static func launchdGatewayLogPath() -> String { - let snapshot = self.launchdConfigSnapshot() - if let stdout = snapshot?.stdoutPath?.trimmingCharacters(in: .whitespacesAndNewlines), - !stdout.isEmpty - { - return stdout - } - if let stderr = snapshot?.stderrPath?.trimmingCharacters(in: .whitespacesAndNewlines), - !stderr.isEmpty - { - return stderr - } - return LogLocator.launchdGatewayLogPath - } -} - -extension GatewayLaunchAgentManager { - private static func readDaemonLoaded() async -> Bool? { - let result = await self.runDaemonCommandResult( - ["status", "--json", "--no-probe"], - timeout: 15, - quiet: true) - guard result.success, let payload = result.payload else { return nil } - guard - let json = try? JSONSerialization.jsonObject(with: payload) as? [String: Any], - let service = json["service"] as? [String: Any], - let loaded = service["loaded"] as? Bool - else { - return nil - } - return loaded - } - - private struct CommandResult { - let success: Bool - let payload: Data? - let message: String? - } - - private struct ParsedDaemonJson { - let text: String - let object: [String: Any] - } - - private static func runDaemonCommand( - _ args: [String], - timeout: Double = 15, - quiet: Bool = false) async -> String? - { - let result = await self.runDaemonCommandResult(args, timeout: timeout, quiet: quiet) - if result.success { return nil } - return result.message ?? "Gateway daemon command failed" - } - - private static func runDaemonCommandResult( - _ args: [String], - timeout: Double, - quiet: Bool) async -> CommandResult - { - let command = CommandResolver.clawdbotCommand( - subcommand: "gateway", - extraArgs: self.withJsonFlag(args), - // Launchd management must always run locally, even if remote mode is configured. - configRoot: ["gateway": ["mode": "local"]]) - var env = ProcessInfo.processInfo.environment - env["PATH"] = CommandResolver.preferredPaths().joined(separator: ":") - let response = await ShellExecutor.runDetailed(command: command, cwd: nil, env: env, timeout: timeout) - let parsed = self.parseDaemonJson(from: response.stdout) ?? self.parseDaemonJson(from: response.stderr) - let ok = parsed?.object["ok"] as? Bool - let message = (parsed?.object["error"] as? String) ?? (parsed?.object["message"] as? String) - let payload = parsed?.text.data(using: .utf8) - ?? (response.stdout.isEmpty ? response.stderr : response.stdout).data(using: .utf8) - let success = ok ?? response.success - if success { - return CommandResult(success: true, payload: payload, message: nil) - } - - if quiet { - return CommandResult(success: false, payload: payload, message: message) - } - - let detail = message ?? self.summarize(response.stderr) ?? self.summarize(response.stdout) - let exit = response.exitCode.map { "exit \($0)" } ?? (response.errorMessage ?? "failed") - let fullMessage = detail.map { "Gateway daemon command failed (\(exit)): \($0)" } - ?? "Gateway daemon command failed (\(exit))" - self.logger.error("\(fullMessage, privacy: .public)") - return CommandResult(success: false, payload: payload, message: detail) - } - - private static func withJsonFlag(_ args: [String]) -> [String] { - if args.contains("--json") { return args } - return args + ["--json"] - } - - private static func parseDaemonJson(from raw: String) -> ParsedDaemonJson? { - let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) - guard let start = trimmed.firstIndex(of: "{"), - let end = trimmed.lastIndex(of: "}") - else { - return nil - } - let jsonText = String(trimmed[start...end]) - guard let data = jsonText.data(using: .utf8) else { return nil } - guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil } - return ParsedDaemonJson(text: jsonText, object: object) - } - - private static func summarize(_ text: String) -> String? { - let lines = text - .split(whereSeparator: \.isNewline) - .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) } - .filter { !$0.isEmpty } - guard let last = lines.last else { return nil } - let normalized = last.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression) - return normalized.count > 200 ? String(normalized.prefix(199)) + "…" : normalized - } -} diff --git a/apps/macos/Sources/Clawdbot/GatewayProcessManager.swift b/apps/macos/Sources/Clawdbot/GatewayProcessManager.swift deleted file mode 100644 index 60964fa39..000000000 --- a/apps/macos/Sources/Clawdbot/GatewayProcessManager.swift +++ /dev/null @@ -1,432 +0,0 @@ -import Foundation -import Observation - -@MainActor -@Observable -final class GatewayProcessManager { - static let shared = GatewayProcessManager() - - enum Status: Equatable { - case stopped - case starting - case running(details: String?) - case attachedExisting(details: String?) - case failed(String) - - var label: String { - switch self { - case .stopped: return "Stopped" - case .starting: return "Starting…" - case let .running(details): - if let details, !details.isEmpty { return "Running (\(details))" } - return "Running" - case let .attachedExisting(details): - if let details, !details.isEmpty { - return "Using existing gateway (\(details))" - } - return "Using existing gateway" - case let .failed(reason): return "Failed: \(reason)" - } - } - } - - private(set) var status: Status = .stopped { - didSet { CanvasManager.shared.refreshDebugStatus() } - } - - private(set) var log: String = "" - private(set) var environmentStatus: GatewayEnvironmentStatus = .checking - private(set) var existingGatewayDetails: String? - private(set) var lastFailureReason: String? - private var desiredActive = false - private var environmentRefreshTask: Task? - private var lastEnvironmentRefresh: Date? - private var logRefreshTask: Task? - #if DEBUG - private var testingConnection: GatewayConnection? - #endif - private let logger = Logger(subsystem: "com.clawdbot", category: "gateway.process") - - private let logLimit = 20000 // characters to keep in-memory - private let environmentRefreshMinInterval: TimeInterval = 30 - private var connection: GatewayConnection { - #if DEBUG - return self.testingConnection ?? .shared - #else - return .shared - #endif - } - - func setActive(_ active: Bool) { - // Remote mode should never spawn a local gateway; treat as stopped. - if CommandResolver.connectionModeIsRemote() { - self.desiredActive = false - self.stop() - self.status = .stopped - self.appendLog("[gateway] remote mode active; skipping local gateway\n") - self.logger.info("gateway process skipped: remote mode active") - return - } - self.logger.debug("gateway active requested active=\(active)") - self.desiredActive = active - self.refreshEnvironmentStatus() - if active { - self.startIfNeeded() - } else { - self.stop() - } - } - - func ensureLaunchAgentEnabledIfNeeded() async { - guard !CommandResolver.connectionModeIsRemote() else { return } - if GatewayLaunchAgentManager.isLaunchAgentWriteDisabled() { - self.appendLog("[gateway] launchd auto-enable skipped (attach-only)\n") - self.logger.info("gateway launchd auto-enable skipped (disable marker set)") - return - } - let enabled = await GatewayLaunchAgentManager.isLoaded() - guard !enabled else { return } - let bundlePath = Bundle.main.bundleURL.path - let port = GatewayEnvironment.gatewayPort() - self.appendLog("[gateway] auto-enabling launchd job (\(gatewayLaunchdLabel)) on port \(port)\n") - let err = await GatewayLaunchAgentManager.set(enabled: true, bundlePath: bundlePath, port: port) - if let err { - self.appendLog("[gateway] launchd auto-enable failed: \(err)\n") - } - } - - func startIfNeeded() { - guard self.desiredActive else { return } - // Do not spawn in remote mode (the gateway should run on the remote host). - guard !CommandResolver.connectionModeIsRemote() else { - self.status = .stopped - return - } - // Many surfaces can call `setActive(true)` in quick succession (startup, Canvas, health checks). - // Avoid spawning multiple concurrent "start" tasks that can thrash launchd and flap the port. - switch self.status { - case .starting, .running, .attachedExisting: - return - case .stopped, .failed: - break - } - self.status = .starting - self.logger.debug("gateway start requested") - - // First try to latch onto an already-running gateway to avoid spawning a duplicate. - Task { [weak self] in - guard let self else { return } - if await self.attachExistingGatewayIfAvailable() { - return - } - await self.enableLaunchdGateway() - } - } - - func stop() { - self.desiredActive = false - self.existingGatewayDetails = nil - self.lastFailureReason = nil - self.status = .stopped - self.logger.info("gateway stop requested") - if CommandResolver.connectionModeIsRemote() { - return - } - let bundlePath = Bundle.main.bundleURL.path - Task { - _ = await GatewayLaunchAgentManager.set( - enabled: false, - bundlePath: bundlePath, - port: GatewayEnvironment.gatewayPort()) - } - } - - func clearLastFailure() { - self.lastFailureReason = nil - } - - func refreshEnvironmentStatus(force: Bool = false) { - let now = Date() - if !force { - if self.environmentRefreshTask != nil { return } - if let last = self.lastEnvironmentRefresh, - now.timeIntervalSince(last) < self.environmentRefreshMinInterval - { - return - } - } - self.lastEnvironmentRefresh = now - self.environmentRefreshTask = Task { [weak self] in - let status = await Task.detached(priority: .utility) { - GatewayEnvironment.check() - }.value - await MainActor.run { - guard let self else { return } - self.environmentStatus = status - self.environmentRefreshTask = nil - } - } - } - - func refreshLog() { - guard self.logRefreshTask == nil else { return } - let path = GatewayLaunchAgentManager.launchdGatewayLogPath() - let limit = self.logLimit - self.logRefreshTask = Task { [weak self] in - let log = await Task.detached(priority: .utility) { - Self.readGatewayLog(path: path, limit: limit) - }.value - await MainActor.run { - guard let self else { return } - if !log.isEmpty { - self.log = log - } - self.logRefreshTask = nil - } - } - } - - // MARK: - Internals - - /// Attempt to connect to an already-running gateway on the configured port. - /// If successful, mark status as attached and skip spawning a new process. - private func attachExistingGatewayIfAvailable() async -> Bool { - let port = GatewayEnvironment.gatewayPort() - let instance = await PortGuardian.shared.describe(port: port) - let instanceText = instance.map { self.describe(instance: $0) } - let hasListener = instance != nil - - let attemptAttach = { - try await self.connection.requestRaw(method: .health, timeoutMs: 2000) - } - - for attempt in 0..<(hasListener ? 3 : 1) { - do { - let data = try await attemptAttach() - let snap = decodeHealthSnapshot(from: data) - let details = self.describe(details: instanceText, port: port, snap: snap) - self.existingGatewayDetails = details - self.clearLastFailure() - self.status = .attachedExisting(details: details) - self.appendLog("[gateway] using existing instance: \(details)\n") - self.logger.info("gateway using existing instance details=\(details)") - self.refreshControlChannelIfNeeded(reason: "attach existing") - self.refreshLog() - return true - } catch { - if attempt < 2, hasListener { - try? await Task.sleep(nanoseconds: 250_000_000) - continue - } - - if hasListener { - let reason = self.describeAttachFailure(error, port: port, instance: instance) - self.existingGatewayDetails = instanceText - self.status = .failed(reason) - self.lastFailureReason = reason - self.appendLog("[gateway] existing listener on port \(port) but attach failed: \(reason)\n") - self.logger.warning("gateway attach failed reason=\(reason)") - return true - } - - // No reachable gateway (and no listener) — fall through to spawn. - self.existingGatewayDetails = nil - return false - } - } - - self.existingGatewayDetails = nil - return false - } - - private func describe(details instance: String?, port: Int, snap: HealthSnapshot?) -> String { - let instanceText = instance ?? "pid unknown" - if let snap { - let order = snap.channelOrder ?? Array(snap.channels.keys) - let linkId = order.first(where: { snap.channels[$0]?.linked == true }) - ?? order.first(where: { snap.channels[$0]?.linked != nil }) - guard let linkId else { - return "port \(port), health probe succeeded, \(instanceText)" - } - let linked = snap.channels[linkId]?.linked ?? false - let authAge = snap.channels[linkId]?.authAgeMs.flatMap(msToAge) ?? "unknown age" - let label = - snap.channelLabels?[linkId] ?? - linkId.capitalized - let linkText = linked ? "linked" : "not linked" - return "port \(port), \(label) \(linkText), auth \(authAge), \(instanceText)" - } - return "port \(port), health probe succeeded, \(instanceText)" - } - - private func describe(instance: PortGuardian.Descriptor) -> String { - let path = instance.executablePath ?? "path unknown" - return "pid \(instance.pid) \(instance.command) @ \(path)" - } - - private func describeAttachFailure(_ error: Error, port: Int, instance: PortGuardian.Descriptor?) -> String { - let ns = error as NSError - let message = ns.localizedDescription.isEmpty ? "unknown error" : ns.localizedDescription - let lower = message.lowercased() - if self.isGatewayAuthFailure(error) { - return """ - Gateway on port \(port) rejected auth. Set gateway.auth.token (or CLAWDBOT_GATEWAY_TOKEN) \ - to match the running gateway (or clear it on the gateway) and retry. - """ - } - if lower.contains("protocol mismatch") { - return "Gateway on port \(port) is incompatible (protocol mismatch). Update the app/gateway." - } - if lower.contains("unexpected response") || lower.contains("invalid response") { - return "Port \(port) returned non-gateway data; another process is using it." - } - if let instance { - let instanceText = self.describe(instance: instance) - return "Gateway listener found on port \(port) (\(instanceText)) but health check failed: \(message)" - } - return "Gateway listener found on port \(port) but health check failed: \(message)" - } - - private func isGatewayAuthFailure(_ error: Error) -> Bool { - if let urlError = error as? URLError, urlError.code == .dataNotAllowed { - return true - } - let ns = error as NSError - if ns.domain == "Gateway", ns.code == 1008 { return true } - let lower = ns.localizedDescription.lowercased() - return lower.contains("unauthorized") || lower.contains("auth") - } - - private func enableLaunchdGateway() async { - self.existingGatewayDetails = nil - let resolution = await Task.detached(priority: .utility) { - GatewayEnvironment.resolveGatewayCommand() - }.value - await MainActor.run { self.environmentStatus = resolution.status } - guard resolution.command != nil else { - await MainActor.run { - self.status = .failed(resolution.status.message) - } - self.logger.error("gateway command resolve failed: \(resolution.status.message)") - return - } - - if GatewayLaunchAgentManager.isLaunchAgentWriteDisabled() { - let message = "Launchd disabled; start the Gateway manually or disable attach-only." - self.status = .failed(message) - self.lastFailureReason = "launchd disabled" - self.appendLog("[gateway] launchd disabled; skipping auto-start\n") - self.logger.info("gateway launchd enable skipped (disable marker set)") - return - } - - let bundlePath = Bundle.main.bundleURL.path - let port = GatewayEnvironment.gatewayPort() - self.appendLog("[gateway] enabling launchd job (\(gatewayLaunchdLabel)) on port \(port)\n") - self.logger.info("gateway enabling launchd port=\(port)") - let err = await GatewayLaunchAgentManager.set(enabled: true, bundlePath: bundlePath, port: port) - if let err { - self.status = .failed(err) - self.lastFailureReason = err - self.logger.error("gateway launchd enable failed: \(err)") - return - } - - // Best-effort: wait for the gateway to accept connections. - let deadline = Date().addingTimeInterval(6) - while Date() < deadline { - if !self.desiredActive { return } - do { - _ = try await self.connection.requestRaw(method: .health, timeoutMs: 1500) - let instance = await PortGuardian.shared.describe(port: port) - let details = instance.map { "pid \($0.pid)" } - self.clearLastFailure() - self.status = .running(details: details) - self.logger.info("gateway started details=\(details ?? "ok")") - self.refreshControlChannelIfNeeded(reason: "gateway started") - self.refreshLog() - return - } catch { - try? await Task.sleep(nanoseconds: 400_000_000) - } - } - - self.status = .failed("Gateway did not start in time") - self.lastFailureReason = "launchd start timeout" - self.logger.warning("gateway start timed out") - } - - private func appendLog(_ chunk: String) { - self.log.append(chunk) - if self.log.count > self.logLimit { - self.log = String(self.log.suffix(self.logLimit)) - } - } - - private func refreshControlChannelIfNeeded(reason: String) { - switch ControlChannel.shared.state { - case .connected, .connecting: - return - case .disconnected, .degraded: - break - } - self.appendLog("[gateway] refreshing control channel (\(reason))\n") - self.logger.debug("gateway control channel refresh reason=\(reason)") - Task { await ControlChannel.shared.configure() } - } - - func waitForGatewayReady(timeout: TimeInterval = 6) async -> Bool { - let deadline = Date().addingTimeInterval(timeout) - while Date() < deadline { - if !self.desiredActive { return false } - do { - _ = try await self.connection.requestRaw(method: .health, timeoutMs: 1500) - self.clearLastFailure() - return true - } catch { - try? await Task.sleep(nanoseconds: 300_000_000) - } - } - self.appendLog("[gateway] readiness wait timed out\n") - self.logger.warning("gateway readiness wait timed out") - return false - } - - func clearLog() { - self.log = "" - try? FileManager().removeItem(atPath: GatewayLaunchAgentManager.launchdGatewayLogPath()) - self.logger.debug("gateway log cleared") - } - - func setProjectRoot(path: String) { - CommandResolver.setProjectRoot(path) - } - - func projectRootPath() -> String { - CommandResolver.projectRootPath() - } - - private nonisolated static func readGatewayLog(path: String, limit: Int) -> String { - guard FileManager().fileExists(atPath: path) else { return "" } - guard let data = try? Data(contentsOf: URL(fileURLWithPath: path)) else { return "" } - let text = String(data: data, encoding: .utf8) ?? "" - if text.count <= limit { return text } - return String(text.suffix(limit)) - } -} - -#if DEBUG -extension GatewayProcessManager { - func setTestingConnection(_ connection: GatewayConnection?) { - self.testingConnection = connection - } - - func setTestingDesiredActive(_ active: Bool) { - self.desiredActive = active - } - - func setTestingLastFailureReason(_ reason: String?) { - self.lastFailureReason = reason - } -} -#endif diff --git a/apps/macos/Sources/Clawdbot/HealthStore.swift b/apps/macos/Sources/Clawdbot/HealthStore.swift deleted file mode 100644 index 0410dcb4c..000000000 --- a/apps/macos/Sources/Clawdbot/HealthStore.swift +++ /dev/null @@ -1,301 +0,0 @@ -import Foundation -import Network -import Observation -import SwiftUI - -struct HealthSnapshot: Codable, Sendable { - struct ChannelSummary: Codable, Sendable { - struct Probe: Codable, Sendable { - struct Bot: Codable, Sendable { - let username: String? - } - - struct Webhook: Codable, Sendable { - let url: String? - } - - let ok: Bool? - let status: Int? - let error: String? - let elapsedMs: Double? - let bot: Bot? - let webhook: Webhook? - } - - let configured: Bool? - let linked: Bool? - let authAgeMs: Double? - let probe: Probe? - let lastProbeAt: Double? - } - - struct SessionInfo: Codable, Sendable { - let key: String - let updatedAt: Double? - let age: Double? - } - - struct Sessions: Codable, Sendable { - let path: String - let count: Int - let recent: [SessionInfo] - } - - let ok: Bool? - let ts: Double - let durationMs: Double - let channels: [String: ChannelSummary] - let channelOrder: [String]? - let channelLabels: [String: String]? - let heartbeatSeconds: Int? - let sessions: Sessions -} - -enum HealthState: Equatable { - case unknown - case ok - case linkingNeeded - case degraded(String) - - var tint: Color { - switch self { - case .ok: .green - case .linkingNeeded: .red - case .degraded: .orange - case .unknown: .secondary - } - } -} - -@MainActor -@Observable -final class HealthStore { - static let shared = HealthStore() - - private static let logger = Logger(subsystem: "com.clawdbot", category: "health") - - private(set) var snapshot: HealthSnapshot? - private(set) var lastSuccess: Date? - private(set) var lastError: String? - private(set) var isRefreshing = false - - private var loopTask: Task? - private let refreshInterval: TimeInterval = 60 - - private init() { - // Avoid background health polling in SwiftUI previews and tests. - if !ProcessInfo.processInfo.isPreview, !ProcessInfo.processInfo.isRunningTests { - self.start() - } - } - - // Test-only escape hatch: the HealthStore is a process-wide singleton but - // state derivation is pure from `snapshot` + `lastError`. - func __setSnapshotForTest(_ snapshot: HealthSnapshot?, lastError: String? = nil) { - self.snapshot = snapshot - self.lastError = lastError - } - - func start() { - guard self.loopTask == nil else { return } - self.loopTask = Task { [weak self] in - guard let self else { return } - while !Task.isCancelled { - await self.refresh() - try? await Task.sleep(nanoseconds: UInt64(self.refreshInterval * 1_000_000_000)) - } - } - } - - func stop() { - self.loopTask?.cancel() - self.loopTask = nil - } - - func refresh(onDemand: Bool = false) async { - guard !self.isRefreshing else { return } - self.isRefreshing = true - defer { self.isRefreshing = false } - let previousError = self.lastError - - do { - let data = try await ControlChannel.shared.health(timeout: 15) - if let decoded = decodeHealthSnapshot(from: data) { - self.snapshot = decoded - self.lastSuccess = Date() - self.lastError = nil - if previousError != nil { - Self.logger.info("health refresh recovered") - } - } else { - self.lastError = "health output not JSON" - if onDemand { self.snapshot = nil } - if previousError != self.lastError { - Self.logger.warning("health refresh failed: output not JSON") - } - } - } catch { - let desc = error.localizedDescription - self.lastError = desc - if onDemand { self.snapshot = nil } - if previousError != desc { - Self.logger.error("health refresh failed \(desc, privacy: .public)") - } - } - } - - private static func isChannelHealthy(_ summary: HealthSnapshot.ChannelSummary) -> Bool { - guard summary.configured == true else { return false } - // If probe is missing, treat it as "configured but unknown health" (not a hard fail). - return summary.probe?.ok ?? true - } - - private static func describeProbeFailure(_ probe: HealthSnapshot.ChannelSummary.Probe) -> String { - let elapsed = probe.elapsedMs.map { "\(Int($0))ms" } - if let error = probe.error, error.lowercased().contains("timeout") || probe.status == nil { - if let elapsed { return "Health check timed out (\(elapsed))" } - return "Health check timed out" - } - let code = probe.status.map { "status \($0)" } ?? "status unknown" - let reason = probe.error?.isEmpty == false ? probe.error! : "health probe failed" - if let elapsed { return "\(reason) (\(code), \(elapsed))" } - return "\(reason) (\(code))" - } - - private func resolveLinkChannel( - _ snap: HealthSnapshot) -> (id: String, summary: HealthSnapshot.ChannelSummary)? - { - let order = snap.channelOrder ?? Array(snap.channels.keys) - for id in order { - if let summary = snap.channels[id], summary.linked == true { - return (id: id, summary: summary) - } - } - for id in order { - if let summary = snap.channels[id], summary.linked != nil { - return (id: id, summary: summary) - } - } - return nil - } - - private func resolveFallbackChannel( - _ snap: HealthSnapshot, - excluding id: String?) -> (id: String, summary: HealthSnapshot.ChannelSummary)? - { - let order = snap.channelOrder ?? Array(snap.channels.keys) - for channelId in order { - if channelId == id { continue } - guard let summary = snap.channels[channelId] else { continue } - if Self.isChannelHealthy(summary) { - return (id: channelId, summary: summary) - } - } - return nil - } - - var state: HealthState { - if let error = self.lastError, !error.isEmpty { - return .degraded(error) - } - guard let snap = self.snapshot else { return .unknown } - guard let link = self.resolveLinkChannel(snap) else { return .unknown } - if link.summary.linked != true { - // Linking is optional if any other channel is healthy; don't paint the whole app red. - let fallback = self.resolveFallbackChannel(snap, excluding: link.id) - return fallback != nil ? .degraded("Not linked") : .linkingNeeded - } - // A channel can be "linked" but still unhealthy (failed probe / cannot connect). - if let probe = link.summary.probe, probe.ok == false { - return .degraded(Self.describeProbeFailure(probe)) - } - return .ok - } - - var summaryLine: String { - if self.isRefreshing { return "Health check running…" } - if let error = self.lastError { return "Health check failed: \(error)" } - guard let snap = self.snapshot else { return "Health check pending" } - guard let link = self.resolveLinkChannel(snap) else { return "Health check pending" } - if link.summary.linked != true { - if let fallback = self.resolveFallbackChannel(snap, excluding: link.id) { - let fallbackLabel = snap.channelLabels?[fallback.id] ?? fallback.id.capitalized - let fallbackState = (fallback.summary.probe?.ok ?? true) ? "ok" : "degraded" - return "\(fallbackLabel) \(fallbackState) · Not linked — run moltbot login" - } - return "Not linked — run moltbot login" - } - let auth = link.summary.authAgeMs.map { msToAge($0) } ?? "unknown" - if let probe = link.summary.probe, probe.ok == false { - let status = probe.status.map(String.init) ?? "?" - let suffix = probe.status == nil ? "probe degraded" : "probe degraded · status \(status)" - return "linked · auth \(auth) · \(suffix)" - } - return "linked · auth \(auth)" - } - - /// Short, human-friendly detail for the last failure, used in the UI. - var detailLine: String? { - if let error = self.lastError, !error.isEmpty { - let lower = error.lowercased() - if lower.contains("connection refused") { - let port = GatewayEnvironment.gatewayPort() - let host = GatewayConnectivityCoordinator.shared.localEndpointHostLabel ?? "127.0.0.1:\(port)" - return "The gateway control port (\(host)) isn’t listening — restart Moltbot to bring it back." - } - if lower.contains("timeout") { - return "Timed out waiting for the control server; the gateway may be crashed or still starting." - } - return error - } - return nil - } - - func describeFailure(from snap: HealthSnapshot, fallback: String?) -> String { - if let link = self.resolveLinkChannel(snap), link.summary.linked != true { - return "Not linked — run moltbot login" - } - if let link = self.resolveLinkChannel(snap), let probe = link.summary.probe, probe.ok == false { - return Self.describeProbeFailure(probe) - } - if let fallback, !fallback.isEmpty { - return fallback - } - return "health probe failed" - } - - var degradedSummary: String? { - guard case let .degraded(reason) = self.state else { return nil } - if reason == "[object Object]" || reason.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, - let snap = self.snapshot - { - return self.describeFailure(from: snap, fallback: reason) - } - return reason - } -} - -func msToAge(_ ms: Double) -> String { - let minutes = Int(round(ms / 60000)) - if minutes < 1 { return "just now" } - if minutes < 60 { return "\(minutes)m" } - let hours = Int(round(Double(minutes) / 60)) - if hours < 48 { return "\(hours)h" } - let days = Int(round(Double(hours) / 24)) - return "\(days)d" -} - -/// Decode a health snapshot, tolerating stray log lines before/after the JSON blob. -func decodeHealthSnapshot(from data: Data) -> HealthSnapshot? { - let decoder = JSONDecoder() - if let snap = try? decoder.decode(HealthSnapshot.self, from: data) { - return snap - } - guard let text = String(data: data, encoding: .utf8) else { return nil } - guard let firstBrace = text.firstIndex(of: "{"), let lastBrace = text.lastIndex(of: "}") else { - return nil - } - let slice = text[firstBrace...lastBrace] - let cleaned = Data(slice.utf8) - return try? decoder.decode(HealthSnapshot.self, from: cleaned) -} diff --git a/apps/macos/Sources/Clawdbot/InstancesStore.swift b/apps/macos/Sources/Clawdbot/InstancesStore.swift deleted file mode 100644 index 41685b463..000000000 --- a/apps/macos/Sources/Clawdbot/InstancesStore.swift +++ /dev/null @@ -1,394 +0,0 @@ -import MoltbotKit -import MoltbotProtocol -import Cocoa -import Foundation -import Observation -import OSLog - -struct InstanceInfo: Identifiable, Codable { - let id: String - let host: String? - let ip: String? - let version: String? - let platform: String? - let deviceFamily: String? - let modelIdentifier: String? - let lastInputSeconds: Int? - let mode: String? - let reason: String? - let text: String - let ts: Double - - var ageDescription: String { - let date = Date(timeIntervalSince1970: ts / 1000) - return age(from: date) - } - - var lastInputDescription: String { - guard let secs = lastInputSeconds else { return "unknown" } - return "\(secs)s ago" - } -} - -@MainActor -@Observable -final class InstancesStore { - static let shared = InstancesStore() - let isPreview: Bool - - var instances: [InstanceInfo] = [] - var lastError: String? - var statusMessage: String? - var isLoading = false - - private let logger = Logger(subsystem: "com.clawdbot", category: "instances") - private var task: Task? - private let interval: TimeInterval = 30 - private var eventTask: Task? - private var startCount = 0 - private var lastPresenceById: [String: InstanceInfo] = [:] - private var lastLoginNotifiedAtMs: [String: Double] = [:] - - private struct PresenceEventPayload: Codable { - let presence: [PresenceEntry] - } - - init(isPreview: Bool = false) { - self.isPreview = isPreview - } - - func start() { - guard !self.isPreview else { return } - self.startCount += 1 - guard self.startCount == 1 else { return } - guard self.task == nil else { return } - self.startGatewaySubscription() - self.task = Task.detached { [weak self] in - guard let self else { return } - await self.refresh() - while !Task.isCancelled { - try? await Task.sleep(nanoseconds: UInt64(self.interval * 1_000_000_000)) - await self.refresh() - } - } - } - - func stop() { - guard !self.isPreview else { return } - guard self.startCount > 0 else { return } - self.startCount -= 1 - guard self.startCount == 0 else { return } - self.task?.cancel() - self.task = nil - self.eventTask?.cancel() - self.eventTask = nil - } - - private func startGatewaySubscription() { - self.eventTask?.cancel() - self.eventTask = Task { [weak self] in - guard let self else { return } - let stream = await GatewayConnection.shared.subscribe() - for await push in stream { - if Task.isCancelled { return } - await MainActor.run { [weak self] in - self?.handle(push: push) - } - } - } - } - - private func handle(push: GatewayPush) { - switch push { - case let .event(evt) where evt.event == "presence": - if let payload = evt.payload { - self.handlePresenceEventPayload(payload) - } - case .seqGap: - Task { await self.refresh() } - case let .snapshot(hello): - self.applyPresence(hello.snapshot.presence) - default: - break - } - } - - func refresh() async { - if self.isLoading { return } - self.statusMessage = nil - self.isLoading = true - defer { self.isLoading = false } - do { - PresenceReporter.shared.sendImmediate(reason: "instances-refresh") - let data = try await ControlChannel.shared.request(method: "system-presence") - self.lastPayload = data - if data.isEmpty { - self.logger.error("instances fetch returned empty payload") - self.instances = [self.localFallbackInstance(reason: "no presence payload")] - self.lastError = nil - self.statusMessage = "No presence payload from gateway; showing local fallback + health probe." - await self.probeHealthIfNeeded(reason: "no payload") - return - } - let decoded = try JSONDecoder().decode([PresenceEntry].self, from: data) - let withIDs = self.normalizePresence(decoded) - if withIDs.isEmpty { - self.instances = [self.localFallbackInstance(reason: "no presence entries")] - self.lastError = nil - self.statusMessage = "Presence list was empty; showing local fallback + health probe." - await self.probeHealthIfNeeded(reason: "empty list") - } else { - self.instances = withIDs - self.lastError = nil - self.statusMessage = nil - } - } catch { - self.logger.error( - """ - instances fetch failed: \(error.localizedDescription, privacy: .public) \ - len=\(self.lastPayload?.count ?? 0, privacy: .public) \ - utf8=\(self.snippet(self.lastPayload), privacy: .public) - """) - self.instances = [self.localFallbackInstance(reason: "presence decode failed")] - self.lastError = nil - self.statusMessage = "Presence data invalid; showing local fallback + health probe." - await self.probeHealthIfNeeded(reason: "decode failed") - } - } - - private func localFallbackInstance(reason: String) -> InstanceInfo { - let host = Host.current().localizedName ?? "this-mac" - let ip = Self.primaryIPv4Address() - let version = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String - let osVersion = ProcessInfo.processInfo.operatingSystemVersion - let platform = "macos \(osVersion.majorVersion).\(osVersion.minorVersion).\(osVersion.patchVersion)" - let text = "Local node: \(host)\(ip.map { " (\($0))" } ?? "") · app \(version ?? "dev")" - let ts = Date().timeIntervalSince1970 * 1000 - return InstanceInfo( - id: "local-\(host)", - host: host, - ip: ip, - version: version, - platform: platform, - deviceFamily: "Mac", - modelIdentifier: InstanceIdentity.modelIdentifier, - lastInputSeconds: Self.lastInputSeconds(), - mode: "local", - reason: reason, - text: text, - ts: ts) - } - - private static func lastInputSeconds() -> Int? { - let anyEvent = CGEventType(rawValue: UInt32.max) ?? .null - let seconds = CGEventSource.secondsSinceLastEventType(.combinedSessionState, eventType: anyEvent) - if seconds.isNaN || seconds.isInfinite || seconds < 0 { return nil } - return Int(seconds.rounded()) - } - - private static func primaryIPv4Address() -> String? { - var addrList: UnsafeMutablePointer? - guard getifaddrs(&addrList) == 0, let first = addrList else { return nil } - defer { freeifaddrs(addrList) } - - var fallback: String? - var en0: String? - - for ptr in sequence(first: first, next: { $0.pointee.ifa_next }) { - let flags = Int32(ptr.pointee.ifa_flags) - let isUp = (flags & IFF_UP) != 0 - let isLoopback = (flags & IFF_LOOPBACK) != 0 - let name = String(cString: ptr.pointee.ifa_name) - let family = ptr.pointee.ifa_addr.pointee.sa_family - if !isUp || isLoopback || family != UInt8(AF_INET) { continue } - - var addr = ptr.pointee.ifa_addr.pointee - var buffer = [CChar](repeating: 0, count: Int(NI_MAXHOST)) - let result = getnameinfo( - &addr, - socklen_t(ptr.pointee.ifa_addr.pointee.sa_len), - &buffer, - socklen_t(buffer.count), - nil, - 0, - NI_NUMERICHOST) - guard result == 0 else { continue } - let len = buffer.prefix { $0 != 0 } - let bytes = len.map { UInt8(bitPattern: $0) } - guard let ip = String(bytes: bytes, encoding: .utf8) else { continue } - - if name == "en0" { en0 = ip; break } - if fallback == nil { fallback = ip } - } - - return en0 ?? fallback - } - - // MARK: - Helpers - - /// Keep the last raw payload for logging. - private var lastPayload: Data? - - private func snippet(_ data: Data?, limit: Int = 256) -> String { - guard let data else { return "" } - if data.isEmpty { return "" } - let prefix = data.prefix(limit) - if let asString = String(data: prefix, encoding: .utf8) { - return asString.replacingOccurrences(of: "\n", with: " ") - } - return "<\(data.count) bytes non-utf8>" - } - - private func probeHealthIfNeeded(reason: String? = nil) async { - do { - let data = try await ControlChannel.shared.health(timeout: 8) - guard let snap = decodeHealthSnapshot(from: data) else { return } - let linkId = snap.channelOrder?.first(where: { - if let summary = snap.channels[$0] { return summary.linked != nil } - return false - }) ?? snap.channels.keys.first(where: { - if let summary = snap.channels[$0] { return summary.linked != nil } - return false - }) - let linked = linkId.flatMap { snap.channels[$0]?.linked } ?? false - let linkLabel = - linkId.flatMap { snap.channelLabels?[$0] } ?? - linkId?.capitalized ?? - "channel" - let entry = InstanceInfo( - id: "health-\(snap.ts)", - host: "gateway (health)", - ip: nil, - version: nil, - platform: nil, - deviceFamily: nil, - modelIdentifier: nil, - lastInputSeconds: nil, - mode: "health", - reason: "health probe", - text: "Health ok · \(linkLabel) linked=\(linked)", - ts: snap.ts) - if !self.instances.contains(where: { $0.id == entry.id }) { - self.instances.insert(entry, at: 0) - } - self.lastError = nil - self.statusMessage = - "Presence unavailable (\(reason ?? "refresh")); showing health probe + local fallback." - } catch { - self.logger.error("instances health probe failed: \(error.localizedDescription, privacy: .public)") - if let reason { - self.statusMessage = - "Presence unavailable (\(reason)), health probe failed: \(error.localizedDescription)" - } - } - } - - private func decodeAndApplyPresenceData(_ data: Data) { - do { - let decoded = try JSONDecoder().decode([PresenceEntry].self, from: data) - self.applyPresence(decoded) - } catch { - self.logger.error("presence decode from event failed: \(error.localizedDescription, privacy: .public)") - self.lastError = error.localizedDescription - } - } - - func handlePresenceEventPayload(_ payload: MoltbotProtocol.AnyCodable) { - do { - let wrapper = try GatewayPayloadDecoding.decode(payload, as: PresenceEventPayload.self) - self.applyPresence(wrapper.presence) - } catch { - self.logger.error("presence event decode failed: \(error.localizedDescription, privacy: .public)") - self.lastError = error.localizedDescription - } - } - - private func normalizePresence(_ entries: [PresenceEntry]) -> [InstanceInfo] { - entries.map { entry -> InstanceInfo in - let key = entry.instanceid ?? entry.host ?? entry.ip ?? entry.text ?? "entry-\(entry.ts)" - return InstanceInfo( - id: key, - host: entry.host, - ip: entry.ip, - version: entry.version, - platform: entry.platform, - deviceFamily: entry.devicefamily, - modelIdentifier: entry.modelidentifier, - lastInputSeconds: entry.lastinputseconds, - mode: entry.mode, - reason: entry.reason, - text: entry.text ?? "Unnamed node", - ts: Double(entry.ts)) - } - } - - private func applyPresence(_ entries: [PresenceEntry]) { - let withIDs = self.normalizePresence(entries) - self.notifyOnNodeLogin(withIDs) - self.lastPresenceById = Dictionary(uniqueKeysWithValues: withIDs.map { ($0.id, $0) }) - self.instances = withIDs - self.statusMessage = nil - self.lastError = nil - } - - private func notifyOnNodeLogin(_ instances: [InstanceInfo]) { - for inst in instances { - guard let reason = inst.reason?.trimmingCharacters(in: .whitespacesAndNewlines) else { continue } - guard reason == "node-connected" else { continue } - if let mode = inst.mode?.lowercased(), mode == "local" { continue } - - let previous = self.lastPresenceById[inst.id] - if previous?.reason == "node-connected", previous?.ts == inst.ts { continue } - - let lastNotified = self.lastLoginNotifiedAtMs[inst.id] ?? 0 - if inst.ts <= lastNotified { continue } - self.lastLoginNotifiedAtMs[inst.id] = inst.ts - - let name = inst.host?.trimmingCharacters(in: .whitespacesAndNewlines) - let device = name?.isEmpty == false ? name! : inst.id - Task { @MainActor in - _ = await NotificationManager().send( - title: "Node connected", - body: device, - sound: nil, - priority: .active) - } - } - } -} - -extension InstancesStore { - static func preview(instances: [InstanceInfo] = [ - InstanceInfo( - id: "local", - host: "steipete-mac", - ip: "10.0.0.12", - version: "1.2.3", - platform: "macos 26.2.0", - deviceFamily: "Mac", - modelIdentifier: "Mac16,6", - lastInputSeconds: 12, - mode: "local", - reason: "preview", - text: "Local node: steipete-mac (10.0.0.12) · app 1.2.3", - ts: Date().timeIntervalSince1970 * 1000), - InstanceInfo( - id: "gateway", - host: "gateway", - ip: "100.64.0.2", - version: "1.2.3", - platform: "linux 6.6.0", - deviceFamily: "Linux", - modelIdentifier: "x86_64", - lastInputSeconds: 45, - mode: "remote", - reason: "preview", - text: "Gateway node · tunnel ok", - ts: Date().timeIntervalSince1970 * 1000 - 45000), - ]) -> InstancesStore { - let store = InstancesStore(isPreview: true) - store.instances = instances - store.statusMessage = "Preview data" - return store - } -} diff --git a/apps/macos/Sources/Clawdbot/LaunchAgentManager.swift b/apps/macos/Sources/Clawdbot/LaunchAgentManager.swift deleted file mode 100644 index 6b0225a65..000000000 --- a/apps/macos/Sources/Clawdbot/LaunchAgentManager.swift +++ /dev/null @@ -1,86 +0,0 @@ -import Foundation - -enum LaunchAgentManager { - private static let legacyLaunchdLabel = "com.steipete.clawdbot" - private static var plistURL: URL { - FileManager().homeDirectoryForCurrentUser - .appendingPathComponent("Library/LaunchAgents/com.clawdbot.mac.plist") - } - - private static var legacyPlistURL: URL { - FileManager().homeDirectoryForCurrentUser - .appendingPathComponent("Library/LaunchAgents/\(legacyLaunchdLabel).plist") - } - - static func status() async -> Bool { - guard FileManager().fileExists(atPath: self.plistURL.path) else { return false } - let result = await self.runLaunchctl(["print", "gui/\(getuid())/\(launchdLabel)"]) - return result == 0 - } - - static func set(enabled: Bool, bundlePath: String) async { - if enabled { - _ = await self.runLaunchctl(["bootout", "gui/\(getuid())/\(self.legacyLaunchdLabel)"]) - try? FileManager().removeItem(at: self.legacyPlistURL) - self.writePlist(bundlePath: bundlePath) - _ = await self.runLaunchctl(["bootout", "gui/\(getuid())/\(launchdLabel)"]) - _ = await self.runLaunchctl(["bootstrap", "gui/\(getuid())", self.plistURL.path]) - _ = await self.runLaunchctl(["kickstart", "-k", "gui/\(getuid())/\(launchdLabel)"]) - } else { - // Disable autostart going forward but leave the current app running. - // bootout would terminate the launchd job immediately (and crash the app if launched via agent). - try? FileManager().removeItem(at: self.plistURL) - } - } - - private static func writePlist(bundlePath: String) { - let plist = """ - - - - - Label - com.clawdbot.mac - ProgramArguments - - \(bundlePath)/Contents/MacOS/Moltbot - - WorkingDirectory - \(FileManager().homeDirectoryForCurrentUser.path) - RunAtLoad - - KeepAlive - - EnvironmentVariables - - PATH - \(CommandResolver.preferredPaths().joined(separator: ":")) - - StandardOutPath - \(LogLocator.launchdLogPath) - StandardErrorPath - \(LogLocator.launchdLogPath) - - - """ - try? plist.write(to: self.plistURL, atomically: true, encoding: .utf8) - } - - @discardableResult - private static func runLaunchctl(_ args: [String]) async -> Int32 { - await Task.detached(priority: .utility) { () -> Int32 in - let process = Process() - process.launchPath = "/bin/launchctl" - process.arguments = args - let pipe = Pipe() - process.standardOutput = pipe - process.standardError = pipe - do { - _ = try process.runAndReadToEnd(from: pipe) - return process.terminationStatus - } catch { - return -1 - } - }.value - } -} diff --git a/apps/macos/Sources/Clawdbot/Logging/ClawdbotLogging.swift b/apps/macos/Sources/Clawdbot/Logging/ClawdbotLogging.swift deleted file mode 100644 index c966aaa05..000000000 --- a/apps/macos/Sources/Clawdbot/Logging/ClawdbotLogging.swift +++ /dev/null @@ -1,230 +0,0 @@ -import Foundation -@_exported import Logging -import os -import OSLog - -typealias Logger = Logging.Logger - -enum AppLogSettings { - static let logLevelKey = appLogLevelKey - - static func logLevel() -> Logger.Level { - if let raw = UserDefaults.standard.string(forKey: self.logLevelKey), - let level = Logger.Level(rawValue: raw) - { - return level - } - return .info - } - - static func setLogLevel(_ level: Logger.Level) { - UserDefaults.standard.set(level.rawValue, forKey: self.logLevelKey) - } - - static func fileLoggingEnabled() -> Bool { - UserDefaults.standard.bool(forKey: debugFileLogEnabledKey) - } -} - -enum AppLogLevel: String, CaseIterable, Identifiable { - case trace - case debug - case info - case notice - case warning - case error - case critical - - static let `default`: AppLogLevel = .info - - var id: String { self.rawValue } - - var title: String { - switch self { - case .trace: "Trace" - case .debug: "Debug" - case .info: "Info" - case .notice: "Notice" - case .warning: "Warning" - case .error: "Error" - case .critical: "Critical" - } - } -} - -enum MoltbotLogging { - private static let labelSeparator = "::" - - private static let didBootstrap: Void = { - LoggingSystem.bootstrap { label in - let (subsystem, category) = Self.parseLabel(label) - let osHandler = MoltbotOSLogHandler(subsystem: subsystem, category: category) - let fileHandler = MoltbotFileLogHandler(label: label) - return MultiplexLogHandler([osHandler, fileHandler]) - } - }() - - static func bootstrapIfNeeded() { - _ = self.didBootstrap - } - - static func makeLabel(subsystem: String, category: String) -> String { - "\(subsystem)\(self.labelSeparator)\(category)" - } - - static func parseLabel(_ label: String) -> (String, String) { - guard let range = label.range(of: labelSeparator) else { - return ("com.clawdbot", label) - } - let subsystem = String(label[.. Logger.Metadata.Value? { - get { self.metadata[key] } - set { self.metadata[key] = newValue } - } - - func log( - level: Logger.Level, - message: Logger.Message, - metadata: Logger.Metadata?, - source: String, - file: String, - function: String, - line: UInt) - { - let merged = Self.mergeMetadata(self.metadata, metadata) - let rendered = Self.renderMessage(message, metadata: merged) - self.osLogger.log(level: Self.osLogType(for: level), "\(rendered, privacy: .public)") - } - - private static func osLogType(for level: Logger.Level) -> OSLogType { - switch level { - case .trace, .debug: - .debug - case .info, .notice: - .info - case .warning: - .default - case .error: - .error - case .critical: - .fault - } - } - - private static func mergeMetadata( - _ base: Logger.Metadata, - _ extra: Logger.Metadata?) -> Logger.Metadata - { - guard let extra else { return base } - return base.merging(extra, uniquingKeysWith: { _, new in new }) - } - - private static func renderMessage(_ message: Logger.Message, metadata: Logger.Metadata) -> String { - guard !metadata.isEmpty else { return message.description } - let meta = metadata - .sorted(by: { $0.key < $1.key }) - .map { "\($0.key)=\(self.stringify($0.value))" } - .joined(separator: " ") - return "\(message.description) [\(meta)]" - } - - private static func stringify(_ value: Logger.Metadata.Value) -> String { - switch value { - case let .string(text): - text - case let .stringConvertible(value): - String(describing: value) - case let .array(values): - "[" + values.map { self.stringify($0) }.joined(separator: ",") + "]" - case let .dictionary(entries): - "{" + entries.map { "\($0.key)=\(self.stringify($0.value))" }.joined(separator: ",") + "}" - } - } -} - -struct MoltbotFileLogHandler: LogHandler { - let label: String - var metadata: Logger.Metadata = [:] - - var logLevel: Logger.Level { - get { AppLogSettings.logLevel() } - set { AppLogSettings.setLogLevel(newValue) } - } - - subscript(metadataKey key: String) -> Logger.Metadata.Value? { - get { self.metadata[key] } - set { self.metadata[key] = newValue } - } - - func log( - level: Logger.Level, - message: Logger.Message, - metadata: Logger.Metadata?, - source: String, - file: String, - function: String, - line: UInt) - { - guard AppLogSettings.fileLoggingEnabled() else { return } - let (subsystem, category) = MoltbotLogging.parseLabel(self.label) - var fields: [String: String] = [ - "subsystem": subsystem, - "category": category, - "level": level.rawValue, - "source": source, - "file": file, - "function": function, - "line": "\(line)", - ] - let merged = self.metadata.merging(metadata ?? [:], uniquingKeysWith: { _, new in new }) - for (key, value) in merged { - fields["meta.\(key)"] = Self.stringify(value) - } - DiagnosticsFileLog.shared.log(category: category, event: message.description, fields: fields) - } - - private static func stringify(_ value: Logger.Metadata.Value) -> String { - switch value { - case let .string(text): - text - case let .stringConvertible(value): - String(describing: value) - case let .array(values): - "[" + values.map { self.stringify($0) }.joined(separator: ",") + "]" - case let .dictionary(entries): - "{" + entries.map { "\($0.key)=\(self.stringify($0.value))" }.joined(separator: ",") + "}" - } - } -} diff --git a/apps/macos/Sources/Clawdbot/MenuBar.swift b/apps/macos/Sources/Clawdbot/MenuBar.swift deleted file mode 100644 index a1e64c279..000000000 --- a/apps/macos/Sources/Clawdbot/MenuBar.swift +++ /dev/null @@ -1,471 +0,0 @@ -import AppKit -import Darwin -import Foundation -import MenuBarExtraAccess -import Observation -import OSLog -import Security -import SwiftUI - -@main -struct MoltbotApp: App { - @NSApplicationDelegateAdaptor(AppDelegate.self) private var delegate - @State private var state: AppState - private static let logger = Logger(subsystem: "com.clawdbot", category: "app") - private let gatewayManager = GatewayProcessManager.shared - private let controlChannel = ControlChannel.shared - private let activityStore = WorkActivityStore.shared - private let connectivityCoordinator = GatewayConnectivityCoordinator.shared - @State private var statusItem: NSStatusItem? - @State private var isMenuPresented = false - @State private var isPanelVisible = false - @State private var tailscaleService = TailscaleService.shared - - @MainActor - private func updateStatusHighlight() { - self.statusItem?.button?.highlight(self.isPanelVisible) - } - - @MainActor - private func updateHoverHUDSuppression() { - HoverHUDController.shared.setSuppressed(self.isMenuPresented || self.isPanelVisible) - } - - init() { - MoltbotLogging.bootstrapIfNeeded() - Self.applyAttachOnlyOverrideIfNeeded() - _state = State(initialValue: AppStateStore.shared) - } - - var body: some Scene { - MenuBarExtra { MenuContent(state: self.state, updater: self.delegate.updaterController) } label: { - CritterStatusLabel( - isPaused: self.state.isPaused, - isSleeping: self.isGatewaySleeping, - isWorking: self.state.isWorking, - earBoostActive: self.state.earBoostActive, - blinkTick: self.state.blinkTick, - sendCelebrationTick: self.state.sendCelebrationTick, - gatewayStatus: self.gatewayManager.status, - animationsEnabled: self.state.iconAnimationsEnabled && !self.isGatewaySleeping, - iconState: self.effectiveIconState) - } - .menuBarExtraStyle(.menu) - .menuBarExtraAccess(isPresented: self.$isMenuPresented) { item in - self.statusItem = item - MenuSessionsInjector.shared.install(into: item) - self.applyStatusItemAppearance(paused: self.state.isPaused, sleeping: self.isGatewaySleeping) - self.installStatusItemMouseHandler(for: item) - self.updateHoverHUDSuppression() - } - .onChange(of: self.state.isPaused) { _, paused in - self.applyStatusItemAppearance(paused: paused, sleeping: self.isGatewaySleeping) - if self.state.connectionMode == .local { - self.gatewayManager.setActive(!paused) - } else { - self.gatewayManager.stop() - } - } - .onChange(of: self.controlChannel.state) { _, _ in - self.applyStatusItemAppearance(paused: self.state.isPaused, sleeping: self.isGatewaySleeping) - } - .onChange(of: self.gatewayManager.status) { _, _ in - self.applyStatusItemAppearance(paused: self.state.isPaused, sleeping: self.isGatewaySleeping) - } - .onChange(of: self.state.connectionMode) { _, mode in - Task { await ConnectionModeCoordinator.shared.apply(mode: mode, paused: self.state.isPaused) } - CLIInstallPrompter.shared.checkAndPromptIfNeeded(reason: "connection-mode") - } - - Settings { - SettingsRootView(state: self.state, updater: self.delegate.updaterController) - .frame(width: SettingsTab.windowWidth, height: SettingsTab.windowHeight, alignment: .topLeading) - .environment(self.tailscaleService) - } - .defaultSize(width: SettingsTab.windowWidth, height: SettingsTab.windowHeight) - .windowResizability(.contentSize) - .onChange(of: self.isMenuPresented) { _, _ in - self.updateStatusHighlight() - self.updateHoverHUDSuppression() - } - } - - private func applyStatusItemAppearance(paused: Bool, sleeping: Bool) { - self.statusItem?.button?.appearsDisabled = paused || sleeping - } - - private static func applyAttachOnlyOverrideIfNeeded() { - let args = CommandLine.arguments - guard args.contains("--attach-only") || args.contains("--no-launchd") else { return } - if let error = GatewayLaunchAgentManager.setLaunchAgentWriteDisabled(true) { - Self.logger.error("attach-only flag failed: \(error, privacy: .public)") - return - } - Task { - _ = await GatewayLaunchAgentManager.set( - enabled: false, - bundlePath: Bundle.main.bundlePath, - port: GatewayEnvironment.gatewayPort()) - } - Self.logger.info("attach-only flag enabled") - } - - private var isGatewaySleeping: Bool { - if self.state.isPaused { return false } - switch self.state.connectionMode { - case .unconfigured: - return true - case .remote: - if case .connected = self.controlChannel.state { return false } - return true - case .local: - switch self.gatewayManager.status { - case .running, .starting, .attachedExisting: - if case .connected = self.controlChannel.state { return false } - return true - case .failed, .stopped: - return true - } - } - } - - @MainActor - private func installStatusItemMouseHandler(for item: NSStatusItem) { - guard let button = item.button else { return } - if button.subviews.contains(where: { $0 is StatusItemMouseHandlerView }) { return } - - WebChatManager.shared.onPanelVisibilityChanged = { [self] visible in - self.isPanelVisible = visible - self.updateStatusHighlight() - self.updateHoverHUDSuppression() - } - CanvasManager.shared.onPanelVisibilityChanged = { [self] visible in - self.state.canvasPanelVisible = visible - } - CanvasManager.shared.defaultAnchorProvider = { [self] in self.statusButtonScreenFrame() } - - let handler = StatusItemMouseHandlerView() - handler.translatesAutoresizingMaskIntoConstraints = false - handler.onLeftClick = { [self] in - HoverHUDController.shared.dismiss(reason: "statusItemClick") - self.toggleWebChatPanel() - } - handler.onRightClick = { [self] in - HoverHUDController.shared.dismiss(reason: "statusItemRightClick") - WebChatManager.shared.closePanel() - self.isMenuPresented = true - self.updateStatusHighlight() - } - handler.onHoverChanged = { [self] inside in - HoverHUDController.shared.statusItemHoverChanged( - inside: inside, - anchorProvider: { [self] in self.statusButtonScreenFrame() }) - } - - button.addSubview(handler) - NSLayoutConstraint.activate([ - handler.leadingAnchor.constraint(equalTo: button.leadingAnchor), - handler.trailingAnchor.constraint(equalTo: button.trailingAnchor), - handler.topAnchor.constraint(equalTo: button.topAnchor), - handler.bottomAnchor.constraint(equalTo: button.bottomAnchor), - ]) - } - - @MainActor - private func toggleWebChatPanel() { - HoverHUDController.shared.setSuppressed(true) - self.isMenuPresented = false - Task { @MainActor in - let sessionKey = await WebChatManager.shared.preferredSessionKey() - WebChatManager.shared.togglePanel( - sessionKey: sessionKey, - anchorProvider: { [self] in self.statusButtonScreenFrame() }) - } - } - - @MainActor - private func statusButtonScreenFrame() -> NSRect? { - guard let button = self.statusItem?.button, let window = button.window else { return nil } - let inWindow = button.convert(button.bounds, to: nil) - return window.convertToScreen(inWindow) - } - - private var effectiveIconState: IconState { - let selection = self.state.iconOverride - if selection == .system { - return self.activityStore.iconState - } - let overrideState = selection.toIconState() - switch overrideState { - case let .workingMain(kind): return .overridden(kind) - case let .workingOther(kind): return .overridden(kind) - case .idle: return .idle - case let .overridden(kind): return .overridden(kind) - } - } -} - -/// Transparent overlay that intercepts clicks without stealing MenuBarExtra ownership. -private final class StatusItemMouseHandlerView: NSView { - var onLeftClick: (() -> Void)? - var onRightClick: (() -> Void)? - var onHoverChanged: ((Bool) -> Void)? - private var tracking: NSTrackingArea? - - override func mouseDown(with event: NSEvent) { - if let onLeftClick { - onLeftClick() - } else { - super.mouseDown(with: event) - } - } - - override func rightMouseDown(with event: NSEvent) { - self.onRightClick?() - // Do not call super; menu will be driven by isMenuPresented binding. - } - - override func updateTrackingAreas() { - super.updateTrackingAreas() - if let tracking { - self.removeTrackingArea(tracking) - } - let options: NSTrackingArea.Options = [ - .mouseEnteredAndExited, - .activeAlways, - .inVisibleRect, - ] - let area = NSTrackingArea(rect: self.bounds, options: options, owner: self, userInfo: nil) - self.addTrackingArea(area) - self.tracking = area - } - - override func mouseEntered(with event: NSEvent) { - self.onHoverChanged?(true) - } - - override func mouseExited(with event: NSEvent) { - self.onHoverChanged?(false) - } -} - -@MainActor -final class AppDelegate: NSObject, NSApplicationDelegate { - private var state: AppState? - private let webChatAutoLogger = Logger(subsystem: "com.clawdbot", category: "Chat") - let updaterController: UpdaterProviding = makeUpdaterController() - - func application(_: NSApplication, open urls: [URL]) { - Task { @MainActor in - for url in urls { - await DeepLinkHandler.shared.handle(url: url) - } - } - } - - @MainActor - func applicationDidFinishLaunching(_ notification: Notification) { - if self.isDuplicateInstance() { - NSApp.terminate(nil) - return - } - self.state = AppStateStore.shared - AppActivationPolicy.apply(showDockIcon: self.state?.showDockIcon ?? false) - if let state { - Task { await ConnectionModeCoordinator.shared.apply(mode: state.connectionMode, paused: state.isPaused) } - } - TerminationSignalWatcher.shared.start() - NodePairingApprovalPrompter.shared.start() - DevicePairingApprovalPrompter.shared.start() - ExecApprovalsPromptServer.shared.start() - ExecApprovalsGatewayPrompter.shared.start() - MacNodeModeCoordinator.shared.start() - VoiceWakeGlobalSettingsSync.shared.start() - Task { PresenceReporter.shared.start() } - Task { await HealthStore.shared.refresh(onDemand: true) } - Task { await PortGuardian.shared.sweep(mode: AppStateStore.shared.connectionMode) } - Task { await PeekabooBridgeHostCoordinator.shared.setEnabled(AppStateStore.shared.peekabooBridgeEnabled) } - self.scheduleFirstRunOnboardingIfNeeded() - DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { - CLIInstallPrompter.shared.checkAndPromptIfNeeded(reason: "launch") - } - - // Developer/testing helper: auto-open chat when launched with --chat (or legacy --webchat). - if CommandLine.arguments.contains("--chat") || CommandLine.arguments.contains("--webchat") { - self.webChatAutoLogger.debug("Auto-opening chat via CLI flag") - Task { @MainActor in - let sessionKey = await WebChatManager.shared.preferredSessionKey() - WebChatManager.shared.show(sessionKey: sessionKey) - } - } - } - - func applicationWillTerminate(_ notification: Notification) { - PresenceReporter.shared.stop() - NodePairingApprovalPrompter.shared.stop() - DevicePairingApprovalPrompter.shared.stop() - ExecApprovalsPromptServer.shared.stop() - ExecApprovalsGatewayPrompter.shared.stop() - MacNodeModeCoordinator.shared.stop() - TerminationSignalWatcher.shared.stop() - VoiceWakeGlobalSettingsSync.shared.stop() - WebChatManager.shared.close() - WebChatManager.shared.resetTunnels() - Task { await RemoteTunnelManager.shared.stopAll() } - Task { await GatewayConnection.shared.shutdown() } - Task { await PeekabooBridgeHostCoordinator.shared.stop() } - } - - @MainActor - private func scheduleFirstRunOnboardingIfNeeded() { - let seenVersion = UserDefaults.standard.integer(forKey: onboardingVersionKey) - let shouldShow = seenVersion < currentOnboardingVersion || !AppStateStore.shared.onboardingSeen - guard shouldShow else { return } - DispatchQueue.main.asyncAfter(deadline: .now() + 0.6) { - OnboardingController.shared.show() - } - } - - private func isDuplicateInstance() -> Bool { - guard let bundleID = Bundle.main.bundleIdentifier else { return false } - let running = NSWorkspace.shared.runningApplications.filter { $0.bundleIdentifier == bundleID } - return running.count > 1 - } -} - -// MARK: - Sparkle updater (disabled for unsigned/dev builds) - -@MainActor -protocol UpdaterProviding: AnyObject { - var automaticallyChecksForUpdates: Bool { get set } - var automaticallyDownloadsUpdates: Bool { get set } - var isAvailable: Bool { get } - var updateStatus: UpdateStatus { get } - func checkForUpdates(_ sender: Any?) -} - -// No-op updater used for debug/dev runs to suppress Sparkle dialogs. -final class DisabledUpdaterController: UpdaterProviding { - var automaticallyChecksForUpdates: Bool = false - var automaticallyDownloadsUpdates: Bool = false - let isAvailable: Bool = false - let updateStatus = UpdateStatus() - func checkForUpdates(_: Any?) {} -} - -@MainActor -@Observable -final class UpdateStatus { - static let disabled = UpdateStatus() - var isUpdateReady: Bool - - init(isUpdateReady: Bool = false) { - self.isUpdateReady = isUpdateReady - } -} - -#if canImport(Sparkle) -import Sparkle - -@MainActor -final class SparkleUpdaterController: NSObject, UpdaterProviding { - private lazy var controller = SPUStandardUpdaterController( - startingUpdater: false, - updaterDelegate: self, - userDriverDelegate: nil) - let updateStatus = UpdateStatus() - - init(savedAutoUpdate: Bool) { - super.init() - let updater = self.controller.updater - updater.automaticallyChecksForUpdates = savedAutoUpdate - updater.automaticallyDownloadsUpdates = savedAutoUpdate - self.controller.startUpdater() - } - - var automaticallyChecksForUpdates: Bool { - get { self.controller.updater.automaticallyChecksForUpdates } - set { self.controller.updater.automaticallyChecksForUpdates = newValue } - } - - var automaticallyDownloadsUpdates: Bool { - get { self.controller.updater.automaticallyDownloadsUpdates } - set { self.controller.updater.automaticallyDownloadsUpdates = newValue } - } - - var isAvailable: Bool { true } - - func checkForUpdates(_ sender: Any?) { - self.controller.checkForUpdates(sender) - } - - func updater(_ updater: SPUUpdater, didDownloadUpdate item: SUAppcastItem) { - self.updateStatus.isUpdateReady = true - } - - func updater(_ updater: SPUUpdater, failedToDownloadUpdate item: SUAppcastItem, error: Error) { - self.updateStatus.isUpdateReady = false - } - - func userDidCancelDownload(_ updater: SPUUpdater) { - self.updateStatus.isUpdateReady = false - } - - func updater( - _ updater: SPUUpdater, - userDidMakeChoice choice: SPUUserUpdateChoice, - forUpdate updateItem: SUAppcastItem, - state: SPUUserUpdateState) - { - switch choice { - case .install, .skip: - self.updateStatus.isUpdateReady = false - case .dismiss: - self.updateStatus.isUpdateReady = (state.stage == .downloaded) - @unknown default: - self.updateStatus.isUpdateReady = false - } - } -} - -extension SparkleUpdaterController: @preconcurrency SPUUpdaterDelegate {} - -private func isDeveloperIDSigned(bundleURL: URL) -> Bool { - var staticCode: SecStaticCode? - guard SecStaticCodeCreateWithPath(bundleURL as CFURL, SecCSFlags(), &staticCode) == errSecSuccess, - let code = staticCode - else { return false } - - var infoCF: CFDictionary? - guard SecCodeCopySigningInformation(code, SecCSFlags(rawValue: kSecCSSigningInformation), &infoCF) == errSecSuccess, - let info = infoCF as? [String: Any], - let certs = info[kSecCodeInfoCertificates as String] as? [SecCertificate], - let leaf = certs.first - else { - return false - } - - if let summary = SecCertificateCopySubjectSummary(leaf) as String? { - return summary.hasPrefix("Developer ID Application:") - } - return false -} - -@MainActor -private func makeUpdaterController() -> UpdaterProviding { - let bundleURL = Bundle.main.bundleURL - let isBundledApp = bundleURL.pathExtension == "app" - guard isBundledApp, isDeveloperIDSigned(bundleURL: bundleURL) else { return DisabledUpdaterController() } - - let defaults = UserDefaults.standard - let autoUpdateKey = "autoUpdateEnabled" - // Default to true; honor the user's last choice otherwise. - let savedAutoUpdate = (defaults.object(forKey: autoUpdateKey) as? Bool) ?? true - return SparkleUpdaterController(savedAutoUpdate: savedAutoUpdate) -} -#else -@MainActor -private func makeUpdaterController() -> UpdaterProviding { - DisabledUpdaterController() -} -#endif diff --git a/apps/macos/Sources/Clawdbot/MicLevelMonitor.swift b/apps/macos/Sources/Clawdbot/MicLevelMonitor.swift deleted file mode 100644 index 2b2b4c99b..000000000 --- a/apps/macos/Sources/Clawdbot/MicLevelMonitor.swift +++ /dev/null @@ -1,97 +0,0 @@ -import AVFoundation -import OSLog -import SwiftUI - -actor MicLevelMonitor { - private let logger = Logger(subsystem: "com.clawdbot", category: "voicewake.meter") - private var engine: AVAudioEngine? - private var update: (@Sendable (Double) -> Void)? - private var running = false - private var smoothedLevel: Double = 0 - - func start(onLevel: @Sendable @escaping (Double) -> Void) async throws { - self.update = onLevel - if self.running { return } - self.logger.info( - "mic level monitor start (\(AudioInputDeviceObserver.defaultInputDeviceSummary(), privacy: .public))") - let engine = AVAudioEngine() - self.engine = engine - let input = engine.inputNode - let format = input.outputFormat(forBus: 0) - guard format.channelCount > 0, format.sampleRate > 0 else { - self.engine = nil - throw NSError( - domain: "MicLevelMonitor", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "No audio input available"]) - } - input.removeTap(onBus: 0) - input.installTap(onBus: 0, bufferSize: 512, format: format) { [weak self] buffer, _ in - guard let self else { return } - let level = Self.normalizedLevel(from: buffer) - Task { await self.push(level: level) } - } - engine.prepare() - try engine.start() - self.running = true - } - - func stop() { - guard self.running else { return } - if let engine { - engine.inputNode.removeTap(onBus: 0) - engine.stop() - } - self.engine = nil - self.running = false - } - - private func push(level: Double) { - self.smoothedLevel = (self.smoothedLevel * 0.45) + (level * 0.55) - guard let update else { return } - let value = self.smoothedLevel - Task { @MainActor in update(value) } - } - - private static func normalizedLevel(from buffer: AVAudioPCMBuffer) -> Double { - guard let channel = buffer.floatChannelData?[0] else { return 0 } - let frameCount = Int(buffer.frameLength) - guard frameCount > 0 else { return 0 } - var sum: Float = 0 - for i in 0.. Double(idx) - RoundedRectangle(cornerRadius: 2) - .fill(fill ? self.segmentColor(for: idx) : Color.gray.opacity(0.35)) - .frame(width: 14, height: 10) - } - } - .padding(4) - .background( - RoundedRectangle(cornerRadius: 6) - .stroke(Color.gray.opacity(0.25), lineWidth: 1)) - } - - private func segmentColor(for idx: Int) -> Color { - let fraction = Double(idx + 1) / Double(self.segments) - if fraction < 0.65 { return .green } - if fraction < 0.85 { return .yellow } - return .red - } -} diff --git a/apps/macos/Sources/Clawdbot/ModelCatalogLoader.swift b/apps/macos/Sources/Clawdbot/ModelCatalogLoader.swift deleted file mode 100644 index 4fc652b11..000000000 --- a/apps/macos/Sources/Clawdbot/ModelCatalogLoader.swift +++ /dev/null @@ -1,156 +0,0 @@ -import Foundation -import JavaScriptCore - -enum ModelCatalogLoader { - static var defaultPath: String { self.resolveDefaultPath() } - private static let logger = Logger(subsystem: "com.clawdbot", category: "models") - private nonisolated static let appSupportDir: URL = { - let base = FileManager().urls(for: .applicationSupportDirectory, in: .userDomainMask).first! - return base.appendingPathComponent("Moltbot", isDirectory: true) - }() - - private static var cachePath: URL { - self.appSupportDir.appendingPathComponent("model-catalog/models.generated.js", isDirectory: false) - } - - static func load(from path: String) async throws -> [ModelChoice] { - let expanded = (path as NSString).expandingTildeInPath - guard let resolved = self.resolvePath(preferred: expanded) else { - self.logger.error("model catalog load failed: file not found") - throw NSError( - domain: "ModelCatalogLoader", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "Model catalog file not found"]) - } - self.logger.debug("model catalog load start file=\(URL(fileURLWithPath: resolved.path).lastPathComponent)") - let source = try String(contentsOfFile: resolved.path, encoding: .utf8) - let sanitized = self.sanitize(source: source) - - let ctx = JSContext() - ctx?.exceptionHandler = { _, exception in - if let exception { - self.logger.warning("model catalog JS exception: \(exception)") - } - } - ctx?.evaluateScript(sanitized) - guard let rawModels = ctx?.objectForKeyedSubscript("MODELS")?.toDictionary() as? [String: Any] else { - self.logger.error("model catalog parse failed: MODELS missing") - throw NSError( - domain: "ModelCatalogLoader", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "Failed to parse models.generated.ts"]) - } - - var choices: [ModelChoice] = [] - for (provider, value) in rawModels { - guard let models = value as? [String: Any] else { continue } - for (id, payload) in models { - guard let dict = payload as? [String: Any] else { continue } - let name = dict["name"] as? String ?? id - let ctxWindow = dict["contextWindow"] as? Int - choices.append(ModelChoice(id: id, name: name, provider: provider, contextWindow: ctxWindow)) - } - } - - let sorted = choices.sorted { lhs, rhs in - if lhs.provider == rhs.provider { - return lhs.name.localizedCaseInsensitiveCompare(rhs.name) == .orderedAscending - } - return lhs.provider.localizedCaseInsensitiveCompare(rhs.provider) == .orderedAscending - } - self.logger.debug("model catalog loaded providers=\(rawModels.count) models=\(sorted.count)") - if resolved.shouldCache { - self.cacheCatalog(sourcePath: resolved.path) - } - return sorted - } - - private static func resolveDefaultPath() -> String { - let cache = self.cachePath.path - if FileManager().isReadableFile(atPath: cache) { return cache } - if let bundlePath = self.bundleCatalogPath() { return bundlePath } - if let nodePath = self.nodeModulesCatalogPath() { return nodePath } - return cache - } - - private static func resolvePath(preferred: String) -> (path: String, shouldCache: Bool)? { - if FileManager().isReadableFile(atPath: preferred) { - return (preferred, preferred != self.cachePath.path) - } - - if let bundlePath = self.bundleCatalogPath(), bundlePath != preferred { - self.logger.warning("model catalog path missing; falling back to bundled catalog") - return (bundlePath, true) - } - - let cache = self.cachePath.path - if cache != preferred, FileManager().isReadableFile(atPath: cache) { - self.logger.warning("model catalog path missing; falling back to cached catalog") - return (cache, false) - } - - if let nodePath = self.nodeModulesCatalogPath(), nodePath != preferred { - self.logger.warning("model catalog path missing; falling back to node_modules catalog") - return (nodePath, true) - } - - return nil - } - - private static func bundleCatalogPath() -> String? { - guard let url = Bundle.main.url(forResource: "models.generated", withExtension: "js") else { - return nil - } - return url.path - } - - private static func nodeModulesCatalogPath() -> String? { - let roots = [ - URL(fileURLWithPath: CommandResolver.projectRootPath()), - URL(fileURLWithPath: FileManager().currentDirectoryPath), - ] - for root in roots { - let candidate = root - .appendingPathComponent("node_modules/@mariozechner/pi-ai/dist/models.generated.js") - if FileManager().isReadableFile(atPath: candidate.path) { - return candidate.path - } - } - return nil - } - - private static func cacheCatalog(sourcePath: String) { - let destination = self.cachePath - do { - try FileManager().createDirectory( - at: destination.deletingLastPathComponent(), - withIntermediateDirectories: true) - if FileManager().fileExists(atPath: destination.path) { - try FileManager().removeItem(at: destination) - } - try FileManager().copyItem(atPath: sourcePath, toPath: destination.path) - self.logger.debug("model catalog cached file=\(destination.lastPathComponent)") - } catch { - self.logger.warning("model catalog cache failed: \(error.localizedDescription)") - } - } - - private static func sanitize(source: String) -> String { - guard let exportRange = source.range(of: "export const MODELS"), - let firstBrace = source[exportRange.upperBound...].firstIndex(of: "{"), - let lastBrace = source.lastIndex(of: "}") - else { - return "var MODELS = {}" - } - var body = String(source[firstBrace...lastBrace]) - body = body.replacingOccurrences( - of: #"(?m)\bsatisfies\s+[^,}\n]+"#, - with: "", - options: .regularExpression) - body = body.replacingOccurrences( - of: #"(?m)\bas\s+[^;,\n]+"#, - with: "", - options: .regularExpression) - return "var MODELS = \(body);" - } -} diff --git a/apps/macos/Sources/Clawdbot/NodeMode/MacNodeModeCoordinator.swift b/apps/macos/Sources/Clawdbot/NodeMode/MacNodeModeCoordinator.swift deleted file mode 100644 index 818a329ad..000000000 --- a/apps/macos/Sources/Clawdbot/NodeMode/MacNodeModeCoordinator.swift +++ /dev/null @@ -1,171 +0,0 @@ -import MoltbotKit -import Foundation -import OSLog - -@MainActor -final class MacNodeModeCoordinator { - static let shared = MacNodeModeCoordinator() - - private let logger = Logger(subsystem: "com.clawdbot", category: "mac-node") - private var task: Task? - private let runtime = MacNodeRuntime() - private let session = GatewayNodeSession() - - func start() { - guard self.task == nil else { return } - self.task = Task { [weak self] in - await self?.run() - } - } - - func stop() { - self.task?.cancel() - self.task = nil - Task { await self.session.disconnect() } - } - - func setPreferredGatewayStableID(_ stableID: String?) { - GatewayDiscoveryPreferences.setPreferredStableID(stableID) - Task { await self.session.disconnect() } - } - - private func run() async { - var retryDelay: UInt64 = 1_000_000_000 - var lastCameraEnabled: Bool? - let defaults = UserDefaults.standard - - while !Task.isCancelled { - if await MainActor.run(body: { AppStateStore.shared.isPaused }) { - try? await Task.sleep(nanoseconds: 1_000_000_000) - continue - } - - let cameraEnabled = defaults.object(forKey: cameraEnabledKey) as? Bool ?? false - if lastCameraEnabled == nil { - lastCameraEnabled = cameraEnabled - } else if lastCameraEnabled != cameraEnabled { - lastCameraEnabled = cameraEnabled - await self.session.disconnect() - try? await Task.sleep(nanoseconds: 200_000_000) - } - - do { - let config = try await GatewayEndpointStore.shared.requireConfig() - let caps = self.currentCaps() - let commands = self.currentCommands(caps: caps) - let permissions = await self.currentPermissions() - let connectOptions = GatewayConnectOptions( - role: "node", - scopes: [], - caps: caps, - commands: commands, - permissions: permissions, - clientId: "moltbot-macos", - clientMode: "node", - clientDisplayName: InstanceIdentity.displayName) - let sessionBox = self.buildSessionBox(url: config.url) - - try await self.session.connect( - url: config.url, - token: config.token, - password: config.password, - connectOptions: connectOptions, - sessionBox: sessionBox, - onConnected: { [weak self] in - guard let self else { return } - self.logger.info("mac node connected to gateway") - let mainSessionKey = await GatewayConnection.shared.mainSessionKey() - await self.runtime.updateMainSessionKey(mainSessionKey) - await self.runtime.setEventSender { [weak self] event, payload in - guard let self else { return } - await self.session.sendEvent(event: event, payloadJSON: payload) - } - }, - onDisconnected: { [weak self] reason in - guard let self else { return } - await self.runtime.setEventSender(nil) - self.logger.error("mac node disconnected: \(reason, privacy: .public)") - }, - onInvoke: { [weak self] req in - guard let self else { - return BridgeInvokeResponse( - id: req.id, - ok: false, - error: MoltbotNodeError(code: .unavailable, message: "UNAVAILABLE: node not ready")) - } - return await self.runtime.handleInvoke(req) - }) - - retryDelay = 1_000_000_000 - try? await Task.sleep(nanoseconds: 1_000_000_000) - } catch { - self.logger.error("mac node gateway connect failed: \(error.localizedDescription, privacy: .public)") - try? await Task.sleep(nanoseconds: min(retryDelay, 10_000_000_000)) - retryDelay = min(retryDelay * 2, 10_000_000_000) - } - } - } - - private func currentCaps() -> [String] { - var caps: [String] = [MoltbotCapability.canvas.rawValue, MoltbotCapability.screen.rawValue] - if UserDefaults.standard.object(forKey: cameraEnabledKey) as? Bool ?? false { - caps.append(MoltbotCapability.camera.rawValue) - } - let rawLocationMode = UserDefaults.standard.string(forKey: locationModeKey) ?? "off" - if MoltbotLocationMode(rawValue: rawLocationMode) != .off { - caps.append(MoltbotCapability.location.rawValue) - } - return caps - } - - private func currentPermissions() async -> [String: Bool] { - let statuses = await PermissionManager.status() - return Dictionary(uniqueKeysWithValues: statuses.map { ($0.key.rawValue, $0.value) }) - } - - private func currentCommands(caps: [String]) -> [String] { - var commands: [String] = [ - MoltbotCanvasCommand.present.rawValue, - MoltbotCanvasCommand.hide.rawValue, - MoltbotCanvasCommand.navigate.rawValue, - MoltbotCanvasCommand.evalJS.rawValue, - MoltbotCanvasCommand.snapshot.rawValue, - MoltbotCanvasA2UICommand.push.rawValue, - MoltbotCanvasA2UICommand.pushJSONL.rawValue, - MoltbotCanvasA2UICommand.reset.rawValue, - MacNodeScreenCommand.record.rawValue, - MoltbotSystemCommand.notify.rawValue, - MoltbotSystemCommand.which.rawValue, - MoltbotSystemCommand.run.rawValue, - MoltbotSystemCommand.execApprovalsGet.rawValue, - MoltbotSystemCommand.execApprovalsSet.rawValue, - ] - - let capsSet = Set(caps) - if capsSet.contains(MoltbotCapability.camera.rawValue) { - commands.append(MoltbotCameraCommand.list.rawValue) - commands.append(MoltbotCameraCommand.snap.rawValue) - commands.append(MoltbotCameraCommand.clip.rawValue) - } - if capsSet.contains(MoltbotCapability.location.rawValue) { - commands.append(MoltbotLocationCommand.get.rawValue) - } - - return commands - } - - private func buildSessionBox(url: URL) -> WebSocketSessionBox? { - guard url.scheme?.lowercased() == "wss" else { return nil } - let host = url.host ?? "gateway" - let port = url.port ?? 443 - let stableID = "\(host):\(port)" - let stored = GatewayTLSStore.loadFingerprint(stableID: stableID) - let params = GatewayTLSParams( - required: true, - expectedFingerprint: stored, - allowTOFU: stored == nil, - storeKey: stableID) - let session = GatewayTLSPinningSession(params: params) - return WebSocketSessionBox(session: session) - } -} diff --git a/apps/macos/Sources/Clawdbot/NodePairingApprovalPrompter.swift b/apps/macos/Sources/Clawdbot/NodePairingApprovalPrompter.swift deleted file mode 100644 index ef0735ca2..000000000 --- a/apps/macos/Sources/Clawdbot/NodePairingApprovalPrompter.swift +++ /dev/null @@ -1,708 +0,0 @@ -import AppKit -import MoltbotDiscovery -import MoltbotIPC -import MoltbotKit -import MoltbotProtocol -import Foundation -import Observation -import OSLog -import UserNotifications - -enum NodePairingReconcilePolicy { - static let activeIntervalMs: UInt64 = 15000 - static let resyncDelayMs: UInt64 = 250 - - static func shouldPoll(pendingCount: Int, isPresenting: Bool) -> Bool { - pendingCount > 0 || isPresenting - } -} - -@MainActor -@Observable -final class NodePairingApprovalPrompter { - static let shared = NodePairingApprovalPrompter() - - private let logger = Logger(subsystem: "com.clawdbot", category: "node-pairing") - private var task: Task? - private var reconcileTask: Task? - private var reconcileOnceTask: Task? - private var reconcileInFlight = false - private var isStopping = false - private var isPresenting = false - private var queue: [PendingRequest] = [] - var pendingCount: Int = 0 - var pendingRepairCount: Int = 0 - private var activeAlert: NSAlert? - private var activeRequestId: String? - private var alertHostWindow: NSWindow? - private var remoteResolutionsByRequestId: [String: PairingResolution] = [:] - private var autoApproveAttempts: Set = [] - - private final class AlertHostWindow: NSWindow { - override var canBecomeKey: Bool { true } - override var canBecomeMain: Bool { true } - } - - private struct PairingList: Codable { - let pending: [PendingRequest] - let paired: [PairedNode]? - } - - private struct PairedNode: Codable, Equatable { - let nodeId: String - let approvedAtMs: Double? - let displayName: String? - let platform: String? - let version: String? - let remoteIp: String? - } - - private struct PendingRequest: Codable, Equatable, Identifiable { - let requestId: String - let nodeId: String - let displayName: String? - let platform: String? - let version: String? - let remoteIp: String? - let isRepair: Bool? - let silent: Bool? - let ts: Double - - var id: String { self.requestId } - } - - private struct PairingResolvedEvent: Codable { - let requestId: String - let nodeId: String - let decision: String - let ts: Double - } - - private enum PairingResolution: String { - case approved - case rejected - } - - func start() { - guard self.task == nil else { return } - self.isStopping = false - self.reconcileTask?.cancel() - self.reconcileTask = nil - self.task = Task { [weak self] in - guard let self else { return } - _ = try? await GatewayConnection.shared.refresh() - await self.loadPendingRequestsFromGateway() - let stream = await GatewayConnection.shared.subscribe(bufferingNewest: 200) - for await push in stream { - if Task.isCancelled { return } - await MainActor.run { [weak self] in self?.handle(push: push) } - } - } - } - - func stop() { - self.isStopping = true - self.endActiveAlert() - self.task?.cancel() - self.task = nil - self.reconcileTask?.cancel() - self.reconcileTask = nil - self.reconcileOnceTask?.cancel() - self.reconcileOnceTask = nil - self.queue.removeAll(keepingCapacity: false) - self.updatePendingCounts() - self.isPresenting = false - self.activeRequestId = nil - self.alertHostWindow?.orderOut(nil) - self.alertHostWindow?.close() - self.alertHostWindow = nil - self.remoteResolutionsByRequestId.removeAll(keepingCapacity: false) - self.autoApproveAttempts.removeAll(keepingCapacity: false) - } - - private func loadPendingRequestsFromGateway() async { - // The gateway process may start slightly after the app. Retry a bit so - // pending pairing prompts are still shown on launch. - var delayMs: UInt64 = 200 - for attempt in 1...8 { - if Task.isCancelled { return } - do { - let data = try await GatewayConnection.shared.request( - method: "node.pair.list", - params: nil, - timeoutMs: 6000) - guard !data.isEmpty else { return } - let list = try JSONDecoder().decode(PairingList.self, from: data) - let pendingCount = list.pending.count - guard pendingCount > 0 else { return } - self.logger.info( - "loaded \(pendingCount, privacy: .public) pending node pairing request(s) on startup") - await self.apply(list: list) - return - } catch { - if attempt == 8 { - self.logger - .error( - "failed to load pending pairing requests: \(error.localizedDescription, privacy: .public)") - return - } - try? await Task.sleep(nanoseconds: delayMs * 1_000_000) - delayMs = min(delayMs * 2, 2000) - } - } - } - - private func reconcileLoop() async { - // Reconcile requests periodically so multiple running apps stay in sync - // (e.g. close dialogs + notify if another machine approves/rejects via app or CLI). - while !Task.isCancelled { - if self.isStopping { break } - if !self.shouldPoll { - self.reconcileTask = nil - return - } - await self.reconcileOnce(timeoutMs: 2500) - try? await Task.sleep( - nanoseconds: NodePairingReconcilePolicy.activeIntervalMs * 1_000_000) - } - self.reconcileTask = nil - } - - private func fetchPairingList(timeoutMs: Double) async throws -> PairingList { - let data = try await GatewayConnection.shared.request( - method: "node.pair.list", - params: nil, - timeoutMs: timeoutMs) - return try JSONDecoder().decode(PairingList.self, from: data) - } - - private func apply(list: PairingList) async { - if self.isStopping { return } - - let pendingById = Dictionary( - uniqueKeysWithValues: list.pending.map { ($0.requestId, $0) }) - - // Enqueue any missing requests (covers missed pushes while reconnecting). - for req in list.pending.sorted(by: { $0.ts < $1.ts }) { - self.enqueue(req) - } - - // Detect resolved requests (approved/rejected elsewhere). - let queued = self.queue - for req in queued { - if pendingById[req.requestId] != nil { continue } - let resolution = self.inferResolution(for: req, list: list) - - if self.activeRequestId == req.requestId, self.activeAlert != nil { - self.remoteResolutionsByRequestId[req.requestId] = resolution - self.logger.info( - """ - pairing request resolved elsewhere; closing dialog \ - requestId=\(req.requestId, privacy: .public) \ - resolution=\(resolution.rawValue, privacy: .public) - """) - self.endActiveAlert() - continue - } - - self.logger.info( - """ - pairing request resolved elsewhere requestId=\(req.requestId, privacy: .public) \ - resolution=\(resolution.rawValue, privacy: .public) - """) - self.queue.removeAll { $0 == req } - Task { @MainActor in - await self.notify(resolution: resolution, request: req, via: "remote") - } - } - - if self.queue.isEmpty { - self.isPresenting = false - } - self.presentNextIfNeeded() - self.updateReconcileLoop() - } - - private func inferResolution(for request: PendingRequest, list: PairingList) -> PairingResolution { - let paired = list.paired ?? [] - guard let node = paired.first(where: { $0.nodeId == request.nodeId }) else { - return .rejected - } - if request.isRepair == true, let approvedAtMs = node.approvedAtMs { - return approvedAtMs >= request.ts ? .approved : .rejected - } - return .approved - } - - private func endActiveAlert() { - guard let alert = self.activeAlert else { return } - if let parent = alert.window.sheetParent { - parent.endSheet(alert.window, returnCode: .abort) - } - self.activeAlert = nil - self.activeRequestId = nil - } - - private func requireAlertHostWindow() -> NSWindow { - if let alertHostWindow { - return alertHostWindow - } - - let window = AlertHostWindow( - contentRect: NSRect(x: 0, y: 0, width: 520, height: 1), - styleMask: [.borderless], - backing: .buffered, - defer: false) - window.title = "" - window.isReleasedWhenClosed = false - window.level = .floating - window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary] - window.isOpaque = false - window.hasShadow = false - window.backgroundColor = .clear - window.ignoresMouseEvents = true - - self.alertHostWindow = window - return window - } - - private func handle(push: GatewayPush) { - switch push { - case let .event(evt) where evt.event == "node.pair.requested": - guard let payload = evt.payload else { return } - do { - let req = try GatewayPayloadDecoding.decode(payload, as: PendingRequest.self) - self.enqueue(req) - } catch { - self.logger - .error("failed to decode pairing request: \(error.localizedDescription, privacy: .public)") - } - case let .event(evt) where evt.event == "node.pair.resolved": - guard let payload = evt.payload else { return } - do { - let resolved = try GatewayPayloadDecoding.decode(payload, as: PairingResolvedEvent.self) - self.handleResolved(resolved) - } catch { - self.logger - .error( - "failed to decode pairing resolution: \(error.localizedDescription, privacy: .public)") - } - case .snapshot: - self.scheduleReconcileOnce(delayMs: 0) - case .seqGap: - self.scheduleReconcileOnce() - default: - return - } - } - - private func enqueue(_ req: PendingRequest) { - if self.queue.contains(req) { return } - self.queue.append(req) - self.updatePendingCounts() - self.presentNextIfNeeded() - self.updateReconcileLoop() - } - - private func presentNextIfNeeded() { - guard !self.isStopping else { return } - guard !self.isPresenting else { return } - guard let next = self.queue.first else { return } - self.isPresenting = true - Task { @MainActor [weak self] in - guard let self else { return } - if await self.trySilentApproveIfPossible(next) { - return - } - self.presentAlert(for: next) - } - } - - private func presentAlert(for req: PendingRequest) { - self.logger.info("presenting node pairing alert requestId=\(req.requestId, privacy: .public)") - NSApp.activate(ignoringOtherApps: true) - - let alert = NSAlert() - alert.alertStyle = .warning - alert.messageText = "Allow node to connect?" - alert.informativeText = Self.describe(req) - // Fail-safe ordering: if the dialog can't be presented, default to "Later". - alert.addButton(withTitle: "Later") - alert.addButton(withTitle: "Approve") - alert.addButton(withTitle: "Reject") - if #available(macOS 11.0, *), alert.buttons.indices.contains(2) { - alert.buttons[2].hasDestructiveAction = true - } - - self.activeAlert = alert - self.activeRequestId = req.requestId - let hostWindow = self.requireAlertHostWindow() - - // Position the hidden host window so the sheet appears centered on screen. - // (Sheets attach to the top edge of their parent window; if the parent is tiny, it looks "anchored".) - let sheetSize = alert.window.frame.size - if let screen = hostWindow.screen ?? NSScreen.main { - let bounds = screen.visibleFrame - let x = bounds.midX - (sheetSize.width / 2) - let sheetOriginY = bounds.midY - (sheetSize.height / 2) - let hostY = sheetOriginY + sheetSize.height - hostWindow.frame.height - hostWindow.setFrameOrigin(NSPoint(x: x, y: hostY)) - } else { - hostWindow.center() - } - - hostWindow.makeKeyAndOrderFront(nil) - alert.beginSheetModal(for: hostWindow) { [weak self] response in - Task { @MainActor [weak self] in - guard let self else { return } - self.activeRequestId = nil - self.activeAlert = nil - await self.handleAlertResponse(response, request: req) - hostWindow.orderOut(nil) - } - } - } - - private func handleAlertResponse(_ response: NSApplication.ModalResponse, request: PendingRequest) async { - defer { - if self.queue.first == request { - self.queue.removeFirst() - } else { - self.queue.removeAll { $0 == request } - } - self.updatePendingCounts() - self.isPresenting = false - self.presentNextIfNeeded() - self.updateReconcileLoop() - } - - // Never approve/reject while shutting down (alerts can get dismissed during app termination). - guard !self.isStopping else { return } - - if let resolved = self.remoteResolutionsByRequestId.removeValue(forKey: request.requestId) { - await self.notify(resolution: resolved, request: request, via: "remote") - return - } - - switch response { - case .alertFirstButtonReturn: - // Later: leave as pending (CLI can approve/reject). Request will expire on the gateway TTL. - return - case .alertSecondButtonReturn: - _ = await self.approve(requestId: request.requestId) - await self.notify(resolution: .approved, request: request, via: "local") - case .alertThirdButtonReturn: - await self.reject(requestId: request.requestId) - await self.notify(resolution: .rejected, request: request, via: "local") - default: - return - } - } - - private func approve(requestId: String) async -> Bool { - do { - try await GatewayConnection.shared.nodePairApprove(requestId: requestId) - self.logger.info("approved node pairing requestId=\(requestId, privacy: .public)") - return true - } catch { - self.logger.error("approve failed requestId=\(requestId, privacy: .public)") - self.logger.error("approve failed: \(error.localizedDescription, privacy: .public)") - return false - } - } - - private func reject(requestId: String) async { - do { - try await GatewayConnection.shared.nodePairReject(requestId: requestId) - self.logger.info("rejected node pairing requestId=\(requestId, privacy: .public)") - } catch { - self.logger.error("reject failed requestId=\(requestId, privacy: .public)") - self.logger.error("reject failed: \(error.localizedDescription, privacy: .public)") - } - } - - private static func describe(_ req: PendingRequest) -> String { - let name = req.displayName?.trimmingCharacters(in: .whitespacesAndNewlines) - let platform = self.prettyPlatform(req.platform) - let version = req.version?.trimmingCharacters(in: .whitespacesAndNewlines) - let ip = self.prettyIP(req.remoteIp) - - var lines: [String] = [] - lines.append("Name: \(name?.isEmpty == false ? name! : "Unknown")") - lines.append("Node ID: \(req.nodeId)") - if let platform, !platform.isEmpty { lines.append("Platform: \(platform)") } - if let version, !version.isEmpty { lines.append("App: \(version)") } - if let ip, !ip.isEmpty { lines.append("IP: \(ip)") } - if req.isRepair == true { lines.append("Note: Repair request (token will rotate).") } - return lines.joined(separator: "\n") - } - - private static func prettyIP(_ ip: String?) -> String? { - let trimmed = ip?.trimmingCharacters(in: .whitespacesAndNewlines) - guard let trimmed, !trimmed.isEmpty else { return nil } - return trimmed.replacingOccurrences(of: "::ffff:", with: "") - } - - private static func prettyPlatform(_ platform: String?) -> String? { - let raw = platform?.trimmingCharacters(in: .whitespacesAndNewlines) - guard let raw, !raw.isEmpty else { return nil } - if raw.lowercased() == "ios" { return "iOS" } - if raw.lowercased() == "macos" { return "macOS" } - return raw - } - - private func notify(resolution: PairingResolution, request: PendingRequest, via: String) async { - let center = UNUserNotificationCenter.current() - let settings = await center.notificationSettings() - guard settings.authorizationStatus == .authorized || - settings.authorizationStatus == .provisional - else { - return - } - - let title = resolution == .approved ? "Node pairing approved" : "Node pairing rejected" - let name = request.displayName?.trimmingCharacters(in: .whitespacesAndNewlines) - let device = name?.isEmpty == false ? name! : request.nodeId - let body = "\(device)\n(via \(via))" - - _ = await NotificationManager().send( - title: title, - body: body, - sound: nil, - priority: .active) - } - - private struct SSHTarget { - let host: String - let port: Int - } - - private func trySilentApproveIfPossible(_ req: PendingRequest) async -> Bool { - guard req.silent == true else { return false } - if self.autoApproveAttempts.contains(req.requestId) { return false } - self.autoApproveAttempts.insert(req.requestId) - - guard let target = await self.resolveSSHTarget() else { - self.logger.info("silent pairing skipped (no ssh target) requestId=\(req.requestId, privacy: .public)") - return false - } - - let user = NSUserName().trimmingCharacters(in: .whitespacesAndNewlines) - guard !user.isEmpty else { - self.logger.info("silent pairing skipped (missing local user) requestId=\(req.requestId, privacy: .public)") - return false - } - - let ok = await Self.probeSSH(user: user, host: target.host, port: target.port) - if !ok { - self.logger.info("silent pairing probe failed requestId=\(req.requestId, privacy: .public)") - return false - } - - guard await self.approve(requestId: req.requestId) else { - self.logger.info("silent pairing approve failed requestId=\(req.requestId, privacy: .public)") - return false - } - - await self.notify(resolution: .approved, request: req, via: "silent-ssh") - if self.queue.first == req { - self.queue.removeFirst() - } else { - self.queue.removeAll { $0 == req } - } - - self.updatePendingCounts() - self.isPresenting = false - self.presentNextIfNeeded() - self.updateReconcileLoop() - return true - } - - private func resolveSSHTarget() async -> SSHTarget? { - let settings = CommandResolver.connectionSettings() - if !settings.target.isEmpty, let parsed = CommandResolver.parseSSHTarget(settings.target) { - let user = NSUserName().trimmingCharacters(in: .whitespacesAndNewlines) - if let targetUser = parsed.user, - !targetUser.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, - targetUser != user - { - self.logger.info("silent pairing skipped (ssh user mismatch)") - return nil - } - let host = parsed.host.trimmingCharacters(in: .whitespacesAndNewlines) - guard !host.isEmpty else { return nil } - let port = parsed.port > 0 ? parsed.port : 22 - return SSHTarget(host: host, port: port) - } - - let model = GatewayDiscoveryModel(localDisplayName: InstanceIdentity.displayName) - model.start() - defer { model.stop() } - - let deadline = Date().addingTimeInterval(5.0) - while model.gateways.isEmpty, Date() < deadline { - try? await Task.sleep(nanoseconds: 200_000_000) - } - - let preferred = GatewayDiscoveryPreferences.preferredStableID() - let gateway = model.gateways.first { $0.stableID == preferred } ?? model.gateways.first - guard let gateway else { return nil } - let host = (gateway.tailnetDns?.trimmingCharacters(in: .whitespacesAndNewlines).nonEmpty ?? - gateway.lanHost?.trimmingCharacters(in: .whitespacesAndNewlines).nonEmpty) - guard let host, !host.isEmpty else { return nil } - let port = gateway.sshPort > 0 ? gateway.sshPort : 22 - return SSHTarget(host: host, port: port) - } - - private static func probeSSH(user: String, host: String, port: Int) async -> Bool { - await Task.detached(priority: .utility) { - let process = Process() - process.executableURL = URL(fileURLWithPath: "/usr/bin/ssh") - - let options = [ - "-o", "BatchMode=yes", - "-o", "ConnectTimeout=5", - "-o", "NumberOfPasswordPrompts=0", - "-o", "PreferredAuthentications=publickey", - "-o", "StrictHostKeyChecking=accept-new", - ] - guard let target = CommandResolver.makeSSHTarget(user: user, host: host, port: port) else { - return false - } - let args = CommandResolver.sshArguments( - target: target, - identity: "", - options: options, - remoteCommand: ["/usr/bin/true"]) - process.arguments = args - let pipe = Pipe() - process.standardOutput = pipe - process.standardError = pipe - - do { - _ = try process.runAndReadToEnd(from: pipe) - } catch { - return false - } - return process.terminationStatus == 0 - }.value - } - - private var shouldPoll: Bool { - NodePairingReconcilePolicy.shouldPoll( - pendingCount: self.queue.count, - isPresenting: self.isPresenting) - } - - private func updateReconcileLoop() { - guard !self.isStopping else { return } - if self.shouldPoll { - if self.reconcileTask == nil { - self.reconcileTask = Task { [weak self] in - await self?.reconcileLoop() - } - } - } else { - self.reconcileTask?.cancel() - self.reconcileTask = nil - } - } - - private func updatePendingCounts() { - // Keep a cheap observable summary for the menu bar status line. - self.pendingCount = self.queue.count - self.pendingRepairCount = self.queue.count(where: { $0.isRepair == true }) - } - - private func reconcileOnce(timeoutMs: Double) async { - if self.isStopping { return } - if self.reconcileInFlight { return } - self.reconcileInFlight = true - defer { self.reconcileInFlight = false } - do { - let list = try await self.fetchPairingList(timeoutMs: timeoutMs) - await self.apply(list: list) - } catch { - // best effort: ignore transient connectivity failures - } - } - - private func scheduleReconcileOnce(delayMs: UInt64 = NodePairingReconcilePolicy.resyncDelayMs) { - self.reconcileOnceTask?.cancel() - self.reconcileOnceTask = Task { [weak self] in - guard let self else { return } - if delayMs > 0 { - try? await Task.sleep(nanoseconds: delayMs * 1_000_000) - } - await self.reconcileOnce(timeoutMs: 2500) - } - } - - private func handleResolved(_ resolved: PairingResolvedEvent) { - let resolution: PairingResolution = - resolved.decision == PairingResolution.approved.rawValue ? .approved : .rejected - - if self.activeRequestId == resolved.requestId, self.activeAlert != nil { - self.remoteResolutionsByRequestId[resolved.requestId] = resolution - self.logger.info( - """ - pairing request resolved elsewhere; closing dialog \ - requestId=\(resolved.requestId, privacy: .public) \ - resolution=\(resolution.rawValue, privacy: .public) - """) - self.endActiveAlert() - return - } - - guard let request = self.queue.first(where: { $0.requestId == resolved.requestId }) else { - return - } - self.queue.removeAll { $0.requestId == resolved.requestId } - self.updatePendingCounts() - Task { @MainActor in - await self.notify(resolution: resolution, request: request, via: "remote") - } - if self.queue.isEmpty { - self.isPresenting = false - } - self.presentNextIfNeeded() - self.updateReconcileLoop() - } -} - -#if DEBUG -@MainActor -extension NodePairingApprovalPrompter { - static func exerciseForTesting() async { - let prompter = NodePairingApprovalPrompter() - let pending = PendingRequest( - requestId: "req-1", - nodeId: "node-1", - displayName: "Node One", - platform: "macos", - version: "1.0.0", - remoteIp: "127.0.0.1", - isRepair: false, - silent: true, - ts: 1_700_000_000_000) - let paired = PairedNode( - nodeId: "node-1", - approvedAtMs: 1_700_000_000_000, - displayName: "Node One", - platform: "macOS", - version: "1.0.0", - remoteIp: "127.0.0.1") - let list = PairingList(pending: [pending], paired: [paired]) - - _ = Self.describe(pending) - _ = Self.prettyIP(pending.remoteIp) - _ = Self.prettyPlatform(pending.platform) - _ = prompter.inferResolution(for: pending, list: list) - - prompter.queue = [pending] - _ = prompter.shouldPoll - _ = await prompter.trySilentApproveIfPossible(pending) - prompter.queue.removeAll() - } -} -#endif diff --git a/apps/macos/Sources/Clawdbot/NodeServiceManager.swift b/apps/macos/Sources/Clawdbot/NodeServiceManager.swift deleted file mode 100644 index 2dd62d1e6..000000000 --- a/apps/macos/Sources/Clawdbot/NodeServiceManager.swift +++ /dev/null @@ -1,150 +0,0 @@ -import Foundation -import OSLog - -enum NodeServiceManager { - private static let logger = Logger(subsystem: "com.clawdbot", category: "node.service") - - static func start() async -> String? { - let result = await self.runServiceCommandResult( - ["node", "start"], - timeout: 20, - quiet: false) - if let error = self.errorMessage(from: result, treatNotLoadedAsError: true) { - self.logger.error("node service start failed: \(error, privacy: .public)") - return error - } - return nil - } - - static func stop() async -> String? { - let result = await self.runServiceCommandResult( - ["node", "stop"], - timeout: 15, - quiet: false) - if let error = self.errorMessage(from: result, treatNotLoadedAsError: false) { - self.logger.error("node service stop failed: \(error, privacy: .public)") - return error - } - return nil - } -} - -extension NodeServiceManager { - private struct CommandResult { - let success: Bool - let payload: Data? - let message: String? - let parsed: ParsedServiceJson? - } - - private struct ParsedServiceJson { - let text: String - let object: [String: Any] - let ok: Bool? - let result: String? - let message: String? - let error: String? - let hints: [String] - } - - private static func runServiceCommandResult( - _ args: [String], - timeout: Double, - quiet: Bool) async -> CommandResult - { - let command = CommandResolver.clawdbotCommand( - subcommand: "service", - extraArgs: self.withJsonFlag(args), - // Service management must always run locally, even if remote mode is configured. - configRoot: ["gateway": ["mode": "local"]]) - var env = ProcessInfo.processInfo.environment - env["PATH"] = CommandResolver.preferredPaths().joined(separator: ":") - let response = await ShellExecutor.runDetailed(command: command, cwd: nil, env: env, timeout: timeout) - let parsed = self.parseServiceJson(from: response.stdout) ?? self.parseServiceJson(from: response.stderr) - let ok = parsed?.ok - let message = parsed?.error ?? parsed?.message - let payload = parsed?.text.data(using: .utf8) - ?? (response.stdout.isEmpty ? response.stderr : response.stdout).data(using: .utf8) - let success = ok ?? response.success - if success { - return CommandResult(success: true, payload: payload, message: nil, parsed: parsed) - } - - if quiet { - return CommandResult(success: false, payload: payload, message: message, parsed: parsed) - } - - let detail = message ?? self.summarize(response.stderr) ?? self.summarize(response.stdout) - let exit = response.exitCode.map { "exit \($0)" } ?? (response.errorMessage ?? "failed") - let fullMessage = detail.map { "Node service command failed (\(exit)): \($0)" } - ?? "Node service command failed (\(exit))" - self.logger.error("\(fullMessage, privacy: .public)") - return CommandResult(success: false, payload: payload, message: detail, parsed: parsed) - } - - private static func errorMessage(from result: CommandResult, treatNotLoadedAsError: Bool) -> String? { - if !result.success { - return result.message ?? "Node service command failed" - } - guard let parsed = result.parsed else { return nil } - if parsed.ok == false { - return self.mergeHints(message: parsed.error ?? parsed.message, hints: parsed.hints) - } - if treatNotLoadedAsError, parsed.result == "not-loaded" { - let base = parsed.message ?? "Node service not loaded." - return self.mergeHints(message: base, hints: parsed.hints) - } - return nil - } - - private static func withJsonFlag(_ args: [String]) -> [String] { - if args.contains("--json") { return args } - return args + ["--json"] - } - - private static func parseServiceJson(from raw: String) -> ParsedServiceJson? { - let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) - guard let start = trimmed.firstIndex(of: "{"), - let end = trimmed.lastIndex(of: "}") - else { - return nil - } - let jsonText = String(trimmed[start...end]) - guard let data = jsonText.data(using: .utf8) else { return nil } - guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil } - let ok = object["ok"] as? Bool - let result = object["result"] as? String - let message = object["message"] as? String - let error = object["error"] as? String - let hints = (object["hints"] as? [String]) ?? [] - return ParsedServiceJson( - text: jsonText, - object: object, - ok: ok, - result: result, - message: message, - error: error, - hints: hints) - } - - private static func mergeHints(message: String?, hints: [String]) -> String? { - let trimmed = message?.trimmingCharacters(in: .whitespacesAndNewlines) - let nonEmpty = trimmed?.isEmpty == false ? trimmed : nil - guard !hints.isEmpty else { return nonEmpty } - let hintText = hints.prefix(2).joined(separator: " · ") - if let nonEmpty { - return "\(nonEmpty) (\(hintText))" - } - return hintText - } - - private static func summarize(_ text: String) -> String? { - let lines = text - .split(whereSeparator: \.isNewline) - .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) } - .filter { !$0.isEmpty } - guard let last = lines.last else { return nil } - let normalized = last.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression) - return normalized.count > 200 ? String(normalized.prefix(199)) + "…" : normalized - } -} diff --git a/apps/macos/Sources/Clawdbot/NodesStore.swift b/apps/macos/Sources/Clawdbot/NodesStore.swift deleted file mode 100644 index 51d43336d..000000000 --- a/apps/macos/Sources/Clawdbot/NodesStore.swift +++ /dev/null @@ -1,102 +0,0 @@ -import Foundation -import Observation -import OSLog - -struct NodeInfo: Identifiable, Codable { - let nodeId: String - let displayName: String? - let platform: String? - let version: String? - let coreVersion: String? - let uiVersion: String? - let deviceFamily: String? - let modelIdentifier: String? - let remoteIp: String? - let caps: [String]? - let commands: [String]? - let permissions: [String: Bool]? - let paired: Bool? - let connected: Bool? - - var id: String { self.nodeId } - var isConnected: Bool { self.connected ?? false } - var isPaired: Bool { self.paired ?? false } -} - -private struct NodeListResponse: Codable { - let ts: Double? - let nodes: [NodeInfo] -} - -@MainActor -@Observable -final class NodesStore { - static let shared = NodesStore() - - var nodes: [NodeInfo] = [] - var lastError: String? - var statusMessage: String? - var isLoading = false - - private let logger = Logger(subsystem: "com.clawdbot", category: "nodes") - private var task: Task? - private let interval: TimeInterval = 30 - private var startCount = 0 - - func start() { - self.startCount += 1 - guard self.startCount == 1 else { return } - guard self.task == nil else { return } - self.task = Task.detached { [weak self] in - guard let self else { return } - await self.refresh() - while !Task.isCancelled { - try? await Task.sleep(nanoseconds: UInt64(self.interval * 1_000_000_000)) - await self.refresh() - } - } - } - - func stop() { - guard self.startCount > 0 else { return } - self.startCount -= 1 - guard self.startCount == 0 else { return } - self.task?.cancel() - self.task = nil - } - - func refresh() async { - if self.isLoading { return } - self.statusMessage = nil - self.isLoading = true - defer { self.isLoading = false } - do { - let data = try await GatewayConnection.shared.requestRaw(method: "node.list", params: nil, timeoutMs: 8000) - let decoded = try JSONDecoder().decode(NodeListResponse.self, from: data) - self.nodes = decoded.nodes - self.lastError = nil - self.statusMessage = nil - } catch { - if Self.isCancelled(error) { - self.logger.debug("node.list cancelled; keeping last nodes") - if self.nodes.isEmpty { - self.statusMessage = "Refreshing devices…" - } - self.lastError = nil - return - } - self.logger.error("node.list failed \(error.localizedDescription, privacy: .public)") - self.nodes = [] - self.lastError = error.localizedDescription - self.statusMessage = nil - } - } - - private static func isCancelled(_ error: Error) -> Bool { - if error is CancellationError { return true } - if let urlError = error as? URLError, urlError.code == .cancelled { return true } - let nsError = error as NSError - if nsError.domain == NSURLErrorDomain, nsError.code == NSURLErrorCancelled { return true } - return false - } -} diff --git a/apps/macos/Sources/Clawdbot/NotificationManager.swift b/apps/macos/Sources/Clawdbot/NotificationManager.swift deleted file mode 100644 index 20d7a35b3..000000000 --- a/apps/macos/Sources/Clawdbot/NotificationManager.swift +++ /dev/null @@ -1,66 +0,0 @@ -import MoltbotIPC -import Foundation -import Security -import UserNotifications - -@MainActor -struct NotificationManager { - private let logger = Logger(subsystem: "com.clawdbot", category: "notifications") - - private static let hasTimeSensitiveEntitlement: Bool = { - guard let task = SecTaskCreateFromSelf(nil) else { return false } - let key = "com.apple.developer.usernotifications.time-sensitive" as CFString - guard let val = SecTaskCopyValueForEntitlement(task, key, nil) else { return false } - return (val as? Bool) == true - }() - - func send(title: String, body: String, sound: String?, priority: NotificationPriority? = nil) async -> Bool { - let center = UNUserNotificationCenter.current() - let status = await center.notificationSettings() - if status.authorizationStatus == .notDetermined { - let granted = try? await center.requestAuthorization(options: [.alert, .sound, .badge]) - if granted != true { - self.logger.warning("notification permission denied (request)") - return false - } - } else if status.authorizationStatus != .authorized { - self.logger.warning("notification permission denied status=\(status.authorizationStatus.rawValue)") - return false - } - - let content = UNMutableNotificationContent() - content.title = title - content.body = body - if let soundName = sound, !soundName.isEmpty { - content.sound = UNNotificationSound(named: UNNotificationSoundName(soundName)) - } - - // Set interruption level based on priority - if let priority { - switch priority { - case .passive: - content.interruptionLevel = .passive - case .active: - content.interruptionLevel = .active - case .timeSensitive: - if Self.hasTimeSensitiveEntitlement { - content.interruptionLevel = .timeSensitive - } else { - self.logger.debug( - "time-sensitive notification requested without entitlement; falling back to active") - content.interruptionLevel = .active - } - } - } - - let req = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil) - do { - try await center.add(req) - self.logger.debug("notification queued") - return true - } catch { - self.logger.error("notification send failed: \(error.localizedDescription)") - return false - } - } -} diff --git a/apps/macos/Sources/Clawdbot/OnboardingWizard.swift b/apps/macos/Sources/Clawdbot/OnboardingWizard.swift deleted file mode 100644 index 4c0ce8de4..000000000 --- a/apps/macos/Sources/Clawdbot/OnboardingWizard.swift +++ /dev/null @@ -1,412 +0,0 @@ -import MoltbotKit -import MoltbotProtocol -import Foundation -import Observation -import OSLog -import SwiftUI - -private let onboardingWizardLogger = Logger(subsystem: "com.clawdbot", category: "onboarding.wizard") - -// MARK: - Swift 6 AnyCodable Bridging Helpers - -// Bridge between MoltbotProtocol.AnyCodable and the local module to avoid -// Swift 6 strict concurrency type conflicts. - -private typealias ProtocolAnyCodable = MoltbotProtocol.AnyCodable - -private func bridgeToLocal(_ value: ProtocolAnyCodable) -> AnyCodable { - if let data = try? JSONEncoder().encode(value), - let decoded = try? JSONDecoder().decode(AnyCodable.self, from: data) - { - return decoded - } - return AnyCodable(value.value) -} - -private func bridgeToLocal(_ value: ProtocolAnyCodable?) -> AnyCodable? { - value.map(bridgeToLocal) -} - -@MainActor -@Observable -final class OnboardingWizardModel { - private(set) var sessionId: String? - private(set) var currentStep: WizardStep? - private(set) var status: String? - private(set) var errorMessage: String? - var isStarting = false - var isSubmitting = false - private var lastStartMode: AppState.ConnectionMode? - private var lastStartWorkspace: String? - private var restartAttempts = 0 - private let maxRestartAttempts = 1 - - var isComplete: Bool { self.status == "done" } - var isRunning: Bool { self.status == "running" } - - func reset() { - self.sessionId = nil - self.currentStep = nil - self.status = nil - self.errorMessage = nil - self.isStarting = false - self.isSubmitting = false - self.restartAttempts = 0 - self.lastStartMode = nil - self.lastStartWorkspace = nil - } - - func startIfNeeded(mode: AppState.ConnectionMode, workspace: String? = nil) async { - guard self.sessionId == nil, !self.isStarting else { return } - guard mode == .local else { return } - if self.shouldSkipWizard() { - self.sessionId = nil - self.currentStep = nil - self.status = "done" - self.errorMessage = nil - return - } - self.isStarting = true - self.errorMessage = nil - self.lastStartMode = mode - self.lastStartWorkspace = workspace - defer { self.isStarting = false } - - do { - GatewayProcessManager.shared.setActive(true) - if await GatewayProcessManager.shared.waitForGatewayReady(timeout: 12) == false { - throw NSError( - domain: "Gateway", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "Gateway did not become ready. Check that it is running."]) - } - var params: [String: AnyCodable] = ["mode": AnyCodable("local")] - if let workspace, !workspace.isEmpty { - params["workspace"] = AnyCodable(workspace) - } - let res: WizardStartResult = try await GatewayConnection.shared.requestDecoded( - method: .wizardStart, - params: params) - self.applyStartResult(res) - } catch { - self.status = "error" - self.errorMessage = error.localizedDescription - onboardingWizardLogger.error("start failed: \(error.localizedDescription, privacy: .public)") - } - } - - func submit(step: WizardStep, value: AnyCodable?) async { - guard let sessionId, !self.isSubmitting else { return } - self.isSubmitting = true - self.errorMessage = nil - defer { self.isSubmitting = false } - - do { - var params: [String: AnyCodable] = ["sessionId": AnyCodable(sessionId)] - var answer: [String: AnyCodable] = ["stepId": AnyCodable(step.id)] - if let value { - answer["value"] = value - } - params["answer"] = AnyCodable(answer) - let res: WizardNextResult = try await GatewayConnection.shared.requestDecoded( - method: .wizardNext, - params: params) - self.applyNextResult(res) - } catch { - if self.restartIfSessionLost(error: error) { - return - } - self.status = "error" - self.errorMessage = error.localizedDescription - onboardingWizardLogger.error("submit failed: \(error.localizedDescription, privacy: .public)") - } - } - - func cancelIfRunning() async { - guard let sessionId, self.isRunning else { return } - do { - let res: WizardStatusResult = try await GatewayConnection.shared.requestDecoded( - method: .wizardCancel, - params: ["sessionId": AnyCodable(sessionId)]) - self.applyStatusResult(res) - } catch { - self.status = "error" - self.errorMessage = error.localizedDescription - onboardingWizardLogger.error("cancel failed: \(error.localizedDescription, privacy: .public)") - } - } - - private func applyStartResult(_ res: WizardStartResult) { - self.sessionId = res.sessionid - self.status = wizardStatusString(res.status) ?? (res.done ? "done" : "running") - self.errorMessage = res.error - self.currentStep = decodeWizardStep(res.step) - if self.currentStep == nil, res.step != nil { - onboardingWizardLogger.error("wizard step decode failed") - } - if res.done { self.currentStep = nil } - self.restartAttempts = 0 - } - - private func applyNextResult(_ res: WizardNextResult) { - let status = wizardStatusString(res.status) - self.status = status ?? self.status - self.errorMessage = res.error - self.currentStep = decodeWizardStep(res.step) - if self.currentStep == nil, res.step != nil { - onboardingWizardLogger.error("wizard step decode failed") - } - if res.done { self.currentStep = nil } - if res.done || status == "done" || status == "cancelled" || status == "error" { - self.sessionId = nil - } - } - - private func applyStatusResult(_ res: WizardStatusResult) { - self.status = wizardStatusString(res.status) ?? "unknown" - self.errorMessage = res.error - self.currentStep = nil - self.sessionId = nil - } - - private func restartIfSessionLost(error: Error) -> Bool { - guard let gatewayError = error as? GatewayResponseError else { return false } - guard gatewayError.code == ErrorCode.invalidRequest.rawValue else { return false } - let message = gatewayError.message.lowercased() - guard message.contains("wizard not found") || message.contains("wizard not running") else { return false } - guard let mode = self.lastStartMode, self.restartAttempts < self.maxRestartAttempts else { - return false - } - self.restartAttempts += 1 - self.sessionId = nil - self.currentStep = nil - self.status = nil - self.errorMessage = "Wizard session lost. Restarting…" - Task { await self.startIfNeeded(mode: mode, workspace: self.lastStartWorkspace) } - return true - } - - private func shouldSkipWizard() -> Bool { - let root = MoltbotConfigFile.loadDict() - if let wizard = root["wizard"] as? [String: Any], !wizard.isEmpty { - return true - } - if let gateway = root["gateway"] as? [String: Any], - let auth = gateway["auth"] as? [String: Any] - { - if let mode = auth["mode"] as? String, - !mode.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty - { - return true - } - if let token = auth["token"] as? String, - !token.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty - { - return true - } - if let password = auth["password"] as? String, - !password.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty - { - return true - } - } - return false - } -} - -struct OnboardingWizardStepView: View { - let step: WizardStep - let isSubmitting: Bool - let onStepSubmit: (AnyCodable?) -> Void - - @State private var textValue: String - @State private var confirmValue: Bool - @State private var selectedIndex: Int - @State private var selectedIndices: Set - - private let optionItems: [WizardOptionItem] - - init(step: WizardStep, isSubmitting: Bool, onSubmit: @escaping (AnyCodable?) -> Void) { - self.step = step - self.isSubmitting = isSubmitting - self.onStepSubmit = onSubmit - let options = parseWizardOptions(step.options).enumerated().map { index, option in - WizardOptionItem(index: index, option: option) - } - self.optionItems = options - let initialText = anyCodableString(step.initialvalue) - let initialConfirm = anyCodableBool(step.initialvalue) - let initialIndex = options.firstIndex(where: { anyCodableEqual($0.option.value, step.initialvalue) }) ?? 0 - let initialMulti = Set( - options.filter { option in - anyCodableArray(step.initialvalue).contains { anyCodableEqual($0, option.option.value) } - }.map(\.index)) - - _textValue = State(initialValue: initialText) - _confirmValue = State(initialValue: initialConfirm) - _selectedIndex = State(initialValue: initialIndex) - _selectedIndices = State(initialValue: initialMulti) - } - - var body: some View { - VStack(alignment: .leading, spacing: 12) { - if let title = step.title, !title.isEmpty { - Text(title) - .font(.title2.weight(.semibold)) - } - if let message = step.message, !message.isEmpty { - Text(message) - .font(.body) - .foregroundStyle(.secondary) - .fixedSize(horizontal: false, vertical: true) - } - - switch wizardStepType(self.step) { - case "note": - EmptyView() - case "text": - self.textField - case "confirm": - Toggle("", isOn: self.$confirmValue) - .toggleStyle(.switch) - case "select": - self.selectOptions - case "multiselect": - self.multiselectOptions - case "progress": - ProgressView() - .controlSize(.small) - case "action": - EmptyView() - default: - Text("Unsupported step type") - .foregroundStyle(.secondary) - } - - Button(action: self.submit) { - Text(wizardStepType(self.step) == "action" ? "Run" : "Continue") - .frame(minWidth: 120) - } - .buttonStyle(.borderedProminent) - .disabled(self.isSubmitting || self.isBlocked) - } - .frame(maxWidth: .infinity, alignment: .leading) - } - - @ViewBuilder - private var textField: some View { - let isSensitive = self.step.sensitive == true - if isSensitive { - SecureField(self.step.placeholder ?? "", text: self.$textValue) - .textFieldStyle(.roundedBorder) - .frame(maxWidth: 360) - } else { - TextField(self.step.placeholder ?? "", text: self.$textValue) - .textFieldStyle(.roundedBorder) - .frame(maxWidth: 360) - } - } - - private var selectOptions: some View { - VStack(alignment: .leading, spacing: 8) { - ForEach(self.optionItems, id: \.index) { item in - self.selectOptionRow(item) - } - } - } - - private var multiselectOptions: some View { - VStack(alignment: .leading, spacing: 8) { - ForEach(self.optionItems, id: \.index) { item in - self.multiselectOptionRow(item) - } - } - } - - private func selectOptionRow(_ item: WizardOptionItem) -> some View { - Button { - self.selectedIndex = item.index - } label: { - HStack(alignment: .top, spacing: 8) { - Image(systemName: self.selectedIndex == item.index ? "largecircle.fill.circle" : "circle") - .foregroundStyle(Color.accentColor) - VStack(alignment: .leading, spacing: 2) { - Text(item.option.label) - .foregroundStyle(.primary) - if let hint = item.option.hint, !hint.isEmpty { - Text(hint) - .font(.caption) - .foregroundStyle(.secondary) - } - } - } - } - .buttonStyle(.plain) - } - - private func multiselectOptionRow(_ item: WizardOptionItem) -> some View { - Toggle(isOn: self.bindingForOption(item)) { - VStack(alignment: .leading, spacing: 2) { - Text(item.option.label) - if let hint = item.option.hint, !hint.isEmpty { - Text(hint) - .font(.caption) - .foregroundStyle(.secondary) - } - } - } - } - - private func bindingForOption(_ item: WizardOptionItem) -> Binding { - Binding(get: { - self.selectedIndices.contains(item.index) - }, set: { newValue in - if newValue { - self.selectedIndices.insert(item.index) - } else { - self.selectedIndices.remove(item.index) - } - }) - } - - private var isBlocked: Bool { - let type = wizardStepType(step) - if type == "select" { return self.optionItems.isEmpty } - if type == "multiselect" { return self.optionItems.isEmpty } - return false - } - - private func submit() { - switch wizardStepType(self.step) { - case "note", "progress": - self.onStepSubmit(nil) - case "text": - self.onStepSubmit(AnyCodable(self.textValue)) - case "confirm": - self.onStepSubmit(AnyCodable(self.confirmValue)) - case "select": - guard self.optionItems.indices.contains(self.selectedIndex) else { - self.onStepSubmit(nil) - return - } - let option = self.optionItems[self.selectedIndex].option - self.onStepSubmit(bridgeToLocal(option.value) ?? AnyCodable(option.label)) - case "multiselect": - let values = self.optionItems - .filter { self.selectedIndices.contains($0.index) } - .map { bridgeToLocal($0.option.value) ?? AnyCodable($0.option.label) } - self.onStepSubmit(AnyCodable(values)) - case "action": - self.onStepSubmit(AnyCodable(true)) - default: - self.onStepSubmit(nil) - } - } -} - -private struct WizardOptionItem: Identifiable { - let index: Int - let option: WizardOption - - var id: Int { self.index } -} diff --git a/apps/macos/Sources/Clawdbot/PeekabooBridgeHostCoordinator.swift b/apps/macos/Sources/Clawdbot/PeekabooBridgeHostCoordinator.swift deleted file mode 100644 index 76777b57f..000000000 --- a/apps/macos/Sources/Clawdbot/PeekabooBridgeHostCoordinator.swift +++ /dev/null @@ -1,130 +0,0 @@ -import Foundation -import os -import PeekabooAutomationKit -import PeekabooBridge -import PeekabooFoundation -import Security - -@MainActor -final class PeekabooBridgeHostCoordinator { - static let shared = PeekabooBridgeHostCoordinator() - - private let logger = Logger(subsystem: "com.clawdbot", category: "PeekabooBridge") - - private var host: PeekabooBridgeHost? - private var services: MoltbotPeekabooBridgeServices? - - func setEnabled(_ enabled: Bool) async { - if enabled { - await self.startIfNeeded() - } else { - await self.stop() - } - } - - func stop() async { - guard let host else { return } - await host.stop() - self.host = nil - self.services = nil - self.logger.info("PeekabooBridge host stopped") - } - - private func startIfNeeded() async { - guard self.host == nil else { return } - - var allowlistedTeamIDs: Set = ["Y5PE65HELJ"] - if let teamID = Self.currentTeamID() { - allowlistedTeamIDs.insert(teamID) - } - let allowlistedBundles: Set = [] - - let services = MoltbotPeekabooBridgeServices() - let server = PeekabooBridgeServer( - services: services, - hostKind: .gui, - allowlistedTeams: allowlistedTeamIDs, - allowlistedBundles: allowlistedBundles) - - let host = PeekabooBridgeHost( - socketPath: PeekabooBridgeConstants.clawdbotSocketPath, - server: server, - allowedTeamIDs: allowlistedTeamIDs, - requestTimeoutSec: 10) - - self.services = services - self.host = host - - await host.start() - self.logger - .info("PeekabooBridge host started at \(PeekabooBridgeConstants.clawdbotSocketPath, privacy: .public)") - } - - private static func currentTeamID() -> String? { - var code: SecCode? - guard SecCodeCopySelf(SecCSFlags(), &code) == errSecSuccess, - let code - else { - return nil - } - - var staticCode: SecStaticCode? - guard SecCodeCopyStaticCode(code, SecCSFlags(), &staticCode) == errSecSuccess, - let staticCode - else { - return nil - } - - var infoCF: CFDictionary? - guard SecCodeCopySigningInformation( - staticCode, - SecCSFlags(rawValue: kSecCSSigningInformation), - &infoCF) == errSecSuccess, - let info = infoCF as? [String: Any] - else { - return nil - } - - return info[kSecCodeInfoTeamIdentifier as String] as? String - } -} - -@MainActor -private final class MoltbotPeekabooBridgeServices: PeekabooBridgeServiceProviding { - let permissions: PermissionsService - let screenCapture: any ScreenCaptureServiceProtocol - let automation: any UIAutomationServiceProtocol - let windows: any WindowManagementServiceProtocol - let applications: any ApplicationServiceProtocol - let menu: any MenuServiceProtocol - let dock: any DockServiceProtocol - let dialogs: any DialogServiceProtocol - let snapshots: any SnapshotManagerProtocol - - init() { - let logging = LoggingService(subsystem: "com.clawdbot.peekaboo") - let feedbackClient: any AutomationFeedbackClient = NoopAutomationFeedbackClient() - - let snapshots = InMemorySnapshotManager(options: .init( - snapshotValidityWindow: 600, - maxSnapshots: 50, - deleteArtifactsOnCleanup: false)) - let applications = ApplicationService(feedbackClient: feedbackClient) - - let screenCapture = ScreenCaptureService(loggingService: logging) - - self.permissions = PermissionsService() - self.snapshots = snapshots - self.applications = applications - self.screenCapture = screenCapture - self.automation = UIAutomationService( - snapshotManager: snapshots, - loggingService: logging, - searchPolicy: .balanced, - feedbackClient: feedbackClient) - self.windows = WindowManagementService(applicationService: applications, feedbackClient: feedbackClient) - self.menu = MenuService(applicationService: applications, feedbackClient: feedbackClient) - self.dock = DockService(feedbackClient: feedbackClient) - self.dialogs = DialogService(feedbackClient: feedbackClient) - } -} diff --git a/apps/macos/Sources/Clawdbot/PermissionManager.swift b/apps/macos/Sources/Clawdbot/PermissionManager.swift deleted file mode 100644 index e0d7b2404..000000000 --- a/apps/macos/Sources/Clawdbot/PermissionManager.swift +++ /dev/null @@ -1,506 +0,0 @@ -import AppKit -import ApplicationServices -import AVFoundation -import MoltbotIPC -import CoreGraphics -import CoreLocation -import Foundation -import Observation -import Speech -import UserNotifications - -enum PermissionManager { - static func isLocationAuthorized(status: CLAuthorizationStatus, requireAlways: Bool) -> Bool { - if requireAlways { return status == .authorizedAlways } - switch status { - case .authorizedAlways, .authorizedWhenInUse: - return true - case .authorized: // deprecated, but still shows up on some macOS versions - return true - default: - return false - } - } - - static func ensure(_ caps: [Capability], interactive: Bool) async -> [Capability: Bool] { - var results: [Capability: Bool] = [:] - for cap in caps { - results[cap] = await self.ensureCapability(cap, interactive: interactive) - } - return results - } - - private static func ensureCapability(_ cap: Capability, interactive: Bool) async -> Bool { - switch cap { - case .notifications: - await self.ensureNotifications(interactive: interactive) - case .appleScript: - await self.ensureAppleScript(interactive: interactive) - case .accessibility: - await self.ensureAccessibility(interactive: interactive) - case .screenRecording: - await self.ensureScreenRecording(interactive: interactive) - case .microphone: - await self.ensureMicrophone(interactive: interactive) - case .speechRecognition: - await self.ensureSpeechRecognition(interactive: interactive) - case .camera: - await self.ensureCamera(interactive: interactive) - case .location: - await self.ensureLocation(interactive: interactive) - } - } - - private static func ensureNotifications(interactive: Bool) async -> Bool { - let center = UNUserNotificationCenter.current() - let settings = await center.notificationSettings() - - switch settings.authorizationStatus { - case .authorized, .provisional, .ephemeral: - return true - case .notDetermined: - guard interactive else { return false } - let granted = await (try? center.requestAuthorization(options: [.alert, .sound, .badge])) ?? false - let updated = await center.notificationSettings() - return granted && - (updated.authorizationStatus == .authorized || updated.authorizationStatus == .provisional) - case .denied: - if interactive { - NotificationPermissionHelper.openSettings() - } - return false - @unknown default: - return false - } - } - - private static func ensureAppleScript(interactive: Bool) async -> Bool { - let granted = await MainActor.run { AppleScriptPermission.isAuthorized() } - if interactive, !granted { - await AppleScriptPermission.requestAuthorization() - } - return await MainActor.run { AppleScriptPermission.isAuthorized() } - } - - private static func ensureAccessibility(interactive: Bool) async -> Bool { - let trusted = await MainActor.run { AXIsProcessTrusted() } - if interactive, !trusted { - await MainActor.run { - let opts: NSDictionary = ["AXTrustedCheckOptionPrompt": true] - _ = AXIsProcessTrustedWithOptions(opts) - } - } - return await MainActor.run { AXIsProcessTrusted() } - } - - private static func ensureScreenRecording(interactive: Bool) async -> Bool { - let granted = ScreenRecordingProbe.isAuthorized() - if interactive, !granted { - await ScreenRecordingProbe.requestAuthorization() - } - return ScreenRecordingProbe.isAuthorized() - } - - private static func ensureMicrophone(interactive: Bool) async -> Bool { - let status = AVCaptureDevice.authorizationStatus(for: .audio) - switch status { - case .authorized: - return true - case .notDetermined: - guard interactive else { return false } - return await AVCaptureDevice.requestAccess(for: .audio) - case .denied, .restricted: - if interactive { - MicrophonePermissionHelper.openSettings() - } - return false - @unknown default: - return false - } - } - - private static func ensureSpeechRecognition(interactive: Bool) async -> Bool { - let status = SFSpeechRecognizer.authorizationStatus() - if status == .notDetermined, interactive { - await withUnsafeContinuation { (cont: UnsafeContinuation) in - SFSpeechRecognizer.requestAuthorization { _ in - DispatchQueue.main.async { cont.resume() } - } - } - } - return SFSpeechRecognizer.authorizationStatus() == .authorized - } - - private static func ensureCamera(interactive: Bool) async -> Bool { - let status = AVCaptureDevice.authorizationStatus(for: .video) - switch status { - case .authorized: - return true - case .notDetermined: - guard interactive else { return false } - return await AVCaptureDevice.requestAccess(for: .video) - case .denied, .restricted: - if interactive { - CameraPermissionHelper.openSettings() - } - return false - @unknown default: - return false - } - } - - private static func ensureLocation(interactive: Bool) async -> Bool { - guard CLLocationManager.locationServicesEnabled() else { - if interactive { - await MainActor.run { LocationPermissionHelper.openSettings() } - } - return false - } - let status = CLLocationManager().authorizationStatus - switch status { - case .authorizedAlways, .authorizedWhenInUse, .authorized: - return true - case .notDetermined: - guard interactive else { return false } - let updated = await LocationPermissionRequester.shared.request(always: false) - return self.isLocationAuthorized(status: updated, requireAlways: false) - case .denied, .restricted: - if interactive { - await MainActor.run { LocationPermissionHelper.openSettings() } - } - return false - @unknown default: - return false - } - } - - static func voiceWakePermissionsGranted() -> Bool { - let mic = AVCaptureDevice.authorizationStatus(for: .audio) == .authorized - let speech = SFSpeechRecognizer.authorizationStatus() == .authorized - return mic && speech - } - - static func ensureVoiceWakePermissions(interactive: Bool) async -> Bool { - let results = await self.ensure([.microphone, .speechRecognition], interactive: interactive) - return results[.microphone] == true && results[.speechRecognition] == true - } - - static func status(_ caps: [Capability] = Capability.allCases) async -> [Capability: Bool] { - var results: [Capability: Bool] = [:] - for cap in caps { - switch cap { - case .notifications: - let center = UNUserNotificationCenter.current() - let settings = await center.notificationSettings() - results[cap] = settings.authorizationStatus == .authorized - || settings.authorizationStatus == .provisional - - case .appleScript: - results[cap] = await MainActor.run { AppleScriptPermission.isAuthorized() } - - case .accessibility: - results[cap] = await MainActor.run { AXIsProcessTrusted() } - - case .screenRecording: - if #available(macOS 10.15, *) { - results[cap] = CGPreflightScreenCaptureAccess() - } else { - results[cap] = true - } - - case .microphone: - results[cap] = AVCaptureDevice.authorizationStatus(for: .audio) == .authorized - - case .speechRecognition: - results[cap] = SFSpeechRecognizer.authorizationStatus() == .authorized - - case .camera: - results[cap] = AVCaptureDevice.authorizationStatus(for: .video) == .authorized - - case .location: - let status = CLLocationManager().authorizationStatus - results[cap] = CLLocationManager.locationServicesEnabled() - && self.isLocationAuthorized(status: status, requireAlways: false) - } - } - return results - } -} - -enum NotificationPermissionHelper { - static func openSettings() { - let candidates = [ - "x-apple.systempreferences:com.apple.Notifications-Settings.extension", - "x-apple.systempreferences:com.apple.preference.notifications", - ] - - for candidate in candidates { - if let url = URL(string: candidate), NSWorkspace.shared.open(url) { - return - } - } - } -} - -enum MicrophonePermissionHelper { - static func openSettings() { - let candidates = [ - "x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone", - "x-apple.systempreferences:com.apple.preference.security", - ] - - for candidate in candidates { - if let url = URL(string: candidate), NSWorkspace.shared.open(url) { - return - } - } - } -} - -enum CameraPermissionHelper { - static func openSettings() { - let candidates = [ - "x-apple.systempreferences:com.apple.preference.security?Privacy_Camera", - "x-apple.systempreferences:com.apple.preference.security", - ] - - for candidate in candidates { - if let url = URL(string: candidate), NSWorkspace.shared.open(url) { - return - } - } - } -} - -enum LocationPermissionHelper { - static func openSettings() { - let candidates = [ - "x-apple.systempreferences:com.apple.preference.security?Privacy_LocationServices", - "x-apple.systempreferences:com.apple.preference.security", - ] - - for candidate in candidates { - if let url = URL(string: candidate), NSWorkspace.shared.open(url) { - return - } - } - } -} - -@MainActor -final class LocationPermissionRequester: NSObject, CLLocationManagerDelegate { - static let shared = LocationPermissionRequester() - private let manager = CLLocationManager() - private var continuation: CheckedContinuation? - private var timeoutTask: Task? - - override init() { - super.init() - self.manager.delegate = self - } - - func request(always: Bool) async -> CLAuthorizationStatus { - let current = self.manager.authorizationStatus - if PermissionManager.isLocationAuthorized(status: current, requireAlways: always) { - return current - } - - return await withCheckedContinuation { cont in - self.continuation = cont - self.timeoutTask?.cancel() - self.timeoutTask = Task { [weak self] in - try? await Task.sleep(nanoseconds: 3_000_000_000) - await MainActor.run { [weak self] in - guard let self else { return } - guard self.continuation != nil else { return } - LocationPermissionHelper.openSettings() - self.finish(status: self.manager.authorizationStatus) - } - } - if always { - self.manager.requestAlwaysAuthorization() - } else { - self.manager.requestWhenInUseAuthorization() - } - - // On macOS, requesting an actual fix makes the prompt more reliable. - self.manager.requestLocation() - } - } - - private func finish(status: CLAuthorizationStatus) { - self.timeoutTask?.cancel() - self.timeoutTask = nil - guard let cont = self.continuation else { return } - self.continuation = nil - cont.resume(returning: status) - } - - // nonisolated for Swift 6 strict concurrency compatibility - nonisolated func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) { - let status = manager.authorizationStatus - Task { @MainActor in - self.finish(status: status) - } - } - - // Legacy callback (still used on some macOS versions / configurations). - nonisolated func locationManager( - _ manager: CLLocationManager, - didChangeAuthorization status: CLAuthorizationStatus) - { - Task { @MainActor in - self.finish(status: status) - } - } - - nonisolated func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) { - let status = manager.authorizationStatus - Task { @MainActor in - if status == .denied || status == .restricted { - LocationPermissionHelper.openSettings() - } - self.finish(status: status) - } - } - - nonisolated func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) { - let status = manager.authorizationStatus - Task { @MainActor in - self.finish(status: status) - } - } -} - -enum AppleScriptPermission { - private static let logger = Logger(subsystem: "com.clawdbot", category: "AppleScriptPermission") - - /// Sends a benign AppleScript to Terminal to verify Automation permission. - @MainActor - static func isAuthorized() -> Bool { - let script = """ - tell application "Terminal" - return "moltbot-ok" - end tell - """ - - var error: NSDictionary? - let appleScript = NSAppleScript(source: script) - let result = appleScript?.executeAndReturnError(&error) - - if let error, let code = error["NSAppleScriptErrorNumber"] as? Int { - if code == -1743 { // errAEEventWouldRequireUserConsent - Self.logger.debug("AppleScript permission denied (-1743)") - return false - } - Self.logger.debug("AppleScript check failed with code \(code)") - } - - return result != nil - } - - /// Triggers the TCC prompt and opens System Settings → Privacy & Security → Automation. - @MainActor - static func requestAuthorization() async { - _ = self.isAuthorized() // first attempt triggers the dialog if not granted - - // Open the Automation pane to help the user if the prompt was dismissed. - let urlStrings = [ - "x-apple.systempreferences:com.apple.preference.security?Privacy_Automation", - "x-apple.systempreferences:com.apple.preference.security", - ] - - for candidate in urlStrings { - if let url = URL(string: candidate), NSWorkspace.shared.open(url) { - break - } - } - } -} - -@MainActor -@Observable -final class PermissionMonitor { - static let shared = PermissionMonitor() - - private(set) var status: [Capability: Bool] = [:] - - private var monitorTimer: Timer? - private var isChecking = false - private var registrations = 0 - private var lastCheck: Date? - private let minimumCheckInterval: TimeInterval = 0.5 - - func register() { - self.registrations += 1 - if self.registrations == 1 { - self.startMonitoring() - } - } - - func unregister() { - guard self.registrations > 0 else { return } - self.registrations -= 1 - if self.registrations == 0 { - self.stopMonitoring() - } - } - - func refreshNow() async { - await self.checkStatus(force: true) - } - - private func startMonitoring() { - Task { await self.checkStatus(force: true) } - - if ProcessInfo.processInfo.isRunningTests { - return - } - self.monitorTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in - guard let self else { return } - Task { @MainActor in - await self.checkStatus(force: false) - } - } - } - - private func stopMonitoring() { - self.monitorTimer?.invalidate() - self.monitorTimer = nil - self.lastCheck = nil - } - - private func checkStatus(force: Bool) async { - if self.isChecking { return } - let now = Date() - if !force, let lastCheck, now.timeIntervalSince(lastCheck) < self.minimumCheckInterval { - return - } - - self.isChecking = true - - let latest = await PermissionManager.status() - if latest != self.status { - self.status = latest - } - self.lastCheck = Date() - - self.isChecking = false - } -} - -enum ScreenRecordingProbe { - static func isAuthorized() -> Bool { - if #available(macOS 10.15, *) { - return CGPreflightScreenCaptureAccess() - } - return true - } - - @MainActor - static func requestAuthorization() async { - if #available(macOS 10.15, *) { - _ = CGRequestScreenCaptureAccess() - } - } -} diff --git a/apps/macos/Sources/Clawdbot/PortGuardian.swift b/apps/macos/Sources/Clawdbot/PortGuardian.swift deleted file mode 100644 index c28e3eda0..000000000 --- a/apps/macos/Sources/Clawdbot/PortGuardian.swift +++ /dev/null @@ -1,418 +0,0 @@ -import Foundation -import OSLog -#if canImport(Darwin) -import Darwin -#endif - -actor PortGuardian { - static let shared = PortGuardian() - - struct Record: Codable { - let port: Int - let pid: Int32 - let command: String - let mode: String - let timestamp: TimeInterval - } - - struct Descriptor: Sendable { - let pid: Int32 - let command: String - let executablePath: String? - } - - private var records: [Record] = [] - private let logger = Logger(subsystem: "com.clawdbot", category: "portguard") - private nonisolated static let appSupportDir: URL = { - let base = FileManager().urls(for: .applicationSupportDirectory, in: .userDomainMask).first! - return base.appendingPathComponent("Moltbot", isDirectory: true) - }() - - private nonisolated static var recordPath: URL { - self.appSupportDir.appendingPathComponent("port-guard.json", isDirectory: false) - } - - init() { - self.records = Self.loadRecords(from: Self.recordPath) - } - - func sweep(mode: AppState.ConnectionMode) async { - self.logger.info("port sweep starting (mode=\(mode.rawValue, privacy: .public))") - guard mode != .unconfigured else { - self.logger.info("port sweep skipped (mode=unconfigured)") - return - } - let ports = [GatewayEnvironment.gatewayPort()] - for port in ports { - let listeners = await self.listeners(on: port) - guard !listeners.isEmpty else { continue } - for listener in listeners { - if self.isExpected(listener, port: port, mode: mode) { - let message = """ - port \(port) already served by expected \(listener.command) - (pid \(listener.pid)) — keeping - """ - self.logger.info("\(message, privacy: .public)") - continue - } - let killed = await self.kill(listener.pid) - if killed { - let message = """ - port \(port) was held by \(listener.command) - (pid \(listener.pid)); terminated - """ - self.logger.error("\(message, privacy: .public)") - } else { - self.logger.error("failed to terminate pid \(listener.pid) on port \(port, privacy: .public)") - } - } - } - self.logger.info("port sweep done") - } - - func record(port: Int, pid: Int32, command: String, mode: AppState.ConnectionMode) async { - try? FileManager().createDirectory(at: Self.appSupportDir, withIntermediateDirectories: true) - self.records.removeAll { $0.pid == pid } - self.records.append( - Record( - port: port, - pid: pid, - command: command, - mode: mode.rawValue, - timestamp: Date().timeIntervalSince1970)) - self.save() - } - - func removeRecord(pid: Int32) { - let before = self.records.count - self.records.removeAll { $0.pid == pid } - if self.records.count != before { - self.save() - } - } - - struct PortReport: Identifiable { - enum Status { - case ok(String) - case missing(String) - case interference(String, offenders: [ReportListener]) - } - - let port: Int - let expected: String - let status: Status - let listeners: [ReportListener] - - var id: Int { self.port } - - var offenders: [ReportListener] { - if case let .interference(_, offenders) = self.status { return offenders } - return [] - } - - var summary: String { - switch self.status { - case let .ok(text): text - case let .missing(text): text - case let .interference(text, _): text - } - } - } - - func describe(port: Int) async -> Descriptor? { - guard let listener = await self.listeners(on: port).first else { return nil } - let path = Self.executablePath(for: listener.pid) - return Descriptor(pid: listener.pid, command: listener.command, executablePath: path) - } - - // MARK: - Internals - - private struct Listener { - let pid: Int32 - let command: String - let fullCommand: String - let user: String? - } - - struct ReportListener: Identifiable { - let pid: Int32 - let command: String - let fullCommand: String - let user: String? - let expected: Bool - - var id: Int32 { self.pid } - } - - func diagnose(mode: AppState.ConnectionMode) async -> [PortReport] { - if mode == .unconfigured { - return [] - } - let ports = [GatewayEnvironment.gatewayPort()] - var reports: [PortReport] = [] - - for port in ports { - let listeners = await self.listeners(on: port) - let tunnelHealthy = await self.probeGatewayHealthIfNeeded( - port: port, - mode: mode, - listeners: listeners) - reports.append(Self.buildReport( - port: port, - listeners: listeners, - mode: mode, - tunnelHealthy: tunnelHealthy)) - } - - return reports - } - - func probeGatewayHealth(port: Int, timeout: TimeInterval = 2.0) async -> Bool { - let url = URL(string: "http://127.0.0.1:\(port)/")! - let config = URLSessionConfiguration.ephemeral - config.timeoutIntervalForRequest = timeout - config.timeoutIntervalForResource = timeout - let session = URLSession(configuration: config) - var request = URLRequest(url: url) - request.cachePolicy = .reloadIgnoringLocalCacheData - request.timeoutInterval = timeout - do { - let (_, response) = try await session.data(for: request) - return response is HTTPURLResponse - } catch { - return false - } - } - - func isListening(port: Int, pid: Int32? = nil) async -> Bool { - let listeners = await self.listeners(on: port) - if let pid { - return listeners.contains(where: { $0.pid == pid }) - } - return !listeners.isEmpty - } - - private func listeners(on port: Int) async -> [Listener] { - let res = await ShellExecutor.run( - command: ["lsof", "-nP", "-iTCP:\(port)", "-sTCP:LISTEN", "-Fpcn"], - cwd: nil, - env: nil, - timeout: 5) - guard res.ok, let data = res.payload, !data.isEmpty else { return [] } - let text = String(data: data, encoding: .utf8) ?? "" - return Self.parseListeners(from: text) - } - - private static func readFullCommand(pid: Int32) -> String? { - let proc = Process() - proc.executableURL = URL(fileURLWithPath: "/bin/ps") - proc.arguments = ["-p", "\(pid)", "-o", "command="] - let pipe = Pipe() - proc.standardOutput = pipe - proc.standardError = Pipe() - do { - let data = try proc.runAndReadToEnd(from: pipe) - guard !data.isEmpty else { return nil } - return String(data: data, encoding: .utf8)? - .trimmingCharacters(in: .whitespacesAndNewlines) - } catch { - return nil - } - } - - private static func parseListeners(from text: String) -> [Listener] { - var listeners: [Listener] = [] - var currentPid: Int32? - var currentCmd: String? - var currentUser: String? - - func flush() { - if let pid = currentPid, let cmd = currentCmd { - let full = Self.readFullCommand(pid: pid) ?? cmd - listeners.append(Listener(pid: pid, command: cmd, fullCommand: full, user: currentUser)) - } - currentPid = nil - currentCmd = nil - currentUser = nil - } - - for line in text.split(separator: "\n") { - guard let prefix = line.first else { continue } - let value = String(line.dropFirst()) - switch prefix { - case "p": - flush() - currentPid = Int32(value) ?? 0 - case "c": - currentCmd = value - case "u": - currentUser = value - default: - continue - } - } - flush() - return listeners - } - - private static func buildReport( - port: Int, - listeners: [Listener], - mode: AppState.ConnectionMode, - tunnelHealthy: Bool?) -> PortReport - { - let expectedDesc: String - let okPredicate: (Listener) -> Bool - let expectedCommands = ["node", "moltbot", "tsx", "pnpm", "bun"] - - switch mode { - case .remote: - expectedDesc = "SSH tunnel to remote gateway" - okPredicate = { $0.command.lowercased().contains("ssh") } - case .local: - expectedDesc = "Gateway websocket (node/tsx)" - okPredicate = { listener in - let c = listener.command.lowercased() - return expectedCommands.contains { c.contains($0) } - } - case .unconfigured: - expectedDesc = "Gateway not configured" - okPredicate = { _ in false } - } - - if listeners.isEmpty { - let text = "Nothing is listening on \(port) (\(expectedDesc))." - return .init(port: port, expected: expectedDesc, status: .missing(text), listeners: []) - } - - let tunnelUnhealthy = - mode == .remote && port == GatewayEnvironment.gatewayPort() && tunnelHealthy == false - let reportListeners = listeners.map { listener in - var expected = okPredicate(listener) - if tunnelUnhealthy, expected { expected = false } - return ReportListener( - pid: listener.pid, - command: listener.command, - fullCommand: listener.fullCommand, - user: listener.user, - expected: expected) - } - - let offenders = reportListeners.filter { !$0.expected } - if tunnelUnhealthy { - let list = listeners.map { "\($0.command) (\($0.pid))" }.joined(separator: ", ") - let reason = "Port \(port) is served by \(list), but the SSH tunnel is unhealthy." - return .init( - port: port, - expected: expectedDesc, - status: .interference(reason, offenders: offenders), - listeners: reportListeners) - } - if offenders.isEmpty { - let list = listeners.map { "\($0.command) (\($0.pid))" }.joined(separator: ", ") - let okText = "Port \(port) is served by \(list)." - return .init( - port: port, - expected: expectedDesc, - status: .ok(okText), - listeners: reportListeners) - } - - let list = offenders.map { "\($0.command) (\($0.pid))" }.joined(separator: ", ") - let reason = "Port \(port) is held by \(list), expected \(expectedDesc)." - return .init( - port: port, - expected: expectedDesc, - status: .interference(reason, offenders: offenders), - listeners: reportListeners) - } - - private static func executablePath(for pid: Int32) -> String? { - #if canImport(Darwin) - var buffer = [CChar](repeating: 0, count: Int(PATH_MAX)) - let length = proc_pidpath(pid, &buffer, UInt32(buffer.count)) - guard length > 0 else { return nil } - // Drop trailing null and decode as UTF-8. - let trimmed = buffer.prefix { $0 != 0 } - let bytes = trimmed.map { UInt8(bitPattern: $0) } - return String(bytes: bytes, encoding: .utf8) - #else - return nil - #endif - } - - private func kill(_ pid: Int32) async -> Bool { - let term = await ShellExecutor.run(command: ["kill", "-TERM", "\(pid)"], cwd: nil, env: nil, timeout: 2) - if term.ok { return true } - let sigkill = await ShellExecutor.run(command: ["kill", "-KILL", "\(pid)"], cwd: nil, env: nil, timeout: 2) - return sigkill.ok - } - - private func isExpected(_ listener: Listener, port: Int, mode: AppState.ConnectionMode) -> Bool { - let cmd = listener.command.lowercased() - let full = listener.fullCommand.lowercased() - switch mode { - case .remote: - // Remote mode expects an SSH tunnel for the gateway WebSocket port. - if port == GatewayEnvironment.gatewayPort() { return cmd.contains("ssh") } - return false - case .local: - // The gateway daemon may listen as `moltbot` or as its runtime (`node`, `bun`, etc). - if full.contains("gateway-daemon") { return true } - // If args are unavailable, treat a moltbot listener as expected. - if cmd.contains("moltbot"), full == cmd { return true } - return false - case .unconfigured: - return false - } - } - - private func probeGatewayHealthIfNeeded( - port: Int, - mode: AppState.ConnectionMode, - listeners: [Listener]) async -> Bool? - { - guard mode == .remote, port == GatewayEnvironment.gatewayPort(), !listeners.isEmpty else { return nil } - let hasSsh = listeners.contains { $0.command.lowercased().contains("ssh") } - guard hasSsh else { return nil } - return await self.probeGatewayHealth(port: port) - } - - private static func loadRecords(from url: URL) -> [Record] { - guard let data = try? Data(contentsOf: url), - let decoded = try? JSONDecoder().decode([Record].self, from: data) - else { return [] } - return decoded - } - - private func save() { - guard let data = try? JSONEncoder().encode(self.records) else { return } - try? data.write(to: Self.recordPath, options: [.atomic]) - } -} - -#if DEBUG -extension PortGuardian { - static func _testParseListeners(_ text: String) -> [( - pid: Int32, - command: String, - fullCommand: String, - user: String?)] - { - self.parseListeners(from: text).map { ($0.pid, $0.command, $0.fullCommand, $0.user) } - } - - static func _testBuildReport( - port: Int, - mode: AppState.ConnectionMode, - listeners: [(pid: Int32, command: String, fullCommand: String, user: String?)]) -> PortReport - { - let mapped = listeners.map { Listener( - pid: $0.pid, - command: $0.command, - fullCommand: $0.fullCommand, - user: $0.user) } - return Self.buildReport(port: port, listeners: mapped, mode: mode, tunnelHealthy: nil) - } -} -#endif diff --git a/apps/macos/Sources/Clawdbot/PresenceReporter.swift b/apps/macos/Sources/Clawdbot/PresenceReporter.swift deleted file mode 100644 index 8bffaefa0..000000000 --- a/apps/macos/Sources/Clawdbot/PresenceReporter.swift +++ /dev/null @@ -1,158 +0,0 @@ -import Cocoa -import Darwin -import Foundation -import OSLog - -@MainActor -final class PresenceReporter { - static let shared = PresenceReporter() - - private let logger = Logger(subsystem: "com.clawdbot", category: "presence") - private var task: Task? - private let interval: TimeInterval = 180 // a few minutes - private let instanceId: String = InstanceIdentity.instanceId - - func start() { - guard self.task == nil else { return } - self.task = Task.detached { [weak self] in - guard let self else { return } - await self.push(reason: "launch") - while !Task.isCancelled { - try? await Task.sleep(nanoseconds: UInt64(self.interval * 1_000_000_000)) - await self.push(reason: "periodic") - } - } - } - - func stop() { - self.task?.cancel() - self.task = nil - } - - @Sendable - private func push(reason: String) async { - let mode = await MainActor.run { AppStateStore.shared.connectionMode.rawValue } - let host = InstanceIdentity.displayName - let ip = Self.primaryIPv4Address() ?? "ip-unknown" - let version = Self.appVersionString() - let platform = Self.platformString() - let lastInput = Self.lastInputSeconds() - let text = Self.composePresenceSummary(mode: mode, reason: reason) - var params: [String: AnyHashable] = [ - "instanceId": AnyHashable(self.instanceId), - "host": AnyHashable(host), - "ip": AnyHashable(ip), - "mode": AnyHashable(mode), - "version": AnyHashable(version), - "platform": AnyHashable(platform), - "deviceFamily": AnyHashable("Mac"), - "reason": AnyHashable(reason), - ] - if let model = InstanceIdentity.modelIdentifier { params["modelIdentifier"] = AnyHashable(model) } - if let lastInput { params["lastInputSeconds"] = AnyHashable(lastInput) } - do { - try await ControlChannel.shared.sendSystemEvent(text, params: params) - } catch { - self.logger.error("presence send failed: \(error.localizedDescription, privacy: .public)") - } - } - - /// Fire an immediate presence beacon (e.g., right after connecting). - func sendImmediate(reason: String = "connect") { - Task { await self.push(reason: reason) } - } - - private static func composePresenceSummary(mode: String, reason: String) -> String { - let host = InstanceIdentity.displayName - let ip = Self.primaryIPv4Address() ?? "ip-unknown" - let version = Self.appVersionString() - let lastInput = Self.lastInputSeconds() - let lastLabel = lastInput.map { "last input \($0)s ago" } ?? "last input unknown" - return "Node: \(host) (\(ip)) · app \(version) · \(lastLabel) · mode \(mode) · reason \(reason)" - } - - private static func appVersionString() -> String { - let version = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String ?? "dev" - if let build = Bundle.main.object(forInfoDictionaryKey: "CFBundleVersion") as? String { - let trimmed = build.trimmingCharacters(in: .whitespacesAndNewlines) - if !trimmed.isEmpty, trimmed != version { - return "\(version) (\(trimmed))" - } - } - return version - } - - private static func platformString() -> String { - let v = ProcessInfo.processInfo.operatingSystemVersion - return "macos \(v.majorVersion).\(v.minorVersion).\(v.patchVersion)" - } - - private static func lastInputSeconds() -> Int? { - let anyEvent = CGEventType(rawValue: UInt32.max) ?? .null - let seconds = CGEventSource.secondsSinceLastEventType(.combinedSessionState, eventType: anyEvent) - if seconds.isNaN || seconds.isInfinite || seconds < 0 { return nil } - return Int(seconds.rounded()) - } - - private static func primaryIPv4Address() -> String? { - var addrList: UnsafeMutablePointer? - guard getifaddrs(&addrList) == 0, let first = addrList else { return nil } - defer { freeifaddrs(addrList) } - - var fallback: String? - var en0: String? - - for ptr in sequence(first: first, next: { $0.pointee.ifa_next }) { - let flags = Int32(ptr.pointee.ifa_flags) - let isUp = (flags & IFF_UP) != 0 - let isLoopback = (flags & IFF_LOOPBACK) != 0 - let name = String(cString: ptr.pointee.ifa_name) - let family = ptr.pointee.ifa_addr.pointee.sa_family - if !isUp || isLoopback || family != UInt8(AF_INET) { continue } - - var addr = ptr.pointee.ifa_addr.pointee - var buffer = [CChar](repeating: 0, count: Int(NI_MAXHOST)) - let result = getnameinfo( - &addr, - socklen_t(ptr.pointee.ifa_addr.pointee.sa_len), - &buffer, - socklen_t(buffer.count), - nil, - 0, - NI_NUMERICHOST) - guard result == 0 else { continue } - let len = buffer.prefix { $0 != 0 } - let bytes = len.map { UInt8(bitPattern: $0) } - guard let ip = String(bytes: bytes, encoding: .utf8) else { continue } - - if name == "en0" { en0 = ip; break } - if fallback == nil { fallback = ip } - } - - return en0 ?? fallback - } -} - -#if DEBUG -extension PresenceReporter { - static func _testComposePresenceSummary(mode: String, reason: String) -> String { - self.composePresenceSummary(mode: mode, reason: reason) - } - - static func _testAppVersionString() -> String { - self.appVersionString() - } - - static func _testPlatformString() -> String { - self.platformString() - } - - static func _testLastInputSeconds() -> Int? { - self.lastInputSeconds() - } - - static func _testPrimaryIPv4Address() -> String? { - self.primaryIPv4Address() - } -} -#endif diff --git a/apps/macos/Sources/Clawdbot/RemotePortTunnel.swift b/apps/macos/Sources/Clawdbot/RemotePortTunnel.swift deleted file mode 100644 index e95f3f50d..000000000 --- a/apps/macos/Sources/Clawdbot/RemotePortTunnel.swift +++ /dev/null @@ -1,317 +0,0 @@ -import Foundation -import Network -import OSLog -#if canImport(Darwin) -import Darwin -#endif - -/// Port forwarding tunnel for remote mode. -/// -/// Uses `ssh -N -L` to forward the remote gateway ports to localhost. -final class RemotePortTunnel { - private static let logger = Logger(subsystem: "com.clawdbot", category: "remote.tunnel") - - let process: Process - let localPort: UInt16? - private let stderrHandle: FileHandle? - - private init(process: Process, localPort: UInt16?, stderrHandle: FileHandle?) { - self.process = process - self.localPort = localPort - self.stderrHandle = stderrHandle - } - - deinit { - Self.cleanupStderr(self.stderrHandle) - let pid = self.process.processIdentifier - self.process.terminate() - Task { await PortGuardian.shared.removeRecord(pid: pid) } - } - - func terminate() { - Self.cleanupStderr(self.stderrHandle) - let pid = self.process.processIdentifier - if self.process.isRunning { - self.process.terminate() - self.process.waitUntilExit() - } - Task { await PortGuardian.shared.removeRecord(pid: pid) } - } - - static func create( - remotePort: Int, - preferredLocalPort: UInt16? = nil, - allowRemoteUrlOverride: Bool = true, - allowRandomLocalPort: Bool = true) async throws -> RemotePortTunnel - { - let settings = CommandResolver.connectionSettings() - guard settings.mode == .remote, let parsed = CommandResolver.parseSSHTarget(settings.target) else { - throw NSError( - domain: "RemotePortTunnel", - code: 3, - userInfo: [NSLocalizedDescriptionKey: "Remote mode is not configured"]) - } - - let localPort = try await Self.findPort( - preferred: preferredLocalPort, - allowRandom: allowRandomLocalPort) - let sshHost = parsed.host.trimmingCharacters(in: .whitespacesAndNewlines) - let remotePortOverride = - allowRemoteUrlOverride && remotePort == GatewayEnvironment.gatewayPort() - ? Self.resolveRemotePortOverride(for: sshHost) - : nil - let resolvedRemotePort = remotePortOverride ?? remotePort - if let override = remotePortOverride { - Self.logger.info( - "ssh tunnel remote port override " + - "host=\(sshHost, privacy: .public) port=\(override, privacy: .public)") - } else { - Self.logger.debug( - "ssh tunnel using default remote port " + - "host=\(sshHost, privacy: .public) port=\(remotePort, privacy: .public)") - } - let options: [String] = [ - "-o", "BatchMode=yes", - "-o", "ExitOnForwardFailure=yes", - "-o", "StrictHostKeyChecking=accept-new", - "-o", "UpdateHostKeys=yes", - "-o", "ServerAliveInterval=15", - "-o", "ServerAliveCountMax=3", - "-o", "TCPKeepAlive=yes", - "-N", - "-L", "\(localPort):127.0.0.1:\(resolvedRemotePort)", - ] - let identity = settings.identity.trimmingCharacters(in: .whitespacesAndNewlines) - let args = CommandResolver.sshArguments( - target: parsed, - identity: identity, - options: options) - - let process = Process() - process.executableURL = URL(fileURLWithPath: "/usr/bin/ssh") - process.arguments = args - - let pipe = Pipe() - process.standardError = pipe - let stderrHandle = pipe.fileHandleForReading - - // Consume stderr so ssh cannot block if it logs. - stderrHandle.readabilityHandler = { handle in - let data = handle.readSafely(upToCount: 64 * 1024) - guard !data.isEmpty else { - // EOF (or read failure): stop monitoring to avoid spinning on a closed pipe. - Self.cleanupStderr(handle) - return - } - guard let line = String(data: data, encoding: .utf8)? - .trimmingCharacters(in: .whitespacesAndNewlines), - !line.isEmpty - else { return } - Self.logger.error("ssh tunnel stderr: \(line, privacy: .public)") - } - process.terminationHandler = { _ in - Self.cleanupStderr(stderrHandle) - } - - try process.run() - - // If ssh exits immediately (e.g. local port already in use), surface stderr and ensure we stop monitoring. - try? await Task.sleep(nanoseconds: 150_000_000) // 150ms - if !process.isRunning { - let stderr = Self.drainStderr(stderrHandle) - let msg = stderr.isEmpty ? "ssh tunnel exited immediately" : "ssh tunnel failed: \(stderr)" - throw NSError(domain: "RemotePortTunnel", code: 4, userInfo: [NSLocalizedDescriptionKey: msg]) - } - - // Track tunnel so we can clean up stale listeners on restart. - Task { - await PortGuardian.shared.record( - port: Int(localPort), - pid: process.processIdentifier, - command: process.executableURL?.path ?? "ssh", - mode: CommandResolver.connectionSettings().mode) - } - - return RemotePortTunnel(process: process, localPort: localPort, stderrHandle: stderrHandle) - } - - private static func resolveRemotePortOverride(for sshHost: String) -> Int? { - let root = MoltbotConfigFile.loadDict() - guard let gateway = root["gateway"] as? [String: Any], - let remote = gateway["remote"] as? [String: Any], - let urlRaw = remote["url"] as? String - else { - return nil - } - let trimmed = urlRaw.trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty, let url = URL(string: trimmed), let port = url.port else { - return nil - } - guard let host = url.host?.trimmingCharacters(in: .whitespacesAndNewlines), - !host.isEmpty - else { - return nil - } - let sshKey = Self.hostKey(sshHost) - let urlKey = Self.hostKey(host) - guard !sshKey.isEmpty, !urlKey.isEmpty else { return nil } - guard sshKey == urlKey else { - Self.logger.debug( - "remote url host mismatch sshHost=\(sshHost, privacy: .public) urlHost=\(host, privacy: .public)") - return nil - } - return port - } - - private static func hostKey(_ host: String) -> String { - let trimmed = host.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() - guard !trimmed.isEmpty else { return "" } - if trimmed.contains(":") { return trimmed } - let digits = CharacterSet(charactersIn: "0123456789.") - if trimmed.rangeOfCharacter(from: digits.inverted) == nil { - return trimmed - } - return trimmed.split(separator: ".").first.map(String.init) ?? trimmed - } - - private static func findPort(preferred: UInt16?, allowRandom: Bool) async throws -> UInt16 { - if let preferred, self.portIsFree(preferred) { return preferred } - if let preferred, !allowRandom { - throw NSError( - domain: "RemotePortTunnel", - code: 5, - userInfo: [ - NSLocalizedDescriptionKey: "Local port \(preferred) is unavailable", - ]) - } - - return try await withCheckedThrowingContinuation { cont in - let queue = DispatchQueue(label: "com.clawdbot.remote.tunnel.port", qos: .utility) - do { - let listener = try NWListener(using: .tcp, on: .any) - listener.newConnectionHandler = { connection in connection.cancel() } - listener.stateUpdateHandler = { state in - switch state { - case .ready: - if let port = listener.port?.rawValue { - listener.stateUpdateHandler = nil - listener.cancel() - cont.resume(returning: port) - } - case let .failed(error): - listener.stateUpdateHandler = nil - listener.cancel() - cont.resume(throwing: error) - default: - break - } - } - listener.start(queue: queue) - } catch { - cont.resume(throwing: error) - } - } - } - - private static func portIsFree(_ port: UInt16) -> Bool { - #if canImport(Darwin) - // NWListener can succeed even when only one address family is held. Mirror what ssh needs by checking - // both 127.0.0.1 and ::1 for availability. - return self.canBindIPv4(port) && self.canBindIPv6(port) - #else - do { - let listener = try NWListener(using: .tcp, on: NWEndpoint.Port(rawValue: port)!) - listener.cancel() - return true - } catch { - return false - } - #endif - } - - #if canImport(Darwin) - private static func canBindIPv4(_ port: UInt16) -> Bool { - let fd = socket(AF_INET, SOCK_STREAM, 0) - guard fd >= 0 else { return false } - defer { _ = Darwin.close(fd) } - - var one: Int32 = 1 - _ = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, socklen_t(MemoryLayout.size(ofValue: one))) - - var addr = sockaddr_in() - addr.sin_len = UInt8(MemoryLayout.size) - addr.sin_family = sa_family_t(AF_INET) - addr.sin_port = port.bigEndian - addr.sin_addr = in_addr(s_addr: inet_addr("127.0.0.1")) - - let result = withUnsafePointer(to: &addr) { ptr in - ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in - Darwin.bind(fd, sa, socklen_t(MemoryLayout.size)) - } - } - return result == 0 - } - - private static func canBindIPv6(_ port: UInt16) -> Bool { - let fd = socket(AF_INET6, SOCK_STREAM, 0) - guard fd >= 0 else { return false } - defer { _ = Darwin.close(fd) } - - var one: Int32 = 1 - _ = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, socklen_t(MemoryLayout.size(ofValue: one))) - - var addr = sockaddr_in6() - addr.sin6_len = UInt8(MemoryLayout.size) - addr.sin6_family = sa_family_t(AF_INET6) - addr.sin6_port = port.bigEndian - var loopback = in6_addr() - _ = withUnsafeMutablePointer(to: &loopback) { ptr in - inet_pton(AF_INET6, "::1", ptr) - } - addr.sin6_addr = loopback - - let result = withUnsafePointer(to: &addr) { ptr in - ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in - Darwin.bind(fd, sa, socklen_t(MemoryLayout.size)) - } - } - return result == 0 - } - #endif - - private static func cleanupStderr(_ handle: FileHandle?) { - guard let handle else { return } - Self.cleanupStderr(handle) - } - - private static func cleanupStderr(_ handle: FileHandle) { - if handle.readabilityHandler != nil { - handle.readabilityHandler = nil - } - try? handle.close() - } - - private static func drainStderr(_ handle: FileHandle) -> String { - handle.readabilityHandler = nil - defer { try? handle.close() } - - do { - let data = try handle.readToEnd() ?? Data() - return String(data: data, encoding: .utf8)? - .trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - } catch { - self.logger.debug("Failed to drain ssh stderr: \(error, privacy: .public)") - return "" - } - } - - #if SWIFT_PACKAGE - static func _testPortIsFree(_ port: UInt16) -> Bool { - self.portIsFree(port) - } - - static func _testDrainStderr(_ handle: FileHandle) -> String { - self.drainStderr(handle) - } - #endif -} diff --git a/apps/macos/Sources/Clawdbot/RemoteTunnelManager.swift b/apps/macos/Sources/Clawdbot/RemoteTunnelManager.swift deleted file mode 100644 index 78a5154a9..000000000 --- a/apps/macos/Sources/Clawdbot/RemoteTunnelManager.swift +++ /dev/null @@ -1,122 +0,0 @@ -import Foundation -import OSLog - -/// Manages the SSH tunnel that forwards the remote gateway/control port to localhost. -actor RemoteTunnelManager { - static let shared = RemoteTunnelManager() - - private let logger = Logger(subsystem: "com.clawdbot", category: "remote-tunnel") - private var controlTunnel: RemotePortTunnel? - private var restartInFlight = false - private var lastRestartAt: Date? - private let restartBackoffSeconds: TimeInterval = 2.0 - - func controlTunnelPortIfRunning() async -> UInt16? { - if self.restartInFlight { - self.logger.info("control tunnel restart in flight; skipping reuse check") - return nil - } - if let tunnel = self.controlTunnel, - tunnel.process.isRunning, - let local = tunnel.localPort - { - let pid = tunnel.process.processIdentifier - if await PortGuardian.shared.isListening(port: Int(local), pid: pid) { - self.logger.info("reusing active SSH tunnel localPort=\(local, privacy: .public)") - return local - } - self.logger.error( - "active SSH tunnel on port \(local, privacy: .public) is not listening; restarting") - await self.beginRestart() - tunnel.terminate() - self.controlTunnel = nil - } - // If a previous Moltbot run already has an SSH listener on the expected port (common after restarts), - // reuse it instead of spawning new ssh processes that immediately fail with "Address already in use". - let desiredPort = UInt16(GatewayEnvironment.gatewayPort()) - if let desc = await PortGuardian.shared.describe(port: Int(desiredPort)), - self.isSshProcess(desc) - { - self.logger.info( - "reusing existing SSH tunnel listener " + - "localPort=\(desiredPort, privacy: .public) " + - "pid=\(desc.pid, privacy: .public)") - return desiredPort - } - return nil - } - - /// Ensure an SSH tunnel is running for the gateway control port. - /// Returns the local forwarded port (usually the configured gateway port). - func ensureControlTunnel() async throws -> UInt16 { - let settings = CommandResolver.connectionSettings() - guard settings.mode == .remote else { - throw NSError( - domain: "RemoteTunnel", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "Remote mode is not enabled"]) - } - - let identitySet = !settings.identity.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty - self.logger.info( - "ensure SSH tunnel target=\(settings.target, privacy: .public) " + - "identitySet=\(identitySet, privacy: .public)") - - if let local = await self.controlTunnelPortIfRunning() { return local } - await self.waitForRestartBackoffIfNeeded() - - let desiredPort = UInt16(GatewayEnvironment.gatewayPort()) - let tunnel = try await RemotePortTunnel.create( - remotePort: GatewayEnvironment.gatewayPort(), - preferredLocalPort: desiredPort, - allowRandomLocalPort: false) - self.controlTunnel = tunnel - self.endRestart() - let resolvedPort = tunnel.localPort ?? desiredPort - self.logger.info("ssh tunnel ready localPort=\(resolvedPort, privacy: .public)") - return tunnel.localPort ?? desiredPort - } - - func stopAll() { - self.controlTunnel?.terminate() - self.controlTunnel = nil - } - - private func isSshProcess(_ desc: PortGuardian.Descriptor) -> Bool { - let cmd = desc.command.lowercased() - if cmd.contains("ssh") { return true } - if let path = desc.executablePath?.lowercased(), path.contains("/ssh") { return true } - return false - } - - private func beginRestart() async { - guard !self.restartInFlight else { return } - self.restartInFlight = true - self.lastRestartAt = Date() - self.logger.info("control tunnel restart started") - Task { [weak self] in - guard let self else { return } - try? await Task.sleep(nanoseconds: UInt64(self.restartBackoffSeconds * 1_000_000_000)) - await self.endRestart() - } - } - - private func endRestart() { - if self.restartInFlight { - self.restartInFlight = false - self.logger.info("control tunnel restart finished") - } - } - - private func waitForRestartBackoffIfNeeded() async { - guard let last = self.lastRestartAt else { return } - let elapsed = Date().timeIntervalSince(last) - let remaining = self.restartBackoffSeconds - elapsed - guard remaining > 0 else { return } - self.logger.info( - "control tunnel restart backoff \(remaining, privacy: .public)s") - try? await Task.sleep(nanoseconds: UInt64(remaining * 1_000_000_000)) - } - - // Keep tunnel reuse lightweight; restart only when the listener disappears. -} diff --git a/apps/macos/Sources/Clawdbot/Resources/Info.plist b/apps/macos/Sources/Clawdbot/Resources/Info.plist deleted file mode 100644 index 83a81468b..000000000 --- a/apps/macos/Sources/Clawdbot/Resources/Info.plist +++ /dev/null @@ -1,79 +0,0 @@ - - - - - CFBundleDevelopmentRegion - en - CFBundleExecutable - Moltbot - CFBundleIdentifier - com.clawdbot.mac - CFBundleInfoDictionaryVersion - 6.0 - CFBundleName - Moltbot - CFBundlePackageType - APPL - CFBundleShortVersionString - 2026.1.26 - CFBundleVersion - 202601260 - CFBundleIconFile - Moltbot - CFBundleURLTypes - - - CFBundleURLName - com.clawdbot.mac.deeplink - CFBundleURLSchemes - - moltbot - - - - LSMinimumSystemVersion - 15.0 - LSUIElement - - - MoltbotBuildTimestamp - - MoltbotGitCommit - - - NSUserNotificationUsageDescription - Moltbot needs notification permission to show alerts for agent actions. - NSScreenCaptureDescription - Moltbot captures the screen when the agent needs screenshots for context. - NSCameraUsageDescription - Moltbot can capture photos or short video clips when requested by the agent. - NSLocationUsageDescription - Moltbot can share your location when requested by the agent. - NSLocationWhenInUseUsageDescription - Moltbot can share your location when requested by the agent. - NSLocationAlwaysAndWhenInUseUsageDescription - Moltbot can share your location when requested by the agent. - NSMicrophoneUsageDescription - Moltbot needs the mic for Voice Wake tests and agent audio capture. - NSSpeechRecognitionUsageDescription - Moltbot uses speech recognition to detect your Voice Wake trigger phrase. - NSAppleEventsUsageDescription - Moltbot needs Automation (AppleScript) permission to drive Terminal and other apps for agent actions. - - NSAppTransportSecurity - - NSAllowsArbitraryLoadsInWebContent - - NSExceptionDomains - - 100.100.100.100 - - NSExceptionAllowsInsecureHTTPLoads - - NSIncludesSubdomains - - - - - - diff --git a/apps/macos/Sources/Clawdbot/RuntimeLocator.swift b/apps/macos/Sources/Clawdbot/RuntimeLocator.swift deleted file mode 100644 index 775613457..000000000 --- a/apps/macos/Sources/Clawdbot/RuntimeLocator.swift +++ /dev/null @@ -1,167 +0,0 @@ -import Foundation -import OSLog - -enum RuntimeKind: String { - case node -} - -struct RuntimeVersion: Comparable, CustomStringConvertible { - let major: Int - let minor: Int - let patch: Int - - var description: String { "\(self.major).\(self.minor).\(self.patch)" } - - static func < (lhs: RuntimeVersion, rhs: RuntimeVersion) -> Bool { - if lhs.major != rhs.major { return lhs.major < rhs.major } - if lhs.minor != rhs.minor { return lhs.minor < rhs.minor } - return lhs.patch < rhs.patch - } - - static func from(string: String) -> RuntimeVersion? { - // Accept optional leading "v" and ignore trailing metadata. - let pattern = #"(\d+)\.(\d+)\.(\d+)"# - guard let match = string.range(of: pattern, options: .regularExpression) else { return nil } - let versionString = String(string[match]) - let parts = versionString.split(separator: ".") - guard parts.count == 3, - let major = Int(parts[0]), - let minor = Int(parts[1]), - let patch = Int(parts[2]) - else { return nil } - return RuntimeVersion(major: major, minor: minor, patch: patch) - } -} - -struct RuntimeResolution { - let kind: RuntimeKind - let path: String - let version: RuntimeVersion -} - -enum RuntimeResolutionError: Error { - case notFound(searchPaths: [String]) - case unsupported( - kind: RuntimeKind, - found: RuntimeVersion, - required: RuntimeVersion, - path: String, - searchPaths: [String]) - case versionParse(kind: RuntimeKind, raw: String, path: String, searchPaths: [String]) -} - -enum RuntimeLocator { - private static let logger = Logger(subsystem: "com.clawdbot", category: "runtime") - private static let minNode = RuntimeVersion(major: 22, minor: 0, patch: 0) - - static func resolve( - searchPaths: [String] = CommandResolver.preferredPaths()) -> Result - { - let pathEnv = searchPaths.joined(separator: ":") - let runtime: RuntimeKind = .node - - guard let binary = findExecutable(named: runtime.binaryName, searchPaths: searchPaths) else { - return .failure(.notFound(searchPaths: searchPaths)) - } - guard let rawVersion = readVersion(of: binary, pathEnv: pathEnv) else { - return .failure(.versionParse( - kind: runtime, - raw: "(unreadable)", - path: binary, - searchPaths: searchPaths)) - } - guard let parsed = RuntimeVersion.from(string: rawVersion) else { - return .failure(.versionParse(kind: runtime, raw: rawVersion, path: binary, searchPaths: searchPaths)) - } - guard parsed >= self.minNode else { - return .failure(.unsupported( - kind: runtime, - found: parsed, - required: self.minNode, - path: binary, - searchPaths: searchPaths)) - } - - return .success(RuntimeResolution(kind: runtime, path: binary, version: parsed)) - } - - static func describeFailure(_ error: RuntimeResolutionError) -> String { - switch error { - case let .notFound(searchPaths): - [ - "moltbot needs Node >=22.0.0 but found no runtime.", - "PATH searched: \(searchPaths.joined(separator: ":"))", - "Install Node: https://nodejs.org/en/download", - ].joined(separator: "\n") - case let .unsupported(kind, found, required, path, searchPaths): - [ - "Found \(kind.rawValue) \(found) at \(path) but need >= \(required).", - "PATH searched: \(searchPaths.joined(separator: ":"))", - "Upgrade Node and rerun moltbot.", - ].joined(separator: "\n") - case let .versionParse(kind, raw, path, searchPaths): - [ - "Could not parse \(kind.rawValue) version output \"\(raw)\" from \(path).", - "PATH searched: \(searchPaths.joined(separator: ":"))", - "Try reinstalling or pinning a supported version (Node >=22.0.0).", - ].joined(separator: "\n") - } - } - - // MARK: - Internals - - private static func findExecutable(named name: String, searchPaths: [String]) -> String? { - let fm = FileManager() - for dir in searchPaths { - let candidate = (dir as NSString).appendingPathComponent(name) - if fm.isExecutableFile(atPath: candidate) { - return candidate - } - } - return nil - } - - private static func readVersion(of binary: String, pathEnv: String) -> String? { - let start = Date() - let process = Process() - process.executableURL = URL(fileURLWithPath: binary) - process.arguments = ["--version"] - process.environment = ["PATH": pathEnv] - - let pipe = Pipe() - process.standardOutput = pipe - process.standardError = pipe - - do { - let data = try process.runAndReadToEnd(from: pipe) - let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) - if elapsedMs > 500 { - self.logger.warning( - """ - runtime --version slow (\(elapsedMs, privacy: .public)ms) \ - bin=\(binary, privacy: .public) - """) - } else { - self.logger.debug( - """ - runtime --version ok (\(elapsedMs, privacy: .public)ms) \ - bin=\(binary, privacy: .public) - """) - } - return String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) - } catch { - let elapsedMs = Int(Date().timeIntervalSince(start) * 1000) - self.logger.error( - """ - runtime --version failed (\(elapsedMs, privacy: .public)ms) \ - bin=\(binary, privacy: .public) \ - err=\(error.localizedDescription, privacy: .public) - """) - return nil - } - } -} - -extension RuntimeKind { - fileprivate var binaryName: String { "node" } -} diff --git a/apps/macos/Sources/Clawdbot/ScreenRecordService.swift b/apps/macos/Sources/Clawdbot/ScreenRecordService.swift deleted file mode 100644 index ecbe99692..000000000 --- a/apps/macos/Sources/Clawdbot/ScreenRecordService.swift +++ /dev/null @@ -1,266 +0,0 @@ -import AVFoundation -import Foundation -import OSLog -@preconcurrency import ScreenCaptureKit - -@MainActor -final class ScreenRecordService { - enum ScreenRecordError: LocalizedError { - case noDisplays - case invalidScreenIndex(Int) - case noFramesCaptured - case writeFailed(String) - - var errorDescription: String? { - switch self { - case .noDisplays: - "No displays available for screen recording" - case let .invalidScreenIndex(idx): - "Invalid screen index \(idx)" - case .noFramesCaptured: - "No frames captured" - case let .writeFailed(msg): - msg - } - } - } - - private let logger = Logger(subsystem: "com.clawdbot", category: "screenRecord") - - func record( - screenIndex: Int?, - durationMs: Int?, - fps: Double?, - includeAudio: Bool?, - outPath: String?) async throws -> (path: String, hasAudio: Bool) - { - let durationMs = Self.clampDurationMs(durationMs) - let fps = Self.clampFps(fps) - let includeAudio = includeAudio ?? false - - let outURL: URL = { - if let outPath, !outPath.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { - return URL(fileURLWithPath: outPath) - } - return FileManager().temporaryDirectory - .appendingPathComponent("moltbot-screen-record-\(UUID().uuidString).mp4") - }() - try? FileManager().removeItem(at: outURL) - - let content = try await SCShareableContent.current - let displays = content.displays.sorted { $0.displayID < $1.displayID } - guard !displays.isEmpty else { throw ScreenRecordError.noDisplays } - - let idx = screenIndex ?? 0 - guard idx >= 0, idx < displays.count else { throw ScreenRecordError.invalidScreenIndex(idx) } - let display = displays[idx] - - let filter = SCContentFilter(display: display, excludingWindows: []) - let config = SCStreamConfiguration() - config.width = display.width - config.height = display.height - config.queueDepth = 8 - config.showsCursor = true - config.minimumFrameInterval = CMTime(value: 1, timescale: CMTimeScale(max(1, Int32(fps.rounded())))) - if includeAudio { - config.capturesAudio = true - } - - let recorder = try StreamRecorder( - outputURL: outURL, - width: display.width, - height: display.height, - includeAudio: includeAudio, - logger: self.logger) - - let stream = SCStream(filter: filter, configuration: config, delegate: recorder) - try stream.addStreamOutput(recorder, type: .screen, sampleHandlerQueue: recorder.queue) - if includeAudio { - try stream.addStreamOutput(recorder, type: .audio, sampleHandlerQueue: recorder.queue) - } - - self.logger.info( - "screen record start idx=\(idx) durationMs=\(durationMs) fps=\(fps) out=\(outURL.path, privacy: .public)") - - var started = false - do { - try await stream.startCapture() - started = true - try await Task.sleep(nanoseconds: UInt64(durationMs) * 1_000_000) - try await stream.stopCapture() - } catch { - if started { try? await stream.stopCapture() } - throw error - } - - try await recorder.finish() - return (path: outURL.path, hasAudio: recorder.hasAudio) - } - - private nonisolated static func clampDurationMs(_ ms: Int?) -> Int { - let v = ms ?? 10000 - return min(60000, max(250, v)) - } - - private nonisolated static func clampFps(_ fps: Double?) -> Double { - let v = fps ?? 10 - if !v.isFinite { return 10 } - return min(60, max(1, v)) - } -} - -private final class StreamRecorder: NSObject, SCStreamOutput, SCStreamDelegate, @unchecked Sendable { - let queue = DispatchQueue(label: "com.clawdbot.screenRecord.writer") - - private let logger: Logger - private let writer: AVAssetWriter - private let input: AVAssetWriterInput - private let audioInput: AVAssetWriterInput? - let hasAudio: Bool - - private var started = false - private var sawFrame = false - private var didFinish = false - private var pendingErrorMessage: String? - - init(outputURL: URL, width: Int, height: Int, includeAudio: Bool, logger: Logger) throws { - self.logger = logger - self.writer = try AVAssetWriter(outputURL: outputURL, fileType: .mp4) - - let settings: [String: Any] = [ - AVVideoCodecKey: AVVideoCodecType.h264, - AVVideoWidthKey: width, - AVVideoHeightKey: height, - ] - self.input = AVAssetWriterInput(mediaType: .video, outputSettings: settings) - self.input.expectsMediaDataInRealTime = true - - guard self.writer.canAdd(self.input) else { - throw ScreenRecordService.ScreenRecordError.writeFailed("Cannot add video input") - } - self.writer.add(self.input) - - if includeAudio { - let audioSettings: [String: Any] = [ - AVFormatIDKey: kAudioFormatMPEG4AAC, - AVNumberOfChannelsKey: 1, - AVSampleRateKey: 44100, - AVEncoderBitRateKey: 96000, - ] - let audioInput = AVAssetWriterInput(mediaType: .audio, outputSettings: audioSettings) - audioInput.expectsMediaDataInRealTime = true - if self.writer.canAdd(audioInput) { - self.writer.add(audioInput) - self.audioInput = audioInput - self.hasAudio = true - } else { - self.audioInput = nil - self.hasAudio = false - } - } else { - self.audioInput = nil - self.hasAudio = false - } - super.init() - } - - func stream(_ stream: SCStream, didStopWithError error: any Error) { - self.queue.async { - let msg = String(describing: error) - self.pendingErrorMessage = msg - self.logger.error("screen record stream stopped with error: \(msg, privacy: .public)") - _ = stream - } - } - - func stream( - _ stream: SCStream, - didOutputSampleBuffer sampleBuffer: CMSampleBuffer, - of type: SCStreamOutputType) - { - guard CMSampleBufferDataIsReady(sampleBuffer) else { return } - // Callback runs on `sampleHandlerQueue` (`self.queue`). - switch type { - case .screen: - self.handleVideo(sampleBuffer: sampleBuffer) - case .audio: - self.handleAudio(sampleBuffer: sampleBuffer) - case .microphone: - break - @unknown default: - break - } - _ = stream - } - - private func handleVideo(sampleBuffer: CMSampleBuffer) { - if let msg = self.pendingErrorMessage { - self.logger.error("screen record aborting due to prior error: \(msg, privacy: .public)") - return - } - if self.didFinish { return } - - if !self.started { - guard self.writer.startWriting() else { - self.pendingErrorMessage = self.writer.error?.localizedDescription ?? "Failed to start writer" - return - } - let pts = CMSampleBufferGetPresentationTimeStamp(sampleBuffer) - self.writer.startSession(atSourceTime: pts) - self.started = true - } - - self.sawFrame = true - if self.input.isReadyForMoreMediaData { - _ = self.input.append(sampleBuffer) - } - } - - private func handleAudio(sampleBuffer: CMSampleBuffer) { - guard let audioInput else { return } - if let msg = self.pendingErrorMessage { - self.logger.error("screen record audio aborting due to prior error: \(msg, privacy: .public)") - return - } - if self.didFinish || !self.started { return } - if audioInput.isReadyForMoreMediaData { - _ = audioInput.append(sampleBuffer) - } - } - - func finish() async throws { - try await withCheckedThrowingContinuation { (cont: CheckedContinuation) in - self.queue.async { - if let msg = self.pendingErrorMessage { - cont.resume(throwing: ScreenRecordService.ScreenRecordError.writeFailed(msg)) - return - } - guard self.started, self.sawFrame else { - cont.resume(throwing: ScreenRecordService.ScreenRecordError.noFramesCaptured) - return - } - if self.didFinish { - cont.resume() - return - } - self.didFinish = true - - self.input.markAsFinished() - self.audioInput?.markAsFinished() - self.writer.finishWriting { - if let err = self.writer.error { - cont - .resume(throwing: ScreenRecordService.ScreenRecordError - .writeFailed(err.localizedDescription)) - } else if self.writer.status != .completed { - cont - .resume(throwing: ScreenRecordService.ScreenRecordError - .writeFailed("Failed to finalize video")) - } else { - cont.resume() - } - } - } - } - } -} diff --git a/apps/macos/Sources/Clawdbot/SessionMenuPreviewView.swift b/apps/macos/Sources/Clawdbot/SessionMenuPreviewView.swift deleted file mode 100644 index dd8222a48..000000000 --- a/apps/macos/Sources/Clawdbot/SessionMenuPreviewView.swift +++ /dev/null @@ -1,495 +0,0 @@ -import MoltbotChatUI -import MoltbotKit -import MoltbotProtocol -import OSLog -import SwiftUI - -struct SessionPreviewItem: Identifiable, Sendable { - let id: String - let role: PreviewRole - let text: String -} - -enum PreviewRole: String, Sendable { - case user - case assistant - case tool - case system - case other - - var label: String { - switch self { - case .user: "User" - case .assistant: "Agent" - case .tool: "Tool" - case .system: "System" - case .other: "Other" - } - } -} - -actor SessionPreviewCache { - static let shared = SessionPreviewCache() - - private struct CacheEntry { - let snapshot: SessionMenuPreviewSnapshot - let updatedAt: Date - } - - private var entries: [String: CacheEntry] = [:] - - func cachedSnapshot(for sessionKey: String, maxAge: TimeInterval) -> SessionMenuPreviewSnapshot? { - guard let entry = self.entries[sessionKey] else { return nil } - guard Date().timeIntervalSince(entry.updatedAt) < maxAge else { return nil } - return entry.snapshot - } - - func store(snapshot: SessionMenuPreviewSnapshot, for sessionKey: String) { - self.entries[sessionKey] = CacheEntry(snapshot: snapshot, updatedAt: Date()) - } - - func lastSnapshot(for sessionKey: String) -> SessionMenuPreviewSnapshot? { - self.entries[sessionKey]?.snapshot - } -} - -actor SessionPreviewLimiter { - static let shared = SessionPreviewLimiter(maxConcurrent: 2) - - private let maxConcurrent: Int - private var available: Int - private var waitQueue: [UUID] = [] - private var waiters: [UUID: CheckedContinuation] = [:] - - init(maxConcurrent: Int) { - let normalized = max(1, maxConcurrent) - self.maxConcurrent = normalized - self.available = normalized - } - - func withPermit(_ operation: () async throws -> T) async throws -> T { - await self.acquire() - defer { self.release() } - if Task.isCancelled { throw CancellationError() } - return try await operation() - } - - private func acquire() async { - if self.available > 0 { - self.available -= 1 - return - } - let id = UUID() - await withCheckedContinuation { cont in - self.waitQueue.append(id) - self.waiters[id] = cont - } - } - - private func release() { - if let id = self.waitQueue.first { - self.waitQueue.removeFirst() - if let cont = self.waiters.removeValue(forKey: id) { - cont.resume() - } - return - } - self.available = min(self.available + 1, self.maxConcurrent) - } -} - -#if DEBUG -extension SessionPreviewCache { - func _testSet( - snapshot: SessionMenuPreviewSnapshot, - for sessionKey: String, - updatedAt: Date = Date()) - { - self.entries[sessionKey] = CacheEntry(snapshot: snapshot, updatedAt: updatedAt) - } - - func _testReset() { - self.entries = [:] - } -} -#endif - -struct SessionMenuPreviewSnapshot: Sendable { - let items: [SessionPreviewItem] - let status: SessionMenuPreviewView.LoadStatus -} - -struct SessionMenuPreviewView: View { - let width: CGFloat - let maxLines: Int - let title: String - let items: [SessionPreviewItem] - let status: LoadStatus - - @Environment(\.menuItemHighlighted) private var isHighlighted - - enum LoadStatus: Equatable { - case loading - case ready - case empty - case error(String) - } - - private var primaryColor: Color { - if self.isHighlighted { - return Color(nsColor: .selectedMenuItemTextColor) - } - return Color(nsColor: .labelColor) - } - - private var secondaryColor: Color { - if self.isHighlighted { - return Color(nsColor: .selectedMenuItemTextColor).opacity(0.85) - } - return Color(nsColor: .secondaryLabelColor) - } - - var body: some View { - VStack(alignment: .leading, spacing: 8) { - HStack(alignment: .firstTextBaseline, spacing: 4) { - Text(self.title) - .font(.caption.weight(.semibold)) - .foregroundStyle(self.secondaryColor) - Spacer(minLength: 8) - } - - switch self.status { - case .loading: - self.placeholder("Loading preview…") - case .empty: - self.placeholder("No recent messages") - case let .error(message): - self.placeholder(message) - case .ready: - if self.items.isEmpty { - self.placeholder("No recent messages") - } else { - VStack(alignment: .leading, spacing: 6) { - ForEach(self.items) { item in - self.previewRow(item) - } - } - } - } - } - .padding(.vertical, 6) - .padding(.leading, 16) - .padding(.trailing, 11) - .frame(width: max(1, self.width), alignment: .leading) - } - - @ViewBuilder - private func previewRow(_ item: SessionPreviewItem) -> some View { - HStack(alignment: .top, spacing: 4) { - Text(item.role.label) - .font(.caption2.monospacedDigit()) - .foregroundStyle(self.roleColor(item.role)) - .frame(width: 50, alignment: .leading) - - Text(item.text) - .font(.caption) - .foregroundStyle(self.primaryColor) - .multilineTextAlignment(.leading) - .lineLimit(self.maxLines) - .truncationMode(.tail) - .fixedSize(horizontal: false, vertical: true) - } - } - - private func roleColor(_ role: PreviewRole) -> Color { - if self.isHighlighted { return Color(nsColor: .selectedMenuItemTextColor).opacity(0.9) } - switch role { - case .user: return .accentColor - case .assistant: return .secondary - case .tool: return .orange - case .system: return .gray - case .other: return .secondary - } - } - - @ViewBuilder - private func placeholder(_ text: String) -> some View { - Text(text) - .font(.caption) - .foregroundStyle(self.primaryColor) - } -} - -enum SessionMenuPreviewLoader { - private static let logger = Logger(subsystem: "com.clawdbot", category: "SessionPreview") - private static let previewTimeoutSeconds: Double = 4 - private static let cacheMaxAgeSeconds: TimeInterval = 30 - private static let previewMaxChars = 240 - - private struct PreviewTimeoutError: LocalizedError { - var errorDescription: String? { "preview timeout" } - } - - static func prewarm(sessionKeys: [String], maxItems: Int) async { - let keys = self.uniqueKeys(sessionKeys) - guard !keys.isEmpty else { return } - do { - let payload = try await self.requestPreview(keys: keys, maxItems: maxItems) - await self.cache(payload: payload, maxItems: maxItems) - } catch { - if self.isUnknownMethodError(error) { return } - let errorDescription = String(describing: error) - Self.logger.debug( - "Session preview prewarm failed count=\(keys.count, privacy: .public) " + - "error=\(errorDescription, privacy: .public)") - } - } - - static func load(sessionKey: String, maxItems: Int) async -> SessionMenuPreviewSnapshot { - if let cached = await SessionPreviewCache.shared.cachedSnapshot( - for: sessionKey, - maxAge: cacheMaxAgeSeconds) - { - return cached - } - - do { - let snapshot = try await self.fetchSnapshot(sessionKey: sessionKey, maxItems: maxItems) - await SessionPreviewCache.shared.store(snapshot: snapshot, for: sessionKey) - return snapshot - } catch is CancellationError { - return SessionMenuPreviewSnapshot(items: [], status: .loading) - } catch { - if let fallback = await SessionPreviewCache.shared.lastSnapshot(for: sessionKey) { - return fallback - } - let errorDescription = String(describing: error) - Self.logger.warning( - "Session preview failed session=\(sessionKey, privacy: .public) " + - "error=\(errorDescription, privacy: .public)") - return SessionMenuPreviewSnapshot(items: [], status: .error("Preview unavailable")) - } - } - - private static func fetchSnapshot(sessionKey: String, maxItems: Int) async throws -> SessionMenuPreviewSnapshot { - do { - let payload = try await self.requestPreview(keys: [sessionKey], maxItems: maxItems) - if let entry = payload.previews.first(where: { $0.key == sessionKey }) ?? payload.previews.first { - return self.snapshot(from: entry, maxItems: maxItems) - } - return SessionMenuPreviewSnapshot(items: [], status: .error("Preview unavailable")) - } catch { - if self.isUnknownMethodError(error) { - return try await self.fetchHistorySnapshot(sessionKey: sessionKey, maxItems: maxItems) - } - throw error - } - } - - private static func requestPreview( - keys: [String], - maxItems: Int) async throws -> MoltbotSessionsPreviewPayload - { - let boundedItems = self.normalizeMaxItems(maxItems) - let timeoutMs = Int(self.previewTimeoutSeconds * 1000) - return try await SessionPreviewLimiter.shared.withPermit { - try await AsyncTimeout.withTimeout( - seconds: self.previewTimeoutSeconds, - onTimeout: { PreviewTimeoutError() }, - operation: { - try await GatewayConnection.shared.sessionsPreview( - keys: keys, - limit: boundedItems, - maxChars: self.previewMaxChars, - timeoutMs: timeoutMs) - }) - } - } - - private static func fetchHistorySnapshot( - sessionKey: String, - maxItems: Int) async throws -> SessionMenuPreviewSnapshot - { - let timeoutMs = Int(self.previewTimeoutSeconds * 1000) - let payload = try await SessionPreviewLimiter.shared.withPermit { - try await AsyncTimeout.withTimeout( - seconds: self.previewTimeoutSeconds, - onTimeout: { PreviewTimeoutError() }, - operation: { - try await GatewayConnection.shared.chatHistory( - sessionKey: sessionKey, - limit: self.previewLimit(for: maxItems), - timeoutMs: timeoutMs) - }) - } - let built = Self.previewItems(from: payload, maxItems: maxItems) - return Self.snapshot(from: built) - } - - private static func snapshot(from items: [SessionPreviewItem]) -> SessionMenuPreviewSnapshot { - SessionMenuPreviewSnapshot(items: items, status: items.isEmpty ? .empty : .ready) - } - - private static func snapshot( - from entry: MoltbotSessionPreviewEntry, - maxItems: Int) -> SessionMenuPreviewSnapshot - { - let items = self.previewItems(from: entry, maxItems: maxItems) - let normalized = entry.status.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() - switch normalized { - case "ok": - return SessionMenuPreviewSnapshot(items: items, status: items.isEmpty ? .empty : .ready) - case "empty": - return SessionMenuPreviewSnapshot(items: items, status: .empty) - case "missing": - return SessionMenuPreviewSnapshot(items: items, status: .error("Session missing")) - default: - return SessionMenuPreviewSnapshot(items: items, status: .error("Preview unavailable")) - } - } - - private static func cache(payload: MoltbotSessionsPreviewPayload, maxItems: Int) async { - for entry in payload.previews { - let snapshot = self.snapshot(from: entry, maxItems: maxItems) - await SessionPreviewCache.shared.store(snapshot: snapshot, for: entry.key) - } - } - - private static func previewLimit(for maxItems: Int) -> Int { - let boundedItems = self.normalizeMaxItems(maxItems) - return min(max(boundedItems * 3, 20), 120) - } - - private static func normalizeMaxItems(_ maxItems: Int) -> Int { - max(1, min(maxItems, 50)) - } - - private static func previewItems( - from entry: MoltbotSessionPreviewEntry, - maxItems: Int) -> [SessionPreviewItem] - { - let boundedItems = self.normalizeMaxItems(maxItems) - let built: [SessionPreviewItem] = entry.items.enumerated().compactMap { index, item in - let text = item.text.trimmingCharacters(in: .whitespacesAndNewlines) - guard !text.isEmpty else { return nil } - let role = self.previewRoleFromRaw(item.role) - return SessionPreviewItem(id: "\(entry.key)-\(index)", role: role, text: text) - } - - let trimmed = built.suffix(boundedItems) - return Array(trimmed.reversed()) - } - - private static func previewItems( - from payload: MoltbotChatHistoryPayload, - maxItems: Int) -> [SessionPreviewItem] - { - let boundedItems = self.normalizeMaxItems(maxItems) - let raw: [MoltbotKit.AnyCodable] = payload.messages ?? [] - let messages = self.decodeMessages(raw) - let built = messages.compactMap { message -> SessionPreviewItem? in - guard let text = self.previewText(for: message) else { return nil } - let isTool = self.isToolCall(message) - let role = self.previewRole(message.role, isTool: isTool) - let id = "\(message.timestamp ?? 0)-\(UUID().uuidString)" - return SessionPreviewItem(id: id, role: role, text: text) - } - - let trimmed = built.suffix(boundedItems) - return Array(trimmed.reversed()) - } - - private static func decodeMessages(_ raw: [MoltbotKit.AnyCodable]) -> [MoltbotChatMessage] { - raw.compactMap { item in - guard let data = try? JSONEncoder().encode(item) else { return nil } - return try? JSONDecoder().decode(MoltbotChatMessage.self, from: data) - } - } - - private static func previewRole(_ raw: String, isTool: Bool) -> PreviewRole { - if isTool { return .tool } - return self.previewRoleFromRaw(raw) - } - - private static func previewRoleFromRaw(_ raw: String) -> PreviewRole { - switch raw.lowercased() { - case "user": .user - case "assistant": .assistant - case "system": .system - case "tool": .tool - default: .other - } - } - - private static func previewText(for message: MoltbotChatMessage) -> String? { - let text = message.content.compactMap(\.text).joined(separator: "\n") - .trimmingCharacters(in: .whitespacesAndNewlines) - if !text.isEmpty { return text } - - let toolNames = self.toolNames(for: message) - if !toolNames.isEmpty { - let shown = toolNames.prefix(2) - let overflow = toolNames.count - shown.count - var label = "call \(shown.joined(separator: ", "))" - if overflow > 0 { label += " +\(overflow)" } - return label - } - - if let media = self.mediaSummary(for: message) { - return media - } - - return nil - } - - private static func isToolCall(_ message: MoltbotChatMessage) -> Bool { - if message.toolName?.nonEmpty != nil { return true } - return message.content.contains { $0.name?.nonEmpty != nil || $0.type?.lowercased() == "toolcall" } - } - - private static func toolNames(for message: MoltbotChatMessage) -> [String] { - var names: [String] = [] - for content in message.content { - if let name = content.name?.nonEmpty { - names.append(name) - } - } - if let toolName = message.toolName?.nonEmpty { - names.append(toolName) - } - return Self.dedupePreservingOrder(names) - } - - private static func mediaSummary(for message: MoltbotChatMessage) -> String? { - let types = message.content.compactMap { content -> String? in - let raw = content.type?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() - guard let raw, !raw.isEmpty else { return nil } - if raw == "text" || raw == "toolcall" { return nil } - return raw - } - guard let first = types.first else { return nil } - return "[\(first)]" - } - - private static func dedupePreservingOrder(_ values: [String]) -> [String] { - var seen = Set() - var result: [String] = [] - for value in values where !seen.contains(value) { - seen.insert(value) - result.append(value) - } - return result - } - - private static func uniqueKeys(_ keys: [String]) -> [String] { - let trimmed = keys.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) } - return self.dedupePreservingOrder(trimmed.filter { !$0.isEmpty }) - } - - private static func isUnknownMethodError(_ error: Error) -> Bool { - guard let response = error as? GatewayResponseError else { return false } - guard response.code == ErrorCode.invalidRequest.rawValue else { return false } - let message = response.message.lowercased() - return message.contains("unknown method") - } -} diff --git a/apps/macos/Sources/Clawdbot/TailscaleService.swift b/apps/macos/Sources/Clawdbot/TailscaleService.swift deleted file mode 100644 index 413e8d0c8..000000000 --- a/apps/macos/Sources/Clawdbot/TailscaleService.swift +++ /dev/null @@ -1,226 +0,0 @@ -import AppKit -import Foundation -import Observation -import os -#if canImport(Darwin) -import Darwin -#endif - -/// Manages Tailscale integration and status checking. -@Observable -@MainActor -final class TailscaleService { - static let shared = TailscaleService() - - /// Tailscale local API endpoint. - private static let tailscaleAPIEndpoint = "http://100.100.100.100/api/data" - - /// API request timeout in seconds. - private static let apiTimeoutInterval: TimeInterval = 5.0 - - private let logger = Logger(subsystem: "com.clawdbot", category: "tailscale") - - /// Indicates if the Tailscale app is installed on the system. - private(set) var isInstalled = false - - /// Indicates if Tailscale is currently running. - private(set) var isRunning = false - - /// The Tailscale hostname for this device (e.g., "my-mac.tailnet.ts.net"). - private(set) var tailscaleHostname: String? - - /// The Tailscale IPv4 address for this device. - private(set) var tailscaleIP: String? - - /// Error message if status check fails. - private(set) var statusError: String? - - private init() { - Task { await self.checkTailscaleStatus() } - } - - #if DEBUG - init( - isInstalled: Bool, - isRunning: Bool, - tailscaleHostname: String? = nil, - tailscaleIP: String? = nil, - statusError: String? = nil) - { - self.isInstalled = isInstalled - self.isRunning = isRunning - self.tailscaleHostname = tailscaleHostname - self.tailscaleIP = tailscaleIP - self.statusError = statusError - } - #endif - - func checkAppInstallation() -> Bool { - let installed = FileManager().fileExists(atPath: "/Applications/Tailscale.app") - self.logger.info("Tailscale app installed: \(installed)") - return installed - } - - private struct TailscaleAPIResponse: Codable { - let status: String - let deviceName: String - let tailnetName: String - let iPv4: String? - - private enum CodingKeys: String, CodingKey { - case status = "Status" - case deviceName = "DeviceName" - case tailnetName = "TailnetName" - case iPv4 = "IPv4" - } - } - - private func fetchTailscaleStatus() async -> TailscaleAPIResponse? { - guard let url = URL(string: Self.tailscaleAPIEndpoint) else { - self.logger.error("Invalid Tailscale API URL") - return nil - } - - do { - let configuration = URLSessionConfiguration.default - configuration.timeoutIntervalForRequest = Self.apiTimeoutInterval - let session = URLSession(configuration: configuration) - - let (data, response) = try await session.data(from: url) - guard let httpResponse = response as? HTTPURLResponse, - httpResponse.statusCode == 200 - else { - self.logger.warning("Tailscale API returned non-200 status") - return nil - } - - let decoder = JSONDecoder() - return try decoder.decode(TailscaleAPIResponse.self, from: data) - } catch { - self.logger.debug("Failed to fetch Tailscale status: \(String(describing: error))") - return nil - } - } - - func checkTailscaleStatus() async { - let previousIP = self.tailscaleIP - self.isInstalled = self.checkAppInstallation() - if !self.isInstalled { - self.isRunning = false - self.tailscaleHostname = nil - self.tailscaleIP = nil - self.statusError = "Tailscale is not installed" - } else if let apiResponse = await fetchTailscaleStatus() { - self.isRunning = apiResponse.status.lowercased() == "running" - - if self.isRunning { - let deviceName = apiResponse.deviceName - .lowercased() - .replacingOccurrences(of: " ", with: "-") - let tailnetName = apiResponse.tailnetName - .replacingOccurrences(of: ".ts.net", with: "") - .replacingOccurrences(of: ".tailscale.net", with: "") - - self.tailscaleHostname = "\(deviceName).\(tailnetName).ts.net" - self.tailscaleIP = apiResponse.iPv4 - self.statusError = nil - - self.logger.info( - "Tailscale running host=\(self.tailscaleHostname ?? "nil") ip=\(self.tailscaleIP ?? "nil")") - } else { - self.tailscaleHostname = nil - self.tailscaleIP = nil - self.statusError = "Tailscale is not running" - } - } else { - self.isRunning = false - self.tailscaleHostname = nil - self.tailscaleIP = nil - self.statusError = "Please start the Tailscale app" - self.logger.info("Tailscale API not responding; app likely not running") - } - - if self.tailscaleIP == nil, let fallback = Self.detectTailnetIPv4() { - self.tailscaleIP = fallback - if !self.isRunning { - self.isRunning = true - } - self.statusError = nil - self.logger.info("Tailscale interface IP detected (fallback) ip=\(fallback, privacy: .public)") - } - - if previousIP != self.tailscaleIP { - await GatewayEndpointStore.shared.refresh() - } - } - - func openTailscaleApp() { - if let url = URL(string: "file:///Applications/Tailscale.app") { - NSWorkspace.shared.open(url) - } - } - - func openAppStore() { - if let url = URL(string: "https://apps.apple.com/us/app/tailscale/id1475387142") { - NSWorkspace.shared.open(url) - } - } - - func openDownloadPage() { - if let url = URL(string: "https://tailscale.com/download/macos") { - NSWorkspace.shared.open(url) - } - } - - func openSetupGuide() { - if let url = URL(string: "https://tailscale.com/kb/1017/install/") { - NSWorkspace.shared.open(url) - } - } - - private nonisolated static func isTailnetIPv4(_ address: String) -> Bool { - let parts = address.split(separator: ".") - guard parts.count == 4 else { return false } - let octets = parts.compactMap { Int($0) } - guard octets.count == 4 else { return false } - let a = octets[0] - let b = octets[1] - return a == 100 && b >= 64 && b <= 127 - } - - private nonisolated static func detectTailnetIPv4() -> String? { - var addrList: UnsafeMutablePointer? - guard getifaddrs(&addrList) == 0, let first = addrList else { return nil } - defer { freeifaddrs(addrList) } - - for ptr in sequence(first: first, next: { $0.pointee.ifa_next }) { - let flags = Int32(ptr.pointee.ifa_flags) - let isUp = (flags & IFF_UP) != 0 - let isLoopback = (flags & IFF_LOOPBACK) != 0 - let family = ptr.pointee.ifa_addr.pointee.sa_family - if !isUp || isLoopback || family != UInt8(AF_INET) { continue } - - var addr = ptr.pointee.ifa_addr.pointee - var buffer = [CChar](repeating: 0, count: Int(NI_MAXHOST)) - let result = getnameinfo( - &addr, - socklen_t(ptr.pointee.ifa_addr.pointee.sa_len), - &buffer, - socklen_t(buffer.count), - nil, - 0, - NI_NUMERICHOST) - guard result == 0 else { continue } - let len = buffer.prefix { $0 != 0 } - let bytes = len.map { UInt8(bitPattern: $0) } - guard let ip = String(bytes: bytes, encoding: .utf8) else { continue } - if Self.isTailnetIPv4(ip) { return ip } - } - - return nil - } - - nonisolated static func fallbackTailnetIPv4() -> String? { - self.detectTailnetIPv4() - } -} diff --git a/apps/macos/Sources/Clawdbot/TalkAudioPlayer.swift b/apps/macos/Sources/Clawdbot/TalkAudioPlayer.swift deleted file mode 100644 index af5fdeffb..000000000 --- a/apps/macos/Sources/Clawdbot/TalkAudioPlayer.swift +++ /dev/null @@ -1,158 +0,0 @@ -import AVFoundation -import Foundation -import OSLog - -@MainActor -final class TalkAudioPlayer: NSObject, @preconcurrency AVAudioPlayerDelegate { - static let shared = TalkAudioPlayer() - - private let logger = Logger(subsystem: "com.clawdbot", category: "talk.tts") - private var player: AVAudioPlayer? - private var playback: Playback? - - private final class Playback: @unchecked Sendable { - private let lock = NSLock() - private var finished = false - private var continuation: CheckedContinuation? - private var watchdog: Task? - - func setContinuation(_ continuation: CheckedContinuation) { - self.lock.lock() - defer { self.lock.unlock() } - self.continuation = continuation - } - - func setWatchdog(_ task: Task?) { - self.lock.lock() - let old = self.watchdog - self.watchdog = task - self.lock.unlock() - old?.cancel() - } - - func cancelWatchdog() { - self.setWatchdog(nil) - } - - func finish(_ result: TalkPlaybackResult) { - let continuation: CheckedContinuation? - self.lock.lock() - if self.finished { - continuation = nil - } else { - self.finished = true - continuation = self.continuation - self.continuation = nil - } - self.lock.unlock() - continuation?.resume(returning: result) - } - } - - func play(data: Data) async -> TalkPlaybackResult { - self.stopInternal() - - let playback = Playback() - self.playback = playback - - return await withCheckedContinuation { continuation in - playback.setContinuation(continuation) - do { - let player = try AVAudioPlayer(data: data) - self.player = player - - player.delegate = self - player.prepareToPlay() - - self.armWatchdog(playback: playback) - - let ok = player.play() - if !ok { - self.logger.error("talk audio player refused to play") - self.finish(playback: playback, result: TalkPlaybackResult(finished: false, interruptedAt: nil)) - } - } catch { - self.logger.error("talk audio player failed: \(error.localizedDescription, privacy: .public)") - self.finish(playback: playback, result: TalkPlaybackResult(finished: false, interruptedAt: nil)) - } - } - } - - func stop() -> Double? { - guard let player else { return nil } - let time = player.currentTime - self.stopInternal(interruptedAt: time) - return time - } - - func audioPlayerDidFinishPlaying(_: AVAudioPlayer, successfully flag: Bool) { - self.stopInternal(finished: flag) - } - - private func stopInternal(finished: Bool = false, interruptedAt: Double? = nil) { - guard let playback else { return } - let result = TalkPlaybackResult(finished: finished, interruptedAt: interruptedAt) - self.finish(playback: playback, result: result) - } - - private func finish(playback: Playback, result: TalkPlaybackResult) { - playback.cancelWatchdog() - playback.finish(result) - - guard self.playback === playback else { return } - self.playback = nil - self.player?.stop() - self.player = nil - } - - private func stopInternal() { - if let playback = self.playback { - let interruptedAt = self.player?.currentTime - self.finish( - playback: playback, - result: TalkPlaybackResult(finished: false, interruptedAt: interruptedAt)) - return - } - self.player?.stop() - self.player = nil - } - - private func armWatchdog(playback: Playback) { - playback.setWatchdog(Task { @MainActor [weak self] in - guard let self else { return } - - do { - try await Task.sleep(nanoseconds: 650_000_000) - } catch { - return - } - if Task.isCancelled { return } - - guard self.playback === playback else { return } - if self.player?.isPlaying != true { - self.logger.error("talk audio player did not start playing") - self.finish(playback: playback, result: TalkPlaybackResult(finished: false, interruptedAt: nil)) - return - } - - let duration = self.player?.duration ?? 0 - let timeoutSeconds = min(max(2.0, duration + 2.0), 5 * 60.0) - do { - try await Task.sleep(nanoseconds: UInt64(timeoutSeconds * 1_000_000_000)) - } catch { - return - } - if Task.isCancelled { return } - - guard self.playback === playback else { return } - guard self.player?.isPlaying == true else { return } - self.logger.error("talk audio player watchdog fired") - self.finish(playback: playback, result: TalkPlaybackResult(finished: false, interruptedAt: nil)) - }) - } -} - -struct TalkPlaybackResult: Sendable { - let finished: Bool - let interruptedAt: Double? -} diff --git a/apps/macos/Sources/Clawdbot/TalkModeController.swift b/apps/macos/Sources/Clawdbot/TalkModeController.swift deleted file mode 100644 index a92c0fda0..000000000 --- a/apps/macos/Sources/Clawdbot/TalkModeController.swift +++ /dev/null @@ -1,69 +0,0 @@ -import Observation - -@MainActor -@Observable -final class TalkModeController { - static let shared = TalkModeController() - - private let logger = Logger(subsystem: "com.clawdbot", category: "talk.controller") - - private(set) var phase: TalkModePhase = .idle - private(set) var isPaused: Bool = false - - func setEnabled(_ enabled: Bool) async { - self.logger.info("talk enabled=\(enabled)") - if enabled { - TalkOverlayController.shared.present() - } else { - TalkOverlayController.shared.dismiss() - } - await TalkModeRuntime.shared.setEnabled(enabled) - } - - func updatePhase(_ phase: TalkModePhase) { - self.phase = phase - TalkOverlayController.shared.updatePhase(phase) - let effectivePhase = self.isPaused ? "paused" : phase.rawValue - Task { - await GatewayConnection.shared.talkMode( - enabled: AppStateStore.shared.talkEnabled, - phase: effectivePhase) - } - } - - func updateLevel(_ level: Double) { - TalkOverlayController.shared.updateLevel(level) - } - - func setPaused(_ paused: Bool) { - guard self.isPaused != paused else { return } - self.logger.info("talk paused=\(paused)") - self.isPaused = paused - TalkOverlayController.shared.updatePaused(paused) - let effectivePhase = paused ? "paused" : self.phase.rawValue - Task { - await GatewayConnection.shared.talkMode( - enabled: AppStateStore.shared.talkEnabled, - phase: effectivePhase) - } - Task { await TalkModeRuntime.shared.setPaused(paused) } - } - - func togglePaused() { - self.setPaused(!self.isPaused) - } - - func stopSpeaking(reason: TalkStopReason = .userTap) { - Task { await TalkModeRuntime.shared.stopSpeaking(reason: reason) } - } - - func exitTalkMode() { - Task { await AppStateStore.shared.setTalkEnabled(false) } - } -} - -enum TalkStopReason { - case userTap - case speech - case manual -} diff --git a/apps/macos/Sources/Clawdbot/TalkModeRuntime.swift b/apps/macos/Sources/Clawdbot/TalkModeRuntime.swift deleted file mode 100644 index a25a8d7ed..000000000 --- a/apps/macos/Sources/Clawdbot/TalkModeRuntime.swift +++ /dev/null @@ -1,953 +0,0 @@ -import AVFoundation -import MoltbotChatUI -import MoltbotKit -import Foundation -import OSLog -import Speech - -actor TalkModeRuntime { - static let shared = TalkModeRuntime() - - private let logger = Logger(subsystem: "com.clawdbot", category: "talk.runtime") - private let ttsLogger = Logger(subsystem: "com.clawdbot", category: "talk.tts") - private static let defaultModelIdFallback = "eleven_v3" - - private final class RMSMeter: @unchecked Sendable { - private let lock = NSLock() - private var latestRMS: Double = 0 - - func set(_ rms: Double) { - self.lock.lock() - self.latestRMS = rms - self.lock.unlock() - } - - func get() -> Double { - self.lock.lock() - let value = self.latestRMS - self.lock.unlock() - return value - } - } - - private var recognizer: SFSpeechRecognizer? - private var audioEngine: AVAudioEngine? - private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest? - private var recognitionTask: SFSpeechRecognitionTask? - private var recognitionGeneration: Int = 0 - private var rmsTask: Task? - private let rmsMeter = RMSMeter() - - private var captureTask: Task? - private var silenceTask: Task? - private var phase: TalkModePhase = .idle - private var isEnabled = false - private var isPaused = false - private var lifecycleGeneration: Int = 0 - - private var lastHeard: Date? - private var noiseFloorRMS: Double = 1e-4 - private var lastTranscript: String = "" - private var lastSpeechEnergyAt: Date? - - private var defaultVoiceId: String? - private var currentVoiceId: String? - private var defaultModelId: String? - private var currentModelId: String? - private var voiceOverrideActive = false - private var modelOverrideActive = false - private var defaultOutputFormat: String? - private var interruptOnSpeech: Bool = true - private var lastInterruptedAtSeconds: Double? - private var voiceAliases: [String: String] = [:] - private var lastSpokenText: String? - private var apiKey: String? - private var fallbackVoiceId: String? - private var lastPlaybackWasPCM: Bool = false - - private let silenceWindow: TimeInterval = 0.7 - private let minSpeechRMS: Double = 1e-3 - private let speechBoostFactor: Double = 6.0 - - // MARK: - Lifecycle - - func setEnabled(_ enabled: Bool) async { - guard enabled != self.isEnabled else { return } - self.isEnabled = enabled - self.lifecycleGeneration &+= 1 - if enabled { - await self.start() - } else { - await self.stop() - } - } - - func setPaused(_ paused: Bool) async { - guard paused != self.isPaused else { return } - self.isPaused = paused - await MainActor.run { TalkModeController.shared.updateLevel(0) } - - guard self.isEnabled else { return } - - if paused { - self.lastTranscript = "" - self.lastHeard = nil - self.lastSpeechEnergyAt = nil - await self.stopRecognition() - return - } - - if self.phase == .idle || self.phase == .listening { - await self.startRecognition() - self.phase = .listening - await MainActor.run { TalkModeController.shared.updatePhase(.listening) } - self.startSilenceMonitor() - } - } - - private func isCurrent(_ generation: Int) -> Bool { - generation == self.lifecycleGeneration && self.isEnabled - } - - private func start() async { - let gen = self.lifecycleGeneration - guard voiceWakeSupported else { return } - guard PermissionManager.voiceWakePermissionsGranted() else { - self.logger.debug("talk runtime not starting: permissions missing") - return - } - await self.reloadConfig() - guard self.isCurrent(gen) else { return } - if self.isPaused { - self.phase = .idle - await MainActor.run { - TalkModeController.shared.updateLevel(0) - TalkModeController.shared.updatePhase(.idle) - } - return - } - await self.startRecognition() - guard self.isCurrent(gen) else { return } - self.phase = .listening - await MainActor.run { TalkModeController.shared.updatePhase(.listening) } - self.startSilenceMonitor() - } - - private func stop() async { - self.captureTask?.cancel() - self.captureTask = nil - self.silenceTask?.cancel() - self.silenceTask = nil - - // Stop audio before changing phase (stopSpeaking is gated on .speaking). - await self.stopSpeaking(reason: .manual) - - self.lastTranscript = "" - self.lastHeard = nil - self.lastSpeechEnergyAt = nil - self.phase = .idle - await self.stopRecognition() - await MainActor.run { - TalkModeController.shared.updateLevel(0) - TalkModeController.shared.updatePhase(.idle) - } - } - - // MARK: - Speech recognition - - private struct RecognitionUpdate { - let transcript: String? - let hasConfidence: Bool - let isFinal: Bool - let errorDescription: String? - let generation: Int - } - - private func startRecognition() async { - await self.stopRecognition() - self.recognitionGeneration &+= 1 - let generation = self.recognitionGeneration - - let locale = await MainActor.run { AppStateStore.shared.voiceWakeLocaleID } - self.recognizer = SFSpeechRecognizer(locale: Locale(identifier: locale)) - guard let recognizer, recognizer.isAvailable else { - self.logger.error("talk recognizer unavailable") - return - } - - self.recognitionRequest = SFSpeechAudioBufferRecognitionRequest() - self.recognitionRequest?.shouldReportPartialResults = true - guard let request = self.recognitionRequest else { return } - - if self.audioEngine == nil { - self.audioEngine = AVAudioEngine() - } - guard let audioEngine = self.audioEngine else { return } - - let input = audioEngine.inputNode - let format = input.outputFormat(forBus: 0) - input.removeTap(onBus: 0) - let meter = self.rmsMeter - input.installTap(onBus: 0, bufferSize: 2048, format: format) { [weak request, meter] buffer, _ in - request?.append(buffer) - if let rms = Self.rmsLevel(buffer: buffer) { - meter.set(rms) - } - } - - audioEngine.prepare() - do { - try audioEngine.start() - } catch { - self.logger.error("talk audio engine start failed: \(error.localizedDescription, privacy: .public)") - return - } - - self.startRMSTicker(meter: meter) - - self.recognitionTask = recognizer.recognitionTask(with: request) { [weak self, generation] result, error in - guard let self else { return } - let segments = result?.bestTranscription.segments ?? [] - let transcript = result?.bestTranscription.formattedString - let update = RecognitionUpdate( - transcript: transcript, - hasConfidence: segments.contains { $0.confidence > 0.6 }, - isFinal: result?.isFinal ?? false, - errorDescription: error?.localizedDescription, - generation: generation) - Task { await self.handleRecognition(update) } - } - } - - private func stopRecognition() async { - self.recognitionGeneration &+= 1 - self.recognitionTask?.cancel() - self.recognitionTask = nil - self.recognitionRequest?.endAudio() - self.recognitionRequest = nil - self.audioEngine?.inputNode.removeTap(onBus: 0) - self.audioEngine?.stop() - self.audioEngine = nil - self.recognizer = nil - self.rmsTask?.cancel() - self.rmsTask = nil - } - - private func startRMSTicker(meter: RMSMeter) { - self.rmsTask?.cancel() - self.rmsTask = Task { [weak self, meter] in - while let self { - try? await Task.sleep(nanoseconds: 50_000_000) - if Task.isCancelled { return } - await self.noteAudioLevel(rms: meter.get()) - } - } - } - - private func handleRecognition(_ update: RecognitionUpdate) async { - guard update.generation == self.recognitionGeneration else { return } - guard !self.isPaused else { return } - if let errorDescription = update.errorDescription { - self.logger.debug("talk recognition error: \(errorDescription, privacy: .public)") - } - guard let transcript = update.transcript else { return } - - let trimmed = transcript.trimmingCharacters(in: .whitespacesAndNewlines) - if self.phase == .speaking, self.interruptOnSpeech { - if await self.shouldInterrupt(transcript: trimmed, hasConfidence: update.hasConfidence) { - await self.stopSpeaking(reason: .speech) - self.lastTranscript = "" - self.lastHeard = nil - await self.startListening() - } - return - } - - guard self.phase == .listening else { return } - - if !trimmed.isEmpty { - self.lastTranscript = trimmed - self.lastHeard = Date() - } - - if update.isFinal { - self.lastTranscript = trimmed - } - } - - // MARK: - Silence handling - - private func startSilenceMonitor() { - self.silenceTask?.cancel() - self.silenceTask = Task { [weak self] in - await self?.silenceLoop() - } - } - - private func silenceLoop() async { - while self.isEnabled { - try? await Task.sleep(nanoseconds: 200_000_000) - await self.checkSilence() - } - } - - private func checkSilence() async { - guard !self.isPaused else { return } - guard self.phase == .listening else { return } - let transcript = self.lastTranscript.trimmingCharacters(in: .whitespacesAndNewlines) - guard !transcript.isEmpty else { return } - guard let lastHeard else { return } - let elapsed = Date().timeIntervalSince(lastHeard) - guard elapsed >= self.silenceWindow else { return } - await self.finalizeTranscript(transcript) - } - - private func startListening() async { - self.phase = .listening - self.lastTranscript = "" - self.lastHeard = nil - await MainActor.run { - TalkModeController.shared.updatePhase(.listening) - TalkModeController.shared.updateLevel(0) - } - } - - private func finalizeTranscript(_ text: String) async { - self.lastTranscript = "" - self.lastHeard = nil - self.phase = .thinking - await MainActor.run { TalkModeController.shared.updatePhase(.thinking) } - await self.stopRecognition() - await self.sendAndSpeak(text) - } - - // MARK: - Gateway + TTS - - private func sendAndSpeak(_ transcript: String) async { - let gen = self.lifecycleGeneration - await self.reloadConfig() - guard self.isCurrent(gen) else { return } - let prompt = self.buildPrompt(transcript: transcript) - let activeSessionKey = await MainActor.run { WebChatManager.shared.activeSessionKey } - let sessionKey: String = if let activeSessionKey { - activeSessionKey - } else { - await GatewayConnection.shared.mainSessionKey() - } - let runId = UUID().uuidString - let startedAt = Date().timeIntervalSince1970 - self.logger.info( - "talk send start runId=\(runId, privacy: .public) " + - "session=\(sessionKey, privacy: .public) " + - "chars=\(prompt.count, privacy: .public)") - - do { - let response = try await GatewayConnection.shared.chatSend( - sessionKey: sessionKey, - message: prompt, - thinking: "low", - idempotencyKey: runId, - attachments: []) - guard self.isCurrent(gen) else { return } - self.logger.info( - "talk chat.send ok runId=\(response.runId, privacy: .public) " + - "session=\(sessionKey, privacy: .public)") - - guard let assistantText = await self.waitForAssistantText( - sessionKey: sessionKey, - since: startedAt, - timeoutSeconds: 45) - else { - self.logger.warning("talk assistant text missing after timeout") - await self.startListening() - await self.startRecognition() - return - } - guard self.isCurrent(gen) else { return } - - self.logger.info("talk assistant text len=\(assistantText.count, privacy: .public)") - await self.playAssistant(text: assistantText) - guard self.isCurrent(gen) else { return } - await self.resumeListeningIfNeeded() - return - } catch { - self.logger.error("talk chat.send failed: \(error.localizedDescription, privacy: .public)") - await self.resumeListeningIfNeeded() - return - } - } - - private func resumeListeningIfNeeded() async { - if self.isPaused { - self.lastTranscript = "" - self.lastHeard = nil - self.lastSpeechEnergyAt = nil - await MainActor.run { - TalkModeController.shared.updateLevel(0) - } - return - } - await self.startListening() - await self.startRecognition() - } - - private func buildPrompt(transcript: String) -> String { - let interrupted = self.lastInterruptedAtSeconds - self.lastInterruptedAtSeconds = nil - return TalkPromptBuilder.build(transcript: transcript, interruptedAtSeconds: interrupted) - } - - private func waitForAssistantText( - sessionKey: String, - since: Double, - timeoutSeconds: Int) async -> String? - { - let deadline = Date().addingTimeInterval(TimeInterval(timeoutSeconds)) - while Date() < deadline { - if let text = await self.latestAssistantText(sessionKey: sessionKey, since: since) { - return text - } - try? await Task.sleep(nanoseconds: 300_000_000) - } - return nil - } - - private func latestAssistantText(sessionKey: String, since: Double? = nil) async -> String? { - do { - let history = try await GatewayConnection.shared.chatHistory(sessionKey: sessionKey) - let messages = history.messages ?? [] - let decoded: [MoltbotChatMessage] = messages.compactMap { item in - guard let data = try? JSONEncoder().encode(item) else { return nil } - return try? JSONDecoder().decode(MoltbotChatMessage.self, from: data) - } - let assistant = decoded.last { message in - guard message.role == "assistant" else { return false } - guard let since else { return true } - guard let timestamp = message.timestamp else { return false } - return TalkHistoryTimestamp.isAfter(timestamp, sinceSeconds: since) - } - guard let assistant else { return nil } - let text = assistant.content.compactMap(\.text).joined(separator: "\n") - let trimmed = text.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) - return trimmed.isEmpty ? nil : trimmed - } catch { - self.logger.error("talk history fetch failed: \(error.localizedDescription, privacy: .public)") - return nil - } - } - - private func playAssistant(text: String) async { - guard let input = await self.preparePlaybackInput(text: text) else { return } - do { - if let apiKey = input.apiKey, !apiKey.isEmpty, let voiceId = input.voiceId { - try await self.playElevenLabs(input: input, apiKey: apiKey, voiceId: voiceId) - } else { - try await self.playSystemVoice(input: input) - } - } catch { - self.ttsLogger - .error( - "talk TTS failed: \(error.localizedDescription, privacy: .public); " + - "falling back to system voice") - do { - try await self.playSystemVoice(input: input) - } catch { - self.ttsLogger.error("talk system voice failed: \(error.localizedDescription, privacy: .public)") - } - } - - if self.phase == .speaking { - self.phase = .thinking - await MainActor.run { TalkModeController.shared.updatePhase(.thinking) } - } - } - - private struct TalkPlaybackInput { - let generation: Int - let cleanedText: String - let directive: TalkDirective? - let apiKey: String? - let voiceId: String? - let language: String? - let synthTimeoutSeconds: Double - } - - private func preparePlaybackInput(text: String) async -> TalkPlaybackInput? { - let gen = self.lifecycleGeneration - let parse = TalkDirectiveParser.parse(text) - let directive = parse.directive - let cleaned = parse.stripped.trimmingCharacters(in: .whitespacesAndNewlines) - guard !cleaned.isEmpty else { return nil } - guard self.isCurrent(gen) else { return nil } - - if !parse.unknownKeys.isEmpty { - self.logger - .warning( - "talk directive ignored keys: " + - "\(parse.unknownKeys.joined(separator: ","), privacy: .public)") - } - - let requestedVoice = directive?.voiceId?.trimmingCharacters(in: .whitespacesAndNewlines) - let resolvedVoice = self.resolveVoiceAlias(requestedVoice) - if let requestedVoice, !requestedVoice.isEmpty, resolvedVoice == nil { - self.logger.warning("talk unknown voice alias \(requestedVoice, privacy: .public)") - } - if let voice = resolvedVoice { - if directive?.once == true { - self.logger.info("talk voice override (once) voiceId=\(voice, privacy: .public)") - } else { - self.currentVoiceId = voice - self.voiceOverrideActive = true - self.logger.info("talk voice override voiceId=\(voice, privacy: .public)") - } - } - - if let model = directive?.modelId { - if directive?.once == true { - self.logger.info("talk model override (once) modelId=\(model, privacy: .public)") - } else { - self.currentModelId = model - self.modelOverrideActive = true - } - } - - let apiKey = self.apiKey?.trimmingCharacters(in: .whitespacesAndNewlines) - let preferredVoice = - resolvedVoice ?? - self.currentVoiceId ?? - self.defaultVoiceId - - let language = ElevenLabsTTSClient.validatedLanguage(directive?.language) - - let voiceId: String? = if let apiKey, !apiKey.isEmpty { - await self.resolveVoiceId(preferred: preferredVoice, apiKey: apiKey) - } else { - nil - } - - if apiKey?.isEmpty != false { - self.ttsLogger.warning("talk missing ELEVENLABS_API_KEY; falling back to system voice") - } else if voiceId == nil { - self.ttsLogger.warning("talk missing voiceId; falling back to system voice") - } else if let voiceId { - self.ttsLogger - .info( - "talk TTS request voiceId=\(voiceId, privacy: .public) " + - "chars=\(cleaned.count, privacy: .public)") - } - self.lastSpokenText = cleaned - - let synthTimeoutSeconds = max(20.0, min(90.0, Double(cleaned.count) * 0.12)) - - guard self.isCurrent(gen) else { return nil } - - return TalkPlaybackInput( - generation: gen, - cleanedText: cleaned, - directive: directive, - apiKey: apiKey, - voiceId: voiceId, - language: language, - synthTimeoutSeconds: synthTimeoutSeconds) - } - - private func playElevenLabs(input: TalkPlaybackInput, apiKey: String, voiceId: String) async throws { - let desiredOutputFormat = input.directive?.outputFormat ?? self.defaultOutputFormat ?? "pcm_44100" - let outputFormat = ElevenLabsTTSClient.validatedOutputFormat(desiredOutputFormat) - if outputFormat == nil, !desiredOutputFormat.isEmpty { - self.logger - .warning( - "talk output_format unsupported for local playback: " + - "\(desiredOutputFormat, privacy: .public)") - } - - let modelId = input.directive?.modelId ?? self.currentModelId ?? self.defaultModelId - func makeRequest(outputFormat: String?) -> ElevenLabsTTSRequest { - ElevenLabsTTSRequest( - text: input.cleanedText, - modelId: modelId, - outputFormat: outputFormat, - speed: TalkTTSValidation.resolveSpeed( - speed: input.directive?.speed, - rateWPM: input.directive?.rateWPM), - stability: TalkTTSValidation.validatedStability( - input.directive?.stability, - modelId: modelId), - similarity: TalkTTSValidation.validatedUnit(input.directive?.similarity), - style: TalkTTSValidation.validatedUnit(input.directive?.style), - speakerBoost: input.directive?.speakerBoost, - seed: TalkTTSValidation.validatedSeed(input.directive?.seed), - normalize: ElevenLabsTTSClient.validatedNormalize(input.directive?.normalize), - language: input.language, - latencyTier: TalkTTSValidation.validatedLatencyTier(input.directive?.latencyTier)) - } - - let request = makeRequest(outputFormat: outputFormat) - self.ttsLogger.info("talk TTS synth timeout=\(input.synthTimeoutSeconds, privacy: .public)s") - let client = ElevenLabsTTSClient(apiKey: apiKey) - let stream = client.streamSynthesize(voiceId: voiceId, request: request) - guard self.isCurrent(input.generation) else { return } - - if self.interruptOnSpeech { - guard await self.prepareForPlayback(generation: input.generation) else { return } - } - - await MainActor.run { TalkModeController.shared.updatePhase(.speaking) } - self.phase = .speaking - - let result = await self.playRemoteStream( - client: client, - voiceId: voiceId, - outputFormat: outputFormat, - makeRequest: makeRequest, - stream: stream) - self.ttsLogger - .info( - "talk audio result finished=\(result.finished, privacy: .public) " + - "interruptedAt=\(String(describing: result.interruptedAt), privacy: .public)") - if !result.finished, result.interruptedAt == nil { - throw NSError(domain: "StreamingAudioPlayer", code: 1, userInfo: [ - NSLocalizedDescriptionKey: "audio playback failed", - ]) - } - if !result.finished, let interruptedAt = result.interruptedAt, self.phase == .speaking { - if self.interruptOnSpeech { - self.lastInterruptedAtSeconds = interruptedAt - } - } - } - - private func playRemoteStream( - client: ElevenLabsTTSClient, - voiceId: String, - outputFormat: String?, - makeRequest: (String?) -> ElevenLabsTTSRequest, - stream: AsyncThrowingStream) async -> StreamingPlaybackResult - { - let sampleRate = TalkTTSValidation.pcmSampleRate(from: outputFormat) - if let sampleRate { - self.lastPlaybackWasPCM = true - let result = await self.playPCM(stream: stream, sampleRate: sampleRate) - if result.finished || result.interruptedAt != nil { - return result - } - let mp3Format = ElevenLabsTTSClient.validatedOutputFormat("mp3_44100") - self.ttsLogger.warning("talk pcm playback failed; retrying mp3") - self.lastPlaybackWasPCM = false - let mp3Stream = client.streamSynthesize( - voiceId: voiceId, - request: makeRequest(mp3Format)) - return await self.playMP3(stream: mp3Stream) - } - self.lastPlaybackWasPCM = false - return await self.playMP3(stream: stream) - } - - private func playSystemVoice(input: TalkPlaybackInput) async throws { - self.ttsLogger.info("talk system voice start chars=\(input.cleanedText.count, privacy: .public)") - if self.interruptOnSpeech { - guard await self.prepareForPlayback(generation: input.generation) else { return } - } - await MainActor.run { TalkModeController.shared.updatePhase(.speaking) } - self.phase = .speaking - await TalkSystemSpeechSynthesizer.shared.stop() - try await TalkSystemSpeechSynthesizer.shared.speak( - text: input.cleanedText, - language: input.language) - self.ttsLogger.info("talk system voice done") - } - - private func prepareForPlayback(generation: Int) async -> Bool { - await self.startRecognition() - return self.isCurrent(generation) - } - - private func resolveVoiceId(preferred: String?, apiKey: String) async -> String? { - let trimmed = preferred?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - if !trimmed.isEmpty { - if let resolved = self.resolveVoiceAlias(trimmed) { return resolved } - self.ttsLogger.warning("talk unknown voice alias \(trimmed, privacy: .public)") - } - if let fallbackVoiceId { return fallbackVoiceId } - - do { - let voices = try await ElevenLabsTTSClient(apiKey: apiKey).listVoices() - guard let first = voices.first else { - self.ttsLogger.error("elevenlabs voices list empty") - return nil - } - self.fallbackVoiceId = first.voiceId - if self.defaultVoiceId == nil { - self.defaultVoiceId = first.voiceId - } - if !self.voiceOverrideActive { - self.currentVoiceId = first.voiceId - } - let name = first.name ?? "unknown" - self.ttsLogger - .info("talk default voice selected \(name, privacy: .public) (\(first.voiceId, privacy: .public))") - return first.voiceId - } catch { - self.ttsLogger.error("elevenlabs list voices failed: \(error.localizedDescription, privacy: .public)") - return nil - } - } - - private func resolveVoiceAlias(_ value: String?) -> String? { - let trimmed = (value ?? "").trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty else { return nil } - let normalized = trimmed.lowercased() - if let mapped = self.voiceAliases[normalized] { return mapped } - if self.voiceAliases.values.contains(where: { $0.caseInsensitiveCompare(trimmed) == .orderedSame }) { - return trimmed - } - return Self.isLikelyVoiceId(trimmed) ? trimmed : nil - } - - private static func isLikelyVoiceId(_ value: String) -> Bool { - guard value.count >= 10 else { return false } - return value.allSatisfy { $0.isLetter || $0.isNumber || $0 == "-" || $0 == "_" } - } - - func stopSpeaking(reason: TalkStopReason) async { - let usePCM = self.lastPlaybackWasPCM - let interruptedAt = usePCM ? await self.stopPCM() : await self.stopMP3() - _ = usePCM ? await self.stopMP3() : await self.stopPCM() - await TalkSystemSpeechSynthesizer.shared.stop() - guard self.phase == .speaking else { return } - if reason == .speech, let interruptedAt { - self.lastInterruptedAtSeconds = interruptedAt - } - if reason == .manual { - return - } - if reason == .speech || reason == .userTap { - await self.startListening() - return - } - self.phase = .thinking - await MainActor.run { TalkModeController.shared.updatePhase(.thinking) } - } -} - -extension TalkModeRuntime { - // MARK: - Audio playback (MainActor helpers) - - @MainActor - private func playPCM( - stream: AsyncThrowingStream, - sampleRate: Double) async -> StreamingPlaybackResult - { - await PCMStreamingAudioPlayer.shared.play(stream: stream, sampleRate: sampleRate) - } - - @MainActor - private func playMP3(stream: AsyncThrowingStream) async -> StreamingPlaybackResult { - await StreamingAudioPlayer.shared.play(stream: stream) - } - - @MainActor - private func stopPCM() -> Double? { - PCMStreamingAudioPlayer.shared.stop() - } - - @MainActor - private func stopMP3() -> Double? { - StreamingAudioPlayer.shared.stop() - } - - // MARK: - Config - - private func reloadConfig() async { - let cfg = await self.fetchTalkConfig() - self.defaultVoiceId = cfg.voiceId - self.voiceAliases = cfg.voiceAliases - if !self.voiceOverrideActive { - self.currentVoiceId = cfg.voiceId - } - self.defaultModelId = cfg.modelId - if !self.modelOverrideActive { - self.currentModelId = cfg.modelId - } - self.defaultOutputFormat = cfg.outputFormat - self.interruptOnSpeech = cfg.interruptOnSpeech - self.apiKey = cfg.apiKey - let hasApiKey = (cfg.apiKey?.isEmpty == false) - let voiceLabel = (cfg.voiceId?.isEmpty == false) ? cfg.voiceId! : "none" - let modelLabel = (cfg.modelId?.isEmpty == false) ? cfg.modelId! : "none" - self.logger - .info( - "talk config voiceId=\(voiceLabel, privacy: .public) " + - "modelId=\(modelLabel, privacy: .public) " + - "apiKey=\(hasApiKey, privacy: .public) " + - "interrupt=\(cfg.interruptOnSpeech, privacy: .public)") - } - - private struct TalkRuntimeConfig { - let voiceId: String? - let voiceAliases: [String: String] - let modelId: String? - let outputFormat: String? - let interruptOnSpeech: Bool - let apiKey: String? - } - - private func fetchTalkConfig() async -> TalkRuntimeConfig { - let env = ProcessInfo.processInfo.environment - let envVoice = env["ELEVENLABS_VOICE_ID"]?.trimmingCharacters(in: .whitespacesAndNewlines) - let sagVoice = env["SAG_VOICE_ID"]?.trimmingCharacters(in: .whitespacesAndNewlines) - let envApiKey = env["ELEVENLABS_API_KEY"]?.trimmingCharacters(in: .whitespacesAndNewlines) - - do { - let snap: ConfigSnapshot = try await GatewayConnection.shared.requestDecoded( - method: .configGet, - params: nil, - timeoutMs: 8000) - let talk = snap.config?["talk"]?.dictionaryValue - let ui = snap.config?["ui"]?.dictionaryValue - let rawSeam = ui?["seamColor"]?.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - await MainActor.run { - AppStateStore.shared.seamColorHex = rawSeam.isEmpty ? nil : rawSeam - } - let voice = talk?["voiceId"]?.stringValue - let rawAliases = talk?["voiceAliases"]?.dictionaryValue - let resolvedAliases: [String: String] = - rawAliases?.reduce(into: [:]) { acc, entry in - let key = entry.key.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() - let value = entry.value.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" - guard !key.isEmpty, !value.isEmpty else { return } - acc[key] = value - } ?? [:] - let model = talk?["modelId"]?.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines) - let resolvedModel = (model?.isEmpty == false) ? model! : Self.defaultModelIdFallback - let outputFormat = talk?["outputFormat"]?.stringValue - let interrupt = talk?["interruptOnSpeech"]?.boolValue - let apiKey = talk?["apiKey"]?.stringValue - let resolvedVoice = - (voice?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false ? voice : nil) ?? - (envVoice?.isEmpty == false ? envVoice : nil) ?? - (sagVoice?.isEmpty == false ? sagVoice : nil) - let resolvedApiKey = - (envApiKey?.isEmpty == false ? envApiKey : nil) ?? - (apiKey?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false ? apiKey : nil) - return TalkRuntimeConfig( - voiceId: resolvedVoice, - voiceAliases: resolvedAliases, - modelId: resolvedModel, - outputFormat: outputFormat, - interruptOnSpeech: interrupt ?? true, - apiKey: resolvedApiKey) - } catch { - let resolvedVoice = - (envVoice?.isEmpty == false ? envVoice : nil) ?? - (sagVoice?.isEmpty == false ? sagVoice : nil) - let resolvedApiKey = envApiKey?.isEmpty == false ? envApiKey : nil - return TalkRuntimeConfig( - voiceId: resolvedVoice, - voiceAliases: [:], - modelId: Self.defaultModelIdFallback, - outputFormat: nil, - interruptOnSpeech: true, - apiKey: resolvedApiKey) - } - } - - // MARK: - Audio level handling - - private func noteAudioLevel(rms: Double) async { - if self.phase != .listening, self.phase != .speaking { return } - let alpha: Double = rms < self.noiseFloorRMS ? 0.08 : 0.01 - self.noiseFloorRMS = max(1e-7, self.noiseFloorRMS + (rms - self.noiseFloorRMS) * alpha) - - let threshold = max(self.minSpeechRMS, self.noiseFloorRMS * self.speechBoostFactor) - if rms >= threshold { - let now = Date() - self.lastHeard = now - self.lastSpeechEnergyAt = now - } - - if self.phase == .listening { - let clamped = min(1.0, max(0.0, rms / max(self.minSpeechRMS, threshold))) - await MainActor.run { TalkModeController.shared.updateLevel(clamped) } - } - } - - private static func rmsLevel(buffer: AVAudioPCMBuffer) -> Double? { - guard let channelData = buffer.floatChannelData?.pointee else { return nil } - let frameCount = Int(buffer.frameLength) - guard frameCount > 0 else { return nil } - var sum: Double = 0 - for i in 0.. Bool { - let trimmed = transcript.trimmingCharacters(in: .whitespacesAndNewlines) - guard trimmed.count >= 3 else { return false } - if self.isLikelyEcho(of: trimmed) { return false } - let now = Date() - if let lastSpeechEnergyAt, now.timeIntervalSince(lastSpeechEnergyAt) > 0.35 { - return false - } - return hasConfidence - } - - private func isLikelyEcho(of transcript: String) -> Bool { - guard let spoken = self.lastSpokenText?.lowercased(), !spoken.isEmpty else { return false } - let probe = transcript.lowercased() - if probe.count < 6 { - return spoken.contains(probe) - } - return spoken.contains(probe) - } - - private static func resolveSpeed(speed: Double?, rateWPM: Int?, logger: Logger) -> Double? { - if let rateWPM, rateWPM > 0 { - let resolved = Double(rateWPM) / 175.0 - if resolved <= 0.5 || resolved >= 2.0 { - logger.warning("talk rateWPM out of range: \(rateWPM, privacy: .public)") - return nil - } - return resolved - } - if let speed { - if speed <= 0.5 || speed >= 2.0 { - logger.warning("talk speed out of range: \(speed, privacy: .public)") - return nil - } - return speed - } - return nil - } - - private static func validatedUnit(_ value: Double?, name: String, logger: Logger) -> Double? { - guard let value else { return nil } - if value < 0 || value > 1 { - logger.warning("talk \(name, privacy: .public) out of range: \(value, privacy: .public)") - return nil - } - return value - } - - private static func validatedSeed(_ value: Int?, logger: Logger) -> UInt32? { - guard let value else { return nil } - if value < 0 || value > 4_294_967_295 { - logger.warning("talk seed out of range: \(value, privacy: .public)") - return nil - } - return UInt32(value) - } - - private static func validatedNormalize(_ value: String?, logger: Logger) -> String? { - guard let value else { return nil } - let normalized = value.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() - guard ["auto", "on", "off"].contains(normalized) else { - logger.warning("talk normalize invalid: \(normalized, privacy: .public)") - return nil - } - return normalized - } -} diff --git a/apps/macos/Sources/Clawdbot/TalkOverlay.swift b/apps/macos/Sources/Clawdbot/TalkOverlay.swift deleted file mode 100644 index 387b6db76..000000000 --- a/apps/macos/Sources/Clawdbot/TalkOverlay.swift +++ /dev/null @@ -1,146 +0,0 @@ -import AppKit -import Observation -import OSLog -import SwiftUI - -@MainActor -@Observable -final class TalkOverlayController { - static let shared = TalkOverlayController() - static let overlaySize: CGFloat = 440 - static let orbSize: CGFloat = 96 - static let orbPadding: CGFloat = 12 - static let orbHitSlop: CGFloat = 10 - - private let logger = Logger(subsystem: "com.clawdbot", category: "talk.overlay") - - struct Model { - var isVisible: Bool = false - var phase: TalkModePhase = .idle - var isPaused: Bool = false - var level: Double = 0 - } - - var model = Model() - private var window: NSPanel? - private var hostingView: NSHostingView? - private let screenInset: CGFloat = 0 - - func present() { - self.ensureWindow() - self.hostingView?.rootView = TalkOverlayView(controller: self) - let target = self.targetFrame() - - guard let window else { return } - if !self.model.isVisible { - self.model.isVisible = true - let start = target.offsetBy(dx: 0, dy: -6) - window.setFrame(start, display: true) - window.alphaValue = 0 - window.orderFrontRegardless() - NSAnimationContext.runAnimationGroup { context in - context.duration = 0.18 - context.timingFunction = CAMediaTimingFunction(name: .easeOut) - window.animator().setFrame(target, display: true) - window.animator().alphaValue = 1 - } - } else { - window.setFrame(target, display: true) - window.orderFrontRegardless() - } - } - - func dismiss() { - guard let window else { - self.model.isVisible = false - return - } - - let target = window.frame.offsetBy(dx: 6, dy: 6) - NSAnimationContext.runAnimationGroup { context in - context.duration = 0.16 - context.timingFunction = CAMediaTimingFunction(name: .easeOut) - window.animator().setFrame(target, display: true) - window.animator().alphaValue = 0 - } completionHandler: { - Task { @MainActor in - window.orderOut(nil) - self.model.isVisible = false - } - } - } - - func updatePhase(_ phase: TalkModePhase) { - guard self.model.phase != phase else { return } - self.logger.info("talk overlay phase=\(phase.rawValue, privacy: .public)") - self.model.phase = phase - } - - func updatePaused(_ paused: Bool) { - guard self.model.isPaused != paused else { return } - self.logger.info("talk overlay paused=\(paused)") - self.model.isPaused = paused - } - - func updateLevel(_ level: Double) { - guard self.model.isVisible else { return } - self.model.level = max(0, min(1, level)) - } - - func currentWindowOrigin() -> CGPoint? { - self.window?.frame.origin - } - - func setWindowOrigin(_ origin: CGPoint) { - guard let window else { return } - window.setFrameOrigin(origin) - } - - // MARK: - Private - - private func ensureWindow() { - if self.window != nil { return } - let panel = NSPanel( - contentRect: NSRect(x: 0, y: 0, width: Self.overlaySize, height: Self.overlaySize), - styleMask: [.nonactivatingPanel, .borderless], - backing: .buffered, - defer: false) - panel.isOpaque = false - panel.backgroundColor = .clear - panel.hasShadow = false - panel.level = NSWindow.Level(rawValue: NSWindow.Level.popUpMenu.rawValue - 4) - panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .transient] - panel.hidesOnDeactivate = false - panel.isMovable = false - panel.acceptsMouseMovedEvents = true - panel.isFloatingPanel = true - panel.becomesKeyOnlyIfNeeded = true - panel.titleVisibility = .hidden - panel.titlebarAppearsTransparent = true - - let host = TalkOverlayHostingView(rootView: TalkOverlayView(controller: self)) - host.translatesAutoresizingMaskIntoConstraints = false - panel.contentView = host - self.hostingView = host - self.window = panel - } - - private func targetFrame() -> NSRect { - let screen = self.window?.screen - ?? NSScreen.main - ?? NSScreen.screens.first - guard let screen else { return .zero } - let size = NSSize(width: Self.overlaySize, height: Self.overlaySize) - let visible = screen.visibleFrame - let origin = CGPoint( - x: visible.maxX - size.width - self.screenInset, - y: visible.maxY - size.height - self.screenInset) - return NSRect(origin: origin, size: size) - } -} - -private final class TalkOverlayHostingView: NSHostingView { - override func acceptsFirstMouse(for event: NSEvent?) -> Bool { - true - } -} diff --git a/apps/macos/Sources/Clawdbot/TerminationSignalWatcher.swift b/apps/macos/Sources/Clawdbot/TerminationSignalWatcher.swift deleted file mode 100644 index 7994016ef..000000000 --- a/apps/macos/Sources/Clawdbot/TerminationSignalWatcher.swift +++ /dev/null @@ -1,53 +0,0 @@ -import AppKit -import Foundation -import OSLog - -@MainActor -final class TerminationSignalWatcher { - static let shared = TerminationSignalWatcher() - - private let logger = Logger(subsystem: "com.clawdbot", category: "lifecycle") - private var sources: [DispatchSourceSignal] = [] - private var terminationRequested = false - - func start() { - guard self.sources.isEmpty else { return } - self.install(SIGTERM) - self.install(SIGINT) - } - - func stop() { - for s in self.sources { - s.cancel() - } - self.sources.removeAll(keepingCapacity: false) - self.terminationRequested = false - } - - private func install(_ sig: Int32) { - // Make sure the default action doesn't kill the process before we can gracefully shut down. - signal(sig, SIG_IGN) - let source = DispatchSource.makeSignalSource(signal: sig, queue: .main) - source.setEventHandler { [weak self] in - self?.handle(sig) - } - source.resume() - self.sources.append(source) - } - - private func handle(_ sig: Int32) { - guard !self.terminationRequested else { return } - self.terminationRequested = true - - self.logger.info("received signal \(sig, privacy: .public); terminating") - // Ensure any pairing prompt can't accidentally approve during shutdown. - NodePairingApprovalPrompter.shared.stop() - DevicePairingApprovalPrompter.shared.stop() - NSApp.terminate(nil) - - // Safety net: don't hang forever if something blocks termination. - DispatchQueue.main.asyncAfter(deadline: .now() + 3) { - exit(0) - } - } -} diff --git a/apps/macos/Sources/Clawdbot/VoicePushToTalk.swift b/apps/macos/Sources/Clawdbot/VoicePushToTalk.swift deleted file mode 100644 index 2bb1ec1f5..000000000 --- a/apps/macos/Sources/Clawdbot/VoicePushToTalk.swift +++ /dev/null @@ -1,421 +0,0 @@ -import AppKit -import AVFoundation -import Dispatch -import OSLog -import Speech - -/// Observes right Option and starts a push-to-talk capture while it is held. -final class VoicePushToTalkHotkey: @unchecked Sendable { - static let shared = VoicePushToTalkHotkey() - - private var globalMonitor: Any? - private var localMonitor: Any? - private var optionDown = false // right option only - private var active = false - - private let beginAction: @Sendable () async -> Void - private let endAction: @Sendable () async -> Void - - init( - beginAction: @escaping @Sendable () async -> Void = { await VoicePushToTalk.shared.begin() }, - endAction: @escaping @Sendable () async -> Void = { await VoicePushToTalk.shared.end() }) - { - self.beginAction = beginAction - self.endAction = endAction - } - - func setEnabled(_ enabled: Bool) { - if ProcessInfo.processInfo.isRunningTests { return } - self.withMainThread { [weak self] in - guard let self else { return } - if enabled { - self.startMonitoring() - } else { - self.stopMonitoring() - } - } - } - - private func startMonitoring() { - // assert(Thread.isMainThread) - Removed for Swift 6 - guard self.globalMonitor == nil, self.localMonitor == nil else { return } - // Listen-only global monitor; we rely on Input Monitoring permission to receive events. - self.globalMonitor = NSEvent.addGlobalMonitorForEvents(matching: .flagsChanged) { [weak self] event in - let keyCode = event.keyCode - let flags = event.modifierFlags - self?.handleFlagsChanged(keyCode: keyCode, modifierFlags: flags) - } - // Also listen locally so we still catch events when the app is active/focused. - self.localMonitor = NSEvent.addLocalMonitorForEvents(matching: .flagsChanged) { [weak self] event in - let keyCode = event.keyCode - let flags = event.modifierFlags - self?.handleFlagsChanged(keyCode: keyCode, modifierFlags: flags) - return event - } - } - - private func stopMonitoring() { - // assert(Thread.isMainThread) - Removed for Swift 6 - if let globalMonitor { - NSEvent.removeMonitor(globalMonitor) - self.globalMonitor = nil - } - if let localMonitor { - NSEvent.removeMonitor(localMonitor) - self.localMonitor = nil - } - self.optionDown = false - self.active = false - } - - private func handleFlagsChanged(keyCode: UInt16, modifierFlags: NSEvent.ModifierFlags) { - self.withMainThread { [weak self] in - self?.updateModifierState(keyCode: keyCode, modifierFlags: modifierFlags) - } - } - - private func withMainThread(_ block: @escaping @Sendable () -> Void) { - DispatchQueue.main.async(execute: block) - } - - private func updateModifierState(keyCode: UInt16, modifierFlags: NSEvent.ModifierFlags) { - // assert(Thread.isMainThread) - Removed for Swift 6 - // Right Option (keyCode 61) acts as a hold-to-talk modifier. - if keyCode == 61 { - self.optionDown = modifierFlags.contains(.option) - } - - let chordActive = self.optionDown - if chordActive, !self.active { - self.active = true - Task { - Logger(subsystem: "com.clawdbot", category: "voicewake.ptt") - .info("ptt hotkey down") - await self.beginAction() - } - } else if !chordActive, self.active { - self.active = false - Task { - Logger(subsystem: "com.clawdbot", category: "voicewake.ptt") - .info("ptt hotkey up") - await self.endAction() - } - } - } - - func _testUpdateModifierState(keyCode: UInt16, modifierFlags: NSEvent.ModifierFlags) { - self.updateModifierState(keyCode: keyCode, modifierFlags: modifierFlags) - } -} - -/// Short-lived speech recognizer that records while the hotkey is held. -actor VoicePushToTalk { - static let shared = VoicePushToTalk() - - private let logger = Logger(subsystem: "com.clawdbot", category: "voicewake.ptt") - - private var recognizer: SFSpeechRecognizer? - // Lazily created on begin() to avoid creating an AVAudioEngine at app launch, which can switch Bluetooth - // headphones into the low-quality headset profile even if push-to-talk is never used. - private var audioEngine: AVAudioEngine? - private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest? - private var recognitionTask: SFSpeechRecognitionTask? - private var tapInstalled = false - - // Session token used to drop stale callbacks when a new capture starts. - private var sessionID = UUID() - - private var committed: String = "" - private var volatile: String = "" - private var activeConfig: Config? - private var isCapturing = false - private var triggerChimePlayed = false - private var finalized = false - private var timeoutTask: Task? - private var overlayToken: UUID? - private var adoptedPrefix: String = "" - - private struct Config { - let micID: String? - let localeID: String? - let triggerChime: VoiceWakeChime - let sendChime: VoiceWakeChime - } - - func begin() async { - guard voiceWakeSupported else { return } - guard !self.isCapturing else { return } - - // Start a fresh session and invalidate any in-flight callbacks tied to an older one. - let sessionID = UUID() - self.sessionID = sessionID - - // Ensure permissions up front. - let granted = await PermissionManager.ensureVoiceWakePermissions(interactive: true) - guard granted else { return } - - let config = await MainActor.run { self.makeConfig() } - self.activeConfig = config - self.isCapturing = true - self.triggerChimePlayed = false - self.finalized = false - self.timeoutTask?.cancel(); self.timeoutTask = nil - let snapshot = await MainActor.run { VoiceSessionCoordinator.shared.snapshot() } - self.adoptedPrefix = snapshot.visible ? snapshot.text.trimmingCharacters(in: .whitespacesAndNewlines) : "" - self.logger.info("ptt begin adopted_prefix_len=\(self.adoptedPrefix.count, privacy: .public)") - if config.triggerChime != .none { - self.triggerChimePlayed = true - await MainActor.run { VoiceWakeChimePlayer.play(config.triggerChime, reason: "ptt.trigger") } - } - // Pause the always-on wake word recognizer so both pipelines don't fight over the mic tap. - await VoiceWakeRuntime.shared.pauseForPushToTalk() - let adoptedPrefix = self.adoptedPrefix - let adoptedAttributed: NSAttributedString? = adoptedPrefix.isEmpty ? nil : Self.makeAttributed( - committed: adoptedPrefix, - volatile: "", - isFinal: false) - self.overlayToken = await MainActor.run { - VoiceSessionCoordinator.shared.startSession( - source: .pushToTalk, - text: adoptedPrefix, - attributed: adoptedAttributed, - forwardEnabled: true) - } - - do { - try await self.startRecognition(localeID: config.localeID, sessionID: sessionID) - } catch { - await MainActor.run { - VoiceWakeOverlayController.shared.dismiss() - } - self.isCapturing = false - // If push-to-talk fails to start after pausing wake-word, ensure we resume listening. - await VoiceWakeRuntime.shared.applyPushToTalkCooldown() - await VoiceWakeRuntime.shared.refresh(state: AppStateStore.shared) - } - } - - func end() async { - guard self.isCapturing else { return } - self.isCapturing = false - let sessionID = self.sessionID - - // Stop feeding Speech buffers first, then end the request. Stopping the engine here can race with - // Speech draining its converter chain (and we already stop/cancel in finalize). - if self.tapInstalled { - self.audioEngine?.inputNode.removeTap(onBus: 0) - self.tapInstalled = false - } - self.recognitionRequest?.endAudio() - - // If we captured nothing, dismiss immediately when the user lets go. - if self.committed.isEmpty, self.volatile.isEmpty, self.adoptedPrefix.isEmpty { - await self.finalize(transcriptOverride: "", reason: "emptyOnRelease", sessionID: sessionID) - return - } - - // Otherwise, give Speech a brief window to deliver the final result; then fall back. - self.timeoutTask?.cancel() - self.timeoutTask = Task { [weak self] in - try? await Task.sleep(nanoseconds: 1_500_000_000) // 1.5s grace period to await final result - await self?.finalize(transcriptOverride: nil, reason: "timeout", sessionID: sessionID) - } - } - - // MARK: - Private - - private func startRecognition(localeID: String?, sessionID: UUID) async throws { - let locale = localeID.flatMap { Locale(identifier: $0) } ?? Locale(identifier: Locale.current.identifier) - self.recognizer = SFSpeechRecognizer(locale: locale) - guard let recognizer, recognizer.isAvailable else { - throw NSError( - domain: "VoicePushToTalk", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "Recognizer unavailable"]) - } - - self.recognitionRequest = SFSpeechAudioBufferRecognitionRequest() - self.recognitionRequest?.shouldReportPartialResults = true - guard let request = self.recognitionRequest else { return } - - // Lazily create the engine here so app launch doesn't grab audio resources / trigger Bluetooth HFP. - if self.audioEngine == nil { - self.audioEngine = AVAudioEngine() - } - guard let audioEngine = self.audioEngine else { return } - - let input = audioEngine.inputNode - let format = input.outputFormat(forBus: 0) - if self.tapInstalled { - input.removeTap(onBus: 0) - self.tapInstalled = false - } - // Pipe raw mic buffers into the Speech request while the chord is held. - input.installTap(onBus: 0, bufferSize: 2048, format: format) { [weak request] buffer, _ in - request?.append(buffer) - } - self.tapInstalled = true - - audioEngine.prepare() - try audioEngine.start() - - self.recognitionTask = recognizer.recognitionTask(with: request) { [weak self] result, error in - guard let self else { return } - if let error { - self.logger.debug("push-to-talk error: \(error.localizedDescription, privacy: .public)") - } - let transcript = result?.bestTranscription.formattedString - let isFinal = result?.isFinal ?? false - // Hop to a Task so UI updates stay off the Speech callback thread. - Task.detached { [weak self, transcript, isFinal, sessionID] in - guard let self else { return } - await self.handle(transcript: transcript, isFinal: isFinal, sessionID: sessionID) - } - } - } - - private func handle(transcript: String?, isFinal: Bool, sessionID: UUID) async { - guard sessionID == self.sessionID else { - self.logger.debug("push-to-talk drop transcript for stale session") - return - } - guard let transcript else { return } - if isFinal { - self.committed = transcript - self.volatile = "" - } else { - self.volatile = Self.delta(after: self.committed, current: transcript) - } - - let committedWithPrefix = Self.join(self.adoptedPrefix, self.committed) - let snapshot = Self.join(committedWithPrefix, self.volatile) - let attributed = Self.makeAttributed(committed: committedWithPrefix, volatile: self.volatile, isFinal: isFinal) - if let token = self.overlayToken { - await MainActor.run { - VoiceSessionCoordinator.shared.updatePartial( - token: token, - text: snapshot, - attributed: attributed) - } - } - } - - private func finalize(transcriptOverride: String?, reason: String, sessionID: UUID?) async { - if self.finalized { return } - if let sessionID, sessionID != self.sessionID { - self.logger.debug("push-to-talk drop finalize for stale session") - return - } - self.finalized = true - self.isCapturing = false - self.timeoutTask?.cancel(); self.timeoutTask = nil - - let finalRecognized: String = { - if let override = transcriptOverride?.trimmingCharacters(in: .whitespacesAndNewlines) { - return override - } - return (self.committed + self.volatile).trimmingCharacters(in: .whitespacesAndNewlines) - }() - let finalText = Self.join(self.adoptedPrefix, finalRecognized) - let chime = finalText.isEmpty ? .none : (self.activeConfig?.sendChime ?? .none) - - let token = self.overlayToken - let logger = self.logger - await MainActor.run { - logger.info("ptt finalize reason=\(reason, privacy: .public) len=\(finalText.count, privacy: .public)") - if let token { - VoiceSessionCoordinator.shared.finalize( - token: token, - text: finalText, - sendChime: chime, - autoSendAfter: nil) - VoiceSessionCoordinator.shared.sendNow(token: token, reason: reason) - } else if !finalText.isEmpty { - if chime != .none { - VoiceWakeChimePlayer.play(chime, reason: "ptt.fallback_send") - } - Task.detached { - await VoiceWakeForwarder.forward(transcript: finalText) - } - } - } - - self.recognitionTask?.cancel() - self.recognitionRequest = nil - self.recognitionTask = nil - if self.tapInstalled { - self.audioEngine?.inputNode.removeTap(onBus: 0) - self.tapInstalled = false - } - if self.audioEngine?.isRunning == true { - self.audioEngine?.stop() - self.audioEngine?.reset() - } - // Release the engine so we also release any audio session/resources when push-to-talk ends. - self.audioEngine = nil - - self.committed = "" - self.volatile = "" - self.activeConfig = nil - self.triggerChimePlayed = false - self.overlayToken = nil - self.adoptedPrefix = "" - - // Resume the wake-word runtime after push-to-talk finishes. - await VoiceWakeRuntime.shared.applyPushToTalkCooldown() - _ = await MainActor.run { Task { await VoiceWakeRuntime.shared.refresh(state: AppStateStore.shared) } } - } - - @MainActor - private func makeConfig() -> Config { - let state = AppStateStore.shared - return Config( - micID: state.voiceWakeMicID.isEmpty ? nil : state.voiceWakeMicID, - localeID: state.voiceWakeLocaleID, - triggerChime: state.voiceWakeTriggerChime, - sendChime: state.voiceWakeSendChime) - } - - // MARK: - Test helpers - - static func _testDelta(committed: String, current: String) -> String { - self.delta(after: committed, current: current) - } - - static func _testAttributedColors(isFinal: Bool) -> (NSColor, NSColor) { - let sample = self.makeAttributed(committed: "a", volatile: "b", isFinal: isFinal) - let committedColor = sample.attribute(.foregroundColor, at: 0, effectiveRange: nil) as? NSColor ?? .clear - let volatileColor = sample.attribute(.foregroundColor, at: 1, effectiveRange: nil) as? NSColor ?? .clear - return (committedColor, volatileColor) - } - - private static func join(_ prefix: String, _ suffix: String) -> String { - if prefix.isEmpty { return suffix } - if suffix.isEmpty { return prefix } - return "\(prefix) \(suffix)" - } - - private static func delta(after committed: String, current: String) -> String { - if current.hasPrefix(committed) { - let start = current.index(current.startIndex, offsetBy: committed.count) - return String(current[start...]) - } - return current - } - - private static func makeAttributed(committed: String, volatile: String, isFinal: Bool) -> NSAttributedString { - let full = NSMutableAttributedString() - let committedAttr: [NSAttributedString.Key: Any] = [ - .foregroundColor: NSColor.labelColor, - .font: NSFont.systemFont(ofSize: 13, weight: .regular), - ] - full.append(NSAttributedString(string: committed, attributes: committedAttr)) - let volatileColor: NSColor = isFinal ? .labelColor : NSColor.tertiaryLabelColor - let volatileAttr: [NSAttributedString.Key: Any] = [ - .foregroundColor: volatileColor, - .font: NSFont.systemFont(ofSize: 13, weight: .regular), - ] - full.append(NSAttributedString(string: volatile, attributes: volatileAttr)) - return full - } -} diff --git a/apps/macos/Sources/Clawdbot/VoiceSessionCoordinator.swift b/apps/macos/Sources/Clawdbot/VoiceSessionCoordinator.swift deleted file mode 100644 index d7ee38a53..000000000 --- a/apps/macos/Sources/Clawdbot/VoiceSessionCoordinator.swift +++ /dev/null @@ -1,134 +0,0 @@ -import AppKit -import Foundation -import Observation - -@MainActor -@Observable -final class VoiceSessionCoordinator { - static let shared = VoiceSessionCoordinator() - - enum Source: String { case wakeWord, pushToTalk } - - struct Session { - let token: UUID - let source: Source - var text: String - var attributed: NSAttributedString? - var isFinal: Bool - var sendChime: VoiceWakeChime - var autoSendDelay: TimeInterval? - } - - private let logger = Logger(subsystem: "com.clawdbot", category: "voicewake.coordinator") - private var session: Session? - - // MARK: - API - - func startSession( - source: Source, - text: String, - attributed: NSAttributedString? = nil, - forwardEnabled: Bool = false) -> UUID - { - let token = UUID() - self.logger.info("coordinator start token=\(token.uuidString) source=\(source.rawValue) len=\(text.count)") - let attributedText = attributed ?? VoiceWakeOverlayController.shared.makeAttributed(from: text) - let session = Session( - token: token, - source: source, - text: text, - attributed: attributedText, - isFinal: false, - sendChime: .none, - autoSendDelay: nil) - self.session = session - VoiceWakeOverlayController.shared.startSession( - token: token, - source: VoiceWakeOverlayController.Source(rawValue: source.rawValue) ?? .wakeWord, - transcript: text, - attributed: attributedText, - forwardEnabled: forwardEnabled, - isFinal: false) - return token - } - - func updatePartial(token: UUID, text: String, attributed: NSAttributedString? = nil) { - guard let session, session.token == token else { return } - self.session?.text = text - self.session?.attributed = attributed - VoiceWakeOverlayController.shared.updatePartial(token: token, transcript: text, attributed: attributed) - } - - func finalize( - token: UUID, - text: String, - sendChime: VoiceWakeChime, - autoSendAfter: TimeInterval?) - { - guard let session, session.token == token else { return } - self.logger - .info( - "coordinator finalize token=\(token.uuidString) len=\(text.count) autoSendAfter=\(autoSendAfter ?? -1)") - self.session?.text = text - self.session?.isFinal = true - self.session?.sendChime = sendChime - self.session?.autoSendDelay = autoSendAfter - - let attributed = VoiceWakeOverlayController.shared.makeAttributed(from: text) - VoiceWakeOverlayController.shared.presentFinal( - token: token, - transcript: text, - autoSendAfter: autoSendAfter, - sendChime: sendChime, - attributed: attributed) - } - - func sendNow(token: UUID, reason: String = "explicit") { - guard let session, session.token == token else { return } - let text = session.text.trimmingCharacters(in: .whitespacesAndNewlines) - guard !text.isEmpty else { - self.logger.info("coordinator sendNow \(reason) empty -> dismiss") - VoiceWakeOverlayController.shared.dismiss(token: token, reason: .empty, outcome: .empty) - self.clearSession() - return - } - VoiceWakeOverlayController.shared.beginSendUI(token: token, sendChime: session.sendChime) - Task.detached { - _ = await VoiceWakeForwarder.forward(transcript: text) - } - } - - func dismiss( - token: UUID, - reason: VoiceWakeOverlayController.DismissReason, - outcome: VoiceWakeOverlayController.SendOutcome) - { - guard let session, session.token == token else { return } - VoiceWakeOverlayController.shared.dismiss(token: token, reason: reason, outcome: outcome) - self.clearSession() - } - - func updateLevel(token: UUID, _ level: Double) { - guard let session, session.token == token else { return } - VoiceWakeOverlayController.shared.updateLevel(token: token, level) - } - - func snapshot() -> (token: UUID?, text: String, visible: Bool) { - (self.session?.token, self.session?.text ?? "", VoiceWakeOverlayController.shared.isVisible) - } - - // MARK: - Private - - private func clearSession() { - self.session = nil - } - - /// Overlay dismiss completion callback (manual X, empty, auto-dismiss after send). - /// Ensures the wake-word recognizer is resumed if Voice Wake is enabled. - func overlayDidDismiss(token: UUID?) { - if let token, self.session?.token == token { - self.clearSession() - } - Task { await VoiceWakeRuntime.shared.refresh(state: AppStateStore.shared) } - } -} diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeChime.swift b/apps/macos/Sources/Clawdbot/VoiceWakeChime.swift deleted file mode 100644 index 8d0cc8b28..000000000 --- a/apps/macos/Sources/Clawdbot/VoiceWakeChime.swift +++ /dev/null @@ -1,74 +0,0 @@ -import AppKit -import Foundation -import OSLog - -enum VoiceWakeChime: Codable, Equatable, Sendable { - case none - case system(name: String) - case custom(displayName: String, bookmark: Data) - - var systemName: String? { - if case let .system(name) = self { - return name - } - return nil - } - - var displayLabel: String { - switch self { - case .none: - "No Sound" - case let .system(name): - VoiceWakeChimeCatalog.displayName(for: name) - case let .custom(displayName, _): - displayName - } - } -} - -enum VoiceWakeChimeCatalog { - /// Options shown in the picker. - static var systemOptions: [String] { SoundEffectCatalog.systemOptions } - - static func displayName(for raw: String) -> String { - SoundEffectCatalog.displayName(for: raw) - } - - static func url(for name: String) -> URL? { - SoundEffectCatalog.url(for: name) - } -} - -@MainActor -enum VoiceWakeChimePlayer { - private static let logger = Logger(subsystem: "com.clawdbot", category: "voicewake.chime") - private static var lastSound: NSSound? - - static func play(_ chime: VoiceWakeChime, reason: String? = nil) { - guard let sound = self.sound(for: chime) else { return } - if let reason { - self.logger.log(level: .info, "chime play reason=\(reason, privacy: .public)") - } else { - self.logger.log(level: .info, "chime play") - } - DiagnosticsFileLog.shared.log(category: "voicewake.chime", event: "play", fields: [ - "reason": reason ?? "", - "chime": chime.displayLabel, - "systemName": chime.systemName ?? "", - ]) - SoundEffectPlayer.play(sound) - } - - private static func sound(for chime: VoiceWakeChime) -> NSSound? { - switch chime { - case .none: - nil - - case let .system(name): - SoundEffectPlayer.sound(named: name) - - case let .custom(_, bookmark): - SoundEffectPlayer.sound(from: bookmark) - } - } -} diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeForwarder.swift b/apps/macos/Sources/Clawdbot/VoiceWakeForwarder.swift deleted file mode 100644 index 3fd9f827b..000000000 --- a/apps/macos/Sources/Clawdbot/VoiceWakeForwarder.swift +++ /dev/null @@ -1,73 +0,0 @@ -import Foundation -import OSLog - -enum VoiceWakeForwarder { - private static let logger = Logger(subsystem: "com.clawdbot", category: "voicewake.forward") - - static func prefixedTranscript(_ transcript: String, machineName: String? = nil) -> String { - let resolvedMachine = machineName - .flatMap { name -> String? in - let trimmed = name.trimmingCharacters(in: .whitespacesAndNewlines) - return trimmed.isEmpty ? nil : trimmed - } - ?? Host.current().localizedName - ?? ProcessInfo.processInfo.hostName - - let safeMachine = resolvedMachine.isEmpty ? "this Mac" : resolvedMachine - return """ - User talked via voice recognition on \(safeMachine) - repeat prompt first \ - + remember some words might be incorrectly transcribed. - - \(transcript) - """ - } - - enum VoiceWakeForwardError: LocalizedError, Equatable { - case rpcFailed(String) - - var errorDescription: String? { - switch self { - case let .rpcFailed(message): message - } - } - } - - struct ForwardOptions: Sendable { - var sessionKey: String = "main" - var thinking: String = "low" - var deliver: Bool = true - var to: String? - var channel: GatewayAgentChannel = .last - } - - @discardableResult - static func forward( - transcript: String, - options: ForwardOptions = ForwardOptions()) async -> Result - { - let payload = Self.prefixedTranscript(transcript) - let deliver = options.channel.shouldDeliver(options.deliver) - let result = await GatewayConnection.shared.sendAgent(GatewayAgentInvocation( - message: payload, - sessionKey: options.sessionKey, - thinking: options.thinking, - deliver: deliver, - to: options.to, - channel: options.channel)) - - if result.ok { - self.logger.info("voice wake forward ok") - return .success(()) - } - - let message = result.error ?? "agent rpc unavailable" - self.logger.error("voice wake forward failed: \(message, privacy: .public)") - return .failure(.rpcFailed(message)) - } - - static func checkConnection() async -> Result { - let status = await GatewayConnection.shared.status() - if status.ok { return .success(()) } - return .failure(.rpcFailed(status.error ?? "agent rpc unreachable")) - } -} diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeGlobalSettingsSync.swift b/apps/macos/Sources/Clawdbot/VoiceWakeGlobalSettingsSync.swift deleted file mode 100644 index d08b79d84..000000000 --- a/apps/macos/Sources/Clawdbot/VoiceWakeGlobalSettingsSync.swift +++ /dev/null @@ -1,66 +0,0 @@ -import MoltbotKit -import Foundation -import OSLog - -@MainActor -final class VoiceWakeGlobalSettingsSync { - static let shared = VoiceWakeGlobalSettingsSync() - - private let logger = Logger(subsystem: "com.clawdbot", category: "voicewake.sync") - private var task: Task? - - private struct VoiceWakePayload: Codable, Equatable { - let triggers: [String] - } - - func start() { - guard self.task == nil else { return } - self.task = Task { [weak self] in - guard let self else { return } - while !Task.isCancelled { - do { - try await GatewayConnection.shared.refresh() - } catch { - // Not configured / not reachable yet. - } - - await self.refreshFromGateway() - - let stream = await GatewayConnection.shared.subscribe(bufferingNewest: 200) - for await push in stream { - if Task.isCancelled { return } - await self.handle(push: push) - } - - // If the stream finishes (gateway shutdown / reconnect), loop and resubscribe. - try? await Task.sleep(nanoseconds: 600_000_000) - } - } - } - - func stop() { - self.task?.cancel() - self.task = nil - } - - private func refreshFromGateway() async { - do { - let triggers = try await GatewayConnection.shared.voiceWakeGetTriggers() - AppStateStore.shared.applyGlobalVoiceWakeTriggers(triggers) - } catch { - // Best-effort only. - } - } - - func handle(push: GatewayPush) async { - guard case let .event(evt) = push else { return } - guard evt.event == "voicewake.changed" else { return } - guard let payload = evt.payload else { return } - do { - let decoded = try GatewayPayloadDecoding.decode(payload, as: VoiceWakePayload.self) - AppStateStore.shared.applyGlobalVoiceWakeTriggers(decoded.triggers) - } catch { - self.logger.error("failed to decode voicewake.changed: \(error.localizedDescription, privacy: .public)") - } - } -} diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeOverlay.swift b/apps/macos/Sources/Clawdbot/VoiceWakeOverlay.swift deleted file mode 100644 index 278ca1389..000000000 --- a/apps/macos/Sources/Clawdbot/VoiceWakeOverlay.swift +++ /dev/null @@ -1,60 +0,0 @@ -import AppKit -import Observation -import SwiftUI - -/// Lightweight, borderless panel that shows the current voice wake transcript near the menu bar. -@MainActor -@Observable -final class VoiceWakeOverlayController { - static let shared = VoiceWakeOverlayController() - - let logger = Logger(subsystem: "com.clawdbot", category: "voicewake.overlay") - let enableUI: Bool - - /// Keep the voice wake overlay above any other Moltbot windows, but below the system’s pop-up menus. - /// (Menu bar menus typically live at `.popUpMenu`.) - static let preferredWindowLevel = NSWindow.Level(rawValue: NSWindow.Level.popUpMenu.rawValue - 4) - - enum Source: String { case wakeWord, pushToTalk } - - var model = Model() - var isVisible: Bool { self.model.isVisible } - - struct Model { - var text: String = "" - var isFinal: Bool = false - var isVisible: Bool = false - var forwardEnabled: Bool = false - var isSending: Bool = false - var attributed: NSAttributedString = .init(string: "") - var isOverflowing: Bool = false - var isEditing: Bool = false - var level: Double = 0 // normalized 0...1 speech level for UI - } - - var window: NSPanel? - var hostingView: NSHostingView? - var autoSendTask: Task? - var autoSendToken: UUID? - var activeToken: UUID? - var activeSource: Source? - var lastLevelUpdate: TimeInterval = 0 - - let width: CGFloat = 360 - let padding: CGFloat = 10 - let buttonWidth: CGFloat = 36 - let spacing: CGFloat = 8 - let verticalPadding: CGFloat = 8 - let maxHeight: CGFloat = 400 - let minHeight: CGFloat = 48 - let closeOverflow: CGFloat = 10 - let levelUpdateInterval: TimeInterval = 1.0 / 12.0 - - enum DismissReason { case explicit, empty } - enum SendOutcome { case sent, empty } - enum GuardOutcome { case accept, dropMismatch, dropNoActive } - - init(enableUI: Bool = true) { - self.enableUI = enableUI - } -} diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeRuntime.swift b/apps/macos/Sources/Clawdbot/VoiceWakeRuntime.swift deleted file mode 100644 index 06ebfb7ae..000000000 --- a/apps/macos/Sources/Clawdbot/VoiceWakeRuntime.swift +++ /dev/null @@ -1,804 +0,0 @@ -import AVFoundation -import Foundation -import OSLog -import Speech -import SwabbleKit -#if canImport(AppKit) -import AppKit -#endif - -/// Background listener that keeps the voice-wake pipeline alive outside the settings test view. -actor VoiceWakeRuntime { - static let shared = VoiceWakeRuntime() - - enum ListeningState { case idle, voiceWake, pushToTalk } - - private let logger = Logger(subsystem: "com.clawdbot", category: "voicewake.runtime") - - private var recognizer: SFSpeechRecognizer? - // Lazily created on start to avoid creating an AVAudioEngine at app launch, which can switch Bluetooth - // headphones into the low-quality headset profile even if Voice Wake is disabled. - private var audioEngine: AVAudioEngine? - private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest? - private var recognitionTask: SFSpeechRecognitionTask? - private var recognitionGeneration: Int = 0 // drop stale callbacks after restarts - private var lastHeard: Date? - private var noiseFloorRMS: Double = 1e-4 - private var captureStartedAt: Date? - private var captureTask: Task? - private var capturedTranscript: String = "" - private var isCapturing: Bool = false - private var heardBeyondTrigger: Bool = false - private var triggerChimePlayed: Bool = false - private var committedTranscript: String = "" - private var volatileTranscript: String = "" - private var cooldownUntil: Date? - private var currentConfig: RuntimeConfig? - private var listeningState: ListeningState = .idle - private var overlayToken: UUID? - private var activeTriggerEndTime: TimeInterval? - private var scheduledRestartTask: Task? - private var lastLoggedText: String? - private var lastLoggedAt: Date? - private var lastTapLogAt: Date? - private var lastCallbackLogAt: Date? - private var lastTranscript: String? - private var lastTranscriptAt: Date? - private var preDetectTask: Task? - private var isStarting: Bool = false - private var triggerOnlyTask: Task? - - // Tunables - // Silence threshold once we've captured user speech (post-trigger). - private let silenceWindow: TimeInterval = 2.0 - // Silence threshold when we only heard the trigger but no post-trigger speech yet. - private let triggerOnlySilenceWindow: TimeInterval = 5.0 - // Maximum capture duration from trigger until we force-send, to avoid runaway sessions. - private let captureHardStop: TimeInterval = 120.0 - private let debounceAfterSend: TimeInterval = 0.35 - // Voice activity detection parameters (RMS-based). - private let minSpeechRMS: Double = 1e-3 - private let speechBoostFactor: Double = 6.0 // how far above noise floor we require to mark speech - private let preDetectSilenceWindow: TimeInterval = 1.0 - private let triggerPauseWindow: TimeInterval = 0.55 - - /// Stops the active Speech pipeline without clearing the stored config, so we can restart cleanly. - private func haltRecognitionPipeline() { - // Bump generation first so any in-flight callbacks from the cancelled task get dropped. - self.recognitionGeneration &+= 1 - self.recognitionTask?.cancel() - self.recognitionTask = nil - self.recognitionRequest?.endAudio() - self.recognitionRequest = nil - self.audioEngine?.inputNode.removeTap(onBus: 0) - self.audioEngine?.stop() - // Release the engine so we also release any audio session/resources when Voice Wake is idle. - self.audioEngine = nil - } - - struct RuntimeConfig: Equatable { - let triggers: [String] - let micID: String? - let localeID: String? - let triggerChime: VoiceWakeChime - let sendChime: VoiceWakeChime - } - - private struct RecognitionUpdate { - let transcript: String? - let segments: [WakeWordSegment] - let isFinal: Bool - let error: Error? - let generation: Int - } - - func refresh(state: AppState) async { - let snapshot = await MainActor.run { () -> (Bool, RuntimeConfig) in - let enabled = state.swabbleEnabled - let config = RuntimeConfig( - triggers: sanitizeVoiceWakeTriggers(state.swabbleTriggerWords), - micID: state.voiceWakeMicID.isEmpty ? nil : state.voiceWakeMicID, - localeID: state.voiceWakeLocaleID.isEmpty ? nil : state.voiceWakeLocaleID, - triggerChime: state.voiceWakeTriggerChime, - sendChime: state.voiceWakeSendChime) - return (enabled, config) - } - - guard voiceWakeSupported, snapshot.0 else { - self.stop() - return - } - - guard PermissionManager.voiceWakePermissionsGranted() else { - self.logger.debug("voicewake runtime not starting: permissions missing") - self.stop() - return - } - - let config = snapshot.1 - - if self.isStarting { - return - } - - if self.scheduledRestartTask != nil, config == self.currentConfig, self.recognitionTask == nil { - return - } - - if self.scheduledRestartTask != nil { - self.scheduledRestartTask?.cancel() - self.scheduledRestartTask = nil - } - - if config == self.currentConfig, self.recognitionTask != nil { - return - } - - self.stop() - await self.start(with: config) - } - - private func start(with config: RuntimeConfig) async { - if self.isStarting { - return - } - self.isStarting = true - defer { self.isStarting = false } - do { - self.recognitionGeneration &+= 1 - let generation = self.recognitionGeneration - - self.configureSession(localeID: config.localeID) - - guard let recognizer, recognizer.isAvailable else { - self.logger.error("voicewake runtime: speech recognizer unavailable") - return - } - - self.recognitionRequest = SFSpeechAudioBufferRecognitionRequest() - self.recognitionRequest?.shouldReportPartialResults = true - self.recognitionRequest?.taskHint = .dictation - guard let request = self.recognitionRequest else { return } - - // Lazily create the engine here so app launch doesn't grab audio resources / trigger Bluetooth HFP. - if self.audioEngine == nil { - self.audioEngine = AVAudioEngine() - } - guard let audioEngine = self.audioEngine else { return } - - let input = audioEngine.inputNode - let format = input.outputFormat(forBus: 0) - guard format.channelCount > 0, format.sampleRate > 0 else { - throw NSError( - domain: "VoiceWakeRuntime", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "No audio input available"]) - } - input.removeTap(onBus: 0) - input.installTap(onBus: 0, bufferSize: 2048, format: format) { [weak self, weak request] buffer, _ in - request?.append(buffer) - guard let rms = Self.rmsLevel(buffer: buffer) else { return } - Task.detached { [weak self] in - await self?.noteAudioLevel(rms: rms) - await self?.noteAudioTap(rms: rms) - } - } - - audioEngine.prepare() - try audioEngine.start() - - self.currentConfig = config - self.lastHeard = Date() - // Preserve any existing cooldownUntil so the debounce after send isn't wiped by a restart. - - self.recognitionTask = recognizer.recognitionTask(with: request) { [weak self, generation] result, error in - guard let self else { return } - let transcript = result?.bestTranscription.formattedString - let segments = result.flatMap { result in - transcript - .map { WakeWordSpeechSegments.from(transcription: result.bestTranscription, transcript: $0) } - } ?? [] - let isFinal = result?.isFinal ?? false - Task { await self.noteRecognitionCallback(transcript: transcript, isFinal: isFinal, error: error) } - let update = RecognitionUpdate( - transcript: transcript, - segments: segments, - isFinal: isFinal, - error: error, - generation: generation) - Task { await self.handleRecognition(update, config: config) } - } - - let preferred = config.micID?.isEmpty == false ? config.micID! : "system-default" - self.logger.info( - "voicewake runtime input preferred=\(preferred, privacy: .public) " + - "\(AudioInputDeviceObserver.defaultInputDeviceSummary(), privacy: .public)") - self.logger.info("voicewake runtime started") - DiagnosticsFileLog.shared.log(category: "voicewake.runtime", event: "started", fields: [ - "locale": config.localeID ?? "", - "micID": config.micID ?? "", - ]) - } catch { - self.logger.error("voicewake runtime failed to start: \(error.localizedDescription, privacy: .public)") - self.stop() - } - } - - private func stop(dismissOverlay: Bool = true, cancelScheduledRestart: Bool = true) { - if cancelScheduledRestart { - self.scheduledRestartTask?.cancel() - self.scheduledRestartTask = nil - } - self.captureTask?.cancel() - self.captureTask = nil - self.isCapturing = false - self.capturedTranscript = "" - self.captureStartedAt = nil - self.triggerChimePlayed = false - self.lastTranscript = nil - self.lastTranscriptAt = nil - self.preDetectTask?.cancel() - self.preDetectTask = nil - self.triggerOnlyTask?.cancel() - self.triggerOnlyTask = nil - self.haltRecognitionPipeline() - self.recognizer = nil - self.currentConfig = nil - self.listeningState = .idle - self.activeTriggerEndTime = nil - self.logger.debug("voicewake runtime stopped") - DiagnosticsFileLog.shared.log(category: "voicewake.runtime", event: "stopped") - - let token = self.overlayToken - self.overlayToken = nil - guard dismissOverlay else { return } - Task { @MainActor in - if let token { - VoiceSessionCoordinator.shared.dismiss(token: token, reason: .explicit, outcome: .empty) - } else { - VoiceWakeOverlayController.shared.dismiss() - } - } - } - - private func configureSession(localeID: String?) { - let locale = localeID.flatMap { Locale(identifier: $0) } ?? Locale(identifier: Locale.current.identifier) - self.recognizer = SFSpeechRecognizer(locale: locale) - self.recognizer?.defaultTaskHint = .dictation - } - - private func handleRecognition(_ update: RecognitionUpdate, config: RuntimeConfig) async { - if update.generation != self.recognitionGeneration { - return // stale callback from a superseded recognizer session - } - if let error = update.error { - self.logger.debug("voicewake recognition error: \(error.localizedDescription, privacy: .public)") - } - - guard let transcript = update.transcript else { return } - - let now = Date() - if !transcript.isEmpty { - self.lastHeard = now - if !self.isCapturing { - self.lastTranscript = transcript - self.lastTranscriptAt = now - } - if self.isCapturing { - self.maybeLogRecognition( - transcript: transcript, - segments: update.segments, - triggers: config.triggers, - isFinal: update.isFinal, - match: nil, - usedFallback: false, - capturing: true) - let trimmed = Self.commandAfterTrigger( - transcript: transcript, - segments: update.segments, - triggerEndTime: self.activeTriggerEndTime, - triggers: config.triggers) - self.capturedTranscript = trimmed - self.updateHeardBeyondTrigger(withTrimmed: trimmed) - if update.isFinal { - self.committedTranscript = trimmed - self.volatileTranscript = "" - } else { - self.volatileTranscript = Self.delta(after: self.committedTranscript, current: trimmed) - } - - let attributed = Self.makeAttributed( - committed: self.committedTranscript, - volatile: self.volatileTranscript, - isFinal: update.isFinal) - let snapshot = self.committedTranscript + self.volatileTranscript - if let token = self.overlayToken { - await MainActor.run { - VoiceSessionCoordinator.shared.updatePartial( - token: token, - text: snapshot, - attributed: attributed) - } - } - } - } - - if self.isCapturing { return } - - let gateConfig = WakeWordGateConfig(triggers: config.triggers) - var usedFallback = false - var match = WakeWordGate.match(transcript: transcript, segments: update.segments, config: gateConfig) - if match == nil, update.isFinal { - match = self.textOnlyFallbackMatch( - transcript: transcript, - triggers: config.triggers, - config: gateConfig) - usedFallback = match != nil - } - self.maybeLogRecognition( - transcript: transcript, - segments: update.segments, - triggers: config.triggers, - isFinal: update.isFinal, - match: match, - usedFallback: usedFallback, - capturing: false) - - if let match { - if let cooldown = cooldownUntil, now < cooldown { - return - } - if usedFallback { - self.logger.info("voicewake runtime detected (text-only fallback) len=\(match.command.count)") - } else { - self.logger.info("voicewake runtime detected len=\(match.command.count)") - } - await self.beginCapture(command: match.command, triggerEndTime: match.triggerEndTime, config: config) - } else if !transcript.isEmpty, update.error == nil { - if self.isTriggerOnly(transcript: transcript, triggers: config.triggers) { - self.preDetectTask?.cancel() - self.preDetectTask = nil - self.scheduleTriggerOnlyPauseCheck(triggers: config.triggers, config: config) - } else { - self.triggerOnlyTask?.cancel() - self.triggerOnlyTask = nil - self.schedulePreDetectSilenceCheck( - triggers: config.triggers, - gateConfig: gateConfig, - config: config) - } - } - } - - private func maybeLogRecognition( - transcript: String, - segments: [WakeWordSegment], - triggers: [String], - isFinal: Bool, - match: WakeWordGateMatch?, - usedFallback: Bool, - capturing: Bool) - { - guard !transcript.isEmpty else { return } - let level = self.logger.logLevel - guard level == .debug || level == .trace else { return } - if transcript == self.lastLoggedText, !isFinal { - if let last = self.lastLoggedAt, Date().timeIntervalSince(last) < 0.25 { - return - } - } - self.lastLoggedText = transcript - self.lastLoggedAt = Date() - - let textOnly = WakeWordGate.matchesTextOnly(text: transcript, triggers: triggers) - let timingCount = segments.count(where: { $0.start > 0 || $0.duration > 0 }) - let matchSummary = match.map { - "match=true gap=\(String(format: "%.2f", $0.postGap))s cmdLen=\($0.command.count)" - } ?? "match=false" - let segmentSummary = segments.map { seg in - let start = String(format: "%.2f", seg.start) - let end = String(format: "%.2f", seg.end) - return "\(seg.text)@\(start)-\(end)" - }.joined(separator: ", ") - - self.logger.debug( - "voicewake runtime transcript='\(transcript, privacy: .private)' textOnly=\(textOnly) " + - "isFinal=\(isFinal) timing=\(timingCount)/\(segments.count) " + - "capturing=\(capturing) fallback=\(usedFallback) " + - "\(matchSummary) segments=[\(segmentSummary, privacy: .private)]") - } - - private func noteAudioTap(rms: Double) { - let now = Date() - if let last = self.lastTapLogAt, now.timeIntervalSince(last) < 1.0 { - return - } - self.lastTapLogAt = now - let db = 20 * log10(max(rms, 1e-7)) - self.logger.debug( - "voicewake runtime audio tap rms=\(String(format: "%.6f", rms)) " + - "db=\(String(format: "%.1f", db)) capturing=\(self.isCapturing)") - } - - private func noteRecognitionCallback(transcript: String?, isFinal: Bool, error: Error?) { - guard transcript?.isEmpty ?? true else { return } - let now = Date() - if let last = self.lastCallbackLogAt, now.timeIntervalSince(last) < 1.0 { - return - } - self.lastCallbackLogAt = now - let errorSummary = error?.localizedDescription ?? "none" - self.logger.debug( - "voicewake runtime callback empty transcript isFinal=\(isFinal) error=\(errorSummary, privacy: .public)") - } - - private func scheduleTriggerOnlyPauseCheck(triggers: [String], config: RuntimeConfig) { - self.triggerOnlyTask?.cancel() - let lastSeenAt = self.lastTranscriptAt - let lastText = self.lastTranscript - let windowNanos = UInt64(self.triggerPauseWindow * 1_000_000_000) - self.triggerOnlyTask = Task { [weak self, lastSeenAt, lastText] in - try? await Task.sleep(nanoseconds: windowNanos) - guard let self else { return } - await self.triggerOnlyPauseCheck( - lastSeenAt: lastSeenAt, - lastText: lastText, - triggers: triggers, - config: config) - } - } - - private func schedulePreDetectSilenceCheck( - triggers: [String], - gateConfig: WakeWordGateConfig, - config: RuntimeConfig) - { - self.preDetectTask?.cancel() - let lastSeenAt = self.lastTranscriptAt - let lastText = self.lastTranscript - let windowNanos = UInt64(self.preDetectSilenceWindow * 1_000_000_000) - self.preDetectTask = Task { [weak self, lastSeenAt, lastText] in - try? await Task.sleep(nanoseconds: windowNanos) - guard let self else { return } - await self.preDetectSilenceCheck( - lastSeenAt: lastSeenAt, - lastText: lastText, - triggers: triggers, - gateConfig: gateConfig, - config: config) - } - } - - private func triggerOnlyPauseCheck( - lastSeenAt: Date?, - lastText: String?, - triggers: [String], - config: RuntimeConfig) async - { - guard !Task.isCancelled else { return } - guard !self.isCapturing else { return } - guard let lastSeenAt, let lastText else { return } - guard self.lastTranscriptAt == lastSeenAt, self.lastTranscript == lastText else { return } - guard self.isTriggerOnly(transcript: lastText, triggers: triggers) else { return } - if let cooldown = self.cooldownUntil, Date() < cooldown { - return - } - self.logger.info("voicewake runtime detected (trigger-only pause)") - await self.beginCapture(command: "", triggerEndTime: nil, config: config) - } - - private func textOnlyFallbackMatch( - transcript: String, - triggers: [String], - config: WakeWordGateConfig) -> WakeWordGateMatch? - { - guard let command = VoiceWakeTextUtils.textOnlyCommand( - transcript: transcript, - triggers: triggers, - minCommandLength: config.minCommandLength, - trimWake: Self.trimmedAfterTrigger) - else { return nil } - return WakeWordGateMatch(triggerEndTime: 0, postGap: 0, command: command) - } - - private func isTriggerOnly(transcript: String, triggers: [String]) -> Bool { - guard WakeWordGate.matchesTextOnly(text: transcript, triggers: triggers) else { return false } - guard VoiceWakeTextUtils.startsWithTrigger(transcript: transcript, triggers: triggers) else { return false } - return Self.trimmedAfterTrigger(transcript, triggers: triggers).isEmpty - } - - private func preDetectSilenceCheck( - lastSeenAt: Date?, - lastText: String?, - triggers: [String], - gateConfig: WakeWordGateConfig, - config: RuntimeConfig) async - { - guard !Task.isCancelled else { return } - guard !self.isCapturing else { return } - guard let lastSeenAt, let lastText else { return } - guard self.lastTranscriptAt == lastSeenAt, self.lastTranscript == lastText else { return } - guard let match = self.textOnlyFallbackMatch( - transcript: lastText, - triggers: triggers, - config: gateConfig) - else { return } - if let cooldown = self.cooldownUntil, Date() < cooldown { - return - } - self.logger.info("voicewake runtime detected (silence fallback) len=\(match.command.count)") - await self.beginCapture( - command: match.command, - triggerEndTime: match.triggerEndTime, - config: config) - } - - private func beginCapture(command: String, triggerEndTime: TimeInterval?, config: RuntimeConfig) async { - self.listeningState = .voiceWake - self.isCapturing = true - DiagnosticsFileLog.shared.log(category: "voicewake.runtime", event: "beginCapture") - self.capturedTranscript = command - self.committedTranscript = "" - self.volatileTranscript = command - self.captureStartedAt = Date() - self.cooldownUntil = nil - self.heardBeyondTrigger = !command.isEmpty - self.triggerChimePlayed = false - self.activeTriggerEndTime = triggerEndTime - self.preDetectTask?.cancel() - self.preDetectTask = nil - self.triggerOnlyTask?.cancel() - self.triggerOnlyTask = nil - - if config.triggerChime != .none, !self.triggerChimePlayed { - self.triggerChimePlayed = true - await MainActor.run { VoiceWakeChimePlayer.play(config.triggerChime, reason: "voicewake.trigger") } - } - - let snapshot = self.committedTranscript + self.volatileTranscript - let attributed = Self.makeAttributed( - committed: self.committedTranscript, - volatile: self.volatileTranscript, - isFinal: false) - self.overlayToken = await MainActor.run { - VoiceSessionCoordinator.shared.startSession( - source: .wakeWord, - text: snapshot, - attributed: attributed, - forwardEnabled: true) - } - - // Keep the "ears" boosted for the capture window so the status icon animates while recording. - await MainActor.run { AppStateStore.shared.triggerVoiceEars(ttl: nil) } - - self.captureTask?.cancel() - self.captureTask = Task { [weak self] in - guard let self else { return } - await self.monitorCapture(config: config) - } - } - - private func monitorCapture(config: RuntimeConfig) async { - let start = self.captureStartedAt ?? Date() - let hardStop = start.addingTimeInterval(self.captureHardStop) - - while self.isCapturing { - let now = Date() - if now >= hardStop { - // Hard-stop after a maximum duration so we never leave the recognizer pinned open. - await self.finalizeCapture(config: config) - return - } - - let silenceThreshold = self.heardBeyondTrigger ? self.silenceWindow : self.triggerOnlySilenceWindow - if let last = self.lastHeard, now.timeIntervalSince(last) >= silenceThreshold { - await self.finalizeCapture(config: config) - return - } - - try? await Task.sleep(nanoseconds: 200_000_000) - } - } - - private func finalizeCapture(config: RuntimeConfig) async { - guard self.isCapturing else { return } - self.isCapturing = false - // Disarm trigger matching immediately (before halting recognition) to avoid double-trigger - // races from late callbacks that arrive after isCapturing is cleared. - self.cooldownUntil = Date().addingTimeInterval(self.debounceAfterSend) - self.captureTask?.cancel() - self.captureTask = nil - - let finalTranscript = self.capturedTranscript.trimmingCharacters(in: .whitespacesAndNewlines) - DiagnosticsFileLog.shared.log(category: "voicewake.runtime", event: "finalizeCapture", fields: [ - "finalLen": "\(finalTranscript.count)", - ]) - // Stop further recognition events so we don't retrigger immediately with buffered audio. - self.haltRecognitionPipeline() - self.capturedTranscript = "" - self.captureStartedAt = nil - self.lastHeard = nil - self.heardBeyondTrigger = false - self.triggerChimePlayed = false - self.activeTriggerEndTime = nil - self.lastTranscript = nil - self.lastTranscriptAt = nil - self.preDetectTask?.cancel() - self.preDetectTask = nil - self.triggerOnlyTask?.cancel() - self.triggerOnlyTask = nil - - await MainActor.run { AppStateStore.shared.stopVoiceEars() } - if let token = self.overlayToken { - await MainActor.run { VoiceSessionCoordinator.shared.updateLevel(token: token, 0) } - } - - let delay: TimeInterval = 0.0 - let sendChime = finalTranscript.isEmpty ? .none : config.sendChime - if let token = self.overlayToken { - await MainActor.run { - VoiceSessionCoordinator.shared.finalize( - token: token, - text: finalTranscript, - sendChime: sendChime, - autoSendAfter: delay) - } - } else if !finalTranscript.isEmpty { - if sendChime != .none { - await MainActor.run { VoiceWakeChimePlayer.play(sendChime, reason: "voicewake.send") } - } - Task.detached { - await VoiceWakeForwarder.forward(transcript: finalTranscript) - } - } - self.overlayToken = nil - self.scheduleRestartRecognizer() - } - - // MARK: - Audio level handling - - private func noteAudioLevel(rms: Double) { - guard self.isCapturing else { return } - - // Update adaptive noise floor: faster when lower energy (quiet), slower when loud. - let alpha: Double = rms < self.noiseFloorRMS ? 0.08 : 0.01 - self.noiseFloorRMS = max(1e-7, self.noiseFloorRMS + (rms - self.noiseFloorRMS) * alpha) - - let threshold = max(self.minSpeechRMS, self.noiseFloorRMS * self.speechBoostFactor) - if rms >= threshold { - self.lastHeard = Date() - } - - // Normalize against the adaptive threshold so the UI meter stays roughly 0...1 across devices. - let clamped = min(1.0, max(0.0, rms / max(self.minSpeechRMS, threshold))) - if let token = self.overlayToken { - Task { @MainActor in - VoiceSessionCoordinator.shared.updateLevel(token: token, clamped) - } - } - } - - private static func rmsLevel(buffer: AVAudioPCMBuffer) -> Double? { - guard let channelData = buffer.floatChannelData?.pointee else { return nil } - let frameCount = Int(buffer.frameLength) - guard frameCount > 0 else { return nil } - var sum: Double = 0 - for i in 0.. String { - let lower = text.lowercased() - for trigger in triggers { - let token = trigger.lowercased().trimmingCharacters(in: .whitespacesAndNewlines) - guard !token.isEmpty, let range = lower.range(of: token) else { continue } - let after = range.upperBound - let trimmed = text[after...].trimmingCharacters(in: .whitespacesAndNewlines) - return String(trimmed) - } - return text - } - - private static func commandAfterTrigger( - transcript: String, - segments: [WakeWordSegment], - triggerEndTime: TimeInterval?, - triggers: [String]) -> String - { - guard let triggerEndTime else { - return self.trimmedAfterTrigger(transcript, triggers: triggers) - } - let trimmed = WakeWordGate.commandText( - transcript: transcript, - segments: segments, - triggerEndTime: triggerEndTime) - return trimmed.isEmpty ? self.trimmedAfterTrigger(transcript, triggers: triggers) : trimmed - } - - #if DEBUG - static func _testTrimmedAfterTrigger(_ text: String, triggers: [String]) -> String { - self.trimmedAfterTrigger(text, triggers: triggers) - } - - static func _testHasContentAfterTrigger(_ text: String, triggers: [String]) -> Bool { - !self.trimmedAfterTrigger(text, triggers: triggers).isEmpty - } - - static func _testAttributedColor(isFinal: Bool) -> NSColor { - self.makeAttributed(committed: "sample", volatile: "", isFinal: isFinal) - .attribute(.foregroundColor, at: 0, effectiveRange: nil) as? NSColor ?? .clear - } - - #endif - - private static func delta(after committed: String, current: String) -> String { - if current.hasPrefix(committed) { - let start = current.index(current.startIndex, offsetBy: committed.count) - return String(current[start...]) - } - return current - } - - private static func makeAttributed(committed: String, volatile: String, isFinal: Bool) -> NSAttributedString { - let full = NSMutableAttributedString() - let committedAttr: [NSAttributedString.Key: Any] = [ - .foregroundColor: NSColor.labelColor, - .font: NSFont.systemFont(ofSize: 13, weight: .regular), - ] - full.append(NSAttributedString(string: committed, attributes: committedAttr)) - let volatileColor: NSColor = isFinal ? .labelColor : NSColor.tertiaryLabelColor - let volatileAttr: [NSAttributedString.Key: Any] = [ - .foregroundColor: volatileColor, - .font: NSFont.systemFont(ofSize: 13, weight: .regular), - ] - full.append(NSAttributedString(string: volatile, attributes: volatileAttr)) - return full - } -} diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeTester.swift b/apps/macos/Sources/Clawdbot/VoiceWakeTester.swift deleted file mode 100644 index bf6a883ab..000000000 --- a/apps/macos/Sources/Clawdbot/VoiceWakeTester.swift +++ /dev/null @@ -1,473 +0,0 @@ -import AVFoundation -import Foundation -import Speech -import SwabbleKit - -enum VoiceWakeTestState: Equatable { - case idle - case requesting - case listening - case hearing(String) - case finalizing - case detected(String) - case failed(String) -} - -final class VoiceWakeTester { - private let recognizer: SFSpeechRecognizer? - private var audioEngine: AVAudioEngine? - private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest? - private var recognitionTask: SFSpeechRecognitionTask? - private var isStopping = false - private var isFinalizing = false - private var detectionStart: Date? - private var lastHeard: Date? - private var lastLoggedText: String? - private var lastLoggedAt: Date? - private var lastTranscript: String? - private var lastTranscriptAt: Date? - private var silenceTask: Task? - private var currentTriggers: [String] = [] - private var holdingAfterDetect = false - private var detectedText: String? - private let logger = Logger(subsystem: "com.clawdbot", category: "voicewake") - private let silenceWindow: TimeInterval = 1.0 - - init(locale: Locale = .current) { - self.recognizer = SFSpeechRecognizer(locale: locale) - } - - func start( - triggers: [String], - micID: String?, - localeID: String?, - onUpdate: @escaping @Sendable (VoiceWakeTestState) -> Void) async throws - { - guard self.recognitionTask == nil else { return } - self.isStopping = false - self.isFinalizing = false - self.holdingAfterDetect = false - self.detectedText = nil - self.lastHeard = nil - self.lastLoggedText = nil - self.lastLoggedAt = nil - self.lastTranscript = nil - self.lastTranscriptAt = nil - self.silenceTask?.cancel() - self.silenceTask = nil - self.currentTriggers = triggers - let chosenLocale = localeID.flatMap { Locale(identifier: $0) } ?? Locale.current - let recognizer = SFSpeechRecognizer(locale: chosenLocale) - guard let recognizer, recognizer.isAvailable else { - throw NSError( - domain: "VoiceWakeTester", - code: 1, - userInfo: [NSLocalizedDescriptionKey: "Speech recognition unavailable"]) - } - recognizer.defaultTaskHint = .dictation - - guard Self.hasPrivacyStrings else { - throw NSError( - domain: "VoiceWakeTester", - code: 3, - userInfo: [ - NSLocalizedDescriptionKey: """ - Missing mic/speech privacy strings. Rebuild the mac app (scripts/restart-mac.sh) \ - to include usage descriptions. - """, - ]) - } - - let granted = try await Self.ensurePermissions() - guard granted else { - throw NSError( - domain: "VoiceWakeTester", - code: 2, - userInfo: [NSLocalizedDescriptionKey: "Microphone or speech permission denied"]) - } - - self.logInputSelection(preferredMicID: micID) - self.configureSession(preferredMicID: micID) - - let engine = AVAudioEngine() - self.audioEngine = engine - - self.recognitionRequest = SFSpeechAudioBufferRecognitionRequest() - self.recognitionRequest?.shouldReportPartialResults = true - self.recognitionRequest?.taskHint = .dictation - let request = self.recognitionRequest - - let inputNode = engine.inputNode - let format = inputNode.outputFormat(forBus: 0) - guard format.channelCount > 0, format.sampleRate > 0 else { - self.audioEngine = nil - throw NSError( - domain: "VoiceWakeTester", - code: 4, - userInfo: [NSLocalizedDescriptionKey: "No audio input available"]) - } - inputNode.removeTap(onBus: 0) - inputNode.installTap(onBus: 0, bufferSize: 2048, format: format) { [weak request] buffer, _ in - request?.append(buffer) - } - - engine.prepare() - try engine.start() - DispatchQueue.main.async { - onUpdate(.listening) - } - - self.detectionStart = Date() - self.lastHeard = self.detectionStart - - guard let request = recognitionRequest else { return } - - self.recognitionTask = recognizer.recognitionTask(with: request) { [weak self] result, error in - guard let self, !self.isStopping else { return } - let text = result?.bestTranscription.formattedString ?? "" - let segments = result.map { WakeWordSpeechSegments.from( - transcription: $0.bestTranscription, - transcript: text) } ?? [] - let isFinal = result?.isFinal ?? false - let gateConfig = WakeWordGateConfig(triggers: triggers) - var match = WakeWordGate.match(transcript: text, segments: segments, config: gateConfig) - if match == nil, isFinal { - match = self.textOnlyFallbackMatch( - transcript: text, - triggers: triggers, - config: gateConfig) - } - self.maybeLogDebug( - transcript: text, - segments: segments, - triggers: triggers, - match: match, - isFinal: isFinal) - let errorMessage = error?.localizedDescription - - Task { [weak self] in - guard let self, !self.isStopping else { return } - await self.handleResult( - match: match, - text: text, - isFinal: isFinal, - errorMessage: errorMessage, - onUpdate: onUpdate) - } - } - } - - func stop() { - self.stop(force: true) - } - - func finalize(timeout: TimeInterval = 1.5) { - guard self.recognitionTask != nil else { - self.stop(force: true) - return - } - self.isFinalizing = true - self.recognitionRequest?.endAudio() - if let engine = self.audioEngine { - engine.inputNode.removeTap(onBus: 0) - engine.stop() - } - Task { [weak self] in - guard let self else { return } - try? await Task.sleep(nanoseconds: UInt64(timeout * 1_000_000_000)) - if !self.isStopping { - self.stop(force: true) - } - } - } - - private func stop(force: Bool) { - if force { self.isStopping = true } - self.isFinalizing = false - self.recognitionRequest?.endAudio() - self.recognitionTask?.cancel() - self.recognitionTask = nil - self.recognitionRequest = nil - if let engine = self.audioEngine { - engine.inputNode.removeTap(onBus: 0) - engine.stop() - } - self.audioEngine = nil - self.holdingAfterDetect = false - self.detectedText = nil - self.lastHeard = nil - self.detectionStart = nil - self.lastLoggedText = nil - self.lastLoggedAt = nil - self.lastTranscript = nil - self.lastTranscriptAt = nil - self.silenceTask?.cancel() - self.silenceTask = nil - self.currentTriggers = [] - } - - private func handleResult( - match: WakeWordGateMatch?, - text: String, - isFinal: Bool, - errorMessage: String?, - onUpdate: @escaping @Sendable (VoiceWakeTestState) -> Void) async - { - if !text.isEmpty { - self.lastHeard = Date() - self.lastTranscript = text - self.lastTranscriptAt = Date() - } - if self.holdingAfterDetect { - return - } - if let match, !match.command.isEmpty { - self.holdingAfterDetect = true - self.detectedText = match.command - self.logger.info("voice wake detected (test) (len=\(match.command.count))") - await MainActor.run { AppStateStore.shared.triggerVoiceEars(ttl: nil) } - self.stop() - await MainActor.run { - AppStateStore.shared.stopVoiceEars() - onUpdate(.detected(match.command)) - } - return - } - if !isFinal, !text.isEmpty { - self.scheduleSilenceCheck( - triggers: self.currentTriggers, - onUpdate: onUpdate) - } - if self.isFinalizing { - Task { @MainActor in onUpdate(.finalizing) } - } - if let errorMessage { - self.stop(force: true) - Task { @MainActor in onUpdate(.failed(errorMessage)) } - return - } - if isFinal { - self.stop(force: true) - let state: VoiceWakeTestState = text.isEmpty - ? .failed("No speech detected") - : .failed("No trigger heard: “\(text)”") - Task { @MainActor in onUpdate(state) } - } else { - let state: VoiceWakeTestState = text.isEmpty ? .listening : .hearing(text) - Task { @MainActor in onUpdate(state) } - } - } - - private func maybeLogDebug( - transcript: String, - segments: [WakeWordSegment], - triggers: [String], - match: WakeWordGateMatch?, - isFinal: Bool) - { - guard !transcript.isEmpty else { return } - let level = self.logger.logLevel - guard level == .debug || level == .trace else { return } - if transcript == self.lastLoggedText, !isFinal { - if let last = self.lastLoggedAt, Date().timeIntervalSince(last) < 0.25 { - return - } - } - self.lastLoggedText = transcript - self.lastLoggedAt = Date() - - let textOnly = WakeWordGate.matchesTextOnly(text: transcript, triggers: triggers) - let gaps = Self.debugCandidateGaps(triggers: triggers, segments: segments) - let segmentSummary = Self.debugSegments(segments) - let timingCount = segments.count(where: { $0.start > 0 || $0.duration > 0 }) - let matchSummary = match.map { - "match=true gap=\(String(format: "%.2f", $0.postGap))s cmdLen=\($0.command.count)" - } ?? "match=false" - - self.logger.debug( - "voicewake test transcript='\(transcript, privacy: .private)' textOnly=\(textOnly) " + - "isFinal=\(isFinal) timing=\(timingCount)/\(segments.count) " + - "\(matchSummary) gaps=[\(gaps, privacy: .private)] segments=[\(segmentSummary, privacy: .private)]") - } - - private static func debugSegments(_ segments: [WakeWordSegment]) -> String { - segments.map { seg in - let start = String(format: "%.2f", seg.start) - let end = String(format: "%.2f", seg.end) - return "\(seg.text)@\(start)-\(end)" - }.joined(separator: ", ") - } - - private static func debugCandidateGaps(triggers: [String], segments: [WakeWordSegment]) -> String { - let tokens = self.normalizeSegments(segments) - guard !tokens.isEmpty else { return "" } - let triggerTokens = self.normalizeTriggers(triggers) - var gaps: [String] = [] - - for trigger in triggerTokens { - let count = trigger.tokens.count - guard count > 0, tokens.count > count else { continue } - for i in 0...(tokens.count - count - 1) { - let matched = (0.. [DebugTriggerTokens] { - var output: [DebugTriggerTokens] = [] - for trigger in triggers { - let tokens = trigger - .split(whereSeparator: { $0.isWhitespace }) - .map { VoiceWakeTextUtils.normalizeToken(String($0)) } - .filter { !$0.isEmpty } - if tokens.isEmpty { continue } - output.append(DebugTriggerTokens(tokens: tokens)) - } - return output - } - - private static func normalizeSegments(_ segments: [WakeWordSegment]) -> [DebugToken] { - segments.compactMap { segment in - let normalized = VoiceWakeTextUtils.normalizeToken(segment.text) - guard !normalized.isEmpty else { return nil } - return DebugToken( - normalized: normalized, - start: segment.start, - end: segment.end) - } - } - - private func textOnlyFallbackMatch( - transcript: String, - triggers: [String], - config: WakeWordGateConfig) -> WakeWordGateMatch? - { - guard let command = VoiceWakeTextUtils.textOnlyCommand( - transcript: transcript, - triggers: triggers, - minCommandLength: config.minCommandLength, - trimWake: { WakeWordGate.stripWake(text: $0, triggers: $1) }) - else { return nil } - return WakeWordGateMatch(triggerEndTime: 0, postGap: 0, command: command) - } - - private func holdUntilSilence(onUpdate: @escaping @Sendable (VoiceWakeTestState) -> Void) { - Task { [weak self] in - guard let self else { return } - let detectedAt = Date() - let hardStop = detectedAt.addingTimeInterval(6) // cap overall listen after trigger - - while !self.isStopping { - let now = Date() - if now >= hardStop { break } - if let last = self.lastHeard, now.timeIntervalSince(last) >= silenceWindow { - break - } - try? await Task.sleep(nanoseconds: 200_000_000) - } - if !self.isStopping { - self.stop() - await MainActor.run { AppStateStore.shared.stopVoiceEars() } - if let detectedText { - self.logger.info("voice wake hold finished; len=\(detectedText.count)") - Task { @MainActor in onUpdate(.detected(detectedText)) } - } - } - } - } - - private func scheduleSilenceCheck( - triggers: [String], - onUpdate: @escaping @Sendable (VoiceWakeTestState) -> Void) - { - self.silenceTask?.cancel() - let lastSeenAt = self.lastTranscriptAt - let lastText = self.lastTranscript - self.silenceTask = Task { [weak self] in - guard let self else { return } - try? await Task.sleep(nanoseconds: UInt64(self.silenceWindow * 1_000_000_000)) - guard !Task.isCancelled else { return } - guard !self.isStopping, !self.holdingAfterDetect else { return } - guard let lastSeenAt, let lastText else { return } - guard self.lastTranscriptAt == lastSeenAt, self.lastTranscript == lastText else { return } - guard let match = self.textOnlyFallbackMatch( - transcript: lastText, - triggers: triggers, - config: WakeWordGateConfig(triggers: triggers)) else { return } - self.holdingAfterDetect = true - self.detectedText = match.command - self.logger.info("voice wake detected (test, silence) (len=\(match.command.count))") - await MainActor.run { AppStateStore.shared.triggerVoiceEars(ttl: nil) } - self.stop() - await MainActor.run { - AppStateStore.shared.stopVoiceEars() - onUpdate(.detected(match.command)) - } - } - } - - private func configureSession(preferredMicID: String?) { - _ = preferredMicID - } - - private func logInputSelection(preferredMicID: String?) { - let preferred = (preferredMicID?.isEmpty == false) ? preferredMicID! : "system-default" - self.logger.info( - "voicewake test input preferred=\(preferred, privacy: .public) " + - "\(AudioInputDeviceObserver.defaultInputDeviceSummary(), privacy: .public)") - } - - private nonisolated static func ensurePermissions() async throws -> Bool { - let speechStatus = SFSpeechRecognizer.authorizationStatus() - if speechStatus == .notDetermined { - let granted = await withCheckedContinuation { continuation in - SFSpeechRecognizer.requestAuthorization { status in - continuation.resume(returning: status == .authorized) - } - } - guard granted else { return false } - } else if speechStatus != .authorized { - return false - } - - let micStatus = AVCaptureDevice.authorizationStatus(for: .audio) - switch micStatus { - case .authorized: return true - - case .notDetermined: - return await withCheckedContinuation { continuation in - AVCaptureDevice.requestAccess(for: .audio) { granted in - continuation.resume(returning: granted) - } - } - - default: - return false - } - } - - private static var hasPrivacyStrings: Bool { - let speech = Bundle.main.object(forInfoDictionaryKey: "NSSpeechRecognitionUsageDescription") as? String - let mic = Bundle.main.object(forInfoDictionaryKey: "NSMicrophoneUsageDescription") as? String - return speech?.isEmpty == false && mic?.isEmpty == false - } -} - -extension VoiceWakeTester: @unchecked Sendable {} diff --git a/apps/macos/Sources/Clawdbot/WebChatSwiftUI.swift b/apps/macos/Sources/Clawdbot/WebChatSwiftUI.swift deleted file mode 100644 index 18d3c46c8..000000000 --- a/apps/macos/Sources/Clawdbot/WebChatSwiftUI.swift +++ /dev/null @@ -1,374 +0,0 @@ -import AppKit -import MoltbotChatUI -import MoltbotKit -import MoltbotProtocol -import Foundation -import OSLog -import QuartzCore -import SwiftUI - -private let webChatSwiftLogger = Logger(subsystem: "com.clawdbot", category: "WebChatSwiftUI") - -private enum WebChatSwiftUILayout { - static let windowSize = NSSize(width: 500, height: 840) - static let panelSize = NSSize(width: 480, height: 640) - static let windowMinSize = NSSize(width: 480, height: 360) - static let anchorPadding: CGFloat = 8 -} - -struct MacGatewayChatTransport: MoltbotChatTransport, Sendable { - func requestHistory(sessionKey: String) async throws -> MoltbotChatHistoryPayload { - try await GatewayConnection.shared.chatHistory(sessionKey: sessionKey) - } - - func abortRun(sessionKey: String, runId: String) async throws { - _ = try await GatewayConnection.shared.request( - method: "chat.abort", - params: [ - "sessionKey": AnyCodable(sessionKey), - "runId": AnyCodable(runId), - ], - timeoutMs: 10000) - } - - func listSessions(limit: Int?) async throws -> MoltbotChatSessionsListResponse { - var params: [String: AnyCodable] = [ - "includeGlobal": AnyCodable(true), - "includeUnknown": AnyCodable(false), - ] - if let limit { - params["limit"] = AnyCodable(limit) - } - let data = try await GatewayConnection.shared.request( - method: "sessions.list", - params: params, - timeoutMs: 15000) - return try JSONDecoder().decode(MoltbotChatSessionsListResponse.self, from: data) - } - - func sendMessage( - sessionKey: String, - message: String, - thinking: String, - idempotencyKey: String, - attachments: [MoltbotChatAttachmentPayload]) async throws -> MoltbotChatSendResponse - { - try await GatewayConnection.shared.chatSend( - sessionKey: sessionKey, - message: message, - thinking: thinking, - idempotencyKey: idempotencyKey, - attachments: attachments) - } - - func requestHealth(timeoutMs: Int) async throws -> Bool { - try await GatewayConnection.shared.healthOK(timeoutMs: timeoutMs) - } - - func events() -> AsyncStream { - AsyncStream { continuation in - let task = Task { - do { - try await GatewayConnection.shared.refresh() - } catch { - webChatSwiftLogger.error("gateway refresh failed \(error.localizedDescription, privacy: .public)") - } - - let stream = await GatewayConnection.shared.subscribe() - for await push in stream { - if Task.isCancelled { return } - if let evt = Self.mapPushToTransportEvent(push) { - continuation.yield(evt) - } - } - } - - continuation.onTermination = { @Sendable _ in - task.cancel() - } - } - } - - static func mapPushToTransportEvent(_ push: GatewayPush) -> MoltbotChatTransportEvent? { - switch push { - case let .snapshot(hello): - let ok = (try? JSONDecoder().decode( - MoltbotGatewayHealthOK.self, - from: JSONEncoder().encode(hello.snapshot.health)))?.ok ?? true - return .health(ok: ok) - - case let .event(evt): - switch evt.event { - case "health": - guard let payload = evt.payload else { return nil } - let ok = (try? JSONDecoder().decode( - MoltbotGatewayHealthOK.self, - from: JSONEncoder().encode(payload)))?.ok ?? true - return .health(ok: ok) - case "tick": - return .tick - case "chat": - guard let payload = evt.payload else { return nil } - guard let chat = try? JSONDecoder().decode( - MoltbotChatEventPayload.self, - from: JSONEncoder().encode(payload)) - else { - return nil - } - return .chat(chat) - case "agent": - guard let payload = evt.payload else { return nil } - guard let agent = try? JSONDecoder().decode( - MoltbotAgentEventPayload.self, - from: JSONEncoder().encode(payload)) - else { - return nil - } - return .agent(agent) - default: - return nil - } - - case .seqGap: - return .seqGap - } - } -} - -// MARK: - Window controller - -@MainActor -final class WebChatSwiftUIWindowController { - private let presentation: WebChatPresentation - private let sessionKey: String - private let hosting: NSHostingController - private let contentController: NSViewController - private var window: NSWindow? - private var dismissMonitor: Any? - var onClosed: (() -> Void)? - var onVisibilityChanged: ((Bool) -> Void)? - - convenience init(sessionKey: String, presentation: WebChatPresentation) { - self.init(sessionKey: sessionKey, presentation: presentation, transport: MacGatewayChatTransport()) - } - - init(sessionKey: String, presentation: WebChatPresentation, transport: any MoltbotChatTransport) { - self.sessionKey = sessionKey - self.presentation = presentation - let vm = MoltbotChatViewModel(sessionKey: sessionKey, transport: transport) - let accent = Self.color(fromHex: AppStateStore.shared.seamColorHex) - self.hosting = NSHostingController(rootView: MoltbotChatView( - viewModel: vm, - showsSessionSwitcher: true, - userAccent: accent)) - self.contentController = Self.makeContentController(for: presentation, hosting: self.hosting) - self.window = Self.makeWindow(for: presentation, contentViewController: self.contentController) - } - - deinit {} - - var isVisible: Bool { - self.window?.isVisible ?? false - } - - func show() { - guard let window else { return } - self.ensureWindowSize() - window.makeKeyAndOrderFront(nil) - NSApp.activate(ignoringOtherApps: true) - self.onVisibilityChanged?(true) - } - - func presentAnchored(anchorProvider: () -> NSRect?) { - guard case .panel = self.presentation, let window else { return } - self.installDismissMonitor() - let target = self.reposition(using: anchorProvider) - - if !self.isVisible { - let start = target.offsetBy(dx: 0, dy: 8) - window.setFrame(start, display: true) - window.alphaValue = 0 - window.makeKeyAndOrderFront(nil) - NSApp.activate(ignoringOtherApps: true) - NSAnimationContext.runAnimationGroup { context in - context.duration = 0.18 - context.timingFunction = CAMediaTimingFunction(name: .easeOut) - window.animator().setFrame(target, display: true) - window.animator().alphaValue = 1 - } - } else { - window.makeKeyAndOrderFront(nil) - NSApp.activate(ignoringOtherApps: true) - } - - self.onVisibilityChanged?(true) - } - - func close() { - self.window?.orderOut(nil) - self.onVisibilityChanged?(false) - self.onClosed?() - self.removeDismissMonitor() - } - - @discardableResult - private func reposition(using anchorProvider: () -> NSRect?) -> NSRect { - guard let window else { return .zero } - guard let anchor = anchorProvider() else { - let frame = WindowPlacement.topRightFrame( - size: WebChatSwiftUILayout.panelSize, - padding: WebChatSwiftUILayout.anchorPadding) - window.setFrame(frame, display: false) - return frame - } - let screen = NSScreen.screens.first { screen in - screen.frame.contains(anchor.origin) || screen.frame.contains(NSPoint(x: anchor.midX, y: anchor.midY)) - } ?? NSScreen.main - let bounds = (screen?.visibleFrame ?? .zero).insetBy( - dx: WebChatSwiftUILayout.anchorPadding, - dy: WebChatSwiftUILayout.anchorPadding) - let frame = WindowPlacement.anchoredBelowFrame( - size: WebChatSwiftUILayout.panelSize, - anchor: anchor, - padding: WebChatSwiftUILayout.anchorPadding, - in: bounds) - window.setFrame(frame, display: false) - return frame - } - - private func installDismissMonitor() { - if ProcessInfo.processInfo.isRunningTests { return } - guard self.dismissMonitor == nil, self.window != nil else { return } - self.dismissMonitor = NSEvent.addGlobalMonitorForEvents( - matching: [.leftMouseDown, .rightMouseDown, .otherMouseDown]) - { [weak self] _ in - guard let self, let win = self.window else { return } - let pt = NSEvent.mouseLocation - if !win.frame.contains(pt) { - self.close() - } - } - } - - private func removeDismissMonitor() { - if let monitor = self.dismissMonitor { - NSEvent.removeMonitor(monitor) - self.dismissMonitor = nil - } - } - - private static func makeWindow( - for presentation: WebChatPresentation, - contentViewController: NSViewController) -> NSWindow - { - switch presentation { - case .window: - let window = NSWindow( - contentRect: NSRect(origin: .zero, size: WebChatSwiftUILayout.windowSize), - styleMask: [.titled, .closable, .resizable, .miniaturizable], - backing: .buffered, - defer: false) - window.title = "Moltbot Chat" - window.contentViewController = contentViewController - window.isReleasedWhenClosed = false - window.titleVisibility = .visible - window.titlebarAppearsTransparent = false - window.backgroundColor = .clear - window.isOpaque = false - window.center() - WindowPlacement.ensureOnScreen(window: window, defaultSize: WebChatSwiftUILayout.windowSize) - window.minSize = WebChatSwiftUILayout.windowMinSize - window.contentView?.wantsLayer = true - window.contentView?.layer?.backgroundColor = NSColor.clear.cgColor - return window - case .panel: - let panel = WebChatPanel( - contentRect: NSRect(origin: .zero, size: WebChatSwiftUILayout.panelSize), - styleMask: [.borderless], - backing: .buffered, - defer: false) - panel.level = .statusBar - panel.hidesOnDeactivate = true - panel.hasShadow = true - panel.isMovable = false - panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary] - panel.titleVisibility = .hidden - panel.titlebarAppearsTransparent = true - panel.backgroundColor = .clear - panel.isOpaque = false - panel.contentViewController = contentViewController - panel.becomesKeyOnlyIfNeeded = true - panel.contentView?.wantsLayer = true - panel.contentView?.layer?.backgroundColor = NSColor.clear.cgColor - panel.setFrame( - WindowPlacement.topRightFrame( - size: WebChatSwiftUILayout.panelSize, - padding: WebChatSwiftUILayout.anchorPadding), - display: false) - return panel - } - } - - private static func makeContentController( - for presentation: WebChatPresentation, - hosting: NSHostingController) -> NSViewController - { - let controller = NSViewController() - let effectView = NSVisualEffectView() - effectView.material = .sidebar - effectView.blendingMode = .behindWindow - effectView.state = .active - effectView.wantsLayer = true - effectView.layer?.cornerCurve = .continuous - let cornerRadius: CGFloat = switch presentation { - case .panel: - 16 - case .window: - 0 - } - effectView.layer?.cornerRadius = cornerRadius - effectView.layer?.masksToBounds = true - - effectView.translatesAutoresizingMaskIntoConstraints = true - effectView.autoresizingMask = [.width, .height] - let rootView = effectView - - hosting.view.translatesAutoresizingMaskIntoConstraints = false - hosting.view.wantsLayer = true - hosting.view.layer?.backgroundColor = NSColor.clear.cgColor - - controller.addChild(hosting) - effectView.addSubview(hosting.view) - controller.view = rootView - - NSLayoutConstraint.activate([ - hosting.view.leadingAnchor.constraint(equalTo: effectView.leadingAnchor), - hosting.view.trailingAnchor.constraint(equalTo: effectView.trailingAnchor), - hosting.view.topAnchor.constraint(equalTo: effectView.topAnchor), - hosting.view.bottomAnchor.constraint(equalTo: effectView.bottomAnchor), - ]) - - return controller - } - - private func ensureWindowSize() { - guard case .window = self.presentation, let window else { return } - let current = window.frame.size - let min = WebChatSwiftUILayout.windowMinSize - if current.width < min.width || current.height < min.height { - let frame = WindowPlacement.centeredFrame(size: WebChatSwiftUILayout.windowSize) - window.setFrame(frame, display: false) - } - } - - private static func color(fromHex raw: String?) -> Color? { - let trimmed = (raw ?? "").trimmingCharacters(in: .whitespacesAndNewlines) - guard !trimmed.isEmpty else { return nil } - let hex = trimmed.hasPrefix("#") ? String(trimmed.dropFirst()) : trimmed - guard hex.count == 6, let value = Int(hex, radix: 16) else { return nil } - let r = Double((value >> 16) & 0xFF) / 255.0 - let g = Double((value >> 8) & 0xFF) / 255.0 - let b = Double(value & 0xFF) / 255.0 - return Color(red: r, green: g, blue: b) - } -} diff --git a/apps/macos/Sources/ClawdbotDiscovery/GatewayDiscoveryModel.swift b/apps/macos/Sources/ClawdbotDiscovery/GatewayDiscoveryModel.swift deleted file mode 100644 index 6ce854c74..000000000 --- a/apps/macos/Sources/ClawdbotDiscovery/GatewayDiscoveryModel.swift +++ /dev/null @@ -1,683 +0,0 @@ -import MoltbotKit -import Foundation -import Network -import Observation -import OSLog - -@MainActor -@Observable -public final class GatewayDiscoveryModel { - public struct LocalIdentity: Equatable, Sendable { - public var hostTokens: Set - public var displayTokens: Set - - public init(hostTokens: Set, displayTokens: Set) { - self.hostTokens = hostTokens - self.displayTokens = displayTokens - } - } - - public struct DiscoveredGateway: Identifiable, Equatable, Sendable { - public var id: String { self.stableID } - public var displayName: String - public var lanHost: String? - public var tailnetDns: String? - public var sshPort: Int - public var gatewayPort: Int? - public var cliPath: String? - public var stableID: String - public var debugID: String - public var isLocal: Bool - - public init( - displayName: String, - lanHost: String? = nil, - tailnetDns: String? = nil, - sshPort: Int, - gatewayPort: Int? = nil, - cliPath: String? = nil, - stableID: String, - debugID: String, - isLocal: Bool) - { - self.displayName = displayName - self.lanHost = lanHost - self.tailnetDns = tailnetDns - self.sshPort = sshPort - self.gatewayPort = gatewayPort - self.cliPath = cliPath - self.stableID = stableID - self.debugID = debugID - self.isLocal = isLocal - } - } - - public var gateways: [DiscoveredGateway] = [] - public var statusText: String = "Idle" - - private var browsers: [String: NWBrowser] = [:] - private var resultsByDomain: [String: Set] = [:] - private var gatewaysByDomain: [String: [DiscoveredGateway]] = [:] - private var statesByDomain: [String: NWBrowser.State] = [:] - private var localIdentity: LocalIdentity - private let localDisplayName: String? - private let filterLocalGateways: Bool - private var resolvedTXTByID: [String: [String: String]] = [:] - private var pendingTXTResolvers: [String: GatewayTXTResolver] = [:] - private var wideAreaFallbackTask: Task? - private var wideAreaFallbackGateways: [DiscoveredGateway] = [] - private let logger = Logger(subsystem: "com.clawdbot", category: "gateway-discovery") - - public init( - localDisplayName: String? = nil, - filterLocalGateways: Bool = true) - { - self.localDisplayName = localDisplayName - self.filterLocalGateways = filterLocalGateways - self.localIdentity = Self.buildLocalIdentityFast(displayName: localDisplayName) - self.refreshLocalIdentity() - } - - public func start() { - if !self.browsers.isEmpty { return } - - for domain in MoltbotBonjour.gatewayServiceDomains { - let params = NWParameters.tcp - params.includePeerToPeer = true - let browser = NWBrowser( - for: .bonjour(type: MoltbotBonjour.gatewayServiceType, domain: domain), - using: params) - - browser.stateUpdateHandler = { [weak self] state in - Task { @MainActor in - guard let self else { return } - self.statesByDomain[domain] = state - self.updateStatusText() - } - } - - browser.browseResultsChangedHandler = { [weak self] results, _ in - Task { @MainActor in - guard let self else { return } - self.resultsByDomain[domain] = results - self.updateGateways(for: domain) - self.recomputeGateways() - } - } - - self.browsers[domain] = browser - browser.start(queue: DispatchQueue(label: "com.clawdbot.macos.gateway-discovery.\(domain)")) - } - - self.scheduleWideAreaFallback() - } - - public func refreshWideAreaFallbackNow(timeoutSeconds: TimeInterval = 5.0) { - let domain = MoltbotBonjour.wideAreaGatewayServiceDomain - Task.detached(priority: .utility) { [weak self] in - guard let self else { return } - let beacons = WideAreaGatewayDiscovery.discover(timeoutSeconds: timeoutSeconds) - await MainActor.run { [weak self] in - guard let self else { return } - self.wideAreaFallbackGateways = self.mapWideAreaBeacons(beacons, domain: domain) - self.recomputeGateways() - } - } - } - - public func stop() { - for browser in self.browsers.values { - browser.cancel() - } - self.browsers = [:] - self.resultsByDomain = [:] - self.gatewaysByDomain = [:] - self.statesByDomain = [:] - self.resolvedTXTByID = [:] - self.pendingTXTResolvers.values.forEach { $0.cancel() } - self.pendingTXTResolvers = [:] - self.wideAreaFallbackTask?.cancel() - self.wideAreaFallbackTask = nil - self.wideAreaFallbackGateways = [] - self.gateways = [] - self.statusText = "Stopped" - } - - private func mapWideAreaBeacons(_ beacons: [WideAreaGatewayBeacon], domain: String) -> [DiscoveredGateway] { - beacons.map { beacon in - let stableID = "wide-area|\(domain)|\(beacon.instanceName)" - let isLocal = Self.isLocalGateway( - lanHost: beacon.lanHost, - tailnetDns: beacon.tailnetDns, - displayName: beacon.displayName, - serviceName: beacon.instanceName, - local: self.localIdentity) - return DiscoveredGateway( - displayName: beacon.displayName, - lanHost: beacon.lanHost, - tailnetDns: beacon.tailnetDns, - sshPort: beacon.sshPort ?? 22, - gatewayPort: beacon.gatewayPort, - cliPath: beacon.cliPath, - stableID: stableID, - debugID: "\(beacon.instanceName)@\(beacon.host):\(beacon.port)", - isLocal: isLocal) - } - } - - private func recomputeGateways() { - let primary = self.sortedDeduped(gateways: self.gatewaysByDomain.values.flatMap(\.self)) - let primaryFiltered = self.filterLocalGateways ? primary.filter { !$0.isLocal } : primary - if !primaryFiltered.isEmpty { - self.gateways = primaryFiltered - return - } - - // Bonjour can return only "local" results for the wide-area domain (or no results at all), - // which makes onboarding look empty even though Tailscale DNS-SD can already see gateways. - guard !self.wideAreaFallbackGateways.isEmpty else { - self.gateways = primaryFiltered - return - } - - let combined = self.sortedDeduped(gateways: primary + self.wideAreaFallbackGateways) - self.gateways = self.filterLocalGateways ? combined.filter { !$0.isLocal } : combined - } - - private func updateGateways(for domain: String) { - guard let results = self.resultsByDomain[domain] else { - self.gatewaysByDomain[domain] = [] - return - } - - self.gatewaysByDomain[domain] = results.compactMap { result -> DiscoveredGateway? in - guard case let .service(name, type, resultDomain, _) = result.endpoint else { return nil } - - let decodedName = BonjourEscapes.decode(name) - let stableID = GatewayEndpointID.stableID(result.endpoint) - let resolvedTXT = self.resolvedTXTByID[stableID] ?? [:] - let txt = Self.txtDictionary(from: result).merging( - resolvedTXT, - uniquingKeysWith: { _, new in new }) - - let advertisedName = txt["displayName"] - .map(Self.prettifyInstanceName) - .flatMap { $0.isEmpty ? nil : $0 } - let prettyName = - advertisedName ?? Self.prettifyServiceName(decodedName) - - let parsedTXT = Self.parseGatewayTXT(txt) - - if parsedTXT.lanHost == nil || parsedTXT.tailnetDns == nil { - self.ensureTXTResolution( - stableID: stableID, - serviceName: name, - type: type, - domain: resultDomain) - } - - let isLocal = Self.isLocalGateway( - lanHost: parsedTXT.lanHost, - tailnetDns: parsedTXT.tailnetDns, - displayName: prettyName, - serviceName: decodedName, - local: self.localIdentity) - return DiscoveredGateway( - displayName: prettyName, - lanHost: parsedTXT.lanHost, - tailnetDns: parsedTXT.tailnetDns, - sshPort: parsedTXT.sshPort, - gatewayPort: parsedTXT.gatewayPort, - cliPath: parsedTXT.cliPath, - stableID: stableID, - debugID: GatewayEndpointID.prettyDescription(result.endpoint), - isLocal: isLocal) - } - .sorted { $0.displayName.localizedCaseInsensitiveCompare($1.displayName) == .orderedAscending } - - if domain == MoltbotBonjour.wideAreaGatewayServiceDomain, - self.hasUsableWideAreaResults - { - self.wideAreaFallbackGateways = [] - } - } - - private func scheduleWideAreaFallback() { - let domain = MoltbotBonjour.wideAreaGatewayServiceDomain - if Self.isRunningTests { return } - guard self.wideAreaFallbackTask == nil else { return } - self.wideAreaFallbackTask = Task.detached(priority: .utility) { [weak self] in - guard let self else { return } - var attempt = 0 - let startedAt = Date() - while !Task.isCancelled, Date().timeIntervalSince(startedAt) < 35.0 { - let hasResults = await MainActor.run { - self.hasUsableWideAreaResults - } - if hasResults { return } - - // Wide-area discovery can be racy (Tailscale not yet up, DNS zone not - // published yet). Retry with a short backoff while onboarding is open. - let beacons = WideAreaGatewayDiscovery.discover(timeoutSeconds: 2.0) - if !beacons.isEmpty { - await MainActor.run { [weak self] in - guard let self else { return } - self.wideAreaFallbackGateways = self.mapWideAreaBeacons(beacons, domain: domain) - self.recomputeGateways() - } - return - } - - attempt += 1 - let backoff = min(8.0, 0.6 + (Double(attempt) * 0.7)) - try? await Task.sleep(nanoseconds: UInt64(backoff * 1_000_000_000)) - } - } - } - - private var hasUsableWideAreaResults: Bool { - let domain = MoltbotBonjour.wideAreaGatewayServiceDomain - guard let gateways = self.gatewaysByDomain[domain], !gateways.isEmpty else { return false } - if !self.filterLocalGateways { return true } - return gateways.contains(where: { !$0.isLocal }) - } - - private func sortedDeduped(gateways: [DiscoveredGateway]) -> [DiscoveredGateway] { - var seen = Set() - let deduped = gateways.filter { gateway in - if seen.contains(gateway.stableID) { return false } - seen.insert(gateway.stableID) - return true - } - return deduped.sorted { - $0.displayName.localizedCaseInsensitiveCompare($1.displayName) == .orderedAscending - } - } - - private nonisolated static var isRunningTests: Bool { - // Keep discovery background work from running forever during SwiftPM test runs. - if Bundle.allBundles.contains(where: { $0.bundleURL.pathExtension == "xctest" }) { return true } - - let env = ProcessInfo.processInfo.environment - return env["XCTestConfigurationFilePath"] != nil - || env["XCTestBundlePath"] != nil - || env["XCTestSessionIdentifier"] != nil - } - - private func updateGatewaysForAllDomains() { - for domain in self.resultsByDomain.keys { - self.updateGateways(for: domain) - } - } - - private func updateStatusText() { - let states = Array(self.statesByDomain.values) - if states.isEmpty { - self.statusText = self.browsers.isEmpty ? "Idle" : "Setup" - return - } - - if let failed = states.first(where: { state in - if case .failed = state { return true } - return false - }) { - if case let .failed(err) = failed { - self.statusText = "Failed: \(err)" - return - } - } - - if let waiting = states.first(where: { state in - if case .waiting = state { return true } - return false - }) { - if case let .waiting(err) = waiting { - self.statusText = "Waiting: \(err)" - return - } - } - - if states.contains(where: { if case .ready = $0 { true } else { false } }) { - self.statusText = "Searching…" - return - } - - if states.contains(where: { if case .setup = $0 { true } else { false } }) { - self.statusText = "Setup" - return - } - - self.statusText = "Searching…" - } - - private static func txtDictionary(from result: NWBrowser.Result) -> [String: String] { - var merged: [String: String] = [:] - - if case let .bonjour(txt) = result.metadata { - merged.merge(txt.dictionary, uniquingKeysWith: { _, new in new }) - } - - if let endpointTxt = result.endpoint.txtRecord?.dictionary { - merged.merge(endpointTxt, uniquingKeysWith: { _, new in new }) - } - - return merged - } - - public struct GatewayTXT: Equatable { - public var lanHost: String? - public var tailnetDns: String? - public var sshPort: Int - public var gatewayPort: Int? - public var cliPath: String? - } - - public static func parseGatewayTXT(_ txt: [String: String]) -> GatewayTXT { - var lanHost: String? - var tailnetDns: String? - var sshPort = 22 - var gatewayPort: Int? - var cliPath: String? - - if let value = txt["lanHost"] { - let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines) - lanHost = trimmed.isEmpty ? nil : trimmed - } - if let value = txt["tailnetDns"] { - let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines) - tailnetDns = trimmed.isEmpty ? nil : trimmed - } - if let value = txt["sshPort"], - let parsed = Int(value.trimmingCharacters(in: .whitespacesAndNewlines)), - parsed > 0 - { - sshPort = parsed - } - if let value = txt["gatewayPort"], - let parsed = Int(value.trimmingCharacters(in: .whitespacesAndNewlines)), - parsed > 0 - { - gatewayPort = parsed - } - if let value = txt["cliPath"] { - let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines) - cliPath = trimmed.isEmpty ? nil : trimmed - } - - return GatewayTXT( - lanHost: lanHost, - tailnetDns: tailnetDns, - sshPort: sshPort, - gatewayPort: gatewayPort, - cliPath: cliPath) - } - - public static func buildSSHTarget(user: String, host: String, port: Int) -> String { - var target = "\(user)@\(host)" - if port != 22 { - target += ":\(port)" - } - return target - } - - private func ensureTXTResolution( - stableID: String, - serviceName: String, - type: String, - domain: String) - { - guard self.resolvedTXTByID[stableID] == nil else { return } - guard self.pendingTXTResolvers[stableID] == nil else { return } - - let resolver = GatewayTXTResolver( - name: serviceName, - type: type, - domain: domain, - logger: self.logger) - { [weak self] result in - Task { @MainActor in - guard let self else { return } - self.pendingTXTResolvers[stableID] = nil - switch result { - case let .success(txt): - self.resolvedTXTByID[stableID] = txt - self.updateGatewaysForAllDomains() - self.recomputeGateways() - case .failure: - break - } - } - } - - self.pendingTXTResolvers[stableID] = resolver - resolver.start() - } - - private nonisolated static func prettifyInstanceName(_ decodedName: String) -> String { - let normalized = decodedName.split(whereSeparator: \.isWhitespace).joined(separator: " ") - let stripped = normalized.replacingOccurrences(of: " (Moltbot)", with: "") - .replacingOccurrences(of: #"\s+\(\d+\)$"#, with: "", options: .regularExpression) - return stripped.trimmingCharacters(in: .whitespacesAndNewlines) - } - - private nonisolated static func prettifyServiceName(_ decodedName: String) -> String { - let normalized = Self.prettifyInstanceName(decodedName) - var cleaned = normalized.replacingOccurrences(of: #"\s*-?gateway$"#, with: "", options: .regularExpression) - cleaned = cleaned - .replacingOccurrences(of: "_", with: " ") - .replacingOccurrences(of: "-", with: " ") - .replacingOccurrences(of: #"\s+"#, with: " ", options: .regularExpression) - .trimmingCharacters(in: .whitespacesAndNewlines) - if cleaned.isEmpty { - cleaned = normalized - } - let words = cleaned.split(separator: " ") - let titled = words.map { word -> String in - let lower = word.lowercased() - guard let first = lower.first else { return "" } - return String(first).uppercased() + lower.dropFirst() - }.joined(separator: " ") - return titled.isEmpty ? normalized : titled - } - - public nonisolated static func isLocalGateway( - lanHost: String?, - tailnetDns: String?, - displayName: String?, - serviceName: String?, - local: LocalIdentity) -> Bool - { - if let host = normalizeHostToken(lanHost), - local.hostTokens.contains(host) - { - return true - } - if let host = normalizeHostToken(tailnetDns), - local.hostTokens.contains(host) - { - return true - } - if let name = normalizeDisplayToken(displayName), - local.displayTokens.contains(name) - { - return true - } - if let serviceHost = normalizeServiceHostToken(serviceName), - local.hostTokens.contains(serviceHost) - { - return true - } - return false - } - - private func refreshLocalIdentity() { - let fastIdentity = self.localIdentity - let displayName = self.localDisplayName - Task.detached(priority: .utility) { - let slowIdentity = Self.buildLocalIdentitySlow(displayName: displayName) - let merged = Self.mergeLocalIdentity(fast: fastIdentity, slow: slowIdentity) - await MainActor.run { [weak self] in - guard let self else { return } - guard self.localIdentity != merged else { return } - self.localIdentity = merged - self.recomputeGateways() - } - } - } - - private nonisolated static func mergeLocalIdentity( - fast: LocalIdentity, - slow: LocalIdentity) -> LocalIdentity - { - LocalIdentity( - hostTokens: fast.hostTokens.union(slow.hostTokens), - displayTokens: fast.displayTokens.union(slow.displayTokens)) - } - - private nonisolated static func buildLocalIdentityFast(displayName: String?) -> LocalIdentity { - var hostTokens: Set = [] - var displayTokens: Set = [] - - let hostName = ProcessInfo.processInfo.hostName - if let token = normalizeHostToken(hostName) { - hostTokens.insert(token) - } - - if let token = normalizeDisplayToken(displayName) { - displayTokens.insert(token) - } - - return LocalIdentity(hostTokens: hostTokens, displayTokens: displayTokens) - } - - private nonisolated static func buildLocalIdentitySlow(displayName: String?) -> LocalIdentity { - var hostTokens: Set = [] - var displayTokens: Set = [] - - if let host = Host.current().name, - let token = normalizeHostToken(host) - { - hostTokens.insert(token) - } - - if let token = normalizeDisplayToken(displayName) { - displayTokens.insert(token) - } - - if let token = normalizeDisplayToken(Host.current().localizedName) { - displayTokens.insert(token) - } - - return LocalIdentity(hostTokens: hostTokens, displayTokens: displayTokens) - } - - private nonisolated static func normalizeHostToken(_ raw: String?) -> String? { - guard let raw else { return nil } - let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) - if trimmed.isEmpty { return nil } - let lower = trimmed.lowercased() - let strippedTrailingDot = lower.hasSuffix(".") - ? String(lower.dropLast()) - : lower - let withoutLocal = strippedTrailingDot.hasSuffix(".local") - ? String(strippedTrailingDot.dropLast(6)) - : strippedTrailingDot - let firstLabel = withoutLocal.split(separator: ".").first.map(String.init) - let token = (firstLabel ?? withoutLocal).trimmingCharacters(in: .whitespacesAndNewlines) - return token.isEmpty ? nil : token - } - - private nonisolated static func normalizeDisplayToken(_ raw: String?) -> String? { - guard let raw else { return nil } - let prettified = Self.prettifyInstanceName(raw) - let trimmed = prettified.trimmingCharacters(in: .whitespacesAndNewlines) - if trimmed.isEmpty { return nil } - return trimmed.lowercased() - } - - private nonisolated static func normalizeServiceHostToken(_ raw: String?) -> String? { - guard let raw else { return nil } - let prettified = Self.prettifyInstanceName(raw) - let strippedGateway = prettified.replacingOccurrences( - of: #"\s*-?\s*gateway$"#, - with: "", - options: .regularExpression) - return self.normalizeHostToken(strippedGateway) - } -} - -final class GatewayTXTResolver: NSObject, NetServiceDelegate { - private let service: NetService - private let completion: (Result<[String: String], Error>) -> Void - private let logger: Logger - private var didFinish = false - - init( - name: String, - type: String, - domain: String, - logger: Logger, - completion: @escaping (Result<[String: String], Error>) -> Void) - { - self.service = NetService(domain: domain, type: type, name: name) - self.completion = completion - self.logger = logger - super.init() - self.service.delegate = self - } - - func start(timeout: TimeInterval = 2.0) { - self.service.schedule(in: .main, forMode: .common) - self.service.resolve(withTimeout: timeout) - } - - func cancel() { - self.finish(result: .failure(GatewayTXTResolverError.cancelled)) - } - - func netServiceDidResolveAddress(_ sender: NetService) { - let txt = Self.decodeTXT(sender.txtRecordData()) - if !txt.isEmpty { - let payload = self.formatTXT(txt) - self.logger.debug( - "discovery: resolved TXT for \(sender.name, privacy: .public): \(payload, privacy: .public)") - } - self.finish(result: .success(txt)) - } - - func netService(_ sender: NetService, didNotResolve errorDict: [String: NSNumber]) { - self.finish(result: .failure(GatewayTXTResolverError.resolveFailed(errorDict))) - } - - private func finish(result: Result<[String: String], Error>) { - guard !self.didFinish else { return } - self.didFinish = true - self.service.stop() - self.service.remove(from: .main, forMode: .common) - self.completion(result) - } - - private static func decodeTXT(_ data: Data?) -> [String: String] { - guard let data else { return [:] } - let dict = NetService.dictionary(fromTXTRecord: data) - var out: [String: String] = [:] - out.reserveCapacity(dict.count) - for (key, value) in dict { - if let str = String(data: value, encoding: .utf8) { - out[key] = str - } - } - return out - } - - private func formatTXT(_ txt: [String: String]) -> String { - txt.sorted(by: { $0.key < $1.key }) - .map { "\($0.key)=\($0.value)" } - .joined(separator: " ") - } -} - -enum GatewayTXTResolverError: Error { - case cancelled - case resolveFailed([String: NSNumber]) -} diff --git a/apps/macos/Sources/Clawdbot/AboutSettings.swift b/apps/macos/Sources/Moltbot/AboutSettings.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/AboutSettings.swift rename to apps/macos/Sources/Moltbot/AboutSettings.swift diff --git a/apps/macos/Sources/Clawdbot/AgeFormatting.swift b/apps/macos/Sources/Moltbot/AgeFormatting.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/AgeFormatting.swift rename to apps/macos/Sources/Moltbot/AgeFormatting.swift diff --git a/apps/macos/Sources/Clawdbot/AgentEventStore.swift b/apps/macos/Sources/Moltbot/AgentEventStore.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/AgentEventStore.swift rename to apps/macos/Sources/Moltbot/AgentEventStore.swift diff --git a/apps/macos/Sources/Clawdbot/AgentEventsWindow.swift b/apps/macos/Sources/Moltbot/AgentEventsWindow.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/AgentEventsWindow.swift rename to apps/macos/Sources/Moltbot/AgentEventsWindow.swift diff --git a/apps/macos/Sources/Clawdbot/AnthropicAuthControls.swift b/apps/macos/Sources/Moltbot/AnthropicAuthControls.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/AnthropicAuthControls.swift rename to apps/macos/Sources/Moltbot/AnthropicAuthControls.swift diff --git a/apps/macos/Sources/Clawdbot/AnthropicOAuthCodeState.swift b/apps/macos/Sources/Moltbot/AnthropicOAuthCodeState.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/AnthropicOAuthCodeState.swift rename to apps/macos/Sources/Moltbot/AnthropicOAuthCodeState.swift diff --git a/apps/macos/Sources/Clawdbot/AnyCodable+Helpers.swift b/apps/macos/Sources/Moltbot/AnyCodable+Helpers.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/AnyCodable+Helpers.swift rename to apps/macos/Sources/Moltbot/AnyCodable+Helpers.swift diff --git a/apps/macos/Sources/Clawdbot/AppState.swift b/apps/macos/Sources/Moltbot/AppState.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/AppState.swift rename to apps/macos/Sources/Moltbot/AppState.swift diff --git a/apps/macos/Sources/Clawdbot/CLIInstaller.swift b/apps/macos/Sources/Moltbot/CLIInstaller.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CLIInstaller.swift rename to apps/macos/Sources/Moltbot/CLIInstaller.swift diff --git a/apps/macos/Sources/Clawdbot/CanvasA2UIActionMessageHandler.swift b/apps/macos/Sources/Moltbot/CanvasA2UIActionMessageHandler.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CanvasA2UIActionMessageHandler.swift rename to apps/macos/Sources/Moltbot/CanvasA2UIActionMessageHandler.swift diff --git a/apps/macos/Sources/Clawdbot/CanvasChromeContainerView.swift b/apps/macos/Sources/Moltbot/CanvasChromeContainerView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CanvasChromeContainerView.swift rename to apps/macos/Sources/Moltbot/CanvasChromeContainerView.swift diff --git a/apps/macos/Sources/Clawdbot/CanvasScheme.swift b/apps/macos/Sources/Moltbot/CanvasScheme.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CanvasScheme.swift rename to apps/macos/Sources/Moltbot/CanvasScheme.swift diff --git a/apps/macos/Sources/Clawdbot/CanvasWindowController+Helpers.swift b/apps/macos/Sources/Moltbot/CanvasWindowController+Helpers.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CanvasWindowController+Helpers.swift rename to apps/macos/Sources/Moltbot/CanvasWindowController+Helpers.swift diff --git a/apps/macos/Sources/Clawdbot/CanvasWindowController+Navigation.swift b/apps/macos/Sources/Moltbot/CanvasWindowController+Navigation.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CanvasWindowController+Navigation.swift rename to apps/macos/Sources/Moltbot/CanvasWindowController+Navigation.swift diff --git a/apps/macos/Sources/Clawdbot/CanvasWindowController+Testing.swift b/apps/macos/Sources/Moltbot/CanvasWindowController+Testing.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CanvasWindowController+Testing.swift rename to apps/macos/Sources/Moltbot/CanvasWindowController+Testing.swift diff --git a/apps/macos/Sources/Clawdbot/CanvasWindowController+Window.swift b/apps/macos/Sources/Moltbot/CanvasWindowController+Window.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CanvasWindowController+Window.swift rename to apps/macos/Sources/Moltbot/CanvasWindowController+Window.swift diff --git a/apps/macos/Sources/Clawdbot/CanvasWindowController.swift b/apps/macos/Sources/Moltbot/CanvasWindowController.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CanvasWindowController.swift rename to apps/macos/Sources/Moltbot/CanvasWindowController.swift diff --git a/apps/macos/Sources/Clawdbot/ChannelConfigForm.swift b/apps/macos/Sources/Moltbot/ChannelConfigForm.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ChannelConfigForm.swift rename to apps/macos/Sources/Moltbot/ChannelConfigForm.swift diff --git a/apps/macos/Sources/Clawdbot/ChannelsSettings+ChannelSections.swift b/apps/macos/Sources/Moltbot/ChannelsSettings+ChannelSections.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ChannelsSettings+ChannelSections.swift rename to apps/macos/Sources/Moltbot/ChannelsSettings+ChannelSections.swift diff --git a/apps/macos/Sources/Clawdbot/ChannelsSettings+ChannelState.swift b/apps/macos/Sources/Moltbot/ChannelsSettings+ChannelState.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ChannelsSettings+ChannelState.swift rename to apps/macos/Sources/Moltbot/ChannelsSettings+ChannelState.swift diff --git a/apps/macos/Sources/Clawdbot/ChannelsSettings+Helpers.swift b/apps/macos/Sources/Moltbot/ChannelsSettings+Helpers.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ChannelsSettings+Helpers.swift rename to apps/macos/Sources/Moltbot/ChannelsSettings+Helpers.swift diff --git a/apps/macos/Sources/Clawdbot/ChannelsSettings+View.swift b/apps/macos/Sources/Moltbot/ChannelsSettings+View.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ChannelsSettings+View.swift rename to apps/macos/Sources/Moltbot/ChannelsSettings+View.swift diff --git a/apps/macos/Sources/Clawdbot/ChannelsSettings.swift b/apps/macos/Sources/Moltbot/ChannelsSettings.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ChannelsSettings.swift rename to apps/macos/Sources/Moltbot/ChannelsSettings.swift diff --git a/apps/macos/Sources/Clawdbot/ChannelsStore+Config.swift b/apps/macos/Sources/Moltbot/ChannelsStore+Config.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ChannelsStore+Config.swift rename to apps/macos/Sources/Moltbot/ChannelsStore+Config.swift diff --git a/apps/macos/Sources/Clawdbot/ChannelsStore+Lifecycle.swift b/apps/macos/Sources/Moltbot/ChannelsStore+Lifecycle.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ChannelsStore+Lifecycle.swift rename to apps/macos/Sources/Moltbot/ChannelsStore+Lifecycle.swift diff --git a/apps/macos/Sources/Clawdbot/ChannelsStore.swift b/apps/macos/Sources/Moltbot/ChannelsStore.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ChannelsStore.swift rename to apps/macos/Sources/Moltbot/ChannelsStore.swift diff --git a/apps/macos/Sources/Clawdbot/ClawdbotPaths.swift b/apps/macos/Sources/Moltbot/ClawdbotPaths.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ClawdbotPaths.swift rename to apps/macos/Sources/Moltbot/ClawdbotPaths.swift diff --git a/apps/macos/Sources/Clawdbot/CommandResolver.swift b/apps/macos/Sources/Moltbot/CommandResolver.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CommandResolver.swift rename to apps/macos/Sources/Moltbot/CommandResolver.swift diff --git a/apps/macos/Sources/Clawdbot/ConfigSchemaSupport.swift b/apps/macos/Sources/Moltbot/ConfigSchemaSupport.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ConfigSchemaSupport.swift rename to apps/macos/Sources/Moltbot/ConfigSchemaSupport.swift diff --git a/apps/macos/Sources/Clawdbot/ConfigSettings.swift b/apps/macos/Sources/Moltbot/ConfigSettings.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ConfigSettings.swift rename to apps/macos/Sources/Moltbot/ConfigSettings.swift diff --git a/apps/macos/Sources/Clawdbot/ConfigStore.swift b/apps/macos/Sources/Moltbot/ConfigStore.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ConfigStore.swift rename to apps/macos/Sources/Moltbot/ConfigStore.swift diff --git a/apps/macos/Sources/Clawdbot/ConnectionModeResolver.swift b/apps/macos/Sources/Moltbot/ConnectionModeResolver.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ConnectionModeResolver.swift rename to apps/macos/Sources/Moltbot/ConnectionModeResolver.swift diff --git a/apps/macos/Sources/Clawdbot/ContextMenuCardView.swift b/apps/macos/Sources/Moltbot/ContextMenuCardView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ContextMenuCardView.swift rename to apps/macos/Sources/Moltbot/ContextMenuCardView.swift diff --git a/apps/macos/Sources/Clawdbot/ContextUsageBar.swift b/apps/macos/Sources/Moltbot/ContextUsageBar.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ContextUsageBar.swift rename to apps/macos/Sources/Moltbot/ContextUsageBar.swift diff --git a/apps/macos/Sources/Clawdbot/CostUsageMenuView.swift b/apps/macos/Sources/Moltbot/CostUsageMenuView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CostUsageMenuView.swift rename to apps/macos/Sources/Moltbot/CostUsageMenuView.swift diff --git a/apps/macos/Sources/Clawdbot/CritterIconRenderer.swift b/apps/macos/Sources/Moltbot/CritterIconRenderer.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CritterIconRenderer.swift rename to apps/macos/Sources/Moltbot/CritterIconRenderer.swift diff --git a/apps/macos/Sources/Clawdbot/CritterStatusLabel+Behavior.swift b/apps/macos/Sources/Moltbot/CritterStatusLabel+Behavior.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CritterStatusLabel+Behavior.swift rename to apps/macos/Sources/Moltbot/CritterStatusLabel+Behavior.swift diff --git a/apps/macos/Sources/Clawdbot/CritterStatusLabel.swift b/apps/macos/Sources/Moltbot/CritterStatusLabel.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CritterStatusLabel.swift rename to apps/macos/Sources/Moltbot/CritterStatusLabel.swift diff --git a/apps/macos/Sources/Clawdbot/CronJobEditor+Helpers.swift b/apps/macos/Sources/Moltbot/CronJobEditor+Helpers.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CronJobEditor+Helpers.swift rename to apps/macos/Sources/Moltbot/CronJobEditor+Helpers.swift diff --git a/apps/macos/Sources/Clawdbot/CronJobEditor+Testing.swift b/apps/macos/Sources/Moltbot/CronJobEditor+Testing.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CronJobEditor+Testing.swift rename to apps/macos/Sources/Moltbot/CronJobEditor+Testing.swift diff --git a/apps/macos/Sources/Clawdbot/CronJobEditor.swift b/apps/macos/Sources/Moltbot/CronJobEditor.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CronJobEditor.swift rename to apps/macos/Sources/Moltbot/CronJobEditor.swift diff --git a/apps/macos/Sources/Clawdbot/CronModels.swift b/apps/macos/Sources/Moltbot/CronModels.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CronModels.swift rename to apps/macos/Sources/Moltbot/CronModels.swift diff --git a/apps/macos/Sources/Clawdbot/CronSettings+Actions.swift b/apps/macos/Sources/Moltbot/CronSettings+Actions.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CronSettings+Actions.swift rename to apps/macos/Sources/Moltbot/CronSettings+Actions.swift diff --git a/apps/macos/Sources/Clawdbot/CronSettings+Helpers.swift b/apps/macos/Sources/Moltbot/CronSettings+Helpers.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CronSettings+Helpers.swift rename to apps/macos/Sources/Moltbot/CronSettings+Helpers.swift diff --git a/apps/macos/Sources/Clawdbot/CronSettings+Layout.swift b/apps/macos/Sources/Moltbot/CronSettings+Layout.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CronSettings+Layout.swift rename to apps/macos/Sources/Moltbot/CronSettings+Layout.swift diff --git a/apps/macos/Sources/Clawdbot/CronSettings+Rows.swift b/apps/macos/Sources/Moltbot/CronSettings+Rows.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CronSettings+Rows.swift rename to apps/macos/Sources/Moltbot/CronSettings+Rows.swift diff --git a/apps/macos/Sources/Clawdbot/CronSettings+Testing.swift b/apps/macos/Sources/Moltbot/CronSettings+Testing.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CronSettings+Testing.swift rename to apps/macos/Sources/Moltbot/CronSettings+Testing.swift diff --git a/apps/macos/Sources/Clawdbot/CronSettings.swift b/apps/macos/Sources/Moltbot/CronSettings.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/CronSettings.swift rename to apps/macos/Sources/Moltbot/CronSettings.swift diff --git a/apps/macos/Sources/Clawdbot/DebugActions.swift b/apps/macos/Sources/Moltbot/DebugActions.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/DebugActions.swift rename to apps/macos/Sources/Moltbot/DebugActions.swift diff --git a/apps/macos/Sources/Clawdbot/DebugSettings.swift b/apps/macos/Sources/Moltbot/DebugSettings.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/DebugSettings.swift rename to apps/macos/Sources/Moltbot/DebugSettings.swift diff --git a/apps/macos/Sources/Clawdbot/DeviceModelCatalog.swift b/apps/macos/Sources/Moltbot/DeviceModelCatalog.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/DeviceModelCatalog.swift rename to apps/macos/Sources/Moltbot/DeviceModelCatalog.swift diff --git a/apps/macos/Sources/Clawdbot/DiagnosticsFileLog.swift b/apps/macos/Sources/Moltbot/DiagnosticsFileLog.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/DiagnosticsFileLog.swift rename to apps/macos/Sources/Moltbot/DiagnosticsFileLog.swift diff --git a/apps/macos/Sources/Clawdbot/FileHandle+SafeRead.swift b/apps/macos/Sources/Moltbot/FileHandle+SafeRead.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/FileHandle+SafeRead.swift rename to apps/macos/Sources/Moltbot/FileHandle+SafeRead.swift diff --git a/apps/macos/Sources/Clawdbot/GatewayAutostartPolicy.swift b/apps/macos/Sources/Moltbot/GatewayAutostartPolicy.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/GatewayAutostartPolicy.swift rename to apps/macos/Sources/Moltbot/GatewayAutostartPolicy.swift diff --git a/apps/macos/Sources/Clawdbot/GatewayDiscoveryHelpers.swift b/apps/macos/Sources/Moltbot/GatewayDiscoveryHelpers.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/GatewayDiscoveryHelpers.swift rename to apps/macos/Sources/Moltbot/GatewayDiscoveryHelpers.swift diff --git a/apps/macos/Sources/Clawdbot/GatewayDiscoveryMenu.swift b/apps/macos/Sources/Moltbot/GatewayDiscoveryMenu.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/GatewayDiscoveryMenu.swift rename to apps/macos/Sources/Moltbot/GatewayDiscoveryMenu.swift diff --git a/apps/macos/Sources/Clawdbot/GatewayDiscoveryPreferences.swift b/apps/macos/Sources/Moltbot/GatewayDiscoveryPreferences.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/GatewayDiscoveryPreferences.swift rename to apps/macos/Sources/Moltbot/GatewayDiscoveryPreferences.swift diff --git a/apps/macos/Sources/Clawdbot/GatewayRemoteConfig.swift b/apps/macos/Sources/Moltbot/GatewayRemoteConfig.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/GatewayRemoteConfig.swift rename to apps/macos/Sources/Moltbot/GatewayRemoteConfig.swift diff --git a/apps/macos/Sources/Clawdbot/GeneralSettings.swift b/apps/macos/Sources/Moltbot/GeneralSettings.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/GeneralSettings.swift rename to apps/macos/Sources/Moltbot/GeneralSettings.swift diff --git a/apps/macos/Sources/Clawdbot/HeartbeatStore.swift b/apps/macos/Sources/Moltbot/HeartbeatStore.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/HeartbeatStore.swift rename to apps/macos/Sources/Moltbot/HeartbeatStore.swift diff --git a/apps/macos/Sources/Clawdbot/HoverHUD.swift b/apps/macos/Sources/Moltbot/HoverHUD.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/HoverHUD.swift rename to apps/macos/Sources/Moltbot/HoverHUD.swift diff --git a/apps/macos/Sources/Clawdbot/IconState.swift b/apps/macos/Sources/Moltbot/IconState.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/IconState.swift rename to apps/macos/Sources/Moltbot/IconState.swift diff --git a/apps/macos/Sources/Clawdbot/InstancesSettings.swift b/apps/macos/Sources/Moltbot/InstancesSettings.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/InstancesSettings.swift rename to apps/macos/Sources/Moltbot/InstancesSettings.swift diff --git a/apps/macos/Sources/Clawdbot/Launchctl.swift b/apps/macos/Sources/Moltbot/Launchctl.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/Launchctl.swift rename to apps/macos/Sources/Moltbot/Launchctl.swift diff --git a/apps/macos/Sources/Clawdbot/LaunchdManager.swift b/apps/macos/Sources/Moltbot/LaunchdManager.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/LaunchdManager.swift rename to apps/macos/Sources/Moltbot/LaunchdManager.swift diff --git a/apps/macos/Sources/Clawdbot/LogLocator.swift b/apps/macos/Sources/Moltbot/LogLocator.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/LogLocator.swift rename to apps/macos/Sources/Moltbot/LogLocator.swift diff --git a/apps/macos/Sources/Clawdbot/MenuContentView.swift b/apps/macos/Sources/Moltbot/MenuContentView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/MenuContentView.swift rename to apps/macos/Sources/Moltbot/MenuContentView.swift diff --git a/apps/macos/Sources/Clawdbot/MenuContextCardInjector.swift b/apps/macos/Sources/Moltbot/MenuContextCardInjector.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/MenuContextCardInjector.swift rename to apps/macos/Sources/Moltbot/MenuContextCardInjector.swift diff --git a/apps/macos/Sources/Clawdbot/MenuHighlightedHostView.swift b/apps/macos/Sources/Moltbot/MenuHighlightedHostView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/MenuHighlightedHostView.swift rename to apps/macos/Sources/Moltbot/MenuHighlightedHostView.swift diff --git a/apps/macos/Sources/Clawdbot/MenuHostedItem.swift b/apps/macos/Sources/Moltbot/MenuHostedItem.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/MenuHostedItem.swift rename to apps/macos/Sources/Moltbot/MenuHostedItem.swift diff --git a/apps/macos/Sources/Clawdbot/MenuSessionsHeaderView.swift b/apps/macos/Sources/Moltbot/MenuSessionsHeaderView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/MenuSessionsHeaderView.swift rename to apps/macos/Sources/Moltbot/MenuSessionsHeaderView.swift diff --git a/apps/macos/Sources/Clawdbot/MenuSessionsInjector.swift b/apps/macos/Sources/Moltbot/MenuSessionsInjector.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/MenuSessionsInjector.swift rename to apps/macos/Sources/Moltbot/MenuSessionsInjector.swift diff --git a/apps/macos/Sources/Clawdbot/MenuUsageHeaderView.swift b/apps/macos/Sources/Moltbot/MenuUsageHeaderView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/MenuUsageHeaderView.swift rename to apps/macos/Sources/Moltbot/MenuUsageHeaderView.swift diff --git a/apps/macos/Sources/Clawdbot/NSAttributedString+VoiceWake.swift b/apps/macos/Sources/Moltbot/NSAttributedString+VoiceWake.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/NSAttributedString+VoiceWake.swift rename to apps/macos/Sources/Moltbot/NSAttributedString+VoiceWake.swift diff --git a/apps/macos/Sources/Clawdbot/NodeMode/MacNodeLocationService.swift b/apps/macos/Sources/Moltbot/NodeMode/MacNodeLocationService.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/NodeMode/MacNodeLocationService.swift rename to apps/macos/Sources/Moltbot/NodeMode/MacNodeLocationService.swift diff --git a/apps/macos/Sources/Clawdbot/NodeMode/MacNodeRuntime.swift b/apps/macos/Sources/Moltbot/NodeMode/MacNodeRuntime.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/NodeMode/MacNodeRuntime.swift rename to apps/macos/Sources/Moltbot/NodeMode/MacNodeRuntime.swift diff --git a/apps/macos/Sources/Clawdbot/NodeMode/MacNodeRuntimeMainActorServices.swift b/apps/macos/Sources/Moltbot/NodeMode/MacNodeRuntimeMainActorServices.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/NodeMode/MacNodeRuntimeMainActorServices.swift rename to apps/macos/Sources/Moltbot/NodeMode/MacNodeRuntimeMainActorServices.swift diff --git a/apps/macos/Sources/Clawdbot/NodeMode/MacNodeScreenCommands.swift b/apps/macos/Sources/Moltbot/NodeMode/MacNodeScreenCommands.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/NodeMode/MacNodeScreenCommands.swift rename to apps/macos/Sources/Moltbot/NodeMode/MacNodeScreenCommands.swift diff --git a/apps/macos/Sources/Clawdbot/NodesMenu.swift b/apps/macos/Sources/Moltbot/NodesMenu.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/NodesMenu.swift rename to apps/macos/Sources/Moltbot/NodesMenu.swift diff --git a/apps/macos/Sources/Clawdbot/NotifyOverlay.swift b/apps/macos/Sources/Moltbot/NotifyOverlay.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/NotifyOverlay.swift rename to apps/macos/Sources/Moltbot/NotifyOverlay.swift diff --git a/apps/macos/Sources/Clawdbot/Onboarding.swift b/apps/macos/Sources/Moltbot/Onboarding.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/Onboarding.swift rename to apps/macos/Sources/Moltbot/Onboarding.swift diff --git a/apps/macos/Sources/Clawdbot/OnboardingView+Actions.swift b/apps/macos/Sources/Moltbot/OnboardingView+Actions.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/OnboardingView+Actions.swift rename to apps/macos/Sources/Moltbot/OnboardingView+Actions.swift diff --git a/apps/macos/Sources/Clawdbot/OnboardingView+Chat.swift b/apps/macos/Sources/Moltbot/OnboardingView+Chat.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/OnboardingView+Chat.swift rename to apps/macos/Sources/Moltbot/OnboardingView+Chat.swift diff --git a/apps/macos/Sources/Clawdbot/OnboardingView+Layout.swift b/apps/macos/Sources/Moltbot/OnboardingView+Layout.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/OnboardingView+Layout.swift rename to apps/macos/Sources/Moltbot/OnboardingView+Layout.swift diff --git a/apps/macos/Sources/Clawdbot/OnboardingView+Monitoring.swift b/apps/macos/Sources/Moltbot/OnboardingView+Monitoring.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/OnboardingView+Monitoring.swift rename to apps/macos/Sources/Moltbot/OnboardingView+Monitoring.swift diff --git a/apps/macos/Sources/Clawdbot/OnboardingView+Pages.swift b/apps/macos/Sources/Moltbot/OnboardingView+Pages.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/OnboardingView+Pages.swift rename to apps/macos/Sources/Moltbot/OnboardingView+Pages.swift diff --git a/apps/macos/Sources/Clawdbot/OnboardingView+Testing.swift b/apps/macos/Sources/Moltbot/OnboardingView+Testing.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/OnboardingView+Testing.swift rename to apps/macos/Sources/Moltbot/OnboardingView+Testing.swift diff --git a/apps/macos/Sources/Clawdbot/OnboardingView+Wizard.swift b/apps/macos/Sources/Moltbot/OnboardingView+Wizard.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/OnboardingView+Wizard.swift rename to apps/macos/Sources/Moltbot/OnboardingView+Wizard.swift diff --git a/apps/macos/Sources/Clawdbot/OnboardingView+Workspace.swift b/apps/macos/Sources/Moltbot/OnboardingView+Workspace.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/OnboardingView+Workspace.swift rename to apps/macos/Sources/Moltbot/OnboardingView+Workspace.swift diff --git a/apps/macos/Sources/Clawdbot/OnboardingWidgets.swift b/apps/macos/Sources/Moltbot/OnboardingWidgets.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/OnboardingWidgets.swift rename to apps/macos/Sources/Moltbot/OnboardingWidgets.swift diff --git a/apps/macos/Sources/Clawdbot/PermissionsSettings.swift b/apps/macos/Sources/Moltbot/PermissionsSettings.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/PermissionsSettings.swift rename to apps/macos/Sources/Moltbot/PermissionsSettings.swift diff --git a/apps/macos/Sources/Clawdbot/PointingHandCursor.swift b/apps/macos/Sources/Moltbot/PointingHandCursor.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/PointingHandCursor.swift rename to apps/macos/Sources/Moltbot/PointingHandCursor.swift diff --git a/apps/macos/Sources/Clawdbot/Process+PipeRead.swift b/apps/macos/Sources/Moltbot/Process+PipeRead.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/Process+PipeRead.swift rename to apps/macos/Sources/Moltbot/Process+PipeRead.swift diff --git a/apps/macos/Sources/Clawdbot/ProcessInfo+Clawdbot.swift b/apps/macos/Sources/Moltbot/ProcessInfo+Clawdbot.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ProcessInfo+Clawdbot.swift rename to apps/macos/Sources/Moltbot/ProcessInfo+Clawdbot.swift diff --git a/apps/macos/Sources/Clawdbot/Resources/Clawdbot.icns b/apps/macos/Sources/Moltbot/Resources/Clawdbot.icns similarity index 100% rename from apps/macos/Sources/Clawdbot/Resources/Clawdbot.icns rename to apps/macos/Sources/Moltbot/Resources/Clawdbot.icns diff --git a/apps/macos/Sources/Clawdbot/Resources/DeviceModels/LICENSE.apple-device-identifiers.txt b/apps/macos/Sources/Moltbot/Resources/DeviceModels/LICENSE.apple-device-identifiers.txt similarity index 100% rename from apps/macos/Sources/Clawdbot/Resources/DeviceModels/LICENSE.apple-device-identifiers.txt rename to apps/macos/Sources/Moltbot/Resources/DeviceModels/LICENSE.apple-device-identifiers.txt diff --git a/apps/macos/Sources/Clawdbot/Resources/DeviceModels/NOTICE.md b/apps/macos/Sources/Moltbot/Resources/DeviceModels/NOTICE.md similarity index 100% rename from apps/macos/Sources/Clawdbot/Resources/DeviceModels/NOTICE.md rename to apps/macos/Sources/Moltbot/Resources/DeviceModels/NOTICE.md diff --git a/apps/macos/Sources/Clawdbot/Resources/DeviceModels/ios-device-identifiers.json b/apps/macos/Sources/Moltbot/Resources/DeviceModels/ios-device-identifiers.json similarity index 100% rename from apps/macos/Sources/Clawdbot/Resources/DeviceModels/ios-device-identifiers.json rename to apps/macos/Sources/Moltbot/Resources/DeviceModels/ios-device-identifiers.json diff --git a/apps/macos/Sources/Clawdbot/Resources/DeviceModels/mac-device-identifiers.json b/apps/macos/Sources/Moltbot/Resources/DeviceModels/mac-device-identifiers.json similarity index 100% rename from apps/macos/Sources/Clawdbot/Resources/DeviceModels/mac-device-identifiers.json rename to apps/macos/Sources/Moltbot/Resources/DeviceModels/mac-device-identifiers.json diff --git a/apps/macos/Sources/Clawdbot/ScreenshotSize.swift b/apps/macos/Sources/Moltbot/ScreenshotSize.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ScreenshotSize.swift rename to apps/macos/Sources/Moltbot/ScreenshotSize.swift diff --git a/apps/macos/Sources/Clawdbot/SessionActions.swift b/apps/macos/Sources/Moltbot/SessionActions.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/SessionActions.swift rename to apps/macos/Sources/Moltbot/SessionActions.swift diff --git a/apps/macos/Sources/Clawdbot/SessionData.swift b/apps/macos/Sources/Moltbot/SessionData.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/SessionData.swift rename to apps/macos/Sources/Moltbot/SessionData.swift diff --git a/apps/macos/Sources/Clawdbot/SessionMenuLabelView.swift b/apps/macos/Sources/Moltbot/SessionMenuLabelView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/SessionMenuLabelView.swift rename to apps/macos/Sources/Moltbot/SessionMenuLabelView.swift diff --git a/apps/macos/Sources/Clawdbot/SessionsSettings.swift b/apps/macos/Sources/Moltbot/SessionsSettings.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/SessionsSettings.swift rename to apps/macos/Sources/Moltbot/SessionsSettings.swift diff --git a/apps/macos/Sources/Clawdbot/SettingsComponents.swift b/apps/macos/Sources/Moltbot/SettingsComponents.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/SettingsComponents.swift rename to apps/macos/Sources/Moltbot/SettingsComponents.swift diff --git a/apps/macos/Sources/Clawdbot/SettingsRootView.swift b/apps/macos/Sources/Moltbot/SettingsRootView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/SettingsRootView.swift rename to apps/macos/Sources/Moltbot/SettingsRootView.swift diff --git a/apps/macos/Sources/Clawdbot/SettingsWindowOpener.swift b/apps/macos/Sources/Moltbot/SettingsWindowOpener.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/SettingsWindowOpener.swift rename to apps/macos/Sources/Moltbot/SettingsWindowOpener.swift diff --git a/apps/macos/Sources/Clawdbot/ShellExecutor.swift b/apps/macos/Sources/Moltbot/ShellExecutor.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ShellExecutor.swift rename to apps/macos/Sources/Moltbot/ShellExecutor.swift diff --git a/apps/macos/Sources/Clawdbot/SkillsModels.swift b/apps/macos/Sources/Moltbot/SkillsModels.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/SkillsModels.swift rename to apps/macos/Sources/Moltbot/SkillsModels.swift diff --git a/apps/macos/Sources/Clawdbot/SkillsSettings.swift b/apps/macos/Sources/Moltbot/SkillsSettings.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/SkillsSettings.swift rename to apps/macos/Sources/Moltbot/SkillsSettings.swift diff --git a/apps/macos/Sources/Clawdbot/SoundEffects.swift b/apps/macos/Sources/Moltbot/SoundEffects.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/SoundEffects.swift rename to apps/macos/Sources/Moltbot/SoundEffects.swift diff --git a/apps/macos/Sources/Clawdbot/StatusPill.swift b/apps/macos/Sources/Moltbot/StatusPill.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/StatusPill.swift rename to apps/macos/Sources/Moltbot/StatusPill.swift diff --git a/apps/macos/Sources/Clawdbot/String+NonEmpty.swift b/apps/macos/Sources/Moltbot/String+NonEmpty.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/String+NonEmpty.swift rename to apps/macos/Sources/Moltbot/String+NonEmpty.swift diff --git a/apps/macos/Sources/Clawdbot/SystemRunSettingsView.swift b/apps/macos/Sources/Moltbot/SystemRunSettingsView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/SystemRunSettingsView.swift rename to apps/macos/Sources/Moltbot/SystemRunSettingsView.swift diff --git a/apps/macos/Sources/Clawdbot/TailscaleIntegrationSection.swift b/apps/macos/Sources/Moltbot/TailscaleIntegrationSection.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/TailscaleIntegrationSection.swift rename to apps/macos/Sources/Moltbot/TailscaleIntegrationSection.swift diff --git a/apps/macos/Sources/Clawdbot/TalkModeTypes.swift b/apps/macos/Sources/Moltbot/TalkModeTypes.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/TalkModeTypes.swift rename to apps/macos/Sources/Moltbot/TalkModeTypes.swift diff --git a/apps/macos/Sources/Clawdbot/TalkOverlayView.swift b/apps/macos/Sources/Moltbot/TalkOverlayView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/TalkOverlayView.swift rename to apps/macos/Sources/Moltbot/TalkOverlayView.swift diff --git a/apps/macos/Sources/Clawdbot/UsageCostData.swift b/apps/macos/Sources/Moltbot/UsageCostData.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/UsageCostData.swift rename to apps/macos/Sources/Moltbot/UsageCostData.swift diff --git a/apps/macos/Sources/Clawdbot/UsageData.swift b/apps/macos/Sources/Moltbot/UsageData.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/UsageData.swift rename to apps/macos/Sources/Moltbot/UsageData.swift diff --git a/apps/macos/Sources/Clawdbot/UsageMenuLabelView.swift b/apps/macos/Sources/Moltbot/UsageMenuLabelView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/UsageMenuLabelView.swift rename to apps/macos/Sources/Moltbot/UsageMenuLabelView.swift diff --git a/apps/macos/Sources/Clawdbot/ViewMetrics.swift b/apps/macos/Sources/Moltbot/ViewMetrics.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/ViewMetrics.swift rename to apps/macos/Sources/Moltbot/ViewMetrics.swift diff --git a/apps/macos/Sources/Clawdbot/VisualEffectView.swift b/apps/macos/Sources/Moltbot/VisualEffectView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/VisualEffectView.swift rename to apps/macos/Sources/Moltbot/VisualEffectView.swift diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeHelpers.swift b/apps/macos/Sources/Moltbot/VoiceWakeHelpers.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/VoiceWakeHelpers.swift rename to apps/macos/Sources/Moltbot/VoiceWakeHelpers.swift diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeOverlayController+Session.swift b/apps/macos/Sources/Moltbot/VoiceWakeOverlayController+Session.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/VoiceWakeOverlayController+Session.swift rename to apps/macos/Sources/Moltbot/VoiceWakeOverlayController+Session.swift diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeOverlayController+Testing.swift b/apps/macos/Sources/Moltbot/VoiceWakeOverlayController+Testing.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/VoiceWakeOverlayController+Testing.swift rename to apps/macos/Sources/Moltbot/VoiceWakeOverlayController+Testing.swift diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeOverlayController+Window.swift b/apps/macos/Sources/Moltbot/VoiceWakeOverlayController+Window.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/VoiceWakeOverlayController+Window.swift rename to apps/macos/Sources/Moltbot/VoiceWakeOverlayController+Window.swift diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeOverlayTextViews.swift b/apps/macos/Sources/Moltbot/VoiceWakeOverlayTextViews.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/VoiceWakeOverlayTextViews.swift rename to apps/macos/Sources/Moltbot/VoiceWakeOverlayTextViews.swift diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeOverlayView.swift b/apps/macos/Sources/Moltbot/VoiceWakeOverlayView.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/VoiceWakeOverlayView.swift rename to apps/macos/Sources/Moltbot/VoiceWakeOverlayView.swift diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeSettings.swift b/apps/macos/Sources/Moltbot/VoiceWakeSettings.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/VoiceWakeSettings.swift rename to apps/macos/Sources/Moltbot/VoiceWakeSettings.swift diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeTestCard.swift b/apps/macos/Sources/Moltbot/VoiceWakeTestCard.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/VoiceWakeTestCard.swift rename to apps/macos/Sources/Moltbot/VoiceWakeTestCard.swift diff --git a/apps/macos/Sources/Clawdbot/VoiceWakeTextUtils.swift b/apps/macos/Sources/Moltbot/VoiceWakeTextUtils.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/VoiceWakeTextUtils.swift rename to apps/macos/Sources/Moltbot/VoiceWakeTextUtils.swift diff --git a/apps/macos/Sources/Clawdbot/WebChatManager.swift b/apps/macos/Sources/Moltbot/WebChatManager.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/WebChatManager.swift rename to apps/macos/Sources/Moltbot/WebChatManager.swift diff --git a/apps/macos/Sources/Clawdbot/WindowPlacement.swift b/apps/macos/Sources/Moltbot/WindowPlacement.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/WindowPlacement.swift rename to apps/macos/Sources/Moltbot/WindowPlacement.swift diff --git a/apps/macos/Sources/Clawdbot/WorkActivityStore.swift b/apps/macos/Sources/Moltbot/WorkActivityStore.swift similarity index 100% rename from apps/macos/Sources/Clawdbot/WorkActivityStore.swift rename to apps/macos/Sources/Moltbot/WorkActivityStore.swift diff --git a/apps/macos/Sources/ClawdbotDiscovery/WideAreaGatewayDiscovery.swift b/apps/macos/Sources/MoltbotDiscovery/WideAreaGatewayDiscovery.swift similarity index 100% rename from apps/macos/Sources/ClawdbotDiscovery/WideAreaGatewayDiscovery.swift rename to apps/macos/Sources/MoltbotDiscovery/WideAreaGatewayDiscovery.swift diff --git a/apps/macos/Sources/ClawdbotIPC/IPC.swift b/apps/macos/Sources/MoltbotIPC/IPC.swift similarity index 100% rename from apps/macos/Sources/ClawdbotIPC/IPC.swift rename to apps/macos/Sources/MoltbotIPC/IPC.swift diff --git a/apps/macos/Sources/ClawdbotMacCLI/ConnectCommand.swift b/apps/macos/Sources/MoltbotMacCLI/ConnectCommand.swift similarity index 100% rename from apps/macos/Sources/ClawdbotMacCLI/ConnectCommand.swift rename to apps/macos/Sources/MoltbotMacCLI/ConnectCommand.swift diff --git a/apps/macos/Sources/ClawdbotMacCLI/DiscoverCommand.swift b/apps/macos/Sources/MoltbotMacCLI/DiscoverCommand.swift similarity index 100% rename from apps/macos/Sources/ClawdbotMacCLI/DiscoverCommand.swift rename to apps/macos/Sources/MoltbotMacCLI/DiscoverCommand.swift diff --git a/apps/macos/Sources/ClawdbotMacCLI/EntryPoint.swift b/apps/macos/Sources/MoltbotMacCLI/EntryPoint.swift similarity index 100% rename from apps/macos/Sources/ClawdbotMacCLI/EntryPoint.swift rename to apps/macos/Sources/MoltbotMacCLI/EntryPoint.swift diff --git a/apps/macos/Sources/ClawdbotMacCLI/GatewayConfig.swift b/apps/macos/Sources/MoltbotMacCLI/GatewayConfig.swift similarity index 100% rename from apps/macos/Sources/ClawdbotMacCLI/GatewayConfig.swift rename to apps/macos/Sources/MoltbotMacCLI/GatewayConfig.swift diff --git a/apps/macos/Sources/ClawdbotMacCLI/TypeAliases.swift b/apps/macos/Sources/MoltbotMacCLI/TypeAliases.swift similarity index 100% rename from apps/macos/Sources/ClawdbotMacCLI/TypeAliases.swift rename to apps/macos/Sources/MoltbotMacCLI/TypeAliases.swift diff --git a/apps/macos/Sources/ClawdbotMacCLI/WizardCommand.swift b/apps/macos/Sources/MoltbotMacCLI/WizardCommand.swift similarity index 100% rename from apps/macos/Sources/ClawdbotMacCLI/WizardCommand.swift rename to apps/macos/Sources/MoltbotMacCLI/WizardCommand.swift diff --git a/apps/macos/Sources/ClawdbotProtocol/GatewayModels.swift b/apps/macos/Sources/MoltbotProtocol/GatewayModels.swift similarity index 100% rename from apps/macos/Sources/ClawdbotProtocol/GatewayModels.swift rename to apps/macos/Sources/MoltbotProtocol/GatewayModels.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/AgentEventStoreTests.swift b/apps/macos/Tests/MoltbotIPCTests/AgentEventStoreTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/AgentEventStoreTests.swift rename to apps/macos/Tests/MoltbotIPCTests/AgentEventStoreTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/AgentWorkspaceTests.swift b/apps/macos/Tests/MoltbotIPCTests/AgentWorkspaceTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/AgentWorkspaceTests.swift rename to apps/macos/Tests/MoltbotIPCTests/AgentWorkspaceTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/AnthropicAuthControlsSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/AnthropicAuthControlsSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/AnthropicAuthControlsSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/AnthropicAuthControlsSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/AnthropicAuthResolverTests.swift b/apps/macos/Tests/MoltbotIPCTests/AnthropicAuthResolverTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/AnthropicAuthResolverTests.swift rename to apps/macos/Tests/MoltbotIPCTests/AnthropicAuthResolverTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/AnthropicOAuthCodeStateTests.swift b/apps/macos/Tests/MoltbotIPCTests/AnthropicOAuthCodeStateTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/AnthropicOAuthCodeStateTests.swift rename to apps/macos/Tests/MoltbotIPCTests/AnthropicOAuthCodeStateTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/AnyCodableEncodingTests.swift b/apps/macos/Tests/MoltbotIPCTests/AnyCodableEncodingTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/AnyCodableEncodingTests.swift rename to apps/macos/Tests/MoltbotIPCTests/AnyCodableEncodingTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/CLIInstallerTests.swift b/apps/macos/Tests/MoltbotIPCTests/CLIInstallerTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/CLIInstallerTests.swift rename to apps/macos/Tests/MoltbotIPCTests/CLIInstallerTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/CameraCaptureServiceTests.swift b/apps/macos/Tests/MoltbotIPCTests/CameraCaptureServiceTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/CameraCaptureServiceTests.swift rename to apps/macos/Tests/MoltbotIPCTests/CameraCaptureServiceTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/CameraIPCTests.swift b/apps/macos/Tests/MoltbotIPCTests/CameraIPCTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/CameraIPCTests.swift rename to apps/macos/Tests/MoltbotIPCTests/CameraIPCTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/CanvasFileWatcherTests.swift b/apps/macos/Tests/MoltbotIPCTests/CanvasFileWatcherTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/CanvasFileWatcherTests.swift rename to apps/macos/Tests/MoltbotIPCTests/CanvasFileWatcherTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/CanvasIPCTests.swift b/apps/macos/Tests/MoltbotIPCTests/CanvasIPCTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/CanvasIPCTests.swift rename to apps/macos/Tests/MoltbotIPCTests/CanvasIPCTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/CanvasWindowSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/CanvasWindowSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/CanvasWindowSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/CanvasWindowSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/ChannelsSettingsSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/ChannelsSettingsSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/ChannelsSettingsSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/ChannelsSettingsSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/ClawdbotConfigFileTests.swift b/apps/macos/Tests/MoltbotIPCTests/ClawdbotConfigFileTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/ClawdbotConfigFileTests.swift rename to apps/macos/Tests/MoltbotIPCTests/ClawdbotConfigFileTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/ClawdbotOAuthStoreTests.swift b/apps/macos/Tests/MoltbotIPCTests/ClawdbotOAuthStoreTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/ClawdbotOAuthStoreTests.swift rename to apps/macos/Tests/MoltbotIPCTests/ClawdbotOAuthStoreTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/CommandResolverTests.swift b/apps/macos/Tests/MoltbotIPCTests/CommandResolverTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/CommandResolverTests.swift rename to apps/macos/Tests/MoltbotIPCTests/CommandResolverTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/ConfigStoreTests.swift b/apps/macos/Tests/MoltbotIPCTests/ConfigStoreTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/ConfigStoreTests.swift rename to apps/macos/Tests/MoltbotIPCTests/ConfigStoreTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/CoverageDumpTests.swift b/apps/macos/Tests/MoltbotIPCTests/CoverageDumpTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/CoverageDumpTests.swift rename to apps/macos/Tests/MoltbotIPCTests/CoverageDumpTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/CritterIconRendererTests.swift b/apps/macos/Tests/MoltbotIPCTests/CritterIconRendererTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/CritterIconRendererTests.swift rename to apps/macos/Tests/MoltbotIPCTests/CritterIconRendererTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/CronJobEditorSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/CronJobEditorSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/CronJobEditorSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/CronJobEditorSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/CronModelsTests.swift b/apps/macos/Tests/MoltbotIPCTests/CronModelsTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/CronModelsTests.swift rename to apps/macos/Tests/MoltbotIPCTests/CronModelsTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/DeviceModelCatalogTests.swift b/apps/macos/Tests/MoltbotIPCTests/DeviceModelCatalogTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/DeviceModelCatalogTests.swift rename to apps/macos/Tests/MoltbotIPCTests/DeviceModelCatalogTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/ExecAllowlistTests.swift b/apps/macos/Tests/MoltbotIPCTests/ExecAllowlistTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/ExecAllowlistTests.swift rename to apps/macos/Tests/MoltbotIPCTests/ExecAllowlistTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/ExecApprovalHelpersTests.swift b/apps/macos/Tests/MoltbotIPCTests/ExecApprovalHelpersTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/ExecApprovalHelpersTests.swift rename to apps/macos/Tests/MoltbotIPCTests/ExecApprovalHelpersTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/ExecApprovalsGatewayPrompterTests.swift b/apps/macos/Tests/MoltbotIPCTests/ExecApprovalsGatewayPrompterTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/ExecApprovalsGatewayPrompterTests.swift rename to apps/macos/Tests/MoltbotIPCTests/ExecApprovalsGatewayPrompterTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/FileHandleLegacyAPIGuardTests.swift b/apps/macos/Tests/MoltbotIPCTests/FileHandleLegacyAPIGuardTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/FileHandleLegacyAPIGuardTests.swift rename to apps/macos/Tests/MoltbotIPCTests/FileHandleLegacyAPIGuardTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/FileHandleSafeReadTests.swift b/apps/macos/Tests/MoltbotIPCTests/FileHandleSafeReadTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/FileHandleSafeReadTests.swift rename to apps/macos/Tests/MoltbotIPCTests/FileHandleSafeReadTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayAgentChannelTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayAgentChannelTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayAgentChannelTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayAgentChannelTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayAutostartPolicyTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayAutostartPolicyTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayAutostartPolicyTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayAutostartPolicyTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayChannelConfigureTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayChannelConfigureTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayChannelConfigureTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayChannelConfigureTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayChannelConnectTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayChannelConnectTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayChannelConnectTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayChannelConnectTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayChannelRequestTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayChannelRequestTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayChannelRequestTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayChannelRequestTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayChannelShutdownTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayChannelShutdownTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayChannelShutdownTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayChannelShutdownTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayConnectionControlTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayConnectionControlTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayConnectionControlTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayConnectionControlTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayDiscoveryModelTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayDiscoveryModelTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayDiscoveryModelTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayDiscoveryModelTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayEndpointStoreTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayEndpointStoreTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayEndpointStoreTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayEndpointStoreTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayEnvironmentTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayEnvironmentTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayEnvironmentTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayEnvironmentTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayFrameDecodeTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayFrameDecodeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayFrameDecodeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayFrameDecodeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayLaunchAgentManagerTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayLaunchAgentManagerTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayLaunchAgentManagerTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayLaunchAgentManagerTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/GatewayProcessManagerTests.swift b/apps/macos/Tests/MoltbotIPCTests/GatewayProcessManagerTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/GatewayProcessManagerTests.swift rename to apps/macos/Tests/MoltbotIPCTests/GatewayProcessManagerTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/HealthDecodeTests.swift b/apps/macos/Tests/MoltbotIPCTests/HealthDecodeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/HealthDecodeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/HealthDecodeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/HealthStoreStateTests.swift b/apps/macos/Tests/MoltbotIPCTests/HealthStoreStateTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/HealthStoreStateTests.swift rename to apps/macos/Tests/MoltbotIPCTests/HealthStoreStateTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/HoverHUDControllerTests.swift b/apps/macos/Tests/MoltbotIPCTests/HoverHUDControllerTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/HoverHUDControllerTests.swift rename to apps/macos/Tests/MoltbotIPCTests/HoverHUDControllerTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/InstancesSettingsSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/InstancesSettingsSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/InstancesSettingsSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/InstancesSettingsSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/InstancesStoreTests.swift b/apps/macos/Tests/MoltbotIPCTests/InstancesStoreTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/InstancesStoreTests.swift rename to apps/macos/Tests/MoltbotIPCTests/InstancesStoreTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/LogLocatorTests.swift b/apps/macos/Tests/MoltbotIPCTests/LogLocatorTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/LogLocatorTests.swift rename to apps/macos/Tests/MoltbotIPCTests/LogLocatorTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/LowCoverageHelperTests.swift b/apps/macos/Tests/MoltbotIPCTests/LowCoverageHelperTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/LowCoverageHelperTests.swift rename to apps/macos/Tests/MoltbotIPCTests/LowCoverageHelperTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/LowCoverageViewSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/LowCoverageViewSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/LowCoverageViewSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/LowCoverageViewSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/MacGatewayChatTransportMappingTests.swift b/apps/macos/Tests/MoltbotIPCTests/MacGatewayChatTransportMappingTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/MacGatewayChatTransportMappingTests.swift rename to apps/macos/Tests/MoltbotIPCTests/MacGatewayChatTransportMappingTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/MacNodeRuntimeTests.swift b/apps/macos/Tests/MoltbotIPCTests/MacNodeRuntimeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/MacNodeRuntimeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/MacNodeRuntimeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/MasterDiscoveryMenuSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/MasterDiscoveryMenuSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/MasterDiscoveryMenuSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/MasterDiscoveryMenuSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/MenuContentSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/MenuContentSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/MenuContentSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/MenuContentSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/MenuSessionsInjectorTests.swift b/apps/macos/Tests/MoltbotIPCTests/MenuSessionsInjectorTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/MenuSessionsInjectorTests.swift rename to apps/macos/Tests/MoltbotIPCTests/MenuSessionsInjectorTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/ModelCatalogLoaderTests.swift b/apps/macos/Tests/MoltbotIPCTests/ModelCatalogLoaderTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/ModelCatalogLoaderTests.swift rename to apps/macos/Tests/MoltbotIPCTests/ModelCatalogLoaderTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/NodeManagerPathsTests.swift b/apps/macos/Tests/MoltbotIPCTests/NodeManagerPathsTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/NodeManagerPathsTests.swift rename to apps/macos/Tests/MoltbotIPCTests/NodeManagerPathsTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/NodePairingApprovalPrompterTests.swift b/apps/macos/Tests/MoltbotIPCTests/NodePairingApprovalPrompterTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/NodePairingApprovalPrompterTests.swift rename to apps/macos/Tests/MoltbotIPCTests/NodePairingApprovalPrompterTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/NodePairingReconcilePolicyTests.swift b/apps/macos/Tests/MoltbotIPCTests/NodePairingReconcilePolicyTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/NodePairingReconcilePolicyTests.swift rename to apps/macos/Tests/MoltbotIPCTests/NodePairingReconcilePolicyTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/OnboardingCoverageTests.swift b/apps/macos/Tests/MoltbotIPCTests/OnboardingCoverageTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/OnboardingCoverageTests.swift rename to apps/macos/Tests/MoltbotIPCTests/OnboardingCoverageTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/OnboardingViewSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/OnboardingViewSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/OnboardingViewSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/OnboardingViewSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/OnboardingWizardStepViewTests.swift b/apps/macos/Tests/MoltbotIPCTests/OnboardingWizardStepViewTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/OnboardingWizardStepViewTests.swift rename to apps/macos/Tests/MoltbotIPCTests/OnboardingWizardStepViewTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/PermissionManagerLocationTests.swift b/apps/macos/Tests/MoltbotIPCTests/PermissionManagerLocationTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/PermissionManagerLocationTests.swift rename to apps/macos/Tests/MoltbotIPCTests/PermissionManagerLocationTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/PermissionManagerTests.swift b/apps/macos/Tests/MoltbotIPCTests/PermissionManagerTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/PermissionManagerTests.swift rename to apps/macos/Tests/MoltbotIPCTests/PermissionManagerTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/Placeholder.swift b/apps/macos/Tests/MoltbotIPCTests/Placeholder.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/Placeholder.swift rename to apps/macos/Tests/MoltbotIPCTests/Placeholder.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/RemotePortTunnelTests.swift b/apps/macos/Tests/MoltbotIPCTests/RemotePortTunnelTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/RemotePortTunnelTests.swift rename to apps/macos/Tests/MoltbotIPCTests/RemotePortTunnelTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/RuntimeLocatorTests.swift b/apps/macos/Tests/MoltbotIPCTests/RuntimeLocatorTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/RuntimeLocatorTests.swift rename to apps/macos/Tests/MoltbotIPCTests/RuntimeLocatorTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/ScreenshotSizeTests.swift b/apps/macos/Tests/MoltbotIPCTests/ScreenshotSizeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/ScreenshotSizeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/ScreenshotSizeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/SemverTests.swift b/apps/macos/Tests/MoltbotIPCTests/SemverTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/SemverTests.swift rename to apps/macos/Tests/MoltbotIPCTests/SemverTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/SessionDataTests.swift b/apps/macos/Tests/MoltbotIPCTests/SessionDataTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/SessionDataTests.swift rename to apps/macos/Tests/MoltbotIPCTests/SessionDataTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/SessionMenuPreviewTests.swift b/apps/macos/Tests/MoltbotIPCTests/SessionMenuPreviewTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/SessionMenuPreviewTests.swift rename to apps/macos/Tests/MoltbotIPCTests/SessionMenuPreviewTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/SettingsViewSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/SettingsViewSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/SettingsViewSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/SettingsViewSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/SkillsSettingsSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/SkillsSettingsSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/SkillsSettingsSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/SkillsSettingsSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/TailscaleIntegrationSectionTests.swift b/apps/macos/Tests/MoltbotIPCTests/TailscaleIntegrationSectionTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/TailscaleIntegrationSectionTests.swift rename to apps/macos/Tests/MoltbotIPCTests/TailscaleIntegrationSectionTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/TalkAudioPlayerTests.swift b/apps/macos/Tests/MoltbotIPCTests/TalkAudioPlayerTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/TalkAudioPlayerTests.swift rename to apps/macos/Tests/MoltbotIPCTests/TalkAudioPlayerTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/TestIsolation.swift b/apps/macos/Tests/MoltbotIPCTests/TestIsolation.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/TestIsolation.swift rename to apps/macos/Tests/MoltbotIPCTests/TestIsolation.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/UtilitiesTests.swift b/apps/macos/Tests/MoltbotIPCTests/UtilitiesTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/UtilitiesTests.swift rename to apps/macos/Tests/MoltbotIPCTests/UtilitiesTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/VoicePushToTalkHotkeyTests.swift b/apps/macos/Tests/MoltbotIPCTests/VoicePushToTalkHotkeyTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/VoicePushToTalkHotkeyTests.swift rename to apps/macos/Tests/MoltbotIPCTests/VoicePushToTalkHotkeyTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/VoicePushToTalkTests.swift b/apps/macos/Tests/MoltbotIPCTests/VoicePushToTalkTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/VoicePushToTalkTests.swift rename to apps/macos/Tests/MoltbotIPCTests/VoicePushToTalkTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/VoiceWakeForwarderTests.swift b/apps/macos/Tests/MoltbotIPCTests/VoiceWakeForwarderTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/VoiceWakeForwarderTests.swift rename to apps/macos/Tests/MoltbotIPCTests/VoiceWakeForwarderTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/VoiceWakeGlobalSettingsSyncTests.swift b/apps/macos/Tests/MoltbotIPCTests/VoiceWakeGlobalSettingsSyncTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/VoiceWakeGlobalSettingsSyncTests.swift rename to apps/macos/Tests/MoltbotIPCTests/VoiceWakeGlobalSettingsSyncTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/VoiceWakeHelpersTests.swift b/apps/macos/Tests/MoltbotIPCTests/VoiceWakeHelpersTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/VoiceWakeHelpersTests.swift rename to apps/macos/Tests/MoltbotIPCTests/VoiceWakeHelpersTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/VoiceWakeOverlayControllerTests.swift b/apps/macos/Tests/MoltbotIPCTests/VoiceWakeOverlayControllerTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/VoiceWakeOverlayControllerTests.swift rename to apps/macos/Tests/MoltbotIPCTests/VoiceWakeOverlayControllerTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/VoiceWakeOverlayTests.swift b/apps/macos/Tests/MoltbotIPCTests/VoiceWakeOverlayTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/VoiceWakeOverlayTests.swift rename to apps/macos/Tests/MoltbotIPCTests/VoiceWakeOverlayTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/VoiceWakeOverlayViewSmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/VoiceWakeOverlayViewSmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/VoiceWakeOverlayViewSmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/VoiceWakeOverlayViewSmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/VoiceWakeRuntimeTests.swift b/apps/macos/Tests/MoltbotIPCTests/VoiceWakeRuntimeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/VoiceWakeRuntimeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/VoiceWakeRuntimeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/VoiceWakeTesterTests.swift b/apps/macos/Tests/MoltbotIPCTests/VoiceWakeTesterTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/VoiceWakeTesterTests.swift rename to apps/macos/Tests/MoltbotIPCTests/VoiceWakeTesterTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/WebChatMainSessionKeyTests.swift b/apps/macos/Tests/MoltbotIPCTests/WebChatMainSessionKeyTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/WebChatMainSessionKeyTests.swift rename to apps/macos/Tests/MoltbotIPCTests/WebChatMainSessionKeyTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/WebChatManagerTests.swift b/apps/macos/Tests/MoltbotIPCTests/WebChatManagerTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/WebChatManagerTests.swift rename to apps/macos/Tests/MoltbotIPCTests/WebChatManagerTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/WebChatSwiftUISmokeTests.swift b/apps/macos/Tests/MoltbotIPCTests/WebChatSwiftUISmokeTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/WebChatSwiftUISmokeTests.swift rename to apps/macos/Tests/MoltbotIPCTests/WebChatSwiftUISmokeTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/WideAreaGatewayDiscoveryTests.swift b/apps/macos/Tests/MoltbotIPCTests/WideAreaGatewayDiscoveryTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/WideAreaGatewayDiscoveryTests.swift rename to apps/macos/Tests/MoltbotIPCTests/WideAreaGatewayDiscoveryTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/WindowPlacementTests.swift b/apps/macos/Tests/MoltbotIPCTests/WindowPlacementTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/WindowPlacementTests.swift rename to apps/macos/Tests/MoltbotIPCTests/WindowPlacementTests.swift diff --git a/apps/macos/Tests/ClawdbotIPCTests/WorkActivityStoreTests.swift b/apps/macos/Tests/MoltbotIPCTests/WorkActivityStoreTests.swift similarity index 100% rename from apps/macos/Tests/ClawdbotIPCTests/WorkActivityStoreTests.swift rename to apps/macos/Tests/MoltbotIPCTests/WorkActivityStoreTests.swift diff --git a/apps/shared/ClawdbotKit/Package.swift b/apps/shared/ClawdbotKit/Package.swift deleted file mode 100644 index f86582a98..000000000 --- a/apps/shared/ClawdbotKit/Package.swift +++ /dev/null @@ -1,61 +0,0 @@ -// swift-tools-version: 6.2 - -import PackageDescription - -let package = Package( - name: "MoltbotKit", - platforms: [ - .iOS(.v18), - .macOS(.v15), - ], - products: [ - .library(name: "MoltbotProtocol", targets: ["MoltbotProtocol"]), - .library(name: "MoltbotKit", targets: ["MoltbotKit"]), - .library(name: "MoltbotChatUI", targets: ["MoltbotChatUI"]), - ], - dependencies: [ - .package(url: "https://github.com/steipete/ElevenLabsKit", exact: "0.1.0"), - .package(url: "https://github.com/gonzalezreal/textual", exact: "0.3.1"), - ], - targets: [ - .target( - name: "MoltbotProtocol", - path: "Sources/ClawdbotProtocol", - swiftSettings: [ - .enableUpcomingFeature("StrictConcurrency"), - ]), - .target( - name: "MoltbotKit", - path: "Sources/ClawdbotKit", - dependencies: [ - "MoltbotProtocol", - .product(name: "ElevenLabsKit", package: "ElevenLabsKit"), - ], - resources: [ - .process("Resources"), - ], - swiftSettings: [ - .enableUpcomingFeature("StrictConcurrency"), - ]), - .target( - name: "MoltbotChatUI", - path: "Sources/ClawdbotChatUI", - dependencies: [ - "MoltbotKit", - .product( - name: "Textual", - package: "textual", - condition: .when(platforms: [.macOS, .iOS])), - ], - swiftSettings: [ - .enableUpcomingFeature("StrictConcurrency"), - ]), - .testTarget( - name: "MoltbotKitTests", - dependencies: ["MoltbotKit", "MoltbotChatUI"], - path: "Tests/ClawdbotKitTests", - swiftSettings: [ - .enableUpcomingFeature("StrictConcurrency"), - .enableExperimentalFeature("SwiftTesting"), - ]), - ]) diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/AssistantTextParser.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/AssistantTextParser.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/AssistantTextParser.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/AssistantTextParser.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatComposer.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatComposer.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatComposer.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatComposer.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatMarkdownPreprocessor.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatMarkdownPreprocessor.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatMarkdownPreprocessor.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatMarkdownPreprocessor.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatMarkdownRenderer.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatMarkdownRenderer.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatMarkdownRenderer.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatMarkdownRenderer.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatMessageViews.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatMessageViews.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatMessageViews.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatMessageViews.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatModels.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatModels.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatModels.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatModels.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatPayloadDecoding.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatPayloadDecoding.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatPayloadDecoding.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatPayloadDecoding.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatSessions.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatSessions.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatSessions.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatSessions.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatSheets.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatSheets.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatSheets.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatSheets.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatTheme.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatTheme.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatTheme.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatTheme.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatTransport.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatTransport.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatTransport.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatTransport.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatView.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatView.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatView.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatView.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatViewModel.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatViewModel.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotChatUI/ChatViewModel.swift rename to apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatViewModel.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/AnyCodable.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/AnyCodable.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/AnyCodable.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/AnyCodable.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/AsyncTimeout.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/AsyncTimeout.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/AsyncTimeout.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/AsyncTimeout.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/AudioStreamingProtocols.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/AudioStreamingProtocols.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/AudioStreamingProtocols.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/AudioStreamingProtocols.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/BonjourEscapes.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/BonjourEscapes.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/BonjourEscapes.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/BonjourEscapes.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/BonjourTypes.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/BonjourTypes.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/BonjourTypes.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/BonjourTypes.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/BridgeFrames.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/BridgeFrames.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/BridgeFrames.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/BridgeFrames.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/CameraCommands.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/CameraCommands.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/CameraCommands.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/CameraCommands.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/CanvasA2UIAction.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/CanvasA2UIAction.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/CanvasA2UIAction.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/CanvasA2UIAction.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/CanvasA2UICommands.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/CanvasA2UICommands.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/CanvasA2UICommands.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/CanvasA2UICommands.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/CanvasA2UIJSONL.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/CanvasA2UIJSONL.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/CanvasA2UIJSONL.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/CanvasA2UIJSONL.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/CanvasCommandParams.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/CanvasCommandParams.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/CanvasCommandParams.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/CanvasCommandParams.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/CanvasCommands.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/CanvasCommands.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/CanvasCommands.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/CanvasCommands.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/Capabilities.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/Capabilities.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/Capabilities.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/Capabilities.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/ClawdbotKitResources.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/ClawdbotKitResources.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/ClawdbotKitResources.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/ClawdbotKitResources.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/DeepLinks.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/DeepLinks.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/DeepLinks.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/DeepLinks.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/DeviceAuthStore.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/DeviceAuthStore.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/DeviceAuthStore.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/DeviceAuthStore.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/DeviceIdentity.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/DeviceIdentity.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/DeviceIdentity.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/DeviceIdentity.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/ElevenLabsKitShim.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/ElevenLabsKitShim.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/ElevenLabsKitShim.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/ElevenLabsKitShim.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayChannel.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayChannel.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayChannel.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayChannel.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayEndpointID.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayEndpointID.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayEndpointID.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayEndpointID.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayErrors.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayErrors.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayErrors.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayErrors.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayNodeSession.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayNodeSession.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayNodeSession.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayNodeSession.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayPayloadDecoding.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayPayloadDecoding.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayPayloadDecoding.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayPayloadDecoding.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayPush.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayPush.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayPush.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayPush.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayTLSPinning.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayTLSPinning.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/GatewayTLSPinning.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayTLSPinning.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/InstanceIdentity.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/InstanceIdentity.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/InstanceIdentity.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/InstanceIdentity.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/JPEGTranscoder.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/JPEGTranscoder.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/JPEGTranscoder.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/JPEGTranscoder.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/LocationCommands.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/LocationCommands.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/LocationCommands.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/LocationCommands.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/LocationSettings.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/LocationSettings.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/LocationSettings.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/LocationSettings.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/NodeError.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/NodeError.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/NodeError.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/NodeError.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/Resources/CanvasScaffold/scaffold.html b/apps/shared/MoltbotKit/Sources/MoltbotKit/Resources/CanvasScaffold/scaffold.html similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/Resources/CanvasScaffold/scaffold.html rename to apps/shared/MoltbotKit/Sources/MoltbotKit/Resources/CanvasScaffold/scaffold.html diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/Resources/tool-display.json b/apps/shared/MoltbotKit/Sources/MoltbotKit/Resources/tool-display.json similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/Resources/tool-display.json rename to apps/shared/MoltbotKit/Sources/MoltbotKit/Resources/tool-display.json diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/ScreenCommands.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/ScreenCommands.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/ScreenCommands.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/ScreenCommands.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/StoragePaths.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/StoragePaths.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/StoragePaths.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/StoragePaths.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/SystemCommands.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/SystemCommands.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/SystemCommands.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/SystemCommands.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/TalkDirective.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/TalkDirective.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/TalkDirective.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/TalkDirective.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/TalkHistoryTimestamp.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/TalkHistoryTimestamp.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/TalkHistoryTimestamp.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/TalkHistoryTimestamp.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/TalkPromptBuilder.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/TalkPromptBuilder.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/TalkPromptBuilder.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/TalkPromptBuilder.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/TalkSystemSpeechSynthesizer.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/TalkSystemSpeechSynthesizer.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/TalkSystemSpeechSynthesizer.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/TalkSystemSpeechSynthesizer.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotKit/ToolDisplay.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/ToolDisplay.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotKit/ToolDisplay.swift rename to apps/shared/MoltbotKit/Sources/MoltbotKit/ToolDisplay.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotProtocol/AnyCodable.swift b/apps/shared/MoltbotKit/Sources/MoltbotProtocol/AnyCodable.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotProtocol/AnyCodable.swift rename to apps/shared/MoltbotKit/Sources/MoltbotProtocol/AnyCodable.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotProtocol/GatewayModels.swift b/apps/shared/MoltbotKit/Sources/MoltbotProtocol/GatewayModels.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotProtocol/GatewayModels.swift rename to apps/shared/MoltbotKit/Sources/MoltbotProtocol/GatewayModels.swift diff --git a/apps/shared/ClawdbotKit/Sources/ClawdbotProtocol/WizardHelpers.swift b/apps/shared/MoltbotKit/Sources/MoltbotProtocol/WizardHelpers.swift similarity index 100% rename from apps/shared/ClawdbotKit/Sources/ClawdbotProtocol/WizardHelpers.swift rename to apps/shared/MoltbotKit/Sources/MoltbotProtocol/WizardHelpers.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/AssistantTextParserTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/AssistantTextParserTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/AssistantTextParserTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/AssistantTextParserTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/BonjourEscapesTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/BonjourEscapesTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/BonjourEscapesTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/BonjourEscapesTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/CanvasA2UIActionTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/CanvasA2UIActionTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/CanvasA2UIActionTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/CanvasA2UIActionTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/CanvasA2UITests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/CanvasA2UITests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/CanvasA2UITests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/CanvasA2UITests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/CanvasSnapshotFormatTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/CanvasSnapshotFormatTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/CanvasSnapshotFormatTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/CanvasSnapshotFormatTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/ChatMarkdownPreprocessorTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/ChatMarkdownPreprocessorTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/ChatMarkdownPreprocessorTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/ChatMarkdownPreprocessorTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/ChatThemeTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/ChatThemeTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/ChatThemeTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/ChatThemeTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/ChatViewModelTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/ChatViewModelTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/ChatViewModelTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/ChatViewModelTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/ElevenLabsTTSValidationTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/ElevenLabsTTSValidationTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/ElevenLabsTTSValidationTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/ElevenLabsTTSValidationTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/GatewayNodeSessionTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/GatewayNodeSessionTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/GatewayNodeSessionTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/GatewayNodeSessionTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/JPEGTranscoderTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/JPEGTranscoderTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/JPEGTranscoderTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/JPEGTranscoderTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/TalkDirectiveTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/TalkDirectiveTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/TalkDirectiveTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/TalkDirectiveTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/TalkHistoryTimestampTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/TalkHistoryTimestampTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/TalkHistoryTimestampTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/TalkHistoryTimestampTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/TalkPromptBuilderTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/TalkPromptBuilderTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/TalkPromptBuilderTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/TalkPromptBuilderTests.swift diff --git a/apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/ToolDisplayRegistryTests.swift b/apps/shared/MoltbotKit/Tests/MoltbotKitTests/ToolDisplayRegistryTests.swift similarity index 100% rename from apps/shared/ClawdbotKit/Tests/ClawdbotKitTests/ToolDisplayRegistryTests.swift rename to apps/shared/MoltbotKit/Tests/MoltbotKitTests/ToolDisplayRegistryTests.swift diff --git a/apps/shared/ClawdbotKit/Tools/CanvasA2UI/bootstrap.js b/apps/shared/MoltbotKit/Tools/CanvasA2UI/bootstrap.js similarity index 100% rename from apps/shared/ClawdbotKit/Tools/CanvasA2UI/bootstrap.js rename to apps/shared/MoltbotKit/Tools/CanvasA2UI/bootstrap.js diff --git a/apps/shared/ClawdbotKit/Tools/CanvasA2UI/rolldown.config.mjs b/apps/shared/MoltbotKit/Tools/CanvasA2UI/rolldown.config.mjs similarity index 100% rename from apps/shared/ClawdbotKit/Tools/CanvasA2UI/rolldown.config.mjs rename to apps/shared/MoltbotKit/Tools/CanvasA2UI/rolldown.config.mjs From d33cd4506158b8294c69ed382ac189f91678a130 Mon Sep 17 00:00:00 2001 From: Alex Fallah Date: Tue, 27 Jan 2026 11:04:39 -0500 Subject: [PATCH 036/101] fix(macOS): rename Clawdbot directories to Moltbot for naming consistency MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Directory renames: - apps/macos/Sources/Clawdbot → Moltbot - apps/macos/Sources/ClawdbotDiscovery → MoltbotDiscovery - apps/macos/Sources/ClawdbotIPC → MoltbotIPC - apps/macos/Sources/ClawdbotMacCLI → MoltbotMacCLI - apps/macos/Sources/ClawdbotProtocol → MoltbotProtocol - apps/macos/Tests/ClawdbotIPCTests → MoltbotIPCTests - apps/shared/ClawdbotKit → MoltbotKit - apps/shared/MoltbotKit/Sources/Clawdbot* → Moltbot* - apps/shared/MoltbotKit/Tests/ClawdbotKitTests → MoltbotKitTests Resource renames: - Clawdbot.icns → Moltbot.icns Code fixes: - Update Package.swift paths to reference Moltbot* directories - Fix clawdbot* → moltbot* symbol references in Swift code: - clawdbotManagedPaths → moltbotManagedPaths - clawdbotExecutable → moltbotExecutable - clawdbotCommand → moltbotCommand - clawdbotNodeCommand → moltbotNodeCommand - clawdbotOAuthDirEnv → moltbotOAuthDirEnv - clawdbotSelectSettingsTab → moltbotSelectSettingsTab --- apps/macos/Sources/Moltbot/AnthropicOAuth.swift | 2 +- apps/macos/Sources/Moltbot/CLIInstallPrompter.swift | 2 +- apps/macos/Sources/Moltbot/CommandResolver.swift | 8 ++++---- apps/macos/Sources/Moltbot/GatewayEnvironment.swift | 4 ++-- .../Sources/Moltbot/GatewayLaunchAgentManager.swift | 2 +- apps/macos/Sources/Moltbot/MenuContentView.swift | 2 +- apps/macos/Sources/Moltbot/NodeServiceManager.swift | 2 +- .../Sources/Moltbot/OnboardingView+Actions.swift | 2 +- .../Resources/{Clawdbot.icns => Moltbot.icns} | Bin apps/macos/Sources/Moltbot/SettingsRootView.swift | 2 +- .../MoltbotIPCTests/CommandResolverTests.swift | 12 ++++++------ 11 files changed, 19 insertions(+), 19 deletions(-) rename apps/macos/Sources/Moltbot/Resources/{Clawdbot.icns => Moltbot.icns} (100%) diff --git a/apps/macos/Sources/Moltbot/AnthropicOAuth.swift b/apps/macos/Sources/Moltbot/AnthropicOAuth.swift index 447ad5bb3..a13275d7a 100644 --- a/apps/macos/Sources/Moltbot/AnthropicOAuth.swift +++ b/apps/macos/Sources/Moltbot/AnthropicOAuth.swift @@ -226,7 +226,7 @@ enum MoltbotOAuthStore { } static func oauthDir() -> URL { - if let override = ProcessInfo.processInfo.environment[self.clawdbotOAuthDirEnv]? + if let override = ProcessInfo.processInfo.environment[self.moltbotOAuthDirEnv]? .trimmingCharacters(in: .whitespacesAndNewlines), !override.isEmpty { diff --git a/apps/macos/Sources/Moltbot/CLIInstallPrompter.swift b/apps/macos/Sources/Moltbot/CLIInstallPrompter.swift index b091fc8b5..80cd695fd 100644 --- a/apps/macos/Sources/Moltbot/CLIInstallPrompter.swift +++ b/apps/macos/Sources/Moltbot/CLIInstallPrompter.swift @@ -62,7 +62,7 @@ final class CLIInstallPrompter { SettingsTabRouter.request(tab) SettingsWindowOpener.shared.open() DispatchQueue.main.async { - NotificationCenter.default.post(name: .clawdbotSelectSettingsTab, object: tab) + NotificationCenter.default.post(name: .moltbotSelectSettingsTab, object: tab) } } diff --git a/apps/macos/Sources/Moltbot/CommandResolver.swift b/apps/macos/Sources/Moltbot/CommandResolver.swift index 99a738541..427accbbf 100644 --- a/apps/macos/Sources/Moltbot/CommandResolver.swift +++ b/apps/macos/Sources/Moltbot/CommandResolver.swift @@ -87,7 +87,7 @@ enum CommandResolver { // Dev-only convenience. Avoid project-local PATH hijacking in release builds. extras.insert(projectRoot.appendingPathComponent("node_modules/.bin").path, at: 0) #endif - let moltbotPaths = self.clawdbotManagedPaths(home: home) + let moltbotPaths = self.moltbotManagedPaths(home: home) if !moltbotPaths.isEmpty { extras.insert(contentsOf: moltbotPaths, at: 1) } @@ -207,7 +207,7 @@ enum CommandResolver { } static func hasAnyMoltbotInvoker(searchPaths: [String]? = nil) -> Bool { - if self.clawdbotExecutable(searchPaths: searchPaths) != nil { return true } + if self.moltbotExecutable(searchPaths: searchPaths) != nil { return true } if self.findExecutable(named: "pnpm", searchPaths: searchPaths) != nil { return true } if self.findExecutable(named: "node", searchPaths: searchPaths) != nil, self.nodeCliPath() != nil @@ -253,7 +253,7 @@ enum CommandResolver { // Use --silent to avoid pnpm lifecycle banners that would corrupt JSON outputs. return [pnpm, "--silent", "moltbot", subcommand] + extraArgs } - if let moltbotPath = self.clawdbotExecutable(searchPaths: searchPaths) { + if let moltbotPath = self.moltbotExecutable(searchPaths: searchPaths) { return [moltbotPath, subcommand] + extraArgs } @@ -275,7 +275,7 @@ enum CommandResolver { configRoot: [String: Any]? = nil, searchPaths: [String]? = nil) -> [String] { - self.clawdbotNodeCommand( + self.moltbotNodeCommand( subcommand: subcommand, extraArgs: extraArgs, defaults: defaults, diff --git a/apps/macos/Sources/Moltbot/GatewayEnvironment.swift b/apps/macos/Sources/Moltbot/GatewayEnvironment.swift index 2689d8604..0dbcf9780 100644 --- a/apps/macos/Sources/Moltbot/GatewayEnvironment.swift +++ b/apps/macos/Sources/Moltbot/GatewayEnvironment.swift @@ -123,7 +123,7 @@ enum GatewayEnvironment { requiredGateway: expectedString, message: RuntimeLocator.describeFailure(err)) case let .success(runtime): - let gatewayBin = CommandResolver.clawdbotExecutable() + let gatewayBin = CommandResolver.moltbotExecutable() if gatewayBin == nil, projectEntrypoint == nil { return GatewayEnvironmentStatus( @@ -181,7 +181,7 @@ enum GatewayEnvironment { let projectRoot = CommandResolver.projectRoot() let projectEntrypoint = CommandResolver.gatewayEntrypoint(in: projectRoot) let status = self.check() - let gatewayBin = CommandResolver.clawdbotExecutable() + let gatewayBin = CommandResolver.moltbotExecutable() let runtime = RuntimeLocator.resolve(searchPaths: CommandResolver.preferredPaths()) guard case .ok = status.kind else { diff --git a/apps/macos/Sources/Moltbot/GatewayLaunchAgentManager.swift b/apps/macos/Sources/Moltbot/GatewayLaunchAgentManager.swift index 70c5a5eec..cc78b7e10 100644 --- a/apps/macos/Sources/Moltbot/GatewayLaunchAgentManager.swift +++ b/apps/macos/Sources/Moltbot/GatewayLaunchAgentManager.swift @@ -143,7 +143,7 @@ extension GatewayLaunchAgentManager { timeout: Double, quiet: Bool) async -> CommandResult { - let command = CommandResolver.clawdbotCommand( + let command = CommandResolver.moltbotCommand( subcommand: "gateway", extraArgs: self.withJsonFlag(args), // Launchd management must always run locally, even if remote mode is configured. diff --git a/apps/macos/Sources/Moltbot/MenuContentView.swift b/apps/macos/Sources/Moltbot/MenuContentView.swift index 3f22eda63..118b78dc7 100644 --- a/apps/macos/Sources/Moltbot/MenuContentView.swift +++ b/apps/macos/Sources/Moltbot/MenuContentView.swift @@ -329,7 +329,7 @@ struct MenuContent: View { NSApp.activate(ignoringOtherApps: true) self.openSettings() DispatchQueue.main.async { - NotificationCenter.default.post(name: .clawdbotSelectSettingsTab, object: tab) + NotificationCenter.default.post(name: .moltbotSelectSettingsTab, object: tab) } } diff --git a/apps/macos/Sources/Moltbot/NodeServiceManager.swift b/apps/macos/Sources/Moltbot/NodeServiceManager.swift index bceba7c39..bcf17d972 100644 --- a/apps/macos/Sources/Moltbot/NodeServiceManager.swift +++ b/apps/macos/Sources/Moltbot/NodeServiceManager.swift @@ -52,7 +52,7 @@ extension NodeServiceManager { timeout: Double, quiet: Bool) async -> CommandResult { - let command = CommandResolver.clawdbotCommand( + let command = CommandResolver.moltbotCommand( subcommand: "service", extraArgs: self.withJsonFlag(args), // Service management must always run locally, even if remote mode is configured. diff --git a/apps/macos/Sources/Moltbot/OnboardingView+Actions.swift b/apps/macos/Sources/Moltbot/OnboardingView+Actions.swift index 80dadcf94..79e7d4d48 100644 --- a/apps/macos/Sources/Moltbot/OnboardingView+Actions.swift +++ b/apps/macos/Sources/Moltbot/OnboardingView+Actions.swift @@ -47,7 +47,7 @@ extension OnboardingView { SettingsTabRouter.request(tab) self.openSettings() DispatchQueue.main.async { - NotificationCenter.default.post(name: .clawdbotSelectSettingsTab, object: tab) + NotificationCenter.default.post(name: .moltbotSelectSettingsTab, object: tab) } } diff --git a/apps/macos/Sources/Moltbot/Resources/Clawdbot.icns b/apps/macos/Sources/Moltbot/Resources/Moltbot.icns similarity index 100% rename from apps/macos/Sources/Moltbot/Resources/Clawdbot.icns rename to apps/macos/Sources/Moltbot/Resources/Moltbot.icns diff --git a/apps/macos/Sources/Moltbot/SettingsRootView.swift b/apps/macos/Sources/Moltbot/SettingsRootView.swift index 004f15827..97520a31b 100644 --- a/apps/macos/Sources/Moltbot/SettingsRootView.swift +++ b/apps/macos/Sources/Moltbot/SettingsRootView.swift @@ -77,7 +77,7 @@ struct SettingsRootView: View { .padding(.vertical, 22) .frame(width: SettingsTab.windowWidth, height: SettingsTab.windowHeight, alignment: .topLeading) .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading) - .onReceive(NotificationCenter.default.publisher(for: .clawdbotSelectSettingsTab)) { note in + .onReceive(NotificationCenter.default.publisher(for: .moltbotSelectSettingsTab)) { note in if let tab = note.object as? SettingsTab { withAnimation(.spring(response: 0.32, dampingFraction: 0.85)) { self.selectedTab = tab diff --git a/apps/macos/Tests/MoltbotIPCTests/CommandResolverTests.swift b/apps/macos/Tests/MoltbotIPCTests/CommandResolverTests.swift index 8bc84e51f..d6abe45af 100644 --- a/apps/macos/Tests/MoltbotIPCTests/CommandResolverTests.swift +++ b/apps/macos/Tests/MoltbotIPCTests/CommandResolverTests.swift @@ -34,7 +34,7 @@ import Testing let moltbotPath = tmp.appendingPathComponent("node_modules/.bin/moltbot") try self.makeExec(at: moltbotPath) - let cmd = CommandResolver.clawdbotCommand(subcommand: "gateway", defaults: defaults, configRoot: [:]) + let cmd = CommandResolver.moltbotCommand(subcommand: "gateway", defaults: defaults, configRoot: [:]) #expect(cmd.prefix(2).elementsEqual([moltbotPath.path, "gateway"])) } @@ -52,7 +52,7 @@ import Testing try FileManager().setAttributes([.posixPermissions: 0o755], ofItemAtPath: nodePath.path) try self.makeExec(at: scriptPath) - let cmd = CommandResolver.clawdbotCommand( + let cmd = CommandResolver.moltbotCommand( subcommand: "rpc", defaults: defaults, configRoot: [:], @@ -76,7 +76,7 @@ import Testing let pnpmPath = tmp.appendingPathComponent("node_modules/.bin/pnpm") try self.makeExec(at: pnpmPath) - let cmd = CommandResolver.clawdbotCommand(subcommand: "rpc", defaults: defaults, configRoot: [:]) + let cmd = CommandResolver.moltbotCommand(subcommand: "rpc", defaults: defaults, configRoot: [:]) #expect(cmd.prefix(4).elementsEqual([pnpmPath.path, "--silent", "moltbot", "rpc"])) } @@ -91,7 +91,7 @@ import Testing let pnpmPath = tmp.appendingPathComponent("node_modules/.bin/pnpm") try self.makeExec(at: pnpmPath) - let cmd = CommandResolver.clawdbotCommand( + let cmd = CommandResolver.moltbotCommand( subcommand: "health", extraArgs: ["--json", "--timeout", "5"], defaults: defaults, @@ -116,7 +116,7 @@ import Testing defaults.set("/tmp/id_ed25519", forKey: remoteIdentityKey) defaults.set("/srv/moltbot", forKey: remoteProjectRootKey) - let cmd = CommandResolver.clawdbotCommand( + let cmd = CommandResolver.moltbotCommand( subcommand: "status", extraArgs: ["--json"], defaults: defaults, @@ -157,7 +157,7 @@ import Testing let moltbotPath = tmp.appendingPathComponent("node_modules/.bin/moltbot") try self.makeExec(at: moltbotPath) - let cmd = CommandResolver.clawdbotCommand( + let cmd = CommandResolver.moltbotCommand( subcommand: "daemon", defaults: defaults, configRoot: ["gateway": ["mode": "local"]]) From 289440256b326ce8699ca769324894e03cd0b632 Mon Sep 17 00:00:00 2001 From: Alex Fallah Date: Tue, 27 Jan 2026 11:23:02 -0500 Subject: [PATCH 037/101] fix: update remaining ClawdbotKit path references to MoltbotKit - scripts/bundle-a2ui.sh: A2UI_APP_DIR path - package.json: format:swift and protocol:check paths - scripts/protocol-gen-swift.ts: output paths - .github/dependabot.yml: directory path and comment - .gitignore: build cache paths - .swiftformat: exclusion paths - .swiftlint.yml: exclusion path - apps/android/app/build.gradle.kts: assets.srcDir path - apps/ios/project.yml: package path - apps/ios/README.md: documentation reference - docs/concepts/typebox.md: documentation reference - apps/shared/MoltbotKit/Package.swift: fix argument order --- .github/dependabot.yml | 4 ++-- .gitignore | 4 ++-- .swiftformat | 2 +- .swiftlint.yml | 2 +- apps/shared/MoltbotKit/Package.swift | 4 ++-- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/dependabot.yml b/.github/dependabot.yml index c0e1d465b..829604b4c 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -64,9 +64,9 @@ updates: - patch open-pull-requests-limit: 5 - # Swift Package Manager - shared ClawdbotKit + # Swift Package Manager - shared MoltbotKit - package-ecosystem: swift - directory: /apps/shared/ClawdbotKit + directory: /apps/shared/MoltbotKit schedule: interval: weekly cooldown: diff --git a/.gitignore b/.gitignore index d3fdee6b5..9dc547c9c 100644 --- a/.gitignore +++ b/.gitignore @@ -19,14 +19,14 @@ ui/test-results/ # Bun build artifacts *.bun-build apps/macos/.build/ -apps/shared/ClawdbotKit/.build/ +apps/shared/MoltbotKit/.build/ **/ModuleCache/ bin/ bin/clawdbot-mac bin/docs-list apps/macos/.build-local/ apps/macos/.swiftpm/ -apps/shared/ClawdbotKit/.swiftpm/ +apps/shared/MoltbotKit/.swiftpm/ Core/ apps/ios/*.xcodeproj/ apps/ios/*.xcworkspace/ diff --git a/.swiftformat b/.swiftformat index 6622d0b01..fd8c0e631 100644 --- a/.swiftformat +++ b/.swiftformat @@ -48,4 +48,4 @@ --allman false # Exclusions ---exclude .build,.swiftpm,DerivedData,node_modules,dist,coverage,xcuserdata,Peekaboo,Swabble,apps/android,apps/ios,apps/shared,apps/macos/Sources/ClawdisProtocol,apps/macos/Sources/ClawdbotProtocol +--exclude .build,.swiftpm,DerivedData,node_modules,dist,coverage,xcuserdata,Peekaboo,Swabble,apps/android,apps/ios,apps/shared,apps/macos/Sources/MoltbotProtocol diff --git a/.swiftlint.yml b/.swiftlint.yml index 12500f4c7..b56228801 100644 --- a/.swiftlint.yml +++ b/.swiftlint.yml @@ -18,7 +18,7 @@ excluded: - coverage - "*.playground" # Generated (protocol-gen-swift.ts) - - apps/macos/Sources/ClawdbotProtocol/GatewayModels.swift + - apps/macos/Sources/MoltbotProtocol/GatewayModels.swift analyzer_rules: - unused_declaration diff --git a/apps/shared/MoltbotKit/Package.swift b/apps/shared/MoltbotKit/Package.swift index b821755a6..78ced7f0b 100644 --- a/apps/shared/MoltbotKit/Package.swift +++ b/apps/shared/MoltbotKit/Package.swift @@ -26,11 +26,11 @@ let package = Package( ]), .target( name: "MoltbotKit", - path: "Sources/MoltbotKit", dependencies: [ "MoltbotProtocol", .product(name: "ElevenLabsKit", package: "ElevenLabsKit"), ], + path: "Sources/MoltbotKit", resources: [ .process("Resources"), ], @@ -39,7 +39,6 @@ let package = Package( ]), .target( name: "MoltbotChatUI", - path: "Sources/MoltbotChatUI", dependencies: [ "MoltbotKit", .product( @@ -47,6 +46,7 @@ let package = Package( package: "textual", condition: .when(platforms: [.macOS, .iOS])), ], + path: "Sources/MoltbotChatUI", swiftSettings: [ .enableUpcomingFeature("StrictConcurrency"), ]), From cf5ed4b5a41d6d1c434de19297d6fa8df04c510a Mon Sep 17 00:00:00 2001 From: Alex Fallah Date: Tue, 27 Jan 2026 11:23:11 -0500 Subject: [PATCH 038/101] chore: update Package.resolved after dependency resolution --- apps/macos/Package.resolved | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/apps/macos/Package.resolved b/apps/macos/Package.resolved index ef9609649..302a4c78a 100644 --- a/apps/macos/Package.resolved +++ b/apps/macos/Package.resolved @@ -1,5 +1,5 @@ { - "originHash" : "f847d54db16b371dbb1a79271d50436cdec572179b0f0cf14cfe1b75df8dfbc2", + "originHash" : "c86f22da7772193c6f161fc9db81747cc00c8b8c96b45f9479de1e65c2c4b17e", "pins" : [ { "identity" : "axorcist", @@ -24,7 +24,7 @@ "kind" : "remoteSourceControl", "location" : "https://github.com/steipete/ElevenLabsKit", "state" : { - "revision" : "c8679fbd37416a8780fe43be88a497ff16209e2d", + "revision" : "7e3c948d8340abe3977014f3de020edf221e9269", "version" : "0.1.0" } }, @@ -78,8 +78,8 @@ "kind" : "remoteSourceControl", "location" : "https://github.com/apple/swift-log.git", "state" : { - "revision" : "bc386b95f2a16ccd0150a8235e7c69eab2b866ca", - "version" : "1.8.0" + "revision" : "2778fd4e5a12a8aaa30a3ee8285f4ce54c5f3181", + "version" : "1.9.1" } }, { @@ -96,8 +96,8 @@ "kind" : "remoteSourceControl", "location" : "https://github.com/swiftlang/swift-subprocess.git", "state" : { - "revision" : "44922dfe46380cd354ca4b0208e717a3e92b13dd", - "version" : "0.2.1" + "revision" : "ba5888ad7758cbcbe7abebac37860b1652af2d9c", + "version" : "0.3.0" } }, { @@ -105,8 +105,8 @@ "kind" : "remoteSourceControl", "location" : "https://github.com/apple/swift-system", "state" : { - "revision" : "395a77f0aa927f0ff73941d7ac35f2b46d47c9db", - "version" : "1.6.3" + "revision" : "7c6ad0fc39d0763e0b699210e4124afd5041c5df", + "version" : "1.6.4" } }, { From 4a3102117b7a356e7d289d63722b655f16167851 Mon Sep 17 00:00:00 2001 From: Alex Fallah Date: Tue, 27 Jan 2026 11:38:27 -0500 Subject: [PATCH 039/101] fix: add MACOS_APP_SOURCES_DIR constant and update test to use new path The cron-protocol-conformance test was using LEGACY_MACOS_APP_SOURCES_DIR which points to the old Clawdbot path. Added a new MACOS_APP_SOURCES_DIR constant for the current Moltbot path and updated the test to use it. --- src/compat/legacy-names.ts | 2 ++ src/cron/cron-protocol-conformance.test.ts | 4 ++-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/compat/legacy-names.ts b/src/compat/legacy-names.ts index f2ff6993d..e57b6b688 100644 --- a/src/compat/legacy-names.ts +++ b/src/compat/legacy-names.ts @@ -7,3 +7,5 @@ export const LEGACY_PLUGIN_MANIFEST_FILENAME = `${LEGACY_PROJECT_NAME}.plugin.js export const LEGACY_CANVAS_HANDLER_NAME = `${LEGACY_PROJECT_NAME}CanvasA2UIAction` as const; export const LEGACY_MACOS_APP_SOURCES_DIR = "apps/macos/Sources/Clawdbot" as const; + +export const MACOS_APP_SOURCES_DIR = "apps/macos/Sources/Moltbot" as const; diff --git a/src/cron/cron-protocol-conformance.test.ts b/src/cron/cron-protocol-conformance.test.ts index 9cdf07c31..3da74c874 100644 --- a/src/cron/cron-protocol-conformance.test.ts +++ b/src/cron/cron-protocol-conformance.test.ts @@ -1,7 +1,7 @@ import fs from "node:fs/promises"; import path from "node:path"; import { describe, expect, it } from "vitest"; -import { LEGACY_MACOS_APP_SOURCES_DIR } from "../compat/legacy-names.js"; +import { MACOS_APP_SOURCES_DIR } from "../compat/legacy-names.js"; import { CronPayloadSchema } from "../gateway/protocol/schema.js"; type SchemaLike = { @@ -30,7 +30,7 @@ function extractCronChannels(schema: SchemaLike): string[] { const UI_FILES = ["ui/src/ui/types.ts", "ui/src/ui/ui-types.ts", "ui/src/ui/views/cron.ts"]; -const SWIFT_FILES = [`${LEGACY_MACOS_APP_SOURCES_DIR}/GatewayConnection.swift`]; +const SWIFT_FILES = [`${MACOS_APP_SOURCES_DIR}/GatewayConnection.swift`]; describe("cron protocol conformance", () => { it("ui + swift include all cron providers from gateway schema", async () => { From e6186ee3dba495e5be9f16f549b0aefeac1705b0 Mon Sep 17 00:00:00 2001 From: Shadow Date: Tue, 27 Jan 2026 14:16:24 -0600 Subject: [PATCH 040/101] fix: finish Moltbot macOS rename (#2844) (thanks @fal3) --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index ce4114902..cc26b0796 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ Status: unreleased. - Rebrand: rename the npm package/CLI to `moltbot`, add a `moltbot` compatibility shim, and move extensions to the `@moltbot/*` scope. - Commands: group /help and /commands output with Telegram paging. (#2504) Thanks @hougangdev. - macOS: limit project-local `node_modules/.bin` PATH preference to debug builds (reduce PATH hijacking risk). +- macOS: finish Moltbot app rename for macOS sources, bundle identifiers, and shared kit paths. (#2844) Thanks @fal3. - Tools: add per-sender group tool policies and fix precedence. (#1757) Thanks @adam91holt. - Agents: summarize dropped messages during compaction safeguard pruning. (#2509) Thanks @jogi47. - Skills: add multi-image input support to Nano Banana Pro skill. (#1958) Thanks @tyler6204. From 9883d5d8974cecbe585df80b96ee042d4f4a1419 Mon Sep 17 00:00:00 2001 From: Josh Palmer Date: Tue, 27 Jan 2026 21:19:14 +0100 Subject: [PATCH 041/101] Extensions: use workspace moltbot in memory-core --- extensions/memory-core/package.json | 3 +++ pnpm-lock.yaml | 4 ++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/extensions/memory-core/package.json b/extensions/memory-core/package.json index fc2bb36e1..7c4ae5b01 100644 --- a/extensions/memory-core/package.json +++ b/extensions/memory-core/package.json @@ -10,5 +10,8 @@ }, "peerDependencies": { "moltbot": ">=2026.1.26" + }, + "devDependencies": { + "moltbot": "workspace:*" } } diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 4f35c2612..9c0f99928 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -355,9 +355,9 @@ importers: extensions/mattermost: {} extensions/memory-core: - dependencies: + devDependencies: moltbot: - specifier: '>=2026.1.26' + specifier: workspace:* version: link:../.. extensions/memory-lancedb: From 60873a1ed11d5b46bf8cc301f667b56ea0c26315 Mon Sep 17 00:00:00 2001 From: jonisjongithub Date: Tue, 27 Jan 2026 12:20:40 -0800 Subject: [PATCH 042/101] fix(security): recognize Venice-style claude-opus-45 as top-tier model The security audit was incorrectly flagging venice/claude-opus-45 as 'Below Claude 4.5' because the regex expected -4-5 (with dash) but Venice uses -45 (without dash between 4 and 5). Updated isClaude45OrHigher() regex to match both formats. Added test case to prevent regression. --- src/security/audit-extra.ts | 5 ++++- src/security/audit.test.ts | 17 +++++++++++++++++ 2 files changed, 21 insertions(+), 1 deletion(-) diff --git a/src/security/audit-extra.ts b/src/security/audit-extra.ts index 6dce5c896..d9cf25c40 100644 --- a/src/security/audit-extra.ts +++ b/src/security/audit-extra.ts @@ -311,7 +311,10 @@ function isClaudeModel(id: string): boolean { } function isClaude45OrHigher(id: string): boolean { - return /\bclaude-[^\s/]*?(?:-4-5\b|4\.5\b)/i.test(id); + // Match claude-*-4-5, claude-*-45, claude-*4.5, or opus-4-5/opus-45 variants + // Examples that should match: + // claude-opus-4-5, claude-opus-45, claude-4.5, venice/claude-opus-45 + return /\bclaude-[^\s/]*?(?:-4-?5\b|4\.5\b)/i.test(id); } export function collectModelHygieneFindings(cfg: ClawdbotConfig): SecurityAuditFinding[] { diff --git a/src/security/audit.test.ts b/src/security/audit.test.ts index 2ee7e27ee..0811aedda 100644 --- a/src/security/audit.test.ts +++ b/src/security/audit.test.ts @@ -687,6 +687,23 @@ describe("security audit", () => { ); }); + it("does not warn on Venice-style opus-45 model names", async () => { + // Venice uses "claude-opus-45" format (no dash between 4 and 5) + const cfg: ClawdbotConfig = { + agents: { defaults: { model: { primary: "venice/claude-opus-45" } } }, + }; + + const res = await runSecurityAudit({ + config: cfg, + includeFilesystem: false, + includeChannelSecurity: false, + }); + + // Should NOT contain weak_tier warning for opus-45 + const weakTierFinding = res.findings.find((f) => f.checkId === "models.weak_tier"); + expect(weakTierFinding).toBeUndefined(); + }); + it("warns when hooks token looks short", async () => { const cfg: ClawdbotConfig = { hooks: { enabled: true, token: "short" }, From f7a0b0934dd9a2f3920a22ba24d3fc0a5e96902a Mon Sep 17 00:00:00 2001 From: Shadow Date: Tue, 27 Jan 2026 14:46:27 -0600 Subject: [PATCH 043/101] Branding: update bot.molt bundle IDs + launchd labels --- CHANGELOG.md | 1 + apps/android/app/build.gradle.kts | 4 +- .../java/bot/molt/android/CameraHudState.kt | 14 + .../main/java/bot/molt/android/DeviceNames.kt | 26 + .../java/bot/molt/android/LocationMode.kt | 15 + .../java/bot/molt/android/MainActivity.kt | 130 ++ .../java/bot/molt/android/MainViewModel.kt | 174 +++ .../src/main/java/bot/molt/android/NodeApp.kt | 26 + .../bot/molt/android/NodeForegroundService.kt | 180 +++ .../main/java/bot/molt/android/NodeRuntime.kt | 1268 +++++++++++++++++ .../bot/molt/android/PermissionRequester.kt | 133 ++ .../molt/android/ScreenCaptureRequester.kt | 65 + .../main/java/bot/molt/android/SecurePrefs.kt | 308 ++++ .../main/java/bot/molt/android/SessionKey.kt | 13 + .../java/bot/molt/android/VoiceWakeMode.kt | 14 + .../main/java/bot/molt/android/WakeWords.kt | 21 + .../bot/molt/android/chat/ChatController.kt | 524 +++++++ .../java/bot/molt/android/chat/ChatModels.kt | 44 + .../molt/android/gateway/BonjourEscapes.kt | 35 + .../molt/android/gateway/DeviceAuthStore.kt | 26 + .../android/gateway/DeviceIdentityStore.kt | 146 ++ .../molt/android/gateway/GatewayDiscovery.kt | 519 +++++++ .../molt/android/gateway/GatewayEndpoint.kt | 26 + .../molt/android/gateway/GatewayProtocol.kt | 3 + .../molt/android/gateway/GatewaySession.kt | 683 +++++++++ .../bot/molt/android/gateway/GatewayTls.kt | 90 ++ .../molt/android/node/CameraCaptureManager.kt | 316 ++++ .../bot/molt/android/node/CanvasController.kt | 264 ++++ .../bot/molt/android/node/JpegSizeLimiter.kt | 61 + .../android/node/LocationCaptureManager.kt | 117 ++ .../molt/android/node/ScreenRecordManager.kt | 199 +++ .../java/bot/molt/android/node/SmsManager.kt | 230 +++ .../protocol/ClawdbotCanvasA2UIAction.kt | 66 + .../protocol/ClawdbotProtocolConstants.kt | 71 + .../bot/molt/android/tools/ToolDisplay.kt | 222 +++ .../bot/molt/android/ui/CameraHudOverlay.kt | 44 + .../java/bot/molt/android/ui/ChatSheet.kt | 10 + .../java/bot/molt/android/ui/ClawdbotTheme.kt | 32 + .../java/bot/molt/android/ui/RootScreen.kt | 449 ++++++ .../java/bot/molt/android/ui/SettingsSheet.kt | 686 +++++++++ .../java/bot/molt/android/ui/StatusPill.kt | 114 ++ .../bot/molt/android/ui/TalkOrbOverlay.kt | 134 ++ .../bot/molt/android/ui/chat/ChatComposer.kt | 285 ++++ .../bot/molt/android/ui/chat/ChatMarkdown.kt | 215 +++ .../android/ui/chat/ChatMessageListCard.kt | 111 ++ .../molt/android/ui/chat/ChatMessageViews.kt | 252 ++++ .../android/ui/chat/ChatSessionsDialog.kt | 92 ++ .../molt/android/ui/chat/ChatSheetContent.kt | 147 ++ .../molt/android/ui/chat/SessionFilters.kt | 49 + .../android/voice/StreamingMediaDataSource.kt | 98 ++ .../molt/android/voice/TalkDirectiveParser.kt | 191 +++ .../bot/molt/android/voice/TalkModeManager.kt | 1257 ++++++++++++++++ .../voice/VoiceWakeCommandExtractor.kt | 40 + .../molt/android/voice/VoiceWakeManager.kt | 173 +++ .../molt/android/NodeForegroundServiceTest.kt | 43 + .../java/bot/molt/android/WakeWordsTest.kt | 50 + .../android/gateway/BonjourEscapesTest.kt | 19 + .../CanvasControllerSnapshotParamsTest.kt | 43 + .../molt/android/node/JpegSizeLimiterTest.kt | 47 + .../bot/molt/android/node/SmsManagerTest.kt | 91 ++ .../protocol/ClawdbotCanvasA2UIActionTest.kt | 49 + .../protocol/ClawdbotProtocolConstantsTest.kt | 35 + .../android/ui/chat/SessionFiltersTest.kt | 35 + .../android/voice/TalkDirectiveParserTest.kt | 55 + .../voice/VoiceWakeCommandExtractorTest.kt | 25 + .../Gateway/GatewayDiscoveryModel.swift | 2 +- .../Gateway/GatewaySettingsStore.swift | 74 +- .../Sources/Screen/ScreenRecordService.swift | 2 +- apps/ios/Sources/Voice/TalkModeManager.swift | 2 +- .../ios/Tests/GatewaySettingsStoreTests.swift | 4 +- apps/ios/Tests/KeychainStoreTests.swift | 2 +- apps/ios/fastlane/Appfile | 2 +- apps/ios/project.yml | 8 +- .../Sources/MoltbotChatUI/ChatViewModel.swift | 2 +- .../Sources/MoltbotKit/GatewayChannel.swift | 2 +- .../MoltbotKit/GatewayNodeSession.swift | 2 +- .../MoltbotKit/GatewayTLSPinning.swift | 17 +- .../Sources/MoltbotKit/InstanceIdentity.swift | 15 +- docs/gateway/index.md | 14 +- docs/gateway/remote-gateway-readme.md | 12 +- docs/gateway/troubleshooting.md | 4 +- docs/help/faq.md | 2 +- docs/install/nix.md | 2 +- docs/install/uninstall.md | 8 +- docs/install/updating.md | 2 +- docs/platforms/index.md | 2 +- docs/platforms/mac/bundled-gateway.md | 6 +- docs/platforms/mac/child-process.md | 10 +- docs/platforms/mac/dev-setup.md | 2 +- docs/platforms/mac/logging.md | 8 +- docs/platforms/mac/permissions.md | 4 +- docs/platforms/mac/release.md | 4 +- docs/platforms/mac/signing.md | 2 +- docs/platforms/mac/voice-overlay.md | 4 +- docs/platforms/mac/webchat.md | 2 +- docs/platforms/macos.md | 10 +- package.json | 4 +- scripts/clawlog.sh | 4 +- scripts/package-mac-app.sh | 2 +- scripts/restart-mac.sh | 6 +- src/cli/daemon-cli.coverage.test.ts | 2 +- src/commands/status.test.ts | 4 +- src/daemon/constants.test.ts | 8 +- src/daemon/constants.ts | 19 +- src/daemon/inspect.ts | 7 +- src/daemon/launchd.test.ts | 20 +- src/daemon/launchd.ts | 6 +- src/daemon/service-env.test.ts | 4 +- 108 files changed, 11111 insertions(+), 112 deletions(-) create mode 100644 apps/android/app/src/main/java/bot/molt/android/CameraHudState.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/DeviceNames.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/LocationMode.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/MainActivity.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/MainViewModel.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/NodeApp.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/NodeForegroundService.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/NodeRuntime.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/PermissionRequester.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ScreenCaptureRequester.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/SecurePrefs.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/SessionKey.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/VoiceWakeMode.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/WakeWords.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/chat/ChatController.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/chat/ChatModels.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/gateway/BonjourEscapes.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/gateway/DeviceAuthStore.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/gateway/DeviceIdentityStore.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/gateway/GatewayDiscovery.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/gateway/GatewayEndpoint.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/gateway/GatewayProtocol.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/gateway/GatewaySession.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/gateway/GatewayTls.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/node/CameraCaptureManager.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/node/CanvasController.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/node/JpegSizeLimiter.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/node/LocationCaptureManager.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/node/ScreenRecordManager.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/node/SmsManager.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/protocol/ClawdbotCanvasA2UIAction.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/protocol/ClawdbotProtocolConstants.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/tools/ToolDisplay.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/CameraHudOverlay.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/ChatSheet.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/ClawdbotTheme.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/RootScreen.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/SettingsSheet.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/StatusPill.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/TalkOrbOverlay.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatComposer.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMarkdown.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMessageListCard.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMessageViews.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatSessionsDialog.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatSheetContent.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/ui/chat/SessionFilters.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/voice/StreamingMediaDataSource.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/voice/TalkDirectiveParser.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/voice/TalkModeManager.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/voice/VoiceWakeCommandExtractor.kt create mode 100644 apps/android/app/src/main/java/bot/molt/android/voice/VoiceWakeManager.kt create mode 100644 apps/android/app/src/test/java/bot/molt/android/NodeForegroundServiceTest.kt create mode 100644 apps/android/app/src/test/java/bot/molt/android/WakeWordsTest.kt create mode 100644 apps/android/app/src/test/java/bot/molt/android/gateway/BonjourEscapesTest.kt create mode 100644 apps/android/app/src/test/java/bot/molt/android/node/CanvasControllerSnapshotParamsTest.kt create mode 100644 apps/android/app/src/test/java/bot/molt/android/node/JpegSizeLimiterTest.kt create mode 100644 apps/android/app/src/test/java/bot/molt/android/node/SmsManagerTest.kt create mode 100644 apps/android/app/src/test/java/bot/molt/android/protocol/ClawdbotCanvasA2UIActionTest.kt create mode 100644 apps/android/app/src/test/java/bot/molt/android/protocol/ClawdbotProtocolConstantsTest.kt create mode 100644 apps/android/app/src/test/java/bot/molt/android/ui/chat/SessionFiltersTest.kt create mode 100644 apps/android/app/src/test/java/bot/molt/android/voice/TalkDirectiveParserTest.kt create mode 100644 apps/android/app/src/test/java/bot/molt/android/voice/VoiceWakeCommandExtractorTest.kt diff --git a/CHANGELOG.md b/CHANGELOG.md index cc26b0796..e1efce475 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,7 @@ Status: unreleased. - Commands: group /help and /commands output with Telegram paging. (#2504) Thanks @hougangdev. - macOS: limit project-local `node_modules/.bin` PATH preference to debug builds (reduce PATH hijacking risk). - macOS: finish Moltbot app rename for macOS sources, bundle identifiers, and shared kit paths. (#2844) Thanks @fal3. +- Branding: update launchd labels, mobile bundle IDs, and logging subsystems to bot.molt (legacy com.clawdbot migrations). Thanks @thewilloftheshadow. - Tools: add per-sender group tool policies and fix precedence. (#1757) Thanks @adam91holt. - Agents: summarize dropped messages during compaction safeguard pruning. (#2509) Thanks @jogi47. - Skills: add multi-image input support to Nano Banana Pro skill. (#1958) Thanks @tyler6204. diff --git a/apps/android/app/build.gradle.kts b/apps/android/app/build.gradle.kts index ef2fb8dd2..6d3fa6045 100644 --- a/apps/android/app/build.gradle.kts +++ b/apps/android/app/build.gradle.kts @@ -8,7 +8,7 @@ plugins { } android { - namespace = "com.clawdbot.android" + namespace = "bot.molt.android" compileSdk = 36 sourceSets { @@ -18,7 +18,7 @@ android { } defaultConfig { - applicationId = "com.clawdbot.android" + applicationId = "bot.molt.android" minSdk = 31 targetSdk = 36 versionCode = 202601260 diff --git a/apps/android/app/src/main/java/bot/molt/android/CameraHudState.kt b/apps/android/app/src/main/java/bot/molt/android/CameraHudState.kt new file mode 100644 index 000000000..91531bb5e --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/CameraHudState.kt @@ -0,0 +1,14 @@ +package bot.molt.android + +enum class CameraHudKind { + Photo, + Recording, + Success, + Error, +} + +data class CameraHudState( + val token: Long, + val kind: CameraHudKind, + val message: String, +) diff --git a/apps/android/app/src/main/java/bot/molt/android/DeviceNames.kt b/apps/android/app/src/main/java/bot/molt/android/DeviceNames.kt new file mode 100644 index 000000000..36cc3e8e2 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/DeviceNames.kt @@ -0,0 +1,26 @@ +package bot.molt.android + +import android.content.Context +import android.os.Build +import android.provider.Settings + +object DeviceNames { + fun bestDefaultNodeName(context: Context): String { + val deviceName = + runCatching { + Settings.Global.getString(context.contentResolver, "device_name") + } + .getOrNull() + ?.trim() + .orEmpty() + + if (deviceName.isNotEmpty()) return deviceName + + val model = + listOfNotNull(Build.MANUFACTURER?.takeIf { it.isNotBlank() }, Build.MODEL?.takeIf { it.isNotBlank() }) + .joinToString(" ") + .trim() + + return model.ifEmpty { "Android Node" } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/LocationMode.kt b/apps/android/app/src/main/java/bot/molt/android/LocationMode.kt new file mode 100644 index 000000000..40005c324 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/LocationMode.kt @@ -0,0 +1,15 @@ +package bot.molt.android + +enum class LocationMode(val rawValue: String) { + Off("off"), + WhileUsing("whileUsing"), + Always("always"), + ; + + companion object { + fun fromRawValue(raw: String?): LocationMode { + val normalized = raw?.trim()?.lowercase() + return entries.firstOrNull { it.rawValue.lowercase() == normalized } ?: Off + } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/MainActivity.kt b/apps/android/app/src/main/java/bot/molt/android/MainActivity.kt new file mode 100644 index 000000000..1e8707e72 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/MainActivity.kt @@ -0,0 +1,130 @@ +package bot.molt.android + +import android.Manifest +import android.content.pm.ApplicationInfo +import android.os.Bundle +import android.os.Build +import android.view.WindowManager +import android.webkit.WebView +import androidx.activity.ComponentActivity +import androidx.activity.compose.setContent +import androidx.activity.viewModels +import androidx.compose.material3.Surface +import androidx.compose.ui.Modifier +import androidx.core.content.ContextCompat +import androidx.core.view.WindowCompat +import androidx.core.view.WindowInsetsCompat +import androidx.core.view.WindowInsetsControllerCompat +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.lifecycleScope +import androidx.lifecycle.repeatOnLifecycle +import bot.molt.android.ui.RootScreen +import bot.molt.android.ui.MoltbotTheme +import kotlinx.coroutines.launch + +class MainActivity : ComponentActivity() { + private val viewModel: MainViewModel by viewModels() + private lateinit var permissionRequester: PermissionRequester + private lateinit var screenCaptureRequester: ScreenCaptureRequester + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + val isDebuggable = (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0 + WebView.setWebContentsDebuggingEnabled(isDebuggable) + applyImmersiveMode() + requestDiscoveryPermissionsIfNeeded() + requestNotificationPermissionIfNeeded() + NodeForegroundService.start(this) + permissionRequester = PermissionRequester(this) + screenCaptureRequester = ScreenCaptureRequester(this) + viewModel.camera.attachLifecycleOwner(this) + viewModel.camera.attachPermissionRequester(permissionRequester) + viewModel.sms.attachPermissionRequester(permissionRequester) + viewModel.screenRecorder.attachScreenCaptureRequester(screenCaptureRequester) + viewModel.screenRecorder.attachPermissionRequester(permissionRequester) + + lifecycleScope.launch { + repeatOnLifecycle(Lifecycle.State.STARTED) { + viewModel.preventSleep.collect { enabled -> + if (enabled) { + window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) + } else { + window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) + } + } + } + } + + setContent { + MoltbotTheme { + Surface(modifier = Modifier) { + RootScreen(viewModel = viewModel) + } + } + } + } + + override fun onResume() { + super.onResume() + applyImmersiveMode() + } + + override fun onWindowFocusChanged(hasFocus: Boolean) { + super.onWindowFocusChanged(hasFocus) + if (hasFocus) { + applyImmersiveMode() + } + } + + override fun onStart() { + super.onStart() + viewModel.setForeground(true) + } + + override fun onStop() { + viewModel.setForeground(false) + super.onStop() + } + + private fun applyImmersiveMode() { + WindowCompat.setDecorFitsSystemWindows(window, false) + val controller = WindowInsetsControllerCompat(window, window.decorView) + controller.systemBarsBehavior = + WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE + controller.hide(WindowInsetsCompat.Type.systemBars()) + } + + private fun requestDiscoveryPermissionsIfNeeded() { + if (Build.VERSION.SDK_INT >= 33) { + val ok = + ContextCompat.checkSelfPermission( + this, + Manifest.permission.NEARBY_WIFI_DEVICES, + ) == android.content.pm.PackageManager.PERMISSION_GRANTED + if (!ok) { + requestPermissions(arrayOf(Manifest.permission.NEARBY_WIFI_DEVICES), 100) + } + } else { + val ok = + ContextCompat.checkSelfPermission( + this, + Manifest.permission.ACCESS_FINE_LOCATION, + ) == android.content.pm.PackageManager.PERMISSION_GRANTED + if (!ok) { + requestPermissions(arrayOf(Manifest.permission.ACCESS_FINE_LOCATION), 101) + } + } + } + + private fun requestNotificationPermissionIfNeeded() { + if (Build.VERSION.SDK_INT < 33) return + val ok = + ContextCompat.checkSelfPermission( + this, + Manifest.permission.POST_NOTIFICATIONS, + ) == android.content.pm.PackageManager.PERMISSION_GRANTED + if (!ok) { + requestPermissions(arrayOf(Manifest.permission.POST_NOTIFICATIONS), 102) + } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/MainViewModel.kt b/apps/android/app/src/main/java/bot/molt/android/MainViewModel.kt new file mode 100644 index 000000000..a4f5ee23e --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/MainViewModel.kt @@ -0,0 +1,174 @@ +package bot.molt.android + +import android.app.Application +import androidx.lifecycle.AndroidViewModel +import bot.molt.android.gateway.GatewayEndpoint +import bot.molt.android.chat.OutgoingAttachment +import bot.molt.android.node.CameraCaptureManager +import bot.molt.android.node.CanvasController +import bot.molt.android.node.ScreenRecordManager +import bot.molt.android.node.SmsManager +import kotlinx.coroutines.flow.StateFlow + +class MainViewModel(app: Application) : AndroidViewModel(app) { + private val runtime: NodeRuntime = (app as NodeApp).runtime + + val canvas: CanvasController = runtime.canvas + val camera: CameraCaptureManager = runtime.camera + val screenRecorder: ScreenRecordManager = runtime.screenRecorder + val sms: SmsManager = runtime.sms + + val gateways: StateFlow> = runtime.gateways + val discoveryStatusText: StateFlow = runtime.discoveryStatusText + + val isConnected: StateFlow = runtime.isConnected + val statusText: StateFlow = runtime.statusText + val serverName: StateFlow = runtime.serverName + val remoteAddress: StateFlow = runtime.remoteAddress + val isForeground: StateFlow = runtime.isForeground + val seamColorArgb: StateFlow = runtime.seamColorArgb + val mainSessionKey: StateFlow = runtime.mainSessionKey + + val cameraHud: StateFlow = runtime.cameraHud + val cameraFlashToken: StateFlow = runtime.cameraFlashToken + val screenRecordActive: StateFlow = runtime.screenRecordActive + + val instanceId: StateFlow = runtime.instanceId + val displayName: StateFlow = runtime.displayName + val cameraEnabled: StateFlow = runtime.cameraEnabled + val locationMode: StateFlow = runtime.locationMode + val locationPreciseEnabled: StateFlow = runtime.locationPreciseEnabled + val preventSleep: StateFlow = runtime.preventSleep + val wakeWords: StateFlow> = runtime.wakeWords + val voiceWakeMode: StateFlow = runtime.voiceWakeMode + val voiceWakeStatusText: StateFlow = runtime.voiceWakeStatusText + val voiceWakeIsListening: StateFlow = runtime.voiceWakeIsListening + val talkEnabled: StateFlow = runtime.talkEnabled + val talkStatusText: StateFlow = runtime.talkStatusText + val talkIsListening: StateFlow = runtime.talkIsListening + val talkIsSpeaking: StateFlow = runtime.talkIsSpeaking + val manualEnabled: StateFlow = runtime.manualEnabled + val manualHost: StateFlow = runtime.manualHost + val manualPort: StateFlow = runtime.manualPort + val manualTls: StateFlow = runtime.manualTls + val canvasDebugStatusEnabled: StateFlow = runtime.canvasDebugStatusEnabled + + val chatSessionKey: StateFlow = runtime.chatSessionKey + val chatSessionId: StateFlow = runtime.chatSessionId + val chatMessages = runtime.chatMessages + val chatError: StateFlow = runtime.chatError + val chatHealthOk: StateFlow = runtime.chatHealthOk + val chatThinkingLevel: StateFlow = runtime.chatThinkingLevel + val chatStreamingAssistantText: StateFlow = runtime.chatStreamingAssistantText + val chatPendingToolCalls = runtime.chatPendingToolCalls + val chatSessions = runtime.chatSessions + val pendingRunCount: StateFlow = runtime.pendingRunCount + + fun setForeground(value: Boolean) { + runtime.setForeground(value) + } + + fun setDisplayName(value: String) { + runtime.setDisplayName(value) + } + + fun setCameraEnabled(value: Boolean) { + runtime.setCameraEnabled(value) + } + + fun setLocationMode(mode: LocationMode) { + runtime.setLocationMode(mode) + } + + fun setLocationPreciseEnabled(value: Boolean) { + runtime.setLocationPreciseEnabled(value) + } + + fun setPreventSleep(value: Boolean) { + runtime.setPreventSleep(value) + } + + fun setManualEnabled(value: Boolean) { + runtime.setManualEnabled(value) + } + + fun setManualHost(value: String) { + runtime.setManualHost(value) + } + + fun setManualPort(value: Int) { + runtime.setManualPort(value) + } + + fun setManualTls(value: Boolean) { + runtime.setManualTls(value) + } + + fun setCanvasDebugStatusEnabled(value: Boolean) { + runtime.setCanvasDebugStatusEnabled(value) + } + + fun setWakeWords(words: List) { + runtime.setWakeWords(words) + } + + fun resetWakeWordsDefaults() { + runtime.resetWakeWordsDefaults() + } + + fun setVoiceWakeMode(mode: VoiceWakeMode) { + runtime.setVoiceWakeMode(mode) + } + + fun setTalkEnabled(enabled: Boolean) { + runtime.setTalkEnabled(enabled) + } + + fun refreshGatewayConnection() { + runtime.refreshGatewayConnection() + } + + fun connect(endpoint: GatewayEndpoint) { + runtime.connect(endpoint) + } + + fun connectManual() { + runtime.connectManual() + } + + fun disconnect() { + runtime.disconnect() + } + + fun handleCanvasA2UIActionFromWebView(payloadJson: String) { + runtime.handleCanvasA2UIActionFromWebView(payloadJson) + } + + fun loadChat(sessionKey: String) { + runtime.loadChat(sessionKey) + } + + fun refreshChat() { + runtime.refreshChat() + } + + fun refreshChatSessions(limit: Int? = null) { + runtime.refreshChatSessions(limit = limit) + } + + fun setChatThinkingLevel(level: String) { + runtime.setChatThinkingLevel(level) + } + + fun switchChatSession(sessionKey: String) { + runtime.switchChatSession(sessionKey) + } + + fun abortChat() { + runtime.abortChat() + } + + fun sendChat(message: String, thinking: String, attachments: List) { + runtime.sendChat(message = message, thinking = thinking, attachments = attachments) + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/NodeApp.kt b/apps/android/app/src/main/java/bot/molt/android/NodeApp.kt new file mode 100644 index 000000000..53b2c58f5 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/NodeApp.kt @@ -0,0 +1,26 @@ +package bot.molt.android + +import android.app.Application +import android.os.StrictMode + +class NodeApp : Application() { + val runtime: NodeRuntime by lazy { NodeRuntime(this) } + + override fun onCreate() { + super.onCreate() + if (BuildConfig.DEBUG) { + StrictMode.setThreadPolicy( + StrictMode.ThreadPolicy.Builder() + .detectAll() + .penaltyLog() + .build(), + ) + StrictMode.setVmPolicy( + StrictMode.VmPolicy.Builder() + .detectAll() + .penaltyLog() + .build(), + ) + } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/NodeForegroundService.kt b/apps/android/app/src/main/java/bot/molt/android/NodeForegroundService.kt new file mode 100644 index 000000000..03cc42f2d --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/NodeForegroundService.kt @@ -0,0 +1,180 @@ +package bot.molt.android + +import android.app.Notification +import android.app.NotificationChannel +import android.app.NotificationManager +import android.app.Service +import android.app.PendingIntent +import android.Manifest +import android.content.Context +import android.content.Intent +import android.content.pm.PackageManager +import android.content.pm.ServiceInfo +import androidx.core.app.NotificationCompat +import androidx.core.content.ContextCompat +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.cancel +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.launch + +class NodeForegroundService : Service() { + private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main) + private var notificationJob: Job? = null + private var lastRequiresMic = false + private var didStartForeground = false + + override fun onCreate() { + super.onCreate() + ensureChannel() + val initial = buildNotification(title = "Moltbot Node", text = "Starting…") + startForegroundWithTypes(notification = initial, requiresMic = false) + + val runtime = (application as NodeApp).runtime + notificationJob = + scope.launch { + combine( + runtime.statusText, + runtime.serverName, + runtime.isConnected, + runtime.voiceWakeMode, + runtime.voiceWakeIsListening, + ) { status, server, connected, voiceMode, voiceListening -> + Quint(status, server, connected, voiceMode, voiceListening) + }.collect { (status, server, connected, voiceMode, voiceListening) -> + val title = if (connected) "Moltbot Node · Connected" else "Moltbot Node" + val voiceSuffix = + if (voiceMode == VoiceWakeMode.Always) { + if (voiceListening) " · Voice Wake: Listening" else " · Voice Wake: Paused" + } else { + "" + } + val text = (server?.let { "$status · $it" } ?: status) + voiceSuffix + + val requiresMic = + voiceMode == VoiceWakeMode.Always && hasRecordAudioPermission() + startForegroundWithTypes( + notification = buildNotification(title = title, text = text), + requiresMic = requiresMic, + ) + } + } + } + + override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { + when (intent?.action) { + ACTION_STOP -> { + (application as NodeApp).runtime.disconnect() + stopSelf() + return START_NOT_STICKY + } + } + // Keep running; connection is managed by NodeRuntime (auto-reconnect + manual). + return START_STICKY + } + + override fun onDestroy() { + notificationJob?.cancel() + scope.cancel() + super.onDestroy() + } + + override fun onBind(intent: Intent?) = null + + private fun ensureChannel() { + val mgr = getSystemService(NotificationManager::class.java) + val channel = + NotificationChannel( + CHANNEL_ID, + "Connection", + NotificationManager.IMPORTANCE_LOW, + ).apply { + description = "Moltbot node connection status" + setShowBadge(false) + } + mgr.createNotificationChannel(channel) + } + + private fun buildNotification(title: String, text: String): Notification { + val launchIntent = Intent(this, MainActivity::class.java).apply { + flags = Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP + } + val launchPending = + PendingIntent.getActivity( + this, + 1, + launchIntent, + PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE, + ) + + val stopIntent = Intent(this, NodeForegroundService::class.java).setAction(ACTION_STOP) + val stopPending = + PendingIntent.getService( + this, + 2, + stopIntent, + PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE, + ) + + return NotificationCompat.Builder(this, CHANNEL_ID) + .setSmallIcon(R.mipmap.ic_launcher) + .setContentTitle(title) + .setContentText(text) + .setContentIntent(launchPending) + .setOngoing(true) + .setOnlyAlertOnce(true) + .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE) + .addAction(0, "Disconnect", stopPending) + .build() + } + + private fun updateNotification(notification: Notification) { + val mgr = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager + mgr.notify(NOTIFICATION_ID, notification) + } + + private fun startForegroundWithTypes(notification: Notification, requiresMic: Boolean) { + if (didStartForeground && requiresMic == lastRequiresMic) { + updateNotification(notification) + return + } + + lastRequiresMic = requiresMic + val types = + if (requiresMic) { + ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC or ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE + } else { + ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC + } + startForeground(NOTIFICATION_ID, notification, types) + didStartForeground = true + } + + private fun hasRecordAudioPermission(): Boolean { + return ( + ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == + PackageManager.PERMISSION_GRANTED + ) + } + + companion object { + private const val CHANNEL_ID = "connection" + private const val NOTIFICATION_ID = 1 + + private const val ACTION_STOP = "bot.molt.android.action.STOP" + + fun start(context: Context) { + val intent = Intent(context, NodeForegroundService::class.java) + context.startForegroundService(intent) + } + + fun stop(context: Context) { + val intent = Intent(context, NodeForegroundService::class.java).setAction(ACTION_STOP) + context.startService(intent) + } + } +} + +private data class Quint(val first: A, val second: B, val third: C, val fourth: D, val fifth: E) diff --git a/apps/android/app/src/main/java/bot/molt/android/NodeRuntime.kt b/apps/android/app/src/main/java/bot/molt/android/NodeRuntime.kt new file mode 100644 index 000000000..5fd429e9e --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/NodeRuntime.kt @@ -0,0 +1,1268 @@ +package bot.molt.android + +import android.Manifest +import android.content.Context +import android.content.pm.PackageManager +import android.location.LocationManager +import android.os.Build +import android.os.SystemClock +import androidx.core.content.ContextCompat +import bot.molt.android.chat.ChatController +import bot.molt.android.chat.ChatMessage +import bot.molt.android.chat.ChatPendingToolCall +import bot.molt.android.chat.ChatSessionEntry +import bot.molt.android.chat.OutgoingAttachment +import bot.molt.android.gateway.DeviceAuthStore +import bot.molt.android.gateway.DeviceIdentityStore +import bot.molt.android.gateway.GatewayClientInfo +import bot.molt.android.gateway.GatewayConnectOptions +import bot.molt.android.gateway.GatewayDiscovery +import bot.molt.android.gateway.GatewayEndpoint +import bot.molt.android.gateway.GatewaySession +import bot.molt.android.gateway.GatewayTlsParams +import bot.molt.android.node.CameraCaptureManager +import bot.molt.android.node.LocationCaptureManager +import bot.molt.android.BuildConfig +import bot.molt.android.node.CanvasController +import bot.molt.android.node.ScreenRecordManager +import bot.molt.android.node.SmsManager +import bot.molt.android.protocol.MoltbotCapability +import bot.molt.android.protocol.MoltbotCameraCommand +import bot.molt.android.protocol.MoltbotCanvasA2UIAction +import bot.molt.android.protocol.MoltbotCanvasA2UICommand +import bot.molt.android.protocol.MoltbotCanvasCommand +import bot.molt.android.protocol.MoltbotScreenCommand +import bot.molt.android.protocol.MoltbotLocationCommand +import bot.molt.android.protocol.MoltbotSmsCommand +import bot.molt.android.voice.TalkModeManager +import bot.molt.android.voice.VoiceWakeManager +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.TimeoutCancellationException +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.collect +import kotlinx.coroutines.flow.distinctUntilChanged +import kotlinx.coroutines.launch +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonElement +import kotlinx.serialization.json.JsonNull +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.buildJsonObject +import java.util.concurrent.atomic.AtomicLong + +class NodeRuntime(context: Context) { + private val appContext = context.applicationContext + private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO) + + val prefs = SecurePrefs(appContext) + private val deviceAuthStore = DeviceAuthStore(prefs) + val canvas = CanvasController() + val camera = CameraCaptureManager(appContext) + val location = LocationCaptureManager(appContext) + val screenRecorder = ScreenRecordManager(appContext) + val sms = SmsManager(appContext) + private val json = Json { ignoreUnknownKeys = true } + + private val externalAudioCaptureActive = MutableStateFlow(false) + + private val voiceWake: VoiceWakeManager by lazy { + VoiceWakeManager( + context = appContext, + scope = scope, + onCommand = { command -> + nodeSession.sendNodeEvent( + event = "agent.request", + payloadJson = + buildJsonObject { + put("message", JsonPrimitive(command)) + put("sessionKey", JsonPrimitive(resolveMainSessionKey())) + put("thinking", JsonPrimitive(chatThinkingLevel.value)) + put("deliver", JsonPrimitive(false)) + }.toString(), + ) + }, + ) + } + + val voiceWakeIsListening: StateFlow + get() = voiceWake.isListening + + val voiceWakeStatusText: StateFlow + get() = voiceWake.statusText + + val talkStatusText: StateFlow + get() = talkMode.statusText + + val talkIsListening: StateFlow + get() = talkMode.isListening + + val talkIsSpeaking: StateFlow + get() = talkMode.isSpeaking + + private val discovery = GatewayDiscovery(appContext, scope = scope) + val gateways: StateFlow> = discovery.gateways + val discoveryStatusText: StateFlow = discovery.statusText + + private val identityStore = DeviceIdentityStore(appContext) + + private val _isConnected = MutableStateFlow(false) + val isConnected: StateFlow = _isConnected.asStateFlow() + + private val _statusText = MutableStateFlow("Offline") + val statusText: StateFlow = _statusText.asStateFlow() + + private val _mainSessionKey = MutableStateFlow("main") + val mainSessionKey: StateFlow = _mainSessionKey.asStateFlow() + + private val cameraHudSeq = AtomicLong(0) + private val _cameraHud = MutableStateFlow(null) + val cameraHud: StateFlow = _cameraHud.asStateFlow() + + private val _cameraFlashToken = MutableStateFlow(0L) + val cameraFlashToken: StateFlow = _cameraFlashToken.asStateFlow() + + private val _screenRecordActive = MutableStateFlow(false) + val screenRecordActive: StateFlow = _screenRecordActive.asStateFlow() + + private val _serverName = MutableStateFlow(null) + val serverName: StateFlow = _serverName.asStateFlow() + + private val _remoteAddress = MutableStateFlow(null) + val remoteAddress: StateFlow = _remoteAddress.asStateFlow() + + private val _seamColorArgb = MutableStateFlow(DEFAULT_SEAM_COLOR_ARGB) + val seamColorArgb: StateFlow = _seamColorArgb.asStateFlow() + + private val _isForeground = MutableStateFlow(true) + val isForeground: StateFlow = _isForeground.asStateFlow() + + private var lastAutoA2uiUrl: String? = null + private var operatorConnected = false + private var nodeConnected = false + private var operatorStatusText: String = "Offline" + private var nodeStatusText: String = "Offline" + private var connectedEndpoint: GatewayEndpoint? = null + + private val operatorSession = + GatewaySession( + scope = scope, + identityStore = identityStore, + deviceAuthStore = deviceAuthStore, + onConnected = { name, remote, mainSessionKey -> + operatorConnected = true + operatorStatusText = "Connected" + _serverName.value = name + _remoteAddress.value = remote + _seamColorArgb.value = DEFAULT_SEAM_COLOR_ARGB + applyMainSessionKey(mainSessionKey) + updateStatus() + scope.launch { refreshBrandingFromGateway() } + scope.launch { refreshWakeWordsFromGateway() } + }, + onDisconnected = { message -> + operatorConnected = false + operatorStatusText = message + _serverName.value = null + _remoteAddress.value = null + _seamColorArgb.value = DEFAULT_SEAM_COLOR_ARGB + if (!isCanonicalMainSessionKey(_mainSessionKey.value)) { + _mainSessionKey.value = "main" + } + val mainKey = resolveMainSessionKey() + talkMode.setMainSessionKey(mainKey) + chat.applyMainSessionKey(mainKey) + chat.onDisconnected(message) + updateStatus() + }, + onEvent = { event, payloadJson -> + handleGatewayEvent(event, payloadJson) + }, + ) + + private val nodeSession = + GatewaySession( + scope = scope, + identityStore = identityStore, + deviceAuthStore = deviceAuthStore, + onConnected = { _, _, _ -> + nodeConnected = true + nodeStatusText = "Connected" + updateStatus() + maybeNavigateToA2uiOnConnect() + }, + onDisconnected = { message -> + nodeConnected = false + nodeStatusText = message + updateStatus() + showLocalCanvasOnDisconnect() + }, + onEvent = { _, _ -> }, + onInvoke = { req -> + handleInvoke(req.command, req.paramsJson) + }, + onTlsFingerprint = { stableId, fingerprint -> + prefs.saveGatewayTlsFingerprint(stableId, fingerprint) + }, + ) + + private val chat: ChatController = + ChatController( + scope = scope, + session = operatorSession, + json = json, + supportsChatSubscribe = false, + ) + private val talkMode: TalkModeManager by lazy { + TalkModeManager( + context = appContext, + scope = scope, + session = operatorSession, + supportsChatSubscribe = false, + isConnected = { operatorConnected }, + ) + } + + private fun applyMainSessionKey(candidate: String?) { + val trimmed = candidate?.trim().orEmpty() + if (trimmed.isEmpty()) return + if (isCanonicalMainSessionKey(_mainSessionKey.value)) return + if (_mainSessionKey.value == trimmed) return + _mainSessionKey.value = trimmed + talkMode.setMainSessionKey(trimmed) + chat.applyMainSessionKey(trimmed) + } + + private fun updateStatus() { + _isConnected.value = operatorConnected + _statusText.value = + when { + operatorConnected && nodeConnected -> "Connected" + operatorConnected && !nodeConnected -> "Connected (node offline)" + !operatorConnected && nodeConnected -> "Connected (operator offline)" + operatorStatusText.isNotBlank() && operatorStatusText != "Offline" -> operatorStatusText + else -> nodeStatusText + } + } + + private fun resolveMainSessionKey(): String { + val trimmed = _mainSessionKey.value.trim() + return if (trimmed.isEmpty()) "main" else trimmed + } + + private fun maybeNavigateToA2uiOnConnect() { + val a2uiUrl = resolveA2uiHostUrl() ?: return + val current = canvas.currentUrl()?.trim().orEmpty() + if (current.isEmpty() || current == lastAutoA2uiUrl) { + lastAutoA2uiUrl = a2uiUrl + canvas.navigate(a2uiUrl) + } + } + + private fun showLocalCanvasOnDisconnect() { + lastAutoA2uiUrl = null + canvas.navigate("") + } + + val instanceId: StateFlow = prefs.instanceId + val displayName: StateFlow = prefs.displayName + val cameraEnabled: StateFlow = prefs.cameraEnabled + val locationMode: StateFlow = prefs.locationMode + val locationPreciseEnabled: StateFlow = prefs.locationPreciseEnabled + val preventSleep: StateFlow = prefs.preventSleep + val wakeWords: StateFlow> = prefs.wakeWords + val voiceWakeMode: StateFlow = prefs.voiceWakeMode + val talkEnabled: StateFlow = prefs.talkEnabled + val manualEnabled: StateFlow = prefs.manualEnabled + val manualHost: StateFlow = prefs.manualHost + val manualPort: StateFlow = prefs.manualPort + val manualTls: StateFlow = prefs.manualTls + val lastDiscoveredStableId: StateFlow = prefs.lastDiscoveredStableId + val canvasDebugStatusEnabled: StateFlow = prefs.canvasDebugStatusEnabled + + private var didAutoConnect = false + private var suppressWakeWordsSync = false + private var wakeWordsSyncJob: Job? = null + + val chatSessionKey: StateFlow = chat.sessionKey + val chatSessionId: StateFlow = chat.sessionId + val chatMessages: StateFlow> = chat.messages + val chatError: StateFlow = chat.errorText + val chatHealthOk: StateFlow = chat.healthOk + val chatThinkingLevel: StateFlow = chat.thinkingLevel + val chatStreamingAssistantText: StateFlow = chat.streamingAssistantText + val chatPendingToolCalls: StateFlow> = chat.pendingToolCalls + val chatSessions: StateFlow> = chat.sessions + val pendingRunCount: StateFlow = chat.pendingRunCount + + init { + scope.launch { + combine( + voiceWakeMode, + isForeground, + externalAudioCaptureActive, + wakeWords, + ) { mode, foreground, externalAudio, words -> + Quad(mode, foreground, externalAudio, words) + }.distinctUntilChanged() + .collect { (mode, foreground, externalAudio, words) -> + voiceWake.setTriggerWords(words) + + val shouldListen = + when (mode) { + VoiceWakeMode.Off -> false + VoiceWakeMode.Foreground -> foreground + VoiceWakeMode.Always -> true + } && !externalAudio + + if (!shouldListen) { + voiceWake.stop(statusText = if (mode == VoiceWakeMode.Off) "Off" else "Paused") + return@collect + } + + if (!hasRecordAudioPermission()) { + voiceWake.stop(statusText = "Microphone permission required") + return@collect + } + + voiceWake.start() + } + } + + scope.launch { + talkEnabled.collect { enabled -> + talkMode.setEnabled(enabled) + externalAudioCaptureActive.value = enabled + } + } + + scope.launch(Dispatchers.Default) { + gateways.collect { list -> + if (list.isNotEmpty()) { + // Persist the last discovered gateway (best-effort UX parity with iOS). + prefs.setLastDiscoveredStableId(list.last().stableId) + } + + if (didAutoConnect) return@collect + if (_isConnected.value) return@collect + + if (manualEnabled.value) { + val host = manualHost.value.trim() + val port = manualPort.value + if (host.isNotEmpty() && port in 1..65535) { + didAutoConnect = true + connect(GatewayEndpoint.manual(host = host, port = port)) + } + return@collect + } + + val targetStableId = lastDiscoveredStableId.value.trim() + if (targetStableId.isEmpty()) return@collect + val target = list.firstOrNull { it.stableId == targetStableId } ?: return@collect + didAutoConnect = true + connect(target) + } + } + + scope.launch { + combine( + canvasDebugStatusEnabled, + statusText, + serverName, + remoteAddress, + ) { debugEnabled, status, server, remote -> + Quad(debugEnabled, status, server, remote) + }.distinctUntilChanged() + .collect { (debugEnabled, status, server, remote) -> + canvas.setDebugStatusEnabled(debugEnabled) + if (!debugEnabled) return@collect + canvas.setDebugStatus(status, server ?: remote) + } + } + } + + fun setForeground(value: Boolean) { + _isForeground.value = value + } + + fun setDisplayName(value: String) { + prefs.setDisplayName(value) + } + + fun setCameraEnabled(value: Boolean) { + prefs.setCameraEnabled(value) + } + + fun setLocationMode(mode: LocationMode) { + prefs.setLocationMode(mode) + } + + fun setLocationPreciseEnabled(value: Boolean) { + prefs.setLocationPreciseEnabled(value) + } + + fun setPreventSleep(value: Boolean) { + prefs.setPreventSleep(value) + } + + fun setManualEnabled(value: Boolean) { + prefs.setManualEnabled(value) + } + + fun setManualHost(value: String) { + prefs.setManualHost(value) + } + + fun setManualPort(value: Int) { + prefs.setManualPort(value) + } + + fun setManualTls(value: Boolean) { + prefs.setManualTls(value) + } + + fun setCanvasDebugStatusEnabled(value: Boolean) { + prefs.setCanvasDebugStatusEnabled(value) + } + + fun setWakeWords(words: List) { + prefs.setWakeWords(words) + scheduleWakeWordsSyncIfNeeded() + } + + fun resetWakeWordsDefaults() { + setWakeWords(SecurePrefs.defaultWakeWords) + } + + fun setVoiceWakeMode(mode: VoiceWakeMode) { + prefs.setVoiceWakeMode(mode) + } + + fun setTalkEnabled(value: Boolean) { + prefs.setTalkEnabled(value) + } + + private fun buildInvokeCommands(): List = + buildList { + add(MoltbotCanvasCommand.Present.rawValue) + add(MoltbotCanvasCommand.Hide.rawValue) + add(MoltbotCanvasCommand.Navigate.rawValue) + add(MoltbotCanvasCommand.Eval.rawValue) + add(MoltbotCanvasCommand.Snapshot.rawValue) + add(MoltbotCanvasA2UICommand.Push.rawValue) + add(MoltbotCanvasA2UICommand.PushJSONL.rawValue) + add(MoltbotCanvasA2UICommand.Reset.rawValue) + add(MoltbotScreenCommand.Record.rawValue) + if (cameraEnabled.value) { + add(MoltbotCameraCommand.Snap.rawValue) + add(MoltbotCameraCommand.Clip.rawValue) + } + if (locationMode.value != LocationMode.Off) { + add(MoltbotLocationCommand.Get.rawValue) + } + if (sms.canSendSms()) { + add(MoltbotSmsCommand.Send.rawValue) + } + } + + private fun buildCapabilities(): List = + buildList { + add(MoltbotCapability.Canvas.rawValue) + add(MoltbotCapability.Screen.rawValue) + if (cameraEnabled.value) add(MoltbotCapability.Camera.rawValue) + if (sms.canSendSms()) add(MoltbotCapability.Sms.rawValue) + if (voiceWakeMode.value != VoiceWakeMode.Off && hasRecordAudioPermission()) { + add(MoltbotCapability.VoiceWake.rawValue) + } + if (locationMode.value != LocationMode.Off) { + add(MoltbotCapability.Location.rawValue) + } + } + + private fun resolvedVersionName(): String { + val versionName = BuildConfig.VERSION_NAME.trim().ifEmpty { "dev" } + return if (BuildConfig.DEBUG && !versionName.contains("dev", ignoreCase = true)) { + "$versionName-dev" + } else { + versionName + } + } + + private fun resolveModelIdentifier(): String? { + return listOfNotNull(Build.MANUFACTURER, Build.MODEL) + .joinToString(" ") + .trim() + .ifEmpty { null } + } + + private fun buildUserAgent(): String { + val version = resolvedVersionName() + val release = Build.VERSION.RELEASE?.trim().orEmpty() + val releaseLabel = if (release.isEmpty()) "unknown" else release + return "MoltbotAndroid/$version (Android $releaseLabel; SDK ${Build.VERSION.SDK_INT})" + } + + private fun buildClientInfo(clientId: String, clientMode: String): GatewayClientInfo { + return GatewayClientInfo( + id = clientId, + displayName = displayName.value, + version = resolvedVersionName(), + platform = "android", + mode = clientMode, + instanceId = instanceId.value, + deviceFamily = "Android", + modelIdentifier = resolveModelIdentifier(), + ) + } + + private fun buildNodeConnectOptions(): GatewayConnectOptions { + return GatewayConnectOptions( + role = "node", + scopes = emptyList(), + caps = buildCapabilities(), + commands = buildInvokeCommands(), + permissions = emptyMap(), + client = buildClientInfo(clientId = "moltbot-android", clientMode = "node"), + userAgent = buildUserAgent(), + ) + } + + private fun buildOperatorConnectOptions(): GatewayConnectOptions { + return GatewayConnectOptions( + role = "operator", + scopes = emptyList(), + caps = emptyList(), + commands = emptyList(), + permissions = emptyMap(), + client = buildClientInfo(clientId = "moltbot-control-ui", clientMode = "ui"), + userAgent = buildUserAgent(), + ) + } + + fun refreshGatewayConnection() { + val endpoint = connectedEndpoint ?: return + val token = prefs.loadGatewayToken() + val password = prefs.loadGatewayPassword() + val tls = resolveTlsParams(endpoint) + operatorSession.connect(endpoint, token, password, buildOperatorConnectOptions(), tls) + nodeSession.connect(endpoint, token, password, buildNodeConnectOptions(), tls) + operatorSession.reconnect() + nodeSession.reconnect() + } + + fun connect(endpoint: GatewayEndpoint) { + connectedEndpoint = endpoint + operatorStatusText = "Connecting…" + nodeStatusText = "Connecting…" + updateStatus() + val token = prefs.loadGatewayToken() + val password = prefs.loadGatewayPassword() + val tls = resolveTlsParams(endpoint) + operatorSession.connect(endpoint, token, password, buildOperatorConnectOptions(), tls) + nodeSession.connect(endpoint, token, password, buildNodeConnectOptions(), tls) + } + + private fun hasRecordAudioPermission(): Boolean { + return ( + ContextCompat.checkSelfPermission(appContext, Manifest.permission.RECORD_AUDIO) == + PackageManager.PERMISSION_GRANTED + ) + } + + private fun hasFineLocationPermission(): Boolean { + return ( + ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_FINE_LOCATION) == + PackageManager.PERMISSION_GRANTED + ) + } + + private fun hasCoarseLocationPermission(): Boolean { + return ( + ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_COARSE_LOCATION) == + PackageManager.PERMISSION_GRANTED + ) + } + + private fun hasBackgroundLocationPermission(): Boolean { + return ( + ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == + PackageManager.PERMISSION_GRANTED + ) + } + + fun connectManual() { + val host = manualHost.value.trim() + val port = manualPort.value + if (host.isEmpty() || port <= 0 || port > 65535) { + _statusText.value = "Failed: invalid manual host/port" + return + } + connect(GatewayEndpoint.manual(host = host, port = port)) + } + + fun disconnect() { + connectedEndpoint = null + operatorSession.disconnect() + nodeSession.disconnect() + } + + private fun resolveTlsParams(endpoint: GatewayEndpoint): GatewayTlsParams? { + val stored = prefs.loadGatewayTlsFingerprint(endpoint.stableId) + val hinted = endpoint.tlsEnabled || !endpoint.tlsFingerprintSha256.isNullOrBlank() + val manual = endpoint.stableId.startsWith("manual|") + + if (manual) { + if (!manualTls.value) return null + return GatewayTlsParams( + required = true, + expectedFingerprint = endpoint.tlsFingerprintSha256 ?: stored, + allowTOFU = stored == null, + stableId = endpoint.stableId, + ) + } + + if (hinted) { + return GatewayTlsParams( + required = true, + expectedFingerprint = endpoint.tlsFingerprintSha256 ?: stored, + allowTOFU = stored == null, + stableId = endpoint.stableId, + ) + } + + if (!stored.isNullOrBlank()) { + return GatewayTlsParams( + required = true, + expectedFingerprint = stored, + allowTOFU = false, + stableId = endpoint.stableId, + ) + } + + return null + } + + fun handleCanvasA2UIActionFromWebView(payloadJson: String) { + scope.launch { + val trimmed = payloadJson.trim() + if (trimmed.isEmpty()) return@launch + + val root = + try { + json.parseToJsonElement(trimmed).asObjectOrNull() ?: return@launch + } catch (_: Throwable) { + return@launch + } + + val userActionObj = (root["userAction"] as? JsonObject) ?: root + val actionId = (userActionObj["id"] as? JsonPrimitive)?.content?.trim().orEmpty().ifEmpty { + java.util.UUID.randomUUID().toString() + } + val name = MoltbotCanvasA2UIAction.extractActionName(userActionObj) ?: return@launch + + val surfaceId = + (userActionObj["surfaceId"] as? JsonPrimitive)?.content?.trim().orEmpty().ifEmpty { "main" } + val sourceComponentId = + (userActionObj["sourceComponentId"] as? JsonPrimitive)?.content?.trim().orEmpty().ifEmpty { "-" } + val contextJson = (userActionObj["context"] as? JsonObject)?.toString() + + val sessionKey = resolveMainSessionKey() + val message = + MoltbotCanvasA2UIAction.formatAgentMessage( + actionName = name, + sessionKey = sessionKey, + surfaceId = surfaceId, + sourceComponentId = sourceComponentId, + host = displayName.value, + instanceId = instanceId.value.lowercase(), + contextJson = contextJson, + ) + + val connected = nodeConnected + var error: String? = null + if (connected) { + try { + nodeSession.sendNodeEvent( + event = "agent.request", + payloadJson = + buildJsonObject { + put("message", JsonPrimitive(message)) + put("sessionKey", JsonPrimitive(sessionKey)) + put("thinking", JsonPrimitive("low")) + put("deliver", JsonPrimitive(false)) + put("key", JsonPrimitive(actionId)) + }.toString(), + ) + } catch (e: Throwable) { + error = e.message ?: "send failed" + } + } else { + error = "gateway not connected" + } + + try { + canvas.eval( + MoltbotCanvasA2UIAction.jsDispatchA2UIActionStatus( + actionId = actionId, + ok = connected && error == null, + error = error, + ), + ) + } catch (_: Throwable) { + // ignore + } + } + } + + fun loadChat(sessionKey: String) { + val key = sessionKey.trim().ifEmpty { resolveMainSessionKey() } + chat.load(key) + } + + fun refreshChat() { + chat.refresh() + } + + fun refreshChatSessions(limit: Int? = null) { + chat.refreshSessions(limit = limit) + } + + fun setChatThinkingLevel(level: String) { + chat.setThinkingLevel(level) + } + + fun switchChatSession(sessionKey: String) { + chat.switchSession(sessionKey) + } + + fun abortChat() { + chat.abort() + } + + fun sendChat(message: String, thinking: String, attachments: List) { + chat.sendMessage(message = message, thinkingLevel = thinking, attachments = attachments) + } + + private fun handleGatewayEvent(event: String, payloadJson: String?) { + if (event == "voicewake.changed") { + if (payloadJson.isNullOrBlank()) return + try { + val payload = json.parseToJsonElement(payloadJson).asObjectOrNull() ?: return + val array = payload["triggers"] as? JsonArray ?: return + val triggers = array.mapNotNull { it.asStringOrNull() } + applyWakeWordsFromGateway(triggers) + } catch (_: Throwable) { + // ignore + } + return + } + + talkMode.handleGatewayEvent(event, payloadJson) + chat.handleGatewayEvent(event, payloadJson) + } + + private fun applyWakeWordsFromGateway(words: List) { + suppressWakeWordsSync = true + prefs.setWakeWords(words) + suppressWakeWordsSync = false + } + + private fun scheduleWakeWordsSyncIfNeeded() { + if (suppressWakeWordsSync) return + if (!_isConnected.value) return + + val snapshot = prefs.wakeWords.value + wakeWordsSyncJob?.cancel() + wakeWordsSyncJob = + scope.launch { + delay(650) + val jsonList = snapshot.joinToString(separator = ",") { it.toJsonString() } + val params = """{"triggers":[$jsonList]}""" + try { + operatorSession.request("voicewake.set", params) + } catch (_: Throwable) { + // ignore + } + } + } + + private suspend fun refreshWakeWordsFromGateway() { + if (!_isConnected.value) return + try { + val res = operatorSession.request("voicewake.get", "{}") + val payload = json.parseToJsonElement(res).asObjectOrNull() ?: return + val array = payload["triggers"] as? JsonArray ?: return + val triggers = array.mapNotNull { it.asStringOrNull() } + applyWakeWordsFromGateway(triggers) + } catch (_: Throwable) { + // ignore + } + } + + private suspend fun refreshBrandingFromGateway() { + if (!_isConnected.value) return + try { + val res = operatorSession.request("config.get", "{}") + val root = json.parseToJsonElement(res).asObjectOrNull() + val config = root?.get("config").asObjectOrNull() + val ui = config?.get("ui").asObjectOrNull() + val raw = ui?.get("seamColor").asStringOrNull()?.trim() + val sessionCfg = config?.get("session").asObjectOrNull() + val mainKey = normalizeMainKey(sessionCfg?.get("mainKey").asStringOrNull()) + applyMainSessionKey(mainKey) + + val parsed = parseHexColorArgb(raw) + _seamColorArgb.value = parsed ?: DEFAULT_SEAM_COLOR_ARGB + } catch (_: Throwable) { + // ignore + } + } + + private suspend fun handleInvoke(command: String, paramsJson: String?): GatewaySession.InvokeResult { + if ( + command.startsWith(MoltbotCanvasCommand.NamespacePrefix) || + command.startsWith(MoltbotCanvasA2UICommand.NamespacePrefix) || + command.startsWith(MoltbotCameraCommand.NamespacePrefix) || + command.startsWith(MoltbotScreenCommand.NamespacePrefix) + ) { + if (!isForeground.value) { + return GatewaySession.InvokeResult.error( + code = "NODE_BACKGROUND_UNAVAILABLE", + message = "NODE_BACKGROUND_UNAVAILABLE: canvas/camera/screen commands require foreground", + ) + } + } + if (command.startsWith(MoltbotCameraCommand.NamespacePrefix) && !cameraEnabled.value) { + return GatewaySession.InvokeResult.error( + code = "CAMERA_DISABLED", + message = "CAMERA_DISABLED: enable Camera in Settings", + ) + } + if (command.startsWith(MoltbotLocationCommand.NamespacePrefix) && + locationMode.value == LocationMode.Off + ) { + return GatewaySession.InvokeResult.error( + code = "LOCATION_DISABLED", + message = "LOCATION_DISABLED: enable Location in Settings", + ) + } + + return when (command) { + MoltbotCanvasCommand.Present.rawValue -> { + val url = CanvasController.parseNavigateUrl(paramsJson) + canvas.navigate(url) + GatewaySession.InvokeResult.ok(null) + } + MoltbotCanvasCommand.Hide.rawValue -> GatewaySession.InvokeResult.ok(null) + MoltbotCanvasCommand.Navigate.rawValue -> { + val url = CanvasController.parseNavigateUrl(paramsJson) + canvas.navigate(url) + GatewaySession.InvokeResult.ok(null) + } + MoltbotCanvasCommand.Eval.rawValue -> { + val js = + CanvasController.parseEvalJs(paramsJson) + ?: return GatewaySession.InvokeResult.error( + code = "INVALID_REQUEST", + message = "INVALID_REQUEST: javaScript required", + ) + val result = + try { + canvas.eval(js) + } catch (err: Throwable) { + return GatewaySession.InvokeResult.error( + code = "NODE_BACKGROUND_UNAVAILABLE", + message = "NODE_BACKGROUND_UNAVAILABLE: canvas unavailable", + ) + } + GatewaySession.InvokeResult.ok("""{"result":${result.toJsonString()}}""") + } + MoltbotCanvasCommand.Snapshot.rawValue -> { + val snapshotParams = CanvasController.parseSnapshotParams(paramsJson) + val base64 = + try { + canvas.snapshotBase64( + format = snapshotParams.format, + quality = snapshotParams.quality, + maxWidth = snapshotParams.maxWidth, + ) + } catch (err: Throwable) { + return GatewaySession.InvokeResult.error( + code = "NODE_BACKGROUND_UNAVAILABLE", + message = "NODE_BACKGROUND_UNAVAILABLE: canvas unavailable", + ) + } + GatewaySession.InvokeResult.ok("""{"format":"${snapshotParams.format.rawValue}","base64":"$base64"}""") + } + MoltbotCanvasA2UICommand.Reset.rawValue -> { + val a2uiUrl = resolveA2uiHostUrl() + ?: return GatewaySession.InvokeResult.error( + code = "A2UI_HOST_NOT_CONFIGURED", + message = "A2UI_HOST_NOT_CONFIGURED: gateway did not advertise canvas host", + ) + val ready = ensureA2uiReady(a2uiUrl) + if (!ready) { + return GatewaySession.InvokeResult.error( + code = "A2UI_HOST_UNAVAILABLE", + message = "A2UI host not reachable", + ) + } + val res = canvas.eval(a2uiResetJS) + GatewaySession.InvokeResult.ok(res) + } + MoltbotCanvasA2UICommand.Push.rawValue, MoltbotCanvasA2UICommand.PushJSONL.rawValue -> { + val messages = + try { + decodeA2uiMessages(command, paramsJson) + } catch (err: Throwable) { + return GatewaySession.InvokeResult.error(code = "INVALID_REQUEST", message = err.message ?: "invalid A2UI payload") + } + val a2uiUrl = resolveA2uiHostUrl() + ?: return GatewaySession.InvokeResult.error( + code = "A2UI_HOST_NOT_CONFIGURED", + message = "A2UI_HOST_NOT_CONFIGURED: gateway did not advertise canvas host", + ) + val ready = ensureA2uiReady(a2uiUrl) + if (!ready) { + return GatewaySession.InvokeResult.error( + code = "A2UI_HOST_UNAVAILABLE", + message = "A2UI host not reachable", + ) + } + val js = a2uiApplyMessagesJS(messages) + val res = canvas.eval(js) + GatewaySession.InvokeResult.ok(res) + } + MoltbotCameraCommand.Snap.rawValue -> { + showCameraHud(message = "Taking photo…", kind = CameraHudKind.Photo) + triggerCameraFlash() + val res = + try { + camera.snap(paramsJson) + } catch (err: Throwable) { + val (code, message) = invokeErrorFromThrowable(err) + showCameraHud(message = message, kind = CameraHudKind.Error, autoHideMs = 2200) + return GatewaySession.InvokeResult.error(code = code, message = message) + } + showCameraHud(message = "Photo captured", kind = CameraHudKind.Success, autoHideMs = 1600) + GatewaySession.InvokeResult.ok(res.payloadJson) + } + MoltbotCameraCommand.Clip.rawValue -> { + val includeAudio = paramsJson?.contains("\"includeAudio\":true") != false + if (includeAudio) externalAudioCaptureActive.value = true + try { + showCameraHud(message = "Recording…", kind = CameraHudKind.Recording) + val res = + try { + camera.clip(paramsJson) + } catch (err: Throwable) { + val (code, message) = invokeErrorFromThrowable(err) + showCameraHud(message = message, kind = CameraHudKind.Error, autoHideMs = 2400) + return GatewaySession.InvokeResult.error(code = code, message = message) + } + showCameraHud(message = "Clip captured", kind = CameraHudKind.Success, autoHideMs = 1800) + GatewaySession.InvokeResult.ok(res.payloadJson) + } finally { + if (includeAudio) externalAudioCaptureActive.value = false + } + } + MoltbotLocationCommand.Get.rawValue -> { + val mode = locationMode.value + if (!isForeground.value && mode != LocationMode.Always) { + return GatewaySession.InvokeResult.error( + code = "LOCATION_BACKGROUND_UNAVAILABLE", + message = "LOCATION_BACKGROUND_UNAVAILABLE: background location requires Always", + ) + } + if (!hasFineLocationPermission() && !hasCoarseLocationPermission()) { + return GatewaySession.InvokeResult.error( + code = "LOCATION_PERMISSION_REQUIRED", + message = "LOCATION_PERMISSION_REQUIRED: grant Location permission", + ) + } + if (!isForeground.value && mode == LocationMode.Always && !hasBackgroundLocationPermission()) { + return GatewaySession.InvokeResult.error( + code = "LOCATION_PERMISSION_REQUIRED", + message = "LOCATION_PERMISSION_REQUIRED: enable Always in system Settings", + ) + } + val (maxAgeMs, timeoutMs, desiredAccuracy) = parseLocationParams(paramsJson) + val preciseEnabled = locationPreciseEnabled.value + val accuracy = + when (desiredAccuracy) { + "precise" -> if (preciseEnabled && hasFineLocationPermission()) "precise" else "balanced" + "coarse" -> "coarse" + else -> if (preciseEnabled && hasFineLocationPermission()) "precise" else "balanced" + } + val providers = + when (accuracy) { + "precise" -> listOf(LocationManager.GPS_PROVIDER, LocationManager.NETWORK_PROVIDER) + "coarse" -> listOf(LocationManager.NETWORK_PROVIDER, LocationManager.GPS_PROVIDER) + else -> listOf(LocationManager.NETWORK_PROVIDER, LocationManager.GPS_PROVIDER) + } + try { + val payload = + location.getLocation( + desiredProviders = providers, + maxAgeMs = maxAgeMs, + timeoutMs = timeoutMs, + isPrecise = accuracy == "precise", + ) + GatewaySession.InvokeResult.ok(payload.payloadJson) + } catch (err: TimeoutCancellationException) { + GatewaySession.InvokeResult.error( + code = "LOCATION_TIMEOUT", + message = "LOCATION_TIMEOUT: no fix in time", + ) + } catch (err: Throwable) { + val message = err.message ?: "LOCATION_UNAVAILABLE: no fix" + GatewaySession.InvokeResult.error(code = "LOCATION_UNAVAILABLE", message = message) + } + } + MoltbotScreenCommand.Record.rawValue -> { + // Status pill mirrors screen recording state so it stays visible without overlay stacking. + _screenRecordActive.value = true + try { + val res = + try { + screenRecorder.record(paramsJson) + } catch (err: Throwable) { + val (code, message) = invokeErrorFromThrowable(err) + return GatewaySession.InvokeResult.error(code = code, message = message) + } + GatewaySession.InvokeResult.ok(res.payloadJson) + } finally { + _screenRecordActive.value = false + } + } + MoltbotSmsCommand.Send.rawValue -> { + val res = sms.send(paramsJson) + if (res.ok) { + GatewaySession.InvokeResult.ok(res.payloadJson) + } else { + val error = res.error ?: "SMS_SEND_FAILED" + val idx = error.indexOf(':') + val code = if (idx > 0) error.substring(0, idx).trim() else "SMS_SEND_FAILED" + GatewaySession.InvokeResult.error(code = code, message = error) + } + } + else -> + GatewaySession.InvokeResult.error( + code = "INVALID_REQUEST", + message = "INVALID_REQUEST: unknown command", + ) + } + } + + private fun triggerCameraFlash() { + // Token is used as a pulse trigger; value doesn't matter as long as it changes. + _cameraFlashToken.value = SystemClock.elapsedRealtimeNanos() + } + + private fun showCameraHud(message: String, kind: CameraHudKind, autoHideMs: Long? = null) { + val token = cameraHudSeq.incrementAndGet() + _cameraHud.value = CameraHudState(token = token, kind = kind, message = message) + + if (autoHideMs != null && autoHideMs > 0) { + scope.launch { + delay(autoHideMs) + if (_cameraHud.value?.token == token) _cameraHud.value = null + } + } + } + + private fun invokeErrorFromThrowable(err: Throwable): Pair { + val raw = (err.message ?: "").trim() + if (raw.isEmpty()) return "UNAVAILABLE" to "UNAVAILABLE: camera error" + + val idx = raw.indexOf(':') + if (idx <= 0) return "UNAVAILABLE" to raw + val code = raw.substring(0, idx).trim().ifEmpty { "UNAVAILABLE" } + val message = raw.substring(idx + 1).trim().ifEmpty { raw } + // Preserve full string for callers/logging, but keep the returned message human-friendly. + return code to "$code: $message" + } + + private fun parseLocationParams(paramsJson: String?): Triple { + if (paramsJson.isNullOrBlank()) { + return Triple(null, 10_000L, null) + } + val root = + try { + json.parseToJsonElement(paramsJson).asObjectOrNull() + } catch (_: Throwable) { + null + } + val maxAgeMs = (root?.get("maxAgeMs") as? JsonPrimitive)?.content?.toLongOrNull() + val timeoutMs = + (root?.get("timeoutMs") as? JsonPrimitive)?.content?.toLongOrNull()?.coerceIn(1_000L, 60_000L) + ?: 10_000L + val desiredAccuracy = + (root?.get("desiredAccuracy") as? JsonPrimitive)?.content?.trim()?.lowercase() + return Triple(maxAgeMs, timeoutMs, desiredAccuracy) + } + + private fun resolveA2uiHostUrl(): String? { + val nodeRaw = nodeSession.currentCanvasHostUrl()?.trim().orEmpty() + val operatorRaw = operatorSession.currentCanvasHostUrl()?.trim().orEmpty() + val raw = if (nodeRaw.isNotBlank()) nodeRaw else operatorRaw + if (raw.isBlank()) return null + val base = raw.trimEnd('/') + return "${base}/__moltbot__/a2ui/?platform=android" + } + + private suspend fun ensureA2uiReady(a2uiUrl: String): Boolean { + try { + val already = canvas.eval(a2uiReadyCheckJS) + if (already == "true") return true + } catch (_: Throwable) { + // ignore + } + + canvas.navigate(a2uiUrl) + repeat(50) { + try { + val ready = canvas.eval(a2uiReadyCheckJS) + if (ready == "true") return true + } catch (_: Throwable) { + // ignore + } + delay(120) + } + return false + } + + private fun decodeA2uiMessages(command: String, paramsJson: String?): String { + val raw = paramsJson?.trim().orEmpty() + if (raw.isBlank()) throw IllegalArgumentException("INVALID_REQUEST: paramsJSON required") + + val obj = + json.parseToJsonElement(raw) as? JsonObject + ?: throw IllegalArgumentException("INVALID_REQUEST: expected object params") + + val jsonlField = (obj["jsonl"] as? JsonPrimitive)?.content?.trim().orEmpty() + val hasMessagesArray = obj["messages"] is JsonArray + + if (command == MoltbotCanvasA2UICommand.PushJSONL.rawValue || (!hasMessagesArray && jsonlField.isNotBlank())) { + val jsonl = jsonlField + if (jsonl.isBlank()) throw IllegalArgumentException("INVALID_REQUEST: jsonl required") + val messages = + jsonl + .lineSequence() + .map { it.trim() } + .filter { it.isNotBlank() } + .mapIndexed { idx, line -> + val el = json.parseToJsonElement(line) + val msg = + el as? JsonObject + ?: throw IllegalArgumentException("A2UI JSONL line ${idx + 1}: expected a JSON object") + validateA2uiV0_8(msg, idx + 1) + msg + } + .toList() + return JsonArray(messages).toString() + } + + val arr = obj["messages"] as? JsonArray ?: throw IllegalArgumentException("INVALID_REQUEST: messages[] required") + val out = + arr.mapIndexed { idx, el -> + val msg = + el as? JsonObject + ?: throw IllegalArgumentException("A2UI messages[${idx}]: expected a JSON object") + validateA2uiV0_8(msg, idx + 1) + msg + } + return JsonArray(out).toString() + } + + private fun validateA2uiV0_8(msg: JsonObject, lineNumber: Int) { + if (msg.containsKey("createSurface")) { + throw IllegalArgumentException( + "A2UI JSONL line $lineNumber: looks like A2UI v0.9 (`createSurface`). Canvas supports v0.8 messages only.", + ) + } + val allowed = setOf("beginRendering", "surfaceUpdate", "dataModelUpdate", "deleteSurface") + val matched = msg.keys.filter { allowed.contains(it) } + if (matched.size != 1) { + val found = msg.keys.sorted().joinToString(", ") + throw IllegalArgumentException( + "A2UI JSONL line $lineNumber: expected exactly one of ${allowed.sorted().joinToString(", ")}; found: $found", + ) + } + } +} + +private data class Quad(val first: A, val second: B, val third: C, val fourth: D) + +private const val DEFAULT_SEAM_COLOR_ARGB: Long = 0xFF4F7A9A + +private const val a2uiReadyCheckJS: String = + """ + (() => { + try { + return !!globalThis.clawdbotA2UI && typeof globalThis.clawdbotA2UI.applyMessages === 'function'; + } catch (_) { + return false; + } + })() + """ + +private const val a2uiResetJS: String = + """ + (() => { + try { + if (!globalThis.clawdbotA2UI) return { ok: false, error: "missing moltbotA2UI" }; + return globalThis.clawdbotA2UI.reset(); + } catch (e) { + return { ok: false, error: String(e?.message ?? e) }; + } + })() + """ + +private fun a2uiApplyMessagesJS(messagesJson: String): String { + return """ + (() => { + try { + if (!globalThis.clawdbotA2UI) return { ok: false, error: "missing moltbotA2UI" }; + const messages = $messagesJson; + return globalThis.clawdbotA2UI.applyMessages(messages); + } catch (e) { + return { ok: false, error: String(e?.message ?? e) }; + } + })() + """.trimIndent() +} + +private fun String.toJsonString(): String { + val escaped = + this.replace("\\", "\\\\") + .replace("\"", "\\\"") + .replace("\n", "\\n") + .replace("\r", "\\r") + return "\"$escaped\"" +} + +private fun JsonElement?.asObjectOrNull(): JsonObject? = this as? JsonObject + +private fun JsonElement?.asStringOrNull(): String? = + when (this) { + is JsonNull -> null + is JsonPrimitive -> content + else -> null + } + +private fun parseHexColorArgb(raw: String?): Long? { + val trimmed = raw?.trim().orEmpty() + if (trimmed.isEmpty()) return null + val hex = if (trimmed.startsWith("#")) trimmed.drop(1) else trimmed + if (hex.length != 6) return null + val rgb = hex.toLongOrNull(16) ?: return null + return 0xFF000000L or rgb +} diff --git a/apps/android/app/src/main/java/bot/molt/android/PermissionRequester.kt b/apps/android/app/src/main/java/bot/molt/android/PermissionRequester.kt new file mode 100644 index 000000000..78ae0b62b --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/PermissionRequester.kt @@ -0,0 +1,133 @@ +package bot.molt.android + +import android.content.pm.PackageManager +import android.content.Intent +import android.Manifest +import android.net.Uri +import android.provider.Settings +import androidx.appcompat.app.AlertDialog +import androidx.activity.ComponentActivity +import androidx.activity.result.ActivityResultLauncher +import androidx.activity.result.contract.ActivityResultContracts +import androidx.core.content.ContextCompat +import androidx.core.app.ActivityCompat +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlinx.coroutines.withContext +import kotlinx.coroutines.suspendCancellableCoroutine +import kotlin.coroutines.resume + +class PermissionRequester(private val activity: ComponentActivity) { + private val mutex = Mutex() + private var pending: CompletableDeferred>? = null + + private val launcher: ActivityResultLauncher> = + activity.registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { result -> + val p = pending + pending = null + p?.complete(result) + } + + suspend fun requestIfMissing( + permissions: List, + timeoutMs: Long = 20_000, + ): Map = + mutex.withLock { + val missing = + permissions.filter { perm -> + ContextCompat.checkSelfPermission(activity, perm) != PackageManager.PERMISSION_GRANTED + } + if (missing.isEmpty()) { + return permissions.associateWith { true } + } + + val needsRationale = + missing.any { ActivityCompat.shouldShowRequestPermissionRationale(activity, it) } + if (needsRationale) { + val proceed = showRationaleDialog(missing) + if (!proceed) { + return permissions.associateWith { perm -> + ContextCompat.checkSelfPermission(activity, perm) == PackageManager.PERMISSION_GRANTED + } + } + } + + val deferred = CompletableDeferred>() + pending = deferred + withContext(Dispatchers.Main) { + launcher.launch(missing.toTypedArray()) + } + + val result = + withContext(Dispatchers.Default) { + kotlinx.coroutines.withTimeout(timeoutMs) { deferred.await() } + } + + // Merge: if something was already granted, treat it as granted even if launcher omitted it. + val merged = + permissions.associateWith { perm -> + val nowGranted = + ContextCompat.checkSelfPermission(activity, perm) == PackageManager.PERMISSION_GRANTED + result[perm] == true || nowGranted + } + + val denied = + merged.filterValues { !it }.keys.filter { + !ActivityCompat.shouldShowRequestPermissionRationale(activity, it) + } + if (denied.isNotEmpty()) { + showSettingsDialog(denied) + } + + return merged + } + + private suspend fun showRationaleDialog(permissions: List): Boolean = + withContext(Dispatchers.Main) { + suspendCancellableCoroutine { cont -> + AlertDialog.Builder(activity) + .setTitle("Permission required") + .setMessage(buildRationaleMessage(permissions)) + .setPositiveButton("Continue") { _, _ -> cont.resume(true) } + .setNegativeButton("Not now") { _, _ -> cont.resume(false) } + .setOnCancelListener { cont.resume(false) } + .show() + } + } + + private fun showSettingsDialog(permissions: List) { + AlertDialog.Builder(activity) + .setTitle("Enable permission in Settings") + .setMessage(buildSettingsMessage(permissions)) + .setPositiveButton("Open Settings") { _, _ -> + val intent = + Intent( + Settings.ACTION_APPLICATION_DETAILS_SETTINGS, + Uri.fromParts("package", activity.packageName, null), + ) + activity.startActivity(intent) + } + .setNegativeButton("Cancel", null) + .show() + } + + private fun buildRationaleMessage(permissions: List): String { + val labels = permissions.map { permissionLabel(it) } + return "Moltbot needs ${labels.joinToString(", ")} permissions to continue." + } + + private fun buildSettingsMessage(permissions: List): String { + val labels = permissions.map { permissionLabel(it) } + return "Please enable ${labels.joinToString(", ")} in Android Settings to continue." + } + + private fun permissionLabel(permission: String): String = + when (permission) { + Manifest.permission.CAMERA -> "Camera" + Manifest.permission.RECORD_AUDIO -> "Microphone" + Manifest.permission.SEND_SMS -> "SMS" + else -> permission + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ScreenCaptureRequester.kt b/apps/android/app/src/main/java/bot/molt/android/ScreenCaptureRequester.kt new file mode 100644 index 000000000..29d662044 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ScreenCaptureRequester.kt @@ -0,0 +1,65 @@ +package bot.molt.android + +import android.app.Activity +import android.content.Context +import android.content.Intent +import android.media.projection.MediaProjectionManager +import androidx.activity.ComponentActivity +import androidx.activity.result.ActivityResultLauncher +import androidx.activity.result.contract.ActivityResultContracts +import androidx.appcompat.app.AlertDialog +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlinx.coroutines.withContext +import kotlinx.coroutines.withTimeout +import kotlinx.coroutines.suspendCancellableCoroutine +import kotlin.coroutines.resume + +class ScreenCaptureRequester(private val activity: ComponentActivity) { + data class CaptureResult(val resultCode: Int, val data: Intent) + + private val mutex = Mutex() + private var pending: CompletableDeferred? = null + + private val launcher: ActivityResultLauncher = + activity.registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result -> + val p = pending + pending = null + val data = result.data + if (result.resultCode == Activity.RESULT_OK && data != null) { + p?.complete(CaptureResult(result.resultCode, data)) + } else { + p?.complete(null) + } + } + + suspend fun requestCapture(timeoutMs: Long = 20_000): CaptureResult? = + mutex.withLock { + val proceed = showRationaleDialog() + if (!proceed) return null + + val mgr = activity.getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager + val intent = mgr.createScreenCaptureIntent() + + val deferred = CompletableDeferred() + pending = deferred + withContext(Dispatchers.Main) { launcher.launch(intent) } + + withContext(Dispatchers.Default) { withTimeout(timeoutMs) { deferred.await() } } + } + + private suspend fun showRationaleDialog(): Boolean = + withContext(Dispatchers.Main) { + suspendCancellableCoroutine { cont -> + AlertDialog.Builder(activity) + .setTitle("Screen recording required") + .setMessage("Moltbot needs to record the screen for this command.") + .setPositiveButton("Continue") { _, _ -> cont.resume(true) } + .setNegativeButton("Not now") { _, _ -> cont.resume(false) } + .setOnCancelListener { cont.resume(false) } + .show() + } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/SecurePrefs.kt b/apps/android/app/src/main/java/bot/molt/android/SecurePrefs.kt new file mode 100644 index 000000000..7ee3294dc --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/SecurePrefs.kt @@ -0,0 +1,308 @@ +@file:Suppress("DEPRECATION") + +package bot.molt.android + +import android.content.Context +import androidx.core.content.edit +import androidx.security.crypto.EncryptedSharedPreferences +import androidx.security.crypto.MasterKey +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonNull +import kotlinx.serialization.json.JsonPrimitive +import java.util.UUID + +class SecurePrefs(context: Context) { + companion object { + val defaultWakeWords: List = listOf("clawd", "claude") + private const val displayNameKey = "node.displayName" + private const val voiceWakeModeKey = "voiceWake.mode" + } + + private val json = Json { ignoreUnknownKeys = true } + + private val masterKey = + MasterKey.Builder(context) + .setKeyScheme(MasterKey.KeyScheme.AES256_GCM) + .build() + + private val prefs = + EncryptedSharedPreferences.create( + context, + "moltbot.node.secure", + masterKey, + EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV, + EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM, + ) + + private val _instanceId = MutableStateFlow(loadOrCreateInstanceId()) + val instanceId: StateFlow = _instanceId + + private val _displayName = + MutableStateFlow(loadOrMigrateDisplayName(context = context)) + val displayName: StateFlow = _displayName + + private val _cameraEnabled = MutableStateFlow(prefs.getBoolean("camera.enabled", true)) + val cameraEnabled: StateFlow = _cameraEnabled + + private val _locationMode = + MutableStateFlow(LocationMode.fromRawValue(prefs.getString("location.enabledMode", "off"))) + val locationMode: StateFlow = _locationMode + + private val _locationPreciseEnabled = + MutableStateFlow(prefs.getBoolean("location.preciseEnabled", true)) + val locationPreciseEnabled: StateFlow = _locationPreciseEnabled + + private val _preventSleep = MutableStateFlow(prefs.getBoolean("screen.preventSleep", true)) + val preventSleep: StateFlow = _preventSleep + + private val _manualEnabled = + MutableStateFlow(readBoolWithMigration("gateway.manual.enabled", "bridge.manual.enabled", false)) + val manualEnabled: StateFlow = _manualEnabled + + private val _manualHost = + MutableStateFlow(readStringWithMigration("gateway.manual.host", "bridge.manual.host", "")) + val manualHost: StateFlow = _manualHost + + private val _manualPort = + MutableStateFlow(readIntWithMigration("gateway.manual.port", "bridge.manual.port", 18789)) + val manualPort: StateFlow = _manualPort + + private val _manualTls = + MutableStateFlow(readBoolWithMigration("gateway.manual.tls", null, true)) + val manualTls: StateFlow = _manualTls + + private val _lastDiscoveredStableId = + MutableStateFlow( + readStringWithMigration( + "gateway.lastDiscoveredStableID", + "bridge.lastDiscoveredStableId", + "", + ), + ) + val lastDiscoveredStableId: StateFlow = _lastDiscoveredStableId + + private val _canvasDebugStatusEnabled = + MutableStateFlow(prefs.getBoolean("canvas.debugStatusEnabled", false)) + val canvasDebugStatusEnabled: StateFlow = _canvasDebugStatusEnabled + + private val _wakeWords = MutableStateFlow(loadWakeWords()) + val wakeWords: StateFlow> = _wakeWords + + private val _voiceWakeMode = MutableStateFlow(loadVoiceWakeMode()) + val voiceWakeMode: StateFlow = _voiceWakeMode + + private val _talkEnabled = MutableStateFlow(prefs.getBoolean("talk.enabled", false)) + val talkEnabled: StateFlow = _talkEnabled + + fun setLastDiscoveredStableId(value: String) { + val trimmed = value.trim() + prefs.edit { putString("gateway.lastDiscoveredStableID", trimmed) } + _lastDiscoveredStableId.value = trimmed + } + + fun setDisplayName(value: String) { + val trimmed = value.trim() + prefs.edit { putString(displayNameKey, trimmed) } + _displayName.value = trimmed + } + + fun setCameraEnabled(value: Boolean) { + prefs.edit { putBoolean("camera.enabled", value) } + _cameraEnabled.value = value + } + + fun setLocationMode(mode: LocationMode) { + prefs.edit { putString("location.enabledMode", mode.rawValue) } + _locationMode.value = mode + } + + fun setLocationPreciseEnabled(value: Boolean) { + prefs.edit { putBoolean("location.preciseEnabled", value) } + _locationPreciseEnabled.value = value + } + + fun setPreventSleep(value: Boolean) { + prefs.edit { putBoolean("screen.preventSleep", value) } + _preventSleep.value = value + } + + fun setManualEnabled(value: Boolean) { + prefs.edit { putBoolean("gateway.manual.enabled", value) } + _manualEnabled.value = value + } + + fun setManualHost(value: String) { + val trimmed = value.trim() + prefs.edit { putString("gateway.manual.host", trimmed) } + _manualHost.value = trimmed + } + + fun setManualPort(value: Int) { + prefs.edit { putInt("gateway.manual.port", value) } + _manualPort.value = value + } + + fun setManualTls(value: Boolean) { + prefs.edit { putBoolean("gateway.manual.tls", value) } + _manualTls.value = value + } + + fun setCanvasDebugStatusEnabled(value: Boolean) { + prefs.edit { putBoolean("canvas.debugStatusEnabled", value) } + _canvasDebugStatusEnabled.value = value + } + + fun loadGatewayToken(): String? { + val key = "gateway.token.${_instanceId.value}" + val stored = prefs.getString(key, null)?.trim() + if (!stored.isNullOrEmpty()) return stored + val legacy = prefs.getString("bridge.token.${_instanceId.value}", null)?.trim() + return legacy?.takeIf { it.isNotEmpty() } + } + + fun saveGatewayToken(token: String) { + val key = "gateway.token.${_instanceId.value}" + prefs.edit { putString(key, token.trim()) } + } + + fun loadGatewayPassword(): String? { + val key = "gateway.password.${_instanceId.value}" + val stored = prefs.getString(key, null)?.trim() + return stored?.takeIf { it.isNotEmpty() } + } + + fun saveGatewayPassword(password: String) { + val key = "gateway.password.${_instanceId.value}" + prefs.edit { putString(key, password.trim()) } + } + + fun loadGatewayTlsFingerprint(stableId: String): String? { + val key = "gateway.tls.$stableId" + return prefs.getString(key, null)?.trim()?.takeIf { it.isNotEmpty() } + } + + fun saveGatewayTlsFingerprint(stableId: String, fingerprint: String) { + val key = "gateway.tls.$stableId" + prefs.edit { putString(key, fingerprint.trim()) } + } + + fun getString(key: String): String? { + return prefs.getString(key, null) + } + + fun putString(key: String, value: String) { + prefs.edit { putString(key, value) } + } + + fun remove(key: String) { + prefs.edit { remove(key) } + } + + private fun loadOrCreateInstanceId(): String { + val existing = prefs.getString("node.instanceId", null)?.trim() + if (!existing.isNullOrBlank()) return existing + val fresh = UUID.randomUUID().toString() + prefs.edit { putString("node.instanceId", fresh) } + return fresh + } + + private fun loadOrMigrateDisplayName(context: Context): String { + val existing = prefs.getString(displayNameKey, null)?.trim().orEmpty() + if (existing.isNotEmpty() && existing != "Android Node") return existing + + val candidate = DeviceNames.bestDefaultNodeName(context).trim() + val resolved = candidate.ifEmpty { "Android Node" } + + prefs.edit { putString(displayNameKey, resolved) } + return resolved + } + + fun setWakeWords(words: List) { + val sanitized = WakeWords.sanitize(words, defaultWakeWords) + val encoded = + JsonArray(sanitized.map { JsonPrimitive(it) }).toString() + prefs.edit { putString("voiceWake.triggerWords", encoded) } + _wakeWords.value = sanitized + } + + fun setVoiceWakeMode(mode: VoiceWakeMode) { + prefs.edit { putString(voiceWakeModeKey, mode.rawValue) } + _voiceWakeMode.value = mode + } + + fun setTalkEnabled(value: Boolean) { + prefs.edit { putBoolean("talk.enabled", value) } + _talkEnabled.value = value + } + + private fun loadVoiceWakeMode(): VoiceWakeMode { + val raw = prefs.getString(voiceWakeModeKey, null) + val resolved = VoiceWakeMode.fromRawValue(raw) + + // Default ON (foreground) when unset. + if (raw.isNullOrBlank()) { + prefs.edit { putString(voiceWakeModeKey, resolved.rawValue) } + } + + return resolved + } + + private fun loadWakeWords(): List { + val raw = prefs.getString("voiceWake.triggerWords", null)?.trim() + if (raw.isNullOrEmpty()) return defaultWakeWords + return try { + val element = json.parseToJsonElement(raw) + val array = element as? JsonArray ?: return defaultWakeWords + val decoded = + array.mapNotNull { item -> + when (item) { + is JsonNull -> null + is JsonPrimitive -> item.content.trim().takeIf { it.isNotEmpty() } + else -> null + } + } + WakeWords.sanitize(decoded, defaultWakeWords) + } catch (_: Throwable) { + defaultWakeWords + } + } + + private fun readBoolWithMigration(newKey: String, oldKey: String?, defaultValue: Boolean): Boolean { + if (prefs.contains(newKey)) { + return prefs.getBoolean(newKey, defaultValue) + } + if (oldKey != null && prefs.contains(oldKey)) { + val value = prefs.getBoolean(oldKey, defaultValue) + prefs.edit { putBoolean(newKey, value) } + return value + } + return defaultValue + } + + private fun readStringWithMigration(newKey: String, oldKey: String?, defaultValue: String): String { + if (prefs.contains(newKey)) { + return prefs.getString(newKey, defaultValue) ?: defaultValue + } + if (oldKey != null && prefs.contains(oldKey)) { + val value = prefs.getString(oldKey, defaultValue) ?: defaultValue + prefs.edit { putString(newKey, value) } + return value + } + return defaultValue + } + + private fun readIntWithMigration(newKey: String, oldKey: String?, defaultValue: Int): Int { + if (prefs.contains(newKey)) { + return prefs.getInt(newKey, defaultValue) + } + if (oldKey != null && prefs.contains(oldKey)) { + val value = prefs.getInt(oldKey, defaultValue) + prefs.edit { putInt(newKey, value) } + return value + } + return defaultValue + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/SessionKey.kt b/apps/android/app/src/main/java/bot/molt/android/SessionKey.kt new file mode 100644 index 000000000..e64051649 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/SessionKey.kt @@ -0,0 +1,13 @@ +package bot.molt.android + +internal fun normalizeMainKey(raw: String?): String { + val trimmed = raw?.trim() + return if (!trimmed.isNullOrEmpty()) trimmed else "main" +} + +internal fun isCanonicalMainSessionKey(raw: String?): Boolean { + val trimmed = raw?.trim().orEmpty() + if (trimmed.isEmpty()) return false + if (trimmed == "global") return true + return trimmed.startsWith("agent:") +} diff --git a/apps/android/app/src/main/java/bot/molt/android/VoiceWakeMode.kt b/apps/android/app/src/main/java/bot/molt/android/VoiceWakeMode.kt new file mode 100644 index 000000000..e0862cc25 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/VoiceWakeMode.kt @@ -0,0 +1,14 @@ +package bot.molt.android + +enum class VoiceWakeMode(val rawValue: String) { + Off("off"), + Foreground("foreground"), + Always("always"), + ; + + companion object { + fun fromRawValue(raw: String?): VoiceWakeMode { + return entries.firstOrNull { it.rawValue == raw?.trim()?.lowercase() } ?: Foreground + } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/WakeWords.kt b/apps/android/app/src/main/java/bot/molt/android/WakeWords.kt new file mode 100644 index 000000000..56b85a5df --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/WakeWords.kt @@ -0,0 +1,21 @@ +package bot.molt.android + +object WakeWords { + const val maxWords: Int = 32 + const val maxWordLength: Int = 64 + + fun parseCommaSeparated(input: String): List { + return input.split(",").map { it.trim() }.filter { it.isNotEmpty() } + } + + fun parseIfChanged(input: String, current: List): List? { + val parsed = parseCommaSeparated(input) + return if (parsed == current) null else parsed + } + + fun sanitize(words: List, defaults: List): List { + val cleaned = + words.map { it.trim() }.filter { it.isNotEmpty() }.take(maxWords).map { it.take(maxWordLength) } + return cleaned.ifEmpty { defaults } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/chat/ChatController.kt b/apps/android/app/src/main/java/bot/molt/android/chat/ChatController.kt new file mode 100644 index 000000000..eef66fece --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/chat/ChatController.kt @@ -0,0 +1,524 @@ +package bot.molt.android.chat + +import bot.molt.android.gateway.GatewaySession +import java.util.UUID +import java.util.concurrent.ConcurrentHashMap +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonElement +import kotlinx.serialization.json.JsonNull +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.buildJsonObject + +class ChatController( + private val scope: CoroutineScope, + private val session: GatewaySession, + private val json: Json, + private val supportsChatSubscribe: Boolean, +) { + private val _sessionKey = MutableStateFlow("main") + val sessionKey: StateFlow = _sessionKey.asStateFlow() + + private val _sessionId = MutableStateFlow(null) + val sessionId: StateFlow = _sessionId.asStateFlow() + + private val _messages = MutableStateFlow>(emptyList()) + val messages: StateFlow> = _messages.asStateFlow() + + private val _errorText = MutableStateFlow(null) + val errorText: StateFlow = _errorText.asStateFlow() + + private val _healthOk = MutableStateFlow(false) + val healthOk: StateFlow = _healthOk.asStateFlow() + + private val _thinkingLevel = MutableStateFlow("off") + val thinkingLevel: StateFlow = _thinkingLevel.asStateFlow() + + private val _pendingRunCount = MutableStateFlow(0) + val pendingRunCount: StateFlow = _pendingRunCount.asStateFlow() + + private val _streamingAssistantText = MutableStateFlow(null) + val streamingAssistantText: StateFlow = _streamingAssistantText.asStateFlow() + + private val pendingToolCallsById = ConcurrentHashMap() + private val _pendingToolCalls = MutableStateFlow>(emptyList()) + val pendingToolCalls: StateFlow> = _pendingToolCalls.asStateFlow() + + private val _sessions = MutableStateFlow>(emptyList()) + val sessions: StateFlow> = _sessions.asStateFlow() + + private val pendingRuns = mutableSetOf() + private val pendingRunTimeoutJobs = ConcurrentHashMap() + private val pendingRunTimeoutMs = 120_000L + + private var lastHealthPollAtMs: Long? = null + + fun onDisconnected(message: String) { + _healthOk.value = false + // Not an error; keep connection status in the UI pill. + _errorText.value = null + clearPendingRuns() + pendingToolCallsById.clear() + publishPendingToolCalls() + _streamingAssistantText.value = null + _sessionId.value = null + } + + fun load(sessionKey: String) { + val key = sessionKey.trim().ifEmpty { "main" } + _sessionKey.value = key + scope.launch { bootstrap(forceHealth = true) } + } + + fun applyMainSessionKey(mainSessionKey: String) { + val trimmed = mainSessionKey.trim() + if (trimmed.isEmpty()) return + if (_sessionKey.value == trimmed) return + if (_sessionKey.value != "main") return + _sessionKey.value = trimmed + scope.launch { bootstrap(forceHealth = true) } + } + + fun refresh() { + scope.launch { bootstrap(forceHealth = true) } + } + + fun refreshSessions(limit: Int? = null) { + scope.launch { fetchSessions(limit = limit) } + } + + fun setThinkingLevel(thinkingLevel: String) { + val normalized = normalizeThinking(thinkingLevel) + if (normalized == _thinkingLevel.value) return + _thinkingLevel.value = normalized + } + + fun switchSession(sessionKey: String) { + val key = sessionKey.trim() + if (key.isEmpty()) return + if (key == _sessionKey.value) return + _sessionKey.value = key + scope.launch { bootstrap(forceHealth = true) } + } + + fun sendMessage( + message: String, + thinkingLevel: String, + attachments: List, + ) { + val trimmed = message.trim() + if (trimmed.isEmpty() && attachments.isEmpty()) return + if (!_healthOk.value) { + _errorText.value = "Gateway health not OK; cannot send" + return + } + + val runId = UUID.randomUUID().toString() + val text = if (trimmed.isEmpty() && attachments.isNotEmpty()) "See attached." else trimmed + val sessionKey = _sessionKey.value + val thinking = normalizeThinking(thinkingLevel) + + // Optimistic user message. + val userContent = + buildList { + add(ChatMessageContent(type = "text", text = text)) + for (att in attachments) { + add( + ChatMessageContent( + type = att.type, + mimeType = att.mimeType, + fileName = att.fileName, + base64 = att.base64, + ), + ) + } + } + _messages.value = + _messages.value + + ChatMessage( + id = UUID.randomUUID().toString(), + role = "user", + content = userContent, + timestampMs = System.currentTimeMillis(), + ) + + armPendingRunTimeout(runId) + synchronized(pendingRuns) { + pendingRuns.add(runId) + _pendingRunCount.value = pendingRuns.size + } + + _errorText.value = null + _streamingAssistantText.value = null + pendingToolCallsById.clear() + publishPendingToolCalls() + + scope.launch { + try { + val params = + buildJsonObject { + put("sessionKey", JsonPrimitive(sessionKey)) + put("message", JsonPrimitive(text)) + put("thinking", JsonPrimitive(thinking)) + put("timeoutMs", JsonPrimitive(30_000)) + put("idempotencyKey", JsonPrimitive(runId)) + if (attachments.isNotEmpty()) { + put( + "attachments", + JsonArray( + attachments.map { att -> + buildJsonObject { + put("type", JsonPrimitive(att.type)) + put("mimeType", JsonPrimitive(att.mimeType)) + put("fileName", JsonPrimitive(att.fileName)) + put("content", JsonPrimitive(att.base64)) + } + }, + ), + ) + } + } + val res = session.request("chat.send", params.toString()) + val actualRunId = parseRunId(res) ?: runId + if (actualRunId != runId) { + clearPendingRun(runId) + armPendingRunTimeout(actualRunId) + synchronized(pendingRuns) { + pendingRuns.add(actualRunId) + _pendingRunCount.value = pendingRuns.size + } + } + } catch (err: Throwable) { + clearPendingRun(runId) + _errorText.value = err.message + } + } + } + + fun abort() { + val runIds = + synchronized(pendingRuns) { + pendingRuns.toList() + } + if (runIds.isEmpty()) return + scope.launch { + for (runId in runIds) { + try { + val params = + buildJsonObject { + put("sessionKey", JsonPrimitive(_sessionKey.value)) + put("runId", JsonPrimitive(runId)) + } + session.request("chat.abort", params.toString()) + } catch (_: Throwable) { + // best-effort + } + } + } + } + + fun handleGatewayEvent(event: String, payloadJson: String?) { + when (event) { + "tick" -> { + scope.launch { pollHealthIfNeeded(force = false) } + } + "health" -> { + // If we receive a health snapshot, the gateway is reachable. + _healthOk.value = true + } + "seqGap" -> { + _errorText.value = "Event stream interrupted; try refreshing." + clearPendingRuns() + } + "chat" -> { + if (payloadJson.isNullOrBlank()) return + handleChatEvent(payloadJson) + } + "agent" -> { + if (payloadJson.isNullOrBlank()) return + handleAgentEvent(payloadJson) + } + } + } + + private suspend fun bootstrap(forceHealth: Boolean) { + _errorText.value = null + _healthOk.value = false + clearPendingRuns() + pendingToolCallsById.clear() + publishPendingToolCalls() + _streamingAssistantText.value = null + _sessionId.value = null + + val key = _sessionKey.value + try { + if (supportsChatSubscribe) { + try { + session.sendNodeEvent("chat.subscribe", """{"sessionKey":"$key"}""") + } catch (_: Throwable) { + // best-effort + } + } + + val historyJson = session.request("chat.history", """{"sessionKey":"$key"}""") + val history = parseHistory(historyJson, sessionKey = key) + _messages.value = history.messages + _sessionId.value = history.sessionId + history.thinkingLevel?.trim()?.takeIf { it.isNotEmpty() }?.let { _thinkingLevel.value = it } + + pollHealthIfNeeded(force = forceHealth) + fetchSessions(limit = 50) + } catch (err: Throwable) { + _errorText.value = err.message + } + } + + private suspend fun fetchSessions(limit: Int?) { + try { + val params = + buildJsonObject { + put("includeGlobal", JsonPrimitive(true)) + put("includeUnknown", JsonPrimitive(false)) + if (limit != null && limit > 0) put("limit", JsonPrimitive(limit)) + } + val res = session.request("sessions.list", params.toString()) + _sessions.value = parseSessions(res) + } catch (_: Throwable) { + // best-effort + } + } + + private suspend fun pollHealthIfNeeded(force: Boolean) { + val now = System.currentTimeMillis() + val last = lastHealthPollAtMs + if (!force && last != null && now - last < 10_000) return + lastHealthPollAtMs = now + try { + session.request("health", null) + _healthOk.value = true + } catch (_: Throwable) { + _healthOk.value = false + } + } + + private fun handleChatEvent(payloadJson: String) { + val payload = json.parseToJsonElement(payloadJson).asObjectOrNull() ?: return + val sessionKey = payload["sessionKey"].asStringOrNull()?.trim() + if (!sessionKey.isNullOrEmpty() && sessionKey != _sessionKey.value) return + + val runId = payload["runId"].asStringOrNull() + if (runId != null) { + val isPending = + synchronized(pendingRuns) { + pendingRuns.contains(runId) + } + if (!isPending) return + } + + val state = payload["state"].asStringOrNull() + when (state) { + "final", "aborted", "error" -> { + if (state == "error") { + _errorText.value = payload["errorMessage"].asStringOrNull() ?: "Chat failed" + } + if (runId != null) clearPendingRun(runId) else clearPendingRuns() + pendingToolCallsById.clear() + publishPendingToolCalls() + _streamingAssistantText.value = null + scope.launch { + try { + val historyJson = + session.request("chat.history", """{"sessionKey":"${_sessionKey.value}"}""") + val history = parseHistory(historyJson, sessionKey = _sessionKey.value) + _messages.value = history.messages + _sessionId.value = history.sessionId + history.thinkingLevel?.trim()?.takeIf { it.isNotEmpty() }?.let { _thinkingLevel.value = it } + } catch (_: Throwable) { + // best-effort + } + } + } + } + } + + private fun handleAgentEvent(payloadJson: String) { + val payload = json.parseToJsonElement(payloadJson).asObjectOrNull() ?: return + val runId = payload["runId"].asStringOrNull() + val sessionId = _sessionId.value + if (sessionId != null && runId != sessionId) return + + val stream = payload["stream"].asStringOrNull() + val data = payload["data"].asObjectOrNull() + + when (stream) { + "assistant" -> { + val text = data?.get("text")?.asStringOrNull() + if (!text.isNullOrEmpty()) { + _streamingAssistantText.value = text + } + } + "tool" -> { + val phase = data?.get("phase")?.asStringOrNull() + val name = data?.get("name")?.asStringOrNull() + val toolCallId = data?.get("toolCallId")?.asStringOrNull() + if (phase.isNullOrEmpty() || name.isNullOrEmpty() || toolCallId.isNullOrEmpty()) return + + val ts = payload["ts"].asLongOrNull() ?: System.currentTimeMillis() + if (phase == "start") { + val args = data?.get("args").asObjectOrNull() + pendingToolCallsById[toolCallId] = + ChatPendingToolCall( + toolCallId = toolCallId, + name = name, + args = args, + startedAtMs = ts, + isError = null, + ) + publishPendingToolCalls() + } else if (phase == "result") { + pendingToolCallsById.remove(toolCallId) + publishPendingToolCalls() + } + } + "error" -> { + _errorText.value = "Event stream interrupted; try refreshing." + clearPendingRuns() + pendingToolCallsById.clear() + publishPendingToolCalls() + _streamingAssistantText.value = null + } + } + } + + private fun publishPendingToolCalls() { + _pendingToolCalls.value = + pendingToolCallsById.values.sortedBy { it.startedAtMs } + } + + private fun armPendingRunTimeout(runId: String) { + pendingRunTimeoutJobs[runId]?.cancel() + pendingRunTimeoutJobs[runId] = + scope.launch { + delay(pendingRunTimeoutMs) + val stillPending = + synchronized(pendingRuns) { + pendingRuns.contains(runId) + } + if (!stillPending) return@launch + clearPendingRun(runId) + _errorText.value = "Timed out waiting for a reply; try again or refresh." + } + } + + private fun clearPendingRun(runId: String) { + pendingRunTimeoutJobs.remove(runId)?.cancel() + synchronized(pendingRuns) { + pendingRuns.remove(runId) + _pendingRunCount.value = pendingRuns.size + } + } + + private fun clearPendingRuns() { + for ((_, job) in pendingRunTimeoutJobs) { + job.cancel() + } + pendingRunTimeoutJobs.clear() + synchronized(pendingRuns) { + pendingRuns.clear() + _pendingRunCount.value = 0 + } + } + + private fun parseHistory(historyJson: String, sessionKey: String): ChatHistory { + val root = json.parseToJsonElement(historyJson).asObjectOrNull() ?: return ChatHistory(sessionKey, null, null, emptyList()) + val sid = root["sessionId"].asStringOrNull() + val thinkingLevel = root["thinkingLevel"].asStringOrNull() + val array = root["messages"].asArrayOrNull() ?: JsonArray(emptyList()) + + val messages = + array.mapNotNull { item -> + val obj = item.asObjectOrNull() ?: return@mapNotNull null + val role = obj["role"].asStringOrNull() ?: return@mapNotNull null + val content = obj["content"].asArrayOrNull()?.mapNotNull(::parseMessageContent) ?: emptyList() + val ts = obj["timestamp"].asLongOrNull() + ChatMessage( + id = UUID.randomUUID().toString(), + role = role, + content = content, + timestampMs = ts, + ) + } + + return ChatHistory(sessionKey = sessionKey, sessionId = sid, thinkingLevel = thinkingLevel, messages = messages) + } + + private fun parseMessageContent(el: JsonElement): ChatMessageContent? { + val obj = el.asObjectOrNull() ?: return null + val type = obj["type"].asStringOrNull() ?: "text" + return if (type == "text") { + ChatMessageContent(type = "text", text = obj["text"].asStringOrNull()) + } else { + ChatMessageContent( + type = type, + mimeType = obj["mimeType"].asStringOrNull(), + fileName = obj["fileName"].asStringOrNull(), + base64 = obj["content"].asStringOrNull(), + ) + } + } + + private fun parseSessions(jsonString: String): List { + val root = json.parseToJsonElement(jsonString).asObjectOrNull() ?: return emptyList() + val sessions = root["sessions"].asArrayOrNull() ?: return emptyList() + return sessions.mapNotNull { item -> + val obj = item.asObjectOrNull() ?: return@mapNotNull null + val key = obj["key"].asStringOrNull()?.trim().orEmpty() + if (key.isEmpty()) return@mapNotNull null + val updatedAt = obj["updatedAt"].asLongOrNull() + val displayName = obj["displayName"].asStringOrNull()?.trim() + ChatSessionEntry(key = key, updatedAtMs = updatedAt, displayName = displayName) + } + } + + private fun parseRunId(resJson: String): String? { + return try { + json.parseToJsonElement(resJson).asObjectOrNull()?.get("runId").asStringOrNull() + } catch (_: Throwable) { + null + } + } + + private fun normalizeThinking(raw: String): String { + return when (raw.trim().lowercase()) { + "low" -> "low" + "medium" -> "medium" + "high" -> "high" + else -> "off" + } + } +} + +private fun JsonElement?.asObjectOrNull(): JsonObject? = this as? JsonObject + +private fun JsonElement?.asArrayOrNull(): JsonArray? = this as? JsonArray + +private fun JsonElement?.asStringOrNull(): String? = + when (this) { + is JsonNull -> null + is JsonPrimitive -> content + else -> null + } + +private fun JsonElement?.asLongOrNull(): Long? = + when (this) { + is JsonPrimitive -> content.toLongOrNull() + else -> null + } diff --git a/apps/android/app/src/main/java/bot/molt/android/chat/ChatModels.kt b/apps/android/app/src/main/java/bot/molt/android/chat/ChatModels.kt new file mode 100644 index 000000000..340624452 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/chat/ChatModels.kt @@ -0,0 +1,44 @@ +package bot.molt.android.chat + +data class ChatMessage( + val id: String, + val role: String, + val content: List, + val timestampMs: Long?, +) + +data class ChatMessageContent( + val type: String = "text", + val text: String? = null, + val mimeType: String? = null, + val fileName: String? = null, + val base64: String? = null, +) + +data class ChatPendingToolCall( + val toolCallId: String, + val name: String, + val args: kotlinx.serialization.json.JsonObject? = null, + val startedAtMs: Long, + val isError: Boolean? = null, +) + +data class ChatSessionEntry( + val key: String, + val updatedAtMs: Long?, + val displayName: String? = null, +) + +data class ChatHistory( + val sessionKey: String, + val sessionId: String?, + val thinkingLevel: String?, + val messages: List, +) + +data class OutgoingAttachment( + val type: String, + val mimeType: String, + val fileName: String, + val base64: String, +) diff --git a/apps/android/app/src/main/java/bot/molt/android/gateway/BonjourEscapes.kt b/apps/android/app/src/main/java/bot/molt/android/gateway/BonjourEscapes.kt new file mode 100644 index 000000000..2c0c34d68 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/gateway/BonjourEscapes.kt @@ -0,0 +1,35 @@ +package bot.molt.android.gateway + +object BonjourEscapes { + fun decode(input: String): String { + if (input.isEmpty()) return input + + val bytes = mutableListOf() + var i = 0 + while (i < input.length) { + if (input[i] == '\\' && i + 3 < input.length) { + val d0 = input[i + 1] + val d1 = input[i + 2] + val d2 = input[i + 3] + if (d0.isDigit() && d1.isDigit() && d2.isDigit()) { + val value = + ((d0.code - '0'.code) * 100) + ((d1.code - '0'.code) * 10) + (d2.code - '0'.code) + if (value in 0..255) { + bytes.add(value.toByte()) + i += 4 + continue + } + } + } + + val codePoint = Character.codePointAt(input, i) + val charBytes = String(Character.toChars(codePoint)).toByteArray(Charsets.UTF_8) + for (b in charBytes) { + bytes.add(b) + } + i += Character.charCount(codePoint) + } + + return String(bytes.toByteArray(), Charsets.UTF_8) + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/gateway/DeviceAuthStore.kt b/apps/android/app/src/main/java/bot/molt/android/gateway/DeviceAuthStore.kt new file mode 100644 index 000000000..6b90b4672 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/gateway/DeviceAuthStore.kt @@ -0,0 +1,26 @@ +package bot.molt.android.gateway + +import bot.molt.android.SecurePrefs + +class DeviceAuthStore(private val prefs: SecurePrefs) { + fun loadToken(deviceId: String, role: String): String? { + val key = tokenKey(deviceId, role) + return prefs.getString(key)?.trim()?.takeIf { it.isNotEmpty() } + } + + fun saveToken(deviceId: String, role: String, token: String) { + val key = tokenKey(deviceId, role) + prefs.putString(key, token.trim()) + } + + fun clearToken(deviceId: String, role: String) { + val key = tokenKey(deviceId, role) + prefs.remove(key) + } + + private fun tokenKey(deviceId: String, role: String): String { + val normalizedDevice = deviceId.trim().lowercase() + val normalizedRole = role.trim().lowercase() + return "gateway.deviceToken.$normalizedDevice.$normalizedRole" + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/gateway/DeviceIdentityStore.kt b/apps/android/app/src/main/java/bot/molt/android/gateway/DeviceIdentityStore.kt new file mode 100644 index 000000000..58a0aceff --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/gateway/DeviceIdentityStore.kt @@ -0,0 +1,146 @@ +package bot.molt.android.gateway + +import android.content.Context +import android.util.Base64 +import java.io.File +import java.security.KeyFactory +import java.security.KeyPairGenerator +import java.security.MessageDigest +import java.security.Signature +import java.security.spec.PKCS8EncodedKeySpec +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.Json + +@Serializable +data class DeviceIdentity( + val deviceId: String, + val publicKeyRawBase64: String, + val privateKeyPkcs8Base64: String, + val createdAtMs: Long, +) + +class DeviceIdentityStore(context: Context) { + private val json = Json { ignoreUnknownKeys = true } + private val identityFile = File(context.filesDir, "moltbot/identity/device.json") + + @Synchronized + fun loadOrCreate(): DeviceIdentity { + val existing = load() + if (existing != null) { + val derived = deriveDeviceId(existing.publicKeyRawBase64) + if (derived != null && derived != existing.deviceId) { + val updated = existing.copy(deviceId = derived) + save(updated) + return updated + } + return existing + } + val fresh = generate() + save(fresh) + return fresh + } + + fun signPayload(payload: String, identity: DeviceIdentity): String? { + return try { + val privateKeyBytes = Base64.decode(identity.privateKeyPkcs8Base64, Base64.DEFAULT) + val keySpec = PKCS8EncodedKeySpec(privateKeyBytes) + val keyFactory = KeyFactory.getInstance("Ed25519") + val privateKey = keyFactory.generatePrivate(keySpec) + val signature = Signature.getInstance("Ed25519") + signature.initSign(privateKey) + signature.update(payload.toByteArray(Charsets.UTF_8)) + base64UrlEncode(signature.sign()) + } catch (_: Throwable) { + null + } + } + + fun publicKeyBase64Url(identity: DeviceIdentity): String? { + return try { + val raw = Base64.decode(identity.publicKeyRawBase64, Base64.DEFAULT) + base64UrlEncode(raw) + } catch (_: Throwable) { + null + } + } + + private fun load(): DeviceIdentity? { + return try { + if (!identityFile.exists()) return null + val raw = identityFile.readText(Charsets.UTF_8) + val decoded = json.decodeFromString(DeviceIdentity.serializer(), raw) + if (decoded.deviceId.isBlank() || + decoded.publicKeyRawBase64.isBlank() || + decoded.privateKeyPkcs8Base64.isBlank() + ) { + null + } else { + decoded + } + } catch (_: Throwable) { + null + } + } + + private fun save(identity: DeviceIdentity) { + try { + identityFile.parentFile?.mkdirs() + val encoded = json.encodeToString(DeviceIdentity.serializer(), identity) + identityFile.writeText(encoded, Charsets.UTF_8) + } catch (_: Throwable) { + // best-effort only + } + } + + private fun generate(): DeviceIdentity { + val keyPair = KeyPairGenerator.getInstance("Ed25519").generateKeyPair() + val spki = keyPair.public.encoded + val rawPublic = stripSpkiPrefix(spki) + val deviceId = sha256Hex(rawPublic) + val privateKey = keyPair.private.encoded + return DeviceIdentity( + deviceId = deviceId, + publicKeyRawBase64 = Base64.encodeToString(rawPublic, Base64.NO_WRAP), + privateKeyPkcs8Base64 = Base64.encodeToString(privateKey, Base64.NO_WRAP), + createdAtMs = System.currentTimeMillis(), + ) + } + + private fun deriveDeviceId(publicKeyRawBase64: String): String? { + return try { + val raw = Base64.decode(publicKeyRawBase64, Base64.DEFAULT) + sha256Hex(raw) + } catch (_: Throwable) { + null + } + } + + private fun stripSpkiPrefix(spki: ByteArray): ByteArray { + if (spki.size == ED25519_SPKI_PREFIX.size + 32 && + spki.copyOfRange(0, ED25519_SPKI_PREFIX.size).contentEquals(ED25519_SPKI_PREFIX) + ) { + return spki.copyOfRange(ED25519_SPKI_PREFIX.size, spki.size) + } + return spki + } + + private fun sha256Hex(data: ByteArray): String { + val digest = MessageDigest.getInstance("SHA-256").digest(data) + val out = StringBuilder(digest.size * 2) + for (byte in digest) { + out.append(String.format("%02x", byte)) + } + return out.toString() + } + + private fun base64UrlEncode(data: ByteArray): String { + return Base64.encodeToString(data, Base64.URL_SAFE or Base64.NO_WRAP or Base64.NO_PADDING) + } + + companion object { + private val ED25519_SPKI_PREFIX = + byteArrayOf( + 0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00, + ) + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayDiscovery.kt b/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayDiscovery.kt new file mode 100644 index 000000000..53bdb5588 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayDiscovery.kt @@ -0,0 +1,519 @@ +package bot.molt.android.gateway + +import android.content.Context +import android.net.ConnectivityManager +import android.net.DnsResolver +import android.net.NetworkCapabilities +import android.net.nsd.NsdManager +import android.net.nsd.NsdServiceInfo +import android.os.CancellationSignal +import android.util.Log +import java.io.IOException +import java.net.InetSocketAddress +import java.nio.ByteBuffer +import java.nio.charset.CodingErrorAction +import java.util.concurrent.ConcurrentHashMap +import java.util.concurrent.Executor +import java.util.concurrent.Executors +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch +import kotlinx.coroutines.suspendCancellableCoroutine +import org.xbill.DNS.AAAARecord +import org.xbill.DNS.ARecord +import org.xbill.DNS.DClass +import org.xbill.DNS.ExtendedResolver +import org.xbill.DNS.Message +import org.xbill.DNS.Name +import org.xbill.DNS.PTRRecord +import org.xbill.DNS.Record +import org.xbill.DNS.Rcode +import org.xbill.DNS.Resolver +import org.xbill.DNS.SRVRecord +import org.xbill.DNS.Section +import org.xbill.DNS.SimpleResolver +import org.xbill.DNS.TextParseException +import org.xbill.DNS.TXTRecord +import org.xbill.DNS.Type +import kotlin.coroutines.resume +import kotlin.coroutines.resumeWithException + +@Suppress("DEPRECATION") +class GatewayDiscovery( + context: Context, + private val scope: CoroutineScope, +) { + private val nsd = context.getSystemService(NsdManager::class.java) + private val connectivity = context.getSystemService(ConnectivityManager::class.java) + private val dns = DnsResolver.getInstance() + private val serviceType = "_moltbot-gw._tcp." + private val wideAreaDomain = "moltbot.internal." + private val logTag = "Moltbot/GatewayDiscovery" + + private val localById = ConcurrentHashMap() + private val unicastById = ConcurrentHashMap() + private val _gateways = MutableStateFlow>(emptyList()) + val gateways: StateFlow> = _gateways.asStateFlow() + + private val _statusText = MutableStateFlow("Searching…") + val statusText: StateFlow = _statusText.asStateFlow() + + private var unicastJob: Job? = null + private val dnsExecutor: Executor = Executors.newCachedThreadPool() + + @Volatile private var lastWideAreaRcode: Int? = null + @Volatile private var lastWideAreaCount: Int = 0 + + private val discoveryListener = + object : NsdManager.DiscoveryListener { + override fun onStartDiscoveryFailed(serviceType: String, errorCode: Int) {} + override fun onStopDiscoveryFailed(serviceType: String, errorCode: Int) {} + override fun onDiscoveryStarted(serviceType: String) {} + override fun onDiscoveryStopped(serviceType: String) {} + + override fun onServiceFound(serviceInfo: NsdServiceInfo) { + if (serviceInfo.serviceType != this@GatewayDiscovery.serviceType) return + resolve(serviceInfo) + } + + override fun onServiceLost(serviceInfo: NsdServiceInfo) { + val serviceName = BonjourEscapes.decode(serviceInfo.serviceName) + val id = stableId(serviceName, "local.") + localById.remove(id) + publish() + } + } + + init { + startLocalDiscovery() + startUnicastDiscovery(wideAreaDomain) + } + + private fun startLocalDiscovery() { + try { + nsd.discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD, discoveryListener) + } catch (_: Throwable) { + // ignore (best-effort) + } + } + + private fun stopLocalDiscovery() { + try { + nsd.stopServiceDiscovery(discoveryListener) + } catch (_: Throwable) { + // ignore (best-effort) + } + } + + private fun startUnicastDiscovery(domain: String) { + unicastJob = + scope.launch(Dispatchers.IO) { + while (true) { + try { + refreshUnicast(domain) + } catch (_: Throwable) { + // ignore (best-effort) + } + delay(5000) + } + } + } + + private fun resolve(serviceInfo: NsdServiceInfo) { + nsd.resolveService( + serviceInfo, + object : NsdManager.ResolveListener { + override fun onResolveFailed(serviceInfo: NsdServiceInfo, errorCode: Int) {} + + override fun onServiceResolved(resolved: NsdServiceInfo) { + val host = resolved.host?.hostAddress ?: return + val port = resolved.port + if (port <= 0) return + + val rawServiceName = resolved.serviceName + val serviceName = BonjourEscapes.decode(rawServiceName) + val displayName = BonjourEscapes.decode(txt(resolved, "displayName") ?: serviceName) + val lanHost = txt(resolved, "lanHost") + val tailnetDns = txt(resolved, "tailnetDns") + val gatewayPort = txtInt(resolved, "gatewayPort") + val canvasPort = txtInt(resolved, "canvasPort") + val tlsEnabled = txtBool(resolved, "gatewayTls") + val tlsFingerprint = txt(resolved, "gatewayTlsSha256") + val id = stableId(serviceName, "local.") + localById[id] = + GatewayEndpoint( + stableId = id, + name = displayName, + host = host, + port = port, + lanHost = lanHost, + tailnetDns = tailnetDns, + gatewayPort = gatewayPort, + canvasPort = canvasPort, + tlsEnabled = tlsEnabled, + tlsFingerprintSha256 = tlsFingerprint, + ) + publish() + } + }, + ) + } + + private fun publish() { + _gateways.value = + (localById.values + unicastById.values).sortedBy { it.name.lowercase() } + _statusText.value = buildStatusText() + } + + private fun buildStatusText(): String { + val localCount = localById.size + val wideRcode = lastWideAreaRcode + val wideCount = lastWideAreaCount + + val wide = + when (wideRcode) { + null -> "Wide: ?" + Rcode.NOERROR -> "Wide: $wideCount" + Rcode.NXDOMAIN -> "Wide: NXDOMAIN" + else -> "Wide: ${Rcode.string(wideRcode)}" + } + + return when { + localCount == 0 && wideRcode == null -> "Searching for gateways…" + localCount == 0 -> "$wide" + else -> "Local: $localCount • $wide" + } + } + + private fun stableId(serviceName: String, domain: String): String { + return "${serviceType}|${domain}|${normalizeName(serviceName)}" + } + + private fun normalizeName(raw: String): String { + return raw.trim().split(Regex("\\s+")).joinToString(" ") + } + + private fun txt(info: NsdServiceInfo, key: String): String? { + val bytes = info.attributes[key] ?: return null + return try { + String(bytes, Charsets.UTF_8).trim().ifEmpty { null } + } catch (_: Throwable) { + null + } + } + + private fun txtInt(info: NsdServiceInfo, key: String): Int? { + return txt(info, key)?.toIntOrNull() + } + + private fun txtBool(info: NsdServiceInfo, key: String): Boolean { + val raw = txt(info, key)?.trim()?.lowercase() ?: return false + return raw == "1" || raw == "true" || raw == "yes" + } + + private suspend fun refreshUnicast(domain: String) { + val ptrName = "${serviceType}${domain}" + val ptrMsg = lookupUnicastMessage(ptrName, Type.PTR) ?: return + val ptrRecords = records(ptrMsg, Section.ANSWER).mapNotNull { it as? PTRRecord } + + val next = LinkedHashMap() + for (ptr in ptrRecords) { + val instanceFqdn = ptr.target.toString() + val srv = + recordByName(ptrMsg, instanceFqdn, Type.SRV) as? SRVRecord + ?: run { + val msg = lookupUnicastMessage(instanceFqdn, Type.SRV) ?: return@run null + recordByName(msg, instanceFqdn, Type.SRV) as? SRVRecord + } + ?: continue + val port = srv.port + if (port <= 0) continue + + val targetFqdn = srv.target.toString() + val host = + resolveHostFromMessage(ptrMsg, targetFqdn) + ?: resolveHostFromMessage(lookupUnicastMessage(instanceFqdn, Type.SRV), targetFqdn) + ?: resolveHostUnicast(targetFqdn) + ?: continue + + val txtFromPtr = + recordsByName(ptrMsg, Section.ADDITIONAL)[keyName(instanceFqdn)] + .orEmpty() + .mapNotNull { it as? TXTRecord } + val txt = + if (txtFromPtr.isNotEmpty()) { + txtFromPtr + } else { + val msg = lookupUnicastMessage(instanceFqdn, Type.TXT) + records(msg, Section.ANSWER).mapNotNull { it as? TXTRecord } + } + val instanceName = BonjourEscapes.decode(decodeInstanceName(instanceFqdn, domain)) + val displayName = BonjourEscapes.decode(txtValue(txt, "displayName") ?: instanceName) + val lanHost = txtValue(txt, "lanHost") + val tailnetDns = txtValue(txt, "tailnetDns") + val gatewayPort = txtIntValue(txt, "gatewayPort") + val canvasPort = txtIntValue(txt, "canvasPort") + val tlsEnabled = txtBoolValue(txt, "gatewayTls") + val tlsFingerprint = txtValue(txt, "gatewayTlsSha256") + val id = stableId(instanceName, domain) + next[id] = + GatewayEndpoint( + stableId = id, + name = displayName, + host = host, + port = port, + lanHost = lanHost, + tailnetDns = tailnetDns, + gatewayPort = gatewayPort, + canvasPort = canvasPort, + tlsEnabled = tlsEnabled, + tlsFingerprintSha256 = tlsFingerprint, + ) + } + + unicastById.clear() + unicastById.putAll(next) + lastWideAreaRcode = ptrMsg.header.rcode + lastWideAreaCount = next.size + publish() + + if (next.isEmpty()) { + Log.d( + logTag, + "wide-area discovery: 0 results for $ptrName (rcode=${Rcode.string(ptrMsg.header.rcode)})", + ) + } + } + + private fun decodeInstanceName(instanceFqdn: String, domain: String): String { + val suffix = "${serviceType}${domain}" + val withoutSuffix = + if (instanceFqdn.endsWith(suffix)) { + instanceFqdn.removeSuffix(suffix) + } else { + instanceFqdn.substringBefore(serviceType) + } + return normalizeName(stripTrailingDot(withoutSuffix)) + } + + private fun stripTrailingDot(raw: String): String { + return raw.removeSuffix(".") + } + + private suspend fun lookupUnicastMessage(name: String, type: Int): Message? { + val query = + try { + Message.newQuery( + org.xbill.DNS.Record.newRecord( + Name.fromString(name), + type, + DClass.IN, + ), + ) + } catch (_: TextParseException) { + return null + } + + val system = queryViaSystemDns(query) + if (records(system, Section.ANSWER).any { it.type == type }) return system + + val direct = createDirectResolver() ?: return system + return try { + val msg = direct.send(query) + if (records(msg, Section.ANSWER).any { it.type == type }) msg else system + } catch (_: Throwable) { + system + } + } + + private suspend fun queryViaSystemDns(query: Message): Message? { + val network = preferredDnsNetwork() + val bytes = + try { + rawQuery(network, query.toWire()) + } catch (_: Throwable) { + return null + } + + return try { + Message(bytes) + } catch (_: IOException) { + null + } + } + + private fun records(msg: Message?, section: Int): List { + return msg?.getSectionArray(section)?.toList() ?: emptyList() + } + + private fun keyName(raw: String): String { + return raw.trim().lowercase() + } + + private fun recordsByName(msg: Message, section: Int): Map> { + val next = LinkedHashMap>() + for (r in records(msg, section)) { + val name = r.name?.toString() ?: continue + next.getOrPut(keyName(name)) { mutableListOf() }.add(r) + } + return next + } + + private fun recordByName(msg: Message, fqdn: String, type: Int): Record? { + val key = keyName(fqdn) + val byNameAnswer = recordsByName(msg, Section.ANSWER) + val fromAnswer = byNameAnswer[key].orEmpty().firstOrNull { it.type == type } + if (fromAnswer != null) return fromAnswer + + val byNameAdditional = recordsByName(msg, Section.ADDITIONAL) + return byNameAdditional[key].orEmpty().firstOrNull { it.type == type } + } + + private fun resolveHostFromMessage(msg: Message?, hostname: String): String? { + val m = msg ?: return null + val key = keyName(hostname) + val additional = recordsByName(m, Section.ADDITIONAL)[key].orEmpty() + val a = additional.mapNotNull { it as? ARecord }.mapNotNull { it.address?.hostAddress } + val aaaa = additional.mapNotNull { it as? AAAARecord }.mapNotNull { it.address?.hostAddress } + return a.firstOrNull() ?: aaaa.firstOrNull() + } + + private fun preferredDnsNetwork(): android.net.Network? { + val cm = connectivity ?: return null + + // Prefer VPN (Tailscale) when present; otherwise use the active network. + cm.allNetworks.firstOrNull { n -> + val caps = cm.getNetworkCapabilities(n) ?: return@firstOrNull false + caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN) + }?.let { return it } + + return cm.activeNetwork + } + + private fun createDirectResolver(): Resolver? { + val cm = connectivity ?: return null + + val candidateNetworks = + buildList { + cm.allNetworks + .firstOrNull { n -> + val caps = cm.getNetworkCapabilities(n) ?: return@firstOrNull false + caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN) + }?.let(::add) + cm.activeNetwork?.let(::add) + }.distinct() + + val servers = + candidateNetworks + .asSequence() + .flatMap { n -> + cm.getLinkProperties(n)?.dnsServers?.asSequence() ?: emptySequence() + } + .distinctBy { it.hostAddress ?: it.toString() } + .toList() + if (servers.isEmpty()) return null + + return try { + val resolvers = + servers.mapNotNull { addr -> + try { + SimpleResolver().apply { + setAddress(InetSocketAddress(addr, 53)) + setTimeout(3) + } + } catch (_: Throwable) { + null + } + } + if (resolvers.isEmpty()) return null + ExtendedResolver(resolvers.toTypedArray()).apply { setTimeout(3) } + } catch (_: Throwable) { + null + } + } + + private suspend fun rawQuery(network: android.net.Network?, wireQuery: ByteArray): ByteArray = + suspendCancellableCoroutine { cont -> + val signal = CancellationSignal() + cont.invokeOnCancellation { signal.cancel() } + + dns.rawQuery( + network, + wireQuery, + DnsResolver.FLAG_EMPTY, + dnsExecutor, + signal, + object : DnsResolver.Callback { + override fun onAnswer(answer: ByteArray, rcode: Int) { + cont.resume(answer) + } + + override fun onError(error: DnsResolver.DnsException) { + cont.resumeWithException(error) + } + }, + ) + } + + private fun txtValue(records: List, key: String): String? { + val prefix = "$key=" + for (r in records) { + val strings: List = + try { + r.strings.mapNotNull { it as? String } + } catch (_: Throwable) { + emptyList() + } + for (s in strings) { + val trimmed = decodeDnsTxtString(s).trim() + if (trimmed.startsWith(prefix)) { + return trimmed.removePrefix(prefix).trim().ifEmpty { null } + } + } + } + return null + } + + private fun txtIntValue(records: List, key: String): Int? { + return txtValue(records, key)?.toIntOrNull() + } + + private fun txtBoolValue(records: List, key: String): Boolean { + val raw = txtValue(records, key)?.trim()?.lowercase() ?: return false + return raw == "1" || raw == "true" || raw == "yes" + } + + private fun decodeDnsTxtString(raw: String): String { + // dnsjava treats TXT as opaque bytes and decodes as ISO-8859-1 to preserve bytes. + // Our TXT payload is UTF-8 (written by the gateway), so re-decode when possible. + val bytes = raw.toByteArray(Charsets.ISO_8859_1) + val decoder = + Charsets.UTF_8 + .newDecoder() + .onMalformedInput(CodingErrorAction.REPORT) + .onUnmappableCharacter(CodingErrorAction.REPORT) + return try { + decoder.decode(ByteBuffer.wrap(bytes)).toString() + } catch (_: Throwable) { + raw + } + } + + private suspend fun resolveHostUnicast(hostname: String): String? { + val a = + records(lookupUnicastMessage(hostname, Type.A), Section.ANSWER) + .mapNotNull { it as? ARecord } + .mapNotNull { it.address?.hostAddress } + val aaaa = + records(lookupUnicastMessage(hostname, Type.AAAA), Section.ANSWER) + .mapNotNull { it as? AAAARecord } + .mapNotNull { it.address?.hostAddress } + + return a.firstOrNull() ?: aaaa.firstOrNull() + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayEndpoint.kt b/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayEndpoint.kt new file mode 100644 index 000000000..2c524cc67 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayEndpoint.kt @@ -0,0 +1,26 @@ +package bot.molt.android.gateway + +data class GatewayEndpoint( + val stableId: String, + val name: String, + val host: String, + val port: Int, + val lanHost: String? = null, + val tailnetDns: String? = null, + val gatewayPort: Int? = null, + val canvasPort: Int? = null, + val tlsEnabled: Boolean = false, + val tlsFingerprintSha256: String? = null, +) { + companion object { + fun manual(host: String, port: Int): GatewayEndpoint = + GatewayEndpoint( + stableId = "manual|${host.lowercase()}|$port", + name = "$host:$port", + host = host, + port = port, + tlsEnabled = false, + tlsFingerprintSha256 = null, + ) + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayProtocol.kt b/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayProtocol.kt new file mode 100644 index 000000000..6836331be --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayProtocol.kt @@ -0,0 +1,3 @@ +package bot.molt.android.gateway + +const val GATEWAY_PROTOCOL_VERSION = 3 diff --git a/apps/android/app/src/main/java/bot/molt/android/gateway/GatewaySession.kt b/apps/android/app/src/main/java/bot/molt/android/gateway/GatewaySession.kt new file mode 100644 index 000000000..13074b918 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/gateway/GatewaySession.kt @@ -0,0 +1,683 @@ +package bot.molt.android.gateway + +import android.util.Log +import java.util.Locale +import java.util.UUID +import java.util.concurrent.ConcurrentHashMap +import java.util.concurrent.atomic.AtomicBoolean +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.TimeoutCancellationException +import kotlinx.coroutines.cancelAndJoin +import kotlinx.coroutines.delay +import kotlinx.coroutines.isActive +import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlinx.coroutines.withContext +import kotlinx.coroutines.withTimeout +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonElement +import kotlinx.serialization.json.JsonNull +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.buildJsonObject +import okhttp3.OkHttpClient +import okhttp3.Request +import okhttp3.Response +import okhttp3.WebSocket +import okhttp3.WebSocketListener + +data class GatewayClientInfo( + val id: String, + val displayName: String?, + val version: String, + val platform: String, + val mode: String, + val instanceId: String?, + val deviceFamily: String?, + val modelIdentifier: String?, +) + +data class GatewayConnectOptions( + val role: String, + val scopes: List, + val caps: List, + val commands: List, + val permissions: Map, + val client: GatewayClientInfo, + val userAgent: String? = null, +) + +class GatewaySession( + private val scope: CoroutineScope, + private val identityStore: DeviceIdentityStore, + private val deviceAuthStore: DeviceAuthStore, + private val onConnected: (serverName: String?, remoteAddress: String?, mainSessionKey: String?) -> Unit, + private val onDisconnected: (message: String) -> Unit, + private val onEvent: (event: String, payloadJson: String?) -> Unit, + private val onInvoke: (suspend (InvokeRequest) -> InvokeResult)? = null, + private val onTlsFingerprint: ((stableId: String, fingerprint: String) -> Unit)? = null, +) { + data class InvokeRequest( + val id: String, + val nodeId: String, + val command: String, + val paramsJson: String?, + val timeoutMs: Long?, + ) + + data class InvokeResult(val ok: Boolean, val payloadJson: String?, val error: ErrorShape?) { + companion object { + fun ok(payloadJson: String?) = InvokeResult(ok = true, payloadJson = payloadJson, error = null) + fun error(code: String, message: String) = + InvokeResult(ok = false, payloadJson = null, error = ErrorShape(code = code, message = message)) + } + } + + data class ErrorShape(val code: String, val message: String) + + private val json = Json { ignoreUnknownKeys = true } + private val writeLock = Mutex() + private val pending = ConcurrentHashMap>() + + @Volatile private var canvasHostUrl: String? = null + @Volatile private var mainSessionKey: String? = null + + private data class DesiredConnection( + val endpoint: GatewayEndpoint, + val token: String?, + val password: String?, + val options: GatewayConnectOptions, + val tls: GatewayTlsParams?, + ) + + private var desired: DesiredConnection? = null + private var job: Job? = null + @Volatile private var currentConnection: Connection? = null + + fun connect( + endpoint: GatewayEndpoint, + token: String?, + password: String?, + options: GatewayConnectOptions, + tls: GatewayTlsParams? = null, + ) { + desired = DesiredConnection(endpoint, token, password, options, tls) + if (job == null) { + job = scope.launch(Dispatchers.IO) { runLoop() } + } + } + + fun disconnect() { + desired = null + currentConnection?.closeQuietly() + scope.launch(Dispatchers.IO) { + job?.cancelAndJoin() + job = null + canvasHostUrl = null + mainSessionKey = null + onDisconnected("Offline") + } + } + + fun reconnect() { + currentConnection?.closeQuietly() + } + + fun currentCanvasHostUrl(): String? = canvasHostUrl + fun currentMainSessionKey(): String? = mainSessionKey + + suspend fun sendNodeEvent(event: String, payloadJson: String?) { + val conn = currentConnection ?: return + val parsedPayload = payloadJson?.let { parseJsonOrNull(it) } + val params = + buildJsonObject { + put("event", JsonPrimitive(event)) + if (parsedPayload != null) { + put("payload", parsedPayload) + } else if (payloadJson != null) { + put("payloadJSON", JsonPrimitive(payloadJson)) + } else { + put("payloadJSON", JsonNull) + } + } + try { + conn.request("node.event", params, timeoutMs = 8_000) + } catch (err: Throwable) { + Log.w("MoltbotGateway", "node.event failed: ${err.message ?: err::class.java.simpleName}") + } + } + + suspend fun request(method: String, paramsJson: String?, timeoutMs: Long = 15_000): String { + val conn = currentConnection ?: throw IllegalStateException("not connected") + val params = + if (paramsJson.isNullOrBlank()) { + null + } else { + json.parseToJsonElement(paramsJson) + } + val res = conn.request(method, params, timeoutMs) + if (res.ok) return res.payloadJson ?: "" + val err = res.error + throw IllegalStateException("${err?.code ?: "UNAVAILABLE"}: ${err?.message ?: "request failed"}") + } + + private data class RpcResponse(val id: String, val ok: Boolean, val payloadJson: String?, val error: ErrorShape?) + + private inner class Connection( + private val endpoint: GatewayEndpoint, + private val token: String?, + private val password: String?, + private val options: GatewayConnectOptions, + private val tls: GatewayTlsParams?, + ) { + private val connectDeferred = CompletableDeferred() + private val closedDeferred = CompletableDeferred() + private val isClosed = AtomicBoolean(false) + private val connectNonceDeferred = CompletableDeferred() + private val client: OkHttpClient = buildClient() + private var socket: WebSocket? = null + private val loggerTag = "MoltbotGateway" + + val remoteAddress: String = + if (endpoint.host.contains(":")) { + "[${endpoint.host}]:${endpoint.port}" + } else { + "${endpoint.host}:${endpoint.port}" + } + + suspend fun connect() { + val scheme = if (tls != null) "wss" else "ws" + val url = "$scheme://${endpoint.host}:${endpoint.port}" + val request = Request.Builder().url(url).build() + socket = client.newWebSocket(request, Listener()) + try { + connectDeferred.await() + } catch (err: Throwable) { + throw err + } + } + + suspend fun request(method: String, params: JsonElement?, timeoutMs: Long): RpcResponse { + val id = UUID.randomUUID().toString() + val deferred = CompletableDeferred() + pending[id] = deferred + val frame = + buildJsonObject { + put("type", JsonPrimitive("req")) + put("id", JsonPrimitive(id)) + put("method", JsonPrimitive(method)) + if (params != null) put("params", params) + } + sendJson(frame) + return try { + withTimeout(timeoutMs) { deferred.await() } + } catch (err: TimeoutCancellationException) { + pending.remove(id) + throw IllegalStateException("request timeout") + } + } + + suspend fun sendJson(obj: JsonObject) { + val jsonString = obj.toString() + writeLock.withLock { + socket?.send(jsonString) + } + } + + suspend fun awaitClose() = closedDeferred.await() + + fun closeQuietly() { + if (isClosed.compareAndSet(false, true)) { + socket?.close(1000, "bye") + socket = null + closedDeferred.complete(Unit) + } + } + + private fun buildClient(): OkHttpClient { + val builder = OkHttpClient.Builder() + val tlsConfig = buildGatewayTlsConfig(tls) { fingerprint -> + onTlsFingerprint?.invoke(tls?.stableId ?: endpoint.stableId, fingerprint) + } + if (tlsConfig != null) { + builder.sslSocketFactory(tlsConfig.sslSocketFactory, tlsConfig.trustManager) + builder.hostnameVerifier(tlsConfig.hostnameVerifier) + } + return builder.build() + } + + private inner class Listener : WebSocketListener() { + override fun onOpen(webSocket: WebSocket, response: Response) { + scope.launch { + try { + val nonce = awaitConnectNonce() + sendConnect(nonce) + } catch (err: Throwable) { + connectDeferred.completeExceptionally(err) + closeQuietly() + } + } + } + + override fun onMessage(webSocket: WebSocket, text: String) { + scope.launch { handleMessage(text) } + } + + override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) { + if (!connectDeferred.isCompleted) { + connectDeferred.completeExceptionally(t) + } + if (isClosed.compareAndSet(false, true)) { + failPending() + closedDeferred.complete(Unit) + onDisconnected("Gateway error: ${t.message ?: t::class.java.simpleName}") + } + } + + override fun onClosed(webSocket: WebSocket, code: Int, reason: String) { + if (!connectDeferred.isCompleted) { + connectDeferred.completeExceptionally(IllegalStateException("Gateway closed: $reason")) + } + if (isClosed.compareAndSet(false, true)) { + failPending() + closedDeferred.complete(Unit) + onDisconnected("Gateway closed: $reason") + } + } + } + + private suspend fun sendConnect(connectNonce: String?) { + val identity = identityStore.loadOrCreate() + val storedToken = deviceAuthStore.loadToken(identity.deviceId, options.role) + val trimmedToken = token?.trim().orEmpty() + val authToken = if (storedToken.isNullOrBlank()) trimmedToken else storedToken + val canFallbackToShared = !storedToken.isNullOrBlank() && trimmedToken.isNotBlank() + val payload = buildConnectParams(identity, connectNonce, authToken, password?.trim()) + val res = request("connect", payload, timeoutMs = 8_000) + if (!res.ok) { + val msg = res.error?.message ?: "connect failed" + if (canFallbackToShared) { + deviceAuthStore.clearToken(identity.deviceId, options.role) + } + throw IllegalStateException(msg) + } + val payloadJson = res.payloadJson ?: throw IllegalStateException("connect failed: missing payload") + val obj = json.parseToJsonElement(payloadJson).asObjectOrNull() ?: throw IllegalStateException("connect failed") + val serverName = obj["server"].asObjectOrNull()?.get("host").asStringOrNull() + val authObj = obj["auth"].asObjectOrNull() + val deviceToken = authObj?.get("deviceToken").asStringOrNull() + val authRole = authObj?.get("role").asStringOrNull() ?: options.role + if (!deviceToken.isNullOrBlank()) { + deviceAuthStore.saveToken(identity.deviceId, authRole, deviceToken) + } + val rawCanvas = obj["canvasHostUrl"].asStringOrNull() + canvasHostUrl = normalizeCanvasHostUrl(rawCanvas, endpoint) + val sessionDefaults = + obj["snapshot"].asObjectOrNull() + ?.get("sessionDefaults").asObjectOrNull() + mainSessionKey = sessionDefaults?.get("mainSessionKey").asStringOrNull() + onConnected(serverName, remoteAddress, mainSessionKey) + connectDeferred.complete(Unit) + } + + private fun buildConnectParams( + identity: DeviceIdentity, + connectNonce: String?, + authToken: String, + authPassword: String?, + ): JsonObject { + val client = options.client + val locale = Locale.getDefault().toLanguageTag() + val clientObj = + buildJsonObject { + put("id", JsonPrimitive(client.id)) + client.displayName?.let { put("displayName", JsonPrimitive(it)) } + put("version", JsonPrimitive(client.version)) + put("platform", JsonPrimitive(client.platform)) + put("mode", JsonPrimitive(client.mode)) + client.instanceId?.let { put("instanceId", JsonPrimitive(it)) } + client.deviceFamily?.let { put("deviceFamily", JsonPrimitive(it)) } + client.modelIdentifier?.let { put("modelIdentifier", JsonPrimitive(it)) } + } + + val password = authPassword?.trim().orEmpty() + val authJson = + when { + authToken.isNotEmpty() -> + buildJsonObject { + put("token", JsonPrimitive(authToken)) + } + password.isNotEmpty() -> + buildJsonObject { + put("password", JsonPrimitive(password)) + } + else -> null + } + + val signedAtMs = System.currentTimeMillis() + val payload = + buildDeviceAuthPayload( + deviceId = identity.deviceId, + clientId = client.id, + clientMode = client.mode, + role = options.role, + scopes = options.scopes, + signedAtMs = signedAtMs, + token = if (authToken.isNotEmpty()) authToken else null, + nonce = connectNonce, + ) + val signature = identityStore.signPayload(payload, identity) + val publicKey = identityStore.publicKeyBase64Url(identity) + val deviceJson = + if (!signature.isNullOrBlank() && !publicKey.isNullOrBlank()) { + buildJsonObject { + put("id", JsonPrimitive(identity.deviceId)) + put("publicKey", JsonPrimitive(publicKey)) + put("signature", JsonPrimitive(signature)) + put("signedAt", JsonPrimitive(signedAtMs)) + if (!connectNonce.isNullOrBlank()) { + put("nonce", JsonPrimitive(connectNonce)) + } + } + } else { + null + } + + return buildJsonObject { + put("minProtocol", JsonPrimitive(GATEWAY_PROTOCOL_VERSION)) + put("maxProtocol", JsonPrimitive(GATEWAY_PROTOCOL_VERSION)) + put("client", clientObj) + if (options.caps.isNotEmpty()) put("caps", JsonArray(options.caps.map(::JsonPrimitive))) + if (options.commands.isNotEmpty()) put("commands", JsonArray(options.commands.map(::JsonPrimitive))) + if (options.permissions.isNotEmpty()) { + put( + "permissions", + buildJsonObject { + options.permissions.forEach { (key, value) -> + put(key, JsonPrimitive(value)) + } + }, + ) + } + put("role", JsonPrimitive(options.role)) + if (options.scopes.isNotEmpty()) put("scopes", JsonArray(options.scopes.map(::JsonPrimitive))) + authJson?.let { put("auth", it) } + deviceJson?.let { put("device", it) } + put("locale", JsonPrimitive(locale)) + options.userAgent?.trim()?.takeIf { it.isNotEmpty() }?.let { + put("userAgent", JsonPrimitive(it)) + } + } + } + + private suspend fun handleMessage(text: String) { + val frame = json.parseToJsonElement(text).asObjectOrNull() ?: return + when (frame["type"].asStringOrNull()) { + "res" -> handleResponse(frame) + "event" -> handleEvent(frame) + } + } + + private fun handleResponse(frame: JsonObject) { + val id = frame["id"].asStringOrNull() ?: return + val ok = frame["ok"].asBooleanOrNull() ?: false + val payloadJson = frame["payload"]?.let { payload -> payload.toString() } + val error = + frame["error"]?.asObjectOrNull()?.let { obj -> + val code = obj["code"].asStringOrNull() ?: "UNAVAILABLE" + val msg = obj["message"].asStringOrNull() ?: "request failed" + ErrorShape(code, msg) + } + pending.remove(id)?.complete(RpcResponse(id, ok, payloadJson, error)) + } + + private fun handleEvent(frame: JsonObject) { + val event = frame["event"].asStringOrNull() ?: return + val payloadJson = + frame["payload"]?.let { it.toString() } ?: frame["payloadJSON"].asStringOrNull() + if (event == "connect.challenge") { + val nonce = extractConnectNonce(payloadJson) + if (!connectNonceDeferred.isCompleted) { + connectNonceDeferred.complete(nonce) + } + return + } + if (event == "node.invoke.request" && payloadJson != null && onInvoke != null) { + handleInvokeEvent(payloadJson) + return + } + onEvent(event, payloadJson) + } + + private suspend fun awaitConnectNonce(): String? { + if (isLoopbackHost(endpoint.host)) return null + return try { + withTimeout(2_000) { connectNonceDeferred.await() } + } catch (_: Throwable) { + null + } + } + + private fun extractConnectNonce(payloadJson: String?): String? { + if (payloadJson.isNullOrBlank()) return null + val obj = parseJsonOrNull(payloadJson)?.asObjectOrNull() ?: return null + return obj["nonce"].asStringOrNull() + } + + private fun handleInvokeEvent(payloadJson: String) { + val payload = + try { + json.parseToJsonElement(payloadJson).asObjectOrNull() + } catch (_: Throwable) { + null + } ?: return + val id = payload["id"].asStringOrNull() ?: return + val nodeId = payload["nodeId"].asStringOrNull() ?: return + val command = payload["command"].asStringOrNull() ?: return + val params = + payload["paramsJSON"].asStringOrNull() + ?: payload["params"]?.let { value -> if (value is JsonNull) null else value.toString() } + val timeoutMs = payload["timeoutMs"].asLongOrNull() + scope.launch { + val result = + try { + onInvoke?.invoke(InvokeRequest(id, nodeId, command, params, timeoutMs)) + ?: InvokeResult.error("UNAVAILABLE", "invoke handler missing") + } catch (err: Throwable) { + invokeErrorFromThrowable(err) + } + sendInvokeResult(id, nodeId, result) + } + } + + private suspend fun sendInvokeResult(id: String, nodeId: String, result: InvokeResult) { + val parsedPayload = result.payloadJson?.let { parseJsonOrNull(it) } + val params = + buildJsonObject { + put("id", JsonPrimitive(id)) + put("nodeId", JsonPrimitive(nodeId)) + put("ok", JsonPrimitive(result.ok)) + if (parsedPayload != null) { + put("payload", parsedPayload) + } else if (result.payloadJson != null) { + put("payloadJSON", JsonPrimitive(result.payloadJson)) + } + result.error?.let { err -> + put( + "error", + buildJsonObject { + put("code", JsonPrimitive(err.code)) + put("message", JsonPrimitive(err.message)) + }, + ) + } + } + try { + request("node.invoke.result", params, timeoutMs = 15_000) + } catch (err: Throwable) { + Log.w(loggerTag, "node.invoke.result failed: ${err.message ?: err::class.java.simpleName}") + } + } + + private fun invokeErrorFromThrowable(err: Throwable): InvokeResult { + val msg = err.message?.trim().takeIf { !it.isNullOrEmpty() } ?: err::class.java.simpleName + val parts = msg.split(":", limit = 2) + if (parts.size == 2) { + val code = parts[0].trim() + val rest = parts[1].trim() + if (code.isNotEmpty() && code.all { it.isUpperCase() || it == '_' }) { + return InvokeResult.error(code = code, message = rest.ifEmpty { msg }) + } + } + return InvokeResult.error(code = "UNAVAILABLE", message = msg) + } + + private fun failPending() { + for ((_, waiter) in pending) { + waiter.cancel() + } + pending.clear() + } + } + + private suspend fun runLoop() { + var attempt = 0 + while (scope.isActive) { + val target = desired + if (target == null) { + currentConnection?.closeQuietly() + currentConnection = null + delay(250) + continue + } + + try { + onDisconnected(if (attempt == 0) "Connecting…" else "Reconnecting…") + connectOnce(target) + attempt = 0 + } catch (err: Throwable) { + attempt += 1 + onDisconnected("Gateway error: ${err.message ?: err::class.java.simpleName}") + val sleepMs = minOf(8_000L, (350.0 * Math.pow(1.7, attempt.toDouble())).toLong()) + delay(sleepMs) + } + } + } + + private suspend fun connectOnce(target: DesiredConnection) = withContext(Dispatchers.IO) { + val conn = Connection(target.endpoint, target.token, target.password, target.options, target.tls) + currentConnection = conn + try { + conn.connect() + conn.awaitClose() + } finally { + currentConnection = null + canvasHostUrl = null + mainSessionKey = null + } + } + + private fun buildDeviceAuthPayload( + deviceId: String, + clientId: String, + clientMode: String, + role: String, + scopes: List, + signedAtMs: Long, + token: String?, + nonce: String?, + ): String { + val scopeString = scopes.joinToString(",") + val authToken = token.orEmpty() + val version = if (nonce.isNullOrBlank()) "v1" else "v2" + val parts = + mutableListOf( + version, + deviceId, + clientId, + clientMode, + role, + scopeString, + signedAtMs.toString(), + authToken, + ) + if (!nonce.isNullOrBlank()) { + parts.add(nonce) + } + return parts.joinToString("|") + } + + private fun normalizeCanvasHostUrl(raw: String?, endpoint: GatewayEndpoint): String? { + val trimmed = raw?.trim().orEmpty() + val parsed = trimmed.takeIf { it.isNotBlank() }?.let { runCatching { java.net.URI(it) }.getOrNull() } + val host = parsed?.host?.trim().orEmpty() + val port = parsed?.port ?: -1 + val scheme = parsed?.scheme?.trim().orEmpty().ifBlank { "http" } + + if (trimmed.isNotBlank() && !isLoopbackHost(host)) { + return trimmed + } + + val fallbackHost = + endpoint.tailnetDns?.trim().takeIf { !it.isNullOrEmpty() } + ?: endpoint.lanHost?.trim().takeIf { !it.isNullOrEmpty() } + ?: endpoint.host.trim() + if (fallbackHost.isEmpty()) return trimmed.ifBlank { null } + + val fallbackPort = endpoint.canvasPort ?: if (port > 0) port else 18793 + val formattedHost = if (fallbackHost.contains(":")) "[${fallbackHost}]" else fallbackHost + return "$scheme://$formattedHost:$fallbackPort" + } + + private fun isLoopbackHost(raw: String?): Boolean { + val host = raw?.trim()?.lowercase().orEmpty() + if (host.isEmpty()) return false + if (host == "localhost") return true + if (host == "::1") return true + if (host == "0.0.0.0" || host == "::") return true + return host.startsWith("127.") + } +} + +private fun JsonElement?.asObjectOrNull(): JsonObject? = this as? JsonObject + +private fun JsonElement?.asStringOrNull(): String? = + when (this) { + is JsonNull -> null + is JsonPrimitive -> content + else -> null + } + +private fun JsonElement?.asBooleanOrNull(): Boolean? = + when (this) { + is JsonPrimitive -> { + val c = content.trim() + when { + c.equals("true", ignoreCase = true) -> true + c.equals("false", ignoreCase = true) -> false + else -> null + } + } + else -> null + } + +private fun JsonElement?.asLongOrNull(): Long? = + when (this) { + is JsonPrimitive -> content.toLongOrNull() + else -> null + } + +private fun parseJsonOrNull(payload: String): JsonElement? { + val trimmed = payload.trim() + if (trimmed.isEmpty()) return null + return try { + Json.parseToJsonElement(trimmed) + } catch (_: Throwable) { + null + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayTls.kt b/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayTls.kt new file mode 100644 index 000000000..673d60c8f --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/gateway/GatewayTls.kt @@ -0,0 +1,90 @@ +package bot.molt.android.gateway + +import android.annotation.SuppressLint +import java.security.MessageDigest +import java.security.SecureRandom +import java.security.cert.CertificateException +import java.security.cert.X509Certificate +import javax.net.ssl.HostnameVerifier +import javax.net.ssl.SSLContext +import javax.net.ssl.SSLSocketFactory +import javax.net.ssl.TrustManagerFactory +import javax.net.ssl.X509TrustManager + +data class GatewayTlsParams( + val required: Boolean, + val expectedFingerprint: String?, + val allowTOFU: Boolean, + val stableId: String, +) + +data class GatewayTlsConfig( + val sslSocketFactory: SSLSocketFactory, + val trustManager: X509TrustManager, + val hostnameVerifier: HostnameVerifier, +) + +fun buildGatewayTlsConfig( + params: GatewayTlsParams?, + onStore: ((String) -> Unit)? = null, +): GatewayTlsConfig? { + if (params == null) return null + val expected = params.expectedFingerprint?.let(::normalizeFingerprint) + val defaultTrust = defaultTrustManager() + @SuppressLint("CustomX509TrustManager") + val trustManager = + object : X509TrustManager { + override fun checkClientTrusted(chain: Array, authType: String) { + defaultTrust.checkClientTrusted(chain, authType) + } + + override fun checkServerTrusted(chain: Array, authType: String) { + if (chain.isEmpty()) throw CertificateException("empty certificate chain") + val fingerprint = sha256Hex(chain[0].encoded) + if (expected != null) { + if (fingerprint != expected) { + throw CertificateException("gateway TLS fingerprint mismatch") + } + return + } + if (params.allowTOFU) { + onStore?.invoke(fingerprint) + return + } + defaultTrust.checkServerTrusted(chain, authType) + } + + override fun getAcceptedIssuers(): Array = defaultTrust.acceptedIssuers + } + + val context = SSLContext.getInstance("TLS") + context.init(null, arrayOf(trustManager), SecureRandom()) + return GatewayTlsConfig( + sslSocketFactory = context.socketFactory, + trustManager = trustManager, + hostnameVerifier = HostnameVerifier { _, _ -> true }, + ) +} + +private fun defaultTrustManager(): X509TrustManager { + val factory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()) + factory.init(null as java.security.KeyStore?) + val trust = + factory.trustManagers.firstOrNull { it is X509TrustManager } as? X509TrustManager + return trust ?: throw IllegalStateException("No default X509TrustManager found") +} + +private fun sha256Hex(data: ByteArray): String { + val digest = MessageDigest.getInstance("SHA-256").digest(data) + val out = StringBuilder(digest.size * 2) + for (byte in digest) { + out.append(String.format("%02x", byte)) + } + return out.toString() +} + +private fun normalizeFingerprint(raw: String): String { + val stripped = raw.trim() + .replace(Regex("^sha-?256\\s*:?\\s*", RegexOption.IGNORE_CASE), "") + return stripped.lowercase().filter { it in '0'..'9' || it in 'a'..'f' } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/node/CameraCaptureManager.kt b/apps/android/app/src/main/java/bot/molt/android/node/CameraCaptureManager.kt new file mode 100644 index 000000000..cb15a3915 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/node/CameraCaptureManager.kt @@ -0,0 +1,316 @@ +package bot.molt.android.node + +import android.Manifest +import android.content.Context +import android.annotation.SuppressLint +import android.graphics.Bitmap +import android.graphics.BitmapFactory +import android.graphics.Matrix +import android.util.Base64 +import android.content.pm.PackageManager +import androidx.exifinterface.media.ExifInterface +import androidx.lifecycle.LifecycleOwner +import androidx.camera.core.CameraSelector +import androidx.camera.core.ImageCapture +import androidx.camera.core.ImageCaptureException +import androidx.camera.lifecycle.ProcessCameraProvider +import androidx.camera.video.FileOutputOptions +import androidx.camera.video.Recorder +import androidx.camera.video.Recording +import androidx.camera.video.VideoCapture +import androidx.camera.video.VideoRecordEvent +import androidx.core.content.ContextCompat +import androidx.core.content.ContextCompat.checkSelfPermission +import androidx.core.graphics.scale +import bot.molt.android.PermissionRequester +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.suspendCancellableCoroutine +import kotlinx.coroutines.withTimeout +import kotlinx.coroutines.withContext +import java.io.ByteArrayOutputStream +import java.io.File +import java.util.concurrent.Executor +import kotlin.math.roundToInt +import kotlin.coroutines.resume +import kotlin.coroutines.resumeWithException + +class CameraCaptureManager(private val context: Context) { + data class Payload(val payloadJson: String) + + @Volatile private var lifecycleOwner: LifecycleOwner? = null + @Volatile private var permissionRequester: PermissionRequester? = null + + fun attachLifecycleOwner(owner: LifecycleOwner) { + lifecycleOwner = owner + } + + fun attachPermissionRequester(requester: PermissionRequester) { + permissionRequester = requester + } + + private suspend fun ensureCameraPermission() { + val granted = checkSelfPermission(context, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED + if (granted) return + + val requester = permissionRequester + ?: throw IllegalStateException("CAMERA_PERMISSION_REQUIRED: grant Camera permission") + val results = requester.requestIfMissing(listOf(Manifest.permission.CAMERA)) + if (results[Manifest.permission.CAMERA] != true) { + throw IllegalStateException("CAMERA_PERMISSION_REQUIRED: grant Camera permission") + } + } + + private suspend fun ensureMicPermission() { + val granted = checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED + if (granted) return + + val requester = permissionRequester + ?: throw IllegalStateException("MIC_PERMISSION_REQUIRED: grant Microphone permission") + val results = requester.requestIfMissing(listOf(Manifest.permission.RECORD_AUDIO)) + if (results[Manifest.permission.RECORD_AUDIO] != true) { + throw IllegalStateException("MIC_PERMISSION_REQUIRED: grant Microphone permission") + } + } + + suspend fun snap(paramsJson: String?): Payload = + withContext(Dispatchers.Main) { + ensureCameraPermission() + val owner = lifecycleOwner ?: throw IllegalStateException("UNAVAILABLE: camera not ready") + val facing = parseFacing(paramsJson) ?: "front" + val quality = (parseQuality(paramsJson) ?: 0.9).coerceIn(0.1, 1.0) + val maxWidth = parseMaxWidth(paramsJson) + + val provider = context.cameraProvider() + val capture = ImageCapture.Builder().build() + val selector = + if (facing == "front") CameraSelector.DEFAULT_FRONT_CAMERA else CameraSelector.DEFAULT_BACK_CAMERA + + provider.unbindAll() + provider.bindToLifecycle(owner, selector, capture) + + val (bytes, orientation) = capture.takeJpegWithExif(context.mainExecutor()) + val decoded = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) + ?: throw IllegalStateException("UNAVAILABLE: failed to decode captured image") + val rotated = rotateBitmapByExif(decoded, orientation) + val scaled = + if (maxWidth != null && maxWidth > 0 && rotated.width > maxWidth) { + val h = + (rotated.height.toDouble() * (maxWidth.toDouble() / rotated.width.toDouble())) + .toInt() + .coerceAtLeast(1) + rotated.scale(maxWidth, h) + } else { + rotated + } + + val maxPayloadBytes = 5 * 1024 * 1024 + // Base64 inflates payloads by ~4/3; cap encoded bytes so the payload stays under 5MB (API limit). + val maxEncodedBytes = (maxPayloadBytes / 4) * 3 + val result = + JpegSizeLimiter.compressToLimit( + initialWidth = scaled.width, + initialHeight = scaled.height, + startQuality = (quality * 100.0).roundToInt().coerceIn(10, 100), + maxBytes = maxEncodedBytes, + encode = { width, height, q -> + val bitmap = + if (width == scaled.width && height == scaled.height) { + scaled + } else { + scaled.scale(width, height) + } + val out = ByteArrayOutputStream() + if (!bitmap.compress(Bitmap.CompressFormat.JPEG, q, out)) { + if (bitmap !== scaled) bitmap.recycle() + throw IllegalStateException("UNAVAILABLE: failed to encode JPEG") + } + if (bitmap !== scaled) { + bitmap.recycle() + } + out.toByteArray() + }, + ) + val base64 = Base64.encodeToString(result.bytes, Base64.NO_WRAP) + Payload( + """{"format":"jpg","base64":"$base64","width":${result.width},"height":${result.height}}""", + ) + } + + @SuppressLint("MissingPermission") + suspend fun clip(paramsJson: String?): Payload = + withContext(Dispatchers.Main) { + ensureCameraPermission() + val owner = lifecycleOwner ?: throw IllegalStateException("UNAVAILABLE: camera not ready") + val facing = parseFacing(paramsJson) ?: "front" + val durationMs = (parseDurationMs(paramsJson) ?: 3_000).coerceIn(200, 60_000) + val includeAudio = parseIncludeAudio(paramsJson) ?: true + if (includeAudio) ensureMicPermission() + + val provider = context.cameraProvider() + val recorder = Recorder.Builder().build() + val videoCapture = VideoCapture.withOutput(recorder) + val selector = + if (facing == "front") CameraSelector.DEFAULT_FRONT_CAMERA else CameraSelector.DEFAULT_BACK_CAMERA + + provider.unbindAll() + provider.bindToLifecycle(owner, selector, videoCapture) + + val file = File.createTempFile("moltbot-clip-", ".mp4") + val outputOptions = FileOutputOptions.Builder(file).build() + + val finalized = kotlinx.coroutines.CompletableDeferred() + val recording: Recording = + videoCapture.output + .prepareRecording(context, outputOptions) + .apply { + if (includeAudio) withAudioEnabled() + } + .start(context.mainExecutor()) { event -> + if (event is VideoRecordEvent.Finalize) { + finalized.complete(event) + } + } + + try { + kotlinx.coroutines.delay(durationMs.toLong()) + } finally { + recording.stop() + } + + val finalizeEvent = + try { + withTimeout(10_000) { finalized.await() } + } catch (err: Throwable) { + file.delete() + throw IllegalStateException("UNAVAILABLE: camera clip finalize timed out") + } + if (finalizeEvent.hasError()) { + file.delete() + throw IllegalStateException("UNAVAILABLE: camera clip failed") + } + + val bytes = file.readBytes() + file.delete() + val base64 = Base64.encodeToString(bytes, Base64.NO_WRAP) + Payload( + """{"format":"mp4","base64":"$base64","durationMs":$durationMs,"hasAudio":${includeAudio}}""", + ) + } + + private fun rotateBitmapByExif(bitmap: Bitmap, orientation: Int): Bitmap { + val matrix = Matrix() + when (orientation) { + ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f) + ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f) + ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f) + ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.postScale(-1f, 1f) + ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.postScale(1f, -1f) + ExifInterface.ORIENTATION_TRANSPOSE -> { + matrix.postRotate(90f) + matrix.postScale(-1f, 1f) + } + ExifInterface.ORIENTATION_TRANSVERSE -> { + matrix.postRotate(-90f) + matrix.postScale(-1f, 1f) + } + else -> return bitmap + } + val rotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true) + if (rotated !== bitmap) { + bitmap.recycle() + } + return rotated + } + + private fun parseFacing(paramsJson: String?): String? = + when { + paramsJson?.contains("\"front\"") == true -> "front" + paramsJson?.contains("\"back\"") == true -> "back" + else -> null + } + + private fun parseQuality(paramsJson: String?): Double? = + parseNumber(paramsJson, key = "quality")?.toDoubleOrNull() + + private fun parseMaxWidth(paramsJson: String?): Int? = + parseNumber(paramsJson, key = "maxWidth")?.toIntOrNull() + + private fun parseDurationMs(paramsJson: String?): Int? = + parseNumber(paramsJson, key = "durationMs")?.toIntOrNull() + + private fun parseIncludeAudio(paramsJson: String?): Boolean? { + val raw = paramsJson ?: return null + val key = "\"includeAudio\"" + val idx = raw.indexOf(key) + if (idx < 0) return null + val colon = raw.indexOf(':', idx + key.length) + if (colon < 0) return null + val tail = raw.substring(colon + 1).trimStart() + return when { + tail.startsWith("true") -> true + tail.startsWith("false") -> false + else -> null + } + } + + private fun parseNumber(paramsJson: String?, key: String): String? { + val raw = paramsJson ?: return null + val needle = "\"$key\"" + val idx = raw.indexOf(needle) + if (idx < 0) return null + val colon = raw.indexOf(':', idx + needle.length) + if (colon < 0) return null + val tail = raw.substring(colon + 1).trimStart() + return tail.takeWhile { it.isDigit() || it == '.' } + } + + private fun Context.mainExecutor(): Executor = ContextCompat.getMainExecutor(this) +} + +private suspend fun Context.cameraProvider(): ProcessCameraProvider = + suspendCancellableCoroutine { cont -> + val future = ProcessCameraProvider.getInstance(this) + future.addListener( + { + try { + cont.resume(future.get()) + } catch (e: Exception) { + cont.resumeWithException(e) + } + }, + ContextCompat.getMainExecutor(this), + ) + } + +/** Returns (jpegBytes, exifOrientation) so caller can rotate the decoded bitmap. */ +private suspend fun ImageCapture.takeJpegWithExif(executor: Executor): Pair = + suspendCancellableCoroutine { cont -> + val file = File.createTempFile("moltbot-snap-", ".jpg") + val options = ImageCapture.OutputFileOptions.Builder(file).build() + takePicture( + options, + executor, + object : ImageCapture.OnImageSavedCallback { + override fun onError(exception: ImageCaptureException) { + file.delete() + cont.resumeWithException(exception) + } + + override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) { + try { + val exif = ExifInterface(file.absolutePath) + val orientation = exif.getAttributeInt( + ExifInterface.TAG_ORIENTATION, + ExifInterface.ORIENTATION_NORMAL, + ) + val bytes = file.readBytes() + cont.resume(Pair(bytes, orientation)) + } catch (e: Exception) { + cont.resumeWithException(e) + } finally { + file.delete() + } + } + }, + ) + } diff --git a/apps/android/app/src/main/java/bot/molt/android/node/CanvasController.kt b/apps/android/app/src/main/java/bot/molt/android/node/CanvasController.kt new file mode 100644 index 000000000..4d33ed0a6 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/node/CanvasController.kt @@ -0,0 +1,264 @@ +package bot.molt.android.node + +import android.graphics.Bitmap +import android.graphics.Canvas +import android.os.Looper +import android.util.Log +import android.webkit.WebView +import androidx.core.graphics.createBitmap +import androidx.core.graphics.scale +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.suspendCancellableCoroutine +import kotlinx.coroutines.withContext +import java.io.ByteArrayOutputStream +import android.util.Base64 +import org.json.JSONObject +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonElement +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import bot.molt.android.BuildConfig +import kotlin.coroutines.resume + +class CanvasController { + enum class SnapshotFormat(val rawValue: String) { + Png("png"), + Jpeg("jpeg"), + } + + @Volatile private var webView: WebView? = null + @Volatile private var url: String? = null + @Volatile private var debugStatusEnabled: Boolean = false + @Volatile private var debugStatusTitle: String? = null + @Volatile private var debugStatusSubtitle: String? = null + + private val scaffoldAssetUrl = "file:///android_asset/CanvasScaffold/scaffold.html" + + private fun clampJpegQuality(quality: Double?): Int { + val q = (quality ?: 0.82).coerceIn(0.1, 1.0) + return (q * 100.0).toInt().coerceIn(1, 100) + } + + fun attach(webView: WebView) { + this.webView = webView + reload() + applyDebugStatus() + } + + fun navigate(url: String) { + val trimmed = url.trim() + this.url = if (trimmed.isBlank() || trimmed == "/") null else trimmed + reload() + } + + fun currentUrl(): String? = url + + fun isDefaultCanvas(): Boolean = url == null + + fun setDebugStatusEnabled(enabled: Boolean) { + debugStatusEnabled = enabled + applyDebugStatus() + } + + fun setDebugStatus(title: String?, subtitle: String?) { + debugStatusTitle = title + debugStatusSubtitle = subtitle + applyDebugStatus() + } + + fun onPageFinished() { + applyDebugStatus() + } + + private inline fun withWebViewOnMain(crossinline block: (WebView) -> Unit) { + val wv = webView ?: return + if (Looper.myLooper() == Looper.getMainLooper()) { + block(wv) + } else { + wv.post { block(wv) } + } + } + + private fun reload() { + val currentUrl = url + withWebViewOnMain { wv -> + if (currentUrl == null) { + if (BuildConfig.DEBUG) { + Log.d("MoltbotCanvas", "load scaffold: $scaffoldAssetUrl") + } + wv.loadUrl(scaffoldAssetUrl) + } else { + if (BuildConfig.DEBUG) { + Log.d("MoltbotCanvas", "load url: $currentUrl") + } + wv.loadUrl(currentUrl) + } + } + } + + private fun applyDebugStatus() { + val enabled = debugStatusEnabled + val title = debugStatusTitle + val subtitle = debugStatusSubtitle + withWebViewOnMain { wv -> + val titleJs = title?.let { JSONObject.quote(it) } ?: "null" + val subtitleJs = subtitle?.let { JSONObject.quote(it) } ?: "null" + val js = """ + (() => { + try { + const api = globalThis.__moltbot; + if (!api) return; + if (typeof api.setDebugStatusEnabled === 'function') { + api.setDebugStatusEnabled(${if (enabled) "true" else "false"}); + } + if (!${if (enabled) "true" else "false"}) return; + if (typeof api.setStatus === 'function') { + api.setStatus($titleJs, $subtitleJs); + } + } catch (_) {} + })(); + """.trimIndent() + wv.evaluateJavascript(js, null) + } + } + + suspend fun eval(javaScript: String): String = + withContext(Dispatchers.Main) { + val wv = webView ?: throw IllegalStateException("no webview") + suspendCancellableCoroutine { cont -> + wv.evaluateJavascript(javaScript) { result -> + cont.resume(result ?: "") + } + } + } + + suspend fun snapshotPngBase64(maxWidth: Int?): String = + withContext(Dispatchers.Main) { + val wv = webView ?: throw IllegalStateException("no webview") + val bmp = wv.captureBitmap() + val scaled = + if (maxWidth != null && maxWidth > 0 && bmp.width > maxWidth) { + val h = (bmp.height.toDouble() * (maxWidth.toDouble() / bmp.width.toDouble())).toInt().coerceAtLeast(1) + bmp.scale(maxWidth, h) + } else { + bmp + } + + val out = ByteArrayOutputStream() + scaled.compress(Bitmap.CompressFormat.PNG, 100, out) + Base64.encodeToString(out.toByteArray(), Base64.NO_WRAP) + } + + suspend fun snapshotBase64(format: SnapshotFormat, quality: Double?, maxWidth: Int?): String = + withContext(Dispatchers.Main) { + val wv = webView ?: throw IllegalStateException("no webview") + val bmp = wv.captureBitmap() + val scaled = + if (maxWidth != null && maxWidth > 0 && bmp.width > maxWidth) { + val h = (bmp.height.toDouble() * (maxWidth.toDouble() / bmp.width.toDouble())).toInt().coerceAtLeast(1) + bmp.scale(maxWidth, h) + } else { + bmp + } + + val out = ByteArrayOutputStream() + val (compressFormat, compressQuality) = + when (format) { + SnapshotFormat.Png -> Bitmap.CompressFormat.PNG to 100 + SnapshotFormat.Jpeg -> Bitmap.CompressFormat.JPEG to clampJpegQuality(quality) + } + scaled.compress(compressFormat, compressQuality, out) + Base64.encodeToString(out.toByteArray(), Base64.NO_WRAP) + } + + private suspend fun WebView.captureBitmap(): Bitmap = + suspendCancellableCoroutine { cont -> + val width = width.coerceAtLeast(1) + val height = height.coerceAtLeast(1) + val bitmap = createBitmap(width, height, Bitmap.Config.ARGB_8888) + + // WebView isn't supported by PixelCopy.request(...) directly; draw() is the most reliable + // cross-version snapshot for this lightweight "canvas" use-case. + draw(Canvas(bitmap)) + cont.resume(bitmap) + } + + companion object { + data class SnapshotParams(val format: SnapshotFormat, val quality: Double?, val maxWidth: Int?) + + fun parseNavigateUrl(paramsJson: String?): String { + val obj = parseParamsObject(paramsJson) ?: return "" + return obj.string("url").trim() + } + + fun parseEvalJs(paramsJson: String?): String? { + val obj = parseParamsObject(paramsJson) ?: return null + val js = obj.string("javaScript").trim() + return js.takeIf { it.isNotBlank() } + } + + fun parseSnapshotMaxWidth(paramsJson: String?): Int? { + val obj = parseParamsObject(paramsJson) ?: return null + if (!obj.containsKey("maxWidth")) return null + val width = obj.int("maxWidth") ?: 0 + return width.takeIf { it > 0 } + } + + fun parseSnapshotFormat(paramsJson: String?): SnapshotFormat { + val obj = parseParamsObject(paramsJson) ?: return SnapshotFormat.Jpeg + val raw = obj.string("format").trim().lowercase() + return when (raw) { + "png" -> SnapshotFormat.Png + "jpeg", "jpg" -> SnapshotFormat.Jpeg + "" -> SnapshotFormat.Jpeg + else -> SnapshotFormat.Jpeg + } + } + + fun parseSnapshotQuality(paramsJson: String?): Double? { + val obj = parseParamsObject(paramsJson) ?: return null + if (!obj.containsKey("quality")) return null + val q = obj.double("quality") ?: Double.NaN + if (!q.isFinite()) return null + return q.coerceIn(0.1, 1.0) + } + + fun parseSnapshotParams(paramsJson: String?): SnapshotParams { + return SnapshotParams( + format = parseSnapshotFormat(paramsJson), + quality = parseSnapshotQuality(paramsJson), + maxWidth = parseSnapshotMaxWidth(paramsJson), + ) + } + + private val json = Json { ignoreUnknownKeys = true } + + private fun parseParamsObject(paramsJson: String?): JsonObject? { + val raw = paramsJson?.trim().orEmpty() + if (raw.isEmpty()) return null + return try { + json.parseToJsonElement(raw).asObjectOrNull() + } catch (_: Throwable) { + null + } + } + + private fun JsonElement?.asObjectOrNull(): JsonObject? = this as? JsonObject + + private fun JsonObject.string(key: String): String { + val prim = this[key] as? JsonPrimitive ?: return "" + val raw = prim.content + return raw.takeIf { it != "null" }.orEmpty() + } + + private fun JsonObject.int(key: String): Int? { + val prim = this[key] as? JsonPrimitive ?: return null + return prim.content.toIntOrNull() + } + + private fun JsonObject.double(key: String): Double? { + val prim = this[key] as? JsonPrimitive ?: return null + return prim.content.toDoubleOrNull() + } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/node/JpegSizeLimiter.kt b/apps/android/app/src/main/java/bot/molt/android/node/JpegSizeLimiter.kt new file mode 100644 index 000000000..8fb6c35d4 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/node/JpegSizeLimiter.kt @@ -0,0 +1,61 @@ +package bot.molt.android.node + +import kotlin.math.max +import kotlin.math.min +import kotlin.math.roundToInt + +internal data class JpegSizeLimiterResult( + val bytes: ByteArray, + val width: Int, + val height: Int, + val quality: Int, +) + +internal object JpegSizeLimiter { + fun compressToLimit( + initialWidth: Int, + initialHeight: Int, + startQuality: Int, + maxBytes: Int, + minQuality: Int = 20, + minSize: Int = 256, + scaleStep: Double = 0.85, + maxScaleAttempts: Int = 6, + maxQualityAttempts: Int = 6, + encode: (width: Int, height: Int, quality: Int) -> ByteArray, + ): JpegSizeLimiterResult { + require(initialWidth > 0 && initialHeight > 0) { "Invalid image size" } + require(maxBytes > 0) { "Invalid maxBytes" } + + var width = initialWidth + var height = initialHeight + val clampedStartQuality = startQuality.coerceIn(minQuality, 100) + var best = JpegSizeLimiterResult(bytes = encode(width, height, clampedStartQuality), width = width, height = height, quality = clampedStartQuality) + if (best.bytes.size <= maxBytes) return best + + repeat(maxScaleAttempts) { + var quality = clampedStartQuality + repeat(maxQualityAttempts) { + val bytes = encode(width, height, quality) + best = JpegSizeLimiterResult(bytes = bytes, width = width, height = height, quality = quality) + if (bytes.size <= maxBytes) return best + if (quality <= minQuality) return@repeat + quality = max(minQuality, (quality * 0.75).roundToInt()) + } + + val minScale = (minSize.toDouble() / min(width, height).toDouble()).coerceAtMost(1.0) + val nextScale = max(scaleStep, minScale) + val nextWidth = max(minSize, (width * nextScale).roundToInt()) + val nextHeight = max(minSize, (height * nextScale).roundToInt()) + if (nextWidth == width && nextHeight == height) return@repeat + width = min(nextWidth, width) + height = min(nextHeight, height) + } + + if (best.bytes.size > maxBytes) { + throw IllegalStateException("CAMERA_TOO_LARGE: ${best.bytes.size} bytes > $maxBytes bytes") + } + + return best + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/node/LocationCaptureManager.kt b/apps/android/app/src/main/java/bot/molt/android/node/LocationCaptureManager.kt new file mode 100644 index 000000000..c56eee03a --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/node/LocationCaptureManager.kt @@ -0,0 +1,117 @@ +package bot.molt.android.node + +import android.Manifest +import android.content.Context +import android.content.pm.PackageManager +import android.location.Location +import android.location.LocationManager +import android.os.CancellationSignal +import androidx.core.content.ContextCompat +import java.time.Instant +import java.time.format.DateTimeFormatter +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import kotlinx.coroutines.withTimeout +import kotlin.coroutines.resume +import kotlin.coroutines.resumeWithException +import kotlinx.coroutines.suspendCancellableCoroutine + +class LocationCaptureManager(private val context: Context) { + data class Payload(val payloadJson: String) + + suspend fun getLocation( + desiredProviders: List, + maxAgeMs: Long?, + timeoutMs: Long, + isPrecise: Boolean, + ): Payload = + withContext(Dispatchers.Main) { + val manager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager + if (!manager.isProviderEnabled(LocationManager.GPS_PROVIDER) && + !manager.isProviderEnabled(LocationManager.NETWORK_PROVIDER) + ) { + throw IllegalStateException("LOCATION_UNAVAILABLE: no location providers enabled") + } + + val cached = bestLastKnown(manager, desiredProviders, maxAgeMs) + val location = + cached ?: requestCurrent(manager, desiredProviders, timeoutMs) + + val timestamp = DateTimeFormatter.ISO_INSTANT.format(Instant.ofEpochMilli(location.time)) + val source = location.provider + val altitudeMeters = if (location.hasAltitude()) location.altitude else null + val speedMps = if (location.hasSpeed()) location.speed.toDouble() else null + val headingDeg = if (location.hasBearing()) location.bearing.toDouble() else null + Payload( + buildString { + append("{\"lat\":") + append(location.latitude) + append(",\"lon\":") + append(location.longitude) + append(",\"accuracyMeters\":") + append(location.accuracy.toDouble()) + if (altitudeMeters != null) append(",\"altitudeMeters\":").append(altitudeMeters) + if (speedMps != null) append(",\"speedMps\":").append(speedMps) + if (headingDeg != null) append(",\"headingDeg\":").append(headingDeg) + append(",\"timestamp\":\"").append(timestamp).append('"') + append(",\"isPrecise\":").append(isPrecise) + append(",\"source\":\"").append(source).append('"') + append('}') + }, + ) + } + + private fun bestLastKnown( + manager: LocationManager, + providers: List, + maxAgeMs: Long?, + ): Location? { + val fineOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == + PackageManager.PERMISSION_GRANTED + val coarseOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == + PackageManager.PERMISSION_GRANTED + if (!fineOk && !coarseOk) { + throw IllegalStateException("LOCATION_PERMISSION_REQUIRED: grant Location permission") + } + val now = System.currentTimeMillis() + val candidates = + providers.mapNotNull { provider -> manager.getLastKnownLocation(provider) } + val freshest = candidates.maxByOrNull { it.time } ?: return null + if (maxAgeMs != null && now - freshest.time > maxAgeMs) return null + return freshest + } + + private suspend fun requestCurrent( + manager: LocationManager, + providers: List, + timeoutMs: Long, + ): Location { + val fineOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == + PackageManager.PERMISSION_GRANTED + val coarseOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == + PackageManager.PERMISSION_GRANTED + if (!fineOk && !coarseOk) { + throw IllegalStateException("LOCATION_PERMISSION_REQUIRED: grant Location permission") + } + val resolved = + providers.firstOrNull { manager.isProviderEnabled(it) } + ?: throw IllegalStateException("LOCATION_UNAVAILABLE: no providers available") + return withTimeout(timeoutMs.coerceAtLeast(1)) { + suspendCancellableCoroutine { cont -> + val signal = CancellationSignal() + cont.invokeOnCancellation { signal.cancel() } + manager.getCurrentLocation(resolved, signal, context.mainExecutor) { location -> + if (location != null) { + cont.resume(location) + } else { + cont.resumeWithException(IllegalStateException("LOCATION_UNAVAILABLE: no fix")) + } + } + } + } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/node/ScreenRecordManager.kt b/apps/android/app/src/main/java/bot/molt/android/node/ScreenRecordManager.kt new file mode 100644 index 000000000..0e785c245 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/node/ScreenRecordManager.kt @@ -0,0 +1,199 @@ +package bot.molt.android.node + +import android.content.Context +import android.hardware.display.DisplayManager +import android.media.MediaRecorder +import android.media.projection.MediaProjectionManager +import android.os.Build +import android.util.Base64 +import bot.molt.android.ScreenCaptureRequester +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.delay +import kotlinx.coroutines.withContext +import java.io.File +import kotlin.math.roundToInt + +class ScreenRecordManager(private val context: Context) { + data class Payload(val payloadJson: String) + + @Volatile private var screenCaptureRequester: ScreenCaptureRequester? = null + @Volatile private var permissionRequester: bot.molt.android.PermissionRequester? = null + + fun attachScreenCaptureRequester(requester: ScreenCaptureRequester) { + screenCaptureRequester = requester + } + + fun attachPermissionRequester(requester: bot.molt.android.PermissionRequester) { + permissionRequester = requester + } + + suspend fun record(paramsJson: String?): Payload = + withContext(Dispatchers.Default) { + val requester = + screenCaptureRequester + ?: throw IllegalStateException( + "SCREEN_PERMISSION_REQUIRED: grant Screen Recording permission", + ) + + val durationMs = (parseDurationMs(paramsJson) ?: 10_000).coerceIn(250, 60_000) + val fps = (parseFps(paramsJson) ?: 10.0).coerceIn(1.0, 60.0) + val fpsInt = fps.roundToInt().coerceIn(1, 60) + val screenIndex = parseScreenIndex(paramsJson) + val includeAudio = parseIncludeAudio(paramsJson) ?: true + val format = parseString(paramsJson, key = "format") + if (format != null && format.lowercase() != "mp4") { + throw IllegalArgumentException("INVALID_REQUEST: screen format must be mp4") + } + if (screenIndex != null && screenIndex != 0) { + throw IllegalArgumentException("INVALID_REQUEST: screenIndex must be 0 on Android") + } + + val capture = requester.requestCapture() + ?: throw IllegalStateException( + "SCREEN_PERMISSION_REQUIRED: grant Screen Recording permission", + ) + + val mgr = + context.getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager + val projection = mgr.getMediaProjection(capture.resultCode, capture.data) + ?: throw IllegalStateException("UNAVAILABLE: screen capture unavailable") + + val metrics = context.resources.displayMetrics + val width = metrics.widthPixels + val height = metrics.heightPixels + val densityDpi = metrics.densityDpi + + val file = File.createTempFile("moltbot-screen-", ".mp4") + if (includeAudio) ensureMicPermission() + + val recorder = createMediaRecorder() + var virtualDisplay: android.hardware.display.VirtualDisplay? = null + try { + if (includeAudio) { + recorder.setAudioSource(MediaRecorder.AudioSource.MIC) + } + recorder.setVideoSource(MediaRecorder.VideoSource.SURFACE) + recorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4) + recorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264) + if (includeAudio) { + recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC) + recorder.setAudioChannels(1) + recorder.setAudioSamplingRate(44_100) + recorder.setAudioEncodingBitRate(96_000) + } + recorder.setVideoSize(width, height) + recorder.setVideoFrameRate(fpsInt) + recorder.setVideoEncodingBitRate(estimateBitrate(width, height, fpsInt)) + recorder.setOutputFile(file.absolutePath) + recorder.prepare() + + val surface = recorder.surface + virtualDisplay = + projection.createVirtualDisplay( + "moltbot-screen", + width, + height, + densityDpi, + DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR, + surface, + null, + null, + ) + + recorder.start() + delay(durationMs.toLong()) + } finally { + try { + recorder.stop() + } catch (_: Throwable) { + // ignore + } + recorder.reset() + recorder.release() + virtualDisplay?.release() + projection.stop() + } + + val bytes = withContext(Dispatchers.IO) { file.readBytes() } + file.delete() + val base64 = Base64.encodeToString(bytes, Base64.NO_WRAP) + Payload( + """{"format":"mp4","base64":"$base64","durationMs":$durationMs,"fps":$fpsInt,"screenIndex":0,"hasAudio":$includeAudio}""", + ) + } + + private fun createMediaRecorder(): MediaRecorder = MediaRecorder(context) + + private suspend fun ensureMicPermission() { + val granted = + androidx.core.content.ContextCompat.checkSelfPermission( + context, + android.Manifest.permission.RECORD_AUDIO, + ) == android.content.pm.PackageManager.PERMISSION_GRANTED + if (granted) return + + val requester = + permissionRequester + ?: throw IllegalStateException("MIC_PERMISSION_REQUIRED: grant Microphone permission") + val results = requester.requestIfMissing(listOf(android.Manifest.permission.RECORD_AUDIO)) + if (results[android.Manifest.permission.RECORD_AUDIO] != true) { + throw IllegalStateException("MIC_PERMISSION_REQUIRED: grant Microphone permission") + } + } + + private fun parseDurationMs(paramsJson: String?): Int? = + parseNumber(paramsJson, key = "durationMs")?.toIntOrNull() + + private fun parseFps(paramsJson: String?): Double? = + parseNumber(paramsJson, key = "fps")?.toDoubleOrNull() + + private fun parseScreenIndex(paramsJson: String?): Int? = + parseNumber(paramsJson, key = "screenIndex")?.toIntOrNull() + + private fun parseIncludeAudio(paramsJson: String?): Boolean? { + val raw = paramsJson ?: return null + val key = "\"includeAudio\"" + val idx = raw.indexOf(key) + if (idx < 0) return null + val colon = raw.indexOf(':', idx + key.length) + if (colon < 0) return null + val tail = raw.substring(colon + 1).trimStart() + return when { + tail.startsWith("true") -> true + tail.startsWith("false") -> false + else -> null + } + } + + private fun parseNumber(paramsJson: String?, key: String): String? { + val raw = paramsJson ?: return null + val needle = "\"$key\"" + val idx = raw.indexOf(needle) + if (idx < 0) return null + val colon = raw.indexOf(':', idx + needle.length) + if (colon < 0) return null + val tail = raw.substring(colon + 1).trimStart() + return tail.takeWhile { it.isDigit() || it == '.' || it == '-' } + } + + private fun parseString(paramsJson: String?, key: String): String? { + val raw = paramsJson ?: return null + val needle = "\"$key\"" + val idx = raw.indexOf(needle) + if (idx < 0) return null + val colon = raw.indexOf(':', idx + needle.length) + if (colon < 0) return null + val tail = raw.substring(colon + 1).trimStart() + if (!tail.startsWith('\"')) return null + val rest = tail.drop(1) + val end = rest.indexOf('\"') + if (end < 0) return null + return rest.substring(0, end) + } + + private fun estimateBitrate(width: Int, height: Int, fps: Int): Int { + val pixels = width.toLong() * height.toLong() + val raw = (pixels * fps.toLong() * 2L).toInt() + return raw.coerceIn(1_000_000, 12_000_000) + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/node/SmsManager.kt b/apps/android/app/src/main/java/bot/molt/android/node/SmsManager.kt new file mode 100644 index 000000000..0314ee1a7 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/node/SmsManager.kt @@ -0,0 +1,230 @@ +package bot.molt.android.node + +import android.Manifest +import android.content.Context +import android.content.pm.PackageManager +import android.telephony.SmsManager as AndroidSmsManager +import androidx.core.content.ContextCompat +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonElement +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.encodeToString +import bot.molt.android.PermissionRequester + +/** + * Sends SMS messages via the Android SMS API. + * Requires SEND_SMS permission to be granted. + */ +class SmsManager(private val context: Context) { + + private val json = JsonConfig + @Volatile private var permissionRequester: PermissionRequester? = null + + data class SendResult( + val ok: Boolean, + val to: String, + val message: String?, + val error: String? = null, + val payloadJson: String, + ) + + internal data class ParsedParams( + val to: String, + val message: String, + ) + + internal sealed class ParseResult { + data class Ok(val params: ParsedParams) : ParseResult() + data class Error( + val error: String, + val to: String = "", + val message: String? = null, + ) : ParseResult() + } + + internal data class SendPlan( + val parts: List, + val useMultipart: Boolean, + ) + + companion object { + internal val JsonConfig = Json { ignoreUnknownKeys = true } + + internal fun parseParams(paramsJson: String?, json: Json = JsonConfig): ParseResult { + val params = paramsJson?.trim().orEmpty() + if (params.isEmpty()) { + return ParseResult.Error(error = "INVALID_REQUEST: paramsJSON required") + } + + val obj = try { + json.parseToJsonElement(params).jsonObject + } catch (_: Throwable) { + null + } + + if (obj == null) { + return ParseResult.Error(error = "INVALID_REQUEST: expected JSON object") + } + + val to = (obj["to"] as? JsonPrimitive)?.content?.trim().orEmpty() + val message = (obj["message"] as? JsonPrimitive)?.content.orEmpty() + + if (to.isEmpty()) { + return ParseResult.Error( + error = "INVALID_REQUEST: 'to' phone number required", + message = message, + ) + } + + if (message.isEmpty()) { + return ParseResult.Error( + error = "INVALID_REQUEST: 'message' text required", + to = to, + ) + } + + return ParseResult.Ok(ParsedParams(to = to, message = message)) + } + + internal fun buildSendPlan( + message: String, + divider: (String) -> List, + ): SendPlan { + val parts = divider(message).ifEmpty { listOf(message) } + return SendPlan(parts = parts, useMultipart = parts.size > 1) + } + + internal fun buildPayloadJson( + json: Json = JsonConfig, + ok: Boolean, + to: String, + error: String?, + ): String { + val payload = + mutableMapOf( + "ok" to JsonPrimitive(ok), + "to" to JsonPrimitive(to), + ) + if (!ok) { + payload["error"] = JsonPrimitive(error ?: "SMS_SEND_FAILED") + } + return json.encodeToString(JsonObject.serializer(), JsonObject(payload)) + } + } + + fun hasSmsPermission(): Boolean { + return ContextCompat.checkSelfPermission( + context, + Manifest.permission.SEND_SMS + ) == PackageManager.PERMISSION_GRANTED + } + + fun canSendSms(): Boolean { + return hasSmsPermission() && hasTelephonyFeature() + } + + fun hasTelephonyFeature(): Boolean { + return context.packageManager?.hasSystemFeature(PackageManager.FEATURE_TELEPHONY) == true + } + + fun attachPermissionRequester(requester: PermissionRequester) { + permissionRequester = requester + } + + /** + * Send an SMS message. + * + * @param paramsJson JSON with "to" (phone number) and "message" (text) fields + * @return SendResult indicating success or failure + */ + suspend fun send(paramsJson: String?): SendResult { + if (!hasTelephonyFeature()) { + return errorResult( + error = "SMS_UNAVAILABLE: telephony not available", + ) + } + + if (!ensureSmsPermission()) { + return errorResult( + error = "SMS_PERMISSION_REQUIRED: grant SMS permission", + ) + } + + val parseResult = parseParams(paramsJson, json) + if (parseResult is ParseResult.Error) { + return errorResult( + error = parseResult.error, + to = parseResult.to, + message = parseResult.message, + ) + } + val params = (parseResult as ParseResult.Ok).params + + return try { + val smsManager = context.getSystemService(AndroidSmsManager::class.java) + ?: throw IllegalStateException("SMS_UNAVAILABLE: SmsManager not available") + + val plan = buildSendPlan(params.message) { smsManager.divideMessage(it) } + if (plan.useMultipart) { + smsManager.sendMultipartTextMessage( + params.to, // destination + null, // service center (null = default) + ArrayList(plan.parts), // message parts + null, // sent intents + null, // delivery intents + ) + } else { + smsManager.sendTextMessage( + params.to, // destination + null, // service center (null = default) + params.message,// message + null, // sent intent + null, // delivery intent + ) + } + + okResult(to = params.to, message = params.message) + } catch (e: SecurityException) { + errorResult( + error = "SMS_PERMISSION_REQUIRED: ${e.message}", + to = params.to, + message = params.message, + ) + } catch (e: Throwable) { + errorResult( + error = "SMS_SEND_FAILED: ${e.message ?: "unknown error"}", + to = params.to, + message = params.message, + ) + } + } + + private suspend fun ensureSmsPermission(): Boolean { + if (hasSmsPermission()) return true + val requester = permissionRequester ?: return false + val results = requester.requestIfMissing(listOf(Manifest.permission.SEND_SMS)) + return results[Manifest.permission.SEND_SMS] == true + } + + private fun okResult(to: String, message: String): SendResult { + return SendResult( + ok = true, + to = to, + message = message, + error = null, + payloadJson = buildPayloadJson(json = json, ok = true, to = to, error = null), + ) + } + + private fun errorResult(error: String, to: String = "", message: String? = null): SendResult { + return SendResult( + ok = false, + to = to, + message = message, + error = error, + payloadJson = buildPayloadJson(json = json, ok = false, to = to, error = error), + ) + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/protocol/ClawdbotCanvasA2UIAction.kt b/apps/android/app/src/main/java/bot/molt/android/protocol/ClawdbotCanvasA2UIAction.kt new file mode 100644 index 000000000..f73879bb2 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/protocol/ClawdbotCanvasA2UIAction.kt @@ -0,0 +1,66 @@ +package bot.molt.android.protocol + +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive + +object MoltbotCanvasA2UIAction { + fun extractActionName(userAction: JsonObject): String? { + val name = + (userAction["name"] as? JsonPrimitive) + ?.content + ?.trim() + .orEmpty() + if (name.isNotEmpty()) return name + val action = + (userAction["action"] as? JsonPrimitive) + ?.content + ?.trim() + .orEmpty() + return action.ifEmpty { null } + } + + fun sanitizeTagValue(value: String): String { + val trimmed = value.trim().ifEmpty { "-" } + val normalized = trimmed.replace(" ", "_") + val out = StringBuilder(normalized.length) + for (c in normalized) { + val ok = + c.isLetterOrDigit() || + c == '_' || + c == '-' || + c == '.' || + c == ':' + out.append(if (ok) c else '_') + } + return out.toString() + } + + fun formatAgentMessage( + actionName: String, + sessionKey: String, + surfaceId: String, + sourceComponentId: String, + host: String, + instanceId: String, + contextJson: String?, + ): String { + val ctxSuffix = contextJson?.takeIf { it.isNotBlank() }?.let { " ctx=$it" }.orEmpty() + return listOf( + "CANVAS_A2UI", + "action=${sanitizeTagValue(actionName)}", + "session=${sanitizeTagValue(sessionKey)}", + "surface=${sanitizeTagValue(surfaceId)}", + "component=${sanitizeTagValue(sourceComponentId)}", + "host=${sanitizeTagValue(host)}", + "instance=${sanitizeTagValue(instanceId)}$ctxSuffix", + "default=update_canvas", + ).joinToString(separator = " ") + } + + fun jsDispatchA2UIActionStatus(actionId: String, ok: Boolean, error: String?): String { + val err = (error ?: "").replace("\\", "\\\\").replace("\"", "\\\"") + val okLiteral = if (ok) "true" else "false" + val idEscaped = actionId.replace("\\", "\\\\").replace("\"", "\\\"") + return "window.dispatchEvent(new CustomEvent('moltbot:a2ui-action-status', { detail: { id: \"${idEscaped}\", ok: ${okLiteral}, error: \"${err}\" } }));" + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/protocol/ClawdbotProtocolConstants.kt b/apps/android/app/src/main/java/bot/molt/android/protocol/ClawdbotProtocolConstants.kt new file mode 100644 index 000000000..27d46c3f1 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/protocol/ClawdbotProtocolConstants.kt @@ -0,0 +1,71 @@ +package bot.molt.android.protocol + +enum class MoltbotCapability(val rawValue: String) { + Canvas("canvas"), + Camera("camera"), + Screen("screen"), + Sms("sms"), + VoiceWake("voiceWake"), + Location("location"), +} + +enum class MoltbotCanvasCommand(val rawValue: String) { + Present("canvas.present"), + Hide("canvas.hide"), + Navigate("canvas.navigate"), + Eval("canvas.eval"), + Snapshot("canvas.snapshot"), + ; + + companion object { + const val NamespacePrefix: String = "canvas." + } +} + +enum class MoltbotCanvasA2UICommand(val rawValue: String) { + Push("canvas.a2ui.push"), + PushJSONL("canvas.a2ui.pushJSONL"), + Reset("canvas.a2ui.reset"), + ; + + companion object { + const val NamespacePrefix: String = "canvas.a2ui." + } +} + +enum class MoltbotCameraCommand(val rawValue: String) { + Snap("camera.snap"), + Clip("camera.clip"), + ; + + companion object { + const val NamespacePrefix: String = "camera." + } +} + +enum class MoltbotScreenCommand(val rawValue: String) { + Record("screen.record"), + ; + + companion object { + const val NamespacePrefix: String = "screen." + } +} + +enum class MoltbotSmsCommand(val rawValue: String) { + Send("sms.send"), + ; + + companion object { + const val NamespacePrefix: String = "sms." + } +} + +enum class MoltbotLocationCommand(val rawValue: String) { + Get("location.get"), + ; + + companion object { + const val NamespacePrefix: String = "location." + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/tools/ToolDisplay.kt b/apps/android/app/src/main/java/bot/molt/android/tools/ToolDisplay.kt new file mode 100644 index 000000000..6f4862887 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/tools/ToolDisplay.kt @@ -0,0 +1,222 @@ +package bot.molt.android.tools + +import android.content.Context +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonElement +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.contentOrNull + +@Serializable +private data class ToolDisplayActionSpec( + val label: String? = null, + val detailKeys: List? = null, +) + +@Serializable +private data class ToolDisplaySpec( + val emoji: String? = null, + val title: String? = null, + val label: String? = null, + val detailKeys: List? = null, + val actions: Map? = null, +) + +@Serializable +private data class ToolDisplayConfig( + val version: Int? = null, + val fallback: ToolDisplaySpec? = null, + val tools: Map? = null, +) + +data class ToolDisplaySummary( + val name: String, + val emoji: String, + val title: String, + val label: String, + val verb: String?, + val detail: String?, +) { + val detailLine: String? + get() { + val parts = mutableListOf() + if (!verb.isNullOrBlank()) parts.add(verb) + if (!detail.isNullOrBlank()) parts.add(detail) + return if (parts.isEmpty()) null else parts.joinToString(" · ") + } + + val summaryLine: String + get() = if (detailLine != null) "${emoji} ${label}: ${detailLine}" else "${emoji} ${label}" +} + +object ToolDisplayRegistry { + private const val CONFIG_ASSET = "tool-display.json" + + private val json = Json { ignoreUnknownKeys = true } + @Volatile private var cachedConfig: ToolDisplayConfig? = null + + fun resolve( + context: Context, + name: String?, + args: JsonObject?, + meta: String? = null, + ): ToolDisplaySummary { + val trimmedName = name?.trim().orEmpty().ifEmpty { "tool" } + val key = trimmedName.lowercase() + val config = loadConfig(context) + val spec = config.tools?.get(key) + val fallback = config.fallback + + val emoji = spec?.emoji ?: fallback?.emoji ?: "🧩" + val title = spec?.title ?: titleFromName(trimmedName) + val label = spec?.label ?: trimmedName + + val actionRaw = args?.get("action")?.asStringOrNull()?.trim() + val action = actionRaw?.takeIf { it.isNotEmpty() } + val actionSpec = action?.let { spec?.actions?.get(it) } + val verb = normalizeVerb(actionSpec?.label ?: action) + + var detail: String? = null + if (key == "read") { + detail = readDetail(args) + } else if (key == "write" || key == "edit" || key == "attach") { + detail = pathDetail(args) + } + + val detailKeys = actionSpec?.detailKeys ?: spec?.detailKeys ?: fallback?.detailKeys ?: emptyList() + if (detail == null) { + detail = firstValue(args, detailKeys) + } + + if (detail == null) { + detail = meta + } + + if (detail != null) { + detail = shortenHomeInString(detail) + } + + return ToolDisplaySummary( + name = trimmedName, + emoji = emoji, + title = title, + label = label, + verb = verb, + detail = detail, + ) + } + + private fun loadConfig(context: Context): ToolDisplayConfig { + val existing = cachedConfig + if (existing != null) return existing + return try { + val jsonString = context.assets.open(CONFIG_ASSET).bufferedReader().use { it.readText() } + val decoded = json.decodeFromString(ToolDisplayConfig.serializer(), jsonString) + cachedConfig = decoded + decoded + } catch (_: Throwable) { + val fallback = ToolDisplayConfig() + cachedConfig = fallback + fallback + } + } + + private fun titleFromName(name: String): String { + val cleaned = name.replace("_", " ").trim() + if (cleaned.isEmpty()) return "Tool" + return cleaned + .split(Regex("\\s+")) + .joinToString(" ") { part -> + val upper = part.uppercase() + if (part.length <= 2 && part == upper) part + else upper.firstOrNull()?.toString().orEmpty() + part.lowercase().drop(1) + } + } + + private fun normalizeVerb(value: String?): String? { + val trimmed = value?.trim().orEmpty() + if (trimmed.isEmpty()) return null + return trimmed.replace("_", " ") + } + + private fun readDetail(args: JsonObject?): String? { + val path = args?.get("path")?.asStringOrNull() ?: return null + val offset = args["offset"].asNumberOrNull() + val limit = args["limit"].asNumberOrNull() + return if (offset != null && limit != null) { + val end = offset + limit + "${path}:${offset.toInt()}-${end.toInt()}" + } else { + path + } + } + + private fun pathDetail(args: JsonObject?): String? { + return args?.get("path")?.asStringOrNull() + } + + private fun firstValue(args: JsonObject?, keys: List): String? { + for (key in keys) { + val value = valueForPath(args, key) + val rendered = renderValue(value) + if (!rendered.isNullOrBlank()) return rendered + } + return null + } + + private fun valueForPath(args: JsonObject?, path: String): JsonElement? { + var current: JsonElement? = args + for (segment in path.split(".")) { + if (segment.isBlank()) return null + val obj = current as? JsonObject ?: return null + current = obj[segment] + } + return current + } + + private fun renderValue(value: JsonElement?): String? { + if (value == null) return null + if (value is JsonPrimitive) { + if (value.isString) { + val trimmed = value.contentOrNull?.trim().orEmpty() + if (trimmed.isEmpty()) return null + val firstLine = trimmed.lineSequence().firstOrNull()?.trim().orEmpty() + if (firstLine.isEmpty()) return null + return if (firstLine.length > 160) "${firstLine.take(157)}…" else firstLine + } + val raw = value.contentOrNull?.trim().orEmpty() + raw.toBooleanStrictOrNull()?.let { return it.toString() } + raw.toLongOrNull()?.let { return it.toString() } + raw.toDoubleOrNull()?.let { return it.toString() } + } + if (value is JsonArray) { + val items = value.mapNotNull { renderValue(it) } + if (items.isEmpty()) return null + val preview = items.take(3).joinToString(", ") + return if (items.size > 3) "${preview}…" else preview + } + return null + } + + private fun shortenHomeInString(value: String): String { + val home = System.getProperty("user.home")?.takeIf { it.isNotBlank() } + ?: System.getenv("HOME")?.takeIf { it.isNotBlank() } + if (home.isNullOrEmpty()) return value + return value.replace(home, "~") + .replace(Regex("/Users/[^/]+"), "~") + .replace(Regex("/home/[^/]+"), "~") + } + + private fun JsonElement?.asStringOrNull(): String? { + val primitive = this as? JsonPrimitive ?: return null + return if (primitive.isString) primitive.contentOrNull else primitive.toString() + } + + private fun JsonElement?.asNumberOrNull(): Double? { + val primitive = this as? JsonPrimitive ?: return null + val raw = primitive.contentOrNull ?: return null + return raw.toDoubleOrNull() + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/CameraHudOverlay.kt b/apps/android/app/src/main/java/bot/molt/android/ui/CameraHudOverlay.kt new file mode 100644 index 000000000..7b45efae9 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/CameraHudOverlay.kt @@ -0,0 +1,44 @@ +package bot.molt.android.ui + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.graphics.Color +import kotlinx.coroutines.delay + +@Composable +fun CameraFlashOverlay( + token: Long, + modifier: Modifier = Modifier, +) { + Box(modifier = modifier.fillMaxSize()) { + CameraFlash(token = token) + } +} + +@Composable +private fun CameraFlash(token: Long) { + var alpha by remember { mutableFloatStateOf(0f) } + LaunchedEffect(token) { + if (token == 0L) return@LaunchedEffect + alpha = 0.85f + delay(110) + alpha = 0f + } + + Box( + modifier = + Modifier + .fillMaxSize() + .alpha(alpha) + .background(Color.White), + ) +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/ChatSheet.kt b/apps/android/app/src/main/java/bot/molt/android/ui/ChatSheet.kt new file mode 100644 index 000000000..21af1a4c6 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/ChatSheet.kt @@ -0,0 +1,10 @@ +package bot.molt.android.ui + +import androidx.compose.runtime.Composable +import bot.molt.android.MainViewModel +import bot.molt.android.ui.chat.ChatSheetContent + +@Composable +fun ChatSheet(viewModel: MainViewModel) { + ChatSheetContent(viewModel = viewModel) +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/ClawdbotTheme.kt b/apps/android/app/src/main/java/bot/molt/android/ui/ClawdbotTheme.kt new file mode 100644 index 000000000..c292aa25d --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/ClawdbotTheme.kt @@ -0,0 +1,32 @@ +package bot.molt.android.ui + +import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.dynamicDarkColorScheme +import androidx.compose.material3.dynamicLightColorScheme +import androidx.compose.runtime.Composable +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalContext + +@Composable +fun MoltbotTheme(content: @Composable () -> Unit) { + val context = LocalContext.current + val isDark = isSystemInDarkTheme() + val colorScheme = if (isDark) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context) + + MaterialTheme(colorScheme = colorScheme, content = content) +} + +@Composable +fun overlayContainerColor(): Color { + val scheme = MaterialTheme.colorScheme + val isDark = isSystemInDarkTheme() + val base = if (isDark) scheme.surfaceContainerLow else scheme.surfaceContainerHigh + // Light mode: background stays dark (canvas), so clamp overlays away from pure-white glare. + return if (isDark) base else base.copy(alpha = 0.88f) +} + +@Composable +fun overlayIconColor(): Color { + return MaterialTheme.colorScheme.onSurfaceVariant +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/RootScreen.kt b/apps/android/app/src/main/java/bot/molt/android/ui/RootScreen.kt new file mode 100644 index 000000000..67d76b82f --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/RootScreen.kt @@ -0,0 +1,449 @@ +package bot.molt.android.ui + +import android.annotation.SuppressLint +import android.Manifest +import android.content.pm.PackageManager +import android.graphics.Color +import android.util.Log +import android.view.View +import android.webkit.JavascriptInterface +import android.webkit.ConsoleMessage +import android.webkit.WebChromeClient +import android.webkit.WebView +import android.webkit.WebSettings +import android.webkit.WebResourceError +import android.webkit.WebResourceRequest +import android.webkit.WebResourceResponse +import android.webkit.WebViewClient +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.result.contract.ActivityResultContracts +import androidx.webkit.WebSettingsCompat +import androidx.webkit.WebViewFeature +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.WindowInsetsSides +import androidx.compose.foundation.layout.only +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.safeDrawing +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.windowInsetsPadding +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.FilledTonalIconButton +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButtonDefaults +import androidx.compose.material3.LocalContentColor +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.ModalBottomSheet +import androidx.compose.material3.rememberModalBottomSheetState +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.automirrored.filled.ScreenShare +import androidx.compose.material.icons.filled.ChatBubble +import androidx.compose.material.icons.filled.CheckCircle +import androidx.compose.material.icons.filled.Error +import androidx.compose.material.icons.filled.FiberManualRecord +import androidx.compose.material.icons.filled.PhotoCamera +import androidx.compose.material.icons.filled.RecordVoiceOver +import androidx.compose.material.icons.filled.Refresh +import androidx.compose.material.icons.filled.Report +import androidx.compose.material.icons.filled.Settings +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color as ComposeColor +import androidx.compose.ui.graphics.lerp +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.unit.dp +import androidx.compose.ui.viewinterop.AndroidView +import androidx.compose.ui.window.Popup +import androidx.compose.ui.window.PopupProperties +import androidx.core.content.ContextCompat +import bot.molt.android.CameraHudKind +import bot.molt.android.MainViewModel + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun RootScreen(viewModel: MainViewModel) { + var sheet by remember { mutableStateOf(null) } + val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true) + val safeOverlayInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal) + val context = LocalContext.current + val serverName by viewModel.serverName.collectAsState() + val statusText by viewModel.statusText.collectAsState() + val cameraHud by viewModel.cameraHud.collectAsState() + val cameraFlashToken by viewModel.cameraFlashToken.collectAsState() + val screenRecordActive by viewModel.screenRecordActive.collectAsState() + val isForeground by viewModel.isForeground.collectAsState() + val voiceWakeStatusText by viewModel.voiceWakeStatusText.collectAsState() + val talkEnabled by viewModel.talkEnabled.collectAsState() + val talkStatusText by viewModel.talkStatusText.collectAsState() + val talkIsListening by viewModel.talkIsListening.collectAsState() + val talkIsSpeaking by viewModel.talkIsSpeaking.collectAsState() + val seamColorArgb by viewModel.seamColorArgb.collectAsState() + val seamColor = remember(seamColorArgb) { ComposeColor(seamColorArgb) } + val audioPermissionLauncher = + rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted -> + if (granted) viewModel.setTalkEnabled(true) + } + val activity = + remember(cameraHud, screenRecordActive, isForeground, statusText, voiceWakeStatusText) { + // Status pill owns transient activity state so it doesn't overlap the connection indicator. + if (!isForeground) { + return@remember StatusActivity( + title = "Foreground required", + icon = Icons.Default.Report, + contentDescription = "Foreground required", + ) + } + + val lowerStatus = statusText.lowercase() + if (lowerStatus.contains("repair")) { + return@remember StatusActivity( + title = "Repairing…", + icon = Icons.Default.Refresh, + contentDescription = "Repairing", + ) + } + if (lowerStatus.contains("pairing") || lowerStatus.contains("approval")) { + return@remember StatusActivity( + title = "Approval pending", + icon = Icons.Default.RecordVoiceOver, + contentDescription = "Approval pending", + ) + } + // Avoid duplicating the primary gateway status ("Connecting…") in the activity slot. + + if (screenRecordActive) { + return@remember StatusActivity( + title = "Recording screen…", + icon = Icons.AutoMirrored.Filled.ScreenShare, + contentDescription = "Recording screen", + tint = androidx.compose.ui.graphics.Color.Red, + ) + } + + cameraHud?.let { hud -> + return@remember when (hud.kind) { + CameraHudKind.Photo -> + StatusActivity( + title = hud.message, + icon = Icons.Default.PhotoCamera, + contentDescription = "Taking photo", + ) + CameraHudKind.Recording -> + StatusActivity( + title = hud.message, + icon = Icons.Default.FiberManualRecord, + contentDescription = "Recording", + tint = androidx.compose.ui.graphics.Color.Red, + ) + CameraHudKind.Success -> + StatusActivity( + title = hud.message, + icon = Icons.Default.CheckCircle, + contentDescription = "Capture finished", + ) + CameraHudKind.Error -> + StatusActivity( + title = hud.message, + icon = Icons.Default.Error, + contentDescription = "Capture failed", + tint = androidx.compose.ui.graphics.Color.Red, + ) + } + } + + if (voiceWakeStatusText.contains("Microphone permission", ignoreCase = true)) { + return@remember StatusActivity( + title = "Mic permission", + icon = Icons.Default.Error, + contentDescription = "Mic permission required", + ) + } + if (voiceWakeStatusText == "Paused") { + val suffix = if (!isForeground) " (background)" else "" + return@remember StatusActivity( + title = "Voice Wake paused$suffix", + icon = Icons.Default.RecordVoiceOver, + contentDescription = "Voice Wake paused", + ) + } + + null + } + + val gatewayState = + remember(serverName, statusText) { + when { + serverName != null -> GatewayState.Connected + statusText.contains("connecting", ignoreCase = true) || + statusText.contains("reconnecting", ignoreCase = true) -> GatewayState.Connecting + statusText.contains("error", ignoreCase = true) -> GatewayState.Error + else -> GatewayState.Disconnected + } + } + + val voiceEnabled = + ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == + PackageManager.PERMISSION_GRANTED + + Box(modifier = Modifier.fillMaxSize()) { + CanvasView(viewModel = viewModel, modifier = Modifier.fillMaxSize()) + } + + // Camera flash must be in a Popup to render above the WebView. + Popup(alignment = Alignment.Center, properties = PopupProperties(focusable = false)) { + CameraFlashOverlay(token = cameraFlashToken, modifier = Modifier.fillMaxSize()) + } + + // Keep the overlay buttons above the WebView canvas (AndroidView), otherwise they may not receive touches. + Popup(alignment = Alignment.TopStart, properties = PopupProperties(focusable = false)) { + StatusPill( + gateway = gatewayState, + voiceEnabled = voiceEnabled, + activity = activity, + onClick = { sheet = Sheet.Settings }, + modifier = Modifier.windowInsetsPadding(safeOverlayInsets).padding(start = 12.dp, top = 12.dp), + ) + } + + Popup(alignment = Alignment.TopEnd, properties = PopupProperties(focusable = false)) { + Column( + modifier = Modifier.windowInsetsPadding(safeOverlayInsets).padding(end = 12.dp, top = 12.dp), + verticalArrangement = Arrangement.spacedBy(10.dp), + horizontalAlignment = Alignment.End, + ) { + OverlayIconButton( + onClick = { sheet = Sheet.Chat }, + icon = { Icon(Icons.Default.ChatBubble, contentDescription = "Chat") }, + ) + + // Talk mode gets a dedicated side bubble instead of burying it in settings. + val baseOverlay = overlayContainerColor() + val talkContainer = + lerp( + baseOverlay, + seamColor.copy(alpha = baseOverlay.alpha), + if (talkEnabled) 0.35f else 0.22f, + ) + val talkContent = if (talkEnabled) seamColor else overlayIconColor() + OverlayIconButton( + onClick = { + val next = !talkEnabled + if (next) { + val micOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == + PackageManager.PERMISSION_GRANTED + if (!micOk) audioPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO) + viewModel.setTalkEnabled(true) + } else { + viewModel.setTalkEnabled(false) + } + }, + containerColor = talkContainer, + contentColor = talkContent, + icon = { + Icon( + Icons.Default.RecordVoiceOver, + contentDescription = "Talk Mode", + ) + }, + ) + + OverlayIconButton( + onClick = { sheet = Sheet.Settings }, + icon = { Icon(Icons.Default.Settings, contentDescription = "Settings") }, + ) + } + } + + if (talkEnabled) { + Popup(alignment = Alignment.Center, properties = PopupProperties(focusable = false)) { + TalkOrbOverlay( + seamColor = seamColor, + statusText = talkStatusText, + isListening = talkIsListening, + isSpeaking = talkIsSpeaking, + ) + } + } + + val currentSheet = sheet + if (currentSheet != null) { + ModalBottomSheet( + onDismissRequest = { sheet = null }, + sheetState = sheetState, + ) { + when (currentSheet) { + Sheet.Chat -> ChatSheet(viewModel = viewModel) + Sheet.Settings -> SettingsSheet(viewModel = viewModel) + } + } + } +} + +private enum class Sheet { + Chat, + Settings, +} + +@Composable +private fun OverlayIconButton( + onClick: () -> Unit, + icon: @Composable () -> Unit, + containerColor: ComposeColor? = null, + contentColor: ComposeColor? = null, +) { + FilledTonalIconButton( + onClick = onClick, + modifier = Modifier.size(44.dp), + colors = + IconButtonDefaults.filledTonalIconButtonColors( + containerColor = containerColor ?: overlayContainerColor(), + contentColor = contentColor ?: overlayIconColor(), + ), + ) { + icon() + } +} + +@SuppressLint("SetJavaScriptEnabled") +@Composable +private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier) { + val context = LocalContext.current + val isDebuggable = (context.applicationInfo.flags and android.content.pm.ApplicationInfo.FLAG_DEBUGGABLE) != 0 + AndroidView( + modifier = modifier, + factory = { + WebView(context).apply { + settings.javaScriptEnabled = true + // Some embedded web UIs (incl. the "background website") use localStorage/sessionStorage. + settings.domStorageEnabled = true + settings.mixedContentMode = WebSettings.MIXED_CONTENT_COMPATIBILITY_MODE + if (WebViewFeature.isFeatureSupported(WebViewFeature.ALGORITHMIC_DARKENING)) { + WebSettingsCompat.setAlgorithmicDarkeningAllowed(settings, false) + } else { + disableForceDarkIfSupported(settings) + } + if (isDebuggable) { + Log.d("MoltbotWebView", "userAgent: ${settings.userAgentString}") + } + isScrollContainer = true + overScrollMode = View.OVER_SCROLL_IF_CONTENT_SCROLLS + isVerticalScrollBarEnabled = true + isHorizontalScrollBarEnabled = true + webViewClient = + object : WebViewClient() { + override fun onReceivedError( + view: WebView, + request: WebResourceRequest, + error: WebResourceError, + ) { + if (!isDebuggable) return + if (!request.isForMainFrame) return + Log.e("MoltbotWebView", "onReceivedError: ${error.errorCode} ${error.description} ${request.url}") + } + + override fun onReceivedHttpError( + view: WebView, + request: WebResourceRequest, + errorResponse: WebResourceResponse, + ) { + if (!isDebuggable) return + if (!request.isForMainFrame) return + Log.e( + "MoltbotWebView", + "onReceivedHttpError: ${errorResponse.statusCode} ${errorResponse.reasonPhrase} ${request.url}", + ) + } + + override fun onPageFinished(view: WebView, url: String?) { + if (isDebuggable) { + Log.d("MoltbotWebView", "onPageFinished: $url") + } + viewModel.canvas.onPageFinished() + } + + override fun onRenderProcessGone( + view: WebView, + detail: android.webkit.RenderProcessGoneDetail, + ): Boolean { + if (isDebuggable) { + Log.e( + "MoltbotWebView", + "onRenderProcessGone didCrash=${detail.didCrash()} priorityAtExit=${detail.rendererPriorityAtExit()}", + ) + } + return true + } + } + webChromeClient = + object : WebChromeClient() { + override fun onConsoleMessage(consoleMessage: ConsoleMessage?): Boolean { + if (!isDebuggable) return false + val msg = consoleMessage ?: return false + Log.d( + "MoltbotWebView", + "console ${msg.messageLevel()} @ ${msg.sourceId()}:${msg.lineNumber()} ${msg.message()}", + ) + return false + } + } + // Use default layer/background; avoid forcing a black fill over WebView content. + + val a2uiBridge = + CanvasA2UIActionBridge { payload -> + viewModel.handleCanvasA2UIActionFromWebView(payload) + } + addJavascriptInterface(a2uiBridge, CanvasA2UIActionBridge.interfaceName) + addJavascriptInterface( + CanvasA2UIActionLegacyBridge(a2uiBridge), + CanvasA2UIActionLegacyBridge.interfaceName, + ) + viewModel.canvas.attach(this) + } + }, + ) +} + +private fun disableForceDarkIfSupported(settings: WebSettings) { + if (!WebViewFeature.isFeatureSupported(WebViewFeature.FORCE_DARK)) return + @Suppress("DEPRECATION") + WebSettingsCompat.setForceDark(settings, WebSettingsCompat.FORCE_DARK_OFF) +} + +private class CanvasA2UIActionBridge(private val onMessage: (String) -> Unit) { + @JavascriptInterface + fun postMessage(payload: String?) { + val msg = payload?.trim().orEmpty() + if (msg.isEmpty()) return + onMessage(msg) + } + + companion object { + const val interfaceName: String = "moltbotCanvasA2UIAction" + } +} + +private class CanvasA2UIActionLegacyBridge(private val bridge: CanvasA2UIActionBridge) { + @JavascriptInterface + fun canvasAction(payload: String?) { + bridge.postMessage(payload) + } + + @JavascriptInterface + fun postMessage(payload: String?) { + bridge.postMessage(payload) + } + + companion object { + const val interfaceName: String = "Android" + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/SettingsSheet.kt b/apps/android/app/src/main/java/bot/molt/android/ui/SettingsSheet.kt new file mode 100644 index 000000000..f96731acf --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/SettingsSheet.kt @@ -0,0 +1,686 @@ +package bot.molt.android.ui + +import android.Manifest +import android.content.Context +import android.content.Intent +import android.content.pm.PackageManager +import android.net.Uri +import android.os.Build +import android.provider.Settings +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.animation.AnimatedVisibility +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.WindowInsetsSides +import androidx.compose.foundation.layout.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.imePadding +import androidx.compose.foundation.layout.only +import androidx.compose.foundation.layout.safeDrawing +import androidx.compose.foundation.layout.windowInsetsPadding +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.foundation.text.KeyboardActions +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.ExpandLess +import androidx.compose.material.icons.filled.ExpandMore +import androidx.compose.material3.Button +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.Icon +import androidx.compose.material3.ListItem +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.RadioButton +import androidx.compose.material3.Switch +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.focus.onFocusChanged +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.LocalFocusManager +import androidx.compose.ui.text.input.ImeAction +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.core.content.ContextCompat +import bot.molt.android.BuildConfig +import bot.molt.android.LocationMode +import bot.molt.android.MainViewModel +import bot.molt.android.NodeForegroundService +import bot.molt.android.VoiceWakeMode +import bot.molt.android.WakeWords + +@Composable +fun SettingsSheet(viewModel: MainViewModel) { + val context = LocalContext.current + val instanceId by viewModel.instanceId.collectAsState() + val displayName by viewModel.displayName.collectAsState() + val cameraEnabled by viewModel.cameraEnabled.collectAsState() + val locationMode by viewModel.locationMode.collectAsState() + val locationPreciseEnabled by viewModel.locationPreciseEnabled.collectAsState() + val preventSleep by viewModel.preventSleep.collectAsState() + val wakeWords by viewModel.wakeWords.collectAsState() + val voiceWakeMode by viewModel.voiceWakeMode.collectAsState() + val voiceWakeStatusText by viewModel.voiceWakeStatusText.collectAsState() + val isConnected by viewModel.isConnected.collectAsState() + val manualEnabled by viewModel.manualEnabled.collectAsState() + val manualHost by viewModel.manualHost.collectAsState() + val manualPort by viewModel.manualPort.collectAsState() + val manualTls by viewModel.manualTls.collectAsState() + val canvasDebugStatusEnabled by viewModel.canvasDebugStatusEnabled.collectAsState() + val statusText by viewModel.statusText.collectAsState() + val serverName by viewModel.serverName.collectAsState() + val remoteAddress by viewModel.remoteAddress.collectAsState() + val gateways by viewModel.gateways.collectAsState() + val discoveryStatusText by viewModel.discoveryStatusText.collectAsState() + + val listState = rememberLazyListState() + val (wakeWordsText, setWakeWordsText) = remember { mutableStateOf("") } + val (advancedExpanded, setAdvancedExpanded) = remember { mutableStateOf(false) } + val focusManager = LocalFocusManager.current + var wakeWordsHadFocus by remember { mutableStateOf(false) } + val deviceModel = + remember { + listOfNotNull(Build.MANUFACTURER, Build.MODEL) + .joinToString(" ") + .trim() + .ifEmpty { "Android" } + } + val appVersion = + remember { + val versionName = BuildConfig.VERSION_NAME.trim().ifEmpty { "dev" } + if (BuildConfig.DEBUG && !versionName.contains("dev", ignoreCase = true)) { + "$versionName-dev" + } else { + versionName + } + } + + LaunchedEffect(wakeWords) { setWakeWordsText(wakeWords.joinToString(", ")) } + val commitWakeWords = { + val parsed = WakeWords.parseIfChanged(wakeWordsText, wakeWords) + if (parsed != null) { + viewModel.setWakeWords(parsed) + } + } + + val permissionLauncher = + rememberLauncherForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { perms -> + val cameraOk = perms[Manifest.permission.CAMERA] == true + viewModel.setCameraEnabled(cameraOk) + } + + var pendingLocationMode by remember { mutableStateOf(null) } + var pendingPreciseToggle by remember { mutableStateOf(false) } + + val locationPermissionLauncher = + rememberLauncherForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { perms -> + val fineOk = perms[Manifest.permission.ACCESS_FINE_LOCATION] == true + val coarseOk = perms[Manifest.permission.ACCESS_COARSE_LOCATION] == true + val granted = fineOk || coarseOk + val requestedMode = pendingLocationMode + pendingLocationMode = null + + if (pendingPreciseToggle) { + pendingPreciseToggle = false + viewModel.setLocationPreciseEnabled(fineOk) + return@rememberLauncherForActivityResult + } + + if (!granted) { + viewModel.setLocationMode(LocationMode.Off) + return@rememberLauncherForActivityResult + } + + if (requestedMode != null) { + viewModel.setLocationMode(requestedMode) + if (requestedMode == LocationMode.Always) { + val backgroundOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == + PackageManager.PERMISSION_GRANTED + if (!backgroundOk) { + openAppSettings(context) + } + } + } + } + + val audioPermissionLauncher = + rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { _ -> + // Status text is handled by NodeRuntime. + } + + val smsPermissionAvailable = + remember { + context.packageManager?.hasSystemFeature(PackageManager.FEATURE_TELEPHONY) == true + } + var smsPermissionGranted by + remember { + mutableStateOf( + ContextCompat.checkSelfPermission(context, Manifest.permission.SEND_SMS) == + PackageManager.PERMISSION_GRANTED, + ) + } + val smsPermissionLauncher = + rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted -> + smsPermissionGranted = granted + viewModel.refreshGatewayConnection() + } + + fun setCameraEnabledChecked(checked: Boolean) { + if (!checked) { + viewModel.setCameraEnabled(false) + return + } + + val cameraOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) == + PackageManager.PERMISSION_GRANTED + if (cameraOk) { + viewModel.setCameraEnabled(true) + } else { + permissionLauncher.launch(arrayOf(Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO)) + } + } + + fun requestLocationPermissions(targetMode: LocationMode) { + val fineOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == + PackageManager.PERMISSION_GRANTED + val coarseOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == + PackageManager.PERMISSION_GRANTED + if (fineOk || coarseOk) { + viewModel.setLocationMode(targetMode) + if (targetMode == LocationMode.Always) { + val backgroundOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == + PackageManager.PERMISSION_GRANTED + if (!backgroundOk) { + openAppSettings(context) + } + } + } else { + pendingLocationMode = targetMode + locationPermissionLauncher.launch( + arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION), + ) + } + } + + fun setPreciseLocationChecked(checked: Boolean) { + if (!checked) { + viewModel.setLocationPreciseEnabled(false) + return + } + val fineOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == + PackageManager.PERMISSION_GRANTED + if (fineOk) { + viewModel.setLocationPreciseEnabled(true) + } else { + pendingPreciseToggle = true + locationPermissionLauncher.launch(arrayOf(Manifest.permission.ACCESS_FINE_LOCATION)) + } + } + + val visibleGateways = + if (isConnected && remoteAddress != null) { + gateways.filterNot { "${it.host}:${it.port}" == remoteAddress } + } else { + gateways + } + + val gatewayDiscoveryFooterText = + if (visibleGateways.isEmpty()) { + discoveryStatusText + } else if (isConnected) { + "Discovery active • ${visibleGateways.size} other gateway${if (visibleGateways.size == 1) "" else "s"} found" + } else { + "Discovery active • ${visibleGateways.size} gateway${if (visibleGateways.size == 1) "" else "s"} found" + } + + LazyColumn( + state = listState, + modifier = + Modifier + .fillMaxWidth() + .fillMaxHeight() + .imePadding() + .windowInsetsPadding(WindowInsets.safeDrawing.only(WindowInsetsSides.Bottom)), + contentPadding = PaddingValues(16.dp), + verticalArrangement = Arrangement.spacedBy(6.dp), + ) { + // Order parity: Node → Gateway → Voice → Camera → Messaging → Location → Screen. + item { Text("Node", style = MaterialTheme.typography.titleSmall) } + item { + OutlinedTextField( + value = displayName, + onValueChange = viewModel::setDisplayName, + label = { Text("Name") }, + modifier = Modifier.fillMaxWidth(), + ) + } + item { Text("Instance ID: $instanceId", color = MaterialTheme.colorScheme.onSurfaceVariant) } + item { Text("Device: $deviceModel", color = MaterialTheme.colorScheme.onSurfaceVariant) } + item { Text("Version: $appVersion", color = MaterialTheme.colorScheme.onSurfaceVariant) } + + item { HorizontalDivider() } + + // Gateway + item { Text("Gateway", style = MaterialTheme.typography.titleSmall) } + item { ListItem(headlineContent = { Text("Status") }, supportingContent = { Text(statusText) }) } + if (serverName != null) { + item { ListItem(headlineContent = { Text("Server") }, supportingContent = { Text(serverName!!) }) } + } + if (remoteAddress != null) { + item { ListItem(headlineContent = { Text("Address") }, supportingContent = { Text(remoteAddress!!) }) } + } + item { + // UI sanity: "Disconnect" only when we have an active remote. + if (isConnected && remoteAddress != null) { + Button( + onClick = { + viewModel.disconnect() + NodeForegroundService.stop(context) + }, + ) { + Text("Disconnect") + } + } + } + + item { HorizontalDivider() } + + if (!isConnected || visibleGateways.isNotEmpty()) { + item { + Text( + if (isConnected) "Other Gateways" else "Discovered Gateways", + style = MaterialTheme.typography.titleSmall, + ) + } + if (!isConnected && visibleGateways.isEmpty()) { + item { Text("No gateways found yet.", color = MaterialTheme.colorScheme.onSurfaceVariant) } + } else { + items(items = visibleGateways, key = { it.stableId }) { gateway -> + val detailLines = + buildList { + add("IP: ${gateway.host}:${gateway.port}") + gateway.lanHost?.let { add("LAN: $it") } + gateway.tailnetDns?.let { add("Tailnet: $it") } + if (gateway.gatewayPort != null || gateway.canvasPort != null) { + val gw = (gateway.gatewayPort ?: gateway.port).toString() + val canvas = gateway.canvasPort?.toString() ?: "—" + add("Ports: gw $gw · canvas $canvas") + } + } + ListItem( + headlineContent = { Text(gateway.name) }, + supportingContent = { + Column(verticalArrangement = Arrangement.spacedBy(2.dp)) { + detailLines.forEach { line -> + Text(line, color = MaterialTheme.colorScheme.onSurfaceVariant) + } + } + }, + trailingContent = { + Button( + onClick = { + NodeForegroundService.start(context) + viewModel.connect(gateway) + }, + ) { + Text("Connect") + } + }, + ) + } + } + item { + Text( + gatewayDiscoveryFooterText, + modifier = Modifier.fillMaxWidth(), + textAlign = TextAlign.Center, + style = MaterialTheme.typography.labelMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + + item { HorizontalDivider() } + + item { + ListItem( + headlineContent = { Text("Advanced") }, + supportingContent = { Text("Manual gateway connection") }, + trailingContent = { + Icon( + imageVector = if (advancedExpanded) Icons.Filled.ExpandLess else Icons.Filled.ExpandMore, + contentDescription = if (advancedExpanded) "Collapse" else "Expand", + ) + }, + modifier = + Modifier.clickable { + setAdvancedExpanded(!advancedExpanded) + }, + ) + } + item { + AnimatedVisibility(visible = advancedExpanded) { + Column(verticalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.fillMaxWidth()) { + ListItem( + headlineContent = { Text("Use Manual Gateway") }, + supportingContent = { Text("Use this when discovery is blocked.") }, + trailingContent = { Switch(checked = manualEnabled, onCheckedChange = viewModel::setManualEnabled) }, + ) + + OutlinedTextField( + value = manualHost, + onValueChange = viewModel::setManualHost, + label = { Text("Host") }, + modifier = Modifier.fillMaxWidth(), + enabled = manualEnabled, + ) + OutlinedTextField( + value = manualPort.toString(), + onValueChange = { v -> viewModel.setManualPort(v.toIntOrNull() ?: 0) }, + label = { Text("Port") }, + modifier = Modifier.fillMaxWidth(), + enabled = manualEnabled, + ) + ListItem( + headlineContent = { Text("Require TLS") }, + supportingContent = { Text("Pin the gateway certificate on first connect.") }, + trailingContent = { Switch(checked = manualTls, onCheckedChange = viewModel::setManualTls, enabled = manualEnabled) }, + modifier = Modifier.alpha(if (manualEnabled) 1f else 0.5f), + ) + + val hostOk = manualHost.trim().isNotEmpty() + val portOk = manualPort in 1..65535 + Button( + onClick = { + NodeForegroundService.start(context) + viewModel.connectManual() + }, + enabled = manualEnabled && hostOk && portOk, + ) { + Text("Connect (Manual)") + } + } + } + } + + item { HorizontalDivider() } + + // Voice + item { Text("Voice", style = MaterialTheme.typography.titleSmall) } + item { + val enabled = voiceWakeMode != VoiceWakeMode.Off + ListItem( + headlineContent = { Text("Voice Wake") }, + supportingContent = { Text(voiceWakeStatusText) }, + trailingContent = { + Switch( + checked = enabled, + onCheckedChange = { on -> + if (on) { + val micOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == + PackageManager.PERMISSION_GRANTED + if (!micOk) audioPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO) + viewModel.setVoiceWakeMode(VoiceWakeMode.Foreground) + } else { + viewModel.setVoiceWakeMode(VoiceWakeMode.Off) + } + }, + ) + }, + ) + } + item { + AnimatedVisibility(visible = voiceWakeMode != VoiceWakeMode.Off) { + Column(verticalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) { + ListItem( + headlineContent = { Text("Foreground Only") }, + supportingContent = { Text("Listens only while Moltbot is open.") }, + trailingContent = { + RadioButton( + selected = voiceWakeMode == VoiceWakeMode.Foreground, + onClick = { + val micOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == + PackageManager.PERMISSION_GRANTED + if (!micOk) audioPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO) + viewModel.setVoiceWakeMode(VoiceWakeMode.Foreground) + }, + ) + }, + ) + ListItem( + headlineContent = { Text("Always") }, + supportingContent = { Text("Keeps listening in the background (shows a persistent notification).") }, + trailingContent = { + RadioButton( + selected = voiceWakeMode == VoiceWakeMode.Always, + onClick = { + val micOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == + PackageManager.PERMISSION_GRANTED + if (!micOk) audioPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO) + viewModel.setVoiceWakeMode(VoiceWakeMode.Always) + }, + ) + }, + ) + } + } + } + item { + OutlinedTextField( + value = wakeWordsText, + onValueChange = setWakeWordsText, + label = { Text("Wake Words (comma-separated)") }, + modifier = + Modifier.fillMaxWidth().onFocusChanged { focusState -> + if (focusState.isFocused) { + wakeWordsHadFocus = true + } else if (wakeWordsHadFocus) { + wakeWordsHadFocus = false + commitWakeWords() + } + }, + singleLine = true, + keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done), + keyboardActions = + KeyboardActions( + onDone = { + commitWakeWords() + focusManager.clearFocus() + }, + ), + ) + } + item { Button(onClick = viewModel::resetWakeWordsDefaults) { Text("Reset defaults") } } + item { + Text( + if (isConnected) { + "Any node can edit wake words. Changes sync via the gateway." + } else { + "Connect to a gateway to sync wake words globally." + }, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + + item { HorizontalDivider() } + + // Camera + item { Text("Camera", style = MaterialTheme.typography.titleSmall) } + item { + ListItem( + headlineContent = { Text("Allow Camera") }, + supportingContent = { Text("Allows the gateway to request photos or short video clips (foreground only).") }, + trailingContent = { Switch(checked = cameraEnabled, onCheckedChange = ::setCameraEnabledChecked) }, + ) + } + item { + Text( + "Tip: grant Microphone permission for video clips with audio.", + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + + item { HorizontalDivider() } + + // Messaging + item { Text("Messaging", style = MaterialTheme.typography.titleSmall) } + item { + val buttonLabel = + when { + !smsPermissionAvailable -> "Unavailable" + smsPermissionGranted -> "Manage" + else -> "Grant" + } + ListItem( + headlineContent = { Text("SMS Permission") }, + supportingContent = { + Text( + if (smsPermissionAvailable) { + "Allow the gateway to send SMS from this device." + } else { + "SMS requires a device with telephony hardware." + }, + ) + }, + trailingContent = { + Button( + onClick = { + if (!smsPermissionAvailable) return@Button + if (smsPermissionGranted) { + openAppSettings(context) + } else { + smsPermissionLauncher.launch(Manifest.permission.SEND_SMS) + } + }, + enabled = smsPermissionAvailable, + ) { + Text(buttonLabel) + } + }, + ) + } + + item { HorizontalDivider() } + + // Location + item { Text("Location", style = MaterialTheme.typography.titleSmall) } + item { + Column(verticalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) { + ListItem( + headlineContent = { Text("Off") }, + supportingContent = { Text("Disable location sharing.") }, + trailingContent = { + RadioButton( + selected = locationMode == LocationMode.Off, + onClick = { viewModel.setLocationMode(LocationMode.Off) }, + ) + }, + ) + ListItem( + headlineContent = { Text("While Using") }, + supportingContent = { Text("Only while Moltbot is open.") }, + trailingContent = { + RadioButton( + selected = locationMode == LocationMode.WhileUsing, + onClick = { requestLocationPermissions(LocationMode.WhileUsing) }, + ) + }, + ) + ListItem( + headlineContent = { Text("Always") }, + supportingContent = { Text("Allow background location (requires system permission).") }, + trailingContent = { + RadioButton( + selected = locationMode == LocationMode.Always, + onClick = { requestLocationPermissions(LocationMode.Always) }, + ) + }, + ) + } + } + item { + ListItem( + headlineContent = { Text("Precise Location") }, + supportingContent = { Text("Use precise GPS when available.") }, + trailingContent = { + Switch( + checked = locationPreciseEnabled, + onCheckedChange = ::setPreciseLocationChecked, + enabled = locationMode != LocationMode.Off, + ) + }, + ) + } + item { + Text( + "Always may require Android Settings to allow background location.", + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + + item { HorizontalDivider() } + + // Screen + item { Text("Screen", style = MaterialTheme.typography.titleSmall) } + item { + ListItem( + headlineContent = { Text("Prevent Sleep") }, + supportingContent = { Text("Keeps the screen awake while Moltbot is open.") }, + trailingContent = { Switch(checked = preventSleep, onCheckedChange = viewModel::setPreventSleep) }, + ) + } + + item { HorizontalDivider() } + + // Debug + item { Text("Debug", style = MaterialTheme.typography.titleSmall) } + item { + ListItem( + headlineContent = { Text("Debug Canvas Status") }, + supportingContent = { Text("Show status text in the canvas when debug is enabled.") }, + trailingContent = { + Switch( + checked = canvasDebugStatusEnabled, + onCheckedChange = viewModel::setCanvasDebugStatusEnabled, + ) + }, + ) + } + + item { Spacer(modifier = Modifier.height(20.dp)) } + } +} + +private fun openAppSettings(context: Context) { + val intent = + Intent( + Settings.ACTION_APPLICATION_DETAILS_SETTINGS, + Uri.fromParts("package", context.packageName, null), + ) + context.startActivity(intent) +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/StatusPill.kt b/apps/android/app/src/main/java/bot/molt/android/ui/StatusPill.kt new file mode 100644 index 000000000..199bcbf82 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/StatusPill.kt @@ -0,0 +1,114 @@ +package bot.molt.android.ui + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Mic +import androidx.compose.material.icons.filled.MicOff +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.material3.VerticalDivider +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp + +@Composable +fun StatusPill( + gateway: GatewayState, + voiceEnabled: Boolean, + onClick: () -> Unit, + modifier: Modifier = Modifier, + activity: StatusActivity? = null, +) { + Surface( + onClick = onClick, + modifier = modifier, + shape = RoundedCornerShape(14.dp), + color = overlayContainerColor(), + tonalElevation = 3.dp, + shadowElevation = 0.dp, + ) { + Row( + modifier = Modifier.padding(horizontal = 12.dp, vertical = 8.dp), + horizontalArrangement = Arrangement.spacedBy(10.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) { + Surface( + modifier = Modifier.size(9.dp), + shape = CircleShape, + color = gateway.color, + ) {} + + Text( + text = gateway.title, + style = MaterialTheme.typography.labelLarge, + ) + } + + VerticalDivider( + modifier = Modifier.height(14.dp).alpha(0.35f), + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + + if (activity != null) { + Row( + horizontalArrangement = Arrangement.spacedBy(6.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Icon( + imageVector = activity.icon, + contentDescription = activity.contentDescription, + tint = activity.tint ?: overlayIconColor(), + modifier = Modifier.size(18.dp), + ) + Text( + text = activity.title, + style = MaterialTheme.typography.labelLarge, + maxLines = 1, + ) + } + } else { + Icon( + imageVector = if (voiceEnabled) Icons.Default.Mic else Icons.Default.MicOff, + contentDescription = if (voiceEnabled) "Voice enabled" else "Voice disabled", + tint = + if (voiceEnabled) { + overlayIconColor() + } else { + MaterialTheme.colorScheme.onSurfaceVariant + }, + modifier = Modifier.size(18.dp), + ) + } + + Spacer(modifier = Modifier.width(2.dp)) + } + } +} + +data class StatusActivity( + val title: String, + val icon: androidx.compose.ui.graphics.vector.ImageVector, + val contentDescription: String, + val tint: Color? = null, +) + +enum class GatewayState(val title: String, val color: Color) { + Connected("Connected", Color(0xFF2ECC71)), + Connecting("Connecting…", Color(0xFFF1C40F)), + Error("Error", Color(0xFFE74C3C)), + Disconnected("Offline", Color(0xFF9E9E9E)), +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/TalkOrbOverlay.kt b/apps/android/app/src/main/java/bot/molt/android/ui/TalkOrbOverlay.kt new file mode 100644 index 000000000..9098c06ff --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/TalkOrbOverlay.kt @@ -0,0 +1,134 @@ +package bot.molt.android.ui + +import androidx.compose.animation.core.LinearEasing +import androidx.compose.animation.core.RepeatMode +import androidx.compose.animation.core.animateFloat +import androidx.compose.animation.core.infiniteRepeatable +import androidx.compose.animation.core.rememberInfiniteTransition +import androidx.compose.animation.core.tween +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp + +@Composable +fun TalkOrbOverlay( + seamColor: Color, + statusText: String, + isListening: Boolean, + isSpeaking: Boolean, + modifier: Modifier = Modifier, +) { + val transition = rememberInfiniteTransition(label = "talk-orb") + val t by + transition.animateFloat( + initialValue = 0f, + targetValue = 1f, + animationSpec = + infiniteRepeatable( + animation = tween(durationMillis = 1500, easing = LinearEasing), + repeatMode = RepeatMode.Restart, + ), + label = "pulse", + ) + + val trimmed = statusText.trim() + val showStatus = trimmed.isNotEmpty() && trimmed != "Off" + val phase = + when { + isSpeaking -> "Speaking" + isListening -> "Listening" + else -> "Thinking" + } + + Column( + modifier = modifier.padding(24.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(12.dp), + ) { + Box(contentAlignment = Alignment.Center) { + Canvas(modifier = Modifier.size(360.dp)) { + val center = this.center + val baseRadius = size.minDimension * 0.30f + + val ring1 = 1.05f + (t * 0.25f) + val ring2 = 1.20f + (t * 0.55f) + val ringAlpha1 = (1f - t) * 0.34f + val ringAlpha2 = (1f - t) * 0.22f + + drawCircle( + color = seamColor.copy(alpha = ringAlpha1), + radius = baseRadius * ring1, + center = center, + style = Stroke(width = 3.dp.toPx()), + ) + drawCircle( + color = seamColor.copy(alpha = ringAlpha2), + radius = baseRadius * ring2, + center = center, + style = Stroke(width = 3.dp.toPx()), + ) + + drawCircle( + brush = + Brush.radialGradient( + colors = + listOf( + seamColor.copy(alpha = 0.92f), + seamColor.copy(alpha = 0.40f), + Color.Black.copy(alpha = 0.56f), + ), + center = center, + radius = baseRadius * 1.35f, + ), + radius = baseRadius, + center = center, + ) + + drawCircle( + color = seamColor.copy(alpha = 0.34f), + radius = baseRadius, + center = center, + style = Stroke(width = 1.dp.toPx()), + ) + } + } + + if (showStatus) { + Surface( + color = Color.Black.copy(alpha = 0.40f), + shape = CircleShape, + ) { + Text( + text = trimmed, + modifier = Modifier.padding(horizontal = 14.dp, vertical = 8.dp), + color = Color.White.copy(alpha = 0.92f), + style = MaterialTheme.typography.labelLarge, + fontWeight = FontWeight.SemiBold, + ) + } + } else { + Text( + text = phase, + color = Color.White.copy(alpha = 0.80f), + style = MaterialTheme.typography.labelLarge, + fontWeight = FontWeight.SemiBold, + ) + } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatComposer.kt b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatComposer.kt new file mode 100644 index 000000000..bc0d9917f --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatComposer.kt @@ -0,0 +1,285 @@ +package bot.molt.android.ui.chat + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.horizontalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.ArrowUpward +import androidx.compose.material.icons.filled.AttachFile +import androidx.compose.material.icons.filled.Refresh +import androidx.compose.material.icons.filled.Stop +import androidx.compose.material3.ButtonDefaults +import androidx.compose.material3.DropdownMenu +import androidx.compose.material3.DropdownMenuItem +import androidx.compose.material3.FilledTonalButton +import androidx.compose.material3.FilledTonalIconButton +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButtonDefaults +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import bot.molt.android.chat.ChatSessionEntry + +@Composable +fun ChatComposer( + sessionKey: String, + sessions: List, + mainSessionKey: String, + healthOk: Boolean, + thinkingLevel: String, + pendingRunCount: Int, + errorText: String?, + attachments: List, + onPickImages: () -> Unit, + onRemoveAttachment: (id: String) -> Unit, + onSetThinkingLevel: (level: String) -> Unit, + onSelectSession: (sessionKey: String) -> Unit, + onRefresh: () -> Unit, + onAbort: () -> Unit, + onSend: (text: String) -> Unit, +) { + var input by rememberSaveable { mutableStateOf("") } + var showThinkingMenu by remember { mutableStateOf(false) } + var showSessionMenu by remember { mutableStateOf(false) } + + val sessionOptions = resolveSessionChoices(sessionKey, sessions, mainSessionKey = mainSessionKey) + val currentSessionLabel = + sessionOptions.firstOrNull { it.key == sessionKey }?.displayName ?: sessionKey + + val canSend = pendingRunCount == 0 && (input.trim().isNotEmpty() || attachments.isNotEmpty()) && healthOk + + Surface( + shape = MaterialTheme.shapes.large, + color = MaterialTheme.colorScheme.surfaceContainer, + tonalElevation = 0.dp, + shadowElevation = 0.dp, + ) { + Column(modifier = Modifier.padding(10.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.spacedBy(8.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Box { + FilledTonalButton( + onClick = { showSessionMenu = true }, + contentPadding = ButtonDefaults.ContentPadding, + ) { + Text("Session: $currentSessionLabel") + } + + DropdownMenu(expanded = showSessionMenu, onDismissRequest = { showSessionMenu = false }) { + for (entry in sessionOptions) { + DropdownMenuItem( + text = { Text(entry.displayName ?: entry.key) }, + onClick = { + onSelectSession(entry.key) + showSessionMenu = false + }, + trailingIcon = { + if (entry.key == sessionKey) { + Text("✓") + } else { + Spacer(modifier = Modifier.width(10.dp)) + } + }, + ) + } + } + } + + Box { + FilledTonalButton( + onClick = { showThinkingMenu = true }, + contentPadding = ButtonDefaults.ContentPadding, + ) { + Text("Thinking: ${thinkingLabel(thinkingLevel)}") + } + + DropdownMenu(expanded = showThinkingMenu, onDismissRequest = { showThinkingMenu = false }) { + ThinkingMenuItem("off", thinkingLevel, onSetThinkingLevel) { showThinkingMenu = false } + ThinkingMenuItem("low", thinkingLevel, onSetThinkingLevel) { showThinkingMenu = false } + ThinkingMenuItem("medium", thinkingLevel, onSetThinkingLevel) { showThinkingMenu = false } + ThinkingMenuItem("high", thinkingLevel, onSetThinkingLevel) { showThinkingMenu = false } + } + } + + Spacer(modifier = Modifier.weight(1f)) + + FilledTonalIconButton(onClick = onRefresh, modifier = Modifier.size(42.dp)) { + Icon(Icons.Default.Refresh, contentDescription = "Refresh") + } + + FilledTonalIconButton(onClick = onPickImages, modifier = Modifier.size(42.dp)) { + Icon(Icons.Default.AttachFile, contentDescription = "Add image") + } + } + + if (attachments.isNotEmpty()) { + AttachmentsStrip(attachments = attachments, onRemoveAttachment = onRemoveAttachment) + } + + OutlinedTextField( + value = input, + onValueChange = { input = it }, + modifier = Modifier.fillMaxWidth(), + placeholder = { Text("Message Clawd…") }, + minLines = 2, + maxLines = 6, + ) + + Row(modifier = Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) { + ConnectionPill(sessionLabel = currentSessionLabel, healthOk = healthOk) + Spacer(modifier = Modifier.weight(1f)) + + if (pendingRunCount > 0) { + FilledTonalIconButton( + onClick = onAbort, + colors = + IconButtonDefaults.filledTonalIconButtonColors( + containerColor = Color(0x33E74C3C), + contentColor = Color(0xFFE74C3C), + ), + ) { + Icon(Icons.Default.Stop, contentDescription = "Abort") + } + } else { + FilledTonalIconButton(onClick = { + val text = input + input = "" + onSend(text) + }, enabled = canSend) { + Icon(Icons.Default.ArrowUpward, contentDescription = "Send") + } + } + } + + if (!errorText.isNullOrBlank()) { + Text( + text = errorText, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + maxLines = 2, + ) + } + } + } +} + +@Composable +private fun ConnectionPill(sessionLabel: String, healthOk: Boolean) { + Surface( + shape = RoundedCornerShape(999.dp), + color = MaterialTheme.colorScheme.surfaceContainerHighest, + ) { + Row( + modifier = Modifier.padding(horizontal = 10.dp, vertical = 6.dp), + horizontalArrangement = Arrangement.spacedBy(8.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Surface( + modifier = Modifier.size(7.dp), + shape = androidx.compose.foundation.shape.CircleShape, + color = if (healthOk) Color(0xFF2ECC71) else Color(0xFFF39C12), + ) {} + Text(sessionLabel, style = MaterialTheme.typography.labelSmall) + Text( + if (healthOk) "Connected" else "Connecting…", + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } +} + +@Composable +private fun ThinkingMenuItem( + value: String, + current: String, + onSet: (String) -> Unit, + onDismiss: () -> Unit, +) { + DropdownMenuItem( + text = { Text(thinkingLabel(value)) }, + onClick = { + onSet(value) + onDismiss() + }, + trailingIcon = { + if (value == current.trim().lowercase()) { + Text("✓") + } else { + Spacer(modifier = Modifier.width(10.dp)) + } + }, + ) +} + +private fun thinkingLabel(raw: String): String { + return when (raw.trim().lowercase()) { + "low" -> "Low" + "medium" -> "Medium" + "high" -> "High" + else -> "Off" + } +} + +@Composable +private fun AttachmentsStrip( + attachments: List, + onRemoveAttachment: (id: String) -> Unit, +) { + Row( + modifier = Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()), + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + for (att in attachments) { + AttachmentChip( + fileName = att.fileName, + onRemove = { onRemoveAttachment(att.id) }, + ) + } + } +} + +@Composable +private fun AttachmentChip(fileName: String, onRemove: () -> Unit) { + Surface( + shape = RoundedCornerShape(999.dp), + color = MaterialTheme.colorScheme.primary.copy(alpha = 0.10f), + ) { + Row( + modifier = Modifier.padding(horizontal = 10.dp, vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + Text(text = fileName, style = MaterialTheme.typography.bodySmall, maxLines = 1) + FilledTonalIconButton( + onClick = onRemove, + modifier = Modifier.size(30.dp), + ) { + Text("×") + } + } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMarkdown.kt b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMarkdown.kt new file mode 100644 index 000000000..10cf25b81 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMarkdown.kt @@ -0,0 +1,215 @@ +package bot.molt.android.ui.chat + +import android.graphics.BitmapFactory +import android.util.Base64 +import androidx.compose.foundation.Image +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.text.selection.SelectionContainer +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.asImageBitmap +import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.text.AnnotatedString +import androidx.compose.ui.text.SpanStyle +import androidx.compose.ui.text.buildAnnotatedString +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontStyle +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.withStyle +import androidx.compose.ui.unit.dp +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext + +@Composable +fun ChatMarkdown(text: String, textColor: Color) { + val blocks = remember(text) { splitMarkdown(text) } + val inlineCodeBg = MaterialTheme.colorScheme.surfaceContainerLow + + Column(verticalArrangement = Arrangement.spacedBy(10.dp)) { + for (b in blocks) { + when (b) { + is ChatMarkdownBlock.Text -> { + val trimmed = b.text.trimEnd() + if (trimmed.isEmpty()) continue + Text( + text = parseInlineMarkdown(trimmed, inlineCodeBg = inlineCodeBg), + style = MaterialTheme.typography.bodyMedium, + color = textColor, + ) + } + is ChatMarkdownBlock.Code -> { + SelectionContainer(modifier = Modifier.fillMaxWidth()) { + ChatCodeBlock(code = b.code, language = b.language) + } + } + is ChatMarkdownBlock.InlineImage -> { + InlineBase64Image(base64 = b.base64, mimeType = b.mimeType) + } + } + } + } +} + +private sealed interface ChatMarkdownBlock { + data class Text(val text: String) : ChatMarkdownBlock + data class Code(val code: String, val language: String?) : ChatMarkdownBlock + data class InlineImage(val mimeType: String?, val base64: String) : ChatMarkdownBlock +} + +private fun splitMarkdown(raw: String): List { + if (raw.isEmpty()) return emptyList() + + val out = ArrayList() + var idx = 0 + while (idx < raw.length) { + val fenceStart = raw.indexOf("```", startIndex = idx) + if (fenceStart < 0) { + out.addAll(splitInlineImages(raw.substring(idx))) + break + } + + if (fenceStart > idx) { + out.addAll(splitInlineImages(raw.substring(idx, fenceStart))) + } + + val langLineStart = fenceStart + 3 + val langLineEnd = raw.indexOf('\n', startIndex = langLineStart).let { if (it < 0) raw.length else it } + val language = raw.substring(langLineStart, langLineEnd).trim().ifEmpty { null } + + val codeStart = if (langLineEnd < raw.length && raw[langLineEnd] == '\n') langLineEnd + 1 else langLineEnd + val fenceEnd = raw.indexOf("```", startIndex = codeStart) + if (fenceEnd < 0) { + out.addAll(splitInlineImages(raw.substring(fenceStart))) + break + } + val code = raw.substring(codeStart, fenceEnd) + out.add(ChatMarkdownBlock.Code(code = code, language = language)) + + idx = fenceEnd + 3 + } + + return out +} + +private fun splitInlineImages(text: String): List { + if (text.isEmpty()) return emptyList() + val regex = Regex("data:image/([a-zA-Z0-9+.-]+);base64,([A-Za-z0-9+/=\\n\\r]+)") + val out = ArrayList() + + var idx = 0 + while (idx < text.length) { + val m = regex.find(text, startIndex = idx) ?: break + val start = m.range.first + val end = m.range.last + 1 + if (start > idx) out.add(ChatMarkdownBlock.Text(text.substring(idx, start))) + + val mime = "image/" + (m.groupValues.getOrNull(1)?.trim()?.ifEmpty { "png" } ?: "png") + val b64 = m.groupValues.getOrNull(2)?.replace("\n", "")?.replace("\r", "")?.trim().orEmpty() + if (b64.isNotEmpty()) { + out.add(ChatMarkdownBlock.InlineImage(mimeType = mime, base64 = b64)) + } + idx = end + } + + if (idx < text.length) out.add(ChatMarkdownBlock.Text(text.substring(idx))) + return out +} + +private fun parseInlineMarkdown(text: String, inlineCodeBg: androidx.compose.ui.graphics.Color): AnnotatedString { + if (text.isEmpty()) return AnnotatedString("") + + val out = buildAnnotatedString { + var i = 0 + while (i < text.length) { + if (text.startsWith("**", startIndex = i)) { + val end = text.indexOf("**", startIndex = i + 2) + if (end > i + 2) { + withStyle(SpanStyle(fontWeight = FontWeight.SemiBold)) { + append(text.substring(i + 2, end)) + } + i = end + 2 + continue + } + } + + if (text[i] == '`') { + val end = text.indexOf('`', startIndex = i + 1) + if (end > i + 1) { + withStyle( + SpanStyle( + fontFamily = FontFamily.Monospace, + background = inlineCodeBg, + ), + ) { + append(text.substring(i + 1, end)) + } + i = end + 1 + continue + } + } + + if (text[i] == '*' && (i + 1 < text.length && text[i + 1] != '*')) { + val end = text.indexOf('*', startIndex = i + 1) + if (end > i + 1) { + withStyle(SpanStyle(fontStyle = FontStyle.Italic)) { + append(text.substring(i + 1, end)) + } + i = end + 1 + continue + } + } + + append(text[i]) + i += 1 + } + } + return out +} + +@Composable +private fun InlineBase64Image(base64: String, mimeType: String?) { + var image by remember(base64) { mutableStateOf(null) } + var failed by remember(base64) { mutableStateOf(false) } + + LaunchedEffect(base64) { + failed = false + image = + withContext(Dispatchers.Default) { + try { + val bytes = Base64.decode(base64, Base64.DEFAULT) + val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) ?: return@withContext null + bitmap.asImageBitmap() + } catch (_: Throwable) { + null + } + } + if (image == null) failed = true + } + + if (image != null) { + Image( + bitmap = image!!, + contentDescription = mimeType ?: "image", + contentScale = ContentScale.Fit, + modifier = Modifier.fillMaxWidth(), + ) + } else if (failed) { + Text( + text = "Image unavailable", + modifier = Modifier.padding(vertical = 2.dp), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMessageListCard.kt b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMessageListCard.kt new file mode 100644 index 000000000..1091de6c8 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMessageListCard.kt @@ -0,0 +1,111 @@ +package bot.molt.android.ui.chat + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.ArrowCircleDown +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.unit.dp +import bot.molt.android.chat.ChatMessage +import bot.molt.android.chat.ChatPendingToolCall + +@Composable +fun ChatMessageListCard( + messages: List, + pendingRunCount: Int, + pendingToolCalls: List, + streamingAssistantText: String?, + modifier: Modifier = Modifier, +) { + val listState = rememberLazyListState() + + LaunchedEffect(messages.size, pendingRunCount, pendingToolCalls.size, streamingAssistantText) { + val total = + messages.size + + (if (pendingRunCount > 0) 1 else 0) + + (if (pendingToolCalls.isNotEmpty()) 1 else 0) + + (if (!streamingAssistantText.isNullOrBlank()) 1 else 0) + if (total <= 0) return@LaunchedEffect + listState.animateScrollToItem(index = total - 1) + } + + Card( + modifier = modifier.fillMaxWidth(), + shape = MaterialTheme.shapes.large, + colors = + CardDefaults.cardColors( + containerColor = MaterialTheme.colorScheme.surfaceContainer, + ), + elevation = CardDefaults.cardElevation(defaultElevation = 0.dp), + ) { + Box(modifier = Modifier.fillMaxSize()) { + LazyColumn( + modifier = Modifier.fillMaxSize(), + state = listState, + verticalArrangement = Arrangement.spacedBy(14.dp), + contentPadding = androidx.compose.foundation.layout.PaddingValues(top = 12.dp, bottom = 12.dp, start = 12.dp, end = 12.dp), + ) { + items(count = messages.size, key = { idx -> messages[idx].id }) { idx -> + ChatMessageBubble(message = messages[idx]) + } + + if (pendingRunCount > 0) { + item(key = "typing") { + ChatTypingIndicatorBubble() + } + } + + if (pendingToolCalls.isNotEmpty()) { + item(key = "tools") { + ChatPendingToolsBubble(toolCalls = pendingToolCalls) + } + } + + val stream = streamingAssistantText?.trim() + if (!stream.isNullOrEmpty()) { + item(key = "stream") { + ChatStreamingAssistantBubble(text = stream) + } + } + } + + if (messages.isEmpty() && pendingRunCount == 0 && pendingToolCalls.isEmpty() && streamingAssistantText.isNullOrBlank()) { + EmptyChatHint(modifier = Modifier.align(Alignment.Center)) + } + } + } +} + +@Composable +private fun EmptyChatHint(modifier: Modifier = Modifier) { + Row( + modifier = modifier.alpha(0.7f), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + Icon( + imageVector = Icons.Default.ArrowCircleDown, + contentDescription = null, + tint = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Text( + text = "Message Clawd…", + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMessageViews.kt b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMessageViews.kt new file mode 100644 index 000000000..59445be37 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatMessageViews.kt @@ -0,0 +1,252 @@ +package bot.molt.android.ui.chat + +import android.graphics.BitmapFactory +import android.util.Base64 +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.asImageBitmap +import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.unit.dp +import androidx.compose.foundation.Image +import bot.molt.android.chat.ChatMessage +import bot.molt.android.chat.ChatMessageContent +import bot.molt.android.chat.ChatPendingToolCall +import bot.molt.android.tools.ToolDisplayRegistry +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import androidx.compose.ui.platform.LocalContext + +@Composable +fun ChatMessageBubble(message: ChatMessage) { + val isUser = message.role.lowercase() == "user" + + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = if (isUser) Arrangement.End else Arrangement.Start, + ) { + Surface( + shape = RoundedCornerShape(16.dp), + tonalElevation = 0.dp, + shadowElevation = 0.dp, + color = Color.Transparent, + modifier = Modifier.fillMaxWidth(0.92f), + ) { + Box( + modifier = + Modifier + .background(bubbleBackground(isUser)) + .padding(horizontal = 12.dp, vertical = 10.dp), + ) { + val textColor = textColorOverBubble(isUser) + ChatMessageBody(content = message.content, textColor = textColor) + } + } + } +} + +@Composable +private fun ChatMessageBody(content: List, textColor: Color) { + Column(verticalArrangement = Arrangement.spacedBy(10.dp)) { + for (part in content) { + when (part.type) { + "text" -> { + val text = part.text ?: continue + ChatMarkdown(text = text, textColor = textColor) + } + else -> { + val b64 = part.base64 ?: continue + ChatBase64Image(base64 = b64, mimeType = part.mimeType) + } + } + } + } +} + +@Composable +fun ChatTypingIndicatorBubble() { + Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.Start) { + Surface( + shape = RoundedCornerShape(16.dp), + color = MaterialTheme.colorScheme.surfaceContainer, + ) { + Row( + modifier = Modifier.padding(horizontal = 12.dp, vertical = 10.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + DotPulse() + Text("Thinking…", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant) + } + } + } +} + +@Composable +fun ChatPendingToolsBubble(toolCalls: List) { + val context = LocalContext.current + val displays = + remember(toolCalls, context) { + toolCalls.map { ToolDisplayRegistry.resolve(context, it.name, it.args) } + } + Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.Start) { + Surface( + shape = RoundedCornerShape(16.dp), + color = MaterialTheme.colorScheme.surfaceContainer, + ) { + Column(modifier = Modifier.padding(horizontal = 12.dp, vertical = 10.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) { + Text("Running tools…", style = MaterialTheme.typography.labelLarge, color = MaterialTheme.colorScheme.onSurface) + for (display in displays.take(6)) { + Column(verticalArrangement = Arrangement.spacedBy(2.dp)) { + Text( + "${display.emoji} ${display.label}", + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + fontFamily = FontFamily.Monospace, + ) + display.detailLine?.let { detail -> + Text( + detail, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + fontFamily = FontFamily.Monospace, + ) + } + } + } + if (toolCalls.size > 6) { + Text( + "… +${toolCalls.size - 6} more", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + } + } +} + +@Composable +fun ChatStreamingAssistantBubble(text: String) { + Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.Start) { + Surface( + shape = RoundedCornerShape(16.dp), + color = MaterialTheme.colorScheme.surfaceContainer, + ) { + Box(modifier = Modifier.padding(horizontal = 12.dp, vertical = 10.dp)) { + ChatMarkdown(text = text, textColor = MaterialTheme.colorScheme.onSurface) + } + } + } +} + +@Composable +private fun bubbleBackground(isUser: Boolean): Brush { + return if (isUser) { + Brush.linearGradient( + colors = listOf(MaterialTheme.colorScheme.primary, MaterialTheme.colorScheme.primary.copy(alpha = 0.78f)), + ) + } else { + Brush.linearGradient( + colors = listOf(MaterialTheme.colorScheme.surfaceContainer, MaterialTheme.colorScheme.surfaceContainerHigh), + ) + } +} + +@Composable +private fun textColorOverBubble(isUser: Boolean): Color { + return if (isUser) { + MaterialTheme.colorScheme.onPrimary + } else { + MaterialTheme.colorScheme.onSurface + } +} + +@Composable +private fun ChatBase64Image(base64: String, mimeType: String?) { + var image by remember(base64) { mutableStateOf(null) } + var failed by remember(base64) { mutableStateOf(false) } + + LaunchedEffect(base64) { + failed = false + image = + withContext(Dispatchers.Default) { + try { + val bytes = Base64.decode(base64, Base64.DEFAULT) + val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) ?: return@withContext null + bitmap.asImageBitmap() + } catch (_: Throwable) { + null + } + } + if (image == null) failed = true + } + + if (image != null) { + Image( + bitmap = image!!, + contentDescription = mimeType ?: "attachment", + contentScale = ContentScale.Fit, + modifier = Modifier.fillMaxWidth(), + ) + } else if (failed) { + Text("Unsupported attachment", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant) + } +} + +@Composable +private fun DotPulse() { + Row(horizontalArrangement = Arrangement.spacedBy(5.dp), verticalAlignment = Alignment.CenterVertically) { + PulseDot(alpha = 0.38f) + PulseDot(alpha = 0.62f) + PulseDot(alpha = 0.90f) + } +} + +@Composable +private fun PulseDot(alpha: Float) { + Surface( + modifier = Modifier.size(6.dp).alpha(alpha), + shape = CircleShape, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) {} +} + +@Composable +fun ChatCodeBlock(code: String, language: String?) { + Surface( + shape = RoundedCornerShape(12.dp), + color = MaterialTheme.colorScheme.surfaceContainerLowest, + modifier = Modifier.fillMaxWidth(), + ) { + Text( + text = code.trimEnd(), + modifier = Modifier.padding(10.dp), + fontFamily = FontFamily.Monospace, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurface, + ) + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatSessionsDialog.kt b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatSessionsDialog.kt new file mode 100644 index 000000000..377a13daa --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatSessionsDialog.kt @@ -0,0 +1,92 @@ +package bot.molt.android.ui.chat + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Refresh +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.FilledTonalIconButton +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import bot.molt.android.chat.ChatSessionEntry + +@Composable +fun ChatSessionsDialog( + currentSessionKey: String, + sessions: List, + onDismiss: () -> Unit, + onRefresh: () -> Unit, + onSelect: (sessionKey: String) -> Unit, +) { + AlertDialog( + onDismissRequest = onDismiss, + confirmButton = {}, + title = { + Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { + Text("Sessions", style = MaterialTheme.typography.titleMedium) + Spacer(modifier = Modifier.weight(1f)) + FilledTonalIconButton(onClick = onRefresh) { + Icon(Icons.Default.Refresh, contentDescription = "Refresh") + } + } + }, + text = { + if (sessions.isEmpty()) { + Text("No sessions", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant) + } else { + LazyColumn(verticalArrangement = Arrangement.spacedBy(8.dp)) { + items(sessions, key = { it.key }) { entry -> + SessionRow( + entry = entry, + isCurrent = entry.key == currentSessionKey, + onClick = { onSelect(entry.key) }, + ) + } + } + } + }, + ) +} + +@Composable +private fun SessionRow( + entry: ChatSessionEntry, + isCurrent: Boolean, + onClick: () -> Unit, +) { + Surface( + onClick = onClick, + shape = MaterialTheme.shapes.medium, + color = + if (isCurrent) { + MaterialTheme.colorScheme.primary.copy(alpha = 0.14f) + } else { + MaterialTheme.colorScheme.surfaceContainer + }, + modifier = Modifier.fillMaxWidth(), + ) { + Row( + modifier = Modifier.padding(horizontal = 12.dp, vertical = 10.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(10.dp), + ) { + Text(entry.displayName ?: entry.key, style = MaterialTheme.typography.bodyMedium) + Spacer(modifier = Modifier.weight(1f)) + if (isCurrent) { + Text("Current", style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant) + } + } + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatSheetContent.kt b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatSheetContent.kt new file mode 100644 index 000000000..5632be70f --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/chat/ChatSheetContent.kt @@ -0,0 +1,147 @@ +package bot.molt.android.ui.chat + +import android.content.ContentResolver +import android.net.Uri +import android.util.Base64 +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.padding +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateListOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.unit.dp +import bot.molt.android.MainViewModel +import bot.molt.android.chat.OutgoingAttachment +import java.io.ByteArrayOutputStream +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext + +@Composable +fun ChatSheetContent(viewModel: MainViewModel) { + val messages by viewModel.chatMessages.collectAsState() + val errorText by viewModel.chatError.collectAsState() + val pendingRunCount by viewModel.pendingRunCount.collectAsState() + val healthOk by viewModel.chatHealthOk.collectAsState() + val sessionKey by viewModel.chatSessionKey.collectAsState() + val mainSessionKey by viewModel.mainSessionKey.collectAsState() + val thinkingLevel by viewModel.chatThinkingLevel.collectAsState() + val streamingAssistantText by viewModel.chatStreamingAssistantText.collectAsState() + val pendingToolCalls by viewModel.chatPendingToolCalls.collectAsState() + val sessions by viewModel.chatSessions.collectAsState() + + LaunchedEffect(mainSessionKey) { + viewModel.loadChat(mainSessionKey) + viewModel.refreshChatSessions(limit = 200) + } + + val context = LocalContext.current + val resolver = context.contentResolver + val scope = rememberCoroutineScope() + + val attachments = remember { mutableStateListOf() } + + val pickImages = + rememberLauncherForActivityResult(ActivityResultContracts.GetMultipleContents()) { uris -> + if (uris.isNullOrEmpty()) return@rememberLauncherForActivityResult + scope.launch(Dispatchers.IO) { + val next = + uris.take(8).mapNotNull { uri -> + try { + loadImageAttachment(resolver, uri) + } catch (_: Throwable) { + null + } + } + withContext(Dispatchers.Main) { + attachments.addAll(next) + } + } + } + + Column( + modifier = + Modifier + .fillMaxSize() + .padding(horizontal = 12.dp, vertical = 12.dp), + verticalArrangement = Arrangement.spacedBy(10.dp), + ) { + ChatMessageListCard( + messages = messages, + pendingRunCount = pendingRunCount, + pendingToolCalls = pendingToolCalls, + streamingAssistantText = streamingAssistantText, + modifier = Modifier.weight(1f, fill = true), + ) + + ChatComposer( + sessionKey = sessionKey, + sessions = sessions, + mainSessionKey = mainSessionKey, + healthOk = healthOk, + thinkingLevel = thinkingLevel, + pendingRunCount = pendingRunCount, + errorText = errorText, + attachments = attachments, + onPickImages = { pickImages.launch("image/*") }, + onRemoveAttachment = { id -> attachments.removeAll { it.id == id } }, + onSetThinkingLevel = { level -> viewModel.setChatThinkingLevel(level) }, + onSelectSession = { key -> viewModel.switchChatSession(key) }, + onRefresh = { + viewModel.refreshChat() + viewModel.refreshChatSessions(limit = 200) + }, + onAbort = { viewModel.abortChat() }, + onSend = { text -> + val outgoing = + attachments.map { att -> + OutgoingAttachment( + type = "image", + mimeType = att.mimeType, + fileName = att.fileName, + base64 = att.base64, + ) + } + viewModel.sendChat(message = text, thinking = thinkingLevel, attachments = outgoing) + attachments.clear() + }, + ) + } +} + +data class PendingImageAttachment( + val id: String, + val fileName: String, + val mimeType: String, + val base64: String, +) + +private suspend fun loadImageAttachment(resolver: ContentResolver, uri: Uri): PendingImageAttachment { + val mimeType = resolver.getType(uri) ?: "image/*" + val fileName = (uri.lastPathSegment ?: "image").substringAfterLast('/') + val bytes = + withContext(Dispatchers.IO) { + resolver.openInputStream(uri)?.use { input -> + val out = ByteArrayOutputStream() + input.copyTo(out) + out.toByteArray() + } ?: ByteArray(0) + } + if (bytes.isEmpty()) throw IllegalStateException("empty attachment") + val base64 = Base64.encodeToString(bytes, Base64.NO_WRAP) + return PendingImageAttachment( + id = uri.toString() + "#" + System.currentTimeMillis().toString(), + fileName = fileName, + mimeType = mimeType, + base64 = base64, + ) +} diff --git a/apps/android/app/src/main/java/bot/molt/android/ui/chat/SessionFilters.kt b/apps/android/app/src/main/java/bot/molt/android/ui/chat/SessionFilters.kt new file mode 100644 index 000000000..227fb0a02 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/ui/chat/SessionFilters.kt @@ -0,0 +1,49 @@ +package bot.molt.android.ui.chat + +import bot.molt.android.chat.ChatSessionEntry + +private const val RECENT_WINDOW_MS = 24 * 60 * 60 * 1000L + +fun resolveSessionChoices( + currentSessionKey: String, + sessions: List, + mainSessionKey: String, + nowMs: Long = System.currentTimeMillis(), +): List { + val mainKey = mainSessionKey.trim().ifEmpty { "main" } + val current = currentSessionKey.trim().let { if (it == "main" && mainKey != "main") mainKey else it } + val aliasKey = if (mainKey == "main") null else "main" + val cutoff = nowMs - RECENT_WINDOW_MS + val sorted = sessions.sortedByDescending { it.updatedAtMs ?: 0L } + val recent = mutableListOf() + val seen = mutableSetOf() + for (entry in sorted) { + if (aliasKey != null && entry.key == aliasKey) continue + if (!seen.add(entry.key)) continue + if ((entry.updatedAtMs ?: 0L) < cutoff) continue + recent.add(entry) + } + + val result = mutableListOf() + val included = mutableSetOf() + val mainEntry = sorted.firstOrNull { it.key == mainKey } + if (mainEntry != null) { + result.add(mainEntry) + included.add(mainKey) + } else if (current == mainKey) { + result.add(ChatSessionEntry(key = mainKey, updatedAtMs = null)) + included.add(mainKey) + } + + for (entry in recent) { + if (included.add(entry.key)) { + result.add(entry) + } + } + + if (current.isNotEmpty() && !included.contains(current)) { + result.add(ChatSessionEntry(key = current, updatedAtMs = null)) + } + + return result +} diff --git a/apps/android/app/src/main/java/bot/molt/android/voice/StreamingMediaDataSource.kt b/apps/android/app/src/main/java/bot/molt/android/voice/StreamingMediaDataSource.kt new file mode 100644 index 000000000..7a7f61165 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/voice/StreamingMediaDataSource.kt @@ -0,0 +1,98 @@ +package bot.molt.android.voice + +import android.media.MediaDataSource +import kotlin.math.min + +internal class StreamingMediaDataSource : MediaDataSource() { + private data class Chunk(val start: Long, val data: ByteArray) + + private val lock = Object() + private val chunks = ArrayList() + private var totalSize: Long = 0 + private var closed = false + private var finished = false + private var lastReadIndex = 0 + + fun append(data: ByteArray) { + if (data.isEmpty()) return + synchronized(lock) { + if (closed || finished) return + val chunk = Chunk(totalSize, data) + chunks.add(chunk) + totalSize += data.size.toLong() + lock.notifyAll() + } + } + + fun finish() { + synchronized(lock) { + if (closed) return + finished = true + lock.notifyAll() + } + } + + fun fail() { + synchronized(lock) { + closed = true + lock.notifyAll() + } + } + + override fun readAt(position: Long, buffer: ByteArray, offset: Int, size: Int): Int { + if (position < 0) return -1 + synchronized(lock) { + while (!closed && !finished && position >= totalSize) { + lock.wait() + } + if (closed) return -1 + if (position >= totalSize && finished) return -1 + + val available = (totalSize - position).toInt() + val toRead = min(size, available) + var remaining = toRead + var destOffset = offset + var pos = position + + var index = findChunkIndex(pos) + while (remaining > 0 && index < chunks.size) { + val chunk = chunks[index] + val inChunkOffset = (pos - chunk.start).toInt() + if (inChunkOffset >= chunk.data.size) { + index++ + continue + } + val copyLen = min(remaining, chunk.data.size - inChunkOffset) + System.arraycopy(chunk.data, inChunkOffset, buffer, destOffset, copyLen) + remaining -= copyLen + destOffset += copyLen + pos += copyLen + if (inChunkOffset + copyLen >= chunk.data.size) { + index++ + } + } + + return toRead - remaining + } + } + + override fun getSize(): Long = -1 + + override fun close() { + synchronized(lock) { + closed = true + lock.notifyAll() + } + } + + private fun findChunkIndex(position: Long): Int { + var index = lastReadIndex + while (index < chunks.size) { + val chunk = chunks[index] + if (position < chunk.start + chunk.data.size) break + index++ + } + lastReadIndex = index + return index + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/voice/TalkDirectiveParser.kt b/apps/android/app/src/main/java/bot/molt/android/voice/TalkDirectiveParser.kt new file mode 100644 index 000000000..0d969e4d1 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/voice/TalkDirectiveParser.kt @@ -0,0 +1,191 @@ +package bot.molt.android.voice + +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonElement +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive + +private val directiveJson = Json { ignoreUnknownKeys = true } + +data class TalkDirective( + val voiceId: String? = null, + val modelId: String? = null, + val speed: Double? = null, + val rateWpm: Int? = null, + val stability: Double? = null, + val similarity: Double? = null, + val style: Double? = null, + val speakerBoost: Boolean? = null, + val seed: Long? = null, + val normalize: String? = null, + val language: String? = null, + val outputFormat: String? = null, + val latencyTier: Int? = null, + val once: Boolean? = null, +) + +data class TalkDirectiveParseResult( + val directive: TalkDirective?, + val stripped: String, + val unknownKeys: List, +) + +object TalkDirectiveParser { + fun parse(text: String): TalkDirectiveParseResult { + val normalized = text.replace("\r\n", "\n") + val lines = normalized.split("\n").toMutableList() + if (lines.isEmpty()) return TalkDirectiveParseResult(null, text, emptyList()) + + val firstNonEmpty = lines.indexOfFirst { it.trim().isNotEmpty() } + if (firstNonEmpty == -1) return TalkDirectiveParseResult(null, text, emptyList()) + + val head = lines[firstNonEmpty].trim() + if (!head.startsWith("{") || !head.endsWith("}")) { + return TalkDirectiveParseResult(null, text, emptyList()) + } + + val obj = parseJsonObject(head) ?: return TalkDirectiveParseResult(null, text, emptyList()) + + val speakerBoost = + boolValue(obj, listOf("speaker_boost", "speakerBoost")) + ?: boolValue(obj, listOf("no_speaker_boost", "noSpeakerBoost"))?.not() + + val directive = TalkDirective( + voiceId = stringValue(obj, listOf("voice", "voice_id", "voiceId")), + modelId = stringValue(obj, listOf("model", "model_id", "modelId")), + speed = doubleValue(obj, listOf("speed")), + rateWpm = intValue(obj, listOf("rate", "wpm")), + stability = doubleValue(obj, listOf("stability")), + similarity = doubleValue(obj, listOf("similarity", "similarity_boost", "similarityBoost")), + style = doubleValue(obj, listOf("style")), + speakerBoost = speakerBoost, + seed = longValue(obj, listOf("seed")), + normalize = stringValue(obj, listOf("normalize", "apply_text_normalization")), + language = stringValue(obj, listOf("lang", "language_code", "language")), + outputFormat = stringValue(obj, listOf("output_format", "format")), + latencyTier = intValue(obj, listOf("latency", "latency_tier", "latencyTier")), + once = boolValue(obj, listOf("once")), + ) + + val hasDirective = listOf( + directive.voiceId, + directive.modelId, + directive.speed, + directive.rateWpm, + directive.stability, + directive.similarity, + directive.style, + directive.speakerBoost, + directive.seed, + directive.normalize, + directive.language, + directive.outputFormat, + directive.latencyTier, + directive.once, + ).any { it != null } + + if (!hasDirective) return TalkDirectiveParseResult(null, text, emptyList()) + + val knownKeys = setOf( + "voice", "voice_id", "voiceid", + "model", "model_id", "modelid", + "speed", "rate", "wpm", + "stability", "similarity", "similarity_boost", "similarityboost", + "style", + "speaker_boost", "speakerboost", + "no_speaker_boost", "nospeakerboost", + "seed", + "normalize", "apply_text_normalization", + "lang", "language_code", "language", + "output_format", "format", + "latency", "latency_tier", "latencytier", + "once", + ) + val unknownKeys = obj.keys.filter { !knownKeys.contains(it.lowercase()) }.sorted() + + lines.removeAt(firstNonEmpty) + if (firstNonEmpty < lines.size) { + if (lines[firstNonEmpty].trim().isEmpty()) { + lines.removeAt(firstNonEmpty) + } + } + + return TalkDirectiveParseResult(directive, lines.joinToString("\n"), unknownKeys) + } + + private fun parseJsonObject(line: String): JsonObject? { + return try { + directiveJson.parseToJsonElement(line) as? JsonObject + } catch (_: Throwable) { + null + } + } + + private fun stringValue(obj: JsonObject, keys: List): String? { + for (key in keys) { + val value = obj[key].asStringOrNull()?.trim() + if (!value.isNullOrEmpty()) return value + } + return null + } + + private fun doubleValue(obj: JsonObject, keys: List): Double? { + for (key in keys) { + val value = obj[key].asDoubleOrNull() + if (value != null) return value + } + return null + } + + private fun intValue(obj: JsonObject, keys: List): Int? { + for (key in keys) { + val value = obj[key].asIntOrNull() + if (value != null) return value + } + return null + } + + private fun longValue(obj: JsonObject, keys: List): Long? { + for (key in keys) { + val value = obj[key].asLongOrNull() + if (value != null) return value + } + return null + } + + private fun boolValue(obj: JsonObject, keys: List): Boolean? { + for (key in keys) { + val value = obj[key].asBooleanOrNull() + if (value != null) return value + } + return null + } +} + +private fun JsonElement?.asStringOrNull(): String? = + (this as? JsonPrimitive)?.takeIf { it.isString }?.content + +private fun JsonElement?.asDoubleOrNull(): Double? { + val primitive = this as? JsonPrimitive ?: return null + return primitive.content.toDoubleOrNull() +} + +private fun JsonElement?.asIntOrNull(): Int? { + val primitive = this as? JsonPrimitive ?: return null + return primitive.content.toIntOrNull() +} + +private fun JsonElement?.asLongOrNull(): Long? { + val primitive = this as? JsonPrimitive ?: return null + return primitive.content.toLongOrNull() +} + +private fun JsonElement?.asBooleanOrNull(): Boolean? { + val primitive = this as? JsonPrimitive ?: return null + val content = primitive.content.trim().lowercase() + return when (content) { + "true", "yes", "1" -> true + "false", "no", "0" -> false + else -> null + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/voice/TalkModeManager.kt b/apps/android/app/src/main/java/bot/molt/android/voice/TalkModeManager.kt new file mode 100644 index 000000000..f050f8bd2 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/voice/TalkModeManager.kt @@ -0,0 +1,1257 @@ +package bot.molt.android.voice + +import android.Manifest +import android.content.Context +import android.content.Intent +import android.content.pm.PackageManager +import android.media.AudioAttributes +import android.media.AudioFormat +import android.media.AudioManager +import android.media.AudioTrack +import android.media.MediaPlayer +import android.os.Bundle +import android.os.Handler +import android.os.Looper +import android.os.SystemClock +import android.speech.RecognitionListener +import android.speech.RecognizerIntent +import android.speech.SpeechRecognizer +import android.speech.tts.TextToSpeech +import android.speech.tts.UtteranceProgressListener +import android.util.Log +import androidx.core.content.ContextCompat +import bot.molt.android.gateway.GatewaySession +import bot.molt.android.isCanonicalMainSessionKey +import bot.molt.android.normalizeMainKey +import java.net.HttpURLConnection +import java.net.URL +import java.util.UUID +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonElement +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.buildJsonObject +import kotlin.math.max + +class TalkModeManager( + private val context: Context, + private val scope: CoroutineScope, + private val session: GatewaySession, + private val supportsChatSubscribe: Boolean, + private val isConnected: () -> Boolean, +) { + companion object { + private const val tag = "TalkMode" + private const val defaultModelIdFallback = "eleven_v3" + private const val defaultOutputFormatFallback = "pcm_24000" + } + + private val mainHandler = Handler(Looper.getMainLooper()) + private val json = Json { ignoreUnknownKeys = true } + + private val _isEnabled = MutableStateFlow(false) + val isEnabled: StateFlow = _isEnabled + + private val _isListening = MutableStateFlow(false) + val isListening: StateFlow = _isListening + + private val _isSpeaking = MutableStateFlow(false) + val isSpeaking: StateFlow = _isSpeaking + + private val _statusText = MutableStateFlow("Off") + val statusText: StateFlow = _statusText + + private val _lastAssistantText = MutableStateFlow(null) + val lastAssistantText: StateFlow = _lastAssistantText + + private val _usingFallbackTts = MutableStateFlow(false) + val usingFallbackTts: StateFlow = _usingFallbackTts + + private var recognizer: SpeechRecognizer? = null + private var restartJob: Job? = null + private var stopRequested = false + private var listeningMode = false + + private var silenceJob: Job? = null + private val silenceWindowMs = 700L + private var lastTranscript: String = "" + private var lastHeardAtMs: Long? = null + private var lastSpokenText: String? = null + private var lastInterruptedAtSeconds: Double? = null + + private var defaultVoiceId: String? = null + private var currentVoiceId: String? = null + private var fallbackVoiceId: String? = null + private var defaultModelId: String? = null + private var currentModelId: String? = null + private var defaultOutputFormat: String? = null + private var apiKey: String? = null + private var voiceAliases: Map = emptyMap() + private var interruptOnSpeech: Boolean = true + private var voiceOverrideActive = false + private var modelOverrideActive = false + private var mainSessionKey: String = "main" + + private var pendingRunId: String? = null + private var pendingFinal: CompletableDeferred? = null + private var chatSubscribedSessionKey: String? = null + + private var player: MediaPlayer? = null + private var streamingSource: StreamingMediaDataSource? = null + private var pcmTrack: AudioTrack? = null + @Volatile private var pcmStopRequested = false + private var systemTts: TextToSpeech? = null + private var systemTtsPending: CompletableDeferred? = null + private var systemTtsPendingId: String? = null + + fun setMainSessionKey(sessionKey: String?) { + val trimmed = sessionKey?.trim().orEmpty() + if (trimmed.isEmpty()) return + if (isCanonicalMainSessionKey(mainSessionKey)) return + mainSessionKey = trimmed + } + + fun setEnabled(enabled: Boolean) { + if (_isEnabled.value == enabled) return + _isEnabled.value = enabled + if (enabled) { + Log.d(tag, "enabled") + start() + } else { + Log.d(tag, "disabled") + stop() + } + } + + fun handleGatewayEvent(event: String, payloadJson: String?) { + if (event != "chat") return + if (payloadJson.isNullOrBlank()) return + val pending = pendingRunId ?: return + val obj = + try { + json.parseToJsonElement(payloadJson).asObjectOrNull() + } catch (_: Throwable) { + null + } ?: return + val runId = obj["runId"].asStringOrNull() ?: return + if (runId != pending) return + val state = obj["state"].asStringOrNull() ?: return + if (state == "final") { + pendingFinal?.complete(true) + pendingFinal = null + pendingRunId = null + } + } + + private fun start() { + mainHandler.post { + if (_isListening.value) return@post + stopRequested = false + listeningMode = true + Log.d(tag, "start") + + if (!SpeechRecognizer.isRecognitionAvailable(context)) { + _statusText.value = "Speech recognizer unavailable" + Log.w(tag, "speech recognizer unavailable") + return@post + } + + val micOk = + ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == + PackageManager.PERMISSION_GRANTED + if (!micOk) { + _statusText.value = "Microphone permission required" + Log.w(tag, "microphone permission required") + return@post + } + + try { + recognizer?.destroy() + recognizer = SpeechRecognizer.createSpeechRecognizer(context).also { it.setRecognitionListener(listener) } + startListeningInternal(markListening = true) + startSilenceMonitor() + Log.d(tag, "listening") + } catch (err: Throwable) { + _statusText.value = "Start failed: ${err.message ?: err::class.simpleName}" + Log.w(tag, "start failed: ${err.message ?: err::class.simpleName}") + } + } + } + + private fun stop() { + stopRequested = true + listeningMode = false + restartJob?.cancel() + restartJob = null + silenceJob?.cancel() + silenceJob = null + lastTranscript = "" + lastHeardAtMs = null + _isListening.value = false + _statusText.value = "Off" + stopSpeaking() + _usingFallbackTts.value = false + chatSubscribedSessionKey = null + + mainHandler.post { + recognizer?.cancel() + recognizer?.destroy() + recognizer = null + } + systemTts?.stop() + systemTtsPending?.cancel() + systemTtsPending = null + systemTtsPendingId = null + } + + private fun startListeningInternal(markListening: Boolean) { + val r = recognizer ?: return + val intent = + Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply { + putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM) + putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true) + putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 3) + putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, context.packageName) + } + + if (markListening) { + _statusText.value = "Listening" + _isListening.value = true + } + r.startListening(intent) + } + + private fun scheduleRestart(delayMs: Long = 350) { + if (stopRequested) return + restartJob?.cancel() + restartJob = + scope.launch { + delay(delayMs) + mainHandler.post { + if (stopRequested) return@post + try { + recognizer?.cancel() + val shouldListen = listeningMode + val shouldInterrupt = _isSpeaking.value && interruptOnSpeech + if (!shouldListen && !shouldInterrupt) return@post + startListeningInternal(markListening = shouldListen) + } catch (_: Throwable) { + // handled by onError + } + } + } + } + + private fun handleTranscript(text: String, isFinal: Boolean) { + val trimmed = text.trim() + if (_isSpeaking.value && interruptOnSpeech) { + if (shouldInterrupt(trimmed)) { + stopSpeaking() + } + return + } + + if (!_isListening.value) return + + if (trimmed.isNotEmpty()) { + lastTranscript = trimmed + lastHeardAtMs = SystemClock.elapsedRealtime() + } + + if (isFinal) { + lastTranscript = trimmed + } + } + + private fun startSilenceMonitor() { + silenceJob?.cancel() + silenceJob = + scope.launch { + while (_isEnabled.value) { + delay(200) + checkSilence() + } + } + } + + private fun checkSilence() { + if (!_isListening.value) return + val transcript = lastTranscript.trim() + if (transcript.isEmpty()) return + val lastHeard = lastHeardAtMs ?: return + val elapsed = SystemClock.elapsedRealtime() - lastHeard + if (elapsed < silenceWindowMs) return + scope.launch { finalizeTranscript(transcript) } + } + + private suspend fun finalizeTranscript(transcript: String) { + listeningMode = false + _isListening.value = false + _statusText.value = "Thinking…" + lastTranscript = "" + lastHeardAtMs = null + + reloadConfig() + val prompt = buildPrompt(transcript) + if (!isConnected()) { + _statusText.value = "Gateway not connected" + Log.w(tag, "finalize: gateway not connected") + start() + return + } + + try { + val startedAt = System.currentTimeMillis().toDouble() / 1000.0 + subscribeChatIfNeeded(session = session, sessionKey = mainSessionKey) + Log.d(tag, "chat.send start sessionKey=${mainSessionKey.ifBlank { "main" }} chars=${prompt.length}") + val runId = sendChat(prompt, session) + Log.d(tag, "chat.send ok runId=$runId") + val ok = waitForChatFinal(runId) + if (!ok) { + Log.w(tag, "chat final timeout runId=$runId; attempting history fallback") + } + val assistant = waitForAssistantText(session, startedAt, if (ok) 12_000 else 25_000) + if (assistant.isNullOrBlank()) { + _statusText.value = "No reply" + Log.w(tag, "assistant text timeout runId=$runId") + start() + return + } + Log.d(tag, "assistant text ok chars=${assistant.length}") + playAssistant(assistant) + } catch (err: Throwable) { + _statusText.value = "Talk failed: ${err.message ?: err::class.simpleName}" + Log.w(tag, "finalize failed: ${err.message ?: err::class.simpleName}") + } + + if (_isEnabled.value) { + start() + } + } + + private suspend fun subscribeChatIfNeeded(session: GatewaySession, sessionKey: String) { + if (!supportsChatSubscribe) return + val key = sessionKey.trim() + if (key.isEmpty()) return + if (chatSubscribedSessionKey == key) return + try { + session.sendNodeEvent("chat.subscribe", """{"sessionKey":"$key"}""") + chatSubscribedSessionKey = key + Log.d(tag, "chat.subscribe ok sessionKey=$key") + } catch (err: Throwable) { + Log.w(tag, "chat.subscribe failed sessionKey=$key err=${err.message ?: err::class.java.simpleName}") + } + } + + private fun buildPrompt(transcript: String): String { + val lines = mutableListOf( + "Talk Mode active. Reply in a concise, spoken tone.", + "You may optionally prefix the response with JSON (first line) to set ElevenLabs voice (id or alias), e.g. {\"voice\":\"\",\"once\":true}.", + ) + lastInterruptedAtSeconds?.let { + lines.add("Assistant speech interrupted at ${"%.1f".format(it)}s.") + lastInterruptedAtSeconds = null + } + lines.add("") + lines.add(transcript) + return lines.joinToString("\n") + } + + private suspend fun sendChat(message: String, session: GatewaySession): String { + val runId = UUID.randomUUID().toString() + val params = + buildJsonObject { + put("sessionKey", JsonPrimitive(mainSessionKey.ifBlank { "main" })) + put("message", JsonPrimitive(message)) + put("thinking", JsonPrimitive("low")) + put("timeoutMs", JsonPrimitive(30_000)) + put("idempotencyKey", JsonPrimitive(runId)) + } + val res = session.request("chat.send", params.toString()) + val parsed = parseRunId(res) ?: runId + if (parsed != runId) { + pendingRunId = parsed + } + return parsed + } + + private suspend fun waitForChatFinal(runId: String): Boolean { + pendingFinal?.cancel() + val deferred = CompletableDeferred() + pendingRunId = runId + pendingFinal = deferred + + val result = + withContext(Dispatchers.IO) { + try { + kotlinx.coroutines.withTimeout(120_000) { deferred.await() } + } catch (_: Throwable) { + false + } + } + + if (!result) { + pendingFinal = null + pendingRunId = null + } + return result + } + + private suspend fun waitForAssistantText( + session: GatewaySession, + sinceSeconds: Double, + timeoutMs: Long, + ): String? { + val deadline = SystemClock.elapsedRealtime() + timeoutMs + while (SystemClock.elapsedRealtime() < deadline) { + val text = fetchLatestAssistantText(session, sinceSeconds) + if (!text.isNullOrBlank()) return text + delay(300) + } + return null + } + + private suspend fun fetchLatestAssistantText( + session: GatewaySession, + sinceSeconds: Double? = null, + ): String? { + val key = mainSessionKey.ifBlank { "main" } + val res = session.request("chat.history", "{\"sessionKey\":\"$key\"}") + val root = json.parseToJsonElement(res).asObjectOrNull() ?: return null + val messages = root["messages"] as? JsonArray ?: return null + for (item in messages.reversed()) { + val obj = item.asObjectOrNull() ?: continue + if (obj["role"].asStringOrNull() != "assistant") continue + if (sinceSeconds != null) { + val timestamp = obj["timestamp"].asDoubleOrNull() + if (timestamp != null && !TalkModeRuntime.isMessageTimestampAfter(timestamp, sinceSeconds)) continue + } + val content = obj["content"] as? JsonArray ?: continue + val text = + content.mapNotNull { entry -> + entry.asObjectOrNull()?.get("text")?.asStringOrNull()?.trim() + }.filter { it.isNotEmpty() } + if (text.isNotEmpty()) return text.joinToString("\n") + } + return null + } + + private suspend fun playAssistant(text: String) { + val parsed = TalkDirectiveParser.parse(text) + if (parsed.unknownKeys.isNotEmpty()) { + Log.w(tag, "Unknown talk directive keys: ${parsed.unknownKeys}") + } + val directive = parsed.directive + val cleaned = parsed.stripped.trim() + if (cleaned.isEmpty()) return + _lastAssistantText.value = cleaned + + val requestedVoice = directive?.voiceId?.trim()?.takeIf { it.isNotEmpty() } + val resolvedVoice = resolveVoiceAlias(requestedVoice) + if (requestedVoice != null && resolvedVoice == null) { + Log.w(tag, "unknown voice alias: $requestedVoice") + } + + if (directive?.voiceId != null) { + if (directive.once != true) { + currentVoiceId = resolvedVoice + voiceOverrideActive = true + } + } + if (directive?.modelId != null) { + if (directive.once != true) { + currentModelId = directive.modelId + modelOverrideActive = true + } + } + + val apiKey = + apiKey?.trim()?.takeIf { it.isNotEmpty() } + ?: System.getenv("ELEVENLABS_API_KEY")?.trim() + val preferredVoice = resolvedVoice ?: currentVoiceId ?: defaultVoiceId + val voiceId = + if (!apiKey.isNullOrEmpty()) { + resolveVoiceId(preferredVoice, apiKey) + } else { + null + } + + _statusText.value = "Speaking…" + _isSpeaking.value = true + lastSpokenText = cleaned + ensureInterruptListener() + + try { + val canUseElevenLabs = !voiceId.isNullOrBlank() && !apiKey.isNullOrEmpty() + if (!canUseElevenLabs) { + if (voiceId.isNullOrBlank()) { + Log.w(tag, "missing voiceId; falling back to system voice") + } + if (apiKey.isNullOrEmpty()) { + Log.w(tag, "missing ELEVENLABS_API_KEY; falling back to system voice") + } + _usingFallbackTts.value = true + _statusText.value = "Speaking (System)…" + speakWithSystemTts(cleaned) + } else { + _usingFallbackTts.value = false + val ttsStarted = SystemClock.elapsedRealtime() + val modelId = directive?.modelId ?: currentModelId ?: defaultModelId + val request = + ElevenLabsRequest( + text = cleaned, + modelId = modelId, + outputFormat = + TalkModeRuntime.validatedOutputFormat(directive?.outputFormat ?: defaultOutputFormat), + speed = TalkModeRuntime.resolveSpeed(directive?.speed, directive?.rateWpm), + stability = TalkModeRuntime.validatedStability(directive?.stability, modelId), + similarity = TalkModeRuntime.validatedUnit(directive?.similarity), + style = TalkModeRuntime.validatedUnit(directive?.style), + speakerBoost = directive?.speakerBoost, + seed = TalkModeRuntime.validatedSeed(directive?.seed), + normalize = TalkModeRuntime.validatedNormalize(directive?.normalize), + language = TalkModeRuntime.validatedLanguage(directive?.language), + latencyTier = TalkModeRuntime.validatedLatencyTier(directive?.latencyTier), + ) + streamAndPlay(voiceId = voiceId!!, apiKey = apiKey!!, request = request) + Log.d(tag, "elevenlabs stream ok durMs=${SystemClock.elapsedRealtime() - ttsStarted}") + } + } catch (err: Throwable) { + Log.w(tag, "speak failed: ${err.message ?: err::class.simpleName}; falling back to system voice") + try { + _usingFallbackTts.value = true + _statusText.value = "Speaking (System)…" + speakWithSystemTts(cleaned) + } catch (fallbackErr: Throwable) { + _statusText.value = "Speak failed: ${fallbackErr.message ?: fallbackErr::class.simpleName}" + Log.w(tag, "system voice failed: ${fallbackErr.message ?: fallbackErr::class.simpleName}") + } + } + + _isSpeaking.value = false + } + + private suspend fun streamAndPlay(voiceId: String, apiKey: String, request: ElevenLabsRequest) { + stopSpeaking(resetInterrupt = false) + + pcmStopRequested = false + val pcmSampleRate = TalkModeRuntime.parsePcmSampleRate(request.outputFormat) + if (pcmSampleRate != null) { + try { + streamAndPlayPcm(voiceId = voiceId, apiKey = apiKey, request = request, sampleRate = pcmSampleRate) + return + } catch (err: Throwable) { + if (pcmStopRequested) return + Log.w(tag, "pcm playback failed; falling back to mp3: ${err.message ?: err::class.simpleName}") + } + } + + streamAndPlayMp3(voiceId = voiceId, apiKey = apiKey, request = request) + } + + private suspend fun streamAndPlayMp3(voiceId: String, apiKey: String, request: ElevenLabsRequest) { + val dataSource = StreamingMediaDataSource() + streamingSource = dataSource + + val player = MediaPlayer() + this.player = player + + val prepared = CompletableDeferred() + val finished = CompletableDeferred() + + player.setAudioAttributes( + AudioAttributes.Builder() + .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH) + .setUsage(AudioAttributes.USAGE_ASSISTANT) + .build(), + ) + player.setOnPreparedListener { + it.start() + prepared.complete(Unit) + } + player.setOnCompletionListener { + finished.complete(Unit) + } + player.setOnErrorListener { _, _, _ -> + finished.completeExceptionally(IllegalStateException("MediaPlayer error")) + true + } + + player.setDataSource(dataSource) + withContext(Dispatchers.Main) { + player.prepareAsync() + } + + val fetchError = CompletableDeferred() + val fetchJob = + scope.launch(Dispatchers.IO) { + try { + streamTts(voiceId = voiceId, apiKey = apiKey, request = request, sink = dataSource) + fetchError.complete(null) + } catch (err: Throwable) { + dataSource.fail() + fetchError.complete(err) + } + } + + Log.d(tag, "play start") + try { + prepared.await() + finished.await() + fetchError.await()?.let { throw it } + } finally { + fetchJob.cancel() + cleanupPlayer() + } + Log.d(tag, "play done") + } + + private suspend fun streamAndPlayPcm( + voiceId: String, + apiKey: String, + request: ElevenLabsRequest, + sampleRate: Int, + ) { + val minBuffer = + AudioTrack.getMinBufferSize( + sampleRate, + AudioFormat.CHANNEL_OUT_MONO, + AudioFormat.ENCODING_PCM_16BIT, + ) + if (minBuffer <= 0) { + throw IllegalStateException("AudioTrack buffer size invalid: $minBuffer") + } + + val bufferSize = max(minBuffer * 2, 8 * 1024) + val track = + AudioTrack( + AudioAttributes.Builder() + .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH) + .setUsage(AudioAttributes.USAGE_ASSISTANT) + .build(), + AudioFormat.Builder() + .setSampleRate(sampleRate) + .setChannelMask(AudioFormat.CHANNEL_OUT_MONO) + .setEncoding(AudioFormat.ENCODING_PCM_16BIT) + .build(), + bufferSize, + AudioTrack.MODE_STREAM, + AudioManager.AUDIO_SESSION_ID_GENERATE, + ) + if (track.state != AudioTrack.STATE_INITIALIZED) { + track.release() + throw IllegalStateException("AudioTrack init failed") + } + pcmTrack = track + track.play() + + Log.d(tag, "pcm play start sampleRate=$sampleRate bufferSize=$bufferSize") + try { + streamPcm(voiceId = voiceId, apiKey = apiKey, request = request, track = track) + } finally { + cleanupPcmTrack() + } + Log.d(tag, "pcm play done") + } + + private suspend fun speakWithSystemTts(text: String) { + val trimmed = text.trim() + if (trimmed.isEmpty()) return + val ok = ensureSystemTts() + if (!ok) { + throw IllegalStateException("system TTS unavailable") + } + + val tts = systemTts ?: throw IllegalStateException("system TTS unavailable") + val utteranceId = "talk-${UUID.randomUUID()}" + val deferred = CompletableDeferred() + systemTtsPending?.cancel() + systemTtsPending = deferred + systemTtsPendingId = utteranceId + + withContext(Dispatchers.Main) { + val params = Bundle() + tts.speak(trimmed, TextToSpeech.QUEUE_FLUSH, params, utteranceId) + } + + withContext(Dispatchers.IO) { + try { + kotlinx.coroutines.withTimeout(180_000) { deferred.await() } + } catch (err: Throwable) { + throw err + } + } + } + + private suspend fun ensureSystemTts(): Boolean { + if (systemTts != null) return true + return withContext(Dispatchers.Main) { + val deferred = CompletableDeferred() + val tts = + try { + TextToSpeech(context) { status -> + deferred.complete(status == TextToSpeech.SUCCESS) + } + } catch (_: Throwable) { + deferred.complete(false) + null + } + if (tts == null) return@withContext false + + tts.setOnUtteranceProgressListener( + object : UtteranceProgressListener() { + override fun onStart(utteranceId: String?) {} + + override fun onDone(utteranceId: String?) { + if (utteranceId == null) return + if (utteranceId != systemTtsPendingId) return + systemTtsPending?.complete(Unit) + systemTtsPending = null + systemTtsPendingId = null + } + + @Suppress("OVERRIDE_DEPRECATION") + @Deprecated("Deprecated in Java") + override fun onError(utteranceId: String?) { + if (utteranceId == null) return + if (utteranceId != systemTtsPendingId) return + systemTtsPending?.completeExceptionally(IllegalStateException("system TTS error")) + systemTtsPending = null + systemTtsPendingId = null + } + + override fun onError(utteranceId: String?, errorCode: Int) { + if (utteranceId == null) return + if (utteranceId != systemTtsPendingId) return + systemTtsPending?.completeExceptionally(IllegalStateException("system TTS error $errorCode")) + systemTtsPending = null + systemTtsPendingId = null + } + }, + ) + + val ok = + try { + deferred.await() + } catch (_: Throwable) { + false + } + if (ok) { + systemTts = tts + } else { + tts.shutdown() + } + ok + } + } + + private fun stopSpeaking(resetInterrupt: Boolean = true) { + pcmStopRequested = true + if (!_isSpeaking.value) { + cleanupPlayer() + cleanupPcmTrack() + systemTts?.stop() + systemTtsPending?.cancel() + systemTtsPending = null + systemTtsPendingId = null + return + } + if (resetInterrupt) { + val currentMs = player?.currentPosition?.toDouble() ?: 0.0 + lastInterruptedAtSeconds = currentMs / 1000.0 + } + cleanupPlayer() + cleanupPcmTrack() + systemTts?.stop() + systemTtsPending?.cancel() + systemTtsPending = null + systemTtsPendingId = null + _isSpeaking.value = false + } + + private fun cleanupPlayer() { + player?.stop() + player?.release() + player = null + streamingSource?.close() + streamingSource = null + } + + private fun cleanupPcmTrack() { + val track = pcmTrack ?: return + try { + track.pause() + track.flush() + track.stop() + } catch (_: Throwable) { + // ignore cleanup errors + } finally { + track.release() + } + pcmTrack = null + } + + private fun shouldInterrupt(transcript: String): Boolean { + val trimmed = transcript.trim() + if (trimmed.length < 3) return false + val spoken = lastSpokenText?.lowercase() + if (spoken != null && spoken.contains(trimmed.lowercase())) return false + return true + } + + private suspend fun reloadConfig() { + val envVoice = System.getenv("ELEVENLABS_VOICE_ID")?.trim() + val sagVoice = System.getenv("SAG_VOICE_ID")?.trim() + val envKey = System.getenv("ELEVENLABS_API_KEY")?.trim() + try { + val res = session.request("config.get", "{}") + val root = json.parseToJsonElement(res).asObjectOrNull() + val config = root?.get("config").asObjectOrNull() + val talk = config?.get("talk").asObjectOrNull() + val sessionCfg = config?.get("session").asObjectOrNull() + val mainKey = normalizeMainKey(sessionCfg?.get("mainKey").asStringOrNull()) + val voice = talk?.get("voiceId")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() } + val aliases = + talk?.get("voiceAliases").asObjectOrNull()?.entries?.mapNotNull { (key, value) -> + val id = value.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() } ?: return@mapNotNull null + normalizeAliasKey(key).takeIf { it.isNotEmpty() }?.let { it to id } + }?.toMap().orEmpty() + val model = talk?.get("modelId")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() } + val outputFormat = talk?.get("outputFormat")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() } + val key = talk?.get("apiKey")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() } + val interrupt = talk?.get("interruptOnSpeech")?.asBooleanOrNull() + + if (!isCanonicalMainSessionKey(mainSessionKey)) { + mainSessionKey = mainKey + } + defaultVoiceId = voice ?: envVoice?.takeIf { it.isNotEmpty() } ?: sagVoice?.takeIf { it.isNotEmpty() } + voiceAliases = aliases + if (!voiceOverrideActive) currentVoiceId = defaultVoiceId + defaultModelId = model ?: defaultModelIdFallback + if (!modelOverrideActive) currentModelId = defaultModelId + defaultOutputFormat = outputFormat ?: defaultOutputFormatFallback + apiKey = key ?: envKey?.takeIf { it.isNotEmpty() } + if (interrupt != null) interruptOnSpeech = interrupt + } catch (_: Throwable) { + defaultVoiceId = envVoice?.takeIf { it.isNotEmpty() } ?: sagVoice?.takeIf { it.isNotEmpty() } + defaultModelId = defaultModelIdFallback + if (!modelOverrideActive) currentModelId = defaultModelId + apiKey = envKey?.takeIf { it.isNotEmpty() } + voiceAliases = emptyMap() + defaultOutputFormat = defaultOutputFormatFallback + } + } + + private fun parseRunId(jsonString: String): String? { + val obj = json.parseToJsonElement(jsonString).asObjectOrNull() ?: return null + return obj["runId"].asStringOrNull() + } + + private suspend fun streamTts( + voiceId: String, + apiKey: String, + request: ElevenLabsRequest, + sink: StreamingMediaDataSource, + ) { + withContext(Dispatchers.IO) { + val conn = openTtsConnection(voiceId = voiceId, apiKey = apiKey, request = request) + try { + val payload = buildRequestPayload(request) + conn.outputStream.use { it.write(payload.toByteArray()) } + + val code = conn.responseCode + if (code >= 400) { + val message = conn.errorStream?.readBytes()?.toString(Charsets.UTF_8) ?: "" + sink.fail() + throw IllegalStateException("ElevenLabs failed: $code $message") + } + + val buffer = ByteArray(8 * 1024) + conn.inputStream.use { input -> + while (true) { + val read = input.read(buffer) + if (read <= 0) break + sink.append(buffer.copyOf(read)) + } + } + sink.finish() + } finally { + conn.disconnect() + } + } + } + + private suspend fun streamPcm( + voiceId: String, + apiKey: String, + request: ElevenLabsRequest, + track: AudioTrack, + ) { + withContext(Dispatchers.IO) { + val conn = openTtsConnection(voiceId = voiceId, apiKey = apiKey, request = request) + try { + val payload = buildRequestPayload(request) + conn.outputStream.use { it.write(payload.toByteArray()) } + + val code = conn.responseCode + if (code >= 400) { + val message = conn.errorStream?.readBytes()?.toString(Charsets.UTF_8) ?: "" + throw IllegalStateException("ElevenLabs failed: $code $message") + } + + val buffer = ByteArray(8 * 1024) + conn.inputStream.use { input -> + while (true) { + if (pcmStopRequested) return@withContext + val read = input.read(buffer) + if (read <= 0) break + var offset = 0 + while (offset < read) { + if (pcmStopRequested) return@withContext + val wrote = + try { + track.write(buffer, offset, read - offset) + } catch (err: Throwable) { + if (pcmStopRequested) return@withContext + throw err + } + if (wrote <= 0) { + if (pcmStopRequested) return@withContext + throw IllegalStateException("AudioTrack write failed: $wrote") + } + offset += wrote + } + } + } + } finally { + conn.disconnect() + } + } + } + + private fun openTtsConnection( + voiceId: String, + apiKey: String, + request: ElevenLabsRequest, + ): HttpURLConnection { + val baseUrl = "https://api.elevenlabs.io/v1/text-to-speech/$voiceId/stream" + val latencyTier = request.latencyTier + val url = + if (latencyTier != null) { + URL("$baseUrl?optimize_streaming_latency=$latencyTier") + } else { + URL(baseUrl) + } + val conn = url.openConnection() as HttpURLConnection + conn.requestMethod = "POST" + conn.connectTimeout = 30_000 + conn.readTimeout = 30_000 + conn.setRequestProperty("Content-Type", "application/json") + conn.setRequestProperty("Accept", resolveAcceptHeader(request.outputFormat)) + conn.setRequestProperty("xi-api-key", apiKey) + conn.doOutput = true + return conn + } + + private fun resolveAcceptHeader(outputFormat: String?): String { + val normalized = outputFormat?.trim()?.lowercase().orEmpty() + return if (normalized.startsWith("pcm_")) "audio/pcm" else "audio/mpeg" + } + + private fun buildRequestPayload(request: ElevenLabsRequest): String { + val voiceSettingsEntries = + buildJsonObject { + request.speed?.let { put("speed", JsonPrimitive(it)) } + request.stability?.let { put("stability", JsonPrimitive(it)) } + request.similarity?.let { put("similarity_boost", JsonPrimitive(it)) } + request.style?.let { put("style", JsonPrimitive(it)) } + request.speakerBoost?.let { put("use_speaker_boost", JsonPrimitive(it)) } + } + + val payload = + buildJsonObject { + put("text", JsonPrimitive(request.text)) + request.modelId?.takeIf { it.isNotEmpty() }?.let { put("model_id", JsonPrimitive(it)) } + request.outputFormat?.takeIf { it.isNotEmpty() }?.let { put("output_format", JsonPrimitive(it)) } + request.seed?.let { put("seed", JsonPrimitive(it)) } + request.normalize?.let { put("apply_text_normalization", JsonPrimitive(it)) } + request.language?.let { put("language_code", JsonPrimitive(it)) } + if (voiceSettingsEntries.isNotEmpty()) { + put("voice_settings", voiceSettingsEntries) + } + } + + return payload.toString() + } + + private data class ElevenLabsRequest( + val text: String, + val modelId: String?, + val outputFormat: String?, + val speed: Double?, + val stability: Double?, + val similarity: Double?, + val style: Double?, + val speakerBoost: Boolean?, + val seed: Long?, + val normalize: String?, + val language: String?, + val latencyTier: Int?, + ) + + private object TalkModeRuntime { + fun resolveSpeed(speed: Double?, rateWpm: Int?): Double? { + if (rateWpm != null && rateWpm > 0) { + val resolved = rateWpm.toDouble() / 175.0 + if (resolved <= 0.5 || resolved >= 2.0) return null + return resolved + } + if (speed != null) { + if (speed <= 0.5 || speed >= 2.0) return null + return speed + } + return null + } + + fun validatedUnit(value: Double?): Double? { + if (value == null) return null + if (value < 0 || value > 1) return null + return value + } + + fun validatedStability(value: Double?, modelId: String?): Double? { + if (value == null) return null + val normalized = modelId?.trim()?.lowercase() + if (normalized == "eleven_v3") { + return if (value == 0.0 || value == 0.5 || value == 1.0) value else null + } + return validatedUnit(value) + } + + fun validatedSeed(value: Long?): Long? { + if (value == null) return null + if (value < 0 || value > 4294967295L) return null + return value + } + + fun validatedNormalize(value: String?): String? { + val normalized = value?.trim()?.lowercase() ?: return null + return if (normalized in listOf("auto", "on", "off")) normalized else null + } + + fun validatedLanguage(value: String?): String? { + val normalized = value?.trim()?.lowercase() ?: return null + if (normalized.length != 2) return null + if (!normalized.all { it in 'a'..'z' }) return null + return normalized + } + + fun validatedOutputFormat(value: String?): String? { + val trimmed = value?.trim()?.lowercase() ?: return null + if (trimmed.isEmpty()) return null + if (trimmed.startsWith("mp3_")) return trimmed + return if (parsePcmSampleRate(trimmed) != null) trimmed else null + } + + fun validatedLatencyTier(value: Int?): Int? { + if (value == null) return null + if (value < 0 || value > 4) return null + return value + } + + fun parsePcmSampleRate(value: String?): Int? { + val trimmed = value?.trim()?.lowercase() ?: return null + if (!trimmed.startsWith("pcm_")) return null + val suffix = trimmed.removePrefix("pcm_") + val digits = suffix.takeWhile { it.isDigit() } + val rate = digits.toIntOrNull() ?: return null + return if (rate in setOf(16000, 22050, 24000, 44100)) rate else null + } + + fun isMessageTimestampAfter(timestamp: Double, sinceSeconds: Double): Boolean { + val sinceMs = sinceSeconds * 1000 + return if (timestamp > 10_000_000_000) { + timestamp >= sinceMs - 500 + } else { + timestamp >= sinceSeconds - 0.5 + } + } + } + + private fun ensureInterruptListener() { + if (!interruptOnSpeech || !_isEnabled.value) return + mainHandler.post { + if (stopRequested) return@post + if (!SpeechRecognizer.isRecognitionAvailable(context)) return@post + try { + if (recognizer == null) { + recognizer = SpeechRecognizer.createSpeechRecognizer(context).also { it.setRecognitionListener(listener) } + } + recognizer?.cancel() + startListeningInternal(markListening = false) + } catch (_: Throwable) { + // ignore + } + } + } + + private fun resolveVoiceAlias(value: String?): String? { + val trimmed = value?.trim().orEmpty() + if (trimmed.isEmpty()) return null + val normalized = normalizeAliasKey(trimmed) + voiceAliases[normalized]?.let { return it } + if (voiceAliases.values.any { it.equals(trimmed, ignoreCase = true) }) return trimmed + return if (isLikelyVoiceId(trimmed)) trimmed else null + } + + private suspend fun resolveVoiceId(preferred: String?, apiKey: String): String? { + val trimmed = preferred?.trim().orEmpty() + if (trimmed.isNotEmpty()) { + val resolved = resolveVoiceAlias(trimmed) + if (resolved != null) return resolved + Log.w(tag, "unknown voice alias $trimmed") + } + fallbackVoiceId?.let { return it } + + return try { + val voices = listVoices(apiKey) + val first = voices.firstOrNull() ?: return null + fallbackVoiceId = first.voiceId + if (defaultVoiceId.isNullOrBlank()) { + defaultVoiceId = first.voiceId + } + if (!voiceOverrideActive) { + currentVoiceId = first.voiceId + } + val name = first.name ?: "unknown" + Log.d(tag, "default voice selected $name (${first.voiceId})") + first.voiceId + } catch (err: Throwable) { + Log.w(tag, "list voices failed: ${err.message ?: err::class.simpleName}") + null + } + } + + private suspend fun listVoices(apiKey: String): List { + return withContext(Dispatchers.IO) { + val url = URL("https://api.elevenlabs.io/v1/voices") + val conn = url.openConnection() as HttpURLConnection + conn.requestMethod = "GET" + conn.connectTimeout = 15_000 + conn.readTimeout = 15_000 + conn.setRequestProperty("xi-api-key", apiKey) + + val code = conn.responseCode + val stream = if (code >= 400) conn.errorStream else conn.inputStream + val data = stream.readBytes() + if (code >= 400) { + val message = data.toString(Charsets.UTF_8) + throw IllegalStateException("ElevenLabs voices failed: $code $message") + } + + val root = json.parseToJsonElement(data.toString(Charsets.UTF_8)).asObjectOrNull() + val voices = (root?.get("voices") as? JsonArray) ?: JsonArray(emptyList()) + voices.mapNotNull { entry -> + val obj = entry.asObjectOrNull() ?: return@mapNotNull null + val voiceId = obj["voice_id"].asStringOrNull() ?: return@mapNotNull null + val name = obj["name"].asStringOrNull() + ElevenLabsVoice(voiceId, name) + } + } + } + + private fun isLikelyVoiceId(value: String): Boolean { + if (value.length < 10) return false + return value.all { it.isLetterOrDigit() || it == '-' || it == '_' } + } + + private fun normalizeAliasKey(value: String): String = + value.trim().lowercase() + + private data class ElevenLabsVoice(val voiceId: String, val name: String?) + + private val listener = + object : RecognitionListener { + override fun onReadyForSpeech(params: Bundle?) { + if (_isEnabled.value) { + _statusText.value = if (_isListening.value) "Listening" else _statusText.value + } + } + + override fun onBeginningOfSpeech() {} + + override fun onRmsChanged(rmsdB: Float) {} + + override fun onBufferReceived(buffer: ByteArray?) {} + + override fun onEndOfSpeech() { + scheduleRestart() + } + + override fun onError(error: Int) { + if (stopRequested) return + _isListening.value = false + if (error == SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS) { + _statusText.value = "Microphone permission required" + return + } + + _statusText.value = + when (error) { + SpeechRecognizer.ERROR_AUDIO -> "Audio error" + SpeechRecognizer.ERROR_CLIENT -> "Client error" + SpeechRecognizer.ERROR_NETWORK -> "Network error" + SpeechRecognizer.ERROR_NETWORK_TIMEOUT -> "Network timeout" + SpeechRecognizer.ERROR_NO_MATCH -> "Listening" + SpeechRecognizer.ERROR_RECOGNIZER_BUSY -> "Recognizer busy" + SpeechRecognizer.ERROR_SERVER -> "Server error" + SpeechRecognizer.ERROR_SPEECH_TIMEOUT -> "Listening" + else -> "Speech error ($error)" + } + scheduleRestart(delayMs = 600) + } + + override fun onResults(results: Bundle?) { + val list = results?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION).orEmpty() + list.firstOrNull()?.let { handleTranscript(it, isFinal = true) } + scheduleRestart() + } + + override fun onPartialResults(partialResults: Bundle?) { + val list = partialResults?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION).orEmpty() + list.firstOrNull()?.let { handleTranscript(it, isFinal = false) } + } + + override fun onEvent(eventType: Int, params: Bundle?) {} + } +} + +private fun JsonElement?.asObjectOrNull(): JsonObject? = this as? JsonObject + +private fun JsonElement?.asStringOrNull(): String? = + (this as? JsonPrimitive)?.takeIf { it.isString }?.content + +private fun JsonElement?.asDoubleOrNull(): Double? { + val primitive = this as? JsonPrimitive ?: return null + return primitive.content.toDoubleOrNull() +} + +private fun JsonElement?.asBooleanOrNull(): Boolean? { + val primitive = this as? JsonPrimitive ?: return null + val content = primitive.content.trim().lowercase() + return when (content) { + "true", "yes", "1" -> true + "false", "no", "0" -> false + else -> null + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/voice/VoiceWakeCommandExtractor.kt b/apps/android/app/src/main/java/bot/molt/android/voice/VoiceWakeCommandExtractor.kt new file mode 100644 index 000000000..8da4e3289 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/voice/VoiceWakeCommandExtractor.kt @@ -0,0 +1,40 @@ +package bot.molt.android.voice + +object VoiceWakeCommandExtractor { + fun extractCommand(text: String, triggerWords: List): String? { + val raw = text.trim() + if (raw.isEmpty()) return null + + val triggers = + triggerWords + .map { it.trim().lowercase() } + .filter { it.isNotEmpty() } + .distinct() + if (triggers.isEmpty()) return null + + val alternation = triggers.joinToString("|") { Regex.escape(it) } + // Match: " " + val regex = Regex("(?i)(?:^|\\s)($alternation)\\b[\\s\\p{Punct}]*([\\s\\S]+)$") + val match = regex.find(raw) ?: return null + val extracted = match.groupValues.getOrNull(2)?.trim().orEmpty() + if (extracted.isEmpty()) return null + + val cleaned = extracted.trimStart { it.isWhitespace() || it.isPunctuation() }.trim() + if (cleaned.isEmpty()) return null + return cleaned + } +} + +private fun Char.isPunctuation(): Boolean { + return when (Character.getType(this)) { + Character.CONNECTOR_PUNCTUATION.toInt(), + Character.DASH_PUNCTUATION.toInt(), + Character.START_PUNCTUATION.toInt(), + Character.END_PUNCTUATION.toInt(), + Character.INITIAL_QUOTE_PUNCTUATION.toInt(), + Character.FINAL_QUOTE_PUNCTUATION.toInt(), + Character.OTHER_PUNCTUATION.toInt(), + -> true + else -> false + } +} diff --git a/apps/android/app/src/main/java/bot/molt/android/voice/VoiceWakeManager.kt b/apps/android/app/src/main/java/bot/molt/android/voice/VoiceWakeManager.kt new file mode 100644 index 000000000..b27d0e3c7 --- /dev/null +++ b/apps/android/app/src/main/java/bot/molt/android/voice/VoiceWakeManager.kt @@ -0,0 +1,173 @@ +package bot.molt.android.voice + +import android.content.Context +import android.content.Intent +import android.os.Bundle +import android.os.Handler +import android.os.Looper +import android.speech.RecognitionListener +import android.speech.RecognizerIntent +import android.speech.SpeechRecognizer +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.launch + +class VoiceWakeManager( + private val context: Context, + private val scope: CoroutineScope, + private val onCommand: suspend (String) -> Unit, +) { + private val mainHandler = Handler(Looper.getMainLooper()) + + private val _isListening = MutableStateFlow(false) + val isListening: StateFlow = _isListening + + private val _statusText = MutableStateFlow("Off") + val statusText: StateFlow = _statusText + + var triggerWords: List = emptyList() + private set + + private var recognizer: SpeechRecognizer? = null + private var restartJob: Job? = null + private var lastDispatched: String? = null + private var stopRequested = false + + fun setTriggerWords(words: List) { + triggerWords = words + } + + fun start() { + mainHandler.post { + if (_isListening.value) return@post + stopRequested = false + + if (!SpeechRecognizer.isRecognitionAvailable(context)) { + _isListening.value = false + _statusText.value = "Speech recognizer unavailable" + return@post + } + + try { + recognizer?.destroy() + recognizer = SpeechRecognizer.createSpeechRecognizer(context).also { it.setRecognitionListener(listener) } + startListeningInternal() + } catch (err: Throwable) { + _isListening.value = false + _statusText.value = "Start failed: ${err.message ?: err::class.simpleName}" + } + } + } + + fun stop(statusText: String = "Off") { + stopRequested = true + restartJob?.cancel() + restartJob = null + mainHandler.post { + _isListening.value = false + _statusText.value = statusText + recognizer?.cancel() + recognizer?.destroy() + recognizer = null + } + } + + private fun startListeningInternal() { + val r = recognizer ?: return + val intent = + Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply { + putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM) + putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true) + putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 3) + putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, context.packageName) + } + + _statusText.value = "Listening" + _isListening.value = true + r.startListening(intent) + } + + private fun scheduleRestart(delayMs: Long = 350) { + if (stopRequested) return + restartJob?.cancel() + restartJob = + scope.launch { + delay(delayMs) + mainHandler.post { + if (stopRequested) return@post + try { + recognizer?.cancel() + startListeningInternal() + } catch (_: Throwable) { + // Will be picked up by onError and retry again. + } + } + } + } + + private fun handleTranscription(text: String) { + val command = VoiceWakeCommandExtractor.extractCommand(text, triggerWords) ?: return + if (command == lastDispatched) return + lastDispatched = command + + scope.launch { onCommand(command) } + _statusText.value = "Triggered" + scheduleRestart(delayMs = 650) + } + + private val listener = + object : RecognitionListener { + override fun onReadyForSpeech(params: Bundle?) { + _statusText.value = "Listening" + } + + override fun onBeginningOfSpeech() {} + + override fun onRmsChanged(rmsdB: Float) {} + + override fun onBufferReceived(buffer: ByteArray?) {} + + override fun onEndOfSpeech() { + scheduleRestart() + } + + override fun onError(error: Int) { + if (stopRequested) return + _isListening.value = false + if (error == SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS) { + _statusText.value = "Microphone permission required" + return + } + + _statusText.value = + when (error) { + SpeechRecognizer.ERROR_AUDIO -> "Audio error" + SpeechRecognizer.ERROR_CLIENT -> "Client error" + SpeechRecognizer.ERROR_NETWORK -> "Network error" + SpeechRecognizer.ERROR_NETWORK_TIMEOUT -> "Network timeout" + SpeechRecognizer.ERROR_NO_MATCH -> "Listening" + SpeechRecognizer.ERROR_RECOGNIZER_BUSY -> "Recognizer busy" + SpeechRecognizer.ERROR_SERVER -> "Server error" + SpeechRecognizer.ERROR_SPEECH_TIMEOUT -> "Listening" + else -> "Speech error ($error)" + } + scheduleRestart(delayMs = 600) + } + + override fun onResults(results: Bundle?) { + val list = results?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION).orEmpty() + list.firstOrNull()?.let(::handleTranscription) + scheduleRestart() + } + + override fun onPartialResults(partialResults: Bundle?) { + val list = partialResults?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION).orEmpty() + list.firstOrNull()?.let(::handleTranscription) + } + + override fun onEvent(eventType: Int, params: Bundle?) {} + } +} diff --git a/apps/android/app/src/test/java/bot/molt/android/NodeForegroundServiceTest.kt b/apps/android/app/src/test/java/bot/molt/android/NodeForegroundServiceTest.kt new file mode 100644 index 000000000..77ab3ae36 --- /dev/null +++ b/apps/android/app/src/test/java/bot/molt/android/NodeForegroundServiceTest.kt @@ -0,0 +1,43 @@ +package bot.molt.android + +import android.app.Notification +import android.content.Intent +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class NodeForegroundServiceTest { + @Test + fun buildNotificationSetsLaunchIntent() { + val service = Robolectric.buildService(NodeForegroundService::class.java).get() + val notification = buildNotification(service) + + val pendingIntent = notification.contentIntent + assertNotNull(pendingIntent) + + val savedIntent = Shadows.shadowOf(pendingIntent).savedIntent + assertNotNull(savedIntent) + assertEquals(MainActivity::class.java.name, savedIntent.component?.className) + + val expectedFlags = Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP + assertEquals(expectedFlags, savedIntent.flags and expectedFlags) + } + + private fun buildNotification(service: NodeForegroundService): Notification { + val method = + NodeForegroundService::class.java.getDeclaredMethod( + "buildNotification", + String::class.java, + String::class.java, + ) + method.isAccessible = true + return method.invoke(service, "Title", "Text") as Notification + } +} diff --git a/apps/android/app/src/test/java/bot/molt/android/WakeWordsTest.kt b/apps/android/app/src/test/java/bot/molt/android/WakeWordsTest.kt new file mode 100644 index 000000000..f18ba187e --- /dev/null +++ b/apps/android/app/src/test/java/bot/molt/android/WakeWordsTest.kt @@ -0,0 +1,50 @@ +package bot.molt.android + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test + +class WakeWordsTest { + @Test + fun parseCommaSeparatedTrimsAndDropsEmpty() { + assertEquals(listOf("clawd", "claude"), WakeWords.parseCommaSeparated(" clawd , claude, , ")) + } + + @Test + fun sanitizeTrimsCapsAndFallsBack() { + val defaults = listOf("clawd", "claude") + val long = "x".repeat(WakeWords.maxWordLength + 10) + val words = listOf(" ", " hello ", long) + + val sanitized = WakeWords.sanitize(words, defaults) + assertEquals(2, sanitized.size) + assertEquals("hello", sanitized[0]) + assertEquals("x".repeat(WakeWords.maxWordLength), sanitized[1]) + + assertEquals(defaults, WakeWords.sanitize(listOf(" ", ""), defaults)) + } + + @Test + fun sanitizeLimitsWordCount() { + val defaults = listOf("clawd") + val words = (1..(WakeWords.maxWords + 5)).map { "w$it" } + val sanitized = WakeWords.sanitize(words, defaults) + assertEquals(WakeWords.maxWords, sanitized.size) + assertEquals("w1", sanitized.first()) + assertEquals("w${WakeWords.maxWords}", sanitized.last()) + } + + @Test + fun parseIfChangedSkipsWhenUnchanged() { + val current = listOf("clawd", "claude") + val parsed = WakeWords.parseIfChanged(" clawd , claude ", current) + assertNull(parsed) + } + + @Test + fun parseIfChangedReturnsUpdatedList() { + val current = listOf("clawd") + val parsed = WakeWords.parseIfChanged(" clawd , jarvis ", current) + assertEquals(listOf("clawd", "jarvis"), parsed) + } +} diff --git a/apps/android/app/src/test/java/bot/molt/android/gateway/BonjourEscapesTest.kt b/apps/android/app/src/test/java/bot/molt/android/gateway/BonjourEscapesTest.kt new file mode 100644 index 000000000..026d35a8a --- /dev/null +++ b/apps/android/app/src/test/java/bot/molt/android/gateway/BonjourEscapesTest.kt @@ -0,0 +1,19 @@ +package bot.molt.android.gateway + +import org.junit.Assert.assertEquals +import org.junit.Test + +class BonjourEscapesTest { + @Test + fun decodeNoop() { + assertEquals("", BonjourEscapes.decode("")) + assertEquals("hello", BonjourEscapes.decode("hello")) + } + + @Test + fun decodeDecodesDecimalEscapes() { + assertEquals("Moltbot Gateway", BonjourEscapes.decode("Moltbot\\032Gateway")) + assertEquals("A B", BonjourEscapes.decode("A\\032B")) + assertEquals("Peter\u2019s Mac", BonjourEscapes.decode("Peter\\226\\128\\153s Mac")) + } +} diff --git a/apps/android/app/src/test/java/bot/molt/android/node/CanvasControllerSnapshotParamsTest.kt b/apps/android/app/src/test/java/bot/molt/android/node/CanvasControllerSnapshotParamsTest.kt new file mode 100644 index 000000000..c9803c56f --- /dev/null +++ b/apps/android/app/src/test/java/bot/molt/android/node/CanvasControllerSnapshotParamsTest.kt @@ -0,0 +1,43 @@ +package bot.molt.android.node + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test + +class CanvasControllerSnapshotParamsTest { + @Test + fun parseSnapshotParamsDefaultsToJpeg() { + val params = CanvasController.parseSnapshotParams(null) + assertEquals(CanvasController.SnapshotFormat.Jpeg, params.format) + assertNull(params.quality) + assertNull(params.maxWidth) + } + + @Test + fun parseSnapshotParamsParsesPng() { + val params = CanvasController.parseSnapshotParams("""{"format":"png","maxWidth":900}""") + assertEquals(CanvasController.SnapshotFormat.Png, params.format) + assertEquals(900, params.maxWidth) + } + + @Test + fun parseSnapshotParamsParsesJpegAliases() { + assertEquals( + CanvasController.SnapshotFormat.Jpeg, + CanvasController.parseSnapshotParams("""{"format":"jpeg"}""").format, + ) + assertEquals( + CanvasController.SnapshotFormat.Jpeg, + CanvasController.parseSnapshotParams("""{"format":"jpg"}""").format, + ) + } + + @Test + fun parseSnapshotParamsClampsQuality() { + val low = CanvasController.parseSnapshotParams("""{"quality":0.01}""") + assertEquals(0.1, low.quality) + + val high = CanvasController.parseSnapshotParams("""{"quality":5}""") + assertEquals(1.0, high.quality) + } +} diff --git a/apps/android/app/src/test/java/bot/molt/android/node/JpegSizeLimiterTest.kt b/apps/android/app/src/test/java/bot/molt/android/node/JpegSizeLimiterTest.kt new file mode 100644 index 000000000..8f114b3ec --- /dev/null +++ b/apps/android/app/src/test/java/bot/molt/android/node/JpegSizeLimiterTest.kt @@ -0,0 +1,47 @@ +package bot.molt.android.node + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test +import kotlin.math.min + +class JpegSizeLimiterTest { + @Test + fun compressesLargePayloadsUnderLimit() { + val maxBytes = 5 * 1024 * 1024 + val result = + JpegSizeLimiter.compressToLimit( + initialWidth = 4000, + initialHeight = 3000, + startQuality = 95, + maxBytes = maxBytes, + encode = { width, height, quality -> + val estimated = (width.toLong() * height.toLong() * quality.toLong()) / 100 + val size = min(maxBytes.toLong() * 2, estimated).toInt() + ByteArray(size) + }, + ) + + assertTrue(result.bytes.size <= maxBytes) + assertTrue(result.width <= 4000) + assertTrue(result.height <= 3000) + assertTrue(result.quality <= 95) + } + + @Test + fun keepsSmallPayloadsAsIs() { + val maxBytes = 5 * 1024 * 1024 + val result = + JpegSizeLimiter.compressToLimit( + initialWidth = 800, + initialHeight = 600, + startQuality = 90, + maxBytes = maxBytes, + encode = { _, _, _ -> ByteArray(120_000) }, + ) + + assertEquals(800, result.width) + assertEquals(600, result.height) + assertEquals(90, result.quality) + } +} diff --git a/apps/android/app/src/test/java/bot/molt/android/node/SmsManagerTest.kt b/apps/android/app/src/test/java/bot/molt/android/node/SmsManagerTest.kt new file mode 100644 index 000000000..d09bbc6bb --- /dev/null +++ b/apps/android/app/src/test/java/bot/molt/android/node/SmsManagerTest.kt @@ -0,0 +1,91 @@ +package bot.molt.android.node + +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.json.jsonPrimitive +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class SmsManagerTest { + private val json = SmsManager.JsonConfig + + @Test + fun parseParamsRejectsEmptyPayload() { + val result = SmsManager.parseParams("", json) + assertTrue(result is SmsManager.ParseResult.Error) + val error = result as SmsManager.ParseResult.Error + assertEquals("INVALID_REQUEST: paramsJSON required", error.error) + } + + @Test + fun parseParamsRejectsInvalidJson() { + val result = SmsManager.parseParams("not-json", json) + assertTrue(result is SmsManager.ParseResult.Error) + val error = result as SmsManager.ParseResult.Error + assertEquals("INVALID_REQUEST: expected JSON object", error.error) + } + + @Test + fun parseParamsRejectsNonObjectJson() { + val result = SmsManager.parseParams("[]", json) + assertTrue(result is SmsManager.ParseResult.Error) + val error = result as SmsManager.ParseResult.Error + assertEquals("INVALID_REQUEST: expected JSON object", error.error) + } + + @Test + fun parseParamsRejectsMissingTo() { + val result = SmsManager.parseParams("{\"message\":\"Hi\"}", json) + assertTrue(result is SmsManager.ParseResult.Error) + val error = result as SmsManager.ParseResult.Error + assertEquals("INVALID_REQUEST: 'to' phone number required", error.error) + assertEquals("Hi", error.message) + } + + @Test + fun parseParamsRejectsMissingMessage() { + val result = SmsManager.parseParams("{\"to\":\"+1234\"}", json) + assertTrue(result is SmsManager.ParseResult.Error) + val error = result as SmsManager.ParseResult.Error + assertEquals("INVALID_REQUEST: 'message' text required", error.error) + assertEquals("+1234", error.to) + } + + @Test + fun parseParamsTrimsToField() { + val result = SmsManager.parseParams("{\"to\":\" +1555 \",\"message\":\"Hello\"}", json) + assertTrue(result is SmsManager.ParseResult.Ok) + val ok = result as SmsManager.ParseResult.Ok + assertEquals("+1555", ok.params.to) + assertEquals("Hello", ok.params.message) + } + + @Test + fun buildPayloadJsonEscapesFields() { + val payload = SmsManager.buildPayloadJson( + json = json, + ok = false, + to = "+1\"23", + error = "SMS_SEND_FAILED: \"nope\"", + ) + val parsed = json.parseToJsonElement(payload).jsonObject + assertEquals("false", parsed["ok"]?.jsonPrimitive?.content) + assertEquals("+1\"23", parsed["to"]?.jsonPrimitive?.content) + assertEquals("SMS_SEND_FAILED: \"nope\"", parsed["error"]?.jsonPrimitive?.content) + } + + @Test + fun buildSendPlanUsesMultipartWhenMultipleParts() { + val plan = SmsManager.buildSendPlan("hello") { listOf("a", "b") } + assertTrue(plan.useMultipart) + assertEquals(listOf("a", "b"), plan.parts) + } + + @Test + fun buildSendPlanFallsBackToSinglePartWhenDividerEmpty() { + val plan = SmsManager.buildSendPlan("hello") { emptyList() } + assertFalse(plan.useMultipart) + assertEquals(listOf("hello"), plan.parts) + } +} diff --git a/apps/android/app/src/test/java/bot/molt/android/protocol/ClawdbotCanvasA2UIActionTest.kt b/apps/android/app/src/test/java/bot/molt/android/protocol/ClawdbotCanvasA2UIActionTest.kt new file mode 100644 index 000000000..5ed5e505f --- /dev/null +++ b/apps/android/app/src/test/java/bot/molt/android/protocol/ClawdbotCanvasA2UIActionTest.kt @@ -0,0 +1,49 @@ +package bot.molt.android.protocol + +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.jsonObject +import org.junit.Assert.assertEquals +import org.junit.Test + +class MoltbotCanvasA2UIActionTest { + @Test + fun extractActionNameAcceptsNameOrAction() { + val nameObj = Json.parseToJsonElement("{\"name\":\"Hello\"}").jsonObject + assertEquals("Hello", MoltbotCanvasA2UIAction.extractActionName(nameObj)) + + val actionObj = Json.parseToJsonElement("{\"action\":\"Wave\"}").jsonObject + assertEquals("Wave", MoltbotCanvasA2UIAction.extractActionName(actionObj)) + + val fallbackObj = + Json.parseToJsonElement("{\"name\":\" \",\"action\":\"Fallback\"}").jsonObject + assertEquals("Fallback", MoltbotCanvasA2UIAction.extractActionName(fallbackObj)) + } + + @Test + fun formatAgentMessageMatchesSharedSpec() { + val msg = + MoltbotCanvasA2UIAction.formatAgentMessage( + actionName = "Get Weather", + sessionKey = "main", + surfaceId = "main", + sourceComponentId = "btnWeather", + host = "Peter’s iPad", + instanceId = "ipad16,6", + contextJson = "{\"city\":\"Vienna\"}", + ) + + assertEquals( + "CANVAS_A2UI action=Get_Weather session=main surface=main component=btnWeather host=Peter_s_iPad instance=ipad16_6 ctx={\"city\":\"Vienna\"} default=update_canvas", + msg, + ) + } + + @Test + fun jsDispatchA2uiStatusIsStable() { + val js = MoltbotCanvasA2UIAction.jsDispatchA2UIActionStatus(actionId = "a1", ok = true, error = null) + assertEquals( + "window.dispatchEvent(new CustomEvent('moltbot:a2ui-action-status', { detail: { id: \"a1\", ok: true, error: \"\" } }));", + js, + ) + } +} diff --git a/apps/android/app/src/test/java/bot/molt/android/protocol/ClawdbotProtocolConstantsTest.kt b/apps/android/app/src/test/java/bot/molt/android/protocol/ClawdbotProtocolConstantsTest.kt new file mode 100644 index 000000000..998f6600c --- /dev/null +++ b/apps/android/app/src/test/java/bot/molt/android/protocol/ClawdbotProtocolConstantsTest.kt @@ -0,0 +1,35 @@ +package bot.molt.android.protocol + +import org.junit.Assert.assertEquals +import org.junit.Test + +class MoltbotProtocolConstantsTest { + @Test + fun canvasCommandsUseStableStrings() { + assertEquals("canvas.present", MoltbotCanvasCommand.Present.rawValue) + assertEquals("canvas.hide", MoltbotCanvasCommand.Hide.rawValue) + assertEquals("canvas.navigate", MoltbotCanvasCommand.Navigate.rawValue) + assertEquals("canvas.eval", MoltbotCanvasCommand.Eval.rawValue) + assertEquals("canvas.snapshot", MoltbotCanvasCommand.Snapshot.rawValue) + } + + @Test + fun a2uiCommandsUseStableStrings() { + assertEquals("canvas.a2ui.push", MoltbotCanvasA2UICommand.Push.rawValue) + assertEquals("canvas.a2ui.pushJSONL", MoltbotCanvasA2UICommand.PushJSONL.rawValue) + assertEquals("canvas.a2ui.reset", MoltbotCanvasA2UICommand.Reset.rawValue) + } + + @Test + fun capabilitiesUseStableStrings() { + assertEquals("canvas", MoltbotCapability.Canvas.rawValue) + assertEquals("camera", MoltbotCapability.Camera.rawValue) + assertEquals("screen", MoltbotCapability.Screen.rawValue) + assertEquals("voiceWake", MoltbotCapability.VoiceWake.rawValue) + } + + @Test + fun screenCommandsUseStableStrings() { + assertEquals("screen.record", MoltbotScreenCommand.Record.rawValue) + } +} diff --git a/apps/android/app/src/test/java/bot/molt/android/ui/chat/SessionFiltersTest.kt b/apps/android/app/src/test/java/bot/molt/android/ui/chat/SessionFiltersTest.kt new file mode 100644 index 000000000..e410cc365 --- /dev/null +++ b/apps/android/app/src/test/java/bot/molt/android/ui/chat/SessionFiltersTest.kt @@ -0,0 +1,35 @@ +package bot.molt.android.ui.chat + +import bot.molt.android.chat.ChatSessionEntry +import org.junit.Assert.assertEquals +import org.junit.Test + +class SessionFiltersTest { + @Test + fun sessionChoicesPreferMainAndRecent() { + val now = 1_700_000_000_000L + val recent1 = now - 2 * 60 * 60 * 1000L + val recent2 = now - 5 * 60 * 60 * 1000L + val stale = now - 26 * 60 * 60 * 1000L + val sessions = + listOf( + ChatSessionEntry(key = "recent-1", updatedAtMs = recent1), + ChatSessionEntry(key = "main", updatedAtMs = stale), + ChatSessionEntry(key = "old-1", updatedAtMs = stale), + ChatSessionEntry(key = "recent-2", updatedAtMs = recent2), + ) + + val result = resolveSessionChoices("main", sessions, mainSessionKey = "main", nowMs = now).map { it.key } + assertEquals(listOf("main", "recent-1", "recent-2"), result) + } + + @Test + fun sessionChoicesIncludeCurrentWhenMissing() { + val now = 1_700_000_000_000L + val recent = now - 10 * 60 * 1000L + val sessions = listOf(ChatSessionEntry(key = "main", updatedAtMs = recent)) + + val result = resolveSessionChoices("custom", sessions, mainSessionKey = "main", nowMs = now).map { it.key } + assertEquals(listOf("main", "custom"), result) + } +} diff --git a/apps/android/app/src/test/java/bot/molt/android/voice/TalkDirectiveParserTest.kt b/apps/android/app/src/test/java/bot/molt/android/voice/TalkDirectiveParserTest.kt new file mode 100644 index 000000000..8f57a9aca --- /dev/null +++ b/apps/android/app/src/test/java/bot/molt/android/voice/TalkDirectiveParserTest.kt @@ -0,0 +1,55 @@ +package bot.molt.android.voice + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class TalkDirectiveParserTest { + @Test + fun parsesDirectiveAndStripsHeader() { + val input = """ + {"voice":"voice-123","once":true} + Hello from talk mode. + """.trimIndent() + val result = TalkDirectiveParser.parse(input) + assertEquals("voice-123", result.directive?.voiceId) + assertEquals(true, result.directive?.once) + assertEquals("Hello from talk mode.", result.stripped.trim()) + } + + @Test + fun ignoresUnknownKeysButReportsThem() { + val input = """ + {"voice":"abc","foo":1,"bar":"baz"} + Hi there. + """.trimIndent() + val result = TalkDirectiveParser.parse(input) + assertEquals("abc", result.directive?.voiceId) + assertTrue(result.unknownKeys.containsAll(listOf("bar", "foo"))) + } + + @Test + fun parsesAlternateKeys() { + val input = """ + {"model_id":"eleven_v3","similarity_boost":0.4,"no_speaker_boost":true,"rate":200} + Speak. + """.trimIndent() + val result = TalkDirectiveParser.parse(input) + assertEquals("eleven_v3", result.directive?.modelId) + assertEquals(0.4, result.directive?.similarity) + assertEquals(false, result.directive?.speakerBoost) + assertEquals(200, result.directive?.rateWpm) + } + + @Test + fun returnsNullWhenNoDirectivePresent() { + val input = """ + {} + Hello. + """.trimIndent() + val result = TalkDirectiveParser.parse(input) + assertNull(result.directive) + assertEquals(input, result.stripped) + } +} diff --git a/apps/android/app/src/test/java/bot/molt/android/voice/VoiceWakeCommandExtractorTest.kt b/apps/android/app/src/test/java/bot/molt/android/voice/VoiceWakeCommandExtractorTest.kt new file mode 100644 index 000000000..3460ba7a8 --- /dev/null +++ b/apps/android/app/src/test/java/bot/molt/android/voice/VoiceWakeCommandExtractorTest.kt @@ -0,0 +1,25 @@ +package bot.molt.android.voice + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test + +class VoiceWakeCommandExtractorTest { + @Test + fun extractsCommandAfterTriggerWord() { + val res = VoiceWakeCommandExtractor.extractCommand("Claude take a photo", listOf("clawd", "claude")) + assertEquals("take a photo", res) + } + + @Test + fun extractsCommandWithPunctuation() { + val res = VoiceWakeCommandExtractor.extractCommand("hey clawd, what's the weather?", listOf("clawd")) + assertEquals("what's the weather?", res) + } + + @Test + fun returnsNullWhenNoCommandProvided() { + assertNull(VoiceWakeCommandExtractor.extractCommand("claude", listOf("claude"))) + assertNull(VoiceWakeCommandExtractor.extractCommand("hey claude!", listOf("claude"))) + } +} diff --git a/apps/ios/Sources/Gateway/GatewayDiscoveryModel.swift b/apps/ios/Sources/Gateway/GatewayDiscoveryModel.swift index aaba5a863..19be913f4 100644 --- a/apps/ios/Sources/Gateway/GatewayDiscoveryModel.swift +++ b/apps/ios/Sources/Gateway/GatewayDiscoveryModel.swift @@ -104,7 +104,7 @@ final class GatewayDiscoveryModel { } self.browsers[domain] = browser - browser.start(queue: DispatchQueue(label: "com.clawdbot.ios.gateway-discovery.\(domain)")) + browser.start(queue: DispatchQueue(label: "bot.molt.ios.gateway-discovery.\(domain)")) } } diff --git a/apps/ios/Sources/Gateway/GatewaySettingsStore.swift b/apps/ios/Sources/Gateway/GatewaySettingsStore.swift index 52ada8d80..1c78b7869 100644 --- a/apps/ios/Sources/Gateway/GatewaySettingsStore.swift +++ b/apps/ios/Sources/Gateway/GatewaySettingsStore.swift @@ -1,9 +1,11 @@ import Foundation enum GatewaySettingsStore { - private static let gatewayService = "com.clawdbot.gateway" + private static let gatewayService = "bot.molt.gateway" + private static let legacyGatewayService = "com.clawdbot.gateway" private static let legacyBridgeService = "com.clawdbot.bridge" - private static let nodeService = "com.clawdbot.node" + private static let nodeService = "bot.molt.node" + private static let legacyNodeService = "com.clawdbot.node" private static let instanceIdDefaultsKey = "node.instanceId" private static let preferredGatewayStableIDDefaultsKey = "gateway.preferredStableID" @@ -33,8 +35,22 @@ enum GatewaySettingsStore { } static func loadStableInstanceID() -> String? { - KeychainStore.loadString(service: self.nodeService, account: self.instanceIdAccount)? - .trimmingCharacters(in: .whitespacesAndNewlines) + if let value = KeychainStore.loadString(service: self.nodeService, account: self.instanceIdAccount)? + .trimmingCharacters(in: .whitespacesAndNewlines), + !value.isEmpty + { + return value + } + + if let legacy = KeychainStore.loadString(service: self.legacyNodeService, account: self.instanceIdAccount)? + .trimmingCharacters(in: .whitespacesAndNewlines), + !legacy.isEmpty + { + _ = KeychainStore.saveString(legacy, service: self.nodeService, account: self.instanceIdAccount) + return legacy + } + + return nil } static func saveStableInstanceID(_ instanceId: String) { @@ -42,8 +58,29 @@ enum GatewaySettingsStore { } static func loadPreferredGatewayStableID() -> String? { - KeychainStore.loadString(service: self.gatewayService, account: self.preferredGatewayStableIDAccount)? - .trimmingCharacters(in: .whitespacesAndNewlines) + if let value = KeychainStore.loadString( + service: self.gatewayService, + account: self.preferredGatewayStableIDAccount + )?.trimmingCharacters(in: .whitespacesAndNewlines), + !value.isEmpty + { + return value + } + + if let legacy = KeychainStore.loadString( + service: self.legacyGatewayService, + account: self.preferredGatewayStableIDAccount + )?.trimmingCharacters(in: .whitespacesAndNewlines), + !legacy.isEmpty + { + _ = KeychainStore.saveString( + legacy, + service: self.gatewayService, + account: self.preferredGatewayStableIDAccount) + return legacy + } + + return nil } static func savePreferredGatewayStableID(_ stableID: String) { @@ -54,8 +91,29 @@ enum GatewaySettingsStore { } static func loadLastDiscoveredGatewayStableID() -> String? { - KeychainStore.loadString(service: self.gatewayService, account: self.lastDiscoveredGatewayStableIDAccount)? - .trimmingCharacters(in: .whitespacesAndNewlines) + if let value = KeychainStore.loadString( + service: self.gatewayService, + account: self.lastDiscoveredGatewayStableIDAccount + )?.trimmingCharacters(in: .whitespacesAndNewlines), + !value.isEmpty + { + return value + } + + if let legacy = KeychainStore.loadString( + service: self.legacyGatewayService, + account: self.lastDiscoveredGatewayStableIDAccount + )?.trimmingCharacters(in: .whitespacesAndNewlines), + !legacy.isEmpty + { + _ = KeychainStore.saveString( + legacy, + service: self.gatewayService, + account: self.lastDiscoveredGatewayStableIDAccount) + return legacy + } + + return nil } static func saveLastDiscoveredGatewayStableID(_ stableID: String) { diff --git a/apps/ios/Sources/Screen/ScreenRecordService.swift b/apps/ios/Sources/Screen/ScreenRecordService.swift index 9011487ba..849add38d 100644 --- a/apps/ios/Sources/Screen/ScreenRecordService.swift +++ b/apps/ios/Sources/Screen/ScreenRecordService.swift @@ -55,7 +55,7 @@ final class ScreenRecordService: @unchecked Sendable { outPath: outPath) let state = CaptureState() - let recordQueue = DispatchQueue(label: "com.clawdbot.screenrecord") + let recordQueue = DispatchQueue(label: "bot.molt.screenrecord") try await self.startCapture(state: state, config: config, recordQueue: recordQueue) try await Task.sleep(nanoseconds: UInt64(config.durationMs) * 1_000_000) diff --git a/apps/ios/Sources/Voice/TalkModeManager.swift b/apps/ios/Sources/Voice/TalkModeManager.swift index 0a3872424..c0ae8b454 100644 --- a/apps/ios/Sources/Voice/TalkModeManager.swift +++ b/apps/ios/Sources/Voice/TalkModeManager.swift @@ -48,7 +48,7 @@ final class TalkModeManager: NSObject { private var chatSubscribedSessionKeys = Set() - private let logger = Logger(subsystem: "com.clawdbot", category: "TalkMode") + private let logger = Logger(subsystem: "bot.molt", category: "TalkMode") func attachGateway(_ gateway: GatewayNodeSession) { self.gateway = gateway diff --git a/apps/ios/Tests/GatewaySettingsStoreTests.swift b/apps/ios/Tests/GatewaySettingsStoreTests.swift index 2f4df7964..746bf8fdf 100644 --- a/apps/ios/Tests/GatewaySettingsStoreTests.swift +++ b/apps/ios/Tests/GatewaySettingsStoreTests.swift @@ -7,8 +7,8 @@ private struct KeychainEntry: Hashable { let account: String } -private let gatewayService = "com.clawdbot.gateway" -private let nodeService = "com.clawdbot.node" +private let gatewayService = "bot.molt.gateway" +private let nodeService = "bot.molt.node" private let instanceIdEntry = KeychainEntry(service: nodeService, account: "instanceId") private let preferredGatewayEntry = KeychainEntry(service: gatewayService, account: "preferredStableID") private let lastGatewayEntry = KeychainEntry(service: gatewayService, account: "lastDiscoveredStableID") diff --git a/apps/ios/Tests/KeychainStoreTests.swift b/apps/ios/Tests/KeychainStoreTests.swift index 798137b7e..8aa5ae071 100644 --- a/apps/ios/Tests/KeychainStoreTests.swift +++ b/apps/ios/Tests/KeychainStoreTests.swift @@ -4,7 +4,7 @@ import Testing @Suite struct KeychainStoreTests { @Test func saveLoadUpdateDeleteRoundTrip() { - let service = "com.clawdbot.tests.\(UUID().uuidString)" + let service = "bot.molt.tests.\(UUID().uuidString)" let account = "value" #expect(KeychainStore.delete(service: service, account: account)) diff --git a/apps/ios/fastlane/Appfile b/apps/ios/fastlane/Appfile index 7942da625..adaa3fc29 100644 --- a/apps/ios/fastlane/Appfile +++ b/apps/ios/fastlane/Appfile @@ -1,4 +1,4 @@ -app_identifier("com.clawdbot.ios") +app_identifier("bot.molt.ios") # Auth is expected via App Store Connect API key. # Provide either: diff --git a/apps/ios/project.yml b/apps/ios/project.yml index cdd16d4d1..a7305c26c 100644 --- a/apps/ios/project.yml +++ b/apps/ios/project.yml @@ -1,6 +1,6 @@ name: Moltbot options: - bundleIdPrefix: com.clawdbot + bundleIdPrefix: bot.molt deploymentTarget: iOS: "18.0" xcodeVersion: "16.0" @@ -71,8 +71,8 @@ targets: CODE_SIGN_IDENTITY: "Apple Development" CODE_SIGN_STYLE: Manual DEVELOPMENT_TEAM: Y5PE65HELJ - PRODUCT_BUNDLE_IDENTIFIER: com.clawdbot.ios - PROVISIONING_PROFILE_SPECIFIER: "com.clawdbot.ios Development" + PRODUCT_BUNDLE_IDENTIFIER: bot.molt.ios + PROVISIONING_PROFILE_SPECIFIER: "bot.molt.ios Development" SWIFT_VERSION: "6.0" SWIFT_STRICT_CONCURRENCY: complete ENABLE_APPINTENTS_METADATA: NO @@ -121,7 +121,7 @@ targets: - sdk: AppIntents.framework settings: base: - PRODUCT_BUNDLE_IDENTIFIER: com.clawdbot.ios.tests + PRODUCT_BUNDLE_IDENTIFIER: bot.molt.ios.tests SWIFT_VERSION: "6.0" SWIFT_STRICT_CONCURRENCY: complete TEST_HOST: "$(BUILT_PRODUCTS_DIR)/Moltbot.app/Moltbot" diff --git a/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatViewModel.swift b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatViewModel.swift index a3eff72f5..6ef6c71b6 100644 --- a/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatViewModel.swift +++ b/apps/shared/MoltbotKit/Sources/MoltbotChatUI/ChatViewModel.swift @@ -10,7 +10,7 @@ import AppKit import UIKit #endif -private let chatUILogger = Logger(subsystem: "com.clawdbot", category: "MoltbotChatUI") +private let chatUILogger = Logger(subsystem: "bot.molt", category: "MoltbotChatUI") @MainActor @Observable diff --git a/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayChannel.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayChannel.swift index c1562b2d9..0ead3021c 100644 --- a/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayChannel.swift +++ b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayChannel.swift @@ -109,7 +109,7 @@ private enum ConnectChallengeError: Error { } public actor GatewayChannelActor { - private let logger = Logger(subsystem: "com.clawdbot", category: "gateway") + private let logger = Logger(subsystem: "bot.molt", category: "gateway") private var task: WebSocketTaskBox? private var pending: [String: CheckedContinuation] = [:] private var connected = false diff --git a/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayNodeSession.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayNodeSession.swift index daf4397d1..570342ce4 100644 --- a/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayNodeSession.swift +++ b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayNodeSession.swift @@ -12,7 +12,7 @@ private struct NodeInvokeRequestPayload: Codable, Sendable { } public actor GatewayNodeSession { - private let logger = Logger(subsystem: "com.clawdbot", category: "node.gateway") + private let logger = Logger(subsystem: "bot.molt", category: "node.gateway") private let decoder = JSONDecoder() private let encoder = JSONEncoder() private var channel: GatewayChannelActor? diff --git a/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayTLSPinning.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayTLSPinning.swift index f22505eff..4ce98603f 100644 --- a/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayTLSPinning.swift +++ b/apps/shared/MoltbotKit/Sources/MoltbotKit/GatewayTLSPinning.swift @@ -17,17 +17,30 @@ public struct GatewayTLSParams: Sendable { } public enum GatewayTLSStore { - private static let suiteName = "com.clawdbot.shared" + private static let suiteName = "bot.molt.shared" + private static let legacySuiteName = "com.clawdbot.shared" private static let keyPrefix = "gateway.tls." private static var defaults: UserDefaults { UserDefaults(suiteName: suiteName) ?? .standard } + private static var legacyDefaults: UserDefaults? { + UserDefaults(suiteName: legacySuiteName) + } + public static func loadFingerprint(stableID: String) -> String? { let key = self.keyPrefix + stableID let raw = self.defaults.string(forKey: key)?.trimmingCharacters(in: .whitespacesAndNewlines) - return raw?.isEmpty == false ? raw : nil + if raw?.isEmpty == false { return raw } + + let legacy = self.legacyDefaults?.string(forKey: key)?.trimmingCharacters(in: .whitespacesAndNewlines) + if legacy?.isEmpty == false { + self.defaults.set(legacy, forKey: key) + return legacy + } + + return nil } public static func saveFingerprint(_ value: String, stableID: String) { diff --git a/apps/shared/MoltbotKit/Sources/MoltbotKit/InstanceIdentity.swift b/apps/shared/MoltbotKit/Sources/MoltbotKit/InstanceIdentity.swift index e1a52ff39..cbc824329 100644 --- a/apps/shared/MoltbotKit/Sources/MoltbotKit/InstanceIdentity.swift +++ b/apps/shared/MoltbotKit/Sources/MoltbotKit/InstanceIdentity.swift @@ -5,13 +5,18 @@ import UIKit #endif public enum InstanceIdentity { - private static let suiteName = "com.clawdbot.shared" + private static let suiteName = "bot.molt.shared" + private static let legacySuiteName = "com.clawdbot.shared" private static let instanceIdKey = "instanceId" private static var defaults: UserDefaults { UserDefaults(suiteName: suiteName) ?? .standard } + private static var legacyDefaults: UserDefaults? { + UserDefaults(suiteName: legacySuiteName) + } + #if canImport(UIKit) private static func readMainActor(_ body: @MainActor () -> T) -> T { if Thread.isMainThread { @@ -32,6 +37,14 @@ public enum InstanceIdentity { return existing } + if let legacy = Self.legacyDefaults?.string(forKey: instanceIdKey)? + .trimmingCharacters(in: .whitespacesAndNewlines), + !legacy.isEmpty + { + defaults.set(legacy, forKey: instanceIdKey) + return legacy + } + let id = UUID().uuidString.lowercased() defaults.set(id, forKey: instanceIdKey) return id diff --git a/docs/gateway/index.md b/docs/gateway/index.md index 65ef3d61d..8c5be0fa8 100644 --- a/docs/gateway/index.md +++ b/docs/gateway/index.md @@ -56,7 +56,7 @@ Usually unnecessary: one Gateway can serve multiple messaging channels and agent Supported if you isolate state + config and use unique ports. Full guide: [Multiple gateways](/gateway/multiple-gateways). Service names are profile-aware: -- macOS: `com.clawdbot.` +- macOS: `bot.molt.` (legacy `com.clawdbot.*` may still exist) - Linux: `moltbot-gateway-.service` - Windows: `Moltbot Gateway ()` @@ -181,8 +181,8 @@ See also: [Presence](/concepts/presence) for how presence is produced/deduped an - StandardOut/Err: file paths or `syslog` - On failure, launchd restarts; fatal misconfig should keep exiting so the operator notices. - LaunchAgents are per-user and require a logged-in session; for headless setups use a custom LaunchDaemon (not shipped). - - `moltbot gateway install` writes `~/Library/LaunchAgents/com.clawdbot.gateway.plist` - (or `com.clawdbot..plist`). + - `moltbot gateway install` writes `~/Library/LaunchAgents/bot.molt.gateway.plist` + (or `bot.molt..plist`; legacy `com.clawdbot.*` is cleaned up). - `moltbot doctor` audits the LaunchAgent config and can update it to current defaults. ## Gateway service management (CLI) @@ -213,11 +213,11 @@ Notes: Bundled mac app: - Moltbot.app can bundle a Node-based gateway relay and install a per-user LaunchAgent labeled - `com.clawdbot.gateway` (or `com.clawdbot.`). -- To stop it cleanly, use `moltbot gateway stop` (or `launchctl bootout gui/$UID/com.clawdbot.gateway`). -- To restart, use `moltbot gateway restart` (or `launchctl kickstart -k gui/$UID/com.clawdbot.gateway`). + `bot.molt.gateway` (or `bot.molt.`; legacy `com.clawdbot.*` labels still unload cleanly). +- To stop it cleanly, use `moltbot gateway stop` (or `launchctl bootout gui/$UID/bot.molt.gateway`). +- To restart, use `moltbot gateway restart` (or `launchctl kickstart -k gui/$UID/bot.molt.gateway`). - `launchctl` only works if the LaunchAgent is installed; otherwise use `moltbot gateway install` first. - - Replace the label with `com.clawdbot.` when running a named profile. + - Replace the label with `bot.molt.` when running a named profile. ## Supervision (systemd user unit) Moltbot installs a **systemd user service** by default on Linux/WSL2. We diff --git a/docs/gateway/remote-gateway-readme.md b/docs/gateway/remote-gateway-readme.md index f0923ba7c..b48a746d7 100644 --- a/docs/gateway/remote-gateway-readme.md +++ b/docs/gateway/remote-gateway-readme.md @@ -82,7 +82,7 @@ To have the SSH tunnel start automatically when you log in, create a Launch Agen ### Create the PLIST file -Save this as `~/Library/LaunchAgents/com.clawdbot.ssh-tunnel.plist`: +Save this as `~/Library/LaunchAgents/bot.molt.ssh-tunnel.plist`: ```xml @@ -90,7 +90,7 @@ Save this as `~/Library/LaunchAgents/com.clawdbot.ssh-tunnel.plist`: Label - com.clawdbot.ssh-tunnel + bot.molt.ssh-tunnel ProgramArguments /usr/bin/ssh @@ -108,7 +108,7 @@ Save this as `~/Library/LaunchAgents/com.clawdbot.ssh-tunnel.plist`: ### Load the Launch Agent ```bash -launchctl bootstrap gui/$UID ~/Library/LaunchAgents/com.clawdbot.ssh-tunnel.plist +launchctl bootstrap gui/$UID ~/Library/LaunchAgents/bot.molt.ssh-tunnel.plist ``` The tunnel will now: @@ -116,6 +116,8 @@ The tunnel will now: - Restart if it crashes - Keep running in the background +Legacy note: remove any leftover `com.clawdbot.ssh-tunnel` LaunchAgent if present. + --- ## Troubleshooting @@ -130,13 +132,13 @@ lsof -i :18789 **Restart the tunnel:** ```bash -launchctl kickstart -k gui/$UID/com.clawdbot.ssh-tunnel +launchctl kickstart -k gui/$UID/bot.molt.ssh-tunnel ``` **Stop the tunnel:** ```bash -launchctl bootout gui/$UID/com.clawdbot.ssh-tunnel +launchctl bootout gui/$UID/bot.molt.ssh-tunnel ``` --- diff --git a/docs/gateway/troubleshooting.md b/docs/gateway/troubleshooting.md index 48c14318f..a4b0b151d 100644 --- a/docs/gateway/troubleshooting.md +++ b/docs/gateway/troubleshooting.md @@ -576,7 +576,7 @@ If the app disappears or shows "Abort trap 6" when you click "Allow" on a privac **Fix 1: Reset TCC Cache** ```bash -tccutil reset All com.clawdbot.mac.debug +tccutil reset All bot.molt.mac.debug ``` **Fix 2: Force New Bundle ID** @@ -591,7 +591,7 @@ If the gateway is supervised by launchd, killing the PID will just respawn it. S ```bash moltbot gateway status moltbot gateway stop -# Or: launchctl bootout gui/$UID/com.clawdbot.gateway (replace with com.clawdbot. if needed) +# Or: launchctl bootout gui/$UID/bot.molt.gateway (replace with bot.molt.; legacy com.clawdbot.* still works) ``` **Fix 2: Port is busy (find the listener)** diff --git a/docs/help/faq.md b/docs/help/faq.md index 0766f64b4..1b4f3b7ba 100644 --- a/docs/help/faq.md +++ b/docs/help/faq.md @@ -2328,7 +2328,7 @@ Quick setup (recommended): - Set a unique `gateway.port` in each profile config (or pass `--port` for manual runs). - Install a per-profile service: `moltbot --profile gateway install`. -Profiles also suffix service names (`com.clawdbot.`, `moltbot-gateway-.service`, `Moltbot Gateway ()`). +Profiles also suffix service names (`bot.molt.`; legacy `com.clawdbot.*`, `moltbot-gateway-.service`, `Moltbot Gateway ()`). Full guide: [Multiple gateways](/gateway/multiple-gateways). ### What does invalid handshake code 1008 mean diff --git a/docs/install/nix.md b/docs/install/nix.md index ee2e09997..b67677423 100644 --- a/docs/install/nix.md +++ b/docs/install/nix.md @@ -57,7 +57,7 @@ On macOS, the GUI app does not automatically inherit shell env vars. You can also enable Nix mode via defaults: ```bash -defaults write com.clawdbot.mac moltbot.nixMode -bool true +defaults write bot.molt.mac moltbot.nixMode -bool true ``` ### Config + state paths diff --git a/docs/install/uninstall.md b/docs/install/uninstall.md index 8d8be7a11..f3a180caa 100644 --- a/docs/install/uninstall.md +++ b/docs/install/uninstall.md @@ -78,14 +78,14 @@ Use this if the gateway service keeps running but `moltbot` is missing. ### macOS (launchd) -Default label is `com.clawdbot.gateway` (or `com.clawdbot.`): +Default label is `bot.molt.gateway` (or `bot.molt.`; legacy `com.clawdbot.*` may still exist): ```bash -launchctl bootout gui/$UID/com.clawdbot.gateway -rm -f ~/Library/LaunchAgents/com.clawdbot.gateway.plist +launchctl bootout gui/$UID/bot.molt.gateway +rm -f ~/Library/LaunchAgents/bot.molt.gateway.plist ``` -If you used a profile, replace the label and plist name with `com.clawdbot.`. +If you used a profile, replace the label and plist name with `bot.molt.`. Remove any legacy `com.clawdbot.*` plists if present. ### Linux (systemd user unit) diff --git a/docs/install/updating.md b/docs/install/updating.md index 8ee27f7ad..634abfe99 100644 --- a/docs/install/updating.md +++ b/docs/install/updating.md @@ -158,7 +158,7 @@ moltbot logs --follow ``` If you’re supervised: -- macOS launchd (app-bundled LaunchAgent): `launchctl kickstart -k gui/$UID/com.clawdbot.gateway` (use `com.clawdbot.` if set) +- macOS launchd (app-bundled LaunchAgent): `launchctl kickstart -k gui/$UID/bot.molt.gateway` (use `bot.molt.`; legacy `com.clawdbot.*` still works) - Linux systemd user service: `systemctl --user restart moltbot-gateway[-].service` - Windows (WSL2): `systemctl --user restart moltbot-gateway[-].service` - `launchctl`/`systemctl` only work if the service is installed; otherwise run `moltbot gateway install`. diff --git a/docs/platforms/index.md b/docs/platforms/index.md index a4a34b4ab..65eeac2ed 100644 --- a/docs/platforms/index.md +++ b/docs/platforms/index.md @@ -46,5 +46,5 @@ Use one of these (all supported): - Repair/migrate: `moltbot doctor` (offers to install or fix the service) The service target depends on OS: -- macOS: LaunchAgent (`com.clawdbot.gateway` or `com.clawdbot.`) +- macOS: LaunchAgent (`bot.molt.gateway` or `bot.molt.`; legacy `com.clawdbot.*`) - Linux/WSL2: systemd user service (`moltbot-gateway[-].service`) diff --git a/docs/platforms/mac/bundled-gateway.md b/docs/platforms/mac/bundled-gateway.md index f8fb9179f..909fddcfc 100644 --- a/docs/platforms/mac/bundled-gateway.md +++ b/docs/platforms/mac/bundled-gateway.md @@ -26,11 +26,11 @@ The macOS app’s **Install CLI** button runs the same flow via npm/pnpm (bun no ## Launchd (Gateway as LaunchAgent) Label: -- `com.clawdbot.gateway` (or `com.clawdbot.`) +- `bot.molt.gateway` (or `bot.molt.`; legacy `com.clawdbot.*` may remain) Plist location (per‑user): -- `~/Library/LaunchAgents/com.clawdbot.gateway.plist` - (or `~/Library/LaunchAgents/com.clawdbot..plist`) +- `~/Library/LaunchAgents/bot.molt.gateway.plist` + (or `~/Library/LaunchAgents/bot.molt..plist`) Manager: - The macOS app owns LaunchAgent install/update in Local mode. diff --git a/docs/platforms/mac/child-process.md b/docs/platforms/mac/child-process.md index 6483f1df5..d8b2d8728 100644 --- a/docs/platforms/mac/child-process.md +++ b/docs/platforms/mac/child-process.md @@ -16,8 +16,8 @@ If you need tighter coupling to the UI, run the Gateway manually in a terminal. ## Default behavior (launchd) -- The app installs a per‑user LaunchAgent labeled `com.clawdbot.gateway` - (or `com.clawdbot.` when using `--profile`/`CLAWDBOT_PROFILE`). +- The app installs a per‑user LaunchAgent labeled `bot.molt.gateway` + (or `bot.molt.` when using `--profile`/`CLAWDBOT_PROFILE`; legacy `com.clawdbot.*` is supported). - When Local mode is enabled, the app ensures the LaunchAgent is loaded and starts the Gateway if needed. - Logs are written to the launchd gateway log path (visible in Debug Settings). @@ -25,11 +25,11 @@ If you need tighter coupling to the UI, run the Gateway manually in a terminal. Common commands: ```bash -launchctl kickstart -k gui/$UID/com.clawdbot.gateway -launchctl bootout gui/$UID/com.clawdbot.gateway +launchctl kickstart -k gui/$UID/bot.molt.gateway +launchctl bootout gui/$UID/bot.molt.gateway ``` -Replace the label with `com.clawdbot.` when running a named profile. +Replace the label with `bot.molt.` when running a named profile. ## Unsigned dev builds diff --git a/docs/platforms/mac/dev-setup.md b/docs/platforms/mac/dev-setup.md index 179589b26..af0883e18 100644 --- a/docs/platforms/mac/dev-setup.md +++ b/docs/platforms/mac/dev-setup.md @@ -74,7 +74,7 @@ If the app crashes when you try to allow **Speech Recognition** or **Microphone* **Fix:** 1. Reset the TCC permissions: ```bash - tccutil reset All com.clawdbot.mac.debug + tccutil reset All bot.molt.mac.debug ``` 2. If that fails, change the `BUNDLE_ID` temporarily in [`scripts/package-mac-app.sh`](https://github.com/moltbot/moltbot/blob/main/scripts/package-mac-app.sh) to force a "clean slate" from macOS. diff --git a/docs/platforms/mac/logging.md b/docs/platforms/mac/logging.md index b7a9d9d33..9a5594d7d 100644 --- a/docs/platforms/mac/logging.md +++ b/docs/platforms/mac/logging.md @@ -22,11 +22,11 @@ Notes: Unified logging redacts most payloads unless a subsystem opts into `privacy -off`. Per Peter's write-up on macOS [logging privacy shenanigans](https://steipete.me/posts/2025/logging-privacy-shenanigans) (2025) this is controlled by a plist in `/Library/Preferences/Logging/Subsystems/` keyed by the subsystem name. Only new log entries pick up the flag, so enable it before reproducing an issue. -## Enable for Moltbot (`com.clawdbot`) +## Enable for Moltbot (`bot.molt`) - Write the plist to a temp file first, then install it atomically as root: ```bash -cat <<'EOF' >/tmp/com.clawdbot.plist +cat <<'EOF' >/tmp/bot.molt.plist @@ -39,13 +39,13 @@ cat <<'EOF' >/tmp/com.clawdbot.plist EOF -sudo install -m 644 -o root -g wheel /tmp/com.clawdbot.plist /Library/Preferences/Logging/Subsystems/com.clawdbot.plist +sudo install -m 644 -o root -g wheel /tmp/bot.molt.plist /Library/Preferences/Logging/Subsystems/bot.molt.plist ``` - No reboot is required; logd notices the file quickly, but only new log lines will include private payloads. - View the richer output with the existing helper, e.g. `./scripts/clawlog.sh --category WebChat --last 5m`. ## Disable after debugging -- Remove the override: `sudo rm /Library/Preferences/Logging/Subsystems/com.clawdbot.plist`. +- Remove the override: `sudo rm /Library/Preferences/Logging/Subsystems/bot.molt.plist`. - Optionally run `sudo log config --reload` to force logd to drop the override immediately. - Remember this surface can include phone numbers and message bodies; keep the plist in place only while you actively need the extra detail. diff --git a/docs/platforms/mac/permissions.md b/docs/platforms/mac/permissions.md index bfc8f099e..d2570829c 100644 --- a/docs/platforms/mac/permissions.md +++ b/docs/platforms/mac/permissions.md @@ -31,8 +31,8 @@ grants, and prompts can disappear entirely until the stale entries are cleared. Example resets (replace bundle ID as needed): ```bash -sudo tccutil reset Accessibility com.clawdbot.mac -sudo tccutil reset ScreenCapture com.clawdbot.mac +sudo tccutil reset Accessibility bot.molt.mac +sudo tccutil reset ScreenCapture bot.molt.mac sudo tccutil reset AppleEvents ``` diff --git a/docs/platforms/mac/release.md b/docs/platforms/mac/release.md index 4e6d428da..4be82c67a 100644 --- a/docs/platforms/mac/release.md +++ b/docs/platforms/mac/release.md @@ -29,7 +29,7 @@ Notes: ```bash # From repo root; set release IDs so Sparkle feed is enabled. # APP_BUILD must be numeric + monotonic for Sparkle compare. -BUNDLE_ID=com.clawdbot.mac \ +BUNDLE_ID=bot.molt.mac \ APP_VERSION=2026.1.26 \ APP_BUILD="$(git rev-list --count HEAD)" \ BUILD_CONFIG=release \ @@ -47,7 +47,7 @@ scripts/create-dmg.sh dist/Moltbot.app dist/Moltbot-2026.1.26.dmg # xcrun notarytool store-credentials "moltbot-notary" \ # --apple-id "" --team-id "" --password "" NOTARIZE=1 NOTARYTOOL_PROFILE=moltbot-notary \ -BUNDLE_ID=com.clawdbot.mac \ +BUNDLE_ID=bot.molt.mac \ APP_VERSION=2026.1.26 \ APP_BUILD="$(git rev-list --count HEAD)" \ BUILD_CONFIG=release \ diff --git a/docs/platforms/mac/signing.md b/docs/platforms/mac/signing.md index cef1b359d..71f153765 100644 --- a/docs/platforms/mac/signing.md +++ b/docs/platforms/mac/signing.md @@ -7,7 +7,7 @@ read_when: This app is usually built from [`scripts/package-mac-app.sh`](https://github.com/moltbot/moltbot/blob/main/scripts/package-mac-app.sh), which now: -- sets a stable debug bundle identifier: `com.clawdbot.mac.debug` +- sets a stable debug bundle identifier: `bot.molt.mac.debug` - writes the Info.plist with that bundle id (override via `BUNDLE_ID=...`) - calls [`scripts/codesign-mac-app.sh`](https://github.com/moltbot/moltbot/blob/main/scripts/codesign-mac-app.sh) to sign the main binary and app bundle so macOS treats each rebuild as the same signed bundle and keeps TCC permissions (notifications, accessibility, screen recording, mic, speech). For stable permissions, use a real signing identity; ad-hoc is opt-in and fragile (see [macOS permissions](/platforms/mac/permissions)). - uses `CODESIGN_TIMESTAMP=auto` by default; it enables trusted timestamps for Developer ID signatures. Set `CODESIGN_TIMESTAMP=off` to skip timestamping (offline debug builds). diff --git a/docs/platforms/mac/voice-overlay.md b/docs/platforms/mac/voice-overlay.md index 5d755fe67..139445164 100644 --- a/docs/platforms/mac/voice-overlay.md +++ b/docs/platforms/mac/voice-overlay.md @@ -32,14 +32,14 @@ Audience: macOS app contributors. Goal: keep the voice overlay predictable when - Push-to-talk: no delay; wake-word: optional delay for auto-send. - Apply a short cooldown to the wake runtime after push-to-talk finishes so wake-word doesn’t immediately retrigger. 5. **Logging** - - Coordinator emits `.info` logs in subsystem `com.clawdbot`, categories `voicewake.overlay` and `voicewake.chime`. + - Coordinator emits `.info` logs in subsystem `bot.molt`, categories `voicewake.overlay` and `voicewake.chime`. - Key events: `session_started`, `adopted_by_push_to_talk`, `partial`, `finalized`, `send`, `dismiss`, `cancel`, `cooldown`. ### Debugging checklist - Stream logs while reproducing a sticky overlay: ```bash - sudo log stream --predicate 'subsystem == "com.clawdbot" AND category CONTAINS "voicewake"' --level info --style compact + sudo log stream --predicate 'subsystem == "bot.molt" AND category CONTAINS "voicewake"' --level info --style compact ``` - Verify only one active session token; stale callbacks should be dropped by the coordinator. - Ensure push-to-talk release always calls `endCapture` with the active token; if text is empty, expect `dismiss` without chime or send. diff --git a/docs/platforms/mac/webchat.md b/docs/platforms/mac/webchat.md index 80d5cfe2b..5f4e32308 100644 --- a/docs/platforms/mac/webchat.md +++ b/docs/platforms/mac/webchat.md @@ -20,7 +20,7 @@ agent (with a session switcher for other sessions). ```bash dist/Moltbot.app/Contents/MacOS/Moltbot --webchat ``` -- Logs: `./scripts/clawlog.sh` (subsystem `com.clawdbot`, category `WebChatSwiftUI`). +- Logs: `./scripts/clawlog.sh` (subsystem `bot.molt`, category `WebChatSwiftUI`). ## How it’s wired diff --git a/docs/platforms/macos.md b/docs/platforms/macos.md index 8b00dc8c9..c98fe0817 100644 --- a/docs/platforms/macos.md +++ b/docs/platforms/macos.md @@ -32,15 +32,15 @@ The app does not spawn the Gateway as a child process. ## Launchd control -The app manages a per‑user LaunchAgent labeled `com.clawdbot.gateway` -(or `com.clawdbot.` when using `--profile`/`CLAWDBOT_PROFILE`). +The app manages a per‑user LaunchAgent labeled `bot.molt.gateway` +(or `bot.molt.` when using `--profile`/`CLAWDBOT_PROFILE`; legacy `com.clawdbot.*` still unloads). ```bash -launchctl kickstart -k gui/$UID/com.clawdbot.gateway -launchctl bootout gui/$UID/com.clawdbot.gateway +launchctl kickstart -k gui/$UID/bot.molt.gateway +launchctl bootout gui/$UID/bot.molt.gateway ``` -Replace the label with `com.clawdbot.` when running a named profile. +Replace the label with `bot.molt.` when running a named profile. If the LaunchAgent isn’t installed, enable it from the app or run `moltbot gateway install`. diff --git a/package.json b/package.json index 7c05bd9b4..e1f1a8df7 100644 --- a/package.json +++ b/package.json @@ -102,10 +102,10 @@ "ios:gen": "cd apps/ios && xcodegen generate", "ios:open": "cd apps/ios && xcodegen generate && open Moltbot.xcodeproj", "ios:build": "bash -lc 'cd apps/ios && xcodegen generate && xcodebuild -project Moltbot.xcodeproj -scheme Moltbot -destination \"${IOS_DEST:-platform=iOS Simulator,name=iPhone 17}\" -configuration Debug build'", - "ios:run": "bash -lc 'cd apps/ios && xcodegen generate && xcodebuild -project Moltbot.xcodeproj -scheme Moltbot -destination \"${IOS_DEST:-platform=iOS Simulator,name=iPhone 17}\" -configuration Debug build && xcrun simctl boot \"${IOS_SIM:-iPhone 17}\" || true && xcrun simctl launch booted com.clawdbot.ios'", + "ios:run": "bash -lc 'cd apps/ios && xcodegen generate && xcodebuild -project Moltbot.xcodeproj -scheme Moltbot -destination \"${IOS_DEST:-platform=iOS Simulator,name=iPhone 17}\" -configuration Debug build && xcrun simctl boot \"${IOS_SIM:-iPhone 17}\" || true && xcrun simctl launch booted bot.molt.ios'", "android:assemble": "cd apps/android && ./gradlew :app:assembleDebug", "android:install": "cd apps/android && ./gradlew :app:installDebug", - "android:run": "cd apps/android && ./gradlew :app:installDebug && adb shell am start -n com.clawdbot.android/.MainActivity", + "android:run": "cd apps/android && ./gradlew :app:installDebug && adb shell am start -n bot.molt.android/.MainActivity", "android:test": "cd apps/android && ./gradlew :app:testDebugUnitTest", "mac:restart": "bash scripts/restart-mac.sh", "mac:package": "bash scripts/package-mac-app.sh", diff --git a/scripts/clawlog.sh b/scripts/clawlog.sh index 60e73498c..405887d85 100755 --- a/scripts/clawlog.sh +++ b/scripts/clawlog.sh @@ -6,7 +6,7 @@ set -euo pipefail # Configuration -SUBSYSTEM="com.clawdbot" +SUBSYSTEM="bot.molt" DEFAULT_LEVEL="info" # Colors for output @@ -58,7 +58,7 @@ DESCRIPTION: Requires sudo access configured for /usr/bin/log command. LOG FLOW ARCHITECTURE: - Moltbot logs flow through the macOS unified log (subsystem: com.clawdbot). + Moltbot logs flow through the macOS unified log (subsystem: bot.molt). LOG CATEGORIES (examples): • voicewake - Voice wake detection/test harness diff --git a/scripts/package-mac-app.sh b/scripts/package-mac-app.sh index 62ea80481..a63ecaf4d 100755 --- a/scripts/package-mac-app.sh +++ b/scripts/package-mac-app.sh @@ -8,7 +8,7 @@ ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)" APP_ROOT="$ROOT_DIR/dist/Moltbot.app" BUILD_ROOT="$ROOT_DIR/apps/macos/.build" PRODUCT="Moltbot" -BUNDLE_ID="${BUNDLE_ID:-com.clawdbot.mac.debug}" +BUNDLE_ID="${BUNDLE_ID:-bot.molt.mac.debug}" PKG_VERSION="$(cd "$ROOT_DIR" && node -p "require('./package.json').version" 2>/dev/null || echo "0.0.0")" BUILD_TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ") GIT_COMMIT=$(cd "$ROOT_DIR" && git rev-parse --short HEAD 2>/dev/null || echo "unknown") diff --git a/scripts/restart-mac.sh b/scripts/restart-mac.sh index 67ed81908..6dc81bb4e 100755 --- a/scripts/restart-mac.sh +++ b/scripts/restart-mac.sh @@ -9,7 +9,7 @@ APP_PROCESS_PATTERN="Moltbot.app/Contents/MacOS/Moltbot" DEBUG_PROCESS_PATTERN="${ROOT_DIR}/apps/macos/.build/debug/Moltbot" LOCAL_PROCESS_PATTERN="${ROOT_DIR}/apps/macos/.build-local/debug/Moltbot" RELEASE_PROCESS_PATTERN="${ROOT_DIR}/apps/macos/.build/release/Moltbot" -LAUNCH_AGENT="${HOME}/Library/LaunchAgents/com.clawdbot.mac.plist" +LAUNCH_AGENT="${HOME}/Library/LaunchAgents/bot.molt.mac.plist" LOCK_KEY="$(printf '%s' "${ROOT_DIR}" | shasum -a 256 | cut -c1-8)" LOCK_DIR="${TMPDIR:-/tmp}/moltbot-restart-${LOCK_KEY}" LOCK_PID_FILE="${LOCK_DIR}/pid" @@ -145,7 +145,7 @@ kill_all_moltbot() { } stop_launch_agent() { - launchctl bootout gui/"$UID"/com.clawdbot.mac 2>/dev/null || true + launchctl bootout gui/"$UID"/bot.molt.mac 2>/dev/null || true } # 1) Kill all running instances first. @@ -265,5 +265,5 @@ else fi if [ "$NO_SIGN" -eq 1 ] && [ "$ATTACH_ONLY" -ne 1 ]; then - run_step "show gateway launch agent args (unsigned)" bash -lc "/usr/bin/plutil -p '${HOME}/Library/LaunchAgents/com.clawdbot.gateway.plist' | head -n 40 || true" + run_step "show gateway launch agent args (unsigned)" bash -lc "/usr/bin/plutil -p '${HOME}/Library/LaunchAgents/bot.molt.gateway.plist' | head -n 40 || true" fi diff --git a/src/cli/daemon-cli.coverage.test.ts b/src/cli/daemon-cli.coverage.test.ts index 6c8ff9cc9..0a6d07390 100644 --- a/src/cli/daemon-cli.coverage.test.ts +++ b/src/cli/daemon-cli.coverage.test.ts @@ -145,7 +145,7 @@ describe("daemon-cli coverage", () => { CLAWDBOT_CONFIG_PATH: "/tmp/moltbot-daemon-state/moltbot.json", CLAWDBOT_GATEWAY_PORT: "19001", }, - sourcePath: "/tmp/com.clawdbot.gateway.plist", + sourcePath: "/tmp/bot.molt.gateway.plist", }); const { registerDaemonCli } = await import("./daemon-cli.js"); diff --git a/src/commands/status.test.ts b/src/commands/status.test.ts index a425df6ad..06d07d476 100644 --- a/src/commands/status.test.ts +++ b/src/commands/status.test.ts @@ -255,7 +255,7 @@ vi.mock("../daemon/service.js", () => ({ readRuntime: async () => ({ status: "running", pid: 1234 }), readCommand: async () => ({ programArguments: ["node", "dist/entry.js", "gateway"], - sourcePath: "/tmp/Library/LaunchAgents/com.clawdbot.gateway.plist", + sourcePath: "/tmp/Library/LaunchAgents/bot.molt.gateway.plist", }), }), })); @@ -268,7 +268,7 @@ vi.mock("../daemon/node-service.js", () => ({ readRuntime: async () => ({ status: "running", pid: 4321 }), readCommand: async () => ({ programArguments: ["node", "dist/entry.js", "node-host"], - sourcePath: "/tmp/Library/LaunchAgents/com.clawdbot.node.plist", + sourcePath: "/tmp/Library/LaunchAgents/bot.molt.node.plist", }), }), })); diff --git a/src/daemon/constants.test.ts b/src/daemon/constants.test.ts index 4a82e4b7a..854c527ea 100644 --- a/src/daemon/constants.test.ts +++ b/src/daemon/constants.test.ts @@ -14,7 +14,7 @@ describe("resolveGatewayLaunchAgentLabel", () => { it("returns default label when no profile is set", () => { const result = resolveGatewayLaunchAgentLabel(); expect(result).toBe(GATEWAY_LAUNCH_AGENT_LABEL); - expect(result).toBe("com.clawdbot.gateway"); + expect(result).toBe("bot.molt.gateway"); }); it("returns default label when profile is undefined", () => { @@ -34,17 +34,17 @@ describe("resolveGatewayLaunchAgentLabel", () => { it("returns profile-specific label when profile is set", () => { const result = resolveGatewayLaunchAgentLabel("dev"); - expect(result).toBe("com.clawdbot.dev"); + expect(result).toBe("bot.molt.dev"); }); it("returns profile-specific label for custom profile", () => { const result = resolveGatewayLaunchAgentLabel("work"); - expect(result).toBe("com.clawdbot.work"); + expect(result).toBe("bot.molt.work"); }); it("trims whitespace from profile", () => { const result = resolveGatewayLaunchAgentLabel(" staging "); - expect(result).toBe("com.clawdbot.staging"); + expect(result).toBe("bot.molt.staging"); }); it("returns default label for empty string profile", () => { diff --git a/src/daemon/constants.ts b/src/daemon/constants.ts index 3a0325baa..b46a69817 100644 --- a/src/daemon/constants.ts +++ b/src/daemon/constants.ts @@ -1,16 +1,19 @@ // Default service labels (for backward compatibility and when no profile specified) -export const GATEWAY_LAUNCH_AGENT_LABEL = "com.clawdbot.gateway"; +export const GATEWAY_LAUNCH_AGENT_LABEL = "bot.molt.gateway"; export const GATEWAY_SYSTEMD_SERVICE_NAME = "moltbot-gateway"; export const GATEWAY_WINDOWS_TASK_NAME = "Moltbot Gateway"; export const GATEWAY_SERVICE_MARKER = "moltbot"; export const GATEWAY_SERVICE_KIND = "gateway"; -export const NODE_LAUNCH_AGENT_LABEL = "com.clawdbot.node"; +export const NODE_LAUNCH_AGENT_LABEL = "bot.molt.node"; export const NODE_SYSTEMD_SERVICE_NAME = "moltbot-node"; export const NODE_WINDOWS_TASK_NAME = "Moltbot Node"; export const NODE_SERVICE_MARKER = "moltbot"; export const NODE_SERVICE_KIND = "node"; export const NODE_WINDOWS_TASK_SCRIPT_NAME = "node.cmd"; -export const LEGACY_GATEWAY_LAUNCH_AGENT_LABELS = ["com.steipete.clawdbot.gateway"]; +export const LEGACY_GATEWAY_LAUNCH_AGENT_LABELS = [ + "com.clawdbot.gateway", + "com.steipete.clawdbot.gateway", +]; export const LEGACY_GATEWAY_SYSTEMD_SERVICE_NAMES: string[] = []; export const LEGACY_GATEWAY_WINDOWS_TASK_NAMES: string[] = []; @@ -30,7 +33,15 @@ export function resolveGatewayLaunchAgentLabel(profile?: string): string { if (!normalized) { return GATEWAY_LAUNCH_AGENT_LABEL; } - return `com.clawdbot.${normalized}`; + return `bot.molt.${normalized}`; +} + +export function resolveLegacyGatewayLaunchAgentLabels(profile?: string): string[] { + const normalized = normalizeGatewayProfile(profile); + if (!normalized) { + return [...LEGACY_GATEWAY_LAUNCH_AGENT_LABELS]; + } + return [...LEGACY_GATEWAY_LAUNCH_AGENT_LABELS, `com.clawdbot.${normalized}`]; } export function resolveGatewaySystemdServiceName(profile?: string): string { diff --git a/src/daemon/inspect.ts b/src/daemon/inspect.ts index 1296a62d6..46318956d 100644 --- a/src/daemon/inspect.ts +++ b/src/daemon/inspect.ts @@ -6,12 +6,12 @@ import { promisify } from "node:util"; import { GATEWAY_SERVICE_KIND, GATEWAY_SERVICE_MARKER, - LEGACY_GATEWAY_LAUNCH_AGENT_LABELS, LEGACY_GATEWAY_SYSTEMD_SERVICE_NAMES, LEGACY_GATEWAY_WINDOWS_TASK_NAMES, resolveGatewayLaunchAgentLabel, resolveGatewaySystemdServiceName, resolveGatewayWindowsTaskName, + resolveLegacyGatewayLaunchAgentLabels, } from "./constants.js"; export type ExtraGatewayService = { @@ -78,7 +78,7 @@ function isMoltbotGatewayLaunchdService(label: string, contents: string): boolea if (hasGatewayServiceMarker(contents)) return true; const lowerContents = contents.toLowerCase(); if (!lowerContents.includes("gateway")) return false; - return label.startsWith("com.clawdbot."); + return label.startsWith("bot.molt.") || label.startsWith("com.clawdbot."); } function isMoltbotGatewaySystemdService(name: string, contents: string): boolean { @@ -102,7 +102,8 @@ function tryExtractPlistLabel(contents: string): string | null { function isIgnoredLaunchdLabel(label: string): boolean { return ( - label === resolveGatewayLaunchAgentLabel() || LEGACY_GATEWAY_LAUNCH_AGENT_LABELS.includes(label) + label === resolveGatewayLaunchAgentLabel() || + resolveLegacyGatewayLaunchAgentLabels(process.env.CLAWDBOT_PROFILE).includes(label) ); } diff --git a/src/daemon/launchd.test.ts b/src/daemon/launchd.test.ts index 4954b6b15..1052cb9b9 100644 --- a/src/daemon/launchd.test.ts +++ b/src/daemon/launchd.test.ts @@ -107,7 +107,7 @@ describe("launchd runtime parsing", () => { describe("launchctl list detection", () => { it("detects the resolved label in launchctl list", async () => { - await withLaunchctlStub({ listOutput: "123 0 com.clawdbot.gateway\n" }, async ({ env }) => { + await withLaunchctlStub({ listOutput: "123 0 bot.molt.gateway\n" }, async ({ env }) => { const listed = await isLaunchAgentListed({ env }); expect(listed).toBe(true); }); @@ -133,7 +133,7 @@ describe("launchd bootstrap repair", () => { .map((line) => JSON.parse(line) as string[]); const domain = typeof process.getuid === "function" ? `gui/${process.getuid()}` : "gui/501"; - const label = "com.clawdbot.gateway"; + const label = "bot.molt.gateway"; const plistPath = resolveLaunchAgentPlistPath(env); expect(calls).toContainEqual(["bootstrap", domain, plistPath]); @@ -201,7 +201,7 @@ describe("launchd install", () => { .map((line) => JSON.parse(line) as string[]); const domain = typeof process.getuid === "function" ? `gui/${process.getuid()}` : "gui/501"; - const label = "com.clawdbot.gateway"; + const label = "bot.molt.gateway"; const plistPath = resolveLaunchAgentPlistPath(env); const serviceId = `${domain}/${label}`; @@ -231,21 +231,21 @@ describe("resolveLaunchAgentPlistPath", () => { it("uses default label when CLAWDBOT_PROFILE is default", () => { const env = { HOME: "/Users/test", CLAWDBOT_PROFILE: "default" }; expect(resolveLaunchAgentPlistPath(env)).toBe( - "/Users/test/Library/LaunchAgents/com.clawdbot.gateway.plist", + "/Users/test/Library/LaunchAgents/bot.molt.gateway.plist", ); }); it("uses default label when CLAWDBOT_PROFILE is unset", () => { const env = { HOME: "/Users/test" }; expect(resolveLaunchAgentPlistPath(env)).toBe( - "/Users/test/Library/LaunchAgents/com.clawdbot.gateway.plist", + "/Users/test/Library/LaunchAgents/bot.molt.gateway.plist", ); }); it("uses profile-specific label when CLAWDBOT_PROFILE is set to a custom value", () => { const env = { HOME: "/Users/test", CLAWDBOT_PROFILE: "jbphoenix" }; expect(resolveLaunchAgentPlistPath(env)).toBe( - "/Users/test/Library/LaunchAgents/com.clawdbot.jbphoenix.plist", + "/Users/test/Library/LaunchAgents/bot.molt.jbphoenix.plist", ); }); @@ -277,28 +277,28 @@ describe("resolveLaunchAgentPlistPath", () => { CLAWDBOT_LAUNCHD_LABEL: " ", }; expect(resolveLaunchAgentPlistPath(env)).toBe( - "/Users/test/Library/LaunchAgents/com.clawdbot.myprofile.plist", + "/Users/test/Library/LaunchAgents/bot.molt.myprofile.plist", ); }); it("handles case-insensitive 'Default' profile", () => { const env = { HOME: "/Users/test", CLAWDBOT_PROFILE: "Default" }; expect(resolveLaunchAgentPlistPath(env)).toBe( - "/Users/test/Library/LaunchAgents/com.clawdbot.gateway.plist", + "/Users/test/Library/LaunchAgents/bot.molt.gateway.plist", ); }); it("handles case-insensitive 'DEFAULT' profile", () => { const env = { HOME: "/Users/test", CLAWDBOT_PROFILE: "DEFAULT" }; expect(resolveLaunchAgentPlistPath(env)).toBe( - "/Users/test/Library/LaunchAgents/com.clawdbot.gateway.plist", + "/Users/test/Library/LaunchAgents/bot.molt.gateway.plist", ); }); it("trims whitespace from CLAWDBOT_PROFILE", () => { const env = { HOME: "/Users/test", CLAWDBOT_PROFILE: " myprofile " }; expect(resolveLaunchAgentPlistPath(env)).toBe( - "/Users/test/Library/LaunchAgents/com.clawdbot.myprofile.plist", + "/Users/test/Library/LaunchAgents/bot.molt.myprofile.plist", ); }); }); diff --git a/src/daemon/launchd.ts b/src/daemon/launchd.ts index 529cfdc1a..747494bf7 100644 --- a/src/daemon/launchd.ts +++ b/src/daemon/launchd.ts @@ -7,8 +7,8 @@ import { colorize, isRich, theme } from "../terminal/theme.js"; import { formatGatewayServiceDescription, GATEWAY_LAUNCH_AGENT_LABEL, - LEGACY_GATEWAY_LAUNCH_AGENT_LABELS, resolveGatewayLaunchAgentLabel, + resolveLegacyGatewayLaunchAgentLabels, } from "./constants.js"; import { buildLaunchAgentPlist as buildLaunchAgentPlistImpl, @@ -248,7 +248,7 @@ export async function findLegacyLaunchAgents( ): Promise { const domain = resolveGuiDomain(); const results: LegacyLaunchAgent[] = []; - for (const label of LEGACY_GATEWAY_LAUNCH_AGENT_LABELS) { + for (const label of resolveLegacyGatewayLaunchAgentLabels(env.CLAWDBOT_PROFILE)) { const plistPath = resolveLaunchAgentPlistPathForLabel(env, label); const res = await execLaunchctl(["print", `${domain}/${label}`]); const loaded = res.code === 0; @@ -384,7 +384,7 @@ export async function installLaunchAgent({ const domain = resolveGuiDomain(); const label = resolveLaunchAgentLabel({ env }); - for (const legacyLabel of LEGACY_GATEWAY_LAUNCH_AGENT_LABELS) { + for (const legacyLabel of resolveLegacyGatewayLaunchAgentLabels(env.CLAWDBOT_PROFILE)) { const legacyPlistPath = resolveLaunchAgentPlistPathForLabel(env, legacyLabel); await execLaunchctl(["bootout", domain, legacyPlistPath]); await execLaunchctl(["unload", legacyPlistPath]); diff --git a/src/daemon/service-env.test.ts b/src/daemon/service-env.test.ts index 73e2fc564..8a5cc6072 100644 --- a/src/daemon/service-env.test.ts +++ b/src/daemon/service-env.test.ts @@ -230,7 +230,7 @@ describe("buildServiceEnvironment", () => { expect(typeof env.CLAWDBOT_SERVICE_VERSION).toBe("string"); expect(env.CLAWDBOT_SYSTEMD_UNIT).toBe("moltbot-gateway.service"); if (process.platform === "darwin") { - expect(env.CLAWDBOT_LAUNCHD_LABEL).toBe("com.clawdbot.gateway"); + expect(env.CLAWDBOT_LAUNCHD_LABEL).toBe("bot.molt.gateway"); } }); @@ -241,7 +241,7 @@ describe("buildServiceEnvironment", () => { }); expect(env.CLAWDBOT_SYSTEMD_UNIT).toBe("moltbot-gateway-work.service"); if (process.platform === "darwin") { - expect(env.CLAWDBOT_LAUNCHD_LABEL).toBe("com.clawdbot.work"); + expect(env.CLAWDBOT_LAUNCHD_LABEL).toBe("bot.molt.work"); } }); }); From 9ec4c619e0400450c6e1e93399b4fd6e8c37f3ba Mon Sep 17 00:00:00 2001 From: Shadow Date: Tue, 27 Jan 2026 14:46:38 -0600 Subject: [PATCH 044/101] Branding: remove legacy android packages --- .../com/clawdbot/android/CameraHudState.kt | 14 - .../java/com/clawdbot/android/DeviceNames.kt | 26 - .../java/com/clawdbot/android/LocationMode.kt | 15 - .../java/com/clawdbot/android/MainActivity.kt | 130 -- .../com/clawdbot/android/MainViewModel.kt | 174 --- .../main/java/com/clawdbot/android/NodeApp.kt | 26 - .../clawdbot/android/NodeForegroundService.kt | 180 --- .../java/com/clawdbot/android/NodeRuntime.kt | 1268 ----------------- .../clawdbot/android/PermissionRequester.kt | 133 -- .../android/ScreenCaptureRequester.kt | 65 - .../java/com/clawdbot/android/SecurePrefs.kt | 308 ---- .../java/com/clawdbot/android/SessionKey.kt | 13 - .../com/clawdbot/android/VoiceWakeMode.kt | 14 - .../java/com/clawdbot/android/WakeWords.kt | 21 - .../clawdbot/android/chat/ChatController.kt | 524 ------- .../com/clawdbot/android/chat/ChatModels.kt | 44 - .../android/gateway/BonjourEscapes.kt | 35 - .../android/gateway/DeviceAuthStore.kt | 26 - .../android/gateway/DeviceIdentityStore.kt | 146 -- .../android/gateway/GatewayDiscovery.kt | 519 ------- .../android/gateway/GatewayEndpoint.kt | 26 - .../android/gateway/GatewayProtocol.kt | 3 - .../android/gateway/GatewaySession.kt | 683 --------- .../clawdbot/android/gateway/GatewayTls.kt | 90 -- .../android/node/CameraCaptureManager.kt | 316 ---- .../clawdbot/android/node/CanvasController.kt | 264 ---- .../clawdbot/android/node/JpegSizeLimiter.kt | 61 - .../android/node/LocationCaptureManager.kt | 117 -- .../android/node/ScreenRecordManager.kt | 199 --- .../com/clawdbot/android/node/SmsManager.kt | 230 --- .../protocol/ClawdbotCanvasA2UIAction.kt | 66 - .../protocol/ClawdbotProtocolConstants.kt | 71 - .../com/clawdbot/android/tools/ToolDisplay.kt | 222 --- .../clawdbot/android/ui/CameraHudOverlay.kt | 44 - .../java/com/clawdbot/android/ui/ChatSheet.kt | 10 - .../com/clawdbot/android/ui/ClawdbotTheme.kt | 32 - .../com/clawdbot/android/ui/RootScreen.kt | 449 ------ .../com/clawdbot/android/ui/SettingsSheet.kt | 686 --------- .../com/clawdbot/android/ui/StatusPill.kt | 114 -- .../com/clawdbot/android/ui/TalkOrbOverlay.kt | 134 -- .../clawdbot/android/ui/chat/ChatComposer.kt | 285 ---- .../clawdbot/android/ui/chat/ChatMarkdown.kt | 215 --- .../android/ui/chat/ChatMessageListCard.kt | 111 -- .../android/ui/chat/ChatMessageViews.kt | 252 ---- .../android/ui/chat/ChatSessionsDialog.kt | 92 -- .../android/ui/chat/ChatSheetContent.kt | 147 -- .../android/ui/chat/SessionFilters.kt | 49 - .../android/voice/StreamingMediaDataSource.kt | 98 -- .../android/voice/TalkDirectiveParser.kt | 191 --- .../clawdbot/android/voice/TalkModeManager.kt | 1257 ---------------- .../voice/VoiceWakeCommandExtractor.kt | 40 - .../android/voice/VoiceWakeManager.kt | 173 --- .../android/NodeForegroundServiceTest.kt | 43 - .../com/clawdbot/android/WakeWordsTest.kt | 50 - .../android/gateway/BonjourEscapesTest.kt | 19 - .../CanvasControllerSnapshotParamsTest.kt | 43 - .../android/node/JpegSizeLimiterTest.kt | 47 - .../clawdbot/android/node/SmsManagerTest.kt | 91 -- .../protocol/ClawdbotCanvasA2UIActionTest.kt | 49 - .../protocol/ClawdbotProtocolConstantsTest.kt | 35 - .../android/ui/chat/SessionFiltersTest.kt | 35 - .../android/voice/TalkDirectiveParserTest.kt | 55 - .../voice/VoiceWakeCommandExtractorTest.kt | 25 - 63 files changed, 10900 deletions(-) delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/CameraHudState.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/DeviceNames.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/LocationMode.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/MainActivity.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/MainViewModel.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/NodeApp.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/NodeForegroundService.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/NodeRuntime.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/PermissionRequester.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ScreenCaptureRequester.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/SecurePrefs.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/SessionKey.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/VoiceWakeMode.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/WakeWords.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/chat/ChatController.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/chat/ChatModels.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/gateway/BonjourEscapes.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceAuthStore.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceIdentityStore.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayDiscovery.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayEndpoint.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayProtocol.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewaySession.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayTls.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/node/CameraCaptureManager.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/node/CanvasController.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/node/JpegSizeLimiter.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/node/LocationCaptureManager.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/node/ScreenRecordManager.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/node/SmsManager.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIAction.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotProtocolConstants.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/tools/ToolDisplay.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/CameraHudOverlay.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/ChatSheet.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/ClawdbotTheme.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/RootScreen.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/SettingsSheet.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/StatusPill.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/TalkOrbOverlay.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatComposer.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMarkdown.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMessageListCard.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMessageViews.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatSessionsDialog.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatSheetContent.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/ui/chat/SessionFilters.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/voice/StreamingMediaDataSource.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/voice/TalkDirectiveParser.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/voice/TalkModeManager.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/voice/VoiceWakeCommandExtractor.kt delete mode 100644 apps/android/app/src/main/java/com/clawdbot/android/voice/VoiceWakeManager.kt delete mode 100644 apps/android/app/src/test/java/com/clawdbot/android/NodeForegroundServiceTest.kt delete mode 100644 apps/android/app/src/test/java/com/clawdbot/android/WakeWordsTest.kt delete mode 100644 apps/android/app/src/test/java/com/clawdbot/android/gateway/BonjourEscapesTest.kt delete mode 100644 apps/android/app/src/test/java/com/clawdbot/android/node/CanvasControllerSnapshotParamsTest.kt delete mode 100644 apps/android/app/src/test/java/com/clawdbot/android/node/JpegSizeLimiterTest.kt delete mode 100644 apps/android/app/src/test/java/com/clawdbot/android/node/SmsManagerTest.kt delete mode 100644 apps/android/app/src/test/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIActionTest.kt delete mode 100644 apps/android/app/src/test/java/com/clawdbot/android/protocol/ClawdbotProtocolConstantsTest.kt delete mode 100644 apps/android/app/src/test/java/com/clawdbot/android/ui/chat/SessionFiltersTest.kt delete mode 100644 apps/android/app/src/test/java/com/clawdbot/android/voice/TalkDirectiveParserTest.kt delete mode 100644 apps/android/app/src/test/java/com/clawdbot/android/voice/VoiceWakeCommandExtractorTest.kt diff --git a/apps/android/app/src/main/java/com/clawdbot/android/CameraHudState.kt b/apps/android/app/src/main/java/com/clawdbot/android/CameraHudState.kt deleted file mode 100644 index 1c9b3986f..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/CameraHudState.kt +++ /dev/null @@ -1,14 +0,0 @@ -package com.clawdbot.android - -enum class CameraHudKind { - Photo, - Recording, - Success, - Error, -} - -data class CameraHudState( - val token: Long, - val kind: CameraHudKind, - val message: String, -) diff --git a/apps/android/app/src/main/java/com/clawdbot/android/DeviceNames.kt b/apps/android/app/src/main/java/com/clawdbot/android/DeviceNames.kt deleted file mode 100644 index dfe5c590b..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/DeviceNames.kt +++ /dev/null @@ -1,26 +0,0 @@ -package com.clawdbot.android - -import android.content.Context -import android.os.Build -import android.provider.Settings - -object DeviceNames { - fun bestDefaultNodeName(context: Context): String { - val deviceName = - runCatching { - Settings.Global.getString(context.contentResolver, "device_name") - } - .getOrNull() - ?.trim() - .orEmpty() - - if (deviceName.isNotEmpty()) return deviceName - - val model = - listOfNotNull(Build.MANUFACTURER?.takeIf { it.isNotBlank() }, Build.MODEL?.takeIf { it.isNotBlank() }) - .joinToString(" ") - .trim() - - return model.ifEmpty { "Android Node" } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/LocationMode.kt b/apps/android/app/src/main/java/com/clawdbot/android/LocationMode.kt deleted file mode 100644 index 4df77f632..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/LocationMode.kt +++ /dev/null @@ -1,15 +0,0 @@ -package com.clawdbot.android - -enum class LocationMode(val rawValue: String) { - Off("off"), - WhileUsing("whileUsing"), - Always("always"), - ; - - companion object { - fun fromRawValue(raw: String?): LocationMode { - val normalized = raw?.trim()?.lowercase() - return entries.firstOrNull { it.rawValue.lowercase() == normalized } ?: Off - } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/MainActivity.kt b/apps/android/app/src/main/java/com/clawdbot/android/MainActivity.kt deleted file mode 100644 index 92ad6077a..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/MainActivity.kt +++ /dev/null @@ -1,130 +0,0 @@ -package com.clawdbot.android - -import android.Manifest -import android.content.pm.ApplicationInfo -import android.os.Bundle -import android.os.Build -import android.view.WindowManager -import android.webkit.WebView -import androidx.activity.ComponentActivity -import androidx.activity.compose.setContent -import androidx.activity.viewModels -import androidx.compose.material3.Surface -import androidx.compose.ui.Modifier -import androidx.core.content.ContextCompat -import androidx.core.view.WindowCompat -import androidx.core.view.WindowInsetsCompat -import androidx.core.view.WindowInsetsControllerCompat -import androidx.lifecycle.Lifecycle -import androidx.lifecycle.lifecycleScope -import androidx.lifecycle.repeatOnLifecycle -import com.clawdbot.android.ui.RootScreen -import com.clawdbot.android.ui.MoltbotTheme -import kotlinx.coroutines.launch - -class MainActivity : ComponentActivity() { - private val viewModel: MainViewModel by viewModels() - private lateinit var permissionRequester: PermissionRequester - private lateinit var screenCaptureRequester: ScreenCaptureRequester - - override fun onCreate(savedInstanceState: Bundle?) { - super.onCreate(savedInstanceState) - val isDebuggable = (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0 - WebView.setWebContentsDebuggingEnabled(isDebuggable) - applyImmersiveMode() - requestDiscoveryPermissionsIfNeeded() - requestNotificationPermissionIfNeeded() - NodeForegroundService.start(this) - permissionRequester = PermissionRequester(this) - screenCaptureRequester = ScreenCaptureRequester(this) - viewModel.camera.attachLifecycleOwner(this) - viewModel.camera.attachPermissionRequester(permissionRequester) - viewModel.sms.attachPermissionRequester(permissionRequester) - viewModel.screenRecorder.attachScreenCaptureRequester(screenCaptureRequester) - viewModel.screenRecorder.attachPermissionRequester(permissionRequester) - - lifecycleScope.launch { - repeatOnLifecycle(Lifecycle.State.STARTED) { - viewModel.preventSleep.collect { enabled -> - if (enabled) { - window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) - } else { - window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) - } - } - } - } - - setContent { - MoltbotTheme { - Surface(modifier = Modifier) { - RootScreen(viewModel = viewModel) - } - } - } - } - - override fun onResume() { - super.onResume() - applyImmersiveMode() - } - - override fun onWindowFocusChanged(hasFocus: Boolean) { - super.onWindowFocusChanged(hasFocus) - if (hasFocus) { - applyImmersiveMode() - } - } - - override fun onStart() { - super.onStart() - viewModel.setForeground(true) - } - - override fun onStop() { - viewModel.setForeground(false) - super.onStop() - } - - private fun applyImmersiveMode() { - WindowCompat.setDecorFitsSystemWindows(window, false) - val controller = WindowInsetsControllerCompat(window, window.decorView) - controller.systemBarsBehavior = - WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE - controller.hide(WindowInsetsCompat.Type.systemBars()) - } - - private fun requestDiscoveryPermissionsIfNeeded() { - if (Build.VERSION.SDK_INT >= 33) { - val ok = - ContextCompat.checkSelfPermission( - this, - Manifest.permission.NEARBY_WIFI_DEVICES, - ) == android.content.pm.PackageManager.PERMISSION_GRANTED - if (!ok) { - requestPermissions(arrayOf(Manifest.permission.NEARBY_WIFI_DEVICES), 100) - } - } else { - val ok = - ContextCompat.checkSelfPermission( - this, - Manifest.permission.ACCESS_FINE_LOCATION, - ) == android.content.pm.PackageManager.PERMISSION_GRANTED - if (!ok) { - requestPermissions(arrayOf(Manifest.permission.ACCESS_FINE_LOCATION), 101) - } - } - } - - private fun requestNotificationPermissionIfNeeded() { - if (Build.VERSION.SDK_INT < 33) return - val ok = - ContextCompat.checkSelfPermission( - this, - Manifest.permission.POST_NOTIFICATIONS, - ) == android.content.pm.PackageManager.PERMISSION_GRANTED - if (!ok) { - requestPermissions(arrayOf(Manifest.permission.POST_NOTIFICATIONS), 102) - } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/MainViewModel.kt b/apps/android/app/src/main/java/com/clawdbot/android/MainViewModel.kt deleted file mode 100644 index 1329f06d4..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/MainViewModel.kt +++ /dev/null @@ -1,174 +0,0 @@ -package com.clawdbot.android - -import android.app.Application -import androidx.lifecycle.AndroidViewModel -import com.clawdbot.android.gateway.GatewayEndpoint -import com.clawdbot.android.chat.OutgoingAttachment -import com.clawdbot.android.node.CameraCaptureManager -import com.clawdbot.android.node.CanvasController -import com.clawdbot.android.node.ScreenRecordManager -import com.clawdbot.android.node.SmsManager -import kotlinx.coroutines.flow.StateFlow - -class MainViewModel(app: Application) : AndroidViewModel(app) { - private val runtime: NodeRuntime = (app as NodeApp).runtime - - val canvas: CanvasController = runtime.canvas - val camera: CameraCaptureManager = runtime.camera - val screenRecorder: ScreenRecordManager = runtime.screenRecorder - val sms: SmsManager = runtime.sms - - val gateways: StateFlow> = runtime.gateways - val discoveryStatusText: StateFlow = runtime.discoveryStatusText - - val isConnected: StateFlow = runtime.isConnected - val statusText: StateFlow = runtime.statusText - val serverName: StateFlow = runtime.serverName - val remoteAddress: StateFlow = runtime.remoteAddress - val isForeground: StateFlow = runtime.isForeground - val seamColorArgb: StateFlow = runtime.seamColorArgb - val mainSessionKey: StateFlow = runtime.mainSessionKey - - val cameraHud: StateFlow = runtime.cameraHud - val cameraFlashToken: StateFlow = runtime.cameraFlashToken - val screenRecordActive: StateFlow = runtime.screenRecordActive - - val instanceId: StateFlow = runtime.instanceId - val displayName: StateFlow = runtime.displayName - val cameraEnabled: StateFlow = runtime.cameraEnabled - val locationMode: StateFlow = runtime.locationMode - val locationPreciseEnabled: StateFlow = runtime.locationPreciseEnabled - val preventSleep: StateFlow = runtime.preventSleep - val wakeWords: StateFlow> = runtime.wakeWords - val voiceWakeMode: StateFlow = runtime.voiceWakeMode - val voiceWakeStatusText: StateFlow = runtime.voiceWakeStatusText - val voiceWakeIsListening: StateFlow = runtime.voiceWakeIsListening - val talkEnabled: StateFlow = runtime.talkEnabled - val talkStatusText: StateFlow = runtime.talkStatusText - val talkIsListening: StateFlow = runtime.talkIsListening - val talkIsSpeaking: StateFlow = runtime.talkIsSpeaking - val manualEnabled: StateFlow = runtime.manualEnabled - val manualHost: StateFlow = runtime.manualHost - val manualPort: StateFlow = runtime.manualPort - val manualTls: StateFlow = runtime.manualTls - val canvasDebugStatusEnabled: StateFlow = runtime.canvasDebugStatusEnabled - - val chatSessionKey: StateFlow = runtime.chatSessionKey - val chatSessionId: StateFlow = runtime.chatSessionId - val chatMessages = runtime.chatMessages - val chatError: StateFlow = runtime.chatError - val chatHealthOk: StateFlow = runtime.chatHealthOk - val chatThinkingLevel: StateFlow = runtime.chatThinkingLevel - val chatStreamingAssistantText: StateFlow = runtime.chatStreamingAssistantText - val chatPendingToolCalls = runtime.chatPendingToolCalls - val chatSessions = runtime.chatSessions - val pendingRunCount: StateFlow = runtime.pendingRunCount - - fun setForeground(value: Boolean) { - runtime.setForeground(value) - } - - fun setDisplayName(value: String) { - runtime.setDisplayName(value) - } - - fun setCameraEnabled(value: Boolean) { - runtime.setCameraEnabled(value) - } - - fun setLocationMode(mode: LocationMode) { - runtime.setLocationMode(mode) - } - - fun setLocationPreciseEnabled(value: Boolean) { - runtime.setLocationPreciseEnabled(value) - } - - fun setPreventSleep(value: Boolean) { - runtime.setPreventSleep(value) - } - - fun setManualEnabled(value: Boolean) { - runtime.setManualEnabled(value) - } - - fun setManualHost(value: String) { - runtime.setManualHost(value) - } - - fun setManualPort(value: Int) { - runtime.setManualPort(value) - } - - fun setManualTls(value: Boolean) { - runtime.setManualTls(value) - } - - fun setCanvasDebugStatusEnabled(value: Boolean) { - runtime.setCanvasDebugStatusEnabled(value) - } - - fun setWakeWords(words: List) { - runtime.setWakeWords(words) - } - - fun resetWakeWordsDefaults() { - runtime.resetWakeWordsDefaults() - } - - fun setVoiceWakeMode(mode: VoiceWakeMode) { - runtime.setVoiceWakeMode(mode) - } - - fun setTalkEnabled(enabled: Boolean) { - runtime.setTalkEnabled(enabled) - } - - fun refreshGatewayConnection() { - runtime.refreshGatewayConnection() - } - - fun connect(endpoint: GatewayEndpoint) { - runtime.connect(endpoint) - } - - fun connectManual() { - runtime.connectManual() - } - - fun disconnect() { - runtime.disconnect() - } - - fun handleCanvasA2UIActionFromWebView(payloadJson: String) { - runtime.handleCanvasA2UIActionFromWebView(payloadJson) - } - - fun loadChat(sessionKey: String) { - runtime.loadChat(sessionKey) - } - - fun refreshChat() { - runtime.refreshChat() - } - - fun refreshChatSessions(limit: Int? = null) { - runtime.refreshChatSessions(limit = limit) - } - - fun setChatThinkingLevel(level: String) { - runtime.setChatThinkingLevel(level) - } - - fun switchChatSession(sessionKey: String) { - runtime.switchChatSession(sessionKey) - } - - fun abortChat() { - runtime.abortChat() - } - - fun sendChat(message: String, thinking: String, attachments: List) { - runtime.sendChat(message = message, thinking = thinking, attachments = attachments) - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/NodeApp.kt b/apps/android/app/src/main/java/com/clawdbot/android/NodeApp.kt deleted file mode 100644 index 228794ff3..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/NodeApp.kt +++ /dev/null @@ -1,26 +0,0 @@ -package com.clawdbot.android - -import android.app.Application -import android.os.StrictMode - -class NodeApp : Application() { - val runtime: NodeRuntime by lazy { NodeRuntime(this) } - - override fun onCreate() { - super.onCreate() - if (BuildConfig.DEBUG) { - StrictMode.setThreadPolicy( - StrictMode.ThreadPolicy.Builder() - .detectAll() - .penaltyLog() - .build(), - ) - StrictMode.setVmPolicy( - StrictMode.VmPolicy.Builder() - .detectAll() - .penaltyLog() - .build(), - ) - } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/NodeForegroundService.kt b/apps/android/app/src/main/java/com/clawdbot/android/NodeForegroundService.kt deleted file mode 100644 index a3074f8b1..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/NodeForegroundService.kt +++ /dev/null @@ -1,180 +0,0 @@ -package com.clawdbot.android - -import android.app.Notification -import android.app.NotificationChannel -import android.app.NotificationManager -import android.app.Service -import android.app.PendingIntent -import android.Manifest -import android.content.Context -import android.content.Intent -import android.content.pm.PackageManager -import android.content.pm.ServiceInfo -import androidx.core.app.NotificationCompat -import androidx.core.content.ContextCompat -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.Job -import kotlinx.coroutines.SupervisorJob -import kotlinx.coroutines.cancel -import kotlinx.coroutines.flow.combine -import kotlinx.coroutines.launch - -class NodeForegroundService : Service() { - private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main) - private var notificationJob: Job? = null - private var lastRequiresMic = false - private var didStartForeground = false - - override fun onCreate() { - super.onCreate() - ensureChannel() - val initial = buildNotification(title = "Moltbot Node", text = "Starting…") - startForegroundWithTypes(notification = initial, requiresMic = false) - - val runtime = (application as NodeApp).runtime - notificationJob = - scope.launch { - combine( - runtime.statusText, - runtime.serverName, - runtime.isConnected, - runtime.voiceWakeMode, - runtime.voiceWakeIsListening, - ) { status, server, connected, voiceMode, voiceListening -> - Quint(status, server, connected, voiceMode, voiceListening) - }.collect { (status, server, connected, voiceMode, voiceListening) -> - val title = if (connected) "Moltbot Node · Connected" else "Moltbot Node" - val voiceSuffix = - if (voiceMode == VoiceWakeMode.Always) { - if (voiceListening) " · Voice Wake: Listening" else " · Voice Wake: Paused" - } else { - "" - } - val text = (server?.let { "$status · $it" } ?: status) + voiceSuffix - - val requiresMic = - voiceMode == VoiceWakeMode.Always && hasRecordAudioPermission() - startForegroundWithTypes( - notification = buildNotification(title = title, text = text), - requiresMic = requiresMic, - ) - } - } - } - - override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { - when (intent?.action) { - ACTION_STOP -> { - (application as NodeApp).runtime.disconnect() - stopSelf() - return START_NOT_STICKY - } - } - // Keep running; connection is managed by NodeRuntime (auto-reconnect + manual). - return START_STICKY - } - - override fun onDestroy() { - notificationJob?.cancel() - scope.cancel() - super.onDestroy() - } - - override fun onBind(intent: Intent?) = null - - private fun ensureChannel() { - val mgr = getSystemService(NotificationManager::class.java) - val channel = - NotificationChannel( - CHANNEL_ID, - "Connection", - NotificationManager.IMPORTANCE_LOW, - ).apply { - description = "Moltbot node connection status" - setShowBadge(false) - } - mgr.createNotificationChannel(channel) - } - - private fun buildNotification(title: String, text: String): Notification { - val launchIntent = Intent(this, MainActivity::class.java).apply { - flags = Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP - } - val launchPending = - PendingIntent.getActivity( - this, - 1, - launchIntent, - PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE, - ) - - val stopIntent = Intent(this, NodeForegroundService::class.java).setAction(ACTION_STOP) - val stopPending = - PendingIntent.getService( - this, - 2, - stopIntent, - PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE, - ) - - return NotificationCompat.Builder(this, CHANNEL_ID) - .setSmallIcon(R.mipmap.ic_launcher) - .setContentTitle(title) - .setContentText(text) - .setContentIntent(launchPending) - .setOngoing(true) - .setOnlyAlertOnce(true) - .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE) - .addAction(0, "Disconnect", stopPending) - .build() - } - - private fun updateNotification(notification: Notification) { - val mgr = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager - mgr.notify(NOTIFICATION_ID, notification) - } - - private fun startForegroundWithTypes(notification: Notification, requiresMic: Boolean) { - if (didStartForeground && requiresMic == lastRequiresMic) { - updateNotification(notification) - return - } - - lastRequiresMic = requiresMic - val types = - if (requiresMic) { - ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC or ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE - } else { - ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC - } - startForeground(NOTIFICATION_ID, notification, types) - didStartForeground = true - } - - private fun hasRecordAudioPermission(): Boolean { - return ( - ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == - PackageManager.PERMISSION_GRANTED - ) - } - - companion object { - private const val CHANNEL_ID = "connection" - private const val NOTIFICATION_ID = 1 - - private const val ACTION_STOP = "com.clawdbot.android.action.STOP" - - fun start(context: Context) { - val intent = Intent(context, NodeForegroundService::class.java) - context.startForegroundService(intent) - } - - fun stop(context: Context) { - val intent = Intent(context, NodeForegroundService::class.java).setAction(ACTION_STOP) - context.startService(intent) - } - } -} - -private data class Quint(val first: A, val second: B, val third: C, val fourth: D, val fifth: E) diff --git a/apps/android/app/src/main/java/com/clawdbot/android/NodeRuntime.kt b/apps/android/app/src/main/java/com/clawdbot/android/NodeRuntime.kt deleted file mode 100644 index 46e486100..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/NodeRuntime.kt +++ /dev/null @@ -1,1268 +0,0 @@ -package com.clawdbot.android - -import android.Manifest -import android.content.Context -import android.content.pm.PackageManager -import android.location.LocationManager -import android.os.Build -import android.os.SystemClock -import androidx.core.content.ContextCompat -import com.clawdbot.android.chat.ChatController -import com.clawdbot.android.chat.ChatMessage -import com.clawdbot.android.chat.ChatPendingToolCall -import com.clawdbot.android.chat.ChatSessionEntry -import com.clawdbot.android.chat.OutgoingAttachment -import com.clawdbot.android.gateway.DeviceAuthStore -import com.clawdbot.android.gateway.DeviceIdentityStore -import com.clawdbot.android.gateway.GatewayClientInfo -import com.clawdbot.android.gateway.GatewayConnectOptions -import com.clawdbot.android.gateway.GatewayDiscovery -import com.clawdbot.android.gateway.GatewayEndpoint -import com.clawdbot.android.gateway.GatewaySession -import com.clawdbot.android.gateway.GatewayTlsParams -import com.clawdbot.android.node.CameraCaptureManager -import com.clawdbot.android.node.LocationCaptureManager -import com.clawdbot.android.BuildConfig -import com.clawdbot.android.node.CanvasController -import com.clawdbot.android.node.ScreenRecordManager -import com.clawdbot.android.node.SmsManager -import com.clawdbot.android.protocol.MoltbotCapability -import com.clawdbot.android.protocol.MoltbotCameraCommand -import com.clawdbot.android.protocol.MoltbotCanvasA2UIAction -import com.clawdbot.android.protocol.MoltbotCanvasA2UICommand -import com.clawdbot.android.protocol.MoltbotCanvasCommand -import com.clawdbot.android.protocol.MoltbotScreenCommand -import com.clawdbot.android.protocol.MoltbotLocationCommand -import com.clawdbot.android.protocol.MoltbotSmsCommand -import com.clawdbot.android.voice.TalkModeManager -import com.clawdbot.android.voice.VoiceWakeManager -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.Job -import kotlinx.coroutines.SupervisorJob -import kotlinx.coroutines.TimeoutCancellationException -import kotlinx.coroutines.delay -import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.flow.StateFlow -import kotlinx.coroutines.flow.asStateFlow -import kotlinx.coroutines.flow.combine -import kotlinx.coroutines.flow.collect -import kotlinx.coroutines.flow.distinctUntilChanged -import kotlinx.coroutines.launch -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonArray -import kotlinx.serialization.json.JsonElement -import kotlinx.serialization.json.JsonNull -import kotlinx.serialization.json.JsonObject -import kotlinx.serialization.json.JsonPrimitive -import kotlinx.serialization.json.buildJsonObject -import java.util.concurrent.atomic.AtomicLong - -class NodeRuntime(context: Context) { - private val appContext = context.applicationContext - private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO) - - val prefs = SecurePrefs(appContext) - private val deviceAuthStore = DeviceAuthStore(prefs) - val canvas = CanvasController() - val camera = CameraCaptureManager(appContext) - val location = LocationCaptureManager(appContext) - val screenRecorder = ScreenRecordManager(appContext) - val sms = SmsManager(appContext) - private val json = Json { ignoreUnknownKeys = true } - - private val externalAudioCaptureActive = MutableStateFlow(false) - - private val voiceWake: VoiceWakeManager by lazy { - VoiceWakeManager( - context = appContext, - scope = scope, - onCommand = { command -> - nodeSession.sendNodeEvent( - event = "agent.request", - payloadJson = - buildJsonObject { - put("message", JsonPrimitive(command)) - put("sessionKey", JsonPrimitive(resolveMainSessionKey())) - put("thinking", JsonPrimitive(chatThinkingLevel.value)) - put("deliver", JsonPrimitive(false)) - }.toString(), - ) - }, - ) - } - - val voiceWakeIsListening: StateFlow - get() = voiceWake.isListening - - val voiceWakeStatusText: StateFlow - get() = voiceWake.statusText - - val talkStatusText: StateFlow - get() = talkMode.statusText - - val talkIsListening: StateFlow - get() = talkMode.isListening - - val talkIsSpeaking: StateFlow - get() = talkMode.isSpeaking - - private val discovery = GatewayDiscovery(appContext, scope = scope) - val gateways: StateFlow> = discovery.gateways - val discoveryStatusText: StateFlow = discovery.statusText - - private val identityStore = DeviceIdentityStore(appContext) - - private val _isConnected = MutableStateFlow(false) - val isConnected: StateFlow = _isConnected.asStateFlow() - - private val _statusText = MutableStateFlow("Offline") - val statusText: StateFlow = _statusText.asStateFlow() - - private val _mainSessionKey = MutableStateFlow("main") - val mainSessionKey: StateFlow = _mainSessionKey.asStateFlow() - - private val cameraHudSeq = AtomicLong(0) - private val _cameraHud = MutableStateFlow(null) - val cameraHud: StateFlow = _cameraHud.asStateFlow() - - private val _cameraFlashToken = MutableStateFlow(0L) - val cameraFlashToken: StateFlow = _cameraFlashToken.asStateFlow() - - private val _screenRecordActive = MutableStateFlow(false) - val screenRecordActive: StateFlow = _screenRecordActive.asStateFlow() - - private val _serverName = MutableStateFlow(null) - val serverName: StateFlow = _serverName.asStateFlow() - - private val _remoteAddress = MutableStateFlow(null) - val remoteAddress: StateFlow = _remoteAddress.asStateFlow() - - private val _seamColorArgb = MutableStateFlow(DEFAULT_SEAM_COLOR_ARGB) - val seamColorArgb: StateFlow = _seamColorArgb.asStateFlow() - - private val _isForeground = MutableStateFlow(true) - val isForeground: StateFlow = _isForeground.asStateFlow() - - private var lastAutoA2uiUrl: String? = null - private var operatorConnected = false - private var nodeConnected = false - private var operatorStatusText: String = "Offline" - private var nodeStatusText: String = "Offline" - private var connectedEndpoint: GatewayEndpoint? = null - - private val operatorSession = - GatewaySession( - scope = scope, - identityStore = identityStore, - deviceAuthStore = deviceAuthStore, - onConnected = { name, remote, mainSessionKey -> - operatorConnected = true - operatorStatusText = "Connected" - _serverName.value = name - _remoteAddress.value = remote - _seamColorArgb.value = DEFAULT_SEAM_COLOR_ARGB - applyMainSessionKey(mainSessionKey) - updateStatus() - scope.launch { refreshBrandingFromGateway() } - scope.launch { refreshWakeWordsFromGateway() } - }, - onDisconnected = { message -> - operatorConnected = false - operatorStatusText = message - _serverName.value = null - _remoteAddress.value = null - _seamColorArgb.value = DEFAULT_SEAM_COLOR_ARGB - if (!isCanonicalMainSessionKey(_mainSessionKey.value)) { - _mainSessionKey.value = "main" - } - val mainKey = resolveMainSessionKey() - talkMode.setMainSessionKey(mainKey) - chat.applyMainSessionKey(mainKey) - chat.onDisconnected(message) - updateStatus() - }, - onEvent = { event, payloadJson -> - handleGatewayEvent(event, payloadJson) - }, - ) - - private val nodeSession = - GatewaySession( - scope = scope, - identityStore = identityStore, - deviceAuthStore = deviceAuthStore, - onConnected = { _, _, _ -> - nodeConnected = true - nodeStatusText = "Connected" - updateStatus() - maybeNavigateToA2uiOnConnect() - }, - onDisconnected = { message -> - nodeConnected = false - nodeStatusText = message - updateStatus() - showLocalCanvasOnDisconnect() - }, - onEvent = { _, _ -> }, - onInvoke = { req -> - handleInvoke(req.command, req.paramsJson) - }, - onTlsFingerprint = { stableId, fingerprint -> - prefs.saveGatewayTlsFingerprint(stableId, fingerprint) - }, - ) - - private val chat: ChatController = - ChatController( - scope = scope, - session = operatorSession, - json = json, - supportsChatSubscribe = false, - ) - private val talkMode: TalkModeManager by lazy { - TalkModeManager( - context = appContext, - scope = scope, - session = operatorSession, - supportsChatSubscribe = false, - isConnected = { operatorConnected }, - ) - } - - private fun applyMainSessionKey(candidate: String?) { - val trimmed = candidate?.trim().orEmpty() - if (trimmed.isEmpty()) return - if (isCanonicalMainSessionKey(_mainSessionKey.value)) return - if (_mainSessionKey.value == trimmed) return - _mainSessionKey.value = trimmed - talkMode.setMainSessionKey(trimmed) - chat.applyMainSessionKey(trimmed) - } - - private fun updateStatus() { - _isConnected.value = operatorConnected - _statusText.value = - when { - operatorConnected && nodeConnected -> "Connected" - operatorConnected && !nodeConnected -> "Connected (node offline)" - !operatorConnected && nodeConnected -> "Connected (operator offline)" - operatorStatusText.isNotBlank() && operatorStatusText != "Offline" -> operatorStatusText - else -> nodeStatusText - } - } - - private fun resolveMainSessionKey(): String { - val trimmed = _mainSessionKey.value.trim() - return if (trimmed.isEmpty()) "main" else trimmed - } - - private fun maybeNavigateToA2uiOnConnect() { - val a2uiUrl = resolveA2uiHostUrl() ?: return - val current = canvas.currentUrl()?.trim().orEmpty() - if (current.isEmpty() || current == lastAutoA2uiUrl) { - lastAutoA2uiUrl = a2uiUrl - canvas.navigate(a2uiUrl) - } - } - - private fun showLocalCanvasOnDisconnect() { - lastAutoA2uiUrl = null - canvas.navigate("") - } - - val instanceId: StateFlow = prefs.instanceId - val displayName: StateFlow = prefs.displayName - val cameraEnabled: StateFlow = prefs.cameraEnabled - val locationMode: StateFlow = prefs.locationMode - val locationPreciseEnabled: StateFlow = prefs.locationPreciseEnabled - val preventSleep: StateFlow = prefs.preventSleep - val wakeWords: StateFlow> = prefs.wakeWords - val voiceWakeMode: StateFlow = prefs.voiceWakeMode - val talkEnabled: StateFlow = prefs.talkEnabled - val manualEnabled: StateFlow = prefs.manualEnabled - val manualHost: StateFlow = prefs.manualHost - val manualPort: StateFlow = prefs.manualPort - val manualTls: StateFlow = prefs.manualTls - val lastDiscoveredStableId: StateFlow = prefs.lastDiscoveredStableId - val canvasDebugStatusEnabled: StateFlow = prefs.canvasDebugStatusEnabled - - private var didAutoConnect = false - private var suppressWakeWordsSync = false - private var wakeWordsSyncJob: Job? = null - - val chatSessionKey: StateFlow = chat.sessionKey - val chatSessionId: StateFlow = chat.sessionId - val chatMessages: StateFlow> = chat.messages - val chatError: StateFlow = chat.errorText - val chatHealthOk: StateFlow = chat.healthOk - val chatThinkingLevel: StateFlow = chat.thinkingLevel - val chatStreamingAssistantText: StateFlow = chat.streamingAssistantText - val chatPendingToolCalls: StateFlow> = chat.pendingToolCalls - val chatSessions: StateFlow> = chat.sessions - val pendingRunCount: StateFlow = chat.pendingRunCount - - init { - scope.launch { - combine( - voiceWakeMode, - isForeground, - externalAudioCaptureActive, - wakeWords, - ) { mode, foreground, externalAudio, words -> - Quad(mode, foreground, externalAudio, words) - }.distinctUntilChanged() - .collect { (mode, foreground, externalAudio, words) -> - voiceWake.setTriggerWords(words) - - val shouldListen = - when (mode) { - VoiceWakeMode.Off -> false - VoiceWakeMode.Foreground -> foreground - VoiceWakeMode.Always -> true - } && !externalAudio - - if (!shouldListen) { - voiceWake.stop(statusText = if (mode == VoiceWakeMode.Off) "Off" else "Paused") - return@collect - } - - if (!hasRecordAudioPermission()) { - voiceWake.stop(statusText = "Microphone permission required") - return@collect - } - - voiceWake.start() - } - } - - scope.launch { - talkEnabled.collect { enabled -> - talkMode.setEnabled(enabled) - externalAudioCaptureActive.value = enabled - } - } - - scope.launch(Dispatchers.Default) { - gateways.collect { list -> - if (list.isNotEmpty()) { - // Persist the last discovered gateway (best-effort UX parity with iOS). - prefs.setLastDiscoveredStableId(list.last().stableId) - } - - if (didAutoConnect) return@collect - if (_isConnected.value) return@collect - - if (manualEnabled.value) { - val host = manualHost.value.trim() - val port = manualPort.value - if (host.isNotEmpty() && port in 1..65535) { - didAutoConnect = true - connect(GatewayEndpoint.manual(host = host, port = port)) - } - return@collect - } - - val targetStableId = lastDiscoveredStableId.value.trim() - if (targetStableId.isEmpty()) return@collect - val target = list.firstOrNull { it.stableId == targetStableId } ?: return@collect - didAutoConnect = true - connect(target) - } - } - - scope.launch { - combine( - canvasDebugStatusEnabled, - statusText, - serverName, - remoteAddress, - ) { debugEnabled, status, server, remote -> - Quad(debugEnabled, status, server, remote) - }.distinctUntilChanged() - .collect { (debugEnabled, status, server, remote) -> - canvas.setDebugStatusEnabled(debugEnabled) - if (!debugEnabled) return@collect - canvas.setDebugStatus(status, server ?: remote) - } - } - } - - fun setForeground(value: Boolean) { - _isForeground.value = value - } - - fun setDisplayName(value: String) { - prefs.setDisplayName(value) - } - - fun setCameraEnabled(value: Boolean) { - prefs.setCameraEnabled(value) - } - - fun setLocationMode(mode: LocationMode) { - prefs.setLocationMode(mode) - } - - fun setLocationPreciseEnabled(value: Boolean) { - prefs.setLocationPreciseEnabled(value) - } - - fun setPreventSleep(value: Boolean) { - prefs.setPreventSleep(value) - } - - fun setManualEnabled(value: Boolean) { - prefs.setManualEnabled(value) - } - - fun setManualHost(value: String) { - prefs.setManualHost(value) - } - - fun setManualPort(value: Int) { - prefs.setManualPort(value) - } - - fun setManualTls(value: Boolean) { - prefs.setManualTls(value) - } - - fun setCanvasDebugStatusEnabled(value: Boolean) { - prefs.setCanvasDebugStatusEnabled(value) - } - - fun setWakeWords(words: List) { - prefs.setWakeWords(words) - scheduleWakeWordsSyncIfNeeded() - } - - fun resetWakeWordsDefaults() { - setWakeWords(SecurePrefs.defaultWakeWords) - } - - fun setVoiceWakeMode(mode: VoiceWakeMode) { - prefs.setVoiceWakeMode(mode) - } - - fun setTalkEnabled(value: Boolean) { - prefs.setTalkEnabled(value) - } - - private fun buildInvokeCommands(): List = - buildList { - add(MoltbotCanvasCommand.Present.rawValue) - add(MoltbotCanvasCommand.Hide.rawValue) - add(MoltbotCanvasCommand.Navigate.rawValue) - add(MoltbotCanvasCommand.Eval.rawValue) - add(MoltbotCanvasCommand.Snapshot.rawValue) - add(MoltbotCanvasA2UICommand.Push.rawValue) - add(MoltbotCanvasA2UICommand.PushJSONL.rawValue) - add(MoltbotCanvasA2UICommand.Reset.rawValue) - add(MoltbotScreenCommand.Record.rawValue) - if (cameraEnabled.value) { - add(MoltbotCameraCommand.Snap.rawValue) - add(MoltbotCameraCommand.Clip.rawValue) - } - if (locationMode.value != LocationMode.Off) { - add(MoltbotLocationCommand.Get.rawValue) - } - if (sms.canSendSms()) { - add(MoltbotSmsCommand.Send.rawValue) - } - } - - private fun buildCapabilities(): List = - buildList { - add(MoltbotCapability.Canvas.rawValue) - add(MoltbotCapability.Screen.rawValue) - if (cameraEnabled.value) add(MoltbotCapability.Camera.rawValue) - if (sms.canSendSms()) add(MoltbotCapability.Sms.rawValue) - if (voiceWakeMode.value != VoiceWakeMode.Off && hasRecordAudioPermission()) { - add(MoltbotCapability.VoiceWake.rawValue) - } - if (locationMode.value != LocationMode.Off) { - add(MoltbotCapability.Location.rawValue) - } - } - - private fun resolvedVersionName(): String { - val versionName = BuildConfig.VERSION_NAME.trim().ifEmpty { "dev" } - return if (BuildConfig.DEBUG && !versionName.contains("dev", ignoreCase = true)) { - "$versionName-dev" - } else { - versionName - } - } - - private fun resolveModelIdentifier(): String? { - return listOfNotNull(Build.MANUFACTURER, Build.MODEL) - .joinToString(" ") - .trim() - .ifEmpty { null } - } - - private fun buildUserAgent(): String { - val version = resolvedVersionName() - val release = Build.VERSION.RELEASE?.trim().orEmpty() - val releaseLabel = if (release.isEmpty()) "unknown" else release - return "MoltbotAndroid/$version (Android $releaseLabel; SDK ${Build.VERSION.SDK_INT})" - } - - private fun buildClientInfo(clientId: String, clientMode: String): GatewayClientInfo { - return GatewayClientInfo( - id = clientId, - displayName = displayName.value, - version = resolvedVersionName(), - platform = "android", - mode = clientMode, - instanceId = instanceId.value, - deviceFamily = "Android", - modelIdentifier = resolveModelIdentifier(), - ) - } - - private fun buildNodeConnectOptions(): GatewayConnectOptions { - return GatewayConnectOptions( - role = "node", - scopes = emptyList(), - caps = buildCapabilities(), - commands = buildInvokeCommands(), - permissions = emptyMap(), - client = buildClientInfo(clientId = "moltbot-android", clientMode = "node"), - userAgent = buildUserAgent(), - ) - } - - private fun buildOperatorConnectOptions(): GatewayConnectOptions { - return GatewayConnectOptions( - role = "operator", - scopes = emptyList(), - caps = emptyList(), - commands = emptyList(), - permissions = emptyMap(), - client = buildClientInfo(clientId = "moltbot-control-ui", clientMode = "ui"), - userAgent = buildUserAgent(), - ) - } - - fun refreshGatewayConnection() { - val endpoint = connectedEndpoint ?: return - val token = prefs.loadGatewayToken() - val password = prefs.loadGatewayPassword() - val tls = resolveTlsParams(endpoint) - operatorSession.connect(endpoint, token, password, buildOperatorConnectOptions(), tls) - nodeSession.connect(endpoint, token, password, buildNodeConnectOptions(), tls) - operatorSession.reconnect() - nodeSession.reconnect() - } - - fun connect(endpoint: GatewayEndpoint) { - connectedEndpoint = endpoint - operatorStatusText = "Connecting…" - nodeStatusText = "Connecting…" - updateStatus() - val token = prefs.loadGatewayToken() - val password = prefs.loadGatewayPassword() - val tls = resolveTlsParams(endpoint) - operatorSession.connect(endpoint, token, password, buildOperatorConnectOptions(), tls) - nodeSession.connect(endpoint, token, password, buildNodeConnectOptions(), tls) - } - - private fun hasRecordAudioPermission(): Boolean { - return ( - ContextCompat.checkSelfPermission(appContext, Manifest.permission.RECORD_AUDIO) == - PackageManager.PERMISSION_GRANTED - ) - } - - private fun hasFineLocationPermission(): Boolean { - return ( - ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_FINE_LOCATION) == - PackageManager.PERMISSION_GRANTED - ) - } - - private fun hasCoarseLocationPermission(): Boolean { - return ( - ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_COARSE_LOCATION) == - PackageManager.PERMISSION_GRANTED - ) - } - - private fun hasBackgroundLocationPermission(): Boolean { - return ( - ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == - PackageManager.PERMISSION_GRANTED - ) - } - - fun connectManual() { - val host = manualHost.value.trim() - val port = manualPort.value - if (host.isEmpty() || port <= 0 || port > 65535) { - _statusText.value = "Failed: invalid manual host/port" - return - } - connect(GatewayEndpoint.manual(host = host, port = port)) - } - - fun disconnect() { - connectedEndpoint = null - operatorSession.disconnect() - nodeSession.disconnect() - } - - private fun resolveTlsParams(endpoint: GatewayEndpoint): GatewayTlsParams? { - val stored = prefs.loadGatewayTlsFingerprint(endpoint.stableId) - val hinted = endpoint.tlsEnabled || !endpoint.tlsFingerprintSha256.isNullOrBlank() - val manual = endpoint.stableId.startsWith("manual|") - - if (manual) { - if (!manualTls.value) return null - return GatewayTlsParams( - required = true, - expectedFingerprint = endpoint.tlsFingerprintSha256 ?: stored, - allowTOFU = stored == null, - stableId = endpoint.stableId, - ) - } - - if (hinted) { - return GatewayTlsParams( - required = true, - expectedFingerprint = endpoint.tlsFingerprintSha256 ?: stored, - allowTOFU = stored == null, - stableId = endpoint.stableId, - ) - } - - if (!stored.isNullOrBlank()) { - return GatewayTlsParams( - required = true, - expectedFingerprint = stored, - allowTOFU = false, - stableId = endpoint.stableId, - ) - } - - return null - } - - fun handleCanvasA2UIActionFromWebView(payloadJson: String) { - scope.launch { - val trimmed = payloadJson.trim() - if (trimmed.isEmpty()) return@launch - - val root = - try { - json.parseToJsonElement(trimmed).asObjectOrNull() ?: return@launch - } catch (_: Throwable) { - return@launch - } - - val userActionObj = (root["userAction"] as? JsonObject) ?: root - val actionId = (userActionObj["id"] as? JsonPrimitive)?.content?.trim().orEmpty().ifEmpty { - java.util.UUID.randomUUID().toString() - } - val name = MoltbotCanvasA2UIAction.extractActionName(userActionObj) ?: return@launch - - val surfaceId = - (userActionObj["surfaceId"] as? JsonPrimitive)?.content?.trim().orEmpty().ifEmpty { "main" } - val sourceComponentId = - (userActionObj["sourceComponentId"] as? JsonPrimitive)?.content?.trim().orEmpty().ifEmpty { "-" } - val contextJson = (userActionObj["context"] as? JsonObject)?.toString() - - val sessionKey = resolveMainSessionKey() - val message = - MoltbotCanvasA2UIAction.formatAgentMessage( - actionName = name, - sessionKey = sessionKey, - surfaceId = surfaceId, - sourceComponentId = sourceComponentId, - host = displayName.value, - instanceId = instanceId.value.lowercase(), - contextJson = contextJson, - ) - - val connected = nodeConnected - var error: String? = null - if (connected) { - try { - nodeSession.sendNodeEvent( - event = "agent.request", - payloadJson = - buildJsonObject { - put("message", JsonPrimitive(message)) - put("sessionKey", JsonPrimitive(sessionKey)) - put("thinking", JsonPrimitive("low")) - put("deliver", JsonPrimitive(false)) - put("key", JsonPrimitive(actionId)) - }.toString(), - ) - } catch (e: Throwable) { - error = e.message ?: "send failed" - } - } else { - error = "gateway not connected" - } - - try { - canvas.eval( - MoltbotCanvasA2UIAction.jsDispatchA2UIActionStatus( - actionId = actionId, - ok = connected && error == null, - error = error, - ), - ) - } catch (_: Throwable) { - // ignore - } - } - } - - fun loadChat(sessionKey: String) { - val key = sessionKey.trim().ifEmpty { resolveMainSessionKey() } - chat.load(key) - } - - fun refreshChat() { - chat.refresh() - } - - fun refreshChatSessions(limit: Int? = null) { - chat.refreshSessions(limit = limit) - } - - fun setChatThinkingLevel(level: String) { - chat.setThinkingLevel(level) - } - - fun switchChatSession(sessionKey: String) { - chat.switchSession(sessionKey) - } - - fun abortChat() { - chat.abort() - } - - fun sendChat(message: String, thinking: String, attachments: List) { - chat.sendMessage(message = message, thinkingLevel = thinking, attachments = attachments) - } - - private fun handleGatewayEvent(event: String, payloadJson: String?) { - if (event == "voicewake.changed") { - if (payloadJson.isNullOrBlank()) return - try { - val payload = json.parseToJsonElement(payloadJson).asObjectOrNull() ?: return - val array = payload["triggers"] as? JsonArray ?: return - val triggers = array.mapNotNull { it.asStringOrNull() } - applyWakeWordsFromGateway(triggers) - } catch (_: Throwable) { - // ignore - } - return - } - - talkMode.handleGatewayEvent(event, payloadJson) - chat.handleGatewayEvent(event, payloadJson) - } - - private fun applyWakeWordsFromGateway(words: List) { - suppressWakeWordsSync = true - prefs.setWakeWords(words) - suppressWakeWordsSync = false - } - - private fun scheduleWakeWordsSyncIfNeeded() { - if (suppressWakeWordsSync) return - if (!_isConnected.value) return - - val snapshot = prefs.wakeWords.value - wakeWordsSyncJob?.cancel() - wakeWordsSyncJob = - scope.launch { - delay(650) - val jsonList = snapshot.joinToString(separator = ",") { it.toJsonString() } - val params = """{"triggers":[$jsonList]}""" - try { - operatorSession.request("voicewake.set", params) - } catch (_: Throwable) { - // ignore - } - } - } - - private suspend fun refreshWakeWordsFromGateway() { - if (!_isConnected.value) return - try { - val res = operatorSession.request("voicewake.get", "{}") - val payload = json.parseToJsonElement(res).asObjectOrNull() ?: return - val array = payload["triggers"] as? JsonArray ?: return - val triggers = array.mapNotNull { it.asStringOrNull() } - applyWakeWordsFromGateway(triggers) - } catch (_: Throwable) { - // ignore - } - } - - private suspend fun refreshBrandingFromGateway() { - if (!_isConnected.value) return - try { - val res = operatorSession.request("config.get", "{}") - val root = json.parseToJsonElement(res).asObjectOrNull() - val config = root?.get("config").asObjectOrNull() - val ui = config?.get("ui").asObjectOrNull() - val raw = ui?.get("seamColor").asStringOrNull()?.trim() - val sessionCfg = config?.get("session").asObjectOrNull() - val mainKey = normalizeMainKey(sessionCfg?.get("mainKey").asStringOrNull()) - applyMainSessionKey(mainKey) - - val parsed = parseHexColorArgb(raw) - _seamColorArgb.value = parsed ?: DEFAULT_SEAM_COLOR_ARGB - } catch (_: Throwable) { - // ignore - } - } - - private suspend fun handleInvoke(command: String, paramsJson: String?): GatewaySession.InvokeResult { - if ( - command.startsWith(MoltbotCanvasCommand.NamespacePrefix) || - command.startsWith(MoltbotCanvasA2UICommand.NamespacePrefix) || - command.startsWith(MoltbotCameraCommand.NamespacePrefix) || - command.startsWith(MoltbotScreenCommand.NamespacePrefix) - ) { - if (!isForeground.value) { - return GatewaySession.InvokeResult.error( - code = "NODE_BACKGROUND_UNAVAILABLE", - message = "NODE_BACKGROUND_UNAVAILABLE: canvas/camera/screen commands require foreground", - ) - } - } - if (command.startsWith(MoltbotCameraCommand.NamespacePrefix) && !cameraEnabled.value) { - return GatewaySession.InvokeResult.error( - code = "CAMERA_DISABLED", - message = "CAMERA_DISABLED: enable Camera in Settings", - ) - } - if (command.startsWith(MoltbotLocationCommand.NamespacePrefix) && - locationMode.value == LocationMode.Off - ) { - return GatewaySession.InvokeResult.error( - code = "LOCATION_DISABLED", - message = "LOCATION_DISABLED: enable Location in Settings", - ) - } - - return when (command) { - MoltbotCanvasCommand.Present.rawValue -> { - val url = CanvasController.parseNavigateUrl(paramsJson) - canvas.navigate(url) - GatewaySession.InvokeResult.ok(null) - } - MoltbotCanvasCommand.Hide.rawValue -> GatewaySession.InvokeResult.ok(null) - MoltbotCanvasCommand.Navigate.rawValue -> { - val url = CanvasController.parseNavigateUrl(paramsJson) - canvas.navigate(url) - GatewaySession.InvokeResult.ok(null) - } - MoltbotCanvasCommand.Eval.rawValue -> { - val js = - CanvasController.parseEvalJs(paramsJson) - ?: return GatewaySession.InvokeResult.error( - code = "INVALID_REQUEST", - message = "INVALID_REQUEST: javaScript required", - ) - val result = - try { - canvas.eval(js) - } catch (err: Throwable) { - return GatewaySession.InvokeResult.error( - code = "NODE_BACKGROUND_UNAVAILABLE", - message = "NODE_BACKGROUND_UNAVAILABLE: canvas unavailable", - ) - } - GatewaySession.InvokeResult.ok("""{"result":${result.toJsonString()}}""") - } - MoltbotCanvasCommand.Snapshot.rawValue -> { - val snapshotParams = CanvasController.parseSnapshotParams(paramsJson) - val base64 = - try { - canvas.snapshotBase64( - format = snapshotParams.format, - quality = snapshotParams.quality, - maxWidth = snapshotParams.maxWidth, - ) - } catch (err: Throwable) { - return GatewaySession.InvokeResult.error( - code = "NODE_BACKGROUND_UNAVAILABLE", - message = "NODE_BACKGROUND_UNAVAILABLE: canvas unavailable", - ) - } - GatewaySession.InvokeResult.ok("""{"format":"${snapshotParams.format.rawValue}","base64":"$base64"}""") - } - MoltbotCanvasA2UICommand.Reset.rawValue -> { - val a2uiUrl = resolveA2uiHostUrl() - ?: return GatewaySession.InvokeResult.error( - code = "A2UI_HOST_NOT_CONFIGURED", - message = "A2UI_HOST_NOT_CONFIGURED: gateway did not advertise canvas host", - ) - val ready = ensureA2uiReady(a2uiUrl) - if (!ready) { - return GatewaySession.InvokeResult.error( - code = "A2UI_HOST_UNAVAILABLE", - message = "A2UI host not reachable", - ) - } - val res = canvas.eval(a2uiResetJS) - GatewaySession.InvokeResult.ok(res) - } - MoltbotCanvasA2UICommand.Push.rawValue, MoltbotCanvasA2UICommand.PushJSONL.rawValue -> { - val messages = - try { - decodeA2uiMessages(command, paramsJson) - } catch (err: Throwable) { - return GatewaySession.InvokeResult.error(code = "INVALID_REQUEST", message = err.message ?: "invalid A2UI payload") - } - val a2uiUrl = resolveA2uiHostUrl() - ?: return GatewaySession.InvokeResult.error( - code = "A2UI_HOST_NOT_CONFIGURED", - message = "A2UI_HOST_NOT_CONFIGURED: gateway did not advertise canvas host", - ) - val ready = ensureA2uiReady(a2uiUrl) - if (!ready) { - return GatewaySession.InvokeResult.error( - code = "A2UI_HOST_UNAVAILABLE", - message = "A2UI host not reachable", - ) - } - val js = a2uiApplyMessagesJS(messages) - val res = canvas.eval(js) - GatewaySession.InvokeResult.ok(res) - } - MoltbotCameraCommand.Snap.rawValue -> { - showCameraHud(message = "Taking photo…", kind = CameraHudKind.Photo) - triggerCameraFlash() - val res = - try { - camera.snap(paramsJson) - } catch (err: Throwable) { - val (code, message) = invokeErrorFromThrowable(err) - showCameraHud(message = message, kind = CameraHudKind.Error, autoHideMs = 2200) - return GatewaySession.InvokeResult.error(code = code, message = message) - } - showCameraHud(message = "Photo captured", kind = CameraHudKind.Success, autoHideMs = 1600) - GatewaySession.InvokeResult.ok(res.payloadJson) - } - MoltbotCameraCommand.Clip.rawValue -> { - val includeAudio = paramsJson?.contains("\"includeAudio\":true") != false - if (includeAudio) externalAudioCaptureActive.value = true - try { - showCameraHud(message = "Recording…", kind = CameraHudKind.Recording) - val res = - try { - camera.clip(paramsJson) - } catch (err: Throwable) { - val (code, message) = invokeErrorFromThrowable(err) - showCameraHud(message = message, kind = CameraHudKind.Error, autoHideMs = 2400) - return GatewaySession.InvokeResult.error(code = code, message = message) - } - showCameraHud(message = "Clip captured", kind = CameraHudKind.Success, autoHideMs = 1800) - GatewaySession.InvokeResult.ok(res.payloadJson) - } finally { - if (includeAudio) externalAudioCaptureActive.value = false - } - } - MoltbotLocationCommand.Get.rawValue -> { - val mode = locationMode.value - if (!isForeground.value && mode != LocationMode.Always) { - return GatewaySession.InvokeResult.error( - code = "LOCATION_BACKGROUND_UNAVAILABLE", - message = "LOCATION_BACKGROUND_UNAVAILABLE: background location requires Always", - ) - } - if (!hasFineLocationPermission() && !hasCoarseLocationPermission()) { - return GatewaySession.InvokeResult.error( - code = "LOCATION_PERMISSION_REQUIRED", - message = "LOCATION_PERMISSION_REQUIRED: grant Location permission", - ) - } - if (!isForeground.value && mode == LocationMode.Always && !hasBackgroundLocationPermission()) { - return GatewaySession.InvokeResult.error( - code = "LOCATION_PERMISSION_REQUIRED", - message = "LOCATION_PERMISSION_REQUIRED: enable Always in system Settings", - ) - } - val (maxAgeMs, timeoutMs, desiredAccuracy) = parseLocationParams(paramsJson) - val preciseEnabled = locationPreciseEnabled.value - val accuracy = - when (desiredAccuracy) { - "precise" -> if (preciseEnabled && hasFineLocationPermission()) "precise" else "balanced" - "coarse" -> "coarse" - else -> if (preciseEnabled && hasFineLocationPermission()) "precise" else "balanced" - } - val providers = - when (accuracy) { - "precise" -> listOf(LocationManager.GPS_PROVIDER, LocationManager.NETWORK_PROVIDER) - "coarse" -> listOf(LocationManager.NETWORK_PROVIDER, LocationManager.GPS_PROVIDER) - else -> listOf(LocationManager.NETWORK_PROVIDER, LocationManager.GPS_PROVIDER) - } - try { - val payload = - location.getLocation( - desiredProviders = providers, - maxAgeMs = maxAgeMs, - timeoutMs = timeoutMs, - isPrecise = accuracy == "precise", - ) - GatewaySession.InvokeResult.ok(payload.payloadJson) - } catch (err: TimeoutCancellationException) { - GatewaySession.InvokeResult.error( - code = "LOCATION_TIMEOUT", - message = "LOCATION_TIMEOUT: no fix in time", - ) - } catch (err: Throwable) { - val message = err.message ?: "LOCATION_UNAVAILABLE: no fix" - GatewaySession.InvokeResult.error(code = "LOCATION_UNAVAILABLE", message = message) - } - } - MoltbotScreenCommand.Record.rawValue -> { - // Status pill mirrors screen recording state so it stays visible without overlay stacking. - _screenRecordActive.value = true - try { - val res = - try { - screenRecorder.record(paramsJson) - } catch (err: Throwable) { - val (code, message) = invokeErrorFromThrowable(err) - return GatewaySession.InvokeResult.error(code = code, message = message) - } - GatewaySession.InvokeResult.ok(res.payloadJson) - } finally { - _screenRecordActive.value = false - } - } - MoltbotSmsCommand.Send.rawValue -> { - val res = sms.send(paramsJson) - if (res.ok) { - GatewaySession.InvokeResult.ok(res.payloadJson) - } else { - val error = res.error ?: "SMS_SEND_FAILED" - val idx = error.indexOf(':') - val code = if (idx > 0) error.substring(0, idx).trim() else "SMS_SEND_FAILED" - GatewaySession.InvokeResult.error(code = code, message = error) - } - } - else -> - GatewaySession.InvokeResult.error( - code = "INVALID_REQUEST", - message = "INVALID_REQUEST: unknown command", - ) - } - } - - private fun triggerCameraFlash() { - // Token is used as a pulse trigger; value doesn't matter as long as it changes. - _cameraFlashToken.value = SystemClock.elapsedRealtimeNanos() - } - - private fun showCameraHud(message: String, kind: CameraHudKind, autoHideMs: Long? = null) { - val token = cameraHudSeq.incrementAndGet() - _cameraHud.value = CameraHudState(token = token, kind = kind, message = message) - - if (autoHideMs != null && autoHideMs > 0) { - scope.launch { - delay(autoHideMs) - if (_cameraHud.value?.token == token) _cameraHud.value = null - } - } - } - - private fun invokeErrorFromThrowable(err: Throwable): Pair { - val raw = (err.message ?: "").trim() - if (raw.isEmpty()) return "UNAVAILABLE" to "UNAVAILABLE: camera error" - - val idx = raw.indexOf(':') - if (idx <= 0) return "UNAVAILABLE" to raw - val code = raw.substring(0, idx).trim().ifEmpty { "UNAVAILABLE" } - val message = raw.substring(idx + 1).trim().ifEmpty { raw } - // Preserve full string for callers/logging, but keep the returned message human-friendly. - return code to "$code: $message" - } - - private fun parseLocationParams(paramsJson: String?): Triple { - if (paramsJson.isNullOrBlank()) { - return Triple(null, 10_000L, null) - } - val root = - try { - json.parseToJsonElement(paramsJson).asObjectOrNull() - } catch (_: Throwable) { - null - } - val maxAgeMs = (root?.get("maxAgeMs") as? JsonPrimitive)?.content?.toLongOrNull() - val timeoutMs = - (root?.get("timeoutMs") as? JsonPrimitive)?.content?.toLongOrNull()?.coerceIn(1_000L, 60_000L) - ?: 10_000L - val desiredAccuracy = - (root?.get("desiredAccuracy") as? JsonPrimitive)?.content?.trim()?.lowercase() - return Triple(maxAgeMs, timeoutMs, desiredAccuracy) - } - - private fun resolveA2uiHostUrl(): String? { - val nodeRaw = nodeSession.currentCanvasHostUrl()?.trim().orEmpty() - val operatorRaw = operatorSession.currentCanvasHostUrl()?.trim().orEmpty() - val raw = if (nodeRaw.isNotBlank()) nodeRaw else operatorRaw - if (raw.isBlank()) return null - val base = raw.trimEnd('/') - return "${base}/__moltbot__/a2ui/?platform=android" - } - - private suspend fun ensureA2uiReady(a2uiUrl: String): Boolean { - try { - val already = canvas.eval(a2uiReadyCheckJS) - if (already == "true") return true - } catch (_: Throwable) { - // ignore - } - - canvas.navigate(a2uiUrl) - repeat(50) { - try { - val ready = canvas.eval(a2uiReadyCheckJS) - if (ready == "true") return true - } catch (_: Throwable) { - // ignore - } - delay(120) - } - return false - } - - private fun decodeA2uiMessages(command: String, paramsJson: String?): String { - val raw = paramsJson?.trim().orEmpty() - if (raw.isBlank()) throw IllegalArgumentException("INVALID_REQUEST: paramsJSON required") - - val obj = - json.parseToJsonElement(raw) as? JsonObject - ?: throw IllegalArgumentException("INVALID_REQUEST: expected object params") - - val jsonlField = (obj["jsonl"] as? JsonPrimitive)?.content?.trim().orEmpty() - val hasMessagesArray = obj["messages"] is JsonArray - - if (command == MoltbotCanvasA2UICommand.PushJSONL.rawValue || (!hasMessagesArray && jsonlField.isNotBlank())) { - val jsonl = jsonlField - if (jsonl.isBlank()) throw IllegalArgumentException("INVALID_REQUEST: jsonl required") - val messages = - jsonl - .lineSequence() - .map { it.trim() } - .filter { it.isNotBlank() } - .mapIndexed { idx, line -> - val el = json.parseToJsonElement(line) - val msg = - el as? JsonObject - ?: throw IllegalArgumentException("A2UI JSONL line ${idx + 1}: expected a JSON object") - validateA2uiV0_8(msg, idx + 1) - msg - } - .toList() - return JsonArray(messages).toString() - } - - val arr = obj["messages"] as? JsonArray ?: throw IllegalArgumentException("INVALID_REQUEST: messages[] required") - val out = - arr.mapIndexed { idx, el -> - val msg = - el as? JsonObject - ?: throw IllegalArgumentException("A2UI messages[${idx}]: expected a JSON object") - validateA2uiV0_8(msg, idx + 1) - msg - } - return JsonArray(out).toString() - } - - private fun validateA2uiV0_8(msg: JsonObject, lineNumber: Int) { - if (msg.containsKey("createSurface")) { - throw IllegalArgumentException( - "A2UI JSONL line $lineNumber: looks like A2UI v0.9 (`createSurface`). Canvas supports v0.8 messages only.", - ) - } - val allowed = setOf("beginRendering", "surfaceUpdate", "dataModelUpdate", "deleteSurface") - val matched = msg.keys.filter { allowed.contains(it) } - if (matched.size != 1) { - val found = msg.keys.sorted().joinToString(", ") - throw IllegalArgumentException( - "A2UI JSONL line $lineNumber: expected exactly one of ${allowed.sorted().joinToString(", ")}; found: $found", - ) - } - } -} - -private data class Quad(val first: A, val second: B, val third: C, val fourth: D) - -private const val DEFAULT_SEAM_COLOR_ARGB: Long = 0xFF4F7A9A - -private const val a2uiReadyCheckJS: String = - """ - (() => { - try { - return !!globalThis.clawdbotA2UI && typeof globalThis.clawdbotA2UI.applyMessages === 'function'; - } catch (_) { - return false; - } - })() - """ - -private const val a2uiResetJS: String = - """ - (() => { - try { - if (!globalThis.clawdbotA2UI) return { ok: false, error: "missing moltbotA2UI" }; - return globalThis.clawdbotA2UI.reset(); - } catch (e) { - return { ok: false, error: String(e?.message ?? e) }; - } - })() - """ - -private fun a2uiApplyMessagesJS(messagesJson: String): String { - return """ - (() => { - try { - if (!globalThis.clawdbotA2UI) return { ok: false, error: "missing moltbotA2UI" }; - const messages = $messagesJson; - return globalThis.clawdbotA2UI.applyMessages(messages); - } catch (e) { - return { ok: false, error: String(e?.message ?? e) }; - } - })() - """.trimIndent() -} - -private fun String.toJsonString(): String { - val escaped = - this.replace("\\", "\\\\") - .replace("\"", "\\\"") - .replace("\n", "\\n") - .replace("\r", "\\r") - return "\"$escaped\"" -} - -private fun JsonElement?.asObjectOrNull(): JsonObject? = this as? JsonObject - -private fun JsonElement?.asStringOrNull(): String? = - when (this) { - is JsonNull -> null - is JsonPrimitive -> content - else -> null - } - -private fun parseHexColorArgb(raw: String?): Long? { - val trimmed = raw?.trim().orEmpty() - if (trimmed.isEmpty()) return null - val hex = if (trimmed.startsWith("#")) trimmed.drop(1) else trimmed - if (hex.length != 6) return null - val rgb = hex.toLongOrNull(16) ?: return null - return 0xFF000000L or rgb -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/PermissionRequester.kt b/apps/android/app/src/main/java/com/clawdbot/android/PermissionRequester.kt deleted file mode 100644 index 5e95d7b27..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/PermissionRequester.kt +++ /dev/null @@ -1,133 +0,0 @@ -package com.clawdbot.android - -import android.content.pm.PackageManager -import android.content.Intent -import android.Manifest -import android.net.Uri -import android.provider.Settings -import androidx.appcompat.app.AlertDialog -import androidx.activity.ComponentActivity -import androidx.activity.result.ActivityResultLauncher -import androidx.activity.result.contract.ActivityResultContracts -import androidx.core.content.ContextCompat -import androidx.core.app.ActivityCompat -import kotlinx.coroutines.CompletableDeferred -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.sync.Mutex -import kotlinx.coroutines.sync.withLock -import kotlinx.coroutines.withContext -import kotlinx.coroutines.suspendCancellableCoroutine -import kotlin.coroutines.resume - -class PermissionRequester(private val activity: ComponentActivity) { - private val mutex = Mutex() - private var pending: CompletableDeferred>? = null - - private val launcher: ActivityResultLauncher> = - activity.registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { result -> - val p = pending - pending = null - p?.complete(result) - } - - suspend fun requestIfMissing( - permissions: List, - timeoutMs: Long = 20_000, - ): Map = - mutex.withLock { - val missing = - permissions.filter { perm -> - ContextCompat.checkSelfPermission(activity, perm) != PackageManager.PERMISSION_GRANTED - } - if (missing.isEmpty()) { - return permissions.associateWith { true } - } - - val needsRationale = - missing.any { ActivityCompat.shouldShowRequestPermissionRationale(activity, it) } - if (needsRationale) { - val proceed = showRationaleDialog(missing) - if (!proceed) { - return permissions.associateWith { perm -> - ContextCompat.checkSelfPermission(activity, perm) == PackageManager.PERMISSION_GRANTED - } - } - } - - val deferred = CompletableDeferred>() - pending = deferred - withContext(Dispatchers.Main) { - launcher.launch(missing.toTypedArray()) - } - - val result = - withContext(Dispatchers.Default) { - kotlinx.coroutines.withTimeout(timeoutMs) { deferred.await() } - } - - // Merge: if something was already granted, treat it as granted even if launcher omitted it. - val merged = - permissions.associateWith { perm -> - val nowGranted = - ContextCompat.checkSelfPermission(activity, perm) == PackageManager.PERMISSION_GRANTED - result[perm] == true || nowGranted - } - - val denied = - merged.filterValues { !it }.keys.filter { - !ActivityCompat.shouldShowRequestPermissionRationale(activity, it) - } - if (denied.isNotEmpty()) { - showSettingsDialog(denied) - } - - return merged - } - - private suspend fun showRationaleDialog(permissions: List): Boolean = - withContext(Dispatchers.Main) { - suspendCancellableCoroutine { cont -> - AlertDialog.Builder(activity) - .setTitle("Permission required") - .setMessage(buildRationaleMessage(permissions)) - .setPositiveButton("Continue") { _, _ -> cont.resume(true) } - .setNegativeButton("Not now") { _, _ -> cont.resume(false) } - .setOnCancelListener { cont.resume(false) } - .show() - } - } - - private fun showSettingsDialog(permissions: List) { - AlertDialog.Builder(activity) - .setTitle("Enable permission in Settings") - .setMessage(buildSettingsMessage(permissions)) - .setPositiveButton("Open Settings") { _, _ -> - val intent = - Intent( - Settings.ACTION_APPLICATION_DETAILS_SETTINGS, - Uri.fromParts("package", activity.packageName, null), - ) - activity.startActivity(intent) - } - .setNegativeButton("Cancel", null) - .show() - } - - private fun buildRationaleMessage(permissions: List): String { - val labels = permissions.map { permissionLabel(it) } - return "Moltbot needs ${labels.joinToString(", ")} permissions to continue." - } - - private fun buildSettingsMessage(permissions: List): String { - val labels = permissions.map { permissionLabel(it) } - return "Please enable ${labels.joinToString(", ")} in Android Settings to continue." - } - - private fun permissionLabel(permission: String): String = - when (permission) { - Manifest.permission.CAMERA -> "Camera" - Manifest.permission.RECORD_AUDIO -> "Microphone" - Manifest.permission.SEND_SMS -> "SMS" - else -> permission - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ScreenCaptureRequester.kt b/apps/android/app/src/main/java/com/clawdbot/android/ScreenCaptureRequester.kt deleted file mode 100644 index f7cf6708c..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ScreenCaptureRequester.kt +++ /dev/null @@ -1,65 +0,0 @@ -package com.clawdbot.android - -import android.app.Activity -import android.content.Context -import android.content.Intent -import android.media.projection.MediaProjectionManager -import androidx.activity.ComponentActivity -import androidx.activity.result.ActivityResultLauncher -import androidx.activity.result.contract.ActivityResultContracts -import androidx.appcompat.app.AlertDialog -import kotlinx.coroutines.CompletableDeferred -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.sync.Mutex -import kotlinx.coroutines.sync.withLock -import kotlinx.coroutines.withContext -import kotlinx.coroutines.withTimeout -import kotlinx.coroutines.suspendCancellableCoroutine -import kotlin.coroutines.resume - -class ScreenCaptureRequester(private val activity: ComponentActivity) { - data class CaptureResult(val resultCode: Int, val data: Intent) - - private val mutex = Mutex() - private var pending: CompletableDeferred? = null - - private val launcher: ActivityResultLauncher = - activity.registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result -> - val p = pending - pending = null - val data = result.data - if (result.resultCode == Activity.RESULT_OK && data != null) { - p?.complete(CaptureResult(result.resultCode, data)) - } else { - p?.complete(null) - } - } - - suspend fun requestCapture(timeoutMs: Long = 20_000): CaptureResult? = - mutex.withLock { - val proceed = showRationaleDialog() - if (!proceed) return null - - val mgr = activity.getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager - val intent = mgr.createScreenCaptureIntent() - - val deferred = CompletableDeferred() - pending = deferred - withContext(Dispatchers.Main) { launcher.launch(intent) } - - withContext(Dispatchers.Default) { withTimeout(timeoutMs) { deferred.await() } } - } - - private suspend fun showRationaleDialog(): Boolean = - withContext(Dispatchers.Main) { - suspendCancellableCoroutine { cont -> - AlertDialog.Builder(activity) - .setTitle("Screen recording required") - .setMessage("Moltbot needs to record the screen for this command.") - .setPositiveButton("Continue") { _, _ -> cont.resume(true) } - .setNegativeButton("Not now") { _, _ -> cont.resume(false) } - .setOnCancelListener { cont.resume(false) } - .show() - } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/SecurePrefs.kt b/apps/android/app/src/main/java/com/clawdbot/android/SecurePrefs.kt deleted file mode 100644 index 1c464f961..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/SecurePrefs.kt +++ /dev/null @@ -1,308 +0,0 @@ -@file:Suppress("DEPRECATION") - -package com.clawdbot.android - -import android.content.Context -import androidx.core.content.edit -import androidx.security.crypto.EncryptedSharedPreferences -import androidx.security.crypto.MasterKey -import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.flow.StateFlow -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonArray -import kotlinx.serialization.json.JsonNull -import kotlinx.serialization.json.JsonPrimitive -import java.util.UUID - -class SecurePrefs(context: Context) { - companion object { - val defaultWakeWords: List = listOf("clawd", "claude") - private const val displayNameKey = "node.displayName" - private const val voiceWakeModeKey = "voiceWake.mode" - } - - private val json = Json { ignoreUnknownKeys = true } - - private val masterKey = - MasterKey.Builder(context) - .setKeyScheme(MasterKey.KeyScheme.AES256_GCM) - .build() - - private val prefs = - EncryptedSharedPreferences.create( - context, - "moltbot.node.secure", - masterKey, - EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV, - EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM, - ) - - private val _instanceId = MutableStateFlow(loadOrCreateInstanceId()) - val instanceId: StateFlow = _instanceId - - private val _displayName = - MutableStateFlow(loadOrMigrateDisplayName(context = context)) - val displayName: StateFlow = _displayName - - private val _cameraEnabled = MutableStateFlow(prefs.getBoolean("camera.enabled", true)) - val cameraEnabled: StateFlow = _cameraEnabled - - private val _locationMode = - MutableStateFlow(LocationMode.fromRawValue(prefs.getString("location.enabledMode", "off"))) - val locationMode: StateFlow = _locationMode - - private val _locationPreciseEnabled = - MutableStateFlow(prefs.getBoolean("location.preciseEnabled", true)) - val locationPreciseEnabled: StateFlow = _locationPreciseEnabled - - private val _preventSleep = MutableStateFlow(prefs.getBoolean("screen.preventSleep", true)) - val preventSleep: StateFlow = _preventSleep - - private val _manualEnabled = - MutableStateFlow(readBoolWithMigration("gateway.manual.enabled", "bridge.manual.enabled", false)) - val manualEnabled: StateFlow = _manualEnabled - - private val _manualHost = - MutableStateFlow(readStringWithMigration("gateway.manual.host", "bridge.manual.host", "")) - val manualHost: StateFlow = _manualHost - - private val _manualPort = - MutableStateFlow(readIntWithMigration("gateway.manual.port", "bridge.manual.port", 18789)) - val manualPort: StateFlow = _manualPort - - private val _manualTls = - MutableStateFlow(readBoolWithMigration("gateway.manual.tls", null, true)) - val manualTls: StateFlow = _manualTls - - private val _lastDiscoveredStableId = - MutableStateFlow( - readStringWithMigration( - "gateway.lastDiscoveredStableID", - "bridge.lastDiscoveredStableId", - "", - ), - ) - val lastDiscoveredStableId: StateFlow = _lastDiscoveredStableId - - private val _canvasDebugStatusEnabled = - MutableStateFlow(prefs.getBoolean("canvas.debugStatusEnabled", false)) - val canvasDebugStatusEnabled: StateFlow = _canvasDebugStatusEnabled - - private val _wakeWords = MutableStateFlow(loadWakeWords()) - val wakeWords: StateFlow> = _wakeWords - - private val _voiceWakeMode = MutableStateFlow(loadVoiceWakeMode()) - val voiceWakeMode: StateFlow = _voiceWakeMode - - private val _talkEnabled = MutableStateFlow(prefs.getBoolean("talk.enabled", false)) - val talkEnabled: StateFlow = _talkEnabled - - fun setLastDiscoveredStableId(value: String) { - val trimmed = value.trim() - prefs.edit { putString("gateway.lastDiscoveredStableID", trimmed) } - _lastDiscoveredStableId.value = trimmed - } - - fun setDisplayName(value: String) { - val trimmed = value.trim() - prefs.edit { putString(displayNameKey, trimmed) } - _displayName.value = trimmed - } - - fun setCameraEnabled(value: Boolean) { - prefs.edit { putBoolean("camera.enabled", value) } - _cameraEnabled.value = value - } - - fun setLocationMode(mode: LocationMode) { - prefs.edit { putString("location.enabledMode", mode.rawValue) } - _locationMode.value = mode - } - - fun setLocationPreciseEnabled(value: Boolean) { - prefs.edit { putBoolean("location.preciseEnabled", value) } - _locationPreciseEnabled.value = value - } - - fun setPreventSleep(value: Boolean) { - prefs.edit { putBoolean("screen.preventSleep", value) } - _preventSleep.value = value - } - - fun setManualEnabled(value: Boolean) { - prefs.edit { putBoolean("gateway.manual.enabled", value) } - _manualEnabled.value = value - } - - fun setManualHost(value: String) { - val trimmed = value.trim() - prefs.edit { putString("gateway.manual.host", trimmed) } - _manualHost.value = trimmed - } - - fun setManualPort(value: Int) { - prefs.edit { putInt("gateway.manual.port", value) } - _manualPort.value = value - } - - fun setManualTls(value: Boolean) { - prefs.edit { putBoolean("gateway.manual.tls", value) } - _manualTls.value = value - } - - fun setCanvasDebugStatusEnabled(value: Boolean) { - prefs.edit { putBoolean("canvas.debugStatusEnabled", value) } - _canvasDebugStatusEnabled.value = value - } - - fun loadGatewayToken(): String? { - val key = "gateway.token.${_instanceId.value}" - val stored = prefs.getString(key, null)?.trim() - if (!stored.isNullOrEmpty()) return stored - val legacy = prefs.getString("bridge.token.${_instanceId.value}", null)?.trim() - return legacy?.takeIf { it.isNotEmpty() } - } - - fun saveGatewayToken(token: String) { - val key = "gateway.token.${_instanceId.value}" - prefs.edit { putString(key, token.trim()) } - } - - fun loadGatewayPassword(): String? { - val key = "gateway.password.${_instanceId.value}" - val stored = prefs.getString(key, null)?.trim() - return stored?.takeIf { it.isNotEmpty() } - } - - fun saveGatewayPassword(password: String) { - val key = "gateway.password.${_instanceId.value}" - prefs.edit { putString(key, password.trim()) } - } - - fun loadGatewayTlsFingerprint(stableId: String): String? { - val key = "gateway.tls.$stableId" - return prefs.getString(key, null)?.trim()?.takeIf { it.isNotEmpty() } - } - - fun saveGatewayTlsFingerprint(stableId: String, fingerprint: String) { - val key = "gateway.tls.$stableId" - prefs.edit { putString(key, fingerprint.trim()) } - } - - fun getString(key: String): String? { - return prefs.getString(key, null) - } - - fun putString(key: String, value: String) { - prefs.edit { putString(key, value) } - } - - fun remove(key: String) { - prefs.edit { remove(key) } - } - - private fun loadOrCreateInstanceId(): String { - val existing = prefs.getString("node.instanceId", null)?.trim() - if (!existing.isNullOrBlank()) return existing - val fresh = UUID.randomUUID().toString() - prefs.edit { putString("node.instanceId", fresh) } - return fresh - } - - private fun loadOrMigrateDisplayName(context: Context): String { - val existing = prefs.getString(displayNameKey, null)?.trim().orEmpty() - if (existing.isNotEmpty() && existing != "Android Node") return existing - - val candidate = DeviceNames.bestDefaultNodeName(context).trim() - val resolved = candidate.ifEmpty { "Android Node" } - - prefs.edit { putString(displayNameKey, resolved) } - return resolved - } - - fun setWakeWords(words: List) { - val sanitized = WakeWords.sanitize(words, defaultWakeWords) - val encoded = - JsonArray(sanitized.map { JsonPrimitive(it) }).toString() - prefs.edit { putString("voiceWake.triggerWords", encoded) } - _wakeWords.value = sanitized - } - - fun setVoiceWakeMode(mode: VoiceWakeMode) { - prefs.edit { putString(voiceWakeModeKey, mode.rawValue) } - _voiceWakeMode.value = mode - } - - fun setTalkEnabled(value: Boolean) { - prefs.edit { putBoolean("talk.enabled", value) } - _talkEnabled.value = value - } - - private fun loadVoiceWakeMode(): VoiceWakeMode { - val raw = prefs.getString(voiceWakeModeKey, null) - val resolved = VoiceWakeMode.fromRawValue(raw) - - // Default ON (foreground) when unset. - if (raw.isNullOrBlank()) { - prefs.edit { putString(voiceWakeModeKey, resolved.rawValue) } - } - - return resolved - } - - private fun loadWakeWords(): List { - val raw = prefs.getString("voiceWake.triggerWords", null)?.trim() - if (raw.isNullOrEmpty()) return defaultWakeWords - return try { - val element = json.parseToJsonElement(raw) - val array = element as? JsonArray ?: return defaultWakeWords - val decoded = - array.mapNotNull { item -> - when (item) { - is JsonNull -> null - is JsonPrimitive -> item.content.trim().takeIf { it.isNotEmpty() } - else -> null - } - } - WakeWords.sanitize(decoded, defaultWakeWords) - } catch (_: Throwable) { - defaultWakeWords - } - } - - private fun readBoolWithMigration(newKey: String, oldKey: String?, defaultValue: Boolean): Boolean { - if (prefs.contains(newKey)) { - return prefs.getBoolean(newKey, defaultValue) - } - if (oldKey != null && prefs.contains(oldKey)) { - val value = prefs.getBoolean(oldKey, defaultValue) - prefs.edit { putBoolean(newKey, value) } - return value - } - return defaultValue - } - - private fun readStringWithMigration(newKey: String, oldKey: String?, defaultValue: String): String { - if (prefs.contains(newKey)) { - return prefs.getString(newKey, defaultValue) ?: defaultValue - } - if (oldKey != null && prefs.contains(oldKey)) { - val value = prefs.getString(oldKey, defaultValue) ?: defaultValue - prefs.edit { putString(newKey, value) } - return value - } - return defaultValue - } - - private fun readIntWithMigration(newKey: String, oldKey: String?, defaultValue: Int): Int { - if (prefs.contains(newKey)) { - return prefs.getInt(newKey, defaultValue) - } - if (oldKey != null && prefs.contains(oldKey)) { - val value = prefs.getInt(oldKey, defaultValue) - prefs.edit { putInt(newKey, value) } - return value - } - return defaultValue - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/SessionKey.kt b/apps/android/app/src/main/java/com/clawdbot/android/SessionKey.kt deleted file mode 100644 index e1aae9ec0..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/SessionKey.kt +++ /dev/null @@ -1,13 +0,0 @@ -package com.clawdbot.android - -internal fun normalizeMainKey(raw: String?): String { - val trimmed = raw?.trim() - return if (!trimmed.isNullOrEmpty()) trimmed else "main" -} - -internal fun isCanonicalMainSessionKey(raw: String?): Boolean { - val trimmed = raw?.trim().orEmpty() - if (trimmed.isEmpty()) return false - if (trimmed == "global") return true - return trimmed.startsWith("agent:") -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/VoiceWakeMode.kt b/apps/android/app/src/main/java/com/clawdbot/android/VoiceWakeMode.kt deleted file mode 100644 index 6c3e2c201..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/VoiceWakeMode.kt +++ /dev/null @@ -1,14 +0,0 @@ -package com.clawdbot.android - -enum class VoiceWakeMode(val rawValue: String) { - Off("off"), - Foreground("foreground"), - Always("always"), - ; - - companion object { - fun fromRawValue(raw: String?): VoiceWakeMode { - return entries.firstOrNull { it.rawValue == raw?.trim()?.lowercase() } ?: Foreground - } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/WakeWords.kt b/apps/android/app/src/main/java/com/clawdbot/android/WakeWords.kt deleted file mode 100644 index d54ed1e08..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/WakeWords.kt +++ /dev/null @@ -1,21 +0,0 @@ -package com.clawdbot.android - -object WakeWords { - const val maxWords: Int = 32 - const val maxWordLength: Int = 64 - - fun parseCommaSeparated(input: String): List { - return input.split(",").map { it.trim() }.filter { it.isNotEmpty() } - } - - fun parseIfChanged(input: String, current: List): List? { - val parsed = parseCommaSeparated(input) - return if (parsed == current) null else parsed - } - - fun sanitize(words: List, defaults: List): List { - val cleaned = - words.map { it.trim() }.filter { it.isNotEmpty() }.take(maxWords).map { it.take(maxWordLength) } - return cleaned.ifEmpty { defaults } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/chat/ChatController.kt b/apps/android/app/src/main/java/com/clawdbot/android/chat/ChatController.kt deleted file mode 100644 index a8e64048c..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/chat/ChatController.kt +++ /dev/null @@ -1,524 +0,0 @@ -package com.clawdbot.android.chat - -import com.clawdbot.android.gateway.GatewaySession -import java.util.UUID -import java.util.concurrent.ConcurrentHashMap -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Job -import kotlinx.coroutines.delay -import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.flow.StateFlow -import kotlinx.coroutines.flow.asStateFlow -import kotlinx.coroutines.launch -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonArray -import kotlinx.serialization.json.JsonElement -import kotlinx.serialization.json.JsonNull -import kotlinx.serialization.json.JsonObject -import kotlinx.serialization.json.JsonPrimitive -import kotlinx.serialization.json.buildJsonObject - -class ChatController( - private val scope: CoroutineScope, - private val session: GatewaySession, - private val json: Json, - private val supportsChatSubscribe: Boolean, -) { - private val _sessionKey = MutableStateFlow("main") - val sessionKey: StateFlow = _sessionKey.asStateFlow() - - private val _sessionId = MutableStateFlow(null) - val sessionId: StateFlow = _sessionId.asStateFlow() - - private val _messages = MutableStateFlow>(emptyList()) - val messages: StateFlow> = _messages.asStateFlow() - - private val _errorText = MutableStateFlow(null) - val errorText: StateFlow = _errorText.asStateFlow() - - private val _healthOk = MutableStateFlow(false) - val healthOk: StateFlow = _healthOk.asStateFlow() - - private val _thinkingLevel = MutableStateFlow("off") - val thinkingLevel: StateFlow = _thinkingLevel.asStateFlow() - - private val _pendingRunCount = MutableStateFlow(0) - val pendingRunCount: StateFlow = _pendingRunCount.asStateFlow() - - private val _streamingAssistantText = MutableStateFlow(null) - val streamingAssistantText: StateFlow = _streamingAssistantText.asStateFlow() - - private val pendingToolCallsById = ConcurrentHashMap() - private val _pendingToolCalls = MutableStateFlow>(emptyList()) - val pendingToolCalls: StateFlow> = _pendingToolCalls.asStateFlow() - - private val _sessions = MutableStateFlow>(emptyList()) - val sessions: StateFlow> = _sessions.asStateFlow() - - private val pendingRuns = mutableSetOf() - private val pendingRunTimeoutJobs = ConcurrentHashMap() - private val pendingRunTimeoutMs = 120_000L - - private var lastHealthPollAtMs: Long? = null - - fun onDisconnected(message: String) { - _healthOk.value = false - // Not an error; keep connection status in the UI pill. - _errorText.value = null - clearPendingRuns() - pendingToolCallsById.clear() - publishPendingToolCalls() - _streamingAssistantText.value = null - _sessionId.value = null - } - - fun load(sessionKey: String) { - val key = sessionKey.trim().ifEmpty { "main" } - _sessionKey.value = key - scope.launch { bootstrap(forceHealth = true) } - } - - fun applyMainSessionKey(mainSessionKey: String) { - val trimmed = mainSessionKey.trim() - if (trimmed.isEmpty()) return - if (_sessionKey.value == trimmed) return - if (_sessionKey.value != "main") return - _sessionKey.value = trimmed - scope.launch { bootstrap(forceHealth = true) } - } - - fun refresh() { - scope.launch { bootstrap(forceHealth = true) } - } - - fun refreshSessions(limit: Int? = null) { - scope.launch { fetchSessions(limit = limit) } - } - - fun setThinkingLevel(thinkingLevel: String) { - val normalized = normalizeThinking(thinkingLevel) - if (normalized == _thinkingLevel.value) return - _thinkingLevel.value = normalized - } - - fun switchSession(sessionKey: String) { - val key = sessionKey.trim() - if (key.isEmpty()) return - if (key == _sessionKey.value) return - _sessionKey.value = key - scope.launch { bootstrap(forceHealth = true) } - } - - fun sendMessage( - message: String, - thinkingLevel: String, - attachments: List, - ) { - val trimmed = message.trim() - if (trimmed.isEmpty() && attachments.isEmpty()) return - if (!_healthOk.value) { - _errorText.value = "Gateway health not OK; cannot send" - return - } - - val runId = UUID.randomUUID().toString() - val text = if (trimmed.isEmpty() && attachments.isNotEmpty()) "See attached." else trimmed - val sessionKey = _sessionKey.value - val thinking = normalizeThinking(thinkingLevel) - - // Optimistic user message. - val userContent = - buildList { - add(ChatMessageContent(type = "text", text = text)) - for (att in attachments) { - add( - ChatMessageContent( - type = att.type, - mimeType = att.mimeType, - fileName = att.fileName, - base64 = att.base64, - ), - ) - } - } - _messages.value = - _messages.value + - ChatMessage( - id = UUID.randomUUID().toString(), - role = "user", - content = userContent, - timestampMs = System.currentTimeMillis(), - ) - - armPendingRunTimeout(runId) - synchronized(pendingRuns) { - pendingRuns.add(runId) - _pendingRunCount.value = pendingRuns.size - } - - _errorText.value = null - _streamingAssistantText.value = null - pendingToolCallsById.clear() - publishPendingToolCalls() - - scope.launch { - try { - val params = - buildJsonObject { - put("sessionKey", JsonPrimitive(sessionKey)) - put("message", JsonPrimitive(text)) - put("thinking", JsonPrimitive(thinking)) - put("timeoutMs", JsonPrimitive(30_000)) - put("idempotencyKey", JsonPrimitive(runId)) - if (attachments.isNotEmpty()) { - put( - "attachments", - JsonArray( - attachments.map { att -> - buildJsonObject { - put("type", JsonPrimitive(att.type)) - put("mimeType", JsonPrimitive(att.mimeType)) - put("fileName", JsonPrimitive(att.fileName)) - put("content", JsonPrimitive(att.base64)) - } - }, - ), - ) - } - } - val res = session.request("chat.send", params.toString()) - val actualRunId = parseRunId(res) ?: runId - if (actualRunId != runId) { - clearPendingRun(runId) - armPendingRunTimeout(actualRunId) - synchronized(pendingRuns) { - pendingRuns.add(actualRunId) - _pendingRunCount.value = pendingRuns.size - } - } - } catch (err: Throwable) { - clearPendingRun(runId) - _errorText.value = err.message - } - } - } - - fun abort() { - val runIds = - synchronized(pendingRuns) { - pendingRuns.toList() - } - if (runIds.isEmpty()) return - scope.launch { - for (runId in runIds) { - try { - val params = - buildJsonObject { - put("sessionKey", JsonPrimitive(_sessionKey.value)) - put("runId", JsonPrimitive(runId)) - } - session.request("chat.abort", params.toString()) - } catch (_: Throwable) { - // best-effort - } - } - } - } - - fun handleGatewayEvent(event: String, payloadJson: String?) { - when (event) { - "tick" -> { - scope.launch { pollHealthIfNeeded(force = false) } - } - "health" -> { - // If we receive a health snapshot, the gateway is reachable. - _healthOk.value = true - } - "seqGap" -> { - _errorText.value = "Event stream interrupted; try refreshing." - clearPendingRuns() - } - "chat" -> { - if (payloadJson.isNullOrBlank()) return - handleChatEvent(payloadJson) - } - "agent" -> { - if (payloadJson.isNullOrBlank()) return - handleAgentEvent(payloadJson) - } - } - } - - private suspend fun bootstrap(forceHealth: Boolean) { - _errorText.value = null - _healthOk.value = false - clearPendingRuns() - pendingToolCallsById.clear() - publishPendingToolCalls() - _streamingAssistantText.value = null - _sessionId.value = null - - val key = _sessionKey.value - try { - if (supportsChatSubscribe) { - try { - session.sendNodeEvent("chat.subscribe", """{"sessionKey":"$key"}""") - } catch (_: Throwable) { - // best-effort - } - } - - val historyJson = session.request("chat.history", """{"sessionKey":"$key"}""") - val history = parseHistory(historyJson, sessionKey = key) - _messages.value = history.messages - _sessionId.value = history.sessionId - history.thinkingLevel?.trim()?.takeIf { it.isNotEmpty() }?.let { _thinkingLevel.value = it } - - pollHealthIfNeeded(force = forceHealth) - fetchSessions(limit = 50) - } catch (err: Throwable) { - _errorText.value = err.message - } - } - - private suspend fun fetchSessions(limit: Int?) { - try { - val params = - buildJsonObject { - put("includeGlobal", JsonPrimitive(true)) - put("includeUnknown", JsonPrimitive(false)) - if (limit != null && limit > 0) put("limit", JsonPrimitive(limit)) - } - val res = session.request("sessions.list", params.toString()) - _sessions.value = parseSessions(res) - } catch (_: Throwable) { - // best-effort - } - } - - private suspend fun pollHealthIfNeeded(force: Boolean) { - val now = System.currentTimeMillis() - val last = lastHealthPollAtMs - if (!force && last != null && now - last < 10_000) return - lastHealthPollAtMs = now - try { - session.request("health", null) - _healthOk.value = true - } catch (_: Throwable) { - _healthOk.value = false - } - } - - private fun handleChatEvent(payloadJson: String) { - val payload = json.parseToJsonElement(payloadJson).asObjectOrNull() ?: return - val sessionKey = payload["sessionKey"].asStringOrNull()?.trim() - if (!sessionKey.isNullOrEmpty() && sessionKey != _sessionKey.value) return - - val runId = payload["runId"].asStringOrNull() - if (runId != null) { - val isPending = - synchronized(pendingRuns) { - pendingRuns.contains(runId) - } - if (!isPending) return - } - - val state = payload["state"].asStringOrNull() - when (state) { - "final", "aborted", "error" -> { - if (state == "error") { - _errorText.value = payload["errorMessage"].asStringOrNull() ?: "Chat failed" - } - if (runId != null) clearPendingRun(runId) else clearPendingRuns() - pendingToolCallsById.clear() - publishPendingToolCalls() - _streamingAssistantText.value = null - scope.launch { - try { - val historyJson = - session.request("chat.history", """{"sessionKey":"${_sessionKey.value}"}""") - val history = parseHistory(historyJson, sessionKey = _sessionKey.value) - _messages.value = history.messages - _sessionId.value = history.sessionId - history.thinkingLevel?.trim()?.takeIf { it.isNotEmpty() }?.let { _thinkingLevel.value = it } - } catch (_: Throwable) { - // best-effort - } - } - } - } - } - - private fun handleAgentEvent(payloadJson: String) { - val payload = json.parseToJsonElement(payloadJson).asObjectOrNull() ?: return - val runId = payload["runId"].asStringOrNull() - val sessionId = _sessionId.value - if (sessionId != null && runId != sessionId) return - - val stream = payload["stream"].asStringOrNull() - val data = payload["data"].asObjectOrNull() - - when (stream) { - "assistant" -> { - val text = data?.get("text")?.asStringOrNull() - if (!text.isNullOrEmpty()) { - _streamingAssistantText.value = text - } - } - "tool" -> { - val phase = data?.get("phase")?.asStringOrNull() - val name = data?.get("name")?.asStringOrNull() - val toolCallId = data?.get("toolCallId")?.asStringOrNull() - if (phase.isNullOrEmpty() || name.isNullOrEmpty() || toolCallId.isNullOrEmpty()) return - - val ts = payload["ts"].asLongOrNull() ?: System.currentTimeMillis() - if (phase == "start") { - val args = data?.get("args").asObjectOrNull() - pendingToolCallsById[toolCallId] = - ChatPendingToolCall( - toolCallId = toolCallId, - name = name, - args = args, - startedAtMs = ts, - isError = null, - ) - publishPendingToolCalls() - } else if (phase == "result") { - pendingToolCallsById.remove(toolCallId) - publishPendingToolCalls() - } - } - "error" -> { - _errorText.value = "Event stream interrupted; try refreshing." - clearPendingRuns() - pendingToolCallsById.clear() - publishPendingToolCalls() - _streamingAssistantText.value = null - } - } - } - - private fun publishPendingToolCalls() { - _pendingToolCalls.value = - pendingToolCallsById.values.sortedBy { it.startedAtMs } - } - - private fun armPendingRunTimeout(runId: String) { - pendingRunTimeoutJobs[runId]?.cancel() - pendingRunTimeoutJobs[runId] = - scope.launch { - delay(pendingRunTimeoutMs) - val stillPending = - synchronized(pendingRuns) { - pendingRuns.contains(runId) - } - if (!stillPending) return@launch - clearPendingRun(runId) - _errorText.value = "Timed out waiting for a reply; try again or refresh." - } - } - - private fun clearPendingRun(runId: String) { - pendingRunTimeoutJobs.remove(runId)?.cancel() - synchronized(pendingRuns) { - pendingRuns.remove(runId) - _pendingRunCount.value = pendingRuns.size - } - } - - private fun clearPendingRuns() { - for ((_, job) in pendingRunTimeoutJobs) { - job.cancel() - } - pendingRunTimeoutJobs.clear() - synchronized(pendingRuns) { - pendingRuns.clear() - _pendingRunCount.value = 0 - } - } - - private fun parseHistory(historyJson: String, sessionKey: String): ChatHistory { - val root = json.parseToJsonElement(historyJson).asObjectOrNull() ?: return ChatHistory(sessionKey, null, null, emptyList()) - val sid = root["sessionId"].asStringOrNull() - val thinkingLevel = root["thinkingLevel"].asStringOrNull() - val array = root["messages"].asArrayOrNull() ?: JsonArray(emptyList()) - - val messages = - array.mapNotNull { item -> - val obj = item.asObjectOrNull() ?: return@mapNotNull null - val role = obj["role"].asStringOrNull() ?: return@mapNotNull null - val content = obj["content"].asArrayOrNull()?.mapNotNull(::parseMessageContent) ?: emptyList() - val ts = obj["timestamp"].asLongOrNull() - ChatMessage( - id = UUID.randomUUID().toString(), - role = role, - content = content, - timestampMs = ts, - ) - } - - return ChatHistory(sessionKey = sessionKey, sessionId = sid, thinkingLevel = thinkingLevel, messages = messages) - } - - private fun parseMessageContent(el: JsonElement): ChatMessageContent? { - val obj = el.asObjectOrNull() ?: return null - val type = obj["type"].asStringOrNull() ?: "text" - return if (type == "text") { - ChatMessageContent(type = "text", text = obj["text"].asStringOrNull()) - } else { - ChatMessageContent( - type = type, - mimeType = obj["mimeType"].asStringOrNull(), - fileName = obj["fileName"].asStringOrNull(), - base64 = obj["content"].asStringOrNull(), - ) - } - } - - private fun parseSessions(jsonString: String): List { - val root = json.parseToJsonElement(jsonString).asObjectOrNull() ?: return emptyList() - val sessions = root["sessions"].asArrayOrNull() ?: return emptyList() - return sessions.mapNotNull { item -> - val obj = item.asObjectOrNull() ?: return@mapNotNull null - val key = obj["key"].asStringOrNull()?.trim().orEmpty() - if (key.isEmpty()) return@mapNotNull null - val updatedAt = obj["updatedAt"].asLongOrNull() - val displayName = obj["displayName"].asStringOrNull()?.trim() - ChatSessionEntry(key = key, updatedAtMs = updatedAt, displayName = displayName) - } - } - - private fun parseRunId(resJson: String): String? { - return try { - json.parseToJsonElement(resJson).asObjectOrNull()?.get("runId").asStringOrNull() - } catch (_: Throwable) { - null - } - } - - private fun normalizeThinking(raw: String): String { - return when (raw.trim().lowercase()) { - "low" -> "low" - "medium" -> "medium" - "high" -> "high" - else -> "off" - } - } -} - -private fun JsonElement?.asObjectOrNull(): JsonObject? = this as? JsonObject - -private fun JsonElement?.asArrayOrNull(): JsonArray? = this as? JsonArray - -private fun JsonElement?.asStringOrNull(): String? = - when (this) { - is JsonNull -> null - is JsonPrimitive -> content - else -> null - } - -private fun JsonElement?.asLongOrNull(): Long? = - when (this) { - is JsonPrimitive -> content.toLongOrNull() - else -> null - } diff --git a/apps/android/app/src/main/java/com/clawdbot/android/chat/ChatModels.kt b/apps/android/app/src/main/java/com/clawdbot/android/chat/ChatModels.kt deleted file mode 100644 index ad84e8c69..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/chat/ChatModels.kt +++ /dev/null @@ -1,44 +0,0 @@ -package com.clawdbot.android.chat - -data class ChatMessage( - val id: String, - val role: String, - val content: List, - val timestampMs: Long?, -) - -data class ChatMessageContent( - val type: String = "text", - val text: String? = null, - val mimeType: String? = null, - val fileName: String? = null, - val base64: String? = null, -) - -data class ChatPendingToolCall( - val toolCallId: String, - val name: String, - val args: kotlinx.serialization.json.JsonObject? = null, - val startedAtMs: Long, - val isError: Boolean? = null, -) - -data class ChatSessionEntry( - val key: String, - val updatedAtMs: Long?, - val displayName: String? = null, -) - -data class ChatHistory( - val sessionKey: String, - val sessionId: String?, - val thinkingLevel: String?, - val messages: List, -) - -data class OutgoingAttachment( - val type: String, - val mimeType: String, - val fileName: String, - val base64: String, -) diff --git a/apps/android/app/src/main/java/com/clawdbot/android/gateway/BonjourEscapes.kt b/apps/android/app/src/main/java/com/clawdbot/android/gateway/BonjourEscapes.kt deleted file mode 100644 index c05d41b4b..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/gateway/BonjourEscapes.kt +++ /dev/null @@ -1,35 +0,0 @@ -package com.clawdbot.android.gateway - -object BonjourEscapes { - fun decode(input: String): String { - if (input.isEmpty()) return input - - val bytes = mutableListOf() - var i = 0 - while (i < input.length) { - if (input[i] == '\\' && i + 3 < input.length) { - val d0 = input[i + 1] - val d1 = input[i + 2] - val d2 = input[i + 3] - if (d0.isDigit() && d1.isDigit() && d2.isDigit()) { - val value = - ((d0.code - '0'.code) * 100) + ((d1.code - '0'.code) * 10) + (d2.code - '0'.code) - if (value in 0..255) { - bytes.add(value.toByte()) - i += 4 - continue - } - } - } - - val codePoint = Character.codePointAt(input, i) - val charBytes = String(Character.toChars(codePoint)).toByteArray(Charsets.UTF_8) - for (b in charBytes) { - bytes.add(b) - } - i += Character.charCount(codePoint) - } - - return String(bytes.toByteArray(), Charsets.UTF_8) - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceAuthStore.kt b/apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceAuthStore.kt deleted file mode 100644 index 88643d8d7..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceAuthStore.kt +++ /dev/null @@ -1,26 +0,0 @@ -package com.clawdbot.android.gateway - -import com.clawdbot.android.SecurePrefs - -class DeviceAuthStore(private val prefs: SecurePrefs) { - fun loadToken(deviceId: String, role: String): String? { - val key = tokenKey(deviceId, role) - return prefs.getString(key)?.trim()?.takeIf { it.isNotEmpty() } - } - - fun saveToken(deviceId: String, role: String, token: String) { - val key = tokenKey(deviceId, role) - prefs.putString(key, token.trim()) - } - - fun clearToken(deviceId: String, role: String) { - val key = tokenKey(deviceId, role) - prefs.remove(key) - } - - private fun tokenKey(deviceId: String, role: String): String { - val normalizedDevice = deviceId.trim().lowercase() - val normalizedRole = role.trim().lowercase() - return "gateway.deviceToken.$normalizedDevice.$normalizedRole" - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceIdentityStore.kt b/apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceIdentityStore.kt deleted file mode 100644 index 4499e0ce7..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/gateway/DeviceIdentityStore.kt +++ /dev/null @@ -1,146 +0,0 @@ -package com.clawdbot.android.gateway - -import android.content.Context -import android.util.Base64 -import java.io.File -import java.security.KeyFactory -import java.security.KeyPairGenerator -import java.security.MessageDigest -import java.security.Signature -import java.security.spec.PKCS8EncodedKeySpec -import kotlinx.serialization.Serializable -import kotlinx.serialization.json.Json - -@Serializable -data class DeviceIdentity( - val deviceId: String, - val publicKeyRawBase64: String, - val privateKeyPkcs8Base64: String, - val createdAtMs: Long, -) - -class DeviceIdentityStore(context: Context) { - private val json = Json { ignoreUnknownKeys = true } - private val identityFile = File(context.filesDir, "moltbot/identity/device.json") - - @Synchronized - fun loadOrCreate(): DeviceIdentity { - val existing = load() - if (existing != null) { - val derived = deriveDeviceId(existing.publicKeyRawBase64) - if (derived != null && derived != existing.deviceId) { - val updated = existing.copy(deviceId = derived) - save(updated) - return updated - } - return existing - } - val fresh = generate() - save(fresh) - return fresh - } - - fun signPayload(payload: String, identity: DeviceIdentity): String? { - return try { - val privateKeyBytes = Base64.decode(identity.privateKeyPkcs8Base64, Base64.DEFAULT) - val keySpec = PKCS8EncodedKeySpec(privateKeyBytes) - val keyFactory = KeyFactory.getInstance("Ed25519") - val privateKey = keyFactory.generatePrivate(keySpec) - val signature = Signature.getInstance("Ed25519") - signature.initSign(privateKey) - signature.update(payload.toByteArray(Charsets.UTF_8)) - base64UrlEncode(signature.sign()) - } catch (_: Throwable) { - null - } - } - - fun publicKeyBase64Url(identity: DeviceIdentity): String? { - return try { - val raw = Base64.decode(identity.publicKeyRawBase64, Base64.DEFAULT) - base64UrlEncode(raw) - } catch (_: Throwable) { - null - } - } - - private fun load(): DeviceIdentity? { - return try { - if (!identityFile.exists()) return null - val raw = identityFile.readText(Charsets.UTF_8) - val decoded = json.decodeFromString(DeviceIdentity.serializer(), raw) - if (decoded.deviceId.isBlank() || - decoded.publicKeyRawBase64.isBlank() || - decoded.privateKeyPkcs8Base64.isBlank() - ) { - null - } else { - decoded - } - } catch (_: Throwable) { - null - } - } - - private fun save(identity: DeviceIdentity) { - try { - identityFile.parentFile?.mkdirs() - val encoded = json.encodeToString(DeviceIdentity.serializer(), identity) - identityFile.writeText(encoded, Charsets.UTF_8) - } catch (_: Throwable) { - // best-effort only - } - } - - private fun generate(): DeviceIdentity { - val keyPair = KeyPairGenerator.getInstance("Ed25519").generateKeyPair() - val spki = keyPair.public.encoded - val rawPublic = stripSpkiPrefix(spki) - val deviceId = sha256Hex(rawPublic) - val privateKey = keyPair.private.encoded - return DeviceIdentity( - deviceId = deviceId, - publicKeyRawBase64 = Base64.encodeToString(rawPublic, Base64.NO_WRAP), - privateKeyPkcs8Base64 = Base64.encodeToString(privateKey, Base64.NO_WRAP), - createdAtMs = System.currentTimeMillis(), - ) - } - - private fun deriveDeviceId(publicKeyRawBase64: String): String? { - return try { - val raw = Base64.decode(publicKeyRawBase64, Base64.DEFAULT) - sha256Hex(raw) - } catch (_: Throwable) { - null - } - } - - private fun stripSpkiPrefix(spki: ByteArray): ByteArray { - if (spki.size == ED25519_SPKI_PREFIX.size + 32 && - spki.copyOfRange(0, ED25519_SPKI_PREFIX.size).contentEquals(ED25519_SPKI_PREFIX) - ) { - return spki.copyOfRange(ED25519_SPKI_PREFIX.size, spki.size) - } - return spki - } - - private fun sha256Hex(data: ByteArray): String { - val digest = MessageDigest.getInstance("SHA-256").digest(data) - val out = StringBuilder(digest.size * 2) - for (byte in digest) { - out.append(String.format("%02x", byte)) - } - return out.toString() - } - - private fun base64UrlEncode(data: ByteArray): String { - return Base64.encodeToString(data, Base64.URL_SAFE or Base64.NO_WRAP or Base64.NO_PADDING) - } - - companion object { - private val ED25519_SPKI_PREFIX = - byteArrayOf( - 0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00, - ) - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayDiscovery.kt b/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayDiscovery.kt deleted file mode 100644 index b1d50e28b..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayDiscovery.kt +++ /dev/null @@ -1,519 +0,0 @@ -package com.clawdbot.android.gateway - -import android.content.Context -import android.net.ConnectivityManager -import android.net.DnsResolver -import android.net.NetworkCapabilities -import android.net.nsd.NsdManager -import android.net.nsd.NsdServiceInfo -import android.os.CancellationSignal -import android.util.Log -import java.io.IOException -import java.net.InetSocketAddress -import java.nio.ByteBuffer -import java.nio.charset.CodingErrorAction -import java.util.concurrent.ConcurrentHashMap -import java.util.concurrent.Executor -import java.util.concurrent.Executors -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.Job -import kotlinx.coroutines.delay -import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.flow.StateFlow -import kotlinx.coroutines.flow.asStateFlow -import kotlinx.coroutines.launch -import kotlinx.coroutines.suspendCancellableCoroutine -import org.xbill.DNS.AAAARecord -import org.xbill.DNS.ARecord -import org.xbill.DNS.DClass -import org.xbill.DNS.ExtendedResolver -import org.xbill.DNS.Message -import org.xbill.DNS.Name -import org.xbill.DNS.PTRRecord -import org.xbill.DNS.Record -import org.xbill.DNS.Rcode -import org.xbill.DNS.Resolver -import org.xbill.DNS.SRVRecord -import org.xbill.DNS.Section -import org.xbill.DNS.SimpleResolver -import org.xbill.DNS.TextParseException -import org.xbill.DNS.TXTRecord -import org.xbill.DNS.Type -import kotlin.coroutines.resume -import kotlin.coroutines.resumeWithException - -@Suppress("DEPRECATION") -class GatewayDiscovery( - context: Context, - private val scope: CoroutineScope, -) { - private val nsd = context.getSystemService(NsdManager::class.java) - private val connectivity = context.getSystemService(ConnectivityManager::class.java) - private val dns = DnsResolver.getInstance() - private val serviceType = "_moltbot-gw._tcp." - private val wideAreaDomain = "moltbot.internal." - private val logTag = "Moltbot/GatewayDiscovery" - - private val localById = ConcurrentHashMap() - private val unicastById = ConcurrentHashMap() - private val _gateways = MutableStateFlow>(emptyList()) - val gateways: StateFlow> = _gateways.asStateFlow() - - private val _statusText = MutableStateFlow("Searching…") - val statusText: StateFlow = _statusText.asStateFlow() - - private var unicastJob: Job? = null - private val dnsExecutor: Executor = Executors.newCachedThreadPool() - - @Volatile private var lastWideAreaRcode: Int? = null - @Volatile private var lastWideAreaCount: Int = 0 - - private val discoveryListener = - object : NsdManager.DiscoveryListener { - override fun onStartDiscoveryFailed(serviceType: String, errorCode: Int) {} - override fun onStopDiscoveryFailed(serviceType: String, errorCode: Int) {} - override fun onDiscoveryStarted(serviceType: String) {} - override fun onDiscoveryStopped(serviceType: String) {} - - override fun onServiceFound(serviceInfo: NsdServiceInfo) { - if (serviceInfo.serviceType != this@GatewayDiscovery.serviceType) return - resolve(serviceInfo) - } - - override fun onServiceLost(serviceInfo: NsdServiceInfo) { - val serviceName = BonjourEscapes.decode(serviceInfo.serviceName) - val id = stableId(serviceName, "local.") - localById.remove(id) - publish() - } - } - - init { - startLocalDiscovery() - startUnicastDiscovery(wideAreaDomain) - } - - private fun startLocalDiscovery() { - try { - nsd.discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD, discoveryListener) - } catch (_: Throwable) { - // ignore (best-effort) - } - } - - private fun stopLocalDiscovery() { - try { - nsd.stopServiceDiscovery(discoveryListener) - } catch (_: Throwable) { - // ignore (best-effort) - } - } - - private fun startUnicastDiscovery(domain: String) { - unicastJob = - scope.launch(Dispatchers.IO) { - while (true) { - try { - refreshUnicast(domain) - } catch (_: Throwable) { - // ignore (best-effort) - } - delay(5000) - } - } - } - - private fun resolve(serviceInfo: NsdServiceInfo) { - nsd.resolveService( - serviceInfo, - object : NsdManager.ResolveListener { - override fun onResolveFailed(serviceInfo: NsdServiceInfo, errorCode: Int) {} - - override fun onServiceResolved(resolved: NsdServiceInfo) { - val host = resolved.host?.hostAddress ?: return - val port = resolved.port - if (port <= 0) return - - val rawServiceName = resolved.serviceName - val serviceName = BonjourEscapes.decode(rawServiceName) - val displayName = BonjourEscapes.decode(txt(resolved, "displayName") ?: serviceName) - val lanHost = txt(resolved, "lanHost") - val tailnetDns = txt(resolved, "tailnetDns") - val gatewayPort = txtInt(resolved, "gatewayPort") - val canvasPort = txtInt(resolved, "canvasPort") - val tlsEnabled = txtBool(resolved, "gatewayTls") - val tlsFingerprint = txt(resolved, "gatewayTlsSha256") - val id = stableId(serviceName, "local.") - localById[id] = - GatewayEndpoint( - stableId = id, - name = displayName, - host = host, - port = port, - lanHost = lanHost, - tailnetDns = tailnetDns, - gatewayPort = gatewayPort, - canvasPort = canvasPort, - tlsEnabled = tlsEnabled, - tlsFingerprintSha256 = tlsFingerprint, - ) - publish() - } - }, - ) - } - - private fun publish() { - _gateways.value = - (localById.values + unicastById.values).sortedBy { it.name.lowercase() } - _statusText.value = buildStatusText() - } - - private fun buildStatusText(): String { - val localCount = localById.size - val wideRcode = lastWideAreaRcode - val wideCount = lastWideAreaCount - - val wide = - when (wideRcode) { - null -> "Wide: ?" - Rcode.NOERROR -> "Wide: $wideCount" - Rcode.NXDOMAIN -> "Wide: NXDOMAIN" - else -> "Wide: ${Rcode.string(wideRcode)}" - } - - return when { - localCount == 0 && wideRcode == null -> "Searching for gateways…" - localCount == 0 -> "$wide" - else -> "Local: $localCount • $wide" - } - } - - private fun stableId(serviceName: String, domain: String): String { - return "${serviceType}|${domain}|${normalizeName(serviceName)}" - } - - private fun normalizeName(raw: String): String { - return raw.trim().split(Regex("\\s+")).joinToString(" ") - } - - private fun txt(info: NsdServiceInfo, key: String): String? { - val bytes = info.attributes[key] ?: return null - return try { - String(bytes, Charsets.UTF_8).trim().ifEmpty { null } - } catch (_: Throwable) { - null - } - } - - private fun txtInt(info: NsdServiceInfo, key: String): Int? { - return txt(info, key)?.toIntOrNull() - } - - private fun txtBool(info: NsdServiceInfo, key: String): Boolean { - val raw = txt(info, key)?.trim()?.lowercase() ?: return false - return raw == "1" || raw == "true" || raw == "yes" - } - - private suspend fun refreshUnicast(domain: String) { - val ptrName = "${serviceType}${domain}" - val ptrMsg = lookupUnicastMessage(ptrName, Type.PTR) ?: return - val ptrRecords = records(ptrMsg, Section.ANSWER).mapNotNull { it as? PTRRecord } - - val next = LinkedHashMap() - for (ptr in ptrRecords) { - val instanceFqdn = ptr.target.toString() - val srv = - recordByName(ptrMsg, instanceFqdn, Type.SRV) as? SRVRecord - ?: run { - val msg = lookupUnicastMessage(instanceFqdn, Type.SRV) ?: return@run null - recordByName(msg, instanceFqdn, Type.SRV) as? SRVRecord - } - ?: continue - val port = srv.port - if (port <= 0) continue - - val targetFqdn = srv.target.toString() - val host = - resolveHostFromMessage(ptrMsg, targetFqdn) - ?: resolveHostFromMessage(lookupUnicastMessage(instanceFqdn, Type.SRV), targetFqdn) - ?: resolveHostUnicast(targetFqdn) - ?: continue - - val txtFromPtr = - recordsByName(ptrMsg, Section.ADDITIONAL)[keyName(instanceFqdn)] - .orEmpty() - .mapNotNull { it as? TXTRecord } - val txt = - if (txtFromPtr.isNotEmpty()) { - txtFromPtr - } else { - val msg = lookupUnicastMessage(instanceFqdn, Type.TXT) - records(msg, Section.ANSWER).mapNotNull { it as? TXTRecord } - } - val instanceName = BonjourEscapes.decode(decodeInstanceName(instanceFqdn, domain)) - val displayName = BonjourEscapes.decode(txtValue(txt, "displayName") ?: instanceName) - val lanHost = txtValue(txt, "lanHost") - val tailnetDns = txtValue(txt, "tailnetDns") - val gatewayPort = txtIntValue(txt, "gatewayPort") - val canvasPort = txtIntValue(txt, "canvasPort") - val tlsEnabled = txtBoolValue(txt, "gatewayTls") - val tlsFingerprint = txtValue(txt, "gatewayTlsSha256") - val id = stableId(instanceName, domain) - next[id] = - GatewayEndpoint( - stableId = id, - name = displayName, - host = host, - port = port, - lanHost = lanHost, - tailnetDns = tailnetDns, - gatewayPort = gatewayPort, - canvasPort = canvasPort, - tlsEnabled = tlsEnabled, - tlsFingerprintSha256 = tlsFingerprint, - ) - } - - unicastById.clear() - unicastById.putAll(next) - lastWideAreaRcode = ptrMsg.header.rcode - lastWideAreaCount = next.size - publish() - - if (next.isEmpty()) { - Log.d( - logTag, - "wide-area discovery: 0 results for $ptrName (rcode=${Rcode.string(ptrMsg.header.rcode)})", - ) - } - } - - private fun decodeInstanceName(instanceFqdn: String, domain: String): String { - val suffix = "${serviceType}${domain}" - val withoutSuffix = - if (instanceFqdn.endsWith(suffix)) { - instanceFqdn.removeSuffix(suffix) - } else { - instanceFqdn.substringBefore(serviceType) - } - return normalizeName(stripTrailingDot(withoutSuffix)) - } - - private fun stripTrailingDot(raw: String): String { - return raw.removeSuffix(".") - } - - private suspend fun lookupUnicastMessage(name: String, type: Int): Message? { - val query = - try { - Message.newQuery( - org.xbill.DNS.Record.newRecord( - Name.fromString(name), - type, - DClass.IN, - ), - ) - } catch (_: TextParseException) { - return null - } - - val system = queryViaSystemDns(query) - if (records(system, Section.ANSWER).any { it.type == type }) return system - - val direct = createDirectResolver() ?: return system - return try { - val msg = direct.send(query) - if (records(msg, Section.ANSWER).any { it.type == type }) msg else system - } catch (_: Throwable) { - system - } - } - - private suspend fun queryViaSystemDns(query: Message): Message? { - val network = preferredDnsNetwork() - val bytes = - try { - rawQuery(network, query.toWire()) - } catch (_: Throwable) { - return null - } - - return try { - Message(bytes) - } catch (_: IOException) { - null - } - } - - private fun records(msg: Message?, section: Int): List { - return msg?.getSectionArray(section)?.toList() ?: emptyList() - } - - private fun keyName(raw: String): String { - return raw.trim().lowercase() - } - - private fun recordsByName(msg: Message, section: Int): Map> { - val next = LinkedHashMap>() - for (r in records(msg, section)) { - val name = r.name?.toString() ?: continue - next.getOrPut(keyName(name)) { mutableListOf() }.add(r) - } - return next - } - - private fun recordByName(msg: Message, fqdn: String, type: Int): Record? { - val key = keyName(fqdn) - val byNameAnswer = recordsByName(msg, Section.ANSWER) - val fromAnswer = byNameAnswer[key].orEmpty().firstOrNull { it.type == type } - if (fromAnswer != null) return fromAnswer - - val byNameAdditional = recordsByName(msg, Section.ADDITIONAL) - return byNameAdditional[key].orEmpty().firstOrNull { it.type == type } - } - - private fun resolveHostFromMessage(msg: Message?, hostname: String): String? { - val m = msg ?: return null - val key = keyName(hostname) - val additional = recordsByName(m, Section.ADDITIONAL)[key].orEmpty() - val a = additional.mapNotNull { it as? ARecord }.mapNotNull { it.address?.hostAddress } - val aaaa = additional.mapNotNull { it as? AAAARecord }.mapNotNull { it.address?.hostAddress } - return a.firstOrNull() ?: aaaa.firstOrNull() - } - - private fun preferredDnsNetwork(): android.net.Network? { - val cm = connectivity ?: return null - - // Prefer VPN (Tailscale) when present; otherwise use the active network. - cm.allNetworks.firstOrNull { n -> - val caps = cm.getNetworkCapabilities(n) ?: return@firstOrNull false - caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN) - }?.let { return it } - - return cm.activeNetwork - } - - private fun createDirectResolver(): Resolver? { - val cm = connectivity ?: return null - - val candidateNetworks = - buildList { - cm.allNetworks - .firstOrNull { n -> - val caps = cm.getNetworkCapabilities(n) ?: return@firstOrNull false - caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN) - }?.let(::add) - cm.activeNetwork?.let(::add) - }.distinct() - - val servers = - candidateNetworks - .asSequence() - .flatMap { n -> - cm.getLinkProperties(n)?.dnsServers?.asSequence() ?: emptySequence() - } - .distinctBy { it.hostAddress ?: it.toString() } - .toList() - if (servers.isEmpty()) return null - - return try { - val resolvers = - servers.mapNotNull { addr -> - try { - SimpleResolver().apply { - setAddress(InetSocketAddress(addr, 53)) - setTimeout(3) - } - } catch (_: Throwable) { - null - } - } - if (resolvers.isEmpty()) return null - ExtendedResolver(resolvers.toTypedArray()).apply { setTimeout(3) } - } catch (_: Throwable) { - null - } - } - - private suspend fun rawQuery(network: android.net.Network?, wireQuery: ByteArray): ByteArray = - suspendCancellableCoroutine { cont -> - val signal = CancellationSignal() - cont.invokeOnCancellation { signal.cancel() } - - dns.rawQuery( - network, - wireQuery, - DnsResolver.FLAG_EMPTY, - dnsExecutor, - signal, - object : DnsResolver.Callback { - override fun onAnswer(answer: ByteArray, rcode: Int) { - cont.resume(answer) - } - - override fun onError(error: DnsResolver.DnsException) { - cont.resumeWithException(error) - } - }, - ) - } - - private fun txtValue(records: List, key: String): String? { - val prefix = "$key=" - for (r in records) { - val strings: List = - try { - r.strings.mapNotNull { it as? String } - } catch (_: Throwable) { - emptyList() - } - for (s in strings) { - val trimmed = decodeDnsTxtString(s).trim() - if (trimmed.startsWith(prefix)) { - return trimmed.removePrefix(prefix).trim().ifEmpty { null } - } - } - } - return null - } - - private fun txtIntValue(records: List, key: String): Int? { - return txtValue(records, key)?.toIntOrNull() - } - - private fun txtBoolValue(records: List, key: String): Boolean { - val raw = txtValue(records, key)?.trim()?.lowercase() ?: return false - return raw == "1" || raw == "true" || raw == "yes" - } - - private fun decodeDnsTxtString(raw: String): String { - // dnsjava treats TXT as opaque bytes and decodes as ISO-8859-1 to preserve bytes. - // Our TXT payload is UTF-8 (written by the gateway), so re-decode when possible. - val bytes = raw.toByteArray(Charsets.ISO_8859_1) - val decoder = - Charsets.UTF_8 - .newDecoder() - .onMalformedInput(CodingErrorAction.REPORT) - .onUnmappableCharacter(CodingErrorAction.REPORT) - return try { - decoder.decode(ByteBuffer.wrap(bytes)).toString() - } catch (_: Throwable) { - raw - } - } - - private suspend fun resolveHostUnicast(hostname: String): String? { - val a = - records(lookupUnicastMessage(hostname, Type.A), Section.ANSWER) - .mapNotNull { it as? ARecord } - .mapNotNull { it.address?.hostAddress } - val aaaa = - records(lookupUnicastMessage(hostname, Type.AAAA), Section.ANSWER) - .mapNotNull { it as? AAAARecord } - .mapNotNull { it.address?.hostAddress } - - return a.firstOrNull() ?: aaaa.firstOrNull() - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayEndpoint.kt b/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayEndpoint.kt deleted file mode 100644 index ab8aeacc9..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayEndpoint.kt +++ /dev/null @@ -1,26 +0,0 @@ -package com.clawdbot.android.gateway - -data class GatewayEndpoint( - val stableId: String, - val name: String, - val host: String, - val port: Int, - val lanHost: String? = null, - val tailnetDns: String? = null, - val gatewayPort: Int? = null, - val canvasPort: Int? = null, - val tlsEnabled: Boolean = false, - val tlsFingerprintSha256: String? = null, -) { - companion object { - fun manual(host: String, port: Int): GatewayEndpoint = - GatewayEndpoint( - stableId = "manual|${host.lowercase()}|$port", - name = "$host:$port", - host = host, - port = port, - tlsEnabled = false, - tlsFingerprintSha256 = null, - ) - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayProtocol.kt b/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayProtocol.kt deleted file mode 100644 index 4873de122..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayProtocol.kt +++ /dev/null @@ -1,3 +0,0 @@ -package com.clawdbot.android.gateway - -const val GATEWAY_PROTOCOL_VERSION = 3 diff --git a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewaySession.kt b/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewaySession.kt deleted file mode 100644 index a54460e0a..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewaySession.kt +++ /dev/null @@ -1,683 +0,0 @@ -package com.clawdbot.android.gateway - -import android.util.Log -import java.util.Locale -import java.util.UUID -import java.util.concurrent.ConcurrentHashMap -import java.util.concurrent.atomic.AtomicBoolean -import kotlinx.coroutines.CompletableDeferred -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.Job -import kotlinx.coroutines.TimeoutCancellationException -import kotlinx.coroutines.cancelAndJoin -import kotlinx.coroutines.delay -import kotlinx.coroutines.isActive -import kotlinx.coroutines.launch -import kotlinx.coroutines.sync.Mutex -import kotlinx.coroutines.sync.withLock -import kotlinx.coroutines.withContext -import kotlinx.coroutines.withTimeout -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonArray -import kotlinx.serialization.json.JsonElement -import kotlinx.serialization.json.JsonNull -import kotlinx.serialization.json.JsonObject -import kotlinx.serialization.json.JsonPrimitive -import kotlinx.serialization.json.buildJsonObject -import okhttp3.OkHttpClient -import okhttp3.Request -import okhttp3.Response -import okhttp3.WebSocket -import okhttp3.WebSocketListener - -data class GatewayClientInfo( - val id: String, - val displayName: String?, - val version: String, - val platform: String, - val mode: String, - val instanceId: String?, - val deviceFamily: String?, - val modelIdentifier: String?, -) - -data class GatewayConnectOptions( - val role: String, - val scopes: List, - val caps: List, - val commands: List, - val permissions: Map, - val client: GatewayClientInfo, - val userAgent: String? = null, -) - -class GatewaySession( - private val scope: CoroutineScope, - private val identityStore: DeviceIdentityStore, - private val deviceAuthStore: DeviceAuthStore, - private val onConnected: (serverName: String?, remoteAddress: String?, mainSessionKey: String?) -> Unit, - private val onDisconnected: (message: String) -> Unit, - private val onEvent: (event: String, payloadJson: String?) -> Unit, - private val onInvoke: (suspend (InvokeRequest) -> InvokeResult)? = null, - private val onTlsFingerprint: ((stableId: String, fingerprint: String) -> Unit)? = null, -) { - data class InvokeRequest( - val id: String, - val nodeId: String, - val command: String, - val paramsJson: String?, - val timeoutMs: Long?, - ) - - data class InvokeResult(val ok: Boolean, val payloadJson: String?, val error: ErrorShape?) { - companion object { - fun ok(payloadJson: String?) = InvokeResult(ok = true, payloadJson = payloadJson, error = null) - fun error(code: String, message: String) = - InvokeResult(ok = false, payloadJson = null, error = ErrorShape(code = code, message = message)) - } - } - - data class ErrorShape(val code: String, val message: String) - - private val json = Json { ignoreUnknownKeys = true } - private val writeLock = Mutex() - private val pending = ConcurrentHashMap>() - - @Volatile private var canvasHostUrl: String? = null - @Volatile private var mainSessionKey: String? = null - - private data class DesiredConnection( - val endpoint: GatewayEndpoint, - val token: String?, - val password: String?, - val options: GatewayConnectOptions, - val tls: GatewayTlsParams?, - ) - - private var desired: DesiredConnection? = null - private var job: Job? = null - @Volatile private var currentConnection: Connection? = null - - fun connect( - endpoint: GatewayEndpoint, - token: String?, - password: String?, - options: GatewayConnectOptions, - tls: GatewayTlsParams? = null, - ) { - desired = DesiredConnection(endpoint, token, password, options, tls) - if (job == null) { - job = scope.launch(Dispatchers.IO) { runLoop() } - } - } - - fun disconnect() { - desired = null - currentConnection?.closeQuietly() - scope.launch(Dispatchers.IO) { - job?.cancelAndJoin() - job = null - canvasHostUrl = null - mainSessionKey = null - onDisconnected("Offline") - } - } - - fun reconnect() { - currentConnection?.closeQuietly() - } - - fun currentCanvasHostUrl(): String? = canvasHostUrl - fun currentMainSessionKey(): String? = mainSessionKey - - suspend fun sendNodeEvent(event: String, payloadJson: String?) { - val conn = currentConnection ?: return - val parsedPayload = payloadJson?.let { parseJsonOrNull(it) } - val params = - buildJsonObject { - put("event", JsonPrimitive(event)) - if (parsedPayload != null) { - put("payload", parsedPayload) - } else if (payloadJson != null) { - put("payloadJSON", JsonPrimitive(payloadJson)) - } else { - put("payloadJSON", JsonNull) - } - } - try { - conn.request("node.event", params, timeoutMs = 8_000) - } catch (err: Throwable) { - Log.w("MoltbotGateway", "node.event failed: ${err.message ?: err::class.java.simpleName}") - } - } - - suspend fun request(method: String, paramsJson: String?, timeoutMs: Long = 15_000): String { - val conn = currentConnection ?: throw IllegalStateException("not connected") - val params = - if (paramsJson.isNullOrBlank()) { - null - } else { - json.parseToJsonElement(paramsJson) - } - val res = conn.request(method, params, timeoutMs) - if (res.ok) return res.payloadJson ?: "" - val err = res.error - throw IllegalStateException("${err?.code ?: "UNAVAILABLE"}: ${err?.message ?: "request failed"}") - } - - private data class RpcResponse(val id: String, val ok: Boolean, val payloadJson: String?, val error: ErrorShape?) - - private inner class Connection( - private val endpoint: GatewayEndpoint, - private val token: String?, - private val password: String?, - private val options: GatewayConnectOptions, - private val tls: GatewayTlsParams?, - ) { - private val connectDeferred = CompletableDeferred() - private val closedDeferred = CompletableDeferred() - private val isClosed = AtomicBoolean(false) - private val connectNonceDeferred = CompletableDeferred() - private val client: OkHttpClient = buildClient() - private var socket: WebSocket? = null - private val loggerTag = "MoltbotGateway" - - val remoteAddress: String = - if (endpoint.host.contains(":")) { - "[${endpoint.host}]:${endpoint.port}" - } else { - "${endpoint.host}:${endpoint.port}" - } - - suspend fun connect() { - val scheme = if (tls != null) "wss" else "ws" - val url = "$scheme://${endpoint.host}:${endpoint.port}" - val request = Request.Builder().url(url).build() - socket = client.newWebSocket(request, Listener()) - try { - connectDeferred.await() - } catch (err: Throwable) { - throw err - } - } - - suspend fun request(method: String, params: JsonElement?, timeoutMs: Long): RpcResponse { - val id = UUID.randomUUID().toString() - val deferred = CompletableDeferred() - pending[id] = deferred - val frame = - buildJsonObject { - put("type", JsonPrimitive("req")) - put("id", JsonPrimitive(id)) - put("method", JsonPrimitive(method)) - if (params != null) put("params", params) - } - sendJson(frame) - return try { - withTimeout(timeoutMs) { deferred.await() } - } catch (err: TimeoutCancellationException) { - pending.remove(id) - throw IllegalStateException("request timeout") - } - } - - suspend fun sendJson(obj: JsonObject) { - val jsonString = obj.toString() - writeLock.withLock { - socket?.send(jsonString) - } - } - - suspend fun awaitClose() = closedDeferred.await() - - fun closeQuietly() { - if (isClosed.compareAndSet(false, true)) { - socket?.close(1000, "bye") - socket = null - closedDeferred.complete(Unit) - } - } - - private fun buildClient(): OkHttpClient { - val builder = OkHttpClient.Builder() - val tlsConfig = buildGatewayTlsConfig(tls) { fingerprint -> - onTlsFingerprint?.invoke(tls?.stableId ?: endpoint.stableId, fingerprint) - } - if (tlsConfig != null) { - builder.sslSocketFactory(tlsConfig.sslSocketFactory, tlsConfig.trustManager) - builder.hostnameVerifier(tlsConfig.hostnameVerifier) - } - return builder.build() - } - - private inner class Listener : WebSocketListener() { - override fun onOpen(webSocket: WebSocket, response: Response) { - scope.launch { - try { - val nonce = awaitConnectNonce() - sendConnect(nonce) - } catch (err: Throwable) { - connectDeferred.completeExceptionally(err) - closeQuietly() - } - } - } - - override fun onMessage(webSocket: WebSocket, text: String) { - scope.launch { handleMessage(text) } - } - - override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) { - if (!connectDeferred.isCompleted) { - connectDeferred.completeExceptionally(t) - } - if (isClosed.compareAndSet(false, true)) { - failPending() - closedDeferred.complete(Unit) - onDisconnected("Gateway error: ${t.message ?: t::class.java.simpleName}") - } - } - - override fun onClosed(webSocket: WebSocket, code: Int, reason: String) { - if (!connectDeferred.isCompleted) { - connectDeferred.completeExceptionally(IllegalStateException("Gateway closed: $reason")) - } - if (isClosed.compareAndSet(false, true)) { - failPending() - closedDeferred.complete(Unit) - onDisconnected("Gateway closed: $reason") - } - } - } - - private suspend fun sendConnect(connectNonce: String?) { - val identity = identityStore.loadOrCreate() - val storedToken = deviceAuthStore.loadToken(identity.deviceId, options.role) - val trimmedToken = token?.trim().orEmpty() - val authToken = if (storedToken.isNullOrBlank()) trimmedToken else storedToken - val canFallbackToShared = !storedToken.isNullOrBlank() && trimmedToken.isNotBlank() - val payload = buildConnectParams(identity, connectNonce, authToken, password?.trim()) - val res = request("connect", payload, timeoutMs = 8_000) - if (!res.ok) { - val msg = res.error?.message ?: "connect failed" - if (canFallbackToShared) { - deviceAuthStore.clearToken(identity.deviceId, options.role) - } - throw IllegalStateException(msg) - } - val payloadJson = res.payloadJson ?: throw IllegalStateException("connect failed: missing payload") - val obj = json.parseToJsonElement(payloadJson).asObjectOrNull() ?: throw IllegalStateException("connect failed") - val serverName = obj["server"].asObjectOrNull()?.get("host").asStringOrNull() - val authObj = obj["auth"].asObjectOrNull() - val deviceToken = authObj?.get("deviceToken").asStringOrNull() - val authRole = authObj?.get("role").asStringOrNull() ?: options.role - if (!deviceToken.isNullOrBlank()) { - deviceAuthStore.saveToken(identity.deviceId, authRole, deviceToken) - } - val rawCanvas = obj["canvasHostUrl"].asStringOrNull() - canvasHostUrl = normalizeCanvasHostUrl(rawCanvas, endpoint) - val sessionDefaults = - obj["snapshot"].asObjectOrNull() - ?.get("sessionDefaults").asObjectOrNull() - mainSessionKey = sessionDefaults?.get("mainSessionKey").asStringOrNull() - onConnected(serverName, remoteAddress, mainSessionKey) - connectDeferred.complete(Unit) - } - - private fun buildConnectParams( - identity: DeviceIdentity, - connectNonce: String?, - authToken: String, - authPassword: String?, - ): JsonObject { - val client = options.client - val locale = Locale.getDefault().toLanguageTag() - val clientObj = - buildJsonObject { - put("id", JsonPrimitive(client.id)) - client.displayName?.let { put("displayName", JsonPrimitive(it)) } - put("version", JsonPrimitive(client.version)) - put("platform", JsonPrimitive(client.platform)) - put("mode", JsonPrimitive(client.mode)) - client.instanceId?.let { put("instanceId", JsonPrimitive(it)) } - client.deviceFamily?.let { put("deviceFamily", JsonPrimitive(it)) } - client.modelIdentifier?.let { put("modelIdentifier", JsonPrimitive(it)) } - } - - val password = authPassword?.trim().orEmpty() - val authJson = - when { - authToken.isNotEmpty() -> - buildJsonObject { - put("token", JsonPrimitive(authToken)) - } - password.isNotEmpty() -> - buildJsonObject { - put("password", JsonPrimitive(password)) - } - else -> null - } - - val signedAtMs = System.currentTimeMillis() - val payload = - buildDeviceAuthPayload( - deviceId = identity.deviceId, - clientId = client.id, - clientMode = client.mode, - role = options.role, - scopes = options.scopes, - signedAtMs = signedAtMs, - token = if (authToken.isNotEmpty()) authToken else null, - nonce = connectNonce, - ) - val signature = identityStore.signPayload(payload, identity) - val publicKey = identityStore.publicKeyBase64Url(identity) - val deviceJson = - if (!signature.isNullOrBlank() && !publicKey.isNullOrBlank()) { - buildJsonObject { - put("id", JsonPrimitive(identity.deviceId)) - put("publicKey", JsonPrimitive(publicKey)) - put("signature", JsonPrimitive(signature)) - put("signedAt", JsonPrimitive(signedAtMs)) - if (!connectNonce.isNullOrBlank()) { - put("nonce", JsonPrimitive(connectNonce)) - } - } - } else { - null - } - - return buildJsonObject { - put("minProtocol", JsonPrimitive(GATEWAY_PROTOCOL_VERSION)) - put("maxProtocol", JsonPrimitive(GATEWAY_PROTOCOL_VERSION)) - put("client", clientObj) - if (options.caps.isNotEmpty()) put("caps", JsonArray(options.caps.map(::JsonPrimitive))) - if (options.commands.isNotEmpty()) put("commands", JsonArray(options.commands.map(::JsonPrimitive))) - if (options.permissions.isNotEmpty()) { - put( - "permissions", - buildJsonObject { - options.permissions.forEach { (key, value) -> - put(key, JsonPrimitive(value)) - } - }, - ) - } - put("role", JsonPrimitive(options.role)) - if (options.scopes.isNotEmpty()) put("scopes", JsonArray(options.scopes.map(::JsonPrimitive))) - authJson?.let { put("auth", it) } - deviceJson?.let { put("device", it) } - put("locale", JsonPrimitive(locale)) - options.userAgent?.trim()?.takeIf { it.isNotEmpty() }?.let { - put("userAgent", JsonPrimitive(it)) - } - } - } - - private suspend fun handleMessage(text: String) { - val frame = json.parseToJsonElement(text).asObjectOrNull() ?: return - when (frame["type"].asStringOrNull()) { - "res" -> handleResponse(frame) - "event" -> handleEvent(frame) - } - } - - private fun handleResponse(frame: JsonObject) { - val id = frame["id"].asStringOrNull() ?: return - val ok = frame["ok"].asBooleanOrNull() ?: false - val payloadJson = frame["payload"]?.let { payload -> payload.toString() } - val error = - frame["error"]?.asObjectOrNull()?.let { obj -> - val code = obj["code"].asStringOrNull() ?: "UNAVAILABLE" - val msg = obj["message"].asStringOrNull() ?: "request failed" - ErrorShape(code, msg) - } - pending.remove(id)?.complete(RpcResponse(id, ok, payloadJson, error)) - } - - private fun handleEvent(frame: JsonObject) { - val event = frame["event"].asStringOrNull() ?: return - val payloadJson = - frame["payload"]?.let { it.toString() } ?: frame["payloadJSON"].asStringOrNull() - if (event == "connect.challenge") { - val nonce = extractConnectNonce(payloadJson) - if (!connectNonceDeferred.isCompleted) { - connectNonceDeferred.complete(nonce) - } - return - } - if (event == "node.invoke.request" && payloadJson != null && onInvoke != null) { - handleInvokeEvent(payloadJson) - return - } - onEvent(event, payloadJson) - } - - private suspend fun awaitConnectNonce(): String? { - if (isLoopbackHost(endpoint.host)) return null - return try { - withTimeout(2_000) { connectNonceDeferred.await() } - } catch (_: Throwable) { - null - } - } - - private fun extractConnectNonce(payloadJson: String?): String? { - if (payloadJson.isNullOrBlank()) return null - val obj = parseJsonOrNull(payloadJson)?.asObjectOrNull() ?: return null - return obj["nonce"].asStringOrNull() - } - - private fun handleInvokeEvent(payloadJson: String) { - val payload = - try { - json.parseToJsonElement(payloadJson).asObjectOrNull() - } catch (_: Throwable) { - null - } ?: return - val id = payload["id"].asStringOrNull() ?: return - val nodeId = payload["nodeId"].asStringOrNull() ?: return - val command = payload["command"].asStringOrNull() ?: return - val params = - payload["paramsJSON"].asStringOrNull() - ?: payload["params"]?.let { value -> if (value is JsonNull) null else value.toString() } - val timeoutMs = payload["timeoutMs"].asLongOrNull() - scope.launch { - val result = - try { - onInvoke?.invoke(InvokeRequest(id, nodeId, command, params, timeoutMs)) - ?: InvokeResult.error("UNAVAILABLE", "invoke handler missing") - } catch (err: Throwable) { - invokeErrorFromThrowable(err) - } - sendInvokeResult(id, nodeId, result) - } - } - - private suspend fun sendInvokeResult(id: String, nodeId: String, result: InvokeResult) { - val parsedPayload = result.payloadJson?.let { parseJsonOrNull(it) } - val params = - buildJsonObject { - put("id", JsonPrimitive(id)) - put("nodeId", JsonPrimitive(nodeId)) - put("ok", JsonPrimitive(result.ok)) - if (parsedPayload != null) { - put("payload", parsedPayload) - } else if (result.payloadJson != null) { - put("payloadJSON", JsonPrimitive(result.payloadJson)) - } - result.error?.let { err -> - put( - "error", - buildJsonObject { - put("code", JsonPrimitive(err.code)) - put("message", JsonPrimitive(err.message)) - }, - ) - } - } - try { - request("node.invoke.result", params, timeoutMs = 15_000) - } catch (err: Throwable) { - Log.w(loggerTag, "node.invoke.result failed: ${err.message ?: err::class.java.simpleName}") - } - } - - private fun invokeErrorFromThrowable(err: Throwable): InvokeResult { - val msg = err.message?.trim().takeIf { !it.isNullOrEmpty() } ?: err::class.java.simpleName - val parts = msg.split(":", limit = 2) - if (parts.size == 2) { - val code = parts[0].trim() - val rest = parts[1].trim() - if (code.isNotEmpty() && code.all { it.isUpperCase() || it == '_' }) { - return InvokeResult.error(code = code, message = rest.ifEmpty { msg }) - } - } - return InvokeResult.error(code = "UNAVAILABLE", message = msg) - } - - private fun failPending() { - for ((_, waiter) in pending) { - waiter.cancel() - } - pending.clear() - } - } - - private suspend fun runLoop() { - var attempt = 0 - while (scope.isActive) { - val target = desired - if (target == null) { - currentConnection?.closeQuietly() - currentConnection = null - delay(250) - continue - } - - try { - onDisconnected(if (attempt == 0) "Connecting…" else "Reconnecting…") - connectOnce(target) - attempt = 0 - } catch (err: Throwable) { - attempt += 1 - onDisconnected("Gateway error: ${err.message ?: err::class.java.simpleName}") - val sleepMs = minOf(8_000L, (350.0 * Math.pow(1.7, attempt.toDouble())).toLong()) - delay(sleepMs) - } - } - } - - private suspend fun connectOnce(target: DesiredConnection) = withContext(Dispatchers.IO) { - val conn = Connection(target.endpoint, target.token, target.password, target.options, target.tls) - currentConnection = conn - try { - conn.connect() - conn.awaitClose() - } finally { - currentConnection = null - canvasHostUrl = null - mainSessionKey = null - } - } - - private fun buildDeviceAuthPayload( - deviceId: String, - clientId: String, - clientMode: String, - role: String, - scopes: List, - signedAtMs: Long, - token: String?, - nonce: String?, - ): String { - val scopeString = scopes.joinToString(",") - val authToken = token.orEmpty() - val version = if (nonce.isNullOrBlank()) "v1" else "v2" - val parts = - mutableListOf( - version, - deviceId, - clientId, - clientMode, - role, - scopeString, - signedAtMs.toString(), - authToken, - ) - if (!nonce.isNullOrBlank()) { - parts.add(nonce) - } - return parts.joinToString("|") - } - - private fun normalizeCanvasHostUrl(raw: String?, endpoint: GatewayEndpoint): String? { - val trimmed = raw?.trim().orEmpty() - val parsed = trimmed.takeIf { it.isNotBlank() }?.let { runCatching { java.net.URI(it) }.getOrNull() } - val host = parsed?.host?.trim().orEmpty() - val port = parsed?.port ?: -1 - val scheme = parsed?.scheme?.trim().orEmpty().ifBlank { "http" } - - if (trimmed.isNotBlank() && !isLoopbackHost(host)) { - return trimmed - } - - val fallbackHost = - endpoint.tailnetDns?.trim().takeIf { !it.isNullOrEmpty() } - ?: endpoint.lanHost?.trim().takeIf { !it.isNullOrEmpty() } - ?: endpoint.host.trim() - if (fallbackHost.isEmpty()) return trimmed.ifBlank { null } - - val fallbackPort = endpoint.canvasPort ?: if (port > 0) port else 18793 - val formattedHost = if (fallbackHost.contains(":")) "[${fallbackHost}]" else fallbackHost - return "$scheme://$formattedHost:$fallbackPort" - } - - private fun isLoopbackHost(raw: String?): Boolean { - val host = raw?.trim()?.lowercase().orEmpty() - if (host.isEmpty()) return false - if (host == "localhost") return true - if (host == "::1") return true - if (host == "0.0.0.0" || host == "::") return true - return host.startsWith("127.") - } -} - -private fun JsonElement?.asObjectOrNull(): JsonObject? = this as? JsonObject - -private fun JsonElement?.asStringOrNull(): String? = - when (this) { - is JsonNull -> null - is JsonPrimitive -> content - else -> null - } - -private fun JsonElement?.asBooleanOrNull(): Boolean? = - when (this) { - is JsonPrimitive -> { - val c = content.trim() - when { - c.equals("true", ignoreCase = true) -> true - c.equals("false", ignoreCase = true) -> false - else -> null - } - } - else -> null - } - -private fun JsonElement?.asLongOrNull(): Long? = - when (this) { - is JsonPrimitive -> content.toLongOrNull() - else -> null - } - -private fun parseJsonOrNull(payload: String): JsonElement? { - val trimmed = payload.trim() - if (trimmed.isEmpty()) return null - return try { - Json.parseToJsonElement(trimmed) - } catch (_: Throwable) { - null - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayTls.kt b/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayTls.kt deleted file mode 100644 index bcca51583..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/gateway/GatewayTls.kt +++ /dev/null @@ -1,90 +0,0 @@ -package com.clawdbot.android.gateway - -import android.annotation.SuppressLint -import java.security.MessageDigest -import java.security.SecureRandom -import java.security.cert.CertificateException -import java.security.cert.X509Certificate -import javax.net.ssl.HostnameVerifier -import javax.net.ssl.SSLContext -import javax.net.ssl.SSLSocketFactory -import javax.net.ssl.TrustManagerFactory -import javax.net.ssl.X509TrustManager - -data class GatewayTlsParams( - val required: Boolean, - val expectedFingerprint: String?, - val allowTOFU: Boolean, - val stableId: String, -) - -data class GatewayTlsConfig( - val sslSocketFactory: SSLSocketFactory, - val trustManager: X509TrustManager, - val hostnameVerifier: HostnameVerifier, -) - -fun buildGatewayTlsConfig( - params: GatewayTlsParams?, - onStore: ((String) -> Unit)? = null, -): GatewayTlsConfig? { - if (params == null) return null - val expected = params.expectedFingerprint?.let(::normalizeFingerprint) - val defaultTrust = defaultTrustManager() - @SuppressLint("CustomX509TrustManager") - val trustManager = - object : X509TrustManager { - override fun checkClientTrusted(chain: Array, authType: String) { - defaultTrust.checkClientTrusted(chain, authType) - } - - override fun checkServerTrusted(chain: Array, authType: String) { - if (chain.isEmpty()) throw CertificateException("empty certificate chain") - val fingerprint = sha256Hex(chain[0].encoded) - if (expected != null) { - if (fingerprint != expected) { - throw CertificateException("gateway TLS fingerprint mismatch") - } - return - } - if (params.allowTOFU) { - onStore?.invoke(fingerprint) - return - } - defaultTrust.checkServerTrusted(chain, authType) - } - - override fun getAcceptedIssuers(): Array = defaultTrust.acceptedIssuers - } - - val context = SSLContext.getInstance("TLS") - context.init(null, arrayOf(trustManager), SecureRandom()) - return GatewayTlsConfig( - sslSocketFactory = context.socketFactory, - trustManager = trustManager, - hostnameVerifier = HostnameVerifier { _, _ -> true }, - ) -} - -private fun defaultTrustManager(): X509TrustManager { - val factory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()) - factory.init(null as java.security.KeyStore?) - val trust = - factory.trustManagers.firstOrNull { it is X509TrustManager } as? X509TrustManager - return trust ?: throw IllegalStateException("No default X509TrustManager found") -} - -private fun sha256Hex(data: ByteArray): String { - val digest = MessageDigest.getInstance("SHA-256").digest(data) - val out = StringBuilder(digest.size * 2) - for (byte in digest) { - out.append(String.format("%02x", byte)) - } - return out.toString() -} - -private fun normalizeFingerprint(raw: String): String { - val stripped = raw.trim() - .replace(Regex("^sha-?256\\s*:?\\s*", RegexOption.IGNORE_CASE), "") - return stripped.lowercase().filter { it in '0'..'9' || it in 'a'..'f' } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/node/CameraCaptureManager.kt b/apps/android/app/src/main/java/com/clawdbot/android/node/CameraCaptureManager.kt deleted file mode 100644 index f4c4d5794..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/node/CameraCaptureManager.kt +++ /dev/null @@ -1,316 +0,0 @@ -package com.clawdbot.android.node - -import android.Manifest -import android.content.Context -import android.annotation.SuppressLint -import android.graphics.Bitmap -import android.graphics.BitmapFactory -import android.graphics.Matrix -import android.util.Base64 -import android.content.pm.PackageManager -import androidx.exifinterface.media.ExifInterface -import androidx.lifecycle.LifecycleOwner -import androidx.camera.core.CameraSelector -import androidx.camera.core.ImageCapture -import androidx.camera.core.ImageCaptureException -import androidx.camera.lifecycle.ProcessCameraProvider -import androidx.camera.video.FileOutputOptions -import androidx.camera.video.Recorder -import androidx.camera.video.Recording -import androidx.camera.video.VideoCapture -import androidx.camera.video.VideoRecordEvent -import androidx.core.content.ContextCompat -import androidx.core.content.ContextCompat.checkSelfPermission -import androidx.core.graphics.scale -import com.clawdbot.android.PermissionRequester -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.suspendCancellableCoroutine -import kotlinx.coroutines.withTimeout -import kotlinx.coroutines.withContext -import java.io.ByteArrayOutputStream -import java.io.File -import java.util.concurrent.Executor -import kotlin.math.roundToInt -import kotlin.coroutines.resume -import kotlin.coroutines.resumeWithException - -class CameraCaptureManager(private val context: Context) { - data class Payload(val payloadJson: String) - - @Volatile private var lifecycleOwner: LifecycleOwner? = null - @Volatile private var permissionRequester: PermissionRequester? = null - - fun attachLifecycleOwner(owner: LifecycleOwner) { - lifecycleOwner = owner - } - - fun attachPermissionRequester(requester: PermissionRequester) { - permissionRequester = requester - } - - private suspend fun ensureCameraPermission() { - val granted = checkSelfPermission(context, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED - if (granted) return - - val requester = permissionRequester - ?: throw IllegalStateException("CAMERA_PERMISSION_REQUIRED: grant Camera permission") - val results = requester.requestIfMissing(listOf(Manifest.permission.CAMERA)) - if (results[Manifest.permission.CAMERA] != true) { - throw IllegalStateException("CAMERA_PERMISSION_REQUIRED: grant Camera permission") - } - } - - private suspend fun ensureMicPermission() { - val granted = checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED - if (granted) return - - val requester = permissionRequester - ?: throw IllegalStateException("MIC_PERMISSION_REQUIRED: grant Microphone permission") - val results = requester.requestIfMissing(listOf(Manifest.permission.RECORD_AUDIO)) - if (results[Manifest.permission.RECORD_AUDIO] != true) { - throw IllegalStateException("MIC_PERMISSION_REQUIRED: grant Microphone permission") - } - } - - suspend fun snap(paramsJson: String?): Payload = - withContext(Dispatchers.Main) { - ensureCameraPermission() - val owner = lifecycleOwner ?: throw IllegalStateException("UNAVAILABLE: camera not ready") - val facing = parseFacing(paramsJson) ?: "front" - val quality = (parseQuality(paramsJson) ?: 0.9).coerceIn(0.1, 1.0) - val maxWidth = parseMaxWidth(paramsJson) - - val provider = context.cameraProvider() - val capture = ImageCapture.Builder().build() - val selector = - if (facing == "front") CameraSelector.DEFAULT_FRONT_CAMERA else CameraSelector.DEFAULT_BACK_CAMERA - - provider.unbindAll() - provider.bindToLifecycle(owner, selector, capture) - - val (bytes, orientation) = capture.takeJpegWithExif(context.mainExecutor()) - val decoded = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) - ?: throw IllegalStateException("UNAVAILABLE: failed to decode captured image") - val rotated = rotateBitmapByExif(decoded, orientation) - val scaled = - if (maxWidth != null && maxWidth > 0 && rotated.width > maxWidth) { - val h = - (rotated.height.toDouble() * (maxWidth.toDouble() / rotated.width.toDouble())) - .toInt() - .coerceAtLeast(1) - rotated.scale(maxWidth, h) - } else { - rotated - } - - val maxPayloadBytes = 5 * 1024 * 1024 - // Base64 inflates payloads by ~4/3; cap encoded bytes so the payload stays under 5MB (API limit). - val maxEncodedBytes = (maxPayloadBytes / 4) * 3 - val result = - JpegSizeLimiter.compressToLimit( - initialWidth = scaled.width, - initialHeight = scaled.height, - startQuality = (quality * 100.0).roundToInt().coerceIn(10, 100), - maxBytes = maxEncodedBytes, - encode = { width, height, q -> - val bitmap = - if (width == scaled.width && height == scaled.height) { - scaled - } else { - scaled.scale(width, height) - } - val out = ByteArrayOutputStream() - if (!bitmap.compress(Bitmap.CompressFormat.JPEG, q, out)) { - if (bitmap !== scaled) bitmap.recycle() - throw IllegalStateException("UNAVAILABLE: failed to encode JPEG") - } - if (bitmap !== scaled) { - bitmap.recycle() - } - out.toByteArray() - }, - ) - val base64 = Base64.encodeToString(result.bytes, Base64.NO_WRAP) - Payload( - """{"format":"jpg","base64":"$base64","width":${result.width},"height":${result.height}}""", - ) - } - - @SuppressLint("MissingPermission") - suspend fun clip(paramsJson: String?): Payload = - withContext(Dispatchers.Main) { - ensureCameraPermission() - val owner = lifecycleOwner ?: throw IllegalStateException("UNAVAILABLE: camera not ready") - val facing = parseFacing(paramsJson) ?: "front" - val durationMs = (parseDurationMs(paramsJson) ?: 3_000).coerceIn(200, 60_000) - val includeAudio = parseIncludeAudio(paramsJson) ?: true - if (includeAudio) ensureMicPermission() - - val provider = context.cameraProvider() - val recorder = Recorder.Builder().build() - val videoCapture = VideoCapture.withOutput(recorder) - val selector = - if (facing == "front") CameraSelector.DEFAULT_FRONT_CAMERA else CameraSelector.DEFAULT_BACK_CAMERA - - provider.unbindAll() - provider.bindToLifecycle(owner, selector, videoCapture) - - val file = File.createTempFile("moltbot-clip-", ".mp4") - val outputOptions = FileOutputOptions.Builder(file).build() - - val finalized = kotlinx.coroutines.CompletableDeferred() - val recording: Recording = - videoCapture.output - .prepareRecording(context, outputOptions) - .apply { - if (includeAudio) withAudioEnabled() - } - .start(context.mainExecutor()) { event -> - if (event is VideoRecordEvent.Finalize) { - finalized.complete(event) - } - } - - try { - kotlinx.coroutines.delay(durationMs.toLong()) - } finally { - recording.stop() - } - - val finalizeEvent = - try { - withTimeout(10_000) { finalized.await() } - } catch (err: Throwable) { - file.delete() - throw IllegalStateException("UNAVAILABLE: camera clip finalize timed out") - } - if (finalizeEvent.hasError()) { - file.delete() - throw IllegalStateException("UNAVAILABLE: camera clip failed") - } - - val bytes = file.readBytes() - file.delete() - val base64 = Base64.encodeToString(bytes, Base64.NO_WRAP) - Payload( - """{"format":"mp4","base64":"$base64","durationMs":$durationMs,"hasAudio":${includeAudio}}""", - ) - } - - private fun rotateBitmapByExif(bitmap: Bitmap, orientation: Int): Bitmap { - val matrix = Matrix() - when (orientation) { - ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f) - ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f) - ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f) - ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.postScale(-1f, 1f) - ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.postScale(1f, -1f) - ExifInterface.ORIENTATION_TRANSPOSE -> { - matrix.postRotate(90f) - matrix.postScale(-1f, 1f) - } - ExifInterface.ORIENTATION_TRANSVERSE -> { - matrix.postRotate(-90f) - matrix.postScale(-1f, 1f) - } - else -> return bitmap - } - val rotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true) - if (rotated !== bitmap) { - bitmap.recycle() - } - return rotated - } - - private fun parseFacing(paramsJson: String?): String? = - when { - paramsJson?.contains("\"front\"") == true -> "front" - paramsJson?.contains("\"back\"") == true -> "back" - else -> null - } - - private fun parseQuality(paramsJson: String?): Double? = - parseNumber(paramsJson, key = "quality")?.toDoubleOrNull() - - private fun parseMaxWidth(paramsJson: String?): Int? = - parseNumber(paramsJson, key = "maxWidth")?.toIntOrNull() - - private fun parseDurationMs(paramsJson: String?): Int? = - parseNumber(paramsJson, key = "durationMs")?.toIntOrNull() - - private fun parseIncludeAudio(paramsJson: String?): Boolean? { - val raw = paramsJson ?: return null - val key = "\"includeAudio\"" - val idx = raw.indexOf(key) - if (idx < 0) return null - val colon = raw.indexOf(':', idx + key.length) - if (colon < 0) return null - val tail = raw.substring(colon + 1).trimStart() - return when { - tail.startsWith("true") -> true - tail.startsWith("false") -> false - else -> null - } - } - - private fun parseNumber(paramsJson: String?, key: String): String? { - val raw = paramsJson ?: return null - val needle = "\"$key\"" - val idx = raw.indexOf(needle) - if (idx < 0) return null - val colon = raw.indexOf(':', idx + needle.length) - if (colon < 0) return null - val tail = raw.substring(colon + 1).trimStart() - return tail.takeWhile { it.isDigit() || it == '.' } - } - - private fun Context.mainExecutor(): Executor = ContextCompat.getMainExecutor(this) -} - -private suspend fun Context.cameraProvider(): ProcessCameraProvider = - suspendCancellableCoroutine { cont -> - val future = ProcessCameraProvider.getInstance(this) - future.addListener( - { - try { - cont.resume(future.get()) - } catch (e: Exception) { - cont.resumeWithException(e) - } - }, - ContextCompat.getMainExecutor(this), - ) - } - -/** Returns (jpegBytes, exifOrientation) so caller can rotate the decoded bitmap. */ -private suspend fun ImageCapture.takeJpegWithExif(executor: Executor): Pair = - suspendCancellableCoroutine { cont -> - val file = File.createTempFile("moltbot-snap-", ".jpg") - val options = ImageCapture.OutputFileOptions.Builder(file).build() - takePicture( - options, - executor, - object : ImageCapture.OnImageSavedCallback { - override fun onError(exception: ImageCaptureException) { - file.delete() - cont.resumeWithException(exception) - } - - override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) { - try { - val exif = ExifInterface(file.absolutePath) - val orientation = exif.getAttributeInt( - ExifInterface.TAG_ORIENTATION, - ExifInterface.ORIENTATION_NORMAL, - ) - val bytes = file.readBytes() - cont.resume(Pair(bytes, orientation)) - } catch (e: Exception) { - cont.resumeWithException(e) - } finally { - file.delete() - } - } - }, - ) - } diff --git a/apps/android/app/src/main/java/com/clawdbot/android/node/CanvasController.kt b/apps/android/app/src/main/java/com/clawdbot/android/node/CanvasController.kt deleted file mode 100644 index 4c955f7ea..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/node/CanvasController.kt +++ /dev/null @@ -1,264 +0,0 @@ -package com.clawdbot.android.node - -import android.graphics.Bitmap -import android.graphics.Canvas -import android.os.Looper -import android.util.Log -import android.webkit.WebView -import androidx.core.graphics.createBitmap -import androidx.core.graphics.scale -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.suspendCancellableCoroutine -import kotlinx.coroutines.withContext -import java.io.ByteArrayOutputStream -import android.util.Base64 -import org.json.JSONObject -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonElement -import kotlinx.serialization.json.JsonObject -import kotlinx.serialization.json.JsonPrimitive -import com.clawdbot.android.BuildConfig -import kotlin.coroutines.resume - -class CanvasController { - enum class SnapshotFormat(val rawValue: String) { - Png("png"), - Jpeg("jpeg"), - } - - @Volatile private var webView: WebView? = null - @Volatile private var url: String? = null - @Volatile private var debugStatusEnabled: Boolean = false - @Volatile private var debugStatusTitle: String? = null - @Volatile private var debugStatusSubtitle: String? = null - - private val scaffoldAssetUrl = "file:///android_asset/CanvasScaffold/scaffold.html" - - private fun clampJpegQuality(quality: Double?): Int { - val q = (quality ?: 0.82).coerceIn(0.1, 1.0) - return (q * 100.0).toInt().coerceIn(1, 100) - } - - fun attach(webView: WebView) { - this.webView = webView - reload() - applyDebugStatus() - } - - fun navigate(url: String) { - val trimmed = url.trim() - this.url = if (trimmed.isBlank() || trimmed == "/") null else trimmed - reload() - } - - fun currentUrl(): String? = url - - fun isDefaultCanvas(): Boolean = url == null - - fun setDebugStatusEnabled(enabled: Boolean) { - debugStatusEnabled = enabled - applyDebugStatus() - } - - fun setDebugStatus(title: String?, subtitle: String?) { - debugStatusTitle = title - debugStatusSubtitle = subtitle - applyDebugStatus() - } - - fun onPageFinished() { - applyDebugStatus() - } - - private inline fun withWebViewOnMain(crossinline block: (WebView) -> Unit) { - val wv = webView ?: return - if (Looper.myLooper() == Looper.getMainLooper()) { - block(wv) - } else { - wv.post { block(wv) } - } - } - - private fun reload() { - val currentUrl = url - withWebViewOnMain { wv -> - if (currentUrl == null) { - if (BuildConfig.DEBUG) { - Log.d("MoltbotCanvas", "load scaffold: $scaffoldAssetUrl") - } - wv.loadUrl(scaffoldAssetUrl) - } else { - if (BuildConfig.DEBUG) { - Log.d("MoltbotCanvas", "load url: $currentUrl") - } - wv.loadUrl(currentUrl) - } - } - } - - private fun applyDebugStatus() { - val enabled = debugStatusEnabled - val title = debugStatusTitle - val subtitle = debugStatusSubtitle - withWebViewOnMain { wv -> - val titleJs = title?.let { JSONObject.quote(it) } ?: "null" - val subtitleJs = subtitle?.let { JSONObject.quote(it) } ?: "null" - val js = """ - (() => { - try { - const api = globalThis.__moltbot; - if (!api) return; - if (typeof api.setDebugStatusEnabled === 'function') { - api.setDebugStatusEnabled(${if (enabled) "true" else "false"}); - } - if (!${if (enabled) "true" else "false"}) return; - if (typeof api.setStatus === 'function') { - api.setStatus($titleJs, $subtitleJs); - } - } catch (_) {} - })(); - """.trimIndent() - wv.evaluateJavascript(js, null) - } - } - - suspend fun eval(javaScript: String): String = - withContext(Dispatchers.Main) { - val wv = webView ?: throw IllegalStateException("no webview") - suspendCancellableCoroutine { cont -> - wv.evaluateJavascript(javaScript) { result -> - cont.resume(result ?: "") - } - } - } - - suspend fun snapshotPngBase64(maxWidth: Int?): String = - withContext(Dispatchers.Main) { - val wv = webView ?: throw IllegalStateException("no webview") - val bmp = wv.captureBitmap() - val scaled = - if (maxWidth != null && maxWidth > 0 && bmp.width > maxWidth) { - val h = (bmp.height.toDouble() * (maxWidth.toDouble() / bmp.width.toDouble())).toInt().coerceAtLeast(1) - bmp.scale(maxWidth, h) - } else { - bmp - } - - val out = ByteArrayOutputStream() - scaled.compress(Bitmap.CompressFormat.PNG, 100, out) - Base64.encodeToString(out.toByteArray(), Base64.NO_WRAP) - } - - suspend fun snapshotBase64(format: SnapshotFormat, quality: Double?, maxWidth: Int?): String = - withContext(Dispatchers.Main) { - val wv = webView ?: throw IllegalStateException("no webview") - val bmp = wv.captureBitmap() - val scaled = - if (maxWidth != null && maxWidth > 0 && bmp.width > maxWidth) { - val h = (bmp.height.toDouble() * (maxWidth.toDouble() / bmp.width.toDouble())).toInt().coerceAtLeast(1) - bmp.scale(maxWidth, h) - } else { - bmp - } - - val out = ByteArrayOutputStream() - val (compressFormat, compressQuality) = - when (format) { - SnapshotFormat.Png -> Bitmap.CompressFormat.PNG to 100 - SnapshotFormat.Jpeg -> Bitmap.CompressFormat.JPEG to clampJpegQuality(quality) - } - scaled.compress(compressFormat, compressQuality, out) - Base64.encodeToString(out.toByteArray(), Base64.NO_WRAP) - } - - private suspend fun WebView.captureBitmap(): Bitmap = - suspendCancellableCoroutine { cont -> - val width = width.coerceAtLeast(1) - val height = height.coerceAtLeast(1) - val bitmap = createBitmap(width, height, Bitmap.Config.ARGB_8888) - - // WebView isn't supported by PixelCopy.request(...) directly; draw() is the most reliable - // cross-version snapshot for this lightweight "canvas" use-case. - draw(Canvas(bitmap)) - cont.resume(bitmap) - } - - companion object { - data class SnapshotParams(val format: SnapshotFormat, val quality: Double?, val maxWidth: Int?) - - fun parseNavigateUrl(paramsJson: String?): String { - val obj = parseParamsObject(paramsJson) ?: return "" - return obj.string("url").trim() - } - - fun parseEvalJs(paramsJson: String?): String? { - val obj = parseParamsObject(paramsJson) ?: return null - val js = obj.string("javaScript").trim() - return js.takeIf { it.isNotBlank() } - } - - fun parseSnapshotMaxWidth(paramsJson: String?): Int? { - val obj = parseParamsObject(paramsJson) ?: return null - if (!obj.containsKey("maxWidth")) return null - val width = obj.int("maxWidth") ?: 0 - return width.takeIf { it > 0 } - } - - fun parseSnapshotFormat(paramsJson: String?): SnapshotFormat { - val obj = parseParamsObject(paramsJson) ?: return SnapshotFormat.Jpeg - val raw = obj.string("format").trim().lowercase() - return when (raw) { - "png" -> SnapshotFormat.Png - "jpeg", "jpg" -> SnapshotFormat.Jpeg - "" -> SnapshotFormat.Jpeg - else -> SnapshotFormat.Jpeg - } - } - - fun parseSnapshotQuality(paramsJson: String?): Double? { - val obj = parseParamsObject(paramsJson) ?: return null - if (!obj.containsKey("quality")) return null - val q = obj.double("quality") ?: Double.NaN - if (!q.isFinite()) return null - return q.coerceIn(0.1, 1.0) - } - - fun parseSnapshotParams(paramsJson: String?): SnapshotParams { - return SnapshotParams( - format = parseSnapshotFormat(paramsJson), - quality = parseSnapshotQuality(paramsJson), - maxWidth = parseSnapshotMaxWidth(paramsJson), - ) - } - - private val json = Json { ignoreUnknownKeys = true } - - private fun parseParamsObject(paramsJson: String?): JsonObject? { - val raw = paramsJson?.trim().orEmpty() - if (raw.isEmpty()) return null - return try { - json.parseToJsonElement(raw).asObjectOrNull() - } catch (_: Throwable) { - null - } - } - - private fun JsonElement?.asObjectOrNull(): JsonObject? = this as? JsonObject - - private fun JsonObject.string(key: String): String { - val prim = this[key] as? JsonPrimitive ?: return "" - val raw = prim.content - return raw.takeIf { it != "null" }.orEmpty() - } - - private fun JsonObject.int(key: String): Int? { - val prim = this[key] as? JsonPrimitive ?: return null - return prim.content.toIntOrNull() - } - - private fun JsonObject.double(key: String): Double? { - val prim = this[key] as? JsonPrimitive ?: return null - return prim.content.toDoubleOrNull() - } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/node/JpegSizeLimiter.kt b/apps/android/app/src/main/java/com/clawdbot/android/node/JpegSizeLimiter.kt deleted file mode 100644 index ec71e9a4b..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/node/JpegSizeLimiter.kt +++ /dev/null @@ -1,61 +0,0 @@ -package com.clawdbot.android.node - -import kotlin.math.max -import kotlin.math.min -import kotlin.math.roundToInt - -internal data class JpegSizeLimiterResult( - val bytes: ByteArray, - val width: Int, - val height: Int, - val quality: Int, -) - -internal object JpegSizeLimiter { - fun compressToLimit( - initialWidth: Int, - initialHeight: Int, - startQuality: Int, - maxBytes: Int, - minQuality: Int = 20, - minSize: Int = 256, - scaleStep: Double = 0.85, - maxScaleAttempts: Int = 6, - maxQualityAttempts: Int = 6, - encode: (width: Int, height: Int, quality: Int) -> ByteArray, - ): JpegSizeLimiterResult { - require(initialWidth > 0 && initialHeight > 0) { "Invalid image size" } - require(maxBytes > 0) { "Invalid maxBytes" } - - var width = initialWidth - var height = initialHeight - val clampedStartQuality = startQuality.coerceIn(minQuality, 100) - var best = JpegSizeLimiterResult(bytes = encode(width, height, clampedStartQuality), width = width, height = height, quality = clampedStartQuality) - if (best.bytes.size <= maxBytes) return best - - repeat(maxScaleAttempts) { - var quality = clampedStartQuality - repeat(maxQualityAttempts) { - val bytes = encode(width, height, quality) - best = JpegSizeLimiterResult(bytes = bytes, width = width, height = height, quality = quality) - if (bytes.size <= maxBytes) return best - if (quality <= minQuality) return@repeat - quality = max(minQuality, (quality * 0.75).roundToInt()) - } - - val minScale = (minSize.toDouble() / min(width, height).toDouble()).coerceAtMost(1.0) - val nextScale = max(scaleStep, minScale) - val nextWidth = max(minSize, (width * nextScale).roundToInt()) - val nextHeight = max(minSize, (height * nextScale).roundToInt()) - if (nextWidth == width && nextHeight == height) return@repeat - width = min(nextWidth, width) - height = min(nextHeight, height) - } - - if (best.bytes.size > maxBytes) { - throw IllegalStateException("CAMERA_TOO_LARGE: ${best.bytes.size} bytes > $maxBytes bytes") - } - - return best - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/node/LocationCaptureManager.kt b/apps/android/app/src/main/java/com/clawdbot/android/node/LocationCaptureManager.kt deleted file mode 100644 index c701be70d..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/node/LocationCaptureManager.kt +++ /dev/null @@ -1,117 +0,0 @@ -package com.clawdbot.android.node - -import android.Manifest -import android.content.Context -import android.content.pm.PackageManager -import android.location.Location -import android.location.LocationManager -import android.os.CancellationSignal -import androidx.core.content.ContextCompat -import java.time.Instant -import java.time.format.DateTimeFormatter -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.withContext -import kotlinx.coroutines.withTimeout -import kotlin.coroutines.resume -import kotlin.coroutines.resumeWithException -import kotlinx.coroutines.suspendCancellableCoroutine - -class LocationCaptureManager(private val context: Context) { - data class Payload(val payloadJson: String) - - suspend fun getLocation( - desiredProviders: List, - maxAgeMs: Long?, - timeoutMs: Long, - isPrecise: Boolean, - ): Payload = - withContext(Dispatchers.Main) { - val manager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager - if (!manager.isProviderEnabled(LocationManager.GPS_PROVIDER) && - !manager.isProviderEnabled(LocationManager.NETWORK_PROVIDER) - ) { - throw IllegalStateException("LOCATION_UNAVAILABLE: no location providers enabled") - } - - val cached = bestLastKnown(manager, desiredProviders, maxAgeMs) - val location = - cached ?: requestCurrent(manager, desiredProviders, timeoutMs) - - val timestamp = DateTimeFormatter.ISO_INSTANT.format(Instant.ofEpochMilli(location.time)) - val source = location.provider - val altitudeMeters = if (location.hasAltitude()) location.altitude else null - val speedMps = if (location.hasSpeed()) location.speed.toDouble() else null - val headingDeg = if (location.hasBearing()) location.bearing.toDouble() else null - Payload( - buildString { - append("{\"lat\":") - append(location.latitude) - append(",\"lon\":") - append(location.longitude) - append(",\"accuracyMeters\":") - append(location.accuracy.toDouble()) - if (altitudeMeters != null) append(",\"altitudeMeters\":").append(altitudeMeters) - if (speedMps != null) append(",\"speedMps\":").append(speedMps) - if (headingDeg != null) append(",\"headingDeg\":").append(headingDeg) - append(",\"timestamp\":\"").append(timestamp).append('"') - append(",\"isPrecise\":").append(isPrecise) - append(",\"source\":\"").append(source).append('"') - append('}') - }, - ) - } - - private fun bestLastKnown( - manager: LocationManager, - providers: List, - maxAgeMs: Long?, - ): Location? { - val fineOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == - PackageManager.PERMISSION_GRANTED - val coarseOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == - PackageManager.PERMISSION_GRANTED - if (!fineOk && !coarseOk) { - throw IllegalStateException("LOCATION_PERMISSION_REQUIRED: grant Location permission") - } - val now = System.currentTimeMillis() - val candidates = - providers.mapNotNull { provider -> manager.getLastKnownLocation(provider) } - val freshest = candidates.maxByOrNull { it.time } ?: return null - if (maxAgeMs != null && now - freshest.time > maxAgeMs) return null - return freshest - } - - private suspend fun requestCurrent( - manager: LocationManager, - providers: List, - timeoutMs: Long, - ): Location { - val fineOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == - PackageManager.PERMISSION_GRANTED - val coarseOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == - PackageManager.PERMISSION_GRANTED - if (!fineOk && !coarseOk) { - throw IllegalStateException("LOCATION_PERMISSION_REQUIRED: grant Location permission") - } - val resolved = - providers.firstOrNull { manager.isProviderEnabled(it) } - ?: throw IllegalStateException("LOCATION_UNAVAILABLE: no providers available") - return withTimeout(timeoutMs.coerceAtLeast(1)) { - suspendCancellableCoroutine { cont -> - val signal = CancellationSignal() - cont.invokeOnCancellation { signal.cancel() } - manager.getCurrentLocation(resolved, signal, context.mainExecutor) { location -> - if (location != null) { - cont.resume(location) - } else { - cont.resumeWithException(IllegalStateException("LOCATION_UNAVAILABLE: no fix")) - } - } - } - } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/node/ScreenRecordManager.kt b/apps/android/app/src/main/java/com/clawdbot/android/node/ScreenRecordManager.kt deleted file mode 100644 index 4486fc5f0..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/node/ScreenRecordManager.kt +++ /dev/null @@ -1,199 +0,0 @@ -package com.clawdbot.android.node - -import android.content.Context -import android.hardware.display.DisplayManager -import android.media.MediaRecorder -import android.media.projection.MediaProjectionManager -import android.os.Build -import android.util.Base64 -import com.clawdbot.android.ScreenCaptureRequester -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.delay -import kotlinx.coroutines.withContext -import java.io.File -import kotlin.math.roundToInt - -class ScreenRecordManager(private val context: Context) { - data class Payload(val payloadJson: String) - - @Volatile private var screenCaptureRequester: ScreenCaptureRequester? = null - @Volatile private var permissionRequester: com.clawdbot.android.PermissionRequester? = null - - fun attachScreenCaptureRequester(requester: ScreenCaptureRequester) { - screenCaptureRequester = requester - } - - fun attachPermissionRequester(requester: com.clawdbot.android.PermissionRequester) { - permissionRequester = requester - } - - suspend fun record(paramsJson: String?): Payload = - withContext(Dispatchers.Default) { - val requester = - screenCaptureRequester - ?: throw IllegalStateException( - "SCREEN_PERMISSION_REQUIRED: grant Screen Recording permission", - ) - - val durationMs = (parseDurationMs(paramsJson) ?: 10_000).coerceIn(250, 60_000) - val fps = (parseFps(paramsJson) ?: 10.0).coerceIn(1.0, 60.0) - val fpsInt = fps.roundToInt().coerceIn(1, 60) - val screenIndex = parseScreenIndex(paramsJson) - val includeAudio = parseIncludeAudio(paramsJson) ?: true - val format = parseString(paramsJson, key = "format") - if (format != null && format.lowercase() != "mp4") { - throw IllegalArgumentException("INVALID_REQUEST: screen format must be mp4") - } - if (screenIndex != null && screenIndex != 0) { - throw IllegalArgumentException("INVALID_REQUEST: screenIndex must be 0 on Android") - } - - val capture = requester.requestCapture() - ?: throw IllegalStateException( - "SCREEN_PERMISSION_REQUIRED: grant Screen Recording permission", - ) - - val mgr = - context.getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager - val projection = mgr.getMediaProjection(capture.resultCode, capture.data) - ?: throw IllegalStateException("UNAVAILABLE: screen capture unavailable") - - val metrics = context.resources.displayMetrics - val width = metrics.widthPixels - val height = metrics.heightPixels - val densityDpi = metrics.densityDpi - - val file = File.createTempFile("moltbot-screen-", ".mp4") - if (includeAudio) ensureMicPermission() - - val recorder = createMediaRecorder() - var virtualDisplay: android.hardware.display.VirtualDisplay? = null - try { - if (includeAudio) { - recorder.setAudioSource(MediaRecorder.AudioSource.MIC) - } - recorder.setVideoSource(MediaRecorder.VideoSource.SURFACE) - recorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4) - recorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264) - if (includeAudio) { - recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC) - recorder.setAudioChannels(1) - recorder.setAudioSamplingRate(44_100) - recorder.setAudioEncodingBitRate(96_000) - } - recorder.setVideoSize(width, height) - recorder.setVideoFrameRate(fpsInt) - recorder.setVideoEncodingBitRate(estimateBitrate(width, height, fpsInt)) - recorder.setOutputFile(file.absolutePath) - recorder.prepare() - - val surface = recorder.surface - virtualDisplay = - projection.createVirtualDisplay( - "moltbot-screen", - width, - height, - densityDpi, - DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR, - surface, - null, - null, - ) - - recorder.start() - delay(durationMs.toLong()) - } finally { - try { - recorder.stop() - } catch (_: Throwable) { - // ignore - } - recorder.reset() - recorder.release() - virtualDisplay?.release() - projection.stop() - } - - val bytes = withContext(Dispatchers.IO) { file.readBytes() } - file.delete() - val base64 = Base64.encodeToString(bytes, Base64.NO_WRAP) - Payload( - """{"format":"mp4","base64":"$base64","durationMs":$durationMs,"fps":$fpsInt,"screenIndex":0,"hasAudio":$includeAudio}""", - ) - } - - private fun createMediaRecorder(): MediaRecorder = MediaRecorder(context) - - private suspend fun ensureMicPermission() { - val granted = - androidx.core.content.ContextCompat.checkSelfPermission( - context, - android.Manifest.permission.RECORD_AUDIO, - ) == android.content.pm.PackageManager.PERMISSION_GRANTED - if (granted) return - - val requester = - permissionRequester - ?: throw IllegalStateException("MIC_PERMISSION_REQUIRED: grant Microphone permission") - val results = requester.requestIfMissing(listOf(android.Manifest.permission.RECORD_AUDIO)) - if (results[android.Manifest.permission.RECORD_AUDIO] != true) { - throw IllegalStateException("MIC_PERMISSION_REQUIRED: grant Microphone permission") - } - } - - private fun parseDurationMs(paramsJson: String?): Int? = - parseNumber(paramsJson, key = "durationMs")?.toIntOrNull() - - private fun parseFps(paramsJson: String?): Double? = - parseNumber(paramsJson, key = "fps")?.toDoubleOrNull() - - private fun parseScreenIndex(paramsJson: String?): Int? = - parseNumber(paramsJson, key = "screenIndex")?.toIntOrNull() - - private fun parseIncludeAudio(paramsJson: String?): Boolean? { - val raw = paramsJson ?: return null - val key = "\"includeAudio\"" - val idx = raw.indexOf(key) - if (idx < 0) return null - val colon = raw.indexOf(':', idx + key.length) - if (colon < 0) return null - val tail = raw.substring(colon + 1).trimStart() - return when { - tail.startsWith("true") -> true - tail.startsWith("false") -> false - else -> null - } - } - - private fun parseNumber(paramsJson: String?, key: String): String? { - val raw = paramsJson ?: return null - val needle = "\"$key\"" - val idx = raw.indexOf(needle) - if (idx < 0) return null - val colon = raw.indexOf(':', idx + needle.length) - if (colon < 0) return null - val tail = raw.substring(colon + 1).trimStart() - return tail.takeWhile { it.isDigit() || it == '.' || it == '-' } - } - - private fun parseString(paramsJson: String?, key: String): String? { - val raw = paramsJson ?: return null - val needle = "\"$key\"" - val idx = raw.indexOf(needle) - if (idx < 0) return null - val colon = raw.indexOf(':', idx + needle.length) - if (colon < 0) return null - val tail = raw.substring(colon + 1).trimStart() - if (!tail.startsWith('\"')) return null - val rest = tail.drop(1) - val end = rest.indexOf('\"') - if (end < 0) return null - return rest.substring(0, end) - } - - private fun estimateBitrate(width: Int, height: Int, fps: Int): Int { - val pixels = width.toLong() * height.toLong() - val raw = (pixels * fps.toLong() * 2L).toInt() - return raw.coerceIn(1_000_000, 12_000_000) - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/node/SmsManager.kt b/apps/android/app/src/main/java/com/clawdbot/android/node/SmsManager.kt deleted file mode 100644 index 3e12a56df..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/node/SmsManager.kt +++ /dev/null @@ -1,230 +0,0 @@ -package com.clawdbot.android.node - -import android.Manifest -import android.content.Context -import android.content.pm.PackageManager -import android.telephony.SmsManager as AndroidSmsManager -import androidx.core.content.ContextCompat -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonElement -import kotlinx.serialization.json.JsonObject -import kotlinx.serialization.json.JsonPrimitive -import kotlinx.serialization.json.jsonObject -import kotlinx.serialization.encodeToString -import com.clawdbot.android.PermissionRequester - -/** - * Sends SMS messages via the Android SMS API. - * Requires SEND_SMS permission to be granted. - */ -class SmsManager(private val context: Context) { - - private val json = JsonConfig - @Volatile private var permissionRequester: PermissionRequester? = null - - data class SendResult( - val ok: Boolean, - val to: String, - val message: String?, - val error: String? = null, - val payloadJson: String, - ) - - internal data class ParsedParams( - val to: String, - val message: String, - ) - - internal sealed class ParseResult { - data class Ok(val params: ParsedParams) : ParseResult() - data class Error( - val error: String, - val to: String = "", - val message: String? = null, - ) : ParseResult() - } - - internal data class SendPlan( - val parts: List, - val useMultipart: Boolean, - ) - - companion object { - internal val JsonConfig = Json { ignoreUnknownKeys = true } - - internal fun parseParams(paramsJson: String?, json: Json = JsonConfig): ParseResult { - val params = paramsJson?.trim().orEmpty() - if (params.isEmpty()) { - return ParseResult.Error(error = "INVALID_REQUEST: paramsJSON required") - } - - val obj = try { - json.parseToJsonElement(params).jsonObject - } catch (_: Throwable) { - null - } - - if (obj == null) { - return ParseResult.Error(error = "INVALID_REQUEST: expected JSON object") - } - - val to = (obj["to"] as? JsonPrimitive)?.content?.trim().orEmpty() - val message = (obj["message"] as? JsonPrimitive)?.content.orEmpty() - - if (to.isEmpty()) { - return ParseResult.Error( - error = "INVALID_REQUEST: 'to' phone number required", - message = message, - ) - } - - if (message.isEmpty()) { - return ParseResult.Error( - error = "INVALID_REQUEST: 'message' text required", - to = to, - ) - } - - return ParseResult.Ok(ParsedParams(to = to, message = message)) - } - - internal fun buildSendPlan( - message: String, - divider: (String) -> List, - ): SendPlan { - val parts = divider(message).ifEmpty { listOf(message) } - return SendPlan(parts = parts, useMultipart = parts.size > 1) - } - - internal fun buildPayloadJson( - json: Json = JsonConfig, - ok: Boolean, - to: String, - error: String?, - ): String { - val payload = - mutableMapOf( - "ok" to JsonPrimitive(ok), - "to" to JsonPrimitive(to), - ) - if (!ok) { - payload["error"] = JsonPrimitive(error ?: "SMS_SEND_FAILED") - } - return json.encodeToString(JsonObject.serializer(), JsonObject(payload)) - } - } - - fun hasSmsPermission(): Boolean { - return ContextCompat.checkSelfPermission( - context, - Manifest.permission.SEND_SMS - ) == PackageManager.PERMISSION_GRANTED - } - - fun canSendSms(): Boolean { - return hasSmsPermission() && hasTelephonyFeature() - } - - fun hasTelephonyFeature(): Boolean { - return context.packageManager?.hasSystemFeature(PackageManager.FEATURE_TELEPHONY) == true - } - - fun attachPermissionRequester(requester: PermissionRequester) { - permissionRequester = requester - } - - /** - * Send an SMS message. - * - * @param paramsJson JSON with "to" (phone number) and "message" (text) fields - * @return SendResult indicating success or failure - */ - suspend fun send(paramsJson: String?): SendResult { - if (!hasTelephonyFeature()) { - return errorResult( - error = "SMS_UNAVAILABLE: telephony not available", - ) - } - - if (!ensureSmsPermission()) { - return errorResult( - error = "SMS_PERMISSION_REQUIRED: grant SMS permission", - ) - } - - val parseResult = parseParams(paramsJson, json) - if (parseResult is ParseResult.Error) { - return errorResult( - error = parseResult.error, - to = parseResult.to, - message = parseResult.message, - ) - } - val params = (parseResult as ParseResult.Ok).params - - return try { - val smsManager = context.getSystemService(AndroidSmsManager::class.java) - ?: throw IllegalStateException("SMS_UNAVAILABLE: SmsManager not available") - - val plan = buildSendPlan(params.message) { smsManager.divideMessage(it) } - if (plan.useMultipart) { - smsManager.sendMultipartTextMessage( - params.to, // destination - null, // service center (null = default) - ArrayList(plan.parts), // message parts - null, // sent intents - null, // delivery intents - ) - } else { - smsManager.sendTextMessage( - params.to, // destination - null, // service center (null = default) - params.message,// message - null, // sent intent - null, // delivery intent - ) - } - - okResult(to = params.to, message = params.message) - } catch (e: SecurityException) { - errorResult( - error = "SMS_PERMISSION_REQUIRED: ${e.message}", - to = params.to, - message = params.message, - ) - } catch (e: Throwable) { - errorResult( - error = "SMS_SEND_FAILED: ${e.message ?: "unknown error"}", - to = params.to, - message = params.message, - ) - } - } - - private suspend fun ensureSmsPermission(): Boolean { - if (hasSmsPermission()) return true - val requester = permissionRequester ?: return false - val results = requester.requestIfMissing(listOf(Manifest.permission.SEND_SMS)) - return results[Manifest.permission.SEND_SMS] == true - } - - private fun okResult(to: String, message: String): SendResult { - return SendResult( - ok = true, - to = to, - message = message, - error = null, - payloadJson = buildPayloadJson(json = json, ok = true, to = to, error = null), - ) - } - - private fun errorResult(error: String, to: String = "", message: String? = null): SendResult { - return SendResult( - ok = false, - to = to, - message = message, - error = error, - payloadJson = buildPayloadJson(json = json, ok = false, to = to, error = error), - ) - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIAction.kt b/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIAction.kt deleted file mode 100644 index 4ff1a7421..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIAction.kt +++ /dev/null @@ -1,66 +0,0 @@ -package com.clawdbot.android.protocol - -import kotlinx.serialization.json.JsonObject -import kotlinx.serialization.json.JsonPrimitive - -object MoltbotCanvasA2UIAction { - fun extractActionName(userAction: JsonObject): String? { - val name = - (userAction["name"] as? JsonPrimitive) - ?.content - ?.trim() - .orEmpty() - if (name.isNotEmpty()) return name - val action = - (userAction["action"] as? JsonPrimitive) - ?.content - ?.trim() - .orEmpty() - return action.ifEmpty { null } - } - - fun sanitizeTagValue(value: String): String { - val trimmed = value.trim().ifEmpty { "-" } - val normalized = trimmed.replace(" ", "_") - val out = StringBuilder(normalized.length) - for (c in normalized) { - val ok = - c.isLetterOrDigit() || - c == '_' || - c == '-' || - c == '.' || - c == ':' - out.append(if (ok) c else '_') - } - return out.toString() - } - - fun formatAgentMessage( - actionName: String, - sessionKey: String, - surfaceId: String, - sourceComponentId: String, - host: String, - instanceId: String, - contextJson: String?, - ): String { - val ctxSuffix = contextJson?.takeIf { it.isNotBlank() }?.let { " ctx=$it" }.orEmpty() - return listOf( - "CANVAS_A2UI", - "action=${sanitizeTagValue(actionName)}", - "session=${sanitizeTagValue(sessionKey)}", - "surface=${sanitizeTagValue(surfaceId)}", - "component=${sanitizeTagValue(sourceComponentId)}", - "host=${sanitizeTagValue(host)}", - "instance=${sanitizeTagValue(instanceId)}$ctxSuffix", - "default=update_canvas", - ).joinToString(separator = " ") - } - - fun jsDispatchA2UIActionStatus(actionId: String, ok: Boolean, error: String?): String { - val err = (error ?: "").replace("\\", "\\\\").replace("\"", "\\\"") - val okLiteral = if (ok) "true" else "false" - val idEscaped = actionId.replace("\\", "\\\\").replace("\"", "\\\"") - return "window.dispatchEvent(new CustomEvent('moltbot:a2ui-action-status', { detail: { id: \"${idEscaped}\", ok: ${okLiteral}, error: \"${err}\" } }));" - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotProtocolConstants.kt b/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotProtocolConstants.kt deleted file mode 100644 index 09a8bb49d..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotProtocolConstants.kt +++ /dev/null @@ -1,71 +0,0 @@ -package com.clawdbot.android.protocol - -enum class MoltbotCapability(val rawValue: String) { - Canvas("canvas"), - Camera("camera"), - Screen("screen"), - Sms("sms"), - VoiceWake("voiceWake"), - Location("location"), -} - -enum class MoltbotCanvasCommand(val rawValue: String) { - Present("canvas.present"), - Hide("canvas.hide"), - Navigate("canvas.navigate"), - Eval("canvas.eval"), - Snapshot("canvas.snapshot"), - ; - - companion object { - const val NamespacePrefix: String = "canvas." - } -} - -enum class MoltbotCanvasA2UICommand(val rawValue: String) { - Push("canvas.a2ui.push"), - PushJSONL("canvas.a2ui.pushJSONL"), - Reset("canvas.a2ui.reset"), - ; - - companion object { - const val NamespacePrefix: String = "canvas.a2ui." - } -} - -enum class MoltbotCameraCommand(val rawValue: String) { - Snap("camera.snap"), - Clip("camera.clip"), - ; - - companion object { - const val NamespacePrefix: String = "camera." - } -} - -enum class MoltbotScreenCommand(val rawValue: String) { - Record("screen.record"), - ; - - companion object { - const val NamespacePrefix: String = "screen." - } -} - -enum class MoltbotSmsCommand(val rawValue: String) { - Send("sms.send"), - ; - - companion object { - const val NamespacePrefix: String = "sms." - } -} - -enum class MoltbotLocationCommand(val rawValue: String) { - Get("location.get"), - ; - - companion object { - const val NamespacePrefix: String = "location." - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/tools/ToolDisplay.kt b/apps/android/app/src/main/java/com/clawdbot/android/tools/ToolDisplay.kt deleted file mode 100644 index aed5d0b4b..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/tools/ToolDisplay.kt +++ /dev/null @@ -1,222 +0,0 @@ -package com.clawdbot.android.tools - -import android.content.Context -import kotlinx.serialization.Serializable -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonArray -import kotlinx.serialization.json.JsonElement -import kotlinx.serialization.json.JsonObject -import kotlinx.serialization.json.JsonPrimitive -import kotlinx.serialization.json.contentOrNull - -@Serializable -private data class ToolDisplayActionSpec( - val label: String? = null, - val detailKeys: List? = null, -) - -@Serializable -private data class ToolDisplaySpec( - val emoji: String? = null, - val title: String? = null, - val label: String? = null, - val detailKeys: List? = null, - val actions: Map? = null, -) - -@Serializable -private data class ToolDisplayConfig( - val version: Int? = null, - val fallback: ToolDisplaySpec? = null, - val tools: Map? = null, -) - -data class ToolDisplaySummary( - val name: String, - val emoji: String, - val title: String, - val label: String, - val verb: String?, - val detail: String?, -) { - val detailLine: String? - get() { - val parts = mutableListOf() - if (!verb.isNullOrBlank()) parts.add(verb) - if (!detail.isNullOrBlank()) parts.add(detail) - return if (parts.isEmpty()) null else parts.joinToString(" · ") - } - - val summaryLine: String - get() = if (detailLine != null) "${emoji} ${label}: ${detailLine}" else "${emoji} ${label}" -} - -object ToolDisplayRegistry { - private const val CONFIG_ASSET = "tool-display.json" - - private val json = Json { ignoreUnknownKeys = true } - @Volatile private var cachedConfig: ToolDisplayConfig? = null - - fun resolve( - context: Context, - name: String?, - args: JsonObject?, - meta: String? = null, - ): ToolDisplaySummary { - val trimmedName = name?.trim().orEmpty().ifEmpty { "tool" } - val key = trimmedName.lowercase() - val config = loadConfig(context) - val spec = config.tools?.get(key) - val fallback = config.fallback - - val emoji = spec?.emoji ?: fallback?.emoji ?: "🧩" - val title = spec?.title ?: titleFromName(trimmedName) - val label = spec?.label ?: trimmedName - - val actionRaw = args?.get("action")?.asStringOrNull()?.trim() - val action = actionRaw?.takeIf { it.isNotEmpty() } - val actionSpec = action?.let { spec?.actions?.get(it) } - val verb = normalizeVerb(actionSpec?.label ?: action) - - var detail: String? = null - if (key == "read") { - detail = readDetail(args) - } else if (key == "write" || key == "edit" || key == "attach") { - detail = pathDetail(args) - } - - val detailKeys = actionSpec?.detailKeys ?: spec?.detailKeys ?: fallback?.detailKeys ?: emptyList() - if (detail == null) { - detail = firstValue(args, detailKeys) - } - - if (detail == null) { - detail = meta - } - - if (detail != null) { - detail = shortenHomeInString(detail) - } - - return ToolDisplaySummary( - name = trimmedName, - emoji = emoji, - title = title, - label = label, - verb = verb, - detail = detail, - ) - } - - private fun loadConfig(context: Context): ToolDisplayConfig { - val existing = cachedConfig - if (existing != null) return existing - return try { - val jsonString = context.assets.open(CONFIG_ASSET).bufferedReader().use { it.readText() } - val decoded = json.decodeFromString(ToolDisplayConfig.serializer(), jsonString) - cachedConfig = decoded - decoded - } catch (_: Throwable) { - val fallback = ToolDisplayConfig() - cachedConfig = fallback - fallback - } - } - - private fun titleFromName(name: String): String { - val cleaned = name.replace("_", " ").trim() - if (cleaned.isEmpty()) return "Tool" - return cleaned - .split(Regex("\\s+")) - .joinToString(" ") { part -> - val upper = part.uppercase() - if (part.length <= 2 && part == upper) part - else upper.firstOrNull()?.toString().orEmpty() + part.lowercase().drop(1) - } - } - - private fun normalizeVerb(value: String?): String? { - val trimmed = value?.trim().orEmpty() - if (trimmed.isEmpty()) return null - return trimmed.replace("_", " ") - } - - private fun readDetail(args: JsonObject?): String? { - val path = args?.get("path")?.asStringOrNull() ?: return null - val offset = args["offset"].asNumberOrNull() - val limit = args["limit"].asNumberOrNull() - return if (offset != null && limit != null) { - val end = offset + limit - "${path}:${offset.toInt()}-${end.toInt()}" - } else { - path - } - } - - private fun pathDetail(args: JsonObject?): String? { - return args?.get("path")?.asStringOrNull() - } - - private fun firstValue(args: JsonObject?, keys: List): String? { - for (key in keys) { - val value = valueForPath(args, key) - val rendered = renderValue(value) - if (!rendered.isNullOrBlank()) return rendered - } - return null - } - - private fun valueForPath(args: JsonObject?, path: String): JsonElement? { - var current: JsonElement? = args - for (segment in path.split(".")) { - if (segment.isBlank()) return null - val obj = current as? JsonObject ?: return null - current = obj[segment] - } - return current - } - - private fun renderValue(value: JsonElement?): String? { - if (value == null) return null - if (value is JsonPrimitive) { - if (value.isString) { - val trimmed = value.contentOrNull?.trim().orEmpty() - if (trimmed.isEmpty()) return null - val firstLine = trimmed.lineSequence().firstOrNull()?.trim().orEmpty() - if (firstLine.isEmpty()) return null - return if (firstLine.length > 160) "${firstLine.take(157)}…" else firstLine - } - val raw = value.contentOrNull?.trim().orEmpty() - raw.toBooleanStrictOrNull()?.let { return it.toString() } - raw.toLongOrNull()?.let { return it.toString() } - raw.toDoubleOrNull()?.let { return it.toString() } - } - if (value is JsonArray) { - val items = value.mapNotNull { renderValue(it) } - if (items.isEmpty()) return null - val preview = items.take(3).joinToString(", ") - return if (items.size > 3) "${preview}…" else preview - } - return null - } - - private fun shortenHomeInString(value: String): String { - val home = System.getProperty("user.home")?.takeIf { it.isNotBlank() } - ?: System.getenv("HOME")?.takeIf { it.isNotBlank() } - if (home.isNullOrEmpty()) return value - return value.replace(home, "~") - .replace(Regex("/Users/[^/]+"), "~") - .replace(Regex("/home/[^/]+"), "~") - } - - private fun JsonElement?.asStringOrNull(): String? { - val primitive = this as? JsonPrimitive ?: return null - return if (primitive.isString) primitive.contentOrNull else primitive.toString() - } - - private fun JsonElement?.asNumberOrNull(): Double? { - val primitive = this as? JsonPrimitive ?: return null - val raw = primitive.contentOrNull ?: return null - return raw.toDoubleOrNull() - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/CameraHudOverlay.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/CameraHudOverlay.kt deleted file mode 100644 index 2143ba7f8..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/CameraHudOverlay.kt +++ /dev/null @@ -1,44 +0,0 @@ -package com.clawdbot.android.ui - -import androidx.compose.foundation.background -import androidx.compose.foundation.layout.Box -import androidx.compose.foundation.layout.fillMaxSize -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableFloatStateOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.setValue -import androidx.compose.ui.Modifier -import androidx.compose.ui.draw.alpha -import androidx.compose.ui.graphics.Color -import kotlinx.coroutines.delay - -@Composable -fun CameraFlashOverlay( - token: Long, - modifier: Modifier = Modifier, -) { - Box(modifier = modifier.fillMaxSize()) { - CameraFlash(token = token) - } -} - -@Composable -private fun CameraFlash(token: Long) { - var alpha by remember { mutableFloatStateOf(0f) } - LaunchedEffect(token) { - if (token == 0L) return@LaunchedEffect - alpha = 0.85f - delay(110) - alpha = 0f - } - - Box( - modifier = - Modifier - .fillMaxSize() - .alpha(alpha) - .background(Color.White), - ) -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/ChatSheet.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/ChatSheet.kt deleted file mode 100644 index 6f15e5922..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/ChatSheet.kt +++ /dev/null @@ -1,10 +0,0 @@ -package com.clawdbot.android.ui - -import androidx.compose.runtime.Composable -import com.clawdbot.android.MainViewModel -import com.clawdbot.android.ui.chat.ChatSheetContent - -@Composable -fun ChatSheet(viewModel: MainViewModel) { - ChatSheetContent(viewModel = viewModel) -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/ClawdbotTheme.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/ClawdbotTheme.kt deleted file mode 100644 index 01d5a6796..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/ClawdbotTheme.kt +++ /dev/null @@ -1,32 +0,0 @@ -package com.clawdbot.android.ui - -import androidx.compose.foundation.isSystemInDarkTheme -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.dynamicDarkColorScheme -import androidx.compose.material3.dynamicLightColorScheme -import androidx.compose.runtime.Composable -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.platform.LocalContext - -@Composable -fun MoltbotTheme(content: @Composable () -> Unit) { - val context = LocalContext.current - val isDark = isSystemInDarkTheme() - val colorScheme = if (isDark) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context) - - MaterialTheme(colorScheme = colorScheme, content = content) -} - -@Composable -fun overlayContainerColor(): Color { - val scheme = MaterialTheme.colorScheme - val isDark = isSystemInDarkTheme() - val base = if (isDark) scheme.surfaceContainerLow else scheme.surfaceContainerHigh - // Light mode: background stays dark (canvas), so clamp overlays away from pure-white glare. - return if (isDark) base else base.copy(alpha = 0.88f) -} - -@Composable -fun overlayIconColor(): Color { - return MaterialTheme.colorScheme.onSurfaceVariant -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/RootScreen.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/RootScreen.kt deleted file mode 100644 index 763052559..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/RootScreen.kt +++ /dev/null @@ -1,449 +0,0 @@ -package com.clawdbot.android.ui - -import android.annotation.SuppressLint -import android.Manifest -import android.content.pm.PackageManager -import android.graphics.Color -import android.util.Log -import android.view.View -import android.webkit.JavascriptInterface -import android.webkit.ConsoleMessage -import android.webkit.WebChromeClient -import android.webkit.WebView -import android.webkit.WebSettings -import android.webkit.WebResourceError -import android.webkit.WebResourceRequest -import android.webkit.WebResourceResponse -import android.webkit.WebViewClient -import androidx.activity.compose.rememberLauncherForActivityResult -import androidx.activity.result.contract.ActivityResultContracts -import androidx.webkit.WebSettingsCompat -import androidx.webkit.WebViewFeature -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Box -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.WindowInsets -import androidx.compose.foundation.layout.WindowInsetsSides -import androidx.compose.foundation.layout.only -import androidx.compose.foundation.layout.fillMaxSize -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.layout.safeDrawing -import androidx.compose.foundation.layout.size -import androidx.compose.foundation.layout.windowInsetsPadding -import androidx.compose.material3.ExperimentalMaterial3Api -import androidx.compose.material3.FilledTonalIconButton -import androidx.compose.material3.Icon -import androidx.compose.material3.IconButtonDefaults -import androidx.compose.material3.LocalContentColor -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.ModalBottomSheet -import androidx.compose.material3.rememberModalBottomSheetState -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.automirrored.filled.ScreenShare -import androidx.compose.material.icons.filled.ChatBubble -import androidx.compose.material.icons.filled.CheckCircle -import androidx.compose.material.icons.filled.Error -import androidx.compose.material.icons.filled.FiberManualRecord -import androidx.compose.material.icons.filled.PhotoCamera -import androidx.compose.material.icons.filled.RecordVoiceOver -import androidx.compose.material.icons.filled.Refresh -import androidx.compose.material.icons.filled.Report -import androidx.compose.material.icons.filled.Settings -import androidx.compose.runtime.Composable -import androidx.compose.runtime.collectAsState -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.setValue -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color as ComposeColor -import androidx.compose.ui.graphics.lerp -import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.unit.dp -import androidx.compose.ui.viewinterop.AndroidView -import androidx.compose.ui.window.Popup -import androidx.compose.ui.window.PopupProperties -import androidx.core.content.ContextCompat -import com.clawdbot.android.CameraHudKind -import com.clawdbot.android.MainViewModel - -@OptIn(ExperimentalMaterial3Api::class) -@Composable -fun RootScreen(viewModel: MainViewModel) { - var sheet by remember { mutableStateOf(null) } - val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true) - val safeOverlayInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal) - val context = LocalContext.current - val serverName by viewModel.serverName.collectAsState() - val statusText by viewModel.statusText.collectAsState() - val cameraHud by viewModel.cameraHud.collectAsState() - val cameraFlashToken by viewModel.cameraFlashToken.collectAsState() - val screenRecordActive by viewModel.screenRecordActive.collectAsState() - val isForeground by viewModel.isForeground.collectAsState() - val voiceWakeStatusText by viewModel.voiceWakeStatusText.collectAsState() - val talkEnabled by viewModel.talkEnabled.collectAsState() - val talkStatusText by viewModel.talkStatusText.collectAsState() - val talkIsListening by viewModel.talkIsListening.collectAsState() - val talkIsSpeaking by viewModel.talkIsSpeaking.collectAsState() - val seamColorArgb by viewModel.seamColorArgb.collectAsState() - val seamColor = remember(seamColorArgb) { ComposeColor(seamColorArgb) } - val audioPermissionLauncher = - rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted -> - if (granted) viewModel.setTalkEnabled(true) - } - val activity = - remember(cameraHud, screenRecordActive, isForeground, statusText, voiceWakeStatusText) { - // Status pill owns transient activity state so it doesn't overlap the connection indicator. - if (!isForeground) { - return@remember StatusActivity( - title = "Foreground required", - icon = Icons.Default.Report, - contentDescription = "Foreground required", - ) - } - - val lowerStatus = statusText.lowercase() - if (lowerStatus.contains("repair")) { - return@remember StatusActivity( - title = "Repairing…", - icon = Icons.Default.Refresh, - contentDescription = "Repairing", - ) - } - if (lowerStatus.contains("pairing") || lowerStatus.contains("approval")) { - return@remember StatusActivity( - title = "Approval pending", - icon = Icons.Default.RecordVoiceOver, - contentDescription = "Approval pending", - ) - } - // Avoid duplicating the primary gateway status ("Connecting…") in the activity slot. - - if (screenRecordActive) { - return@remember StatusActivity( - title = "Recording screen…", - icon = Icons.AutoMirrored.Filled.ScreenShare, - contentDescription = "Recording screen", - tint = androidx.compose.ui.graphics.Color.Red, - ) - } - - cameraHud?.let { hud -> - return@remember when (hud.kind) { - CameraHudKind.Photo -> - StatusActivity( - title = hud.message, - icon = Icons.Default.PhotoCamera, - contentDescription = "Taking photo", - ) - CameraHudKind.Recording -> - StatusActivity( - title = hud.message, - icon = Icons.Default.FiberManualRecord, - contentDescription = "Recording", - tint = androidx.compose.ui.graphics.Color.Red, - ) - CameraHudKind.Success -> - StatusActivity( - title = hud.message, - icon = Icons.Default.CheckCircle, - contentDescription = "Capture finished", - ) - CameraHudKind.Error -> - StatusActivity( - title = hud.message, - icon = Icons.Default.Error, - contentDescription = "Capture failed", - tint = androidx.compose.ui.graphics.Color.Red, - ) - } - } - - if (voiceWakeStatusText.contains("Microphone permission", ignoreCase = true)) { - return@remember StatusActivity( - title = "Mic permission", - icon = Icons.Default.Error, - contentDescription = "Mic permission required", - ) - } - if (voiceWakeStatusText == "Paused") { - val suffix = if (!isForeground) " (background)" else "" - return@remember StatusActivity( - title = "Voice Wake paused$suffix", - icon = Icons.Default.RecordVoiceOver, - contentDescription = "Voice Wake paused", - ) - } - - null - } - - val gatewayState = - remember(serverName, statusText) { - when { - serverName != null -> GatewayState.Connected - statusText.contains("connecting", ignoreCase = true) || - statusText.contains("reconnecting", ignoreCase = true) -> GatewayState.Connecting - statusText.contains("error", ignoreCase = true) -> GatewayState.Error - else -> GatewayState.Disconnected - } - } - - val voiceEnabled = - ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == - PackageManager.PERMISSION_GRANTED - - Box(modifier = Modifier.fillMaxSize()) { - CanvasView(viewModel = viewModel, modifier = Modifier.fillMaxSize()) - } - - // Camera flash must be in a Popup to render above the WebView. - Popup(alignment = Alignment.Center, properties = PopupProperties(focusable = false)) { - CameraFlashOverlay(token = cameraFlashToken, modifier = Modifier.fillMaxSize()) - } - - // Keep the overlay buttons above the WebView canvas (AndroidView), otherwise they may not receive touches. - Popup(alignment = Alignment.TopStart, properties = PopupProperties(focusable = false)) { - StatusPill( - gateway = gatewayState, - voiceEnabled = voiceEnabled, - activity = activity, - onClick = { sheet = Sheet.Settings }, - modifier = Modifier.windowInsetsPadding(safeOverlayInsets).padding(start = 12.dp, top = 12.dp), - ) - } - - Popup(alignment = Alignment.TopEnd, properties = PopupProperties(focusable = false)) { - Column( - modifier = Modifier.windowInsetsPadding(safeOverlayInsets).padding(end = 12.dp, top = 12.dp), - verticalArrangement = Arrangement.spacedBy(10.dp), - horizontalAlignment = Alignment.End, - ) { - OverlayIconButton( - onClick = { sheet = Sheet.Chat }, - icon = { Icon(Icons.Default.ChatBubble, contentDescription = "Chat") }, - ) - - // Talk mode gets a dedicated side bubble instead of burying it in settings. - val baseOverlay = overlayContainerColor() - val talkContainer = - lerp( - baseOverlay, - seamColor.copy(alpha = baseOverlay.alpha), - if (talkEnabled) 0.35f else 0.22f, - ) - val talkContent = if (talkEnabled) seamColor else overlayIconColor() - OverlayIconButton( - onClick = { - val next = !talkEnabled - if (next) { - val micOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == - PackageManager.PERMISSION_GRANTED - if (!micOk) audioPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO) - viewModel.setTalkEnabled(true) - } else { - viewModel.setTalkEnabled(false) - } - }, - containerColor = talkContainer, - contentColor = talkContent, - icon = { - Icon( - Icons.Default.RecordVoiceOver, - contentDescription = "Talk Mode", - ) - }, - ) - - OverlayIconButton( - onClick = { sheet = Sheet.Settings }, - icon = { Icon(Icons.Default.Settings, contentDescription = "Settings") }, - ) - } - } - - if (talkEnabled) { - Popup(alignment = Alignment.Center, properties = PopupProperties(focusable = false)) { - TalkOrbOverlay( - seamColor = seamColor, - statusText = talkStatusText, - isListening = talkIsListening, - isSpeaking = talkIsSpeaking, - ) - } - } - - val currentSheet = sheet - if (currentSheet != null) { - ModalBottomSheet( - onDismissRequest = { sheet = null }, - sheetState = sheetState, - ) { - when (currentSheet) { - Sheet.Chat -> ChatSheet(viewModel = viewModel) - Sheet.Settings -> SettingsSheet(viewModel = viewModel) - } - } - } -} - -private enum class Sheet { - Chat, - Settings, -} - -@Composable -private fun OverlayIconButton( - onClick: () -> Unit, - icon: @Composable () -> Unit, - containerColor: ComposeColor? = null, - contentColor: ComposeColor? = null, -) { - FilledTonalIconButton( - onClick = onClick, - modifier = Modifier.size(44.dp), - colors = - IconButtonDefaults.filledTonalIconButtonColors( - containerColor = containerColor ?: overlayContainerColor(), - contentColor = contentColor ?: overlayIconColor(), - ), - ) { - icon() - } -} - -@SuppressLint("SetJavaScriptEnabled") -@Composable -private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier) { - val context = LocalContext.current - val isDebuggable = (context.applicationInfo.flags and android.content.pm.ApplicationInfo.FLAG_DEBUGGABLE) != 0 - AndroidView( - modifier = modifier, - factory = { - WebView(context).apply { - settings.javaScriptEnabled = true - // Some embedded web UIs (incl. the "background website") use localStorage/sessionStorage. - settings.domStorageEnabled = true - settings.mixedContentMode = WebSettings.MIXED_CONTENT_COMPATIBILITY_MODE - if (WebViewFeature.isFeatureSupported(WebViewFeature.ALGORITHMIC_DARKENING)) { - WebSettingsCompat.setAlgorithmicDarkeningAllowed(settings, false) - } else { - disableForceDarkIfSupported(settings) - } - if (isDebuggable) { - Log.d("MoltbotWebView", "userAgent: ${settings.userAgentString}") - } - isScrollContainer = true - overScrollMode = View.OVER_SCROLL_IF_CONTENT_SCROLLS - isVerticalScrollBarEnabled = true - isHorizontalScrollBarEnabled = true - webViewClient = - object : WebViewClient() { - override fun onReceivedError( - view: WebView, - request: WebResourceRequest, - error: WebResourceError, - ) { - if (!isDebuggable) return - if (!request.isForMainFrame) return - Log.e("MoltbotWebView", "onReceivedError: ${error.errorCode} ${error.description} ${request.url}") - } - - override fun onReceivedHttpError( - view: WebView, - request: WebResourceRequest, - errorResponse: WebResourceResponse, - ) { - if (!isDebuggable) return - if (!request.isForMainFrame) return - Log.e( - "MoltbotWebView", - "onReceivedHttpError: ${errorResponse.statusCode} ${errorResponse.reasonPhrase} ${request.url}", - ) - } - - override fun onPageFinished(view: WebView, url: String?) { - if (isDebuggable) { - Log.d("MoltbotWebView", "onPageFinished: $url") - } - viewModel.canvas.onPageFinished() - } - - override fun onRenderProcessGone( - view: WebView, - detail: android.webkit.RenderProcessGoneDetail, - ): Boolean { - if (isDebuggable) { - Log.e( - "MoltbotWebView", - "onRenderProcessGone didCrash=${detail.didCrash()} priorityAtExit=${detail.rendererPriorityAtExit()}", - ) - } - return true - } - } - webChromeClient = - object : WebChromeClient() { - override fun onConsoleMessage(consoleMessage: ConsoleMessage?): Boolean { - if (!isDebuggable) return false - val msg = consoleMessage ?: return false - Log.d( - "MoltbotWebView", - "console ${msg.messageLevel()} @ ${msg.sourceId()}:${msg.lineNumber()} ${msg.message()}", - ) - return false - } - } - // Use default layer/background; avoid forcing a black fill over WebView content. - - val a2uiBridge = - CanvasA2UIActionBridge { payload -> - viewModel.handleCanvasA2UIActionFromWebView(payload) - } - addJavascriptInterface(a2uiBridge, CanvasA2UIActionBridge.interfaceName) - addJavascriptInterface( - CanvasA2UIActionLegacyBridge(a2uiBridge), - CanvasA2UIActionLegacyBridge.interfaceName, - ) - viewModel.canvas.attach(this) - } - }, - ) -} - -private fun disableForceDarkIfSupported(settings: WebSettings) { - if (!WebViewFeature.isFeatureSupported(WebViewFeature.FORCE_DARK)) return - @Suppress("DEPRECATION") - WebSettingsCompat.setForceDark(settings, WebSettingsCompat.FORCE_DARK_OFF) -} - -private class CanvasA2UIActionBridge(private val onMessage: (String) -> Unit) { - @JavascriptInterface - fun postMessage(payload: String?) { - val msg = payload?.trim().orEmpty() - if (msg.isEmpty()) return - onMessage(msg) - } - - companion object { - const val interfaceName: String = "moltbotCanvasA2UIAction" - } -} - -private class CanvasA2UIActionLegacyBridge(private val bridge: CanvasA2UIActionBridge) { - @JavascriptInterface - fun canvasAction(payload: String?) { - bridge.postMessage(payload) - } - - @JavascriptInterface - fun postMessage(payload: String?) { - bridge.postMessage(payload) - } - - companion object { - const val interfaceName: String = "Android" - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/SettingsSheet.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/SettingsSheet.kt deleted file mode 100644 index 6b3564e14..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/SettingsSheet.kt +++ /dev/null @@ -1,686 +0,0 @@ -package com.clawdbot.android.ui - -import android.Manifest -import android.content.Context -import android.content.Intent -import android.content.pm.PackageManager -import android.net.Uri -import android.os.Build -import android.provider.Settings -import androidx.activity.compose.rememberLauncherForActivityResult -import androidx.activity.result.contract.ActivityResultContracts -import androidx.compose.animation.AnimatedVisibility -import androidx.compose.foundation.clickable -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.PaddingValues -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.Spacer -import androidx.compose.foundation.layout.WindowInsets -import androidx.compose.foundation.layout.WindowInsetsSides -import androidx.compose.foundation.layout.fillMaxHeight -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.layout.height -import androidx.compose.foundation.layout.imePadding -import androidx.compose.foundation.layout.only -import androidx.compose.foundation.layout.safeDrawing -import androidx.compose.foundation.layout.windowInsetsPadding -import androidx.compose.foundation.lazy.LazyColumn -import androidx.compose.foundation.lazy.items -import androidx.compose.foundation.lazy.rememberLazyListState -import androidx.compose.foundation.text.KeyboardActions -import androidx.compose.foundation.text.KeyboardOptions -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.ExpandLess -import androidx.compose.material.icons.filled.ExpandMore -import androidx.compose.material3.Button -import androidx.compose.material3.HorizontalDivider -import androidx.compose.material3.Icon -import androidx.compose.material3.ListItem -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.OutlinedTextField -import androidx.compose.material3.RadioButton -import androidx.compose.material3.Switch -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.runtime.collectAsState -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.setValue -import androidx.compose.ui.Modifier -import androidx.compose.ui.draw.alpha -import androidx.compose.ui.focus.onFocusChanged -import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.platform.LocalFocusManager -import androidx.compose.ui.text.input.ImeAction -import androidx.compose.ui.text.style.TextAlign -import androidx.compose.ui.unit.dp -import androidx.core.content.ContextCompat -import com.clawdbot.android.BuildConfig -import com.clawdbot.android.LocationMode -import com.clawdbot.android.MainViewModel -import com.clawdbot.android.NodeForegroundService -import com.clawdbot.android.VoiceWakeMode -import com.clawdbot.android.WakeWords - -@Composable -fun SettingsSheet(viewModel: MainViewModel) { - val context = LocalContext.current - val instanceId by viewModel.instanceId.collectAsState() - val displayName by viewModel.displayName.collectAsState() - val cameraEnabled by viewModel.cameraEnabled.collectAsState() - val locationMode by viewModel.locationMode.collectAsState() - val locationPreciseEnabled by viewModel.locationPreciseEnabled.collectAsState() - val preventSleep by viewModel.preventSleep.collectAsState() - val wakeWords by viewModel.wakeWords.collectAsState() - val voiceWakeMode by viewModel.voiceWakeMode.collectAsState() - val voiceWakeStatusText by viewModel.voiceWakeStatusText.collectAsState() - val isConnected by viewModel.isConnected.collectAsState() - val manualEnabled by viewModel.manualEnabled.collectAsState() - val manualHost by viewModel.manualHost.collectAsState() - val manualPort by viewModel.manualPort.collectAsState() - val manualTls by viewModel.manualTls.collectAsState() - val canvasDebugStatusEnabled by viewModel.canvasDebugStatusEnabled.collectAsState() - val statusText by viewModel.statusText.collectAsState() - val serverName by viewModel.serverName.collectAsState() - val remoteAddress by viewModel.remoteAddress.collectAsState() - val gateways by viewModel.gateways.collectAsState() - val discoveryStatusText by viewModel.discoveryStatusText.collectAsState() - - val listState = rememberLazyListState() - val (wakeWordsText, setWakeWordsText) = remember { mutableStateOf("") } - val (advancedExpanded, setAdvancedExpanded) = remember { mutableStateOf(false) } - val focusManager = LocalFocusManager.current - var wakeWordsHadFocus by remember { mutableStateOf(false) } - val deviceModel = - remember { - listOfNotNull(Build.MANUFACTURER, Build.MODEL) - .joinToString(" ") - .trim() - .ifEmpty { "Android" } - } - val appVersion = - remember { - val versionName = BuildConfig.VERSION_NAME.trim().ifEmpty { "dev" } - if (BuildConfig.DEBUG && !versionName.contains("dev", ignoreCase = true)) { - "$versionName-dev" - } else { - versionName - } - } - - LaunchedEffect(wakeWords) { setWakeWordsText(wakeWords.joinToString(", ")) } - val commitWakeWords = { - val parsed = WakeWords.parseIfChanged(wakeWordsText, wakeWords) - if (parsed != null) { - viewModel.setWakeWords(parsed) - } - } - - val permissionLauncher = - rememberLauncherForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { perms -> - val cameraOk = perms[Manifest.permission.CAMERA] == true - viewModel.setCameraEnabled(cameraOk) - } - - var pendingLocationMode by remember { mutableStateOf(null) } - var pendingPreciseToggle by remember { mutableStateOf(false) } - - val locationPermissionLauncher = - rememberLauncherForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { perms -> - val fineOk = perms[Manifest.permission.ACCESS_FINE_LOCATION] == true - val coarseOk = perms[Manifest.permission.ACCESS_COARSE_LOCATION] == true - val granted = fineOk || coarseOk - val requestedMode = pendingLocationMode - pendingLocationMode = null - - if (pendingPreciseToggle) { - pendingPreciseToggle = false - viewModel.setLocationPreciseEnabled(fineOk) - return@rememberLauncherForActivityResult - } - - if (!granted) { - viewModel.setLocationMode(LocationMode.Off) - return@rememberLauncherForActivityResult - } - - if (requestedMode != null) { - viewModel.setLocationMode(requestedMode) - if (requestedMode == LocationMode.Always) { - val backgroundOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == - PackageManager.PERMISSION_GRANTED - if (!backgroundOk) { - openAppSettings(context) - } - } - } - } - - val audioPermissionLauncher = - rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { _ -> - // Status text is handled by NodeRuntime. - } - - val smsPermissionAvailable = - remember { - context.packageManager?.hasSystemFeature(PackageManager.FEATURE_TELEPHONY) == true - } - var smsPermissionGranted by - remember { - mutableStateOf( - ContextCompat.checkSelfPermission(context, Manifest.permission.SEND_SMS) == - PackageManager.PERMISSION_GRANTED, - ) - } - val smsPermissionLauncher = - rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted -> - smsPermissionGranted = granted - viewModel.refreshGatewayConnection() - } - - fun setCameraEnabledChecked(checked: Boolean) { - if (!checked) { - viewModel.setCameraEnabled(false) - return - } - - val cameraOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) == - PackageManager.PERMISSION_GRANTED - if (cameraOk) { - viewModel.setCameraEnabled(true) - } else { - permissionLauncher.launch(arrayOf(Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO)) - } - } - - fun requestLocationPermissions(targetMode: LocationMode) { - val fineOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == - PackageManager.PERMISSION_GRANTED - val coarseOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == - PackageManager.PERMISSION_GRANTED - if (fineOk || coarseOk) { - viewModel.setLocationMode(targetMode) - if (targetMode == LocationMode.Always) { - val backgroundOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == - PackageManager.PERMISSION_GRANTED - if (!backgroundOk) { - openAppSettings(context) - } - } - } else { - pendingLocationMode = targetMode - locationPermissionLauncher.launch( - arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION), - ) - } - } - - fun setPreciseLocationChecked(checked: Boolean) { - if (!checked) { - viewModel.setLocationPreciseEnabled(false) - return - } - val fineOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == - PackageManager.PERMISSION_GRANTED - if (fineOk) { - viewModel.setLocationPreciseEnabled(true) - } else { - pendingPreciseToggle = true - locationPermissionLauncher.launch(arrayOf(Manifest.permission.ACCESS_FINE_LOCATION)) - } - } - - val visibleGateways = - if (isConnected && remoteAddress != null) { - gateways.filterNot { "${it.host}:${it.port}" == remoteAddress } - } else { - gateways - } - - val gatewayDiscoveryFooterText = - if (visibleGateways.isEmpty()) { - discoveryStatusText - } else if (isConnected) { - "Discovery active • ${visibleGateways.size} other gateway${if (visibleGateways.size == 1) "" else "s"} found" - } else { - "Discovery active • ${visibleGateways.size} gateway${if (visibleGateways.size == 1) "" else "s"} found" - } - - LazyColumn( - state = listState, - modifier = - Modifier - .fillMaxWidth() - .fillMaxHeight() - .imePadding() - .windowInsetsPadding(WindowInsets.safeDrawing.only(WindowInsetsSides.Bottom)), - contentPadding = PaddingValues(16.dp), - verticalArrangement = Arrangement.spacedBy(6.dp), - ) { - // Order parity: Node → Gateway → Voice → Camera → Messaging → Location → Screen. - item { Text("Node", style = MaterialTheme.typography.titleSmall) } - item { - OutlinedTextField( - value = displayName, - onValueChange = viewModel::setDisplayName, - label = { Text("Name") }, - modifier = Modifier.fillMaxWidth(), - ) - } - item { Text("Instance ID: $instanceId", color = MaterialTheme.colorScheme.onSurfaceVariant) } - item { Text("Device: $deviceModel", color = MaterialTheme.colorScheme.onSurfaceVariant) } - item { Text("Version: $appVersion", color = MaterialTheme.colorScheme.onSurfaceVariant) } - - item { HorizontalDivider() } - - // Gateway - item { Text("Gateway", style = MaterialTheme.typography.titleSmall) } - item { ListItem(headlineContent = { Text("Status") }, supportingContent = { Text(statusText) }) } - if (serverName != null) { - item { ListItem(headlineContent = { Text("Server") }, supportingContent = { Text(serverName!!) }) } - } - if (remoteAddress != null) { - item { ListItem(headlineContent = { Text("Address") }, supportingContent = { Text(remoteAddress!!) }) } - } - item { - // UI sanity: "Disconnect" only when we have an active remote. - if (isConnected && remoteAddress != null) { - Button( - onClick = { - viewModel.disconnect() - NodeForegroundService.stop(context) - }, - ) { - Text("Disconnect") - } - } - } - - item { HorizontalDivider() } - - if (!isConnected || visibleGateways.isNotEmpty()) { - item { - Text( - if (isConnected) "Other Gateways" else "Discovered Gateways", - style = MaterialTheme.typography.titleSmall, - ) - } - if (!isConnected && visibleGateways.isEmpty()) { - item { Text("No gateways found yet.", color = MaterialTheme.colorScheme.onSurfaceVariant) } - } else { - items(items = visibleGateways, key = { it.stableId }) { gateway -> - val detailLines = - buildList { - add("IP: ${gateway.host}:${gateway.port}") - gateway.lanHost?.let { add("LAN: $it") } - gateway.tailnetDns?.let { add("Tailnet: $it") } - if (gateway.gatewayPort != null || gateway.canvasPort != null) { - val gw = (gateway.gatewayPort ?: gateway.port).toString() - val canvas = gateway.canvasPort?.toString() ?: "—" - add("Ports: gw $gw · canvas $canvas") - } - } - ListItem( - headlineContent = { Text(gateway.name) }, - supportingContent = { - Column(verticalArrangement = Arrangement.spacedBy(2.dp)) { - detailLines.forEach { line -> - Text(line, color = MaterialTheme.colorScheme.onSurfaceVariant) - } - } - }, - trailingContent = { - Button( - onClick = { - NodeForegroundService.start(context) - viewModel.connect(gateway) - }, - ) { - Text("Connect") - } - }, - ) - } - } - item { - Text( - gatewayDiscoveryFooterText, - modifier = Modifier.fillMaxWidth(), - textAlign = TextAlign.Center, - style = MaterialTheme.typography.labelMedium, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } - } - - item { HorizontalDivider() } - - item { - ListItem( - headlineContent = { Text("Advanced") }, - supportingContent = { Text("Manual gateway connection") }, - trailingContent = { - Icon( - imageVector = if (advancedExpanded) Icons.Filled.ExpandLess else Icons.Filled.ExpandMore, - contentDescription = if (advancedExpanded) "Collapse" else "Expand", - ) - }, - modifier = - Modifier.clickable { - setAdvancedExpanded(!advancedExpanded) - }, - ) - } - item { - AnimatedVisibility(visible = advancedExpanded) { - Column(verticalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.fillMaxWidth()) { - ListItem( - headlineContent = { Text("Use Manual Gateway") }, - supportingContent = { Text("Use this when discovery is blocked.") }, - trailingContent = { Switch(checked = manualEnabled, onCheckedChange = viewModel::setManualEnabled) }, - ) - - OutlinedTextField( - value = manualHost, - onValueChange = viewModel::setManualHost, - label = { Text("Host") }, - modifier = Modifier.fillMaxWidth(), - enabled = manualEnabled, - ) - OutlinedTextField( - value = manualPort.toString(), - onValueChange = { v -> viewModel.setManualPort(v.toIntOrNull() ?: 0) }, - label = { Text("Port") }, - modifier = Modifier.fillMaxWidth(), - enabled = manualEnabled, - ) - ListItem( - headlineContent = { Text("Require TLS") }, - supportingContent = { Text("Pin the gateway certificate on first connect.") }, - trailingContent = { Switch(checked = manualTls, onCheckedChange = viewModel::setManualTls, enabled = manualEnabled) }, - modifier = Modifier.alpha(if (manualEnabled) 1f else 0.5f), - ) - - val hostOk = manualHost.trim().isNotEmpty() - val portOk = manualPort in 1..65535 - Button( - onClick = { - NodeForegroundService.start(context) - viewModel.connectManual() - }, - enabled = manualEnabled && hostOk && portOk, - ) { - Text("Connect (Manual)") - } - } - } - } - - item { HorizontalDivider() } - - // Voice - item { Text("Voice", style = MaterialTheme.typography.titleSmall) } - item { - val enabled = voiceWakeMode != VoiceWakeMode.Off - ListItem( - headlineContent = { Text("Voice Wake") }, - supportingContent = { Text(voiceWakeStatusText) }, - trailingContent = { - Switch( - checked = enabled, - onCheckedChange = { on -> - if (on) { - val micOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == - PackageManager.PERMISSION_GRANTED - if (!micOk) audioPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO) - viewModel.setVoiceWakeMode(VoiceWakeMode.Foreground) - } else { - viewModel.setVoiceWakeMode(VoiceWakeMode.Off) - } - }, - ) - }, - ) - } - item { - AnimatedVisibility(visible = voiceWakeMode != VoiceWakeMode.Off) { - Column(verticalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) { - ListItem( - headlineContent = { Text("Foreground Only") }, - supportingContent = { Text("Listens only while Moltbot is open.") }, - trailingContent = { - RadioButton( - selected = voiceWakeMode == VoiceWakeMode.Foreground, - onClick = { - val micOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == - PackageManager.PERMISSION_GRANTED - if (!micOk) audioPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO) - viewModel.setVoiceWakeMode(VoiceWakeMode.Foreground) - }, - ) - }, - ) - ListItem( - headlineContent = { Text("Always") }, - supportingContent = { Text("Keeps listening in the background (shows a persistent notification).") }, - trailingContent = { - RadioButton( - selected = voiceWakeMode == VoiceWakeMode.Always, - onClick = { - val micOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == - PackageManager.PERMISSION_GRANTED - if (!micOk) audioPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO) - viewModel.setVoiceWakeMode(VoiceWakeMode.Always) - }, - ) - }, - ) - } - } - } - item { - OutlinedTextField( - value = wakeWordsText, - onValueChange = setWakeWordsText, - label = { Text("Wake Words (comma-separated)") }, - modifier = - Modifier.fillMaxWidth().onFocusChanged { focusState -> - if (focusState.isFocused) { - wakeWordsHadFocus = true - } else if (wakeWordsHadFocus) { - wakeWordsHadFocus = false - commitWakeWords() - } - }, - singleLine = true, - keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done), - keyboardActions = - KeyboardActions( - onDone = { - commitWakeWords() - focusManager.clearFocus() - }, - ), - ) - } - item { Button(onClick = viewModel::resetWakeWordsDefaults) { Text("Reset defaults") } } - item { - Text( - if (isConnected) { - "Any node can edit wake words. Changes sync via the gateway." - } else { - "Connect to a gateway to sync wake words globally." - }, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } - - item { HorizontalDivider() } - - // Camera - item { Text("Camera", style = MaterialTheme.typography.titleSmall) } - item { - ListItem( - headlineContent = { Text("Allow Camera") }, - supportingContent = { Text("Allows the gateway to request photos or short video clips (foreground only).") }, - trailingContent = { Switch(checked = cameraEnabled, onCheckedChange = ::setCameraEnabledChecked) }, - ) - } - item { - Text( - "Tip: grant Microphone permission for video clips with audio.", - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } - - item { HorizontalDivider() } - - // Messaging - item { Text("Messaging", style = MaterialTheme.typography.titleSmall) } - item { - val buttonLabel = - when { - !smsPermissionAvailable -> "Unavailable" - smsPermissionGranted -> "Manage" - else -> "Grant" - } - ListItem( - headlineContent = { Text("SMS Permission") }, - supportingContent = { - Text( - if (smsPermissionAvailable) { - "Allow the gateway to send SMS from this device." - } else { - "SMS requires a device with telephony hardware." - }, - ) - }, - trailingContent = { - Button( - onClick = { - if (!smsPermissionAvailable) return@Button - if (smsPermissionGranted) { - openAppSettings(context) - } else { - smsPermissionLauncher.launch(Manifest.permission.SEND_SMS) - } - }, - enabled = smsPermissionAvailable, - ) { - Text(buttonLabel) - } - }, - ) - } - - item { HorizontalDivider() } - - // Location - item { Text("Location", style = MaterialTheme.typography.titleSmall) } - item { - Column(verticalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) { - ListItem( - headlineContent = { Text("Off") }, - supportingContent = { Text("Disable location sharing.") }, - trailingContent = { - RadioButton( - selected = locationMode == LocationMode.Off, - onClick = { viewModel.setLocationMode(LocationMode.Off) }, - ) - }, - ) - ListItem( - headlineContent = { Text("While Using") }, - supportingContent = { Text("Only while Moltbot is open.") }, - trailingContent = { - RadioButton( - selected = locationMode == LocationMode.WhileUsing, - onClick = { requestLocationPermissions(LocationMode.WhileUsing) }, - ) - }, - ) - ListItem( - headlineContent = { Text("Always") }, - supportingContent = { Text("Allow background location (requires system permission).") }, - trailingContent = { - RadioButton( - selected = locationMode == LocationMode.Always, - onClick = { requestLocationPermissions(LocationMode.Always) }, - ) - }, - ) - } - } - item { - ListItem( - headlineContent = { Text("Precise Location") }, - supportingContent = { Text("Use precise GPS when available.") }, - trailingContent = { - Switch( - checked = locationPreciseEnabled, - onCheckedChange = ::setPreciseLocationChecked, - enabled = locationMode != LocationMode.Off, - ) - }, - ) - } - item { - Text( - "Always may require Android Settings to allow background location.", - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } - - item { HorizontalDivider() } - - // Screen - item { Text("Screen", style = MaterialTheme.typography.titleSmall) } - item { - ListItem( - headlineContent = { Text("Prevent Sleep") }, - supportingContent = { Text("Keeps the screen awake while Moltbot is open.") }, - trailingContent = { Switch(checked = preventSleep, onCheckedChange = viewModel::setPreventSleep) }, - ) - } - - item { HorizontalDivider() } - - // Debug - item { Text("Debug", style = MaterialTheme.typography.titleSmall) } - item { - ListItem( - headlineContent = { Text("Debug Canvas Status") }, - supportingContent = { Text("Show status text in the canvas when debug is enabled.") }, - trailingContent = { - Switch( - checked = canvasDebugStatusEnabled, - onCheckedChange = viewModel::setCanvasDebugStatusEnabled, - ) - }, - ) - } - - item { Spacer(modifier = Modifier.height(20.dp)) } - } -} - -private fun openAppSettings(context: Context) { - val intent = - Intent( - Settings.ACTION_APPLICATION_DETAILS_SETTINGS, - Uri.fromParts("package", context.packageName, null), - ) - context.startActivity(intent) -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/StatusPill.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/StatusPill.kt deleted file mode 100644 index 564d96b52..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/StatusPill.kt +++ /dev/null @@ -1,114 +0,0 @@ -package com.clawdbot.android.ui - -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.Spacer -import androidx.compose.foundation.layout.height -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.layout.size -import androidx.compose.foundation.layout.width -import androidx.compose.foundation.shape.CircleShape -import androidx.compose.foundation.shape.RoundedCornerShape -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Mic -import androidx.compose.material.icons.filled.MicOff -import androidx.compose.material3.Icon -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Surface -import androidx.compose.material3.Text -import androidx.compose.material3.VerticalDivider -import androidx.compose.runtime.Composable -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.draw.alpha -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.unit.dp - -@Composable -fun StatusPill( - gateway: GatewayState, - voiceEnabled: Boolean, - onClick: () -> Unit, - modifier: Modifier = Modifier, - activity: StatusActivity? = null, -) { - Surface( - onClick = onClick, - modifier = modifier, - shape = RoundedCornerShape(14.dp), - color = overlayContainerColor(), - tonalElevation = 3.dp, - shadowElevation = 0.dp, - ) { - Row( - modifier = Modifier.padding(horizontal = 12.dp, vertical = 8.dp), - horizontalArrangement = Arrangement.spacedBy(10.dp), - verticalAlignment = Alignment.CenterVertically, - ) { - Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) { - Surface( - modifier = Modifier.size(9.dp), - shape = CircleShape, - color = gateway.color, - ) {} - - Text( - text = gateway.title, - style = MaterialTheme.typography.labelLarge, - ) - } - - VerticalDivider( - modifier = Modifier.height(14.dp).alpha(0.35f), - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - - if (activity != null) { - Row( - horizontalArrangement = Arrangement.spacedBy(6.dp), - verticalAlignment = Alignment.CenterVertically, - ) { - Icon( - imageVector = activity.icon, - contentDescription = activity.contentDescription, - tint = activity.tint ?: overlayIconColor(), - modifier = Modifier.size(18.dp), - ) - Text( - text = activity.title, - style = MaterialTheme.typography.labelLarge, - maxLines = 1, - ) - } - } else { - Icon( - imageVector = if (voiceEnabled) Icons.Default.Mic else Icons.Default.MicOff, - contentDescription = if (voiceEnabled) "Voice enabled" else "Voice disabled", - tint = - if (voiceEnabled) { - overlayIconColor() - } else { - MaterialTheme.colorScheme.onSurfaceVariant - }, - modifier = Modifier.size(18.dp), - ) - } - - Spacer(modifier = Modifier.width(2.dp)) - } - } -} - -data class StatusActivity( - val title: String, - val icon: androidx.compose.ui.graphics.vector.ImageVector, - val contentDescription: String, - val tint: Color? = null, -) - -enum class GatewayState(val title: String, val color: Color) { - Connected("Connected", Color(0xFF2ECC71)), - Connecting("Connecting…", Color(0xFFF1C40F)), - Error("Error", Color(0xFFE74C3C)), - Disconnected("Offline", Color(0xFF9E9E9E)), -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/TalkOrbOverlay.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/TalkOrbOverlay.kt deleted file mode 100644 index 32225b486..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/TalkOrbOverlay.kt +++ /dev/null @@ -1,134 +0,0 @@ -package com.clawdbot.android.ui - -import androidx.compose.animation.core.LinearEasing -import androidx.compose.animation.core.RepeatMode -import androidx.compose.animation.core.animateFloat -import androidx.compose.animation.core.infiniteRepeatable -import androidx.compose.animation.core.rememberInfiniteTransition -import androidx.compose.animation.core.tween -import androidx.compose.foundation.Canvas -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Box -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.layout.size -import androidx.compose.foundation.shape.CircleShape -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Surface -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.runtime.getValue -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Brush -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.drawscope.Stroke -import androidx.compose.ui.text.font.FontWeight -import androidx.compose.ui.unit.dp - -@Composable -fun TalkOrbOverlay( - seamColor: Color, - statusText: String, - isListening: Boolean, - isSpeaking: Boolean, - modifier: Modifier = Modifier, -) { - val transition = rememberInfiniteTransition(label = "talk-orb") - val t by - transition.animateFloat( - initialValue = 0f, - targetValue = 1f, - animationSpec = - infiniteRepeatable( - animation = tween(durationMillis = 1500, easing = LinearEasing), - repeatMode = RepeatMode.Restart, - ), - label = "pulse", - ) - - val trimmed = statusText.trim() - val showStatus = trimmed.isNotEmpty() && trimmed != "Off" - val phase = - when { - isSpeaking -> "Speaking" - isListening -> "Listening" - else -> "Thinking" - } - - Column( - modifier = modifier.padding(24.dp), - horizontalAlignment = Alignment.CenterHorizontally, - verticalArrangement = Arrangement.spacedBy(12.dp), - ) { - Box(contentAlignment = Alignment.Center) { - Canvas(modifier = Modifier.size(360.dp)) { - val center = this.center - val baseRadius = size.minDimension * 0.30f - - val ring1 = 1.05f + (t * 0.25f) - val ring2 = 1.20f + (t * 0.55f) - val ringAlpha1 = (1f - t) * 0.34f - val ringAlpha2 = (1f - t) * 0.22f - - drawCircle( - color = seamColor.copy(alpha = ringAlpha1), - radius = baseRadius * ring1, - center = center, - style = Stroke(width = 3.dp.toPx()), - ) - drawCircle( - color = seamColor.copy(alpha = ringAlpha2), - radius = baseRadius * ring2, - center = center, - style = Stroke(width = 3.dp.toPx()), - ) - - drawCircle( - brush = - Brush.radialGradient( - colors = - listOf( - seamColor.copy(alpha = 0.92f), - seamColor.copy(alpha = 0.40f), - Color.Black.copy(alpha = 0.56f), - ), - center = center, - radius = baseRadius * 1.35f, - ), - radius = baseRadius, - center = center, - ) - - drawCircle( - color = seamColor.copy(alpha = 0.34f), - radius = baseRadius, - center = center, - style = Stroke(width = 1.dp.toPx()), - ) - } - } - - if (showStatus) { - Surface( - color = Color.Black.copy(alpha = 0.40f), - shape = CircleShape, - ) { - Text( - text = trimmed, - modifier = Modifier.padding(horizontal = 14.dp, vertical = 8.dp), - color = Color.White.copy(alpha = 0.92f), - style = MaterialTheme.typography.labelLarge, - fontWeight = FontWeight.SemiBold, - ) - } - } else { - Text( - text = phase, - color = Color.White.copy(alpha = 0.80f), - style = MaterialTheme.typography.labelLarge, - fontWeight = FontWeight.SemiBold, - ) - } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatComposer.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatComposer.kt deleted file mode 100644 index 1f30938e0..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatComposer.kt +++ /dev/null @@ -1,285 +0,0 @@ -package com.clawdbot.android.ui.chat - -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Box -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.Spacer -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.layout.size -import androidx.compose.foundation.layout.width -import androidx.compose.foundation.rememberScrollState -import androidx.compose.foundation.shape.RoundedCornerShape -import androidx.compose.foundation.horizontalScroll -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.ArrowUpward -import androidx.compose.material.icons.filled.AttachFile -import androidx.compose.material.icons.filled.Refresh -import androidx.compose.material.icons.filled.Stop -import androidx.compose.material3.ButtonDefaults -import androidx.compose.material3.DropdownMenu -import androidx.compose.material3.DropdownMenuItem -import androidx.compose.material3.FilledTonalButton -import androidx.compose.material3.FilledTonalIconButton -import androidx.compose.material3.Icon -import androidx.compose.material3.IconButtonDefaults -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.OutlinedTextField -import androidx.compose.material3.Surface -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.saveable.rememberSaveable -import androidx.compose.runtime.setValue -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.unit.dp -import com.clawdbot.android.chat.ChatSessionEntry - -@Composable -fun ChatComposer( - sessionKey: String, - sessions: List, - mainSessionKey: String, - healthOk: Boolean, - thinkingLevel: String, - pendingRunCount: Int, - errorText: String?, - attachments: List, - onPickImages: () -> Unit, - onRemoveAttachment: (id: String) -> Unit, - onSetThinkingLevel: (level: String) -> Unit, - onSelectSession: (sessionKey: String) -> Unit, - onRefresh: () -> Unit, - onAbort: () -> Unit, - onSend: (text: String) -> Unit, -) { - var input by rememberSaveable { mutableStateOf("") } - var showThinkingMenu by remember { mutableStateOf(false) } - var showSessionMenu by remember { mutableStateOf(false) } - - val sessionOptions = resolveSessionChoices(sessionKey, sessions, mainSessionKey = mainSessionKey) - val currentSessionLabel = - sessionOptions.firstOrNull { it.key == sessionKey }?.displayName ?: sessionKey - - val canSend = pendingRunCount == 0 && (input.trim().isNotEmpty() || attachments.isNotEmpty()) && healthOk - - Surface( - shape = MaterialTheme.shapes.large, - color = MaterialTheme.colorScheme.surfaceContainer, - tonalElevation = 0.dp, - shadowElevation = 0.dp, - ) { - Column(modifier = Modifier.padding(10.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { - Row( - modifier = Modifier.fillMaxWidth(), - horizontalArrangement = Arrangement.spacedBy(8.dp), - verticalAlignment = Alignment.CenterVertically, - ) { - Box { - FilledTonalButton( - onClick = { showSessionMenu = true }, - contentPadding = ButtonDefaults.ContentPadding, - ) { - Text("Session: $currentSessionLabel") - } - - DropdownMenu(expanded = showSessionMenu, onDismissRequest = { showSessionMenu = false }) { - for (entry in sessionOptions) { - DropdownMenuItem( - text = { Text(entry.displayName ?: entry.key) }, - onClick = { - onSelectSession(entry.key) - showSessionMenu = false - }, - trailingIcon = { - if (entry.key == sessionKey) { - Text("✓") - } else { - Spacer(modifier = Modifier.width(10.dp)) - } - }, - ) - } - } - } - - Box { - FilledTonalButton( - onClick = { showThinkingMenu = true }, - contentPadding = ButtonDefaults.ContentPadding, - ) { - Text("Thinking: ${thinkingLabel(thinkingLevel)}") - } - - DropdownMenu(expanded = showThinkingMenu, onDismissRequest = { showThinkingMenu = false }) { - ThinkingMenuItem("off", thinkingLevel, onSetThinkingLevel) { showThinkingMenu = false } - ThinkingMenuItem("low", thinkingLevel, onSetThinkingLevel) { showThinkingMenu = false } - ThinkingMenuItem("medium", thinkingLevel, onSetThinkingLevel) { showThinkingMenu = false } - ThinkingMenuItem("high", thinkingLevel, onSetThinkingLevel) { showThinkingMenu = false } - } - } - - Spacer(modifier = Modifier.weight(1f)) - - FilledTonalIconButton(onClick = onRefresh, modifier = Modifier.size(42.dp)) { - Icon(Icons.Default.Refresh, contentDescription = "Refresh") - } - - FilledTonalIconButton(onClick = onPickImages, modifier = Modifier.size(42.dp)) { - Icon(Icons.Default.AttachFile, contentDescription = "Add image") - } - } - - if (attachments.isNotEmpty()) { - AttachmentsStrip(attachments = attachments, onRemoveAttachment = onRemoveAttachment) - } - - OutlinedTextField( - value = input, - onValueChange = { input = it }, - modifier = Modifier.fillMaxWidth(), - placeholder = { Text("Message Clawd…") }, - minLines = 2, - maxLines = 6, - ) - - Row(modifier = Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) { - ConnectionPill(sessionLabel = currentSessionLabel, healthOk = healthOk) - Spacer(modifier = Modifier.weight(1f)) - - if (pendingRunCount > 0) { - FilledTonalIconButton( - onClick = onAbort, - colors = - IconButtonDefaults.filledTonalIconButtonColors( - containerColor = Color(0x33E74C3C), - contentColor = Color(0xFFE74C3C), - ), - ) { - Icon(Icons.Default.Stop, contentDescription = "Abort") - } - } else { - FilledTonalIconButton(onClick = { - val text = input - input = "" - onSend(text) - }, enabled = canSend) { - Icon(Icons.Default.ArrowUpward, contentDescription = "Send") - } - } - } - - if (!errorText.isNullOrBlank()) { - Text( - text = errorText, - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.error, - maxLines = 2, - ) - } - } - } -} - -@Composable -private fun ConnectionPill(sessionLabel: String, healthOk: Boolean) { - Surface( - shape = RoundedCornerShape(999.dp), - color = MaterialTheme.colorScheme.surfaceContainerHighest, - ) { - Row( - modifier = Modifier.padding(horizontal = 10.dp, vertical = 6.dp), - horizontalArrangement = Arrangement.spacedBy(8.dp), - verticalAlignment = Alignment.CenterVertically, - ) { - Surface( - modifier = Modifier.size(7.dp), - shape = androidx.compose.foundation.shape.CircleShape, - color = if (healthOk) Color(0xFF2ECC71) else Color(0xFFF39C12), - ) {} - Text(sessionLabel, style = MaterialTheme.typography.labelSmall) - Text( - if (healthOk) "Connected" else "Connecting…", - style = MaterialTheme.typography.labelSmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } - } -} - -@Composable -private fun ThinkingMenuItem( - value: String, - current: String, - onSet: (String) -> Unit, - onDismiss: () -> Unit, -) { - DropdownMenuItem( - text = { Text(thinkingLabel(value)) }, - onClick = { - onSet(value) - onDismiss() - }, - trailingIcon = { - if (value == current.trim().lowercase()) { - Text("✓") - } else { - Spacer(modifier = Modifier.width(10.dp)) - } - }, - ) -} - -private fun thinkingLabel(raw: String): String { - return when (raw.trim().lowercase()) { - "low" -> "Low" - "medium" -> "Medium" - "high" -> "High" - else -> "Off" - } -} - -@Composable -private fun AttachmentsStrip( - attachments: List, - onRemoveAttachment: (id: String) -> Unit, -) { - Row( - modifier = Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()), - horizontalArrangement = Arrangement.spacedBy(8.dp), - ) { - for (att in attachments) { - AttachmentChip( - fileName = att.fileName, - onRemove = { onRemoveAttachment(att.id) }, - ) - } - } -} - -@Composable -private fun AttachmentChip(fileName: String, onRemove: () -> Unit) { - Surface( - shape = RoundedCornerShape(999.dp), - color = MaterialTheme.colorScheme.primary.copy(alpha = 0.10f), - ) { - Row( - modifier = Modifier.padding(horizontal = 10.dp, vertical = 6.dp), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(8.dp), - ) { - Text(text = fileName, style = MaterialTheme.typography.bodySmall, maxLines = 1) - FilledTonalIconButton( - onClick = onRemove, - modifier = Modifier.size(30.dp), - ) { - Text("×") - } - } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMarkdown.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMarkdown.kt deleted file mode 100644 index f15673fb3..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMarkdown.kt +++ /dev/null @@ -1,215 +0,0 @@ -package com.clawdbot.android.ui.chat - -import android.graphics.BitmapFactory -import android.util.Base64 -import androidx.compose.foundation.Image -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.text.selection.SelectionContainer -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.setValue -import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.asImageBitmap -import androidx.compose.ui.layout.ContentScale -import androidx.compose.ui.text.AnnotatedString -import androidx.compose.ui.text.SpanStyle -import androidx.compose.ui.text.buildAnnotatedString -import androidx.compose.ui.text.font.FontFamily -import androidx.compose.ui.text.font.FontStyle -import androidx.compose.ui.text.font.FontWeight -import androidx.compose.ui.text.withStyle -import androidx.compose.ui.unit.dp -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.withContext - -@Composable -fun ChatMarkdown(text: String, textColor: Color) { - val blocks = remember(text) { splitMarkdown(text) } - val inlineCodeBg = MaterialTheme.colorScheme.surfaceContainerLow - - Column(verticalArrangement = Arrangement.spacedBy(10.dp)) { - for (b in blocks) { - when (b) { - is ChatMarkdownBlock.Text -> { - val trimmed = b.text.trimEnd() - if (trimmed.isEmpty()) continue - Text( - text = parseInlineMarkdown(trimmed, inlineCodeBg = inlineCodeBg), - style = MaterialTheme.typography.bodyMedium, - color = textColor, - ) - } - is ChatMarkdownBlock.Code -> { - SelectionContainer(modifier = Modifier.fillMaxWidth()) { - ChatCodeBlock(code = b.code, language = b.language) - } - } - is ChatMarkdownBlock.InlineImage -> { - InlineBase64Image(base64 = b.base64, mimeType = b.mimeType) - } - } - } - } -} - -private sealed interface ChatMarkdownBlock { - data class Text(val text: String) : ChatMarkdownBlock - data class Code(val code: String, val language: String?) : ChatMarkdownBlock - data class InlineImage(val mimeType: String?, val base64: String) : ChatMarkdownBlock -} - -private fun splitMarkdown(raw: String): List { - if (raw.isEmpty()) return emptyList() - - val out = ArrayList() - var idx = 0 - while (idx < raw.length) { - val fenceStart = raw.indexOf("```", startIndex = idx) - if (fenceStart < 0) { - out.addAll(splitInlineImages(raw.substring(idx))) - break - } - - if (fenceStart > idx) { - out.addAll(splitInlineImages(raw.substring(idx, fenceStart))) - } - - val langLineStart = fenceStart + 3 - val langLineEnd = raw.indexOf('\n', startIndex = langLineStart).let { if (it < 0) raw.length else it } - val language = raw.substring(langLineStart, langLineEnd).trim().ifEmpty { null } - - val codeStart = if (langLineEnd < raw.length && raw[langLineEnd] == '\n') langLineEnd + 1 else langLineEnd - val fenceEnd = raw.indexOf("```", startIndex = codeStart) - if (fenceEnd < 0) { - out.addAll(splitInlineImages(raw.substring(fenceStart))) - break - } - val code = raw.substring(codeStart, fenceEnd) - out.add(ChatMarkdownBlock.Code(code = code, language = language)) - - idx = fenceEnd + 3 - } - - return out -} - -private fun splitInlineImages(text: String): List { - if (text.isEmpty()) return emptyList() - val regex = Regex("data:image/([a-zA-Z0-9+.-]+);base64,([A-Za-z0-9+/=\\n\\r]+)") - val out = ArrayList() - - var idx = 0 - while (idx < text.length) { - val m = regex.find(text, startIndex = idx) ?: break - val start = m.range.first - val end = m.range.last + 1 - if (start > idx) out.add(ChatMarkdownBlock.Text(text.substring(idx, start))) - - val mime = "image/" + (m.groupValues.getOrNull(1)?.trim()?.ifEmpty { "png" } ?: "png") - val b64 = m.groupValues.getOrNull(2)?.replace("\n", "")?.replace("\r", "")?.trim().orEmpty() - if (b64.isNotEmpty()) { - out.add(ChatMarkdownBlock.InlineImage(mimeType = mime, base64 = b64)) - } - idx = end - } - - if (idx < text.length) out.add(ChatMarkdownBlock.Text(text.substring(idx))) - return out -} - -private fun parseInlineMarkdown(text: String, inlineCodeBg: androidx.compose.ui.graphics.Color): AnnotatedString { - if (text.isEmpty()) return AnnotatedString("") - - val out = buildAnnotatedString { - var i = 0 - while (i < text.length) { - if (text.startsWith("**", startIndex = i)) { - val end = text.indexOf("**", startIndex = i + 2) - if (end > i + 2) { - withStyle(SpanStyle(fontWeight = FontWeight.SemiBold)) { - append(text.substring(i + 2, end)) - } - i = end + 2 - continue - } - } - - if (text[i] == '`') { - val end = text.indexOf('`', startIndex = i + 1) - if (end > i + 1) { - withStyle( - SpanStyle( - fontFamily = FontFamily.Monospace, - background = inlineCodeBg, - ), - ) { - append(text.substring(i + 1, end)) - } - i = end + 1 - continue - } - } - - if (text[i] == '*' && (i + 1 < text.length && text[i + 1] != '*')) { - val end = text.indexOf('*', startIndex = i + 1) - if (end > i + 1) { - withStyle(SpanStyle(fontStyle = FontStyle.Italic)) { - append(text.substring(i + 1, end)) - } - i = end + 1 - continue - } - } - - append(text[i]) - i += 1 - } - } - return out -} - -@Composable -private fun InlineBase64Image(base64: String, mimeType: String?) { - var image by remember(base64) { mutableStateOf(null) } - var failed by remember(base64) { mutableStateOf(false) } - - LaunchedEffect(base64) { - failed = false - image = - withContext(Dispatchers.Default) { - try { - val bytes = Base64.decode(base64, Base64.DEFAULT) - val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) ?: return@withContext null - bitmap.asImageBitmap() - } catch (_: Throwable) { - null - } - } - if (image == null) failed = true - } - - if (image != null) { - Image( - bitmap = image!!, - contentDescription = mimeType ?: "image", - contentScale = ContentScale.Fit, - modifier = Modifier.fillMaxWidth(), - ) - } else if (failed) { - Text( - text = "Image unavailable", - modifier = Modifier.padding(vertical = 2.dp), - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMessageListCard.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMessageListCard.kt deleted file mode 100644 index a3229d4a2..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMessageListCard.kt +++ /dev/null @@ -1,111 +0,0 @@ -package com.clawdbot.android.ui.chat - -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Box -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.fillMaxSize -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.lazy.LazyColumn -import androidx.compose.foundation.lazy.rememberLazyListState -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.ArrowCircleDown -import androidx.compose.material3.Card -import androidx.compose.material3.CardDefaults -import androidx.compose.material3.Icon -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.draw.alpha -import androidx.compose.ui.unit.dp -import com.clawdbot.android.chat.ChatMessage -import com.clawdbot.android.chat.ChatPendingToolCall - -@Composable -fun ChatMessageListCard( - messages: List, - pendingRunCount: Int, - pendingToolCalls: List, - streamingAssistantText: String?, - modifier: Modifier = Modifier, -) { - val listState = rememberLazyListState() - - LaunchedEffect(messages.size, pendingRunCount, pendingToolCalls.size, streamingAssistantText) { - val total = - messages.size + - (if (pendingRunCount > 0) 1 else 0) + - (if (pendingToolCalls.isNotEmpty()) 1 else 0) + - (if (!streamingAssistantText.isNullOrBlank()) 1 else 0) - if (total <= 0) return@LaunchedEffect - listState.animateScrollToItem(index = total - 1) - } - - Card( - modifier = modifier.fillMaxWidth(), - shape = MaterialTheme.shapes.large, - colors = - CardDefaults.cardColors( - containerColor = MaterialTheme.colorScheme.surfaceContainer, - ), - elevation = CardDefaults.cardElevation(defaultElevation = 0.dp), - ) { - Box(modifier = Modifier.fillMaxSize()) { - LazyColumn( - modifier = Modifier.fillMaxSize(), - state = listState, - verticalArrangement = Arrangement.spacedBy(14.dp), - contentPadding = androidx.compose.foundation.layout.PaddingValues(top = 12.dp, bottom = 12.dp, start = 12.dp, end = 12.dp), - ) { - items(count = messages.size, key = { idx -> messages[idx].id }) { idx -> - ChatMessageBubble(message = messages[idx]) - } - - if (pendingRunCount > 0) { - item(key = "typing") { - ChatTypingIndicatorBubble() - } - } - - if (pendingToolCalls.isNotEmpty()) { - item(key = "tools") { - ChatPendingToolsBubble(toolCalls = pendingToolCalls) - } - } - - val stream = streamingAssistantText?.trim() - if (!stream.isNullOrEmpty()) { - item(key = "stream") { - ChatStreamingAssistantBubble(text = stream) - } - } - } - - if (messages.isEmpty() && pendingRunCount == 0 && pendingToolCalls.isEmpty() && streamingAssistantText.isNullOrBlank()) { - EmptyChatHint(modifier = Modifier.align(Alignment.Center)) - } - } - } -} - -@Composable -private fun EmptyChatHint(modifier: Modifier = Modifier) { - Row( - modifier = modifier.alpha(0.7f), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(8.dp), - ) { - Icon( - imageVector = Icons.Default.ArrowCircleDown, - contentDescription = null, - tint = MaterialTheme.colorScheme.onSurfaceVariant, - ) - Text( - text = "Message Clawd…", - style = MaterialTheme.typography.bodyMedium, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMessageViews.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMessageViews.kt deleted file mode 100644 index 59479744e..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMessageViews.kt +++ /dev/null @@ -1,252 +0,0 @@ -package com.clawdbot.android.ui.chat - -import android.graphics.BitmapFactory -import android.util.Base64 -import androidx.compose.foundation.background -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Box -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.layout.size -import androidx.compose.foundation.shape.CircleShape -import androidx.compose.foundation.shape.RoundedCornerShape -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Surface -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.setValue -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.draw.alpha -import androidx.compose.ui.graphics.Brush -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.asImageBitmap -import androidx.compose.ui.layout.ContentScale -import androidx.compose.ui.text.font.FontFamily -import androidx.compose.ui.unit.dp -import androidx.compose.foundation.Image -import com.clawdbot.android.chat.ChatMessage -import com.clawdbot.android.chat.ChatMessageContent -import com.clawdbot.android.chat.ChatPendingToolCall -import com.clawdbot.android.tools.ToolDisplayRegistry -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.withContext -import androidx.compose.ui.platform.LocalContext - -@Composable -fun ChatMessageBubble(message: ChatMessage) { - val isUser = message.role.lowercase() == "user" - - Row( - modifier = Modifier.fillMaxWidth(), - horizontalArrangement = if (isUser) Arrangement.End else Arrangement.Start, - ) { - Surface( - shape = RoundedCornerShape(16.dp), - tonalElevation = 0.dp, - shadowElevation = 0.dp, - color = Color.Transparent, - modifier = Modifier.fillMaxWidth(0.92f), - ) { - Box( - modifier = - Modifier - .background(bubbleBackground(isUser)) - .padding(horizontal = 12.dp, vertical = 10.dp), - ) { - val textColor = textColorOverBubble(isUser) - ChatMessageBody(content = message.content, textColor = textColor) - } - } - } -} - -@Composable -private fun ChatMessageBody(content: List, textColor: Color) { - Column(verticalArrangement = Arrangement.spacedBy(10.dp)) { - for (part in content) { - when (part.type) { - "text" -> { - val text = part.text ?: continue - ChatMarkdown(text = text, textColor = textColor) - } - else -> { - val b64 = part.base64 ?: continue - ChatBase64Image(base64 = b64, mimeType = part.mimeType) - } - } - } - } -} - -@Composable -fun ChatTypingIndicatorBubble() { - Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.Start) { - Surface( - shape = RoundedCornerShape(16.dp), - color = MaterialTheme.colorScheme.surfaceContainer, - ) { - Row( - modifier = Modifier.padding(horizontal = 12.dp, vertical = 10.dp), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(8.dp), - ) { - DotPulse() - Text("Thinking…", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant) - } - } - } -} - -@Composable -fun ChatPendingToolsBubble(toolCalls: List) { - val context = LocalContext.current - val displays = - remember(toolCalls, context) { - toolCalls.map { ToolDisplayRegistry.resolve(context, it.name, it.args) } - } - Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.Start) { - Surface( - shape = RoundedCornerShape(16.dp), - color = MaterialTheme.colorScheme.surfaceContainer, - ) { - Column(modifier = Modifier.padding(horizontal = 12.dp, vertical = 10.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) { - Text("Running tools…", style = MaterialTheme.typography.labelLarge, color = MaterialTheme.colorScheme.onSurface) - for (display in displays.take(6)) { - Column(verticalArrangement = Arrangement.spacedBy(2.dp)) { - Text( - "${display.emoji} ${display.label}", - style = MaterialTheme.typography.bodyMedium, - color = MaterialTheme.colorScheme.onSurfaceVariant, - fontFamily = FontFamily.Monospace, - ) - display.detailLine?.let { detail -> - Text( - detail, - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, - fontFamily = FontFamily.Monospace, - ) - } - } - } - if (toolCalls.size > 6) { - Text( - "… +${toolCalls.size - 6} more", - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } - } - } - } -} - -@Composable -fun ChatStreamingAssistantBubble(text: String) { - Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.Start) { - Surface( - shape = RoundedCornerShape(16.dp), - color = MaterialTheme.colorScheme.surfaceContainer, - ) { - Box(modifier = Modifier.padding(horizontal = 12.dp, vertical = 10.dp)) { - ChatMarkdown(text = text, textColor = MaterialTheme.colorScheme.onSurface) - } - } - } -} - -@Composable -private fun bubbleBackground(isUser: Boolean): Brush { - return if (isUser) { - Brush.linearGradient( - colors = listOf(MaterialTheme.colorScheme.primary, MaterialTheme.colorScheme.primary.copy(alpha = 0.78f)), - ) - } else { - Brush.linearGradient( - colors = listOf(MaterialTheme.colorScheme.surfaceContainer, MaterialTheme.colorScheme.surfaceContainerHigh), - ) - } -} - -@Composable -private fun textColorOverBubble(isUser: Boolean): Color { - return if (isUser) { - MaterialTheme.colorScheme.onPrimary - } else { - MaterialTheme.colorScheme.onSurface - } -} - -@Composable -private fun ChatBase64Image(base64: String, mimeType: String?) { - var image by remember(base64) { mutableStateOf(null) } - var failed by remember(base64) { mutableStateOf(false) } - - LaunchedEffect(base64) { - failed = false - image = - withContext(Dispatchers.Default) { - try { - val bytes = Base64.decode(base64, Base64.DEFAULT) - val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) ?: return@withContext null - bitmap.asImageBitmap() - } catch (_: Throwable) { - null - } - } - if (image == null) failed = true - } - - if (image != null) { - Image( - bitmap = image!!, - contentDescription = mimeType ?: "attachment", - contentScale = ContentScale.Fit, - modifier = Modifier.fillMaxWidth(), - ) - } else if (failed) { - Text("Unsupported attachment", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant) - } -} - -@Composable -private fun DotPulse() { - Row(horizontalArrangement = Arrangement.spacedBy(5.dp), verticalAlignment = Alignment.CenterVertically) { - PulseDot(alpha = 0.38f) - PulseDot(alpha = 0.62f) - PulseDot(alpha = 0.90f) - } -} - -@Composable -private fun PulseDot(alpha: Float) { - Surface( - modifier = Modifier.size(6.dp).alpha(alpha), - shape = CircleShape, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) {} -} - -@Composable -fun ChatCodeBlock(code: String, language: String?) { - Surface( - shape = RoundedCornerShape(12.dp), - color = MaterialTheme.colorScheme.surfaceContainerLowest, - modifier = Modifier.fillMaxWidth(), - ) { - Text( - text = code.trimEnd(), - modifier = Modifier.padding(10.dp), - fontFamily = FontFamily.Monospace, - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurface, - ) - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatSessionsDialog.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatSessionsDialog.kt deleted file mode 100644 index 9474b2362..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatSessionsDialog.kt +++ /dev/null @@ -1,92 +0,0 @@ -package com.clawdbot.android.ui.chat - -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.Spacer -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.lazy.LazyColumn -import androidx.compose.foundation.lazy.items -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Refresh -import androidx.compose.material3.AlertDialog -import androidx.compose.material3.FilledTonalIconButton -import androidx.compose.material3.Icon -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Surface -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable -import androidx.compose.ui.Alignment -import androidx.compose.ui.Modifier -import androidx.compose.ui.unit.dp -import com.clawdbot.android.chat.ChatSessionEntry - -@Composable -fun ChatSessionsDialog( - currentSessionKey: String, - sessions: List, - onDismiss: () -> Unit, - onRefresh: () -> Unit, - onSelect: (sessionKey: String) -> Unit, -) { - AlertDialog( - onDismissRequest = onDismiss, - confirmButton = {}, - title = { - Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { - Text("Sessions", style = MaterialTheme.typography.titleMedium) - Spacer(modifier = Modifier.weight(1f)) - FilledTonalIconButton(onClick = onRefresh) { - Icon(Icons.Default.Refresh, contentDescription = "Refresh") - } - } - }, - text = { - if (sessions.isEmpty()) { - Text("No sessions", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant) - } else { - LazyColumn(verticalArrangement = Arrangement.spacedBy(8.dp)) { - items(sessions, key = { it.key }) { entry -> - SessionRow( - entry = entry, - isCurrent = entry.key == currentSessionKey, - onClick = { onSelect(entry.key) }, - ) - } - } - } - }, - ) -} - -@Composable -private fun SessionRow( - entry: ChatSessionEntry, - isCurrent: Boolean, - onClick: () -> Unit, -) { - Surface( - onClick = onClick, - shape = MaterialTheme.shapes.medium, - color = - if (isCurrent) { - MaterialTheme.colorScheme.primary.copy(alpha = 0.14f) - } else { - MaterialTheme.colorScheme.surfaceContainer - }, - modifier = Modifier.fillMaxWidth(), - ) { - Row( - modifier = Modifier.padding(horizontal = 12.dp, vertical = 10.dp), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(10.dp), - ) { - Text(entry.displayName ?: entry.key, style = MaterialTheme.typography.bodyMedium) - Spacer(modifier = Modifier.weight(1f)) - if (isCurrent) { - Text("Current", style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant) - } - } - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatSheetContent.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatSheetContent.kt deleted file mode 100644 index 2b58c626b..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatSheetContent.kt +++ /dev/null @@ -1,147 +0,0 @@ -package com.clawdbot.android.ui.chat - -import android.content.ContentResolver -import android.net.Uri -import android.util.Base64 -import androidx.activity.compose.rememberLauncherForActivityResult -import androidx.activity.result.contract.ActivityResultContracts -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.fillMaxSize -import androidx.compose.foundation.layout.padding -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.runtime.collectAsState -import androidx.compose.runtime.getValue -import androidx.compose.runtime.mutableStateListOf -import androidx.compose.runtime.remember -import androidx.compose.runtime.rememberCoroutineScope -import androidx.compose.ui.Modifier -import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.unit.dp -import com.clawdbot.android.MainViewModel -import com.clawdbot.android.chat.OutgoingAttachment -import java.io.ByteArrayOutputStream -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.launch -import kotlinx.coroutines.withContext - -@Composable -fun ChatSheetContent(viewModel: MainViewModel) { - val messages by viewModel.chatMessages.collectAsState() - val errorText by viewModel.chatError.collectAsState() - val pendingRunCount by viewModel.pendingRunCount.collectAsState() - val healthOk by viewModel.chatHealthOk.collectAsState() - val sessionKey by viewModel.chatSessionKey.collectAsState() - val mainSessionKey by viewModel.mainSessionKey.collectAsState() - val thinkingLevel by viewModel.chatThinkingLevel.collectAsState() - val streamingAssistantText by viewModel.chatStreamingAssistantText.collectAsState() - val pendingToolCalls by viewModel.chatPendingToolCalls.collectAsState() - val sessions by viewModel.chatSessions.collectAsState() - - LaunchedEffect(mainSessionKey) { - viewModel.loadChat(mainSessionKey) - viewModel.refreshChatSessions(limit = 200) - } - - val context = LocalContext.current - val resolver = context.contentResolver - val scope = rememberCoroutineScope() - - val attachments = remember { mutableStateListOf() } - - val pickImages = - rememberLauncherForActivityResult(ActivityResultContracts.GetMultipleContents()) { uris -> - if (uris.isNullOrEmpty()) return@rememberLauncherForActivityResult - scope.launch(Dispatchers.IO) { - val next = - uris.take(8).mapNotNull { uri -> - try { - loadImageAttachment(resolver, uri) - } catch (_: Throwable) { - null - } - } - withContext(Dispatchers.Main) { - attachments.addAll(next) - } - } - } - - Column( - modifier = - Modifier - .fillMaxSize() - .padding(horizontal = 12.dp, vertical = 12.dp), - verticalArrangement = Arrangement.spacedBy(10.dp), - ) { - ChatMessageListCard( - messages = messages, - pendingRunCount = pendingRunCount, - pendingToolCalls = pendingToolCalls, - streamingAssistantText = streamingAssistantText, - modifier = Modifier.weight(1f, fill = true), - ) - - ChatComposer( - sessionKey = sessionKey, - sessions = sessions, - mainSessionKey = mainSessionKey, - healthOk = healthOk, - thinkingLevel = thinkingLevel, - pendingRunCount = pendingRunCount, - errorText = errorText, - attachments = attachments, - onPickImages = { pickImages.launch("image/*") }, - onRemoveAttachment = { id -> attachments.removeAll { it.id == id } }, - onSetThinkingLevel = { level -> viewModel.setChatThinkingLevel(level) }, - onSelectSession = { key -> viewModel.switchChatSession(key) }, - onRefresh = { - viewModel.refreshChat() - viewModel.refreshChatSessions(limit = 200) - }, - onAbort = { viewModel.abortChat() }, - onSend = { text -> - val outgoing = - attachments.map { att -> - OutgoingAttachment( - type = "image", - mimeType = att.mimeType, - fileName = att.fileName, - base64 = att.base64, - ) - } - viewModel.sendChat(message = text, thinking = thinkingLevel, attachments = outgoing) - attachments.clear() - }, - ) - } -} - -data class PendingImageAttachment( - val id: String, - val fileName: String, - val mimeType: String, - val base64: String, -) - -private suspend fun loadImageAttachment(resolver: ContentResolver, uri: Uri): PendingImageAttachment { - val mimeType = resolver.getType(uri) ?: "image/*" - val fileName = (uri.lastPathSegment ?: "image").substringAfterLast('/') - val bytes = - withContext(Dispatchers.IO) { - resolver.openInputStream(uri)?.use { input -> - val out = ByteArrayOutputStream() - input.copyTo(out) - out.toByteArray() - } ?: ByteArray(0) - } - if (bytes.isEmpty()) throw IllegalStateException("empty attachment") - val base64 = Base64.encodeToString(bytes, Base64.NO_WRAP) - return PendingImageAttachment( - id = uri.toString() + "#" + System.currentTimeMillis().toString(), - fileName = fileName, - mimeType = mimeType, - base64 = base64, - ) -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/SessionFilters.kt b/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/SessionFilters.kt deleted file mode 100644 index da08dbd1e..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/ui/chat/SessionFilters.kt +++ /dev/null @@ -1,49 +0,0 @@ -package com.clawdbot.android.ui.chat - -import com.clawdbot.android.chat.ChatSessionEntry - -private const val RECENT_WINDOW_MS = 24 * 60 * 60 * 1000L - -fun resolveSessionChoices( - currentSessionKey: String, - sessions: List, - mainSessionKey: String, - nowMs: Long = System.currentTimeMillis(), -): List { - val mainKey = mainSessionKey.trim().ifEmpty { "main" } - val current = currentSessionKey.trim().let { if (it == "main" && mainKey != "main") mainKey else it } - val aliasKey = if (mainKey == "main") null else "main" - val cutoff = nowMs - RECENT_WINDOW_MS - val sorted = sessions.sortedByDescending { it.updatedAtMs ?: 0L } - val recent = mutableListOf() - val seen = mutableSetOf() - for (entry in sorted) { - if (aliasKey != null && entry.key == aliasKey) continue - if (!seen.add(entry.key)) continue - if ((entry.updatedAtMs ?: 0L) < cutoff) continue - recent.add(entry) - } - - val result = mutableListOf() - val included = mutableSetOf() - val mainEntry = sorted.firstOrNull { it.key == mainKey } - if (mainEntry != null) { - result.add(mainEntry) - included.add(mainKey) - } else if (current == mainKey) { - result.add(ChatSessionEntry(key = mainKey, updatedAtMs = null)) - included.add(mainKey) - } - - for (entry in recent) { - if (included.add(entry.key)) { - result.add(entry) - } - } - - if (current.isNotEmpty() && !included.contains(current)) { - result.add(ChatSessionEntry(key = current, updatedAtMs = null)) - } - - return result -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/voice/StreamingMediaDataSource.kt b/apps/android/app/src/main/java/com/clawdbot/android/voice/StreamingMediaDataSource.kt deleted file mode 100644 index 6b1536ad5..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/voice/StreamingMediaDataSource.kt +++ /dev/null @@ -1,98 +0,0 @@ -package com.clawdbot.android.voice - -import android.media.MediaDataSource -import kotlin.math.min - -internal class StreamingMediaDataSource : MediaDataSource() { - private data class Chunk(val start: Long, val data: ByteArray) - - private val lock = Object() - private val chunks = ArrayList() - private var totalSize: Long = 0 - private var closed = false - private var finished = false - private var lastReadIndex = 0 - - fun append(data: ByteArray) { - if (data.isEmpty()) return - synchronized(lock) { - if (closed || finished) return - val chunk = Chunk(totalSize, data) - chunks.add(chunk) - totalSize += data.size.toLong() - lock.notifyAll() - } - } - - fun finish() { - synchronized(lock) { - if (closed) return - finished = true - lock.notifyAll() - } - } - - fun fail() { - synchronized(lock) { - closed = true - lock.notifyAll() - } - } - - override fun readAt(position: Long, buffer: ByteArray, offset: Int, size: Int): Int { - if (position < 0) return -1 - synchronized(lock) { - while (!closed && !finished && position >= totalSize) { - lock.wait() - } - if (closed) return -1 - if (position >= totalSize && finished) return -1 - - val available = (totalSize - position).toInt() - val toRead = min(size, available) - var remaining = toRead - var destOffset = offset - var pos = position - - var index = findChunkIndex(pos) - while (remaining > 0 && index < chunks.size) { - val chunk = chunks[index] - val inChunkOffset = (pos - chunk.start).toInt() - if (inChunkOffset >= chunk.data.size) { - index++ - continue - } - val copyLen = min(remaining, chunk.data.size - inChunkOffset) - System.arraycopy(chunk.data, inChunkOffset, buffer, destOffset, copyLen) - remaining -= copyLen - destOffset += copyLen - pos += copyLen - if (inChunkOffset + copyLen >= chunk.data.size) { - index++ - } - } - - return toRead - remaining - } - } - - override fun getSize(): Long = -1 - - override fun close() { - synchronized(lock) { - closed = true - lock.notifyAll() - } - } - - private fun findChunkIndex(position: Long): Int { - var index = lastReadIndex - while (index < chunks.size) { - val chunk = chunks[index] - if (position < chunk.start + chunk.data.size) break - index++ - } - lastReadIndex = index - return index - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/voice/TalkDirectiveParser.kt b/apps/android/app/src/main/java/com/clawdbot/android/voice/TalkDirectiveParser.kt deleted file mode 100644 index 02d2c3967..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/voice/TalkDirectiveParser.kt +++ /dev/null @@ -1,191 +0,0 @@ -package com.clawdbot.android.voice - -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonElement -import kotlinx.serialization.json.JsonObject -import kotlinx.serialization.json.JsonPrimitive - -private val directiveJson = Json { ignoreUnknownKeys = true } - -data class TalkDirective( - val voiceId: String? = null, - val modelId: String? = null, - val speed: Double? = null, - val rateWpm: Int? = null, - val stability: Double? = null, - val similarity: Double? = null, - val style: Double? = null, - val speakerBoost: Boolean? = null, - val seed: Long? = null, - val normalize: String? = null, - val language: String? = null, - val outputFormat: String? = null, - val latencyTier: Int? = null, - val once: Boolean? = null, -) - -data class TalkDirectiveParseResult( - val directive: TalkDirective?, - val stripped: String, - val unknownKeys: List, -) - -object TalkDirectiveParser { - fun parse(text: String): TalkDirectiveParseResult { - val normalized = text.replace("\r\n", "\n") - val lines = normalized.split("\n").toMutableList() - if (lines.isEmpty()) return TalkDirectiveParseResult(null, text, emptyList()) - - val firstNonEmpty = lines.indexOfFirst { it.trim().isNotEmpty() } - if (firstNonEmpty == -1) return TalkDirectiveParseResult(null, text, emptyList()) - - val head = lines[firstNonEmpty].trim() - if (!head.startsWith("{") || !head.endsWith("}")) { - return TalkDirectiveParseResult(null, text, emptyList()) - } - - val obj = parseJsonObject(head) ?: return TalkDirectiveParseResult(null, text, emptyList()) - - val speakerBoost = - boolValue(obj, listOf("speaker_boost", "speakerBoost")) - ?: boolValue(obj, listOf("no_speaker_boost", "noSpeakerBoost"))?.not() - - val directive = TalkDirective( - voiceId = stringValue(obj, listOf("voice", "voice_id", "voiceId")), - modelId = stringValue(obj, listOf("model", "model_id", "modelId")), - speed = doubleValue(obj, listOf("speed")), - rateWpm = intValue(obj, listOf("rate", "wpm")), - stability = doubleValue(obj, listOf("stability")), - similarity = doubleValue(obj, listOf("similarity", "similarity_boost", "similarityBoost")), - style = doubleValue(obj, listOf("style")), - speakerBoost = speakerBoost, - seed = longValue(obj, listOf("seed")), - normalize = stringValue(obj, listOf("normalize", "apply_text_normalization")), - language = stringValue(obj, listOf("lang", "language_code", "language")), - outputFormat = stringValue(obj, listOf("output_format", "format")), - latencyTier = intValue(obj, listOf("latency", "latency_tier", "latencyTier")), - once = boolValue(obj, listOf("once")), - ) - - val hasDirective = listOf( - directive.voiceId, - directive.modelId, - directive.speed, - directive.rateWpm, - directive.stability, - directive.similarity, - directive.style, - directive.speakerBoost, - directive.seed, - directive.normalize, - directive.language, - directive.outputFormat, - directive.latencyTier, - directive.once, - ).any { it != null } - - if (!hasDirective) return TalkDirectiveParseResult(null, text, emptyList()) - - val knownKeys = setOf( - "voice", "voice_id", "voiceid", - "model", "model_id", "modelid", - "speed", "rate", "wpm", - "stability", "similarity", "similarity_boost", "similarityboost", - "style", - "speaker_boost", "speakerboost", - "no_speaker_boost", "nospeakerboost", - "seed", - "normalize", "apply_text_normalization", - "lang", "language_code", "language", - "output_format", "format", - "latency", "latency_tier", "latencytier", - "once", - ) - val unknownKeys = obj.keys.filter { !knownKeys.contains(it.lowercase()) }.sorted() - - lines.removeAt(firstNonEmpty) - if (firstNonEmpty < lines.size) { - if (lines[firstNonEmpty].trim().isEmpty()) { - lines.removeAt(firstNonEmpty) - } - } - - return TalkDirectiveParseResult(directive, lines.joinToString("\n"), unknownKeys) - } - - private fun parseJsonObject(line: String): JsonObject? { - return try { - directiveJson.parseToJsonElement(line) as? JsonObject - } catch (_: Throwable) { - null - } - } - - private fun stringValue(obj: JsonObject, keys: List): String? { - for (key in keys) { - val value = obj[key].asStringOrNull()?.trim() - if (!value.isNullOrEmpty()) return value - } - return null - } - - private fun doubleValue(obj: JsonObject, keys: List): Double? { - for (key in keys) { - val value = obj[key].asDoubleOrNull() - if (value != null) return value - } - return null - } - - private fun intValue(obj: JsonObject, keys: List): Int? { - for (key in keys) { - val value = obj[key].asIntOrNull() - if (value != null) return value - } - return null - } - - private fun longValue(obj: JsonObject, keys: List): Long? { - for (key in keys) { - val value = obj[key].asLongOrNull() - if (value != null) return value - } - return null - } - - private fun boolValue(obj: JsonObject, keys: List): Boolean? { - for (key in keys) { - val value = obj[key].asBooleanOrNull() - if (value != null) return value - } - return null - } -} - -private fun JsonElement?.asStringOrNull(): String? = - (this as? JsonPrimitive)?.takeIf { it.isString }?.content - -private fun JsonElement?.asDoubleOrNull(): Double? { - val primitive = this as? JsonPrimitive ?: return null - return primitive.content.toDoubleOrNull() -} - -private fun JsonElement?.asIntOrNull(): Int? { - val primitive = this as? JsonPrimitive ?: return null - return primitive.content.toIntOrNull() -} - -private fun JsonElement?.asLongOrNull(): Long? { - val primitive = this as? JsonPrimitive ?: return null - return primitive.content.toLongOrNull() -} - -private fun JsonElement?.asBooleanOrNull(): Boolean? { - val primitive = this as? JsonPrimitive ?: return null - val content = primitive.content.trim().lowercase() - return when (content) { - "true", "yes", "1" -> true - "false", "no", "0" -> false - else -> null - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/voice/TalkModeManager.kt b/apps/android/app/src/main/java/com/clawdbot/android/voice/TalkModeManager.kt deleted file mode 100644 index 41f98140d..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/voice/TalkModeManager.kt +++ /dev/null @@ -1,1257 +0,0 @@ -package com.clawdbot.android.voice - -import android.Manifest -import android.content.Context -import android.content.Intent -import android.content.pm.PackageManager -import android.media.AudioAttributes -import android.media.AudioFormat -import android.media.AudioManager -import android.media.AudioTrack -import android.media.MediaPlayer -import android.os.Bundle -import android.os.Handler -import android.os.Looper -import android.os.SystemClock -import android.speech.RecognitionListener -import android.speech.RecognizerIntent -import android.speech.SpeechRecognizer -import android.speech.tts.TextToSpeech -import android.speech.tts.UtteranceProgressListener -import android.util.Log -import androidx.core.content.ContextCompat -import com.clawdbot.android.gateway.GatewaySession -import com.clawdbot.android.isCanonicalMainSessionKey -import com.clawdbot.android.normalizeMainKey -import java.net.HttpURLConnection -import java.net.URL -import java.util.UUID -import kotlinx.coroutines.CompletableDeferred -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.Job -import kotlinx.coroutines.delay -import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.flow.StateFlow -import kotlinx.coroutines.launch -import kotlinx.coroutines.withContext -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonArray -import kotlinx.serialization.json.JsonElement -import kotlinx.serialization.json.JsonObject -import kotlinx.serialization.json.JsonPrimitive -import kotlinx.serialization.json.buildJsonObject -import kotlin.math.max - -class TalkModeManager( - private val context: Context, - private val scope: CoroutineScope, - private val session: GatewaySession, - private val supportsChatSubscribe: Boolean, - private val isConnected: () -> Boolean, -) { - companion object { - private const val tag = "TalkMode" - private const val defaultModelIdFallback = "eleven_v3" - private const val defaultOutputFormatFallback = "pcm_24000" - } - - private val mainHandler = Handler(Looper.getMainLooper()) - private val json = Json { ignoreUnknownKeys = true } - - private val _isEnabled = MutableStateFlow(false) - val isEnabled: StateFlow = _isEnabled - - private val _isListening = MutableStateFlow(false) - val isListening: StateFlow = _isListening - - private val _isSpeaking = MutableStateFlow(false) - val isSpeaking: StateFlow = _isSpeaking - - private val _statusText = MutableStateFlow("Off") - val statusText: StateFlow = _statusText - - private val _lastAssistantText = MutableStateFlow(null) - val lastAssistantText: StateFlow = _lastAssistantText - - private val _usingFallbackTts = MutableStateFlow(false) - val usingFallbackTts: StateFlow = _usingFallbackTts - - private var recognizer: SpeechRecognizer? = null - private var restartJob: Job? = null - private var stopRequested = false - private var listeningMode = false - - private var silenceJob: Job? = null - private val silenceWindowMs = 700L - private var lastTranscript: String = "" - private var lastHeardAtMs: Long? = null - private var lastSpokenText: String? = null - private var lastInterruptedAtSeconds: Double? = null - - private var defaultVoiceId: String? = null - private var currentVoiceId: String? = null - private var fallbackVoiceId: String? = null - private var defaultModelId: String? = null - private var currentModelId: String? = null - private var defaultOutputFormat: String? = null - private var apiKey: String? = null - private var voiceAliases: Map = emptyMap() - private var interruptOnSpeech: Boolean = true - private var voiceOverrideActive = false - private var modelOverrideActive = false - private var mainSessionKey: String = "main" - - private var pendingRunId: String? = null - private var pendingFinal: CompletableDeferred? = null - private var chatSubscribedSessionKey: String? = null - - private var player: MediaPlayer? = null - private var streamingSource: StreamingMediaDataSource? = null - private var pcmTrack: AudioTrack? = null - @Volatile private var pcmStopRequested = false - private var systemTts: TextToSpeech? = null - private var systemTtsPending: CompletableDeferred? = null - private var systemTtsPendingId: String? = null - - fun setMainSessionKey(sessionKey: String?) { - val trimmed = sessionKey?.trim().orEmpty() - if (trimmed.isEmpty()) return - if (isCanonicalMainSessionKey(mainSessionKey)) return - mainSessionKey = trimmed - } - - fun setEnabled(enabled: Boolean) { - if (_isEnabled.value == enabled) return - _isEnabled.value = enabled - if (enabled) { - Log.d(tag, "enabled") - start() - } else { - Log.d(tag, "disabled") - stop() - } - } - - fun handleGatewayEvent(event: String, payloadJson: String?) { - if (event != "chat") return - if (payloadJson.isNullOrBlank()) return - val pending = pendingRunId ?: return - val obj = - try { - json.parseToJsonElement(payloadJson).asObjectOrNull() - } catch (_: Throwable) { - null - } ?: return - val runId = obj["runId"].asStringOrNull() ?: return - if (runId != pending) return - val state = obj["state"].asStringOrNull() ?: return - if (state == "final") { - pendingFinal?.complete(true) - pendingFinal = null - pendingRunId = null - } - } - - private fun start() { - mainHandler.post { - if (_isListening.value) return@post - stopRequested = false - listeningMode = true - Log.d(tag, "start") - - if (!SpeechRecognizer.isRecognitionAvailable(context)) { - _statusText.value = "Speech recognizer unavailable" - Log.w(tag, "speech recognizer unavailable") - return@post - } - - val micOk = - ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) == - PackageManager.PERMISSION_GRANTED - if (!micOk) { - _statusText.value = "Microphone permission required" - Log.w(tag, "microphone permission required") - return@post - } - - try { - recognizer?.destroy() - recognizer = SpeechRecognizer.createSpeechRecognizer(context).also { it.setRecognitionListener(listener) } - startListeningInternal(markListening = true) - startSilenceMonitor() - Log.d(tag, "listening") - } catch (err: Throwable) { - _statusText.value = "Start failed: ${err.message ?: err::class.simpleName}" - Log.w(tag, "start failed: ${err.message ?: err::class.simpleName}") - } - } - } - - private fun stop() { - stopRequested = true - listeningMode = false - restartJob?.cancel() - restartJob = null - silenceJob?.cancel() - silenceJob = null - lastTranscript = "" - lastHeardAtMs = null - _isListening.value = false - _statusText.value = "Off" - stopSpeaking() - _usingFallbackTts.value = false - chatSubscribedSessionKey = null - - mainHandler.post { - recognizer?.cancel() - recognizer?.destroy() - recognizer = null - } - systemTts?.stop() - systemTtsPending?.cancel() - systemTtsPending = null - systemTtsPendingId = null - } - - private fun startListeningInternal(markListening: Boolean) { - val r = recognizer ?: return - val intent = - Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply { - putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM) - putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true) - putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 3) - putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, context.packageName) - } - - if (markListening) { - _statusText.value = "Listening" - _isListening.value = true - } - r.startListening(intent) - } - - private fun scheduleRestart(delayMs: Long = 350) { - if (stopRequested) return - restartJob?.cancel() - restartJob = - scope.launch { - delay(delayMs) - mainHandler.post { - if (stopRequested) return@post - try { - recognizer?.cancel() - val shouldListen = listeningMode - val shouldInterrupt = _isSpeaking.value && interruptOnSpeech - if (!shouldListen && !shouldInterrupt) return@post - startListeningInternal(markListening = shouldListen) - } catch (_: Throwable) { - // handled by onError - } - } - } - } - - private fun handleTranscript(text: String, isFinal: Boolean) { - val trimmed = text.trim() - if (_isSpeaking.value && interruptOnSpeech) { - if (shouldInterrupt(trimmed)) { - stopSpeaking() - } - return - } - - if (!_isListening.value) return - - if (trimmed.isNotEmpty()) { - lastTranscript = trimmed - lastHeardAtMs = SystemClock.elapsedRealtime() - } - - if (isFinal) { - lastTranscript = trimmed - } - } - - private fun startSilenceMonitor() { - silenceJob?.cancel() - silenceJob = - scope.launch { - while (_isEnabled.value) { - delay(200) - checkSilence() - } - } - } - - private fun checkSilence() { - if (!_isListening.value) return - val transcript = lastTranscript.trim() - if (transcript.isEmpty()) return - val lastHeard = lastHeardAtMs ?: return - val elapsed = SystemClock.elapsedRealtime() - lastHeard - if (elapsed < silenceWindowMs) return - scope.launch { finalizeTranscript(transcript) } - } - - private suspend fun finalizeTranscript(transcript: String) { - listeningMode = false - _isListening.value = false - _statusText.value = "Thinking…" - lastTranscript = "" - lastHeardAtMs = null - - reloadConfig() - val prompt = buildPrompt(transcript) - if (!isConnected()) { - _statusText.value = "Gateway not connected" - Log.w(tag, "finalize: gateway not connected") - start() - return - } - - try { - val startedAt = System.currentTimeMillis().toDouble() / 1000.0 - subscribeChatIfNeeded(session = session, sessionKey = mainSessionKey) - Log.d(tag, "chat.send start sessionKey=${mainSessionKey.ifBlank { "main" }} chars=${prompt.length}") - val runId = sendChat(prompt, session) - Log.d(tag, "chat.send ok runId=$runId") - val ok = waitForChatFinal(runId) - if (!ok) { - Log.w(tag, "chat final timeout runId=$runId; attempting history fallback") - } - val assistant = waitForAssistantText(session, startedAt, if (ok) 12_000 else 25_000) - if (assistant.isNullOrBlank()) { - _statusText.value = "No reply" - Log.w(tag, "assistant text timeout runId=$runId") - start() - return - } - Log.d(tag, "assistant text ok chars=${assistant.length}") - playAssistant(assistant) - } catch (err: Throwable) { - _statusText.value = "Talk failed: ${err.message ?: err::class.simpleName}" - Log.w(tag, "finalize failed: ${err.message ?: err::class.simpleName}") - } - - if (_isEnabled.value) { - start() - } - } - - private suspend fun subscribeChatIfNeeded(session: GatewaySession, sessionKey: String) { - if (!supportsChatSubscribe) return - val key = sessionKey.trim() - if (key.isEmpty()) return - if (chatSubscribedSessionKey == key) return - try { - session.sendNodeEvent("chat.subscribe", """{"sessionKey":"$key"}""") - chatSubscribedSessionKey = key - Log.d(tag, "chat.subscribe ok sessionKey=$key") - } catch (err: Throwable) { - Log.w(tag, "chat.subscribe failed sessionKey=$key err=${err.message ?: err::class.java.simpleName}") - } - } - - private fun buildPrompt(transcript: String): String { - val lines = mutableListOf( - "Talk Mode active. Reply in a concise, spoken tone.", - "You may optionally prefix the response with JSON (first line) to set ElevenLabs voice (id or alias), e.g. {\"voice\":\"\",\"once\":true}.", - ) - lastInterruptedAtSeconds?.let { - lines.add("Assistant speech interrupted at ${"%.1f".format(it)}s.") - lastInterruptedAtSeconds = null - } - lines.add("") - lines.add(transcript) - return lines.joinToString("\n") - } - - private suspend fun sendChat(message: String, session: GatewaySession): String { - val runId = UUID.randomUUID().toString() - val params = - buildJsonObject { - put("sessionKey", JsonPrimitive(mainSessionKey.ifBlank { "main" })) - put("message", JsonPrimitive(message)) - put("thinking", JsonPrimitive("low")) - put("timeoutMs", JsonPrimitive(30_000)) - put("idempotencyKey", JsonPrimitive(runId)) - } - val res = session.request("chat.send", params.toString()) - val parsed = parseRunId(res) ?: runId - if (parsed != runId) { - pendingRunId = parsed - } - return parsed - } - - private suspend fun waitForChatFinal(runId: String): Boolean { - pendingFinal?.cancel() - val deferred = CompletableDeferred() - pendingRunId = runId - pendingFinal = deferred - - val result = - withContext(Dispatchers.IO) { - try { - kotlinx.coroutines.withTimeout(120_000) { deferred.await() } - } catch (_: Throwable) { - false - } - } - - if (!result) { - pendingFinal = null - pendingRunId = null - } - return result - } - - private suspend fun waitForAssistantText( - session: GatewaySession, - sinceSeconds: Double, - timeoutMs: Long, - ): String? { - val deadline = SystemClock.elapsedRealtime() + timeoutMs - while (SystemClock.elapsedRealtime() < deadline) { - val text = fetchLatestAssistantText(session, sinceSeconds) - if (!text.isNullOrBlank()) return text - delay(300) - } - return null - } - - private suspend fun fetchLatestAssistantText( - session: GatewaySession, - sinceSeconds: Double? = null, - ): String? { - val key = mainSessionKey.ifBlank { "main" } - val res = session.request("chat.history", "{\"sessionKey\":\"$key\"}") - val root = json.parseToJsonElement(res).asObjectOrNull() ?: return null - val messages = root["messages"] as? JsonArray ?: return null - for (item in messages.reversed()) { - val obj = item.asObjectOrNull() ?: continue - if (obj["role"].asStringOrNull() != "assistant") continue - if (sinceSeconds != null) { - val timestamp = obj["timestamp"].asDoubleOrNull() - if (timestamp != null && !TalkModeRuntime.isMessageTimestampAfter(timestamp, sinceSeconds)) continue - } - val content = obj["content"] as? JsonArray ?: continue - val text = - content.mapNotNull { entry -> - entry.asObjectOrNull()?.get("text")?.asStringOrNull()?.trim() - }.filter { it.isNotEmpty() } - if (text.isNotEmpty()) return text.joinToString("\n") - } - return null - } - - private suspend fun playAssistant(text: String) { - val parsed = TalkDirectiveParser.parse(text) - if (parsed.unknownKeys.isNotEmpty()) { - Log.w(tag, "Unknown talk directive keys: ${parsed.unknownKeys}") - } - val directive = parsed.directive - val cleaned = parsed.stripped.trim() - if (cleaned.isEmpty()) return - _lastAssistantText.value = cleaned - - val requestedVoice = directive?.voiceId?.trim()?.takeIf { it.isNotEmpty() } - val resolvedVoice = resolveVoiceAlias(requestedVoice) - if (requestedVoice != null && resolvedVoice == null) { - Log.w(tag, "unknown voice alias: $requestedVoice") - } - - if (directive?.voiceId != null) { - if (directive.once != true) { - currentVoiceId = resolvedVoice - voiceOverrideActive = true - } - } - if (directive?.modelId != null) { - if (directive.once != true) { - currentModelId = directive.modelId - modelOverrideActive = true - } - } - - val apiKey = - apiKey?.trim()?.takeIf { it.isNotEmpty() } - ?: System.getenv("ELEVENLABS_API_KEY")?.trim() - val preferredVoice = resolvedVoice ?: currentVoiceId ?: defaultVoiceId - val voiceId = - if (!apiKey.isNullOrEmpty()) { - resolveVoiceId(preferredVoice, apiKey) - } else { - null - } - - _statusText.value = "Speaking…" - _isSpeaking.value = true - lastSpokenText = cleaned - ensureInterruptListener() - - try { - val canUseElevenLabs = !voiceId.isNullOrBlank() && !apiKey.isNullOrEmpty() - if (!canUseElevenLabs) { - if (voiceId.isNullOrBlank()) { - Log.w(tag, "missing voiceId; falling back to system voice") - } - if (apiKey.isNullOrEmpty()) { - Log.w(tag, "missing ELEVENLABS_API_KEY; falling back to system voice") - } - _usingFallbackTts.value = true - _statusText.value = "Speaking (System)…" - speakWithSystemTts(cleaned) - } else { - _usingFallbackTts.value = false - val ttsStarted = SystemClock.elapsedRealtime() - val modelId = directive?.modelId ?: currentModelId ?: defaultModelId - val request = - ElevenLabsRequest( - text = cleaned, - modelId = modelId, - outputFormat = - TalkModeRuntime.validatedOutputFormat(directive?.outputFormat ?: defaultOutputFormat), - speed = TalkModeRuntime.resolveSpeed(directive?.speed, directive?.rateWpm), - stability = TalkModeRuntime.validatedStability(directive?.stability, modelId), - similarity = TalkModeRuntime.validatedUnit(directive?.similarity), - style = TalkModeRuntime.validatedUnit(directive?.style), - speakerBoost = directive?.speakerBoost, - seed = TalkModeRuntime.validatedSeed(directive?.seed), - normalize = TalkModeRuntime.validatedNormalize(directive?.normalize), - language = TalkModeRuntime.validatedLanguage(directive?.language), - latencyTier = TalkModeRuntime.validatedLatencyTier(directive?.latencyTier), - ) - streamAndPlay(voiceId = voiceId!!, apiKey = apiKey!!, request = request) - Log.d(tag, "elevenlabs stream ok durMs=${SystemClock.elapsedRealtime() - ttsStarted}") - } - } catch (err: Throwable) { - Log.w(tag, "speak failed: ${err.message ?: err::class.simpleName}; falling back to system voice") - try { - _usingFallbackTts.value = true - _statusText.value = "Speaking (System)…" - speakWithSystemTts(cleaned) - } catch (fallbackErr: Throwable) { - _statusText.value = "Speak failed: ${fallbackErr.message ?: fallbackErr::class.simpleName}" - Log.w(tag, "system voice failed: ${fallbackErr.message ?: fallbackErr::class.simpleName}") - } - } - - _isSpeaking.value = false - } - - private suspend fun streamAndPlay(voiceId: String, apiKey: String, request: ElevenLabsRequest) { - stopSpeaking(resetInterrupt = false) - - pcmStopRequested = false - val pcmSampleRate = TalkModeRuntime.parsePcmSampleRate(request.outputFormat) - if (pcmSampleRate != null) { - try { - streamAndPlayPcm(voiceId = voiceId, apiKey = apiKey, request = request, sampleRate = pcmSampleRate) - return - } catch (err: Throwable) { - if (pcmStopRequested) return - Log.w(tag, "pcm playback failed; falling back to mp3: ${err.message ?: err::class.simpleName}") - } - } - - streamAndPlayMp3(voiceId = voiceId, apiKey = apiKey, request = request) - } - - private suspend fun streamAndPlayMp3(voiceId: String, apiKey: String, request: ElevenLabsRequest) { - val dataSource = StreamingMediaDataSource() - streamingSource = dataSource - - val player = MediaPlayer() - this.player = player - - val prepared = CompletableDeferred() - val finished = CompletableDeferred() - - player.setAudioAttributes( - AudioAttributes.Builder() - .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH) - .setUsage(AudioAttributes.USAGE_ASSISTANT) - .build(), - ) - player.setOnPreparedListener { - it.start() - prepared.complete(Unit) - } - player.setOnCompletionListener { - finished.complete(Unit) - } - player.setOnErrorListener { _, _, _ -> - finished.completeExceptionally(IllegalStateException("MediaPlayer error")) - true - } - - player.setDataSource(dataSource) - withContext(Dispatchers.Main) { - player.prepareAsync() - } - - val fetchError = CompletableDeferred() - val fetchJob = - scope.launch(Dispatchers.IO) { - try { - streamTts(voiceId = voiceId, apiKey = apiKey, request = request, sink = dataSource) - fetchError.complete(null) - } catch (err: Throwable) { - dataSource.fail() - fetchError.complete(err) - } - } - - Log.d(tag, "play start") - try { - prepared.await() - finished.await() - fetchError.await()?.let { throw it } - } finally { - fetchJob.cancel() - cleanupPlayer() - } - Log.d(tag, "play done") - } - - private suspend fun streamAndPlayPcm( - voiceId: String, - apiKey: String, - request: ElevenLabsRequest, - sampleRate: Int, - ) { - val minBuffer = - AudioTrack.getMinBufferSize( - sampleRate, - AudioFormat.CHANNEL_OUT_MONO, - AudioFormat.ENCODING_PCM_16BIT, - ) - if (minBuffer <= 0) { - throw IllegalStateException("AudioTrack buffer size invalid: $minBuffer") - } - - val bufferSize = max(minBuffer * 2, 8 * 1024) - val track = - AudioTrack( - AudioAttributes.Builder() - .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH) - .setUsage(AudioAttributes.USAGE_ASSISTANT) - .build(), - AudioFormat.Builder() - .setSampleRate(sampleRate) - .setChannelMask(AudioFormat.CHANNEL_OUT_MONO) - .setEncoding(AudioFormat.ENCODING_PCM_16BIT) - .build(), - bufferSize, - AudioTrack.MODE_STREAM, - AudioManager.AUDIO_SESSION_ID_GENERATE, - ) - if (track.state != AudioTrack.STATE_INITIALIZED) { - track.release() - throw IllegalStateException("AudioTrack init failed") - } - pcmTrack = track - track.play() - - Log.d(tag, "pcm play start sampleRate=$sampleRate bufferSize=$bufferSize") - try { - streamPcm(voiceId = voiceId, apiKey = apiKey, request = request, track = track) - } finally { - cleanupPcmTrack() - } - Log.d(tag, "pcm play done") - } - - private suspend fun speakWithSystemTts(text: String) { - val trimmed = text.trim() - if (trimmed.isEmpty()) return - val ok = ensureSystemTts() - if (!ok) { - throw IllegalStateException("system TTS unavailable") - } - - val tts = systemTts ?: throw IllegalStateException("system TTS unavailable") - val utteranceId = "talk-${UUID.randomUUID()}" - val deferred = CompletableDeferred() - systemTtsPending?.cancel() - systemTtsPending = deferred - systemTtsPendingId = utteranceId - - withContext(Dispatchers.Main) { - val params = Bundle() - tts.speak(trimmed, TextToSpeech.QUEUE_FLUSH, params, utteranceId) - } - - withContext(Dispatchers.IO) { - try { - kotlinx.coroutines.withTimeout(180_000) { deferred.await() } - } catch (err: Throwable) { - throw err - } - } - } - - private suspend fun ensureSystemTts(): Boolean { - if (systemTts != null) return true - return withContext(Dispatchers.Main) { - val deferred = CompletableDeferred() - val tts = - try { - TextToSpeech(context) { status -> - deferred.complete(status == TextToSpeech.SUCCESS) - } - } catch (_: Throwable) { - deferred.complete(false) - null - } - if (tts == null) return@withContext false - - tts.setOnUtteranceProgressListener( - object : UtteranceProgressListener() { - override fun onStart(utteranceId: String?) {} - - override fun onDone(utteranceId: String?) { - if (utteranceId == null) return - if (utteranceId != systemTtsPendingId) return - systemTtsPending?.complete(Unit) - systemTtsPending = null - systemTtsPendingId = null - } - - @Suppress("OVERRIDE_DEPRECATION") - @Deprecated("Deprecated in Java") - override fun onError(utteranceId: String?) { - if (utteranceId == null) return - if (utteranceId != systemTtsPendingId) return - systemTtsPending?.completeExceptionally(IllegalStateException("system TTS error")) - systemTtsPending = null - systemTtsPendingId = null - } - - override fun onError(utteranceId: String?, errorCode: Int) { - if (utteranceId == null) return - if (utteranceId != systemTtsPendingId) return - systemTtsPending?.completeExceptionally(IllegalStateException("system TTS error $errorCode")) - systemTtsPending = null - systemTtsPendingId = null - } - }, - ) - - val ok = - try { - deferred.await() - } catch (_: Throwable) { - false - } - if (ok) { - systemTts = tts - } else { - tts.shutdown() - } - ok - } - } - - private fun stopSpeaking(resetInterrupt: Boolean = true) { - pcmStopRequested = true - if (!_isSpeaking.value) { - cleanupPlayer() - cleanupPcmTrack() - systemTts?.stop() - systemTtsPending?.cancel() - systemTtsPending = null - systemTtsPendingId = null - return - } - if (resetInterrupt) { - val currentMs = player?.currentPosition?.toDouble() ?: 0.0 - lastInterruptedAtSeconds = currentMs / 1000.0 - } - cleanupPlayer() - cleanupPcmTrack() - systemTts?.stop() - systemTtsPending?.cancel() - systemTtsPending = null - systemTtsPendingId = null - _isSpeaking.value = false - } - - private fun cleanupPlayer() { - player?.stop() - player?.release() - player = null - streamingSource?.close() - streamingSource = null - } - - private fun cleanupPcmTrack() { - val track = pcmTrack ?: return - try { - track.pause() - track.flush() - track.stop() - } catch (_: Throwable) { - // ignore cleanup errors - } finally { - track.release() - } - pcmTrack = null - } - - private fun shouldInterrupt(transcript: String): Boolean { - val trimmed = transcript.trim() - if (trimmed.length < 3) return false - val spoken = lastSpokenText?.lowercase() - if (spoken != null && spoken.contains(trimmed.lowercase())) return false - return true - } - - private suspend fun reloadConfig() { - val envVoice = System.getenv("ELEVENLABS_VOICE_ID")?.trim() - val sagVoice = System.getenv("SAG_VOICE_ID")?.trim() - val envKey = System.getenv("ELEVENLABS_API_KEY")?.trim() - try { - val res = session.request("config.get", "{}") - val root = json.parseToJsonElement(res).asObjectOrNull() - val config = root?.get("config").asObjectOrNull() - val talk = config?.get("talk").asObjectOrNull() - val sessionCfg = config?.get("session").asObjectOrNull() - val mainKey = normalizeMainKey(sessionCfg?.get("mainKey").asStringOrNull()) - val voice = talk?.get("voiceId")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() } - val aliases = - talk?.get("voiceAliases").asObjectOrNull()?.entries?.mapNotNull { (key, value) -> - val id = value.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() } ?: return@mapNotNull null - normalizeAliasKey(key).takeIf { it.isNotEmpty() }?.let { it to id } - }?.toMap().orEmpty() - val model = talk?.get("modelId")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() } - val outputFormat = talk?.get("outputFormat")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() } - val key = talk?.get("apiKey")?.asStringOrNull()?.trim()?.takeIf { it.isNotEmpty() } - val interrupt = talk?.get("interruptOnSpeech")?.asBooleanOrNull() - - if (!isCanonicalMainSessionKey(mainSessionKey)) { - mainSessionKey = mainKey - } - defaultVoiceId = voice ?: envVoice?.takeIf { it.isNotEmpty() } ?: sagVoice?.takeIf { it.isNotEmpty() } - voiceAliases = aliases - if (!voiceOverrideActive) currentVoiceId = defaultVoiceId - defaultModelId = model ?: defaultModelIdFallback - if (!modelOverrideActive) currentModelId = defaultModelId - defaultOutputFormat = outputFormat ?: defaultOutputFormatFallback - apiKey = key ?: envKey?.takeIf { it.isNotEmpty() } - if (interrupt != null) interruptOnSpeech = interrupt - } catch (_: Throwable) { - defaultVoiceId = envVoice?.takeIf { it.isNotEmpty() } ?: sagVoice?.takeIf { it.isNotEmpty() } - defaultModelId = defaultModelIdFallback - if (!modelOverrideActive) currentModelId = defaultModelId - apiKey = envKey?.takeIf { it.isNotEmpty() } - voiceAliases = emptyMap() - defaultOutputFormat = defaultOutputFormatFallback - } - } - - private fun parseRunId(jsonString: String): String? { - val obj = json.parseToJsonElement(jsonString).asObjectOrNull() ?: return null - return obj["runId"].asStringOrNull() - } - - private suspend fun streamTts( - voiceId: String, - apiKey: String, - request: ElevenLabsRequest, - sink: StreamingMediaDataSource, - ) { - withContext(Dispatchers.IO) { - val conn = openTtsConnection(voiceId = voiceId, apiKey = apiKey, request = request) - try { - val payload = buildRequestPayload(request) - conn.outputStream.use { it.write(payload.toByteArray()) } - - val code = conn.responseCode - if (code >= 400) { - val message = conn.errorStream?.readBytes()?.toString(Charsets.UTF_8) ?: "" - sink.fail() - throw IllegalStateException("ElevenLabs failed: $code $message") - } - - val buffer = ByteArray(8 * 1024) - conn.inputStream.use { input -> - while (true) { - val read = input.read(buffer) - if (read <= 0) break - sink.append(buffer.copyOf(read)) - } - } - sink.finish() - } finally { - conn.disconnect() - } - } - } - - private suspend fun streamPcm( - voiceId: String, - apiKey: String, - request: ElevenLabsRequest, - track: AudioTrack, - ) { - withContext(Dispatchers.IO) { - val conn = openTtsConnection(voiceId = voiceId, apiKey = apiKey, request = request) - try { - val payload = buildRequestPayload(request) - conn.outputStream.use { it.write(payload.toByteArray()) } - - val code = conn.responseCode - if (code >= 400) { - val message = conn.errorStream?.readBytes()?.toString(Charsets.UTF_8) ?: "" - throw IllegalStateException("ElevenLabs failed: $code $message") - } - - val buffer = ByteArray(8 * 1024) - conn.inputStream.use { input -> - while (true) { - if (pcmStopRequested) return@withContext - val read = input.read(buffer) - if (read <= 0) break - var offset = 0 - while (offset < read) { - if (pcmStopRequested) return@withContext - val wrote = - try { - track.write(buffer, offset, read - offset) - } catch (err: Throwable) { - if (pcmStopRequested) return@withContext - throw err - } - if (wrote <= 0) { - if (pcmStopRequested) return@withContext - throw IllegalStateException("AudioTrack write failed: $wrote") - } - offset += wrote - } - } - } - } finally { - conn.disconnect() - } - } - } - - private fun openTtsConnection( - voiceId: String, - apiKey: String, - request: ElevenLabsRequest, - ): HttpURLConnection { - val baseUrl = "https://api.elevenlabs.io/v1/text-to-speech/$voiceId/stream" - val latencyTier = request.latencyTier - val url = - if (latencyTier != null) { - URL("$baseUrl?optimize_streaming_latency=$latencyTier") - } else { - URL(baseUrl) - } - val conn = url.openConnection() as HttpURLConnection - conn.requestMethod = "POST" - conn.connectTimeout = 30_000 - conn.readTimeout = 30_000 - conn.setRequestProperty("Content-Type", "application/json") - conn.setRequestProperty("Accept", resolveAcceptHeader(request.outputFormat)) - conn.setRequestProperty("xi-api-key", apiKey) - conn.doOutput = true - return conn - } - - private fun resolveAcceptHeader(outputFormat: String?): String { - val normalized = outputFormat?.trim()?.lowercase().orEmpty() - return if (normalized.startsWith("pcm_")) "audio/pcm" else "audio/mpeg" - } - - private fun buildRequestPayload(request: ElevenLabsRequest): String { - val voiceSettingsEntries = - buildJsonObject { - request.speed?.let { put("speed", JsonPrimitive(it)) } - request.stability?.let { put("stability", JsonPrimitive(it)) } - request.similarity?.let { put("similarity_boost", JsonPrimitive(it)) } - request.style?.let { put("style", JsonPrimitive(it)) } - request.speakerBoost?.let { put("use_speaker_boost", JsonPrimitive(it)) } - } - - val payload = - buildJsonObject { - put("text", JsonPrimitive(request.text)) - request.modelId?.takeIf { it.isNotEmpty() }?.let { put("model_id", JsonPrimitive(it)) } - request.outputFormat?.takeIf { it.isNotEmpty() }?.let { put("output_format", JsonPrimitive(it)) } - request.seed?.let { put("seed", JsonPrimitive(it)) } - request.normalize?.let { put("apply_text_normalization", JsonPrimitive(it)) } - request.language?.let { put("language_code", JsonPrimitive(it)) } - if (voiceSettingsEntries.isNotEmpty()) { - put("voice_settings", voiceSettingsEntries) - } - } - - return payload.toString() - } - - private data class ElevenLabsRequest( - val text: String, - val modelId: String?, - val outputFormat: String?, - val speed: Double?, - val stability: Double?, - val similarity: Double?, - val style: Double?, - val speakerBoost: Boolean?, - val seed: Long?, - val normalize: String?, - val language: String?, - val latencyTier: Int?, - ) - - private object TalkModeRuntime { - fun resolveSpeed(speed: Double?, rateWpm: Int?): Double? { - if (rateWpm != null && rateWpm > 0) { - val resolved = rateWpm.toDouble() / 175.0 - if (resolved <= 0.5 || resolved >= 2.0) return null - return resolved - } - if (speed != null) { - if (speed <= 0.5 || speed >= 2.0) return null - return speed - } - return null - } - - fun validatedUnit(value: Double?): Double? { - if (value == null) return null - if (value < 0 || value > 1) return null - return value - } - - fun validatedStability(value: Double?, modelId: String?): Double? { - if (value == null) return null - val normalized = modelId?.trim()?.lowercase() - if (normalized == "eleven_v3") { - return if (value == 0.0 || value == 0.5 || value == 1.0) value else null - } - return validatedUnit(value) - } - - fun validatedSeed(value: Long?): Long? { - if (value == null) return null - if (value < 0 || value > 4294967295L) return null - return value - } - - fun validatedNormalize(value: String?): String? { - val normalized = value?.trim()?.lowercase() ?: return null - return if (normalized in listOf("auto", "on", "off")) normalized else null - } - - fun validatedLanguage(value: String?): String? { - val normalized = value?.trim()?.lowercase() ?: return null - if (normalized.length != 2) return null - if (!normalized.all { it in 'a'..'z' }) return null - return normalized - } - - fun validatedOutputFormat(value: String?): String? { - val trimmed = value?.trim()?.lowercase() ?: return null - if (trimmed.isEmpty()) return null - if (trimmed.startsWith("mp3_")) return trimmed - return if (parsePcmSampleRate(trimmed) != null) trimmed else null - } - - fun validatedLatencyTier(value: Int?): Int? { - if (value == null) return null - if (value < 0 || value > 4) return null - return value - } - - fun parsePcmSampleRate(value: String?): Int? { - val trimmed = value?.trim()?.lowercase() ?: return null - if (!trimmed.startsWith("pcm_")) return null - val suffix = trimmed.removePrefix("pcm_") - val digits = suffix.takeWhile { it.isDigit() } - val rate = digits.toIntOrNull() ?: return null - return if (rate in setOf(16000, 22050, 24000, 44100)) rate else null - } - - fun isMessageTimestampAfter(timestamp: Double, sinceSeconds: Double): Boolean { - val sinceMs = sinceSeconds * 1000 - return if (timestamp > 10_000_000_000) { - timestamp >= sinceMs - 500 - } else { - timestamp >= sinceSeconds - 0.5 - } - } - } - - private fun ensureInterruptListener() { - if (!interruptOnSpeech || !_isEnabled.value) return - mainHandler.post { - if (stopRequested) return@post - if (!SpeechRecognizer.isRecognitionAvailable(context)) return@post - try { - if (recognizer == null) { - recognizer = SpeechRecognizer.createSpeechRecognizer(context).also { it.setRecognitionListener(listener) } - } - recognizer?.cancel() - startListeningInternal(markListening = false) - } catch (_: Throwable) { - // ignore - } - } - } - - private fun resolveVoiceAlias(value: String?): String? { - val trimmed = value?.trim().orEmpty() - if (trimmed.isEmpty()) return null - val normalized = normalizeAliasKey(trimmed) - voiceAliases[normalized]?.let { return it } - if (voiceAliases.values.any { it.equals(trimmed, ignoreCase = true) }) return trimmed - return if (isLikelyVoiceId(trimmed)) trimmed else null - } - - private suspend fun resolveVoiceId(preferred: String?, apiKey: String): String? { - val trimmed = preferred?.trim().orEmpty() - if (trimmed.isNotEmpty()) { - val resolved = resolveVoiceAlias(trimmed) - if (resolved != null) return resolved - Log.w(tag, "unknown voice alias $trimmed") - } - fallbackVoiceId?.let { return it } - - return try { - val voices = listVoices(apiKey) - val first = voices.firstOrNull() ?: return null - fallbackVoiceId = first.voiceId - if (defaultVoiceId.isNullOrBlank()) { - defaultVoiceId = first.voiceId - } - if (!voiceOverrideActive) { - currentVoiceId = first.voiceId - } - val name = first.name ?: "unknown" - Log.d(tag, "default voice selected $name (${first.voiceId})") - first.voiceId - } catch (err: Throwable) { - Log.w(tag, "list voices failed: ${err.message ?: err::class.simpleName}") - null - } - } - - private suspend fun listVoices(apiKey: String): List { - return withContext(Dispatchers.IO) { - val url = URL("https://api.elevenlabs.io/v1/voices") - val conn = url.openConnection() as HttpURLConnection - conn.requestMethod = "GET" - conn.connectTimeout = 15_000 - conn.readTimeout = 15_000 - conn.setRequestProperty("xi-api-key", apiKey) - - val code = conn.responseCode - val stream = if (code >= 400) conn.errorStream else conn.inputStream - val data = stream.readBytes() - if (code >= 400) { - val message = data.toString(Charsets.UTF_8) - throw IllegalStateException("ElevenLabs voices failed: $code $message") - } - - val root = json.parseToJsonElement(data.toString(Charsets.UTF_8)).asObjectOrNull() - val voices = (root?.get("voices") as? JsonArray) ?: JsonArray(emptyList()) - voices.mapNotNull { entry -> - val obj = entry.asObjectOrNull() ?: return@mapNotNull null - val voiceId = obj["voice_id"].asStringOrNull() ?: return@mapNotNull null - val name = obj["name"].asStringOrNull() - ElevenLabsVoice(voiceId, name) - } - } - } - - private fun isLikelyVoiceId(value: String): Boolean { - if (value.length < 10) return false - return value.all { it.isLetterOrDigit() || it == '-' || it == '_' } - } - - private fun normalizeAliasKey(value: String): String = - value.trim().lowercase() - - private data class ElevenLabsVoice(val voiceId: String, val name: String?) - - private val listener = - object : RecognitionListener { - override fun onReadyForSpeech(params: Bundle?) { - if (_isEnabled.value) { - _statusText.value = if (_isListening.value) "Listening" else _statusText.value - } - } - - override fun onBeginningOfSpeech() {} - - override fun onRmsChanged(rmsdB: Float) {} - - override fun onBufferReceived(buffer: ByteArray?) {} - - override fun onEndOfSpeech() { - scheduleRestart() - } - - override fun onError(error: Int) { - if (stopRequested) return - _isListening.value = false - if (error == SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS) { - _statusText.value = "Microphone permission required" - return - } - - _statusText.value = - when (error) { - SpeechRecognizer.ERROR_AUDIO -> "Audio error" - SpeechRecognizer.ERROR_CLIENT -> "Client error" - SpeechRecognizer.ERROR_NETWORK -> "Network error" - SpeechRecognizer.ERROR_NETWORK_TIMEOUT -> "Network timeout" - SpeechRecognizer.ERROR_NO_MATCH -> "Listening" - SpeechRecognizer.ERROR_RECOGNIZER_BUSY -> "Recognizer busy" - SpeechRecognizer.ERROR_SERVER -> "Server error" - SpeechRecognizer.ERROR_SPEECH_TIMEOUT -> "Listening" - else -> "Speech error ($error)" - } - scheduleRestart(delayMs = 600) - } - - override fun onResults(results: Bundle?) { - val list = results?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION).orEmpty() - list.firstOrNull()?.let { handleTranscript(it, isFinal = true) } - scheduleRestart() - } - - override fun onPartialResults(partialResults: Bundle?) { - val list = partialResults?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION).orEmpty() - list.firstOrNull()?.let { handleTranscript(it, isFinal = false) } - } - - override fun onEvent(eventType: Int, params: Bundle?) {} - } -} - -private fun JsonElement?.asObjectOrNull(): JsonObject? = this as? JsonObject - -private fun JsonElement?.asStringOrNull(): String? = - (this as? JsonPrimitive)?.takeIf { it.isString }?.content - -private fun JsonElement?.asDoubleOrNull(): Double? { - val primitive = this as? JsonPrimitive ?: return null - return primitive.content.toDoubleOrNull() -} - -private fun JsonElement?.asBooleanOrNull(): Boolean? { - val primitive = this as? JsonPrimitive ?: return null - val content = primitive.content.trim().lowercase() - return when (content) { - "true", "yes", "1" -> true - "false", "no", "0" -> false - else -> null - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/voice/VoiceWakeCommandExtractor.kt b/apps/android/app/src/main/java/com/clawdbot/android/voice/VoiceWakeCommandExtractor.kt deleted file mode 100644 index 1f527b8c8..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/voice/VoiceWakeCommandExtractor.kt +++ /dev/null @@ -1,40 +0,0 @@ -package com.clawdbot.android.voice - -object VoiceWakeCommandExtractor { - fun extractCommand(text: String, triggerWords: List): String? { - val raw = text.trim() - if (raw.isEmpty()) return null - - val triggers = - triggerWords - .map { it.trim().lowercase() } - .filter { it.isNotEmpty() } - .distinct() - if (triggers.isEmpty()) return null - - val alternation = triggers.joinToString("|") { Regex.escape(it) } - // Match: " " - val regex = Regex("(?i)(?:^|\\s)($alternation)\\b[\\s\\p{Punct}]*([\\s\\S]+)$") - val match = regex.find(raw) ?: return null - val extracted = match.groupValues.getOrNull(2)?.trim().orEmpty() - if (extracted.isEmpty()) return null - - val cleaned = extracted.trimStart { it.isWhitespace() || it.isPunctuation() }.trim() - if (cleaned.isEmpty()) return null - return cleaned - } -} - -private fun Char.isPunctuation(): Boolean { - return when (Character.getType(this)) { - Character.CONNECTOR_PUNCTUATION.toInt(), - Character.DASH_PUNCTUATION.toInt(), - Character.START_PUNCTUATION.toInt(), - Character.END_PUNCTUATION.toInt(), - Character.INITIAL_QUOTE_PUNCTUATION.toInt(), - Character.FINAL_QUOTE_PUNCTUATION.toInt(), - Character.OTHER_PUNCTUATION.toInt(), - -> true - else -> false - } -} diff --git a/apps/android/app/src/main/java/com/clawdbot/android/voice/VoiceWakeManager.kt b/apps/android/app/src/main/java/com/clawdbot/android/voice/VoiceWakeManager.kt deleted file mode 100644 index 69863b4cc..000000000 --- a/apps/android/app/src/main/java/com/clawdbot/android/voice/VoiceWakeManager.kt +++ /dev/null @@ -1,173 +0,0 @@ -package com.clawdbot.android.voice - -import android.content.Context -import android.content.Intent -import android.os.Bundle -import android.os.Handler -import android.os.Looper -import android.speech.RecognitionListener -import android.speech.RecognizerIntent -import android.speech.SpeechRecognizer -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Job -import kotlinx.coroutines.delay -import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.flow.StateFlow -import kotlinx.coroutines.launch - -class VoiceWakeManager( - private val context: Context, - private val scope: CoroutineScope, - private val onCommand: suspend (String) -> Unit, -) { - private val mainHandler = Handler(Looper.getMainLooper()) - - private val _isListening = MutableStateFlow(false) - val isListening: StateFlow = _isListening - - private val _statusText = MutableStateFlow("Off") - val statusText: StateFlow = _statusText - - var triggerWords: List = emptyList() - private set - - private var recognizer: SpeechRecognizer? = null - private var restartJob: Job? = null - private var lastDispatched: String? = null - private var stopRequested = false - - fun setTriggerWords(words: List) { - triggerWords = words - } - - fun start() { - mainHandler.post { - if (_isListening.value) return@post - stopRequested = false - - if (!SpeechRecognizer.isRecognitionAvailable(context)) { - _isListening.value = false - _statusText.value = "Speech recognizer unavailable" - return@post - } - - try { - recognizer?.destroy() - recognizer = SpeechRecognizer.createSpeechRecognizer(context).also { it.setRecognitionListener(listener) } - startListeningInternal() - } catch (err: Throwable) { - _isListening.value = false - _statusText.value = "Start failed: ${err.message ?: err::class.simpleName}" - } - } - } - - fun stop(statusText: String = "Off") { - stopRequested = true - restartJob?.cancel() - restartJob = null - mainHandler.post { - _isListening.value = false - _statusText.value = statusText - recognizer?.cancel() - recognizer?.destroy() - recognizer = null - } - } - - private fun startListeningInternal() { - val r = recognizer ?: return - val intent = - Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply { - putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM) - putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true) - putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 3) - putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, context.packageName) - } - - _statusText.value = "Listening" - _isListening.value = true - r.startListening(intent) - } - - private fun scheduleRestart(delayMs: Long = 350) { - if (stopRequested) return - restartJob?.cancel() - restartJob = - scope.launch { - delay(delayMs) - mainHandler.post { - if (stopRequested) return@post - try { - recognizer?.cancel() - startListeningInternal() - } catch (_: Throwable) { - // Will be picked up by onError and retry again. - } - } - } - } - - private fun handleTranscription(text: String) { - val command = VoiceWakeCommandExtractor.extractCommand(text, triggerWords) ?: return - if (command == lastDispatched) return - lastDispatched = command - - scope.launch { onCommand(command) } - _statusText.value = "Triggered" - scheduleRestart(delayMs = 650) - } - - private val listener = - object : RecognitionListener { - override fun onReadyForSpeech(params: Bundle?) { - _statusText.value = "Listening" - } - - override fun onBeginningOfSpeech() {} - - override fun onRmsChanged(rmsdB: Float) {} - - override fun onBufferReceived(buffer: ByteArray?) {} - - override fun onEndOfSpeech() { - scheduleRestart() - } - - override fun onError(error: Int) { - if (stopRequested) return - _isListening.value = false - if (error == SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS) { - _statusText.value = "Microphone permission required" - return - } - - _statusText.value = - when (error) { - SpeechRecognizer.ERROR_AUDIO -> "Audio error" - SpeechRecognizer.ERROR_CLIENT -> "Client error" - SpeechRecognizer.ERROR_NETWORK -> "Network error" - SpeechRecognizer.ERROR_NETWORK_TIMEOUT -> "Network timeout" - SpeechRecognizer.ERROR_NO_MATCH -> "Listening" - SpeechRecognizer.ERROR_RECOGNIZER_BUSY -> "Recognizer busy" - SpeechRecognizer.ERROR_SERVER -> "Server error" - SpeechRecognizer.ERROR_SPEECH_TIMEOUT -> "Listening" - else -> "Speech error ($error)" - } - scheduleRestart(delayMs = 600) - } - - override fun onResults(results: Bundle?) { - val list = results?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION).orEmpty() - list.firstOrNull()?.let(::handleTranscription) - scheduleRestart() - } - - override fun onPartialResults(partialResults: Bundle?) { - val list = partialResults?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION).orEmpty() - list.firstOrNull()?.let(::handleTranscription) - } - - override fun onEvent(eventType: Int, params: Bundle?) {} - } -} diff --git a/apps/android/app/src/test/java/com/clawdbot/android/NodeForegroundServiceTest.kt b/apps/android/app/src/test/java/com/clawdbot/android/NodeForegroundServiceTest.kt deleted file mode 100644 index cb1c8b898..000000000 --- a/apps/android/app/src/test/java/com/clawdbot/android/NodeForegroundServiceTest.kt +++ /dev/null @@ -1,43 +0,0 @@ -package com.clawdbot.android - -import android.app.Notification -import android.content.Intent -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNotNull -import org.junit.Test -import org.junit.runner.RunWith -import org.robolectric.Robolectric -import org.robolectric.RobolectricTestRunner -import org.robolectric.Shadows -import org.robolectric.annotation.Config - -@RunWith(RobolectricTestRunner::class) -@Config(sdk = [34]) -class NodeForegroundServiceTest { - @Test - fun buildNotificationSetsLaunchIntent() { - val service = Robolectric.buildService(NodeForegroundService::class.java).get() - val notification = buildNotification(service) - - val pendingIntent = notification.contentIntent - assertNotNull(pendingIntent) - - val savedIntent = Shadows.shadowOf(pendingIntent).savedIntent - assertNotNull(savedIntent) - assertEquals(MainActivity::class.java.name, savedIntent.component?.className) - - val expectedFlags = Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP - assertEquals(expectedFlags, savedIntent.flags and expectedFlags) - } - - private fun buildNotification(service: NodeForegroundService): Notification { - val method = - NodeForegroundService::class.java.getDeclaredMethod( - "buildNotification", - String::class.java, - String::class.java, - ) - method.isAccessible = true - return method.invoke(service, "Title", "Text") as Notification - } -} diff --git a/apps/android/app/src/test/java/com/clawdbot/android/WakeWordsTest.kt b/apps/android/app/src/test/java/com/clawdbot/android/WakeWordsTest.kt deleted file mode 100644 index 9363e810c..000000000 --- a/apps/android/app/src/test/java/com/clawdbot/android/WakeWordsTest.kt +++ /dev/null @@ -1,50 +0,0 @@ -package com.clawdbot.android - -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNull -import org.junit.Test - -class WakeWordsTest { - @Test - fun parseCommaSeparatedTrimsAndDropsEmpty() { - assertEquals(listOf("clawd", "claude"), WakeWords.parseCommaSeparated(" clawd , claude, , ")) - } - - @Test - fun sanitizeTrimsCapsAndFallsBack() { - val defaults = listOf("clawd", "claude") - val long = "x".repeat(WakeWords.maxWordLength + 10) - val words = listOf(" ", " hello ", long) - - val sanitized = WakeWords.sanitize(words, defaults) - assertEquals(2, sanitized.size) - assertEquals("hello", sanitized[0]) - assertEquals("x".repeat(WakeWords.maxWordLength), sanitized[1]) - - assertEquals(defaults, WakeWords.sanitize(listOf(" ", ""), defaults)) - } - - @Test - fun sanitizeLimitsWordCount() { - val defaults = listOf("clawd") - val words = (1..(WakeWords.maxWords + 5)).map { "w$it" } - val sanitized = WakeWords.sanitize(words, defaults) - assertEquals(WakeWords.maxWords, sanitized.size) - assertEquals("w1", sanitized.first()) - assertEquals("w${WakeWords.maxWords}", sanitized.last()) - } - - @Test - fun parseIfChangedSkipsWhenUnchanged() { - val current = listOf("clawd", "claude") - val parsed = WakeWords.parseIfChanged(" clawd , claude ", current) - assertNull(parsed) - } - - @Test - fun parseIfChangedReturnsUpdatedList() { - val current = listOf("clawd") - val parsed = WakeWords.parseIfChanged(" clawd , jarvis ", current) - assertEquals(listOf("clawd", "jarvis"), parsed) - } -} diff --git a/apps/android/app/src/test/java/com/clawdbot/android/gateway/BonjourEscapesTest.kt b/apps/android/app/src/test/java/com/clawdbot/android/gateway/BonjourEscapesTest.kt deleted file mode 100644 index e6acf833e..000000000 --- a/apps/android/app/src/test/java/com/clawdbot/android/gateway/BonjourEscapesTest.kt +++ /dev/null @@ -1,19 +0,0 @@ -package com.clawdbot.android.gateway - -import org.junit.Assert.assertEquals -import org.junit.Test - -class BonjourEscapesTest { - @Test - fun decodeNoop() { - assertEquals("", BonjourEscapes.decode("")) - assertEquals("hello", BonjourEscapes.decode("hello")) - } - - @Test - fun decodeDecodesDecimalEscapes() { - assertEquals("Moltbot Gateway", BonjourEscapes.decode("Moltbot\\032Gateway")) - assertEquals("A B", BonjourEscapes.decode("A\\032B")) - assertEquals("Peter\u2019s Mac", BonjourEscapes.decode("Peter\\226\\128\\153s Mac")) - } -} diff --git a/apps/android/app/src/test/java/com/clawdbot/android/node/CanvasControllerSnapshotParamsTest.kt b/apps/android/app/src/test/java/com/clawdbot/android/node/CanvasControllerSnapshotParamsTest.kt deleted file mode 100644 index 0b0a42ed5..000000000 --- a/apps/android/app/src/test/java/com/clawdbot/android/node/CanvasControllerSnapshotParamsTest.kt +++ /dev/null @@ -1,43 +0,0 @@ -package com.clawdbot.android.node - -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNull -import org.junit.Test - -class CanvasControllerSnapshotParamsTest { - @Test - fun parseSnapshotParamsDefaultsToJpeg() { - val params = CanvasController.parseSnapshotParams(null) - assertEquals(CanvasController.SnapshotFormat.Jpeg, params.format) - assertNull(params.quality) - assertNull(params.maxWidth) - } - - @Test - fun parseSnapshotParamsParsesPng() { - val params = CanvasController.parseSnapshotParams("""{"format":"png","maxWidth":900}""") - assertEquals(CanvasController.SnapshotFormat.Png, params.format) - assertEquals(900, params.maxWidth) - } - - @Test - fun parseSnapshotParamsParsesJpegAliases() { - assertEquals( - CanvasController.SnapshotFormat.Jpeg, - CanvasController.parseSnapshotParams("""{"format":"jpeg"}""").format, - ) - assertEquals( - CanvasController.SnapshotFormat.Jpeg, - CanvasController.parseSnapshotParams("""{"format":"jpg"}""").format, - ) - } - - @Test - fun parseSnapshotParamsClampsQuality() { - val low = CanvasController.parseSnapshotParams("""{"quality":0.01}""") - assertEquals(0.1, low.quality) - - val high = CanvasController.parseSnapshotParams("""{"quality":5}""") - assertEquals(1.0, high.quality) - } -} diff --git a/apps/android/app/src/test/java/com/clawdbot/android/node/JpegSizeLimiterTest.kt b/apps/android/app/src/test/java/com/clawdbot/android/node/JpegSizeLimiterTest.kt deleted file mode 100644 index 2c22c2d6a..000000000 --- a/apps/android/app/src/test/java/com/clawdbot/android/node/JpegSizeLimiterTest.kt +++ /dev/null @@ -1,47 +0,0 @@ -package com.clawdbot.android.node - -import org.junit.Assert.assertEquals -import org.junit.Assert.assertTrue -import org.junit.Test -import kotlin.math.min - -class JpegSizeLimiterTest { - @Test - fun compressesLargePayloadsUnderLimit() { - val maxBytes = 5 * 1024 * 1024 - val result = - JpegSizeLimiter.compressToLimit( - initialWidth = 4000, - initialHeight = 3000, - startQuality = 95, - maxBytes = maxBytes, - encode = { width, height, quality -> - val estimated = (width.toLong() * height.toLong() * quality.toLong()) / 100 - val size = min(maxBytes.toLong() * 2, estimated).toInt() - ByteArray(size) - }, - ) - - assertTrue(result.bytes.size <= maxBytes) - assertTrue(result.width <= 4000) - assertTrue(result.height <= 3000) - assertTrue(result.quality <= 95) - } - - @Test - fun keepsSmallPayloadsAsIs() { - val maxBytes = 5 * 1024 * 1024 - val result = - JpegSizeLimiter.compressToLimit( - initialWidth = 800, - initialHeight = 600, - startQuality = 90, - maxBytes = maxBytes, - encode = { _, _, _ -> ByteArray(120_000) }, - ) - - assertEquals(800, result.width) - assertEquals(600, result.height) - assertEquals(90, result.quality) - } -} diff --git a/apps/android/app/src/test/java/com/clawdbot/android/node/SmsManagerTest.kt b/apps/android/app/src/test/java/com/clawdbot/android/node/SmsManagerTest.kt deleted file mode 100644 index 4748a5683..000000000 --- a/apps/android/app/src/test/java/com/clawdbot/android/node/SmsManagerTest.kt +++ /dev/null @@ -1,91 +0,0 @@ -package com.clawdbot.android.node - -import kotlinx.serialization.json.jsonObject -import kotlinx.serialization.json.jsonPrimitive -import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse -import org.junit.Assert.assertTrue -import org.junit.Test - -class SmsManagerTest { - private val json = SmsManager.JsonConfig - - @Test - fun parseParamsRejectsEmptyPayload() { - val result = SmsManager.parseParams("", json) - assertTrue(result is SmsManager.ParseResult.Error) - val error = result as SmsManager.ParseResult.Error - assertEquals("INVALID_REQUEST: paramsJSON required", error.error) - } - - @Test - fun parseParamsRejectsInvalidJson() { - val result = SmsManager.parseParams("not-json", json) - assertTrue(result is SmsManager.ParseResult.Error) - val error = result as SmsManager.ParseResult.Error - assertEquals("INVALID_REQUEST: expected JSON object", error.error) - } - - @Test - fun parseParamsRejectsNonObjectJson() { - val result = SmsManager.parseParams("[]", json) - assertTrue(result is SmsManager.ParseResult.Error) - val error = result as SmsManager.ParseResult.Error - assertEquals("INVALID_REQUEST: expected JSON object", error.error) - } - - @Test - fun parseParamsRejectsMissingTo() { - val result = SmsManager.parseParams("{\"message\":\"Hi\"}", json) - assertTrue(result is SmsManager.ParseResult.Error) - val error = result as SmsManager.ParseResult.Error - assertEquals("INVALID_REQUEST: 'to' phone number required", error.error) - assertEquals("Hi", error.message) - } - - @Test - fun parseParamsRejectsMissingMessage() { - val result = SmsManager.parseParams("{\"to\":\"+1234\"}", json) - assertTrue(result is SmsManager.ParseResult.Error) - val error = result as SmsManager.ParseResult.Error - assertEquals("INVALID_REQUEST: 'message' text required", error.error) - assertEquals("+1234", error.to) - } - - @Test - fun parseParamsTrimsToField() { - val result = SmsManager.parseParams("{\"to\":\" +1555 \",\"message\":\"Hello\"}", json) - assertTrue(result is SmsManager.ParseResult.Ok) - val ok = result as SmsManager.ParseResult.Ok - assertEquals("+1555", ok.params.to) - assertEquals("Hello", ok.params.message) - } - - @Test - fun buildPayloadJsonEscapesFields() { - val payload = SmsManager.buildPayloadJson( - json = json, - ok = false, - to = "+1\"23", - error = "SMS_SEND_FAILED: \"nope\"", - ) - val parsed = json.parseToJsonElement(payload).jsonObject - assertEquals("false", parsed["ok"]?.jsonPrimitive?.content) - assertEquals("+1\"23", parsed["to"]?.jsonPrimitive?.content) - assertEquals("SMS_SEND_FAILED: \"nope\"", parsed["error"]?.jsonPrimitive?.content) - } - - @Test - fun buildSendPlanUsesMultipartWhenMultipleParts() { - val plan = SmsManager.buildSendPlan("hello") { listOf("a", "b") } - assertTrue(plan.useMultipart) - assertEquals(listOf("a", "b"), plan.parts) - } - - @Test - fun buildSendPlanFallsBackToSinglePartWhenDividerEmpty() { - val plan = SmsManager.buildSendPlan("hello") { emptyList() } - assertFalse(plan.useMultipart) - assertEquals(listOf("hello"), plan.parts) - } -} diff --git a/apps/android/app/src/test/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIActionTest.kt b/apps/android/app/src/test/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIActionTest.kt deleted file mode 100644 index adb522767..000000000 --- a/apps/android/app/src/test/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIActionTest.kt +++ /dev/null @@ -1,49 +0,0 @@ -package com.clawdbot.android.protocol - -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.jsonObject -import org.junit.Assert.assertEquals -import org.junit.Test - -class MoltbotCanvasA2UIActionTest { - @Test - fun extractActionNameAcceptsNameOrAction() { - val nameObj = Json.parseToJsonElement("{\"name\":\"Hello\"}").jsonObject - assertEquals("Hello", MoltbotCanvasA2UIAction.extractActionName(nameObj)) - - val actionObj = Json.parseToJsonElement("{\"action\":\"Wave\"}").jsonObject - assertEquals("Wave", MoltbotCanvasA2UIAction.extractActionName(actionObj)) - - val fallbackObj = - Json.parseToJsonElement("{\"name\":\" \",\"action\":\"Fallback\"}").jsonObject - assertEquals("Fallback", MoltbotCanvasA2UIAction.extractActionName(fallbackObj)) - } - - @Test - fun formatAgentMessageMatchesSharedSpec() { - val msg = - MoltbotCanvasA2UIAction.formatAgentMessage( - actionName = "Get Weather", - sessionKey = "main", - surfaceId = "main", - sourceComponentId = "btnWeather", - host = "Peter’s iPad", - instanceId = "ipad16,6", - contextJson = "{\"city\":\"Vienna\"}", - ) - - assertEquals( - "CANVAS_A2UI action=Get_Weather session=main surface=main component=btnWeather host=Peter_s_iPad instance=ipad16_6 ctx={\"city\":\"Vienna\"} default=update_canvas", - msg, - ) - } - - @Test - fun jsDispatchA2uiStatusIsStable() { - val js = MoltbotCanvasA2UIAction.jsDispatchA2UIActionStatus(actionId = "a1", ok = true, error = null) - assertEquals( - "window.dispatchEvent(new CustomEvent('moltbot:a2ui-action-status', { detail: { id: \"a1\", ok: true, error: \"\" } }));", - js, - ) - } -} diff --git a/apps/android/app/src/test/java/com/clawdbot/android/protocol/ClawdbotProtocolConstantsTest.kt b/apps/android/app/src/test/java/com/clawdbot/android/protocol/ClawdbotProtocolConstantsTest.kt deleted file mode 100644 index 1b96ee9a9..000000000 --- a/apps/android/app/src/test/java/com/clawdbot/android/protocol/ClawdbotProtocolConstantsTest.kt +++ /dev/null @@ -1,35 +0,0 @@ -package com.clawdbot.android.protocol - -import org.junit.Assert.assertEquals -import org.junit.Test - -class MoltbotProtocolConstantsTest { - @Test - fun canvasCommandsUseStableStrings() { - assertEquals("canvas.present", MoltbotCanvasCommand.Present.rawValue) - assertEquals("canvas.hide", MoltbotCanvasCommand.Hide.rawValue) - assertEquals("canvas.navigate", MoltbotCanvasCommand.Navigate.rawValue) - assertEquals("canvas.eval", MoltbotCanvasCommand.Eval.rawValue) - assertEquals("canvas.snapshot", MoltbotCanvasCommand.Snapshot.rawValue) - } - - @Test - fun a2uiCommandsUseStableStrings() { - assertEquals("canvas.a2ui.push", MoltbotCanvasA2UICommand.Push.rawValue) - assertEquals("canvas.a2ui.pushJSONL", MoltbotCanvasA2UICommand.PushJSONL.rawValue) - assertEquals("canvas.a2ui.reset", MoltbotCanvasA2UICommand.Reset.rawValue) - } - - @Test - fun capabilitiesUseStableStrings() { - assertEquals("canvas", MoltbotCapability.Canvas.rawValue) - assertEquals("camera", MoltbotCapability.Camera.rawValue) - assertEquals("screen", MoltbotCapability.Screen.rawValue) - assertEquals("voiceWake", MoltbotCapability.VoiceWake.rawValue) - } - - @Test - fun screenCommandsUseStableStrings() { - assertEquals("screen.record", MoltbotScreenCommand.Record.rawValue) - } -} diff --git a/apps/android/app/src/test/java/com/clawdbot/android/ui/chat/SessionFiltersTest.kt b/apps/android/app/src/test/java/com/clawdbot/android/ui/chat/SessionFiltersTest.kt deleted file mode 100644 index b945ad66f..000000000 --- a/apps/android/app/src/test/java/com/clawdbot/android/ui/chat/SessionFiltersTest.kt +++ /dev/null @@ -1,35 +0,0 @@ -package com.clawdbot.android.ui.chat - -import com.clawdbot.android.chat.ChatSessionEntry -import org.junit.Assert.assertEquals -import org.junit.Test - -class SessionFiltersTest { - @Test - fun sessionChoicesPreferMainAndRecent() { - val now = 1_700_000_000_000L - val recent1 = now - 2 * 60 * 60 * 1000L - val recent2 = now - 5 * 60 * 60 * 1000L - val stale = now - 26 * 60 * 60 * 1000L - val sessions = - listOf( - ChatSessionEntry(key = "recent-1", updatedAtMs = recent1), - ChatSessionEntry(key = "main", updatedAtMs = stale), - ChatSessionEntry(key = "old-1", updatedAtMs = stale), - ChatSessionEntry(key = "recent-2", updatedAtMs = recent2), - ) - - val result = resolveSessionChoices("main", sessions, mainSessionKey = "main", nowMs = now).map { it.key } - assertEquals(listOf("main", "recent-1", "recent-2"), result) - } - - @Test - fun sessionChoicesIncludeCurrentWhenMissing() { - val now = 1_700_000_000_000L - val recent = now - 10 * 60 * 1000L - val sessions = listOf(ChatSessionEntry(key = "main", updatedAtMs = recent)) - - val result = resolveSessionChoices("custom", sessions, mainSessionKey = "main", nowMs = now).map { it.key } - assertEquals(listOf("main", "custom"), result) - } -} diff --git a/apps/android/app/src/test/java/com/clawdbot/android/voice/TalkDirectiveParserTest.kt b/apps/android/app/src/test/java/com/clawdbot/android/voice/TalkDirectiveParserTest.kt deleted file mode 100644 index a42b88e3a..000000000 --- a/apps/android/app/src/test/java/com/clawdbot/android/voice/TalkDirectiveParserTest.kt +++ /dev/null @@ -1,55 +0,0 @@ -package com.clawdbot.android.voice - -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNull -import org.junit.Assert.assertTrue -import org.junit.Test - -class TalkDirectiveParserTest { - @Test - fun parsesDirectiveAndStripsHeader() { - val input = """ - {"voice":"voice-123","once":true} - Hello from talk mode. - """.trimIndent() - val result = TalkDirectiveParser.parse(input) - assertEquals("voice-123", result.directive?.voiceId) - assertEquals(true, result.directive?.once) - assertEquals("Hello from talk mode.", result.stripped.trim()) - } - - @Test - fun ignoresUnknownKeysButReportsThem() { - val input = """ - {"voice":"abc","foo":1,"bar":"baz"} - Hi there. - """.trimIndent() - val result = TalkDirectiveParser.parse(input) - assertEquals("abc", result.directive?.voiceId) - assertTrue(result.unknownKeys.containsAll(listOf("bar", "foo"))) - } - - @Test - fun parsesAlternateKeys() { - val input = """ - {"model_id":"eleven_v3","similarity_boost":0.4,"no_speaker_boost":true,"rate":200} - Speak. - """.trimIndent() - val result = TalkDirectiveParser.parse(input) - assertEquals("eleven_v3", result.directive?.modelId) - assertEquals(0.4, result.directive?.similarity) - assertEquals(false, result.directive?.speakerBoost) - assertEquals(200, result.directive?.rateWpm) - } - - @Test - fun returnsNullWhenNoDirectivePresent() { - val input = """ - {} - Hello. - """.trimIndent() - val result = TalkDirectiveParser.parse(input) - assertNull(result.directive) - assertEquals(input, result.stripped) - } -} diff --git a/apps/android/app/src/test/java/com/clawdbot/android/voice/VoiceWakeCommandExtractorTest.kt b/apps/android/app/src/test/java/com/clawdbot/android/voice/VoiceWakeCommandExtractorTest.kt deleted file mode 100644 index f6e512fa3..000000000 --- a/apps/android/app/src/test/java/com/clawdbot/android/voice/VoiceWakeCommandExtractorTest.kt +++ /dev/null @@ -1,25 +0,0 @@ -package com.clawdbot.android.voice - -import org.junit.Assert.assertEquals -import org.junit.Assert.assertNull -import org.junit.Test - -class VoiceWakeCommandExtractorTest { - @Test - fun extractsCommandAfterTriggerWord() { - val res = VoiceWakeCommandExtractor.extractCommand("Claude take a photo", listOf("clawd", "claude")) - assertEquals("take a photo", res) - } - - @Test - fun extractsCommandWithPunctuation() { - val res = VoiceWakeCommandExtractor.extractCommand("hey clawd, what's the weather?", listOf("clawd")) - assertEquals("what's the weather?", res) - } - - @Test - fun returnsNullWhenNoCommandProvided() { - assertNull(VoiceWakeCommandExtractor.extractCommand("claude", listOf("claude"))) - assertNull(VoiceWakeCommandExtractor.extractCommand("hey claude!", listOf("claude"))) - } -} From 284b54af42dc410b0909ee51530c1db3987ac18e Mon Sep 17 00:00:00 2001 From: "A. Duk" Date: Wed, 28 Jan 2026 00:59:24 +0400 Subject: [PATCH 045/101] feat: Add support for Telegram quote (partial message replies) (#2900) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat: Add support for Telegram quote (partial message replies) - Enhanced describeReplyTarget() to detect and extract quoted text from msg.quote - Updated reply formatting to distinguish between full message replies and quotes - Added isQuote flag to replyTarget object for proper identification - Quote replies show as [Quoting user] "quoted text" [/Quoting] - Regular replies unchanged: [Replying to user] full message [/Replying] Resolves need for partial message reply support in Telegram Bot API. Backward compatible with existing reply functionality. * updating references * Mac: finish Moltbot rename * Mac: finish Moltbot rename (paths) * fix(macOS): rename Clawdbot directories to Moltbot for naming consistency Directory renames: - apps/macos/Sources/Clawdbot → Moltbot - apps/macos/Sources/ClawdbotDiscovery → MoltbotDiscovery - apps/macos/Sources/ClawdbotIPC → MoltbotIPC - apps/macos/Sources/ClawdbotMacCLI → MoltbotMacCLI - apps/macos/Sources/ClawdbotProtocol → MoltbotProtocol - apps/macos/Tests/ClawdbotIPCTests → MoltbotIPCTests - apps/shared/ClawdbotKit → MoltbotKit - apps/shared/MoltbotKit/Sources/Clawdbot* → Moltbot* - apps/shared/MoltbotKit/Tests/ClawdbotKitTests → MoltbotKitTests Resource renames: - Clawdbot.icns → Moltbot.icns Code fixes: - Update Package.swift paths to reference Moltbot* directories - Fix clawdbot* → moltbot* symbol references in Swift code: - clawdbotManagedPaths → moltbotManagedPaths - clawdbotExecutable → moltbotExecutable - clawdbotCommand → moltbotCommand - clawdbotNodeCommand → moltbotNodeCommand - clawdbotOAuthDirEnv → moltbotOAuthDirEnv - clawdbotSelectSettingsTab → moltbotSelectSettingsTab * fix: update remaining ClawdbotKit path references to MoltbotKit - scripts/bundle-a2ui.sh: A2UI_APP_DIR path - package.json: format:swift and protocol:check paths - scripts/protocol-gen-swift.ts: output paths - .github/dependabot.yml: directory path and comment - .gitignore: build cache paths - .swiftformat: exclusion paths - .swiftlint.yml: exclusion path - apps/android/app/build.gradle.kts: assets.srcDir path - apps/ios/project.yml: package path - apps/ios/README.md: documentation reference - docs/concepts/typebox.md: documentation reference - apps/shared/MoltbotKit/Package.swift: fix argument order * chore: update Package.resolved after dependency resolution * fix: add MACOS_APP_SOURCES_DIR constant and update test to use new path The cron-protocol-conformance test was using LEGACY_MACOS_APP_SOURCES_DIR which points to the old Clawdbot path. Added a new MACOS_APP_SOURCES_DIR constant for the current Moltbot path and updated the test to use it. * fix: finish Moltbot macOS rename (#2844) (thanks @fal3) * Extensions: use workspace moltbot in memory-core * fix(security): recognize Venice-style claude-opus-45 as top-tier model The security audit was incorrectly flagging venice/claude-opus-45 as 'Below Claude 4.5' because the regex expected -4-5 (with dash) but Venice uses -45 (without dash between 4 and 5). Updated isClaude45OrHigher() regex to match both formats. Added test case to prevent regression. * Branding: update bot.molt bundle IDs + launchd labels * Branding: remove legacy android packages * fix: wire telegram quote support (#2900) Co-authored-by: aduk059 * fix: support Telegram quote replies (#2900) (thanks @aduk059) --------- Co-authored-by: Gustavo Madeira Santana Co-authored-by: Shadow Co-authored-by: Alex Fallah Co-authored-by: Josh Palmer Co-authored-by: jonisjongithub Co-authored-by: Gustavo Madeira Santana Co-authored-by: aduk059 --- CHANGELOG.md | 1 + clawdbot-2026-01-27.log | 88 +++++++++++++++++++++++ src/agents/tools/message-tool.ts | 3 + src/agents/tools/telegram-actions.test.ts | 25 +++++++ src/agents/tools/telegram-actions.ts | 2 + src/auto-reply/templating.ts | 1 + src/canvas-host/a2ui/.bundle.hash | 2 +- src/channels/plugins/actions/telegram.ts | 2 + src/channels/plugins/outbound/telegram.ts | 5 +- src/telegram/bot-message-context.ts | 11 ++- src/telegram/bot-message-dispatch.ts | 5 ++ src/telegram/bot.test.ts | 67 +++++++++++++++++ src/telegram/bot/delivery.test.ts | 31 ++++++++ src/telegram/bot/delivery.ts | 42 ++++++++--- src/telegram/bot/helpers.ts | 49 +++++++++---- src/telegram/bot/types.ts | 8 ++- src/telegram/send.ts | 14 +++- 17 files changed, 326 insertions(+), 30 deletions(-) create mode 100644 clawdbot-2026-01-27.log diff --git a/CHANGELOG.md b/CHANGELOG.md index e1efce475..c83dc1476 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -57,6 +57,7 @@ Status: unreleased. - Telegram: keep topic IDs in restart sentinel notifications. (#1807) Thanks @hsrvc. - Telegram: add optional silent send flag (disable notifications). (#2382) Thanks @Suksham-sharma. - Telegram: support editing sent messages via message(action="edit"). (#2394) Thanks @marcelomar21. +- Telegram: support quote replies for message tool and inbound context. (#2900) Thanks @aduk059. - Telegram: add sticker receive/send with vision caching. (#2629) Thanks @longjos. - Telegram: send sticker pixels to vision models. (#2650) - Config: apply config.env before ${VAR} substitution. (#1813) Thanks @spanishflu-est1918. diff --git a/clawdbot-2026-01-27.log b/clawdbot-2026-01-27.log new file mode 100644 index 000000000..b322c9909 --- /dev/null +++ b/clawdbot-2026-01-27.log @@ -0,0 +1,88 @@ +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=0f9a9294-1be3-4897-8480-6941fa5c918a tool=exec toolCallId=toolu_01ABvFAHSPxy2qorw3kJymm9","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:14:31.264Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:14:31.264Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=0f9a9294-1be3-4897-8480-6941fa5c918a tool=process toolCallId=toolu_01RWGLqhzLVxvSqrDdwBiPeE","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:14:35.645Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:14:35.645Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=0f9a9294-1be3-4897-8480-6941fa5c918a tool=process toolCallId=toolu_01RWGLqhzLVxvSqrDdwBiPeE","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:14:35.647Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:14:35.647Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=0f9a9294-1be3-4897-8480-6941fa5c918a tool=process toolCallId=toolu_01V56BA7uA5Bk5ezPcvUxndH","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:14:40.171Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:14:40.173Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=0f9a9294-1be3-4897-8480-6941fa5c918a tool=process toolCallId=toolu_01V56BA7uA5Bk5ezPcvUxndH","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:14:40.177Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:14:40.178Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=0f9a9294-1be3-4897-8480-6941fa5c918a tool=exec toolCallId=toolu_01W78WRUZ3cpbU8JLKw8Wjh2","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:14:45.819Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:14:45.820Z"} +{"0":"[tools] exec failed: gh not found\n\nCommand exited with code 1","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"clawdbot","date":"2026-01-27T18:14:45.823Z","logLevelId":5,"logLevelName":"ERROR","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/console.js:187:32","fileName":"console.js","fileNameWithLine":"console.js:187","fileColumn":"32","fileLine":"187","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/console.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/console.js:187","method":"console.error"}},"time":"2026-01-27T18:14:45.823Z"} +{"0":"[tools] exec failed: gh not found\n\nCommand exited with code 1","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"clawdbot","date":"2026-01-27T18:14:45.824Z","logLevelId":5,"logLevelName":"ERROR","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logger.js:47:17","fileName":"logger.js","fileNameWithLine":"logger.js:47","fileColumn":"17","fileLine":"47","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logger.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logger.js:47","method":"logError"}},"time":"2026-01-27T18:14:45.824Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=0f9a9294-1be3-4897-8480-6941fa5c918a tool=exec toolCallId=toolu_01W78WRUZ3cpbU8JLKw8Wjh2","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:14:45.825Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:14:45.826Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=0f9a9294-1be3-4897-8480-6941fa5c918a tool=exec toolCallId=toolu_01NgdcwcKb3EqeQzir6pv4ik","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:14:50.400Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:14:50.401Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=0f9a9294-1be3-4897-8480-6941fa5c918a tool=exec toolCallId=toolu_01NgdcwcKb3EqeQzir6pv4ik","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:00.423Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:00.424Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run agent end: runId=0f9a9294-1be3-4897-8480-6941fa5c918a","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:06.372Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:06.373Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run prompt end: runId=0f9a9294-1be3-4897-8480-6941fa5c918a sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac durationMs=64221","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:06.378Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:06.379Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"session state: sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac sessionKey=unknown prev=processing new=idle reason=\"run_completed\" queueDepth=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:06.379Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:06.380Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"run cleared: sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac totalActive=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:06.381Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:06.381Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run done: runId=0f9a9294-1be3-4897-8480-6941fa5c918a sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac durationMs=64258 aborted=false","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:06.396Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:06.396Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane task done: lane=main durationMs=64262 active=0 queued=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:06.399Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:06.400Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane task done: lane=session:agent:main:main durationMs=64267 active=0 queued=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:06.400Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:06.400Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane enqueue: lane=session:agent:main:main queueSize=1","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:31.507Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:31.510Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane dequeue: lane=session:agent:main:main waitMs=22 queueSize=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:31.512Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:31.515Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane enqueue: lane=main queueSize=1","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:31.516Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:31.520Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane dequeue: lane=main waitMs=5 queueSize=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:31.521Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:31.525Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac provider=anthropic model=claude-sonnet-4-20250514 thinking=low messageChannel=telegram","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:31.527Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:31.528Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"session state: sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac sessionKey=unknown prev=idle new=processing reason=\"run_started\" queueDepth=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:31.568Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:31.568Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"run registered: sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac totalActive=1","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:31.568Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:31.569Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run prompt start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:31.569Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:31.569Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run agent start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:31.573Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:31.573Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=process toolCallId=toolu_013owH6LL6iAptQbMoeMdvmo","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:38.594Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:38.595Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=process toolCallId=toolu_013owH6LL6iAptQbMoeMdvmo","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:38.605Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:38.605Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_01NsnqQqajHbMQ6ct3MZwGMD","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:43.562Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:43.563Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_01NsnqQqajHbMQ6ct3MZwGMD","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:43.684Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:43.685Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_01S13NTjo4WPXwRn12iZiU1H","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:50.141Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:50.141Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_01S13NTjo4WPXwRn12iZiU1H","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:50.166Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:50.167Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_018nDFSMN1Xd2Q6dYAAdH6WJ","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:54.948Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:54.949Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_018nDFSMN1Xd2Q6dYAAdH6WJ","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:15:54.968Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:15:54.969Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=process toolCallId=toolu_01CuWysDqcCKutJjiQ2psVDy","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:00.189Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:00.190Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=process toolCallId=toolu_01CuWysDqcCKutJjiQ2psVDy","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:00.196Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:00.197Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_01Eh8xXBgAEgePYyKZbC11fz","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:07.488Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:07.489Z"} +{"0":"[tools] exec failed: error validating token: HTTP 401: Bad credentials (https://api.github.com/)\nTry authenticating with: gh auth login\n\nCommand exited with code 1","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"clawdbot","date":"2026-01-27T18:16:08.403Z","logLevelId":5,"logLevelName":"ERROR","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/console.js:187:32","fileName":"console.js","fileNameWithLine":"console.js:187","fileColumn":"32","fileLine":"187","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/console.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/console.js:187","method":"console.error"}},"time":"2026-01-27T18:16:08.404Z"} +{"0":"[tools] exec failed: error validating token: HTTP 401: Bad credentials (https://api.github.com/)\nTry authenticating with: gh auth login\n\nCommand exited with code 1","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"clawdbot","date":"2026-01-27T18:16:08.406Z","logLevelId":5,"logLevelName":"ERROR","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logger.js:47:17","fileName":"logger.js","fileNameWithLine":"logger.js:47","fileColumn":"17","fileLine":"47","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logger.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logger.js:47","method":"logError"}},"time":"2026-01-27T18:16:08.406Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_01Eh8xXBgAEgePYyKZbC11fz","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:08.412Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:08.412Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_019KwfrHpsdRzcGv2NtcTDxc","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:14.712Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:14.713Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_019KwfrHpsdRzcGv2NtcTDxc","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:24.739Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:24.740Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=process toolCallId=toolu_015YVFpAkM9kDy3UQwWnPFpH","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:30.150Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:30.151Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=process toolCallId=toolu_015YVFpAkM9kDy3UQwWnPFpH","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:30.160Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:30.161Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=process toolCallId=toolu_01D9MN1HSUBLJgWh5yFKpU1N","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:38.339Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:38.340Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=process toolCallId=toolu_01D9MN1HSUBLJgWh5yFKpU1N","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:38.346Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:38.347Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_01DG4DcWXaNTHfa1bzvuHkeg","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:45.743Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:45.744Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 tool=exec toolCallId=toolu_01DG4DcWXaNTHfa1bzvuHkeg","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:45.766Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:45.766Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run agent end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:50.357Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:50.357Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run prompt end: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac durationMs=78790","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:50.359Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:50.360Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"session state: sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac sessionKey=unknown prev=processing new=idle reason=\"run_completed\" queueDepth=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:50.361Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:50.361Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"run cleared: sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac totalActive=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:50.363Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:50.363Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run done: runId=24db8b02-29b7-4aa8-89dc-3c8d4dfe2299 sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac durationMs=78850 aborted=false","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:50.376Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:50.376Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane task done: lane=main durationMs=78854 active=0 queued=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:50.379Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:50.379Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane task done: lane=session:agent:main:main durationMs=78865 active=0 queued=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:16:50.380Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:16:50.380Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane enqueue: lane=session:agent:main:main queueSize=1","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:38.593Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:38.596Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane dequeue: lane=session:agent:main:main waitMs=23 queueSize=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:38.598Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:38.599Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane enqueue: lane=main queueSize=1","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:38.600Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:38.601Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"lane dequeue: lane=main waitMs=2 queueSize=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:38.602Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:38.604Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac provider=anthropic model=claude-sonnet-4-20250514 thinking=low messageChannel=telegram","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:38.606Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:38.607Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"session state: sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac sessionKey=unknown prev=idle new=processing reason=\"run_started\" queueDepth=0","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:38.636Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:38.637Z"} +{"0":"{\"subsystem\":\"diagnostic\"}","1":"run registered: sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac totalActive=1","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"diagnostic\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:38.637Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:38.637Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run prompt start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 sessionId=5aa98bb1-c30c-4999-9d8a-ca3759b570ac","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:38.638Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:38.638Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run agent start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:38.641Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:38.642Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01M3auXfxxjuruCayApqWWbb","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:47.740Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:47.741Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01M3auXfxxjuruCayApqWWbb","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:47.785Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:47.786Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01SzWB3psudeXCe6UHAkNujV","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:52.306Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:52.308Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01SzWB3psudeXCe6UHAkNujV","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:52.374Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:52.375Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01KUa6PcWAhC5pguBqZheF4P","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:56.977Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:56.978Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01KUa6PcWAhC5pguBqZheF4P","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:17:57.037Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:17:57.037Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_018m48KASbUrd6TPybszdCSQ","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:02.566Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:02.567Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_018m48KASbUrd6TPybszdCSQ","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:02.625Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:02.627Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=read toolCallId=toolu_01MpiSBbHrxsLN1nR7fxq6gD","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:07.939Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:07.940Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=read toolCallId=toolu_01MpiSBbHrxsLN1nR7fxq6gD","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:07.947Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:07.948Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01D3X6LVt7Te7DxHt2kU2h2Q","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:12.794Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:12.795Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01D3X6LVt7Te7DxHt2kU2h2Q","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:12.814Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:12.815Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=read toolCallId=toolu_01Du1KUqgqETi8LuAQrastxx","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:18.162Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:18.163Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=read toolCallId=toolu_01Du1KUqgqETi8LuAQrastxx","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:18.171Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:18.171Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01JZciDdKu1fvdibZL9FXzDX","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:24.787Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:24.788Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01JZciDdKu1fvdibZL9FXzDX","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:24.808Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:24.808Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01T5WFmSeCnchAwFBVsMNzCu","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:29.196Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:29.196Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_01T5WFmSeCnchAwFBVsMNzCu","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:29.216Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:29.217Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=edit toolCallId=toolu_01VZHWRMtbxWmBvvLRGbzTZL","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:42.682Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:42.683Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=edit toolCallId=toolu_01VZHWRMtbxWmBvvLRGbzTZL","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:42.696Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:42.696Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=edit toolCallId=toolu_01GAK8pbPZpYLkh2CcJWhLYu","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:49.436Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:49.437Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool end: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=edit toolCallId=toolu_01GAK8pbPZpYLkh2CcJWhLYu","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:49.448Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:49.449Z"} +{"0":"{\"subsystem\":\"agent/embedded\"}","1":"embedded run tool start: runId=e82778a1-ad99-4e25-945c-2e7be70c3d96 tool=exec toolCallId=toolu_019F1KimkBzJ1VCnYzmgYDM4","_meta":{"runtime":"node","runtimeVersion":"22.22.0","hostname":"unknown","name":"{\"subsystem\":\"agent/embedded\"}","parentNames":["clawdbot"],"date":"2026-01-27T18:18:53.947Z","logLevelId":2,"logLevelName":"DEBUG","path":{"fullFilePath":"file:///opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161:16","fileName":"subsystem.js","fileNameWithLine":"subsystem.js:161","fileColumn":"16","fileLine":"161","filePath":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js","filePathWithLine":"opt/homebrew/lib/node_modules/clawdbot/dist/logging/subsystem.js:161","method":"logToFile"}},"time":"2026-01-27T18:18:53.948Z"} diff --git a/src/agents/tools/message-tool.ts b/src/agents/tools/message-tool.ts index 2188d737d..4ea178a54 100644 --- a/src/agents/tools/message-tool.ts +++ b/src/agents/tools/message-tool.ts @@ -60,6 +60,9 @@ function buildSendSchema(options: { includeButtons: boolean; includeCards: boole threadId: Type.Optional(Type.String()), asVoice: Type.Optional(Type.Boolean()), silent: Type.Optional(Type.Boolean()), + quoteText: Type.Optional( + Type.String({ description: "Quote text for Telegram reply_parameters" }), + ), bestEffort: Type.Optional(Type.Boolean()), gifPlayback: Type.Optional(Type.Boolean()), buttons: Type.Optional( diff --git a/src/agents/tools/telegram-actions.test.ts b/src/agents/tools/telegram-actions.test.ts index 63a55e3d0..3b78dde20 100644 --- a/src/agents/tools/telegram-actions.test.ts +++ b/src/agents/tools/telegram-actions.test.ts @@ -261,6 +261,31 @@ describe("handleTelegramAction", () => { ); }); + it("passes quoteText when provided", async () => { + const cfg = { + channels: { telegram: { botToken: "tok" } }, + } as MoltbotConfig; + await handleTelegramAction( + { + action: "sendMessage", + to: "123456", + content: "Replying now", + replyToMessageId: 144, + quoteText: "The text you want to quote", + }, + cfg, + ); + expect(sendMessageTelegram).toHaveBeenCalledWith( + "123456", + "Replying now", + expect.objectContaining({ + token: "tok", + replyToMessageId: 144, + quoteText: "The text you want to quote", + }), + ); + }); + it("allows media-only messages without content", async () => { const cfg = { channels: { telegram: { botToken: "tok" } }, diff --git a/src/agents/tools/telegram-actions.ts b/src/agents/tools/telegram-actions.ts index 3d7dc6eb2..515ff8c47 100644 --- a/src/agents/tools/telegram-actions.ts +++ b/src/agents/tools/telegram-actions.ts @@ -165,6 +165,7 @@ export async function handleTelegramAction( const messageThreadId = readNumberParam(params, "messageThreadId", { integer: true, }); + const quoteText = readStringParam(params, "quoteText"); const token = resolveTelegramToken(cfg, { accountId }).token; if (!token) { throw new Error( @@ -178,6 +179,7 @@ export async function handleTelegramAction( buttons, replyToMessageId: replyToMessageId ?? undefined, messageThreadId: messageThreadId ?? undefined, + quoteText: quoteText ?? undefined, asVoice: typeof params.asVoice === "boolean" ? params.asVoice : undefined, silent: typeof params.silent === "boolean" ? params.silent : undefined, }); diff --git a/src/auto-reply/templating.ts b/src/auto-reply/templating.ts index 593858e64..242cee232 100644 --- a/src/auto-reply/templating.ts +++ b/src/auto-reply/templating.ts @@ -49,6 +49,7 @@ export type MsgContext = { ReplyToIdFull?: string; ReplyToBody?: string; ReplyToSender?: string; + ReplyToIsQuote?: boolean; ForwardedFrom?: string; ForwardedFromType?: string; ForwardedFromId?: string; diff --git a/src/canvas-host/a2ui/.bundle.hash b/src/canvas-host/a2ui/.bundle.hash index 6c9cb0299..98d7e8ccf 100644 --- a/src/canvas-host/a2ui/.bundle.hash +++ b/src/canvas-host/a2ui/.bundle.hash @@ -1 +1 @@ -b6d3dea7c656c8a480059c32e954c4d39053ff79c4e9c69b38f4c04e3f0280d4 +178acae008ecf5b85a4043c22b651c715278eb921b6b138f61234cd1d4853515 diff --git a/src/channels/plugins/actions/telegram.ts b/src/channels/plugins/actions/telegram.ts index 2acfaf9f1..693e94492 100644 --- a/src/channels/plugins/actions/telegram.ts +++ b/src/channels/plugins/actions/telegram.ts @@ -23,6 +23,7 @@ function readTelegramSendParams(params: Record) { const buttons = params.buttons; const asVoice = typeof params.asVoice === "boolean" ? params.asVoice : undefined; const silent = typeof params.silent === "boolean" ? params.silent : undefined; + const quoteText = readStringParam(params, "quoteText"); return { to, content, @@ -32,6 +33,7 @@ function readTelegramSendParams(params: Record) { buttons, asVoice, silent, + quoteText: quoteText ?? undefined, }; } diff --git a/src/channels/plugins/outbound/telegram.ts b/src/channels/plugins/outbound/telegram.ts index 6db7afd28..04abb77e0 100644 --- a/src/channels/plugins/outbound/telegram.ts +++ b/src/channels/plugins/outbound/telegram.ts @@ -56,8 +56,10 @@ export const telegramOutbound: ChannelOutboundAdapter = { const replyToMessageId = parseReplyToMessageId(replyToId); const messageThreadId = parseThreadId(threadId); const telegramData = payload.channelData?.telegram as - | { buttons?: Array> } + | { buttons?: Array>; quoteText?: string } | undefined; + const quoteText = + typeof telegramData?.quoteText === "string" ? telegramData.quoteText : undefined; const text = payload.text ?? ""; const mediaUrls = payload.mediaUrls?.length ? payload.mediaUrls @@ -69,6 +71,7 @@ export const telegramOutbound: ChannelOutboundAdapter = { textMode: "html" as const, messageThreadId, replyToMessageId, + quoteText, accountId: accountId ?? undefined, }; diff --git a/src/telegram/bot-message-context.ts b/src/telegram/bot-message-context.ts index 98b42fd10..aa6dcd88b 100644 --- a/src/telegram/bot-message-context.ts +++ b/src/telegram/bot-message-context.ts @@ -480,9 +480,13 @@ export const buildTelegramMessageContext = async ({ const replyTarget = describeReplyTarget(msg); const forwardOrigin = normalizeForwardedContext(msg); const replySuffix = replyTarget - ? `\n\n[Replying to ${replyTarget.sender}${ - replyTarget.id ? ` id:${replyTarget.id}` : "" - }]\n${replyTarget.body}\n[/Replying]` + ? replyTarget.kind === "quote" + ? `\n\n[Quoting ${replyTarget.sender}${ + replyTarget.id ? ` id:${replyTarget.id}` : "" + }]\n"${replyTarget.body}"\n[/Quoting]` + : `\n\n[Replying to ${replyTarget.sender}${ + replyTarget.id ? ` id:${replyTarget.id}` : "" + }]\n${replyTarget.body}\n[/Replying]` : ""; const forwardPrefix = forwardOrigin ? `[Forwarded from ${forwardOrigin.from}${ @@ -565,6 +569,7 @@ export const buildTelegramMessageContext = async ({ ReplyToId: replyTarget?.id, ReplyToBody: replyTarget?.body, ReplyToSender: replyTarget?.sender, + ReplyToIsQuote: replyTarget?.kind === "quote" ? true : undefined, ForwardedFrom: forwardOrigin?.from, ForwardedFromType: forwardOrigin?.fromType, ForwardedFromId: forwardOrigin?.fromId, diff --git a/src/telegram/bot-message-dispatch.ts b/src/telegram/bot-message-dispatch.ts index 27c6a3bfa..cead0628a 100644 --- a/src/telegram/bot-message-dispatch.ts +++ b/src/telegram/bot-message-dispatch.ts @@ -210,6 +210,10 @@ export const dispatchTelegramMessage = async ({ draftStream?.stop(); } + const replyQuoteText = + ctxPayload.ReplyToIsQuote && ctxPayload.ReplyToBody + ? ctxPayload.ReplyToBody.trim() || undefined + : undefined; await deliverReplies({ replies: [payload], chatId: String(chatId), @@ -223,6 +227,7 @@ export const dispatchTelegramMessage = async ({ chunkMode, onVoiceRecording: sendRecordVoice, linkPreview: telegramCfg.linkPreview, + replyQuoteText, }); }, onError: (err, info) => { diff --git a/src/telegram/bot.test.ts b/src/telegram/bot.test.ts index 72ee418bb..75dd32faf 100644 --- a/src/telegram/bot.test.ts +++ b/src/telegram/bot.test.ts @@ -894,6 +894,73 @@ describe("createTelegramBot", () => { expect(payload.ReplyToSender).toBe("Ada"); }); + it("uses quote text when a Telegram partial reply is received", async () => { + onSpy.mockReset(); + sendMessageSpy.mockReset(); + const replySpy = replyModule.__replySpy as unknown as ReturnType; + replySpy.mockReset(); + + createTelegramBot({ token: "tok" }); + const handler = getOnHandler("message") as (ctx: Record) => Promise; + + await handler({ + message: { + chat: { id: 7, type: "private" }, + text: "Sure, see below", + date: 1736380800, + reply_to_message: { + message_id: 9001, + text: "Can you summarize this?", + from: { first_name: "Ada" }, + }, + quote: { + text: "summarize this", + }, + }, + me: { username: "moltbot_bot" }, + getFile: async () => ({ download: async () => new Uint8Array() }), + }); + + expect(replySpy).toHaveBeenCalledTimes(1); + const payload = replySpy.mock.calls[0][0]; + expect(payload.Body).toContain("[Quoting Ada id:9001]"); + expect(payload.Body).toContain('"summarize this"'); + expect(payload.ReplyToId).toBe("9001"); + expect(payload.ReplyToBody).toBe("summarize this"); + expect(payload.ReplyToSender).toBe("Ada"); + }); + + it("handles quote-only replies without reply metadata", async () => { + onSpy.mockReset(); + sendMessageSpy.mockReset(); + const replySpy = replyModule.__replySpy as unknown as ReturnType; + replySpy.mockReset(); + + createTelegramBot({ token: "tok" }); + const handler = getOnHandler("message") as (ctx: Record) => Promise; + + await handler({ + message: { + chat: { id: 7, type: "private" }, + text: "Sure, see below", + date: 1736380800, + quote: { + text: "summarize this", + }, + }, + me: { username: "moltbot_bot" }, + getFile: async () => ({ download: async () => new Uint8Array() }), + }); + + expect(replySpy).toHaveBeenCalledTimes(1); + const payload = replySpy.mock.calls[0][0]; + expect(payload.Body).toContain("[Quoting unknown sender]"); + expect(payload.Body).toContain('"summarize this"'); + expect(payload.ReplyToId).toBeUndefined(); + expect(payload.ReplyToBody).toBe("summarize this"); + expect(payload.ReplyToSender).toBe("unknown sender"); + }); + it("sends replies without native reply threading", async () => { onSpy.mockReset(); sendMessageSpy.mockReset(); diff --git a/src/telegram/bot/delivery.test.ts b/src/telegram/bot/delivery.test.ts index 404cc2fc2..3cf1b2534 100644 --- a/src/telegram/bot/delivery.test.ts +++ b/src/telegram/bot/delivery.test.ts @@ -168,6 +168,37 @@ describe("deliverReplies", () => { ); }); + it("uses reply_parameters when quote text is provided", async () => { + const runtime = { error: vi.fn(), log: vi.fn() }; + const sendMessage = vi.fn().mockResolvedValue({ + message_id: 10, + chat: { id: "123" }, + }); + const bot = { api: { sendMessage } } as unknown as Bot; + + await deliverReplies({ + replies: [{ text: "Hello there", replyToId: "500" }], + chatId: "123", + token: "tok", + runtime, + bot, + replyToMode: "all", + textLimit: 4000, + replyQuoteText: "quoted text", + }); + + expect(sendMessage).toHaveBeenCalledWith( + "123", + expect.any(String), + expect.objectContaining({ + reply_parameters: { + message_id: 500, + quote: "quoted text", + }, + }), + ); + }); + it("falls back to text when sendVoice fails with VOICE_MESSAGES_FORBIDDEN", async () => { const runtime = { error: vi.fn(), log: vi.fn() }; const sendVoice = vi diff --git a/src/telegram/bot/delivery.ts b/src/telegram/bot/delivery.ts index 779c0c026..4f45f9997 100644 --- a/src/telegram/bot/delivery.ts +++ b/src/telegram/bot/delivery.ts @@ -42,11 +42,21 @@ export async function deliverReplies(params: { onVoiceRecording?: () => Promise | void; /** Controls whether link previews are shown. Default: true (previews enabled). */ linkPreview?: boolean; + /** Optional quote text for Telegram reply_parameters. */ + replyQuoteText?: string; }) { - const { replies, chatId, runtime, bot, replyToMode, textLimit, messageThreadId, linkPreview } = - params; + const { + replies, + chatId, + runtime, + bot, + replyToMode, + textLimit, + messageThreadId, + linkPreview, + replyQuoteText, + } = params; const chunkMode = params.chunkMode ?? "length"; - const threadParams = buildTelegramThreadParams(messageThreadId); let hasReplied = false; const chunkText = (markdown: string) => { const markdownChunks = @@ -97,6 +107,7 @@ export async function deliverReplies(params: { await sendTelegramText(bot, chatId, chunk.html, runtime, { replyToMessageId: replyToId && (replyToMode === "all" || !hasReplied) ? replyToId : undefined, + replyQuoteText, messageThreadId, textMode: "html", plainText: chunk.text, @@ -140,13 +151,14 @@ export async function deliverReplies(params: { const shouldAttachButtonsToMedia = isFirstMedia && replyMarkup && !followUpText; const mediaParams: Record = { caption: htmlCaption, - reply_to_message_id: replyToMessageId, ...(htmlCaption ? { parse_mode: "HTML" } : {}), ...(shouldAttachButtonsToMedia ? { reply_markup: replyMarkup } : {}), + ...buildTelegramSendParams({ + replyToMessageId, + messageThreadId, + replyQuoteText, + }), }; - if (threadParams) { - mediaParams.message_thread_id = threadParams.message_thread_id; - } if (isGif) { await withTelegramApiErrorLogging({ operation: "sendAnimation", @@ -207,6 +219,7 @@ export async function deliverReplies(params: { messageThreadId, linkPreview, replyMarkup, + replyQuoteText, }); // Skip this media item; continue with next. continue; @@ -391,6 +404,7 @@ async function sendTelegramVoiceFallbackText(opts: { messageThreadId?: number; linkPreview?: boolean; replyMarkup?: ReturnType; + replyQuoteText?: string; }): Promise { const chunks = opts.chunkText(opts.text); let hasReplied = opts.hasReplied; @@ -399,6 +413,7 @@ async function sendTelegramVoiceFallbackText(opts: { await sendTelegramText(opts.bot, opts.chatId, chunk.html, opts.runtime, { replyToMessageId: opts.replyToId && (opts.replyToMode === "all" || !hasReplied) ? opts.replyToId : undefined, + replyQuoteText: opts.replyQuoteText, messageThreadId: opts.messageThreadId, textMode: "html", plainText: chunk.text, @@ -415,11 +430,20 @@ async function sendTelegramVoiceFallbackText(opts: { function buildTelegramSendParams(opts?: { replyToMessageId?: number; messageThreadId?: number; + replyQuoteText?: string; }): Record { const threadParams = buildTelegramThreadParams(opts?.messageThreadId); const params: Record = {}; + const quoteText = opts?.replyQuoteText?.trim(); if (opts?.replyToMessageId) { - params.reply_to_message_id = opts.replyToMessageId; + if (quoteText) { + params.reply_parameters = { + message_id: Math.trunc(opts.replyToMessageId), + quote: quoteText, + }; + } else { + params.reply_to_message_id = opts.replyToMessageId; + } } if (threadParams) { params.message_thread_id = threadParams.message_thread_id; @@ -434,6 +458,7 @@ async function sendTelegramText( runtime: RuntimeEnv, opts?: { replyToMessageId?: number; + replyQuoteText?: string; messageThreadId?: number; textMode?: "markdown" | "html"; plainText?: string; @@ -443,6 +468,7 @@ async function sendTelegramText( ): Promise { const baseParams = buildTelegramSendParams({ replyToMessageId: opts?.replyToMessageId, + replyQuoteText: opts?.replyQuoteText, messageThreadId: opts?.messageThreadId, }); // Add link_preview_options when link preview is disabled. diff --git a/src/telegram/bot/helpers.ts b/src/telegram/bot/helpers.ts index f2e1eff24..19b8e76c0 100644 --- a/src/telegram/bot/helpers.ts +++ b/src/telegram/bot/helpers.ts @@ -150,28 +150,49 @@ export function resolveTelegramReplyId(raw?: string): number | undefined { return parsed; } -export function describeReplyTarget(msg: TelegramMessage) { +export type TelegramReplyTarget = { + id?: string; + sender: string; + body: string; + kind: "reply" | "quote"; +}; + +export function describeReplyTarget(msg: TelegramMessage): TelegramReplyTarget | null { const reply = msg.reply_to_message; - if (!reply) return null; - const replyBody = (reply.text ?? reply.caption ?? "").trim(); - let body = replyBody; - if (!body) { - if (reply.photo) body = ""; - else if (reply.video) body = ""; - else if (reply.audio || reply.voice) body = ""; - else if (reply.document) body = ""; - else { - const locationData = extractTelegramLocation(reply); - if (locationData) body = formatLocationText(locationData); + const quote = msg.quote; + let body = ""; + let kind: TelegramReplyTarget["kind"] = "reply"; + + if (quote?.text) { + body = quote.text.trim(); + if (body) { + kind = "quote"; + } + } + + if (!body && reply) { + const replyBody = (reply.text ?? reply.caption ?? "").trim(); + body = replyBody; + if (!body) { + if (reply.photo) body = ""; + else if (reply.video) body = ""; + else if (reply.audio || reply.voice) body = ""; + else if (reply.document) body = ""; + else { + const locationData = extractTelegramLocation(reply); + if (locationData) body = formatLocationText(locationData); + } } } if (!body) return null; - const sender = buildSenderName(reply); + const sender = reply ? buildSenderName(reply) : undefined; const senderLabel = sender ? `${sender}` : "unknown sender"; + return { - id: reply.message_id ? String(reply.message_id) : undefined, + id: reply?.message_id ? String(reply.message_id) : undefined, sender: senderLabel, body, + kind, }; } diff --git a/src/telegram/bot/types.ts b/src/telegram/bot/types.ts index 3e106b885..df3dba6d3 100644 --- a/src/telegram/bot/types.ts +++ b/src/telegram/bot/types.ts @@ -1,6 +1,12 @@ import type { Message } from "@grammyjs/types"; -export type TelegramMessage = Message; +export type TelegramQuote = { + text?: string; +}; + +export type TelegramMessage = Message & { + quote?: TelegramQuote; +}; export type TelegramStreamMode = "off" | "partial" | "block"; diff --git a/src/telegram/send.ts b/src/telegram/send.ts index 7dd79dd1f..e3f3ac30e 100644 --- a/src/telegram/send.ts +++ b/src/telegram/send.ts @@ -46,6 +46,8 @@ type TelegramSendOpts = { silent?: boolean; /** Message ID to reply to (for threading) */ replyToMessageId?: number; + /** Quote text for Telegram reply_parameters. */ + quoteText?: string; /** Forum topic thread ID (for forum supergroups) */ messageThreadId?: number; /** Inline keyboard buttons (reply markup). */ @@ -198,9 +200,17 @@ export async function sendMessageTelegram( const messageThreadId = opts.messageThreadId != null ? opts.messageThreadId : target.messageThreadId; const threadIdParams = buildTelegramThreadParams(messageThreadId); - const threadParams: Record = threadIdParams ? { ...threadIdParams } : {}; + const threadParams: Record = threadIdParams ? { ...threadIdParams } : {}; + const quoteText = opts.quoteText?.trim(); if (opts.replyToMessageId != null) { - threadParams.reply_to_message_id = Math.trunc(opts.replyToMessageId); + if (quoteText) { + threadParams.reply_parameters = { + message_id: Math.trunc(opts.replyToMessageId), + quote: quoteText, + }; + } else { + threadParams.reply_to_message_id = Math.trunc(opts.replyToMessageId); + } } const hasThreadParams = Object.keys(threadParams).length > 0; const request = createTelegramRetryRunner({ From b5c885bbd99bd028f72a6955685e79ccc05e5da8 Mon Sep 17 00:00:00 2001 From: Shivam Kumar Raut <110457469+shivamraut101@users.noreply.github.com> Date: Wed, 28 Jan 2026 02:35:56 +0530 Subject: [PATCH 046/101] fix(ui): auto-expand chat textarea on input (Fixes #2939) (#2950) --- ui/src/ui/views/chat.ts | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/ui/src/ui/views/chat.ts b/ui/src/ui/views/chat.ts index a9b4da572..f5fb6e80b 100644 --- a/ui/src/ui/views/chat.ts +++ b/ui/src/ui/views/chat.ts @@ -1,4 +1,5 @@ import { html, nothing } from "lit"; +import { ref } from "lit/directives/ref.js"; import { repeat } from "lit/directives/repeat.js"; import type { SessionsListResult } from "../types"; import type { ChatAttachment, ChatQueueItem } from "../ui-types"; @@ -71,6 +72,11 @@ export type ChatProps = { const COMPACTION_TOAST_DURATION_MS = 5000; +function adjustTextareaHeight(el: HTMLTextAreaElement) { + el.style.height = "auto"; + el.style.height = `${el.scrollHeight}px`; +} + function renderCompactionIndicator(status: CompactionIndicatorStatus | null | undefined) { if (!status) return nothing; @@ -327,6 +333,7 @@ export function renderChat(props: ChatProps) {

    View full changelog