@otterware/openclaw-otter 0.2.3 → 0.2.5

package/control.js

@@ -445,9 +445,13 @@ export function createBrowserControl({
       }
       const tab = tabOf(targetId);
       tab.seen = now();
-      tab.lock = { until: now() + CONTROL_TTL_MS, next: 1, waiting: new Map() };
+      const lock = { until: now() + CONTROL_TTL_MS, next: 1, waiting: new Map() };
+      tab.lock = lock;
       // The page's own file picker is offered to you while you hold it.
-      const page = await pageOf(tab, targetId, profile);
+      const page = await pageOf(tab, targetId, profile).catch((error) => {
+        if (tab.lock === lock) unlock(tab);
+        throw error;
+      });
       void page.call("Page.setInterceptFileChooserDialog", { enabled: true }).catch(() => {});
     },
     release(targetId) {
@@ -505,13 +509,13 @@ export function createBrowserControl({
       if (!tab) throw new Error("Take control of this tab first.");
       const chooser = tab.chooser;
       if (!chooser) throw new Error("The page isn't asking for a file.");
-      tab.chooser = null;
       const picked = Array.isArray(files) ? files : [];
       const total = picked.reduce((sum, f) => sum + String(f?.data ?? "").length * 0.75, 0);
       if (total > MAX_UPLOAD_BYTES) throw new Error("Those files are too large (10 MB at most).");
       const dir = path.join(uploads, randomUUID());
       const paths = [];
       if (picked.length > 0) {
+        setTimeout(() => void rm(dir, { recursive: true, force: true }), UPLOADS_KEPT_MS).unref?.();
         for (const [i, file] of picked.entries()) {
           // A folder each, so two files of the same name both reach the page as named.
           const at = path.join(dir, String(i));
@@ -520,13 +524,13 @@ export function createBrowserControl({
           await writeFile(path.join(at, name), Buffer.from(String(file?.data ?? ""), "base64"));
           paths.push(path.join(at, name));
         }
-        setTimeout(() => void rm(dir, { recursive: true, force: true }), UPLOADS_KEPT_MS).unref?.();
       }
       const page = await pageOf(tab, targetId, profile);
       await page.call("DOM.setFileInputFiles", {
         files: paths,
         backendNodeId: chooser.backendNodeId,
       });
+      if (tab.chooser === chooser) tab.chooser = null;
     },
   };
 }

package/files.js

@@ -1,7 +1,8 @@
 import { open, realpath } from "node:fs/promises";
 import path from "node:path";
 
-export const MAX_FILE_BYTES = 50 * 1024 * 1024;
+/** Sent base64 in one gateway message (16 MB at most). */
+export const MAX_FILE_BYTES = 10 * 1024 * 1024;
 
 /** A file in the agent's workspace, whole: the gateway's own reader stops at images and small text. */
 export async function readWorkspaceFile(workspace, requested) {
@@ -14,7 +15,7 @@ export async function readWorkspaceFile(workspace, requested) {
   try {
     const stat = await handle.stat();
     if (!stat.isFile()) throw new Error("file not found");
-    if (stat.size > MAX_FILE_BYTES) throw new Error("file is too large (50 MB max)");
+    if (stat.size > MAX_FILE_BYTES) throw new Error("file is too large (10 MB max)");
     const data = await handle.readFile();
     return { name: path.basename(file), size: data.length, content: data.toString("base64") };
   } finally {

package/index.js

@@ -5,6 +5,7 @@ import {
   defineChannelPluginEntry,
 } from "openclaw/plugin-sdk/channel-core";
 import { toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
+import { waitUntilAbort } from "openclaw/plugin-sdk/channel-outbound";
 import { runInDetachedAsyncContext } from "openclaw/plugin-sdk/concurrency-runtime";
 import { defineStableChannelIngressIdentity } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
@@ -15,17 +16,18 @@ import { runDetachedWebhookWork } from "openclaw/plugin-sdk/webhook-request-guar
 import { readWorkspaceFile } from "./files.js";
 import {
   accountOf,
+  chatOf,
   chatTarget,
+  deliver,
   isNewChat,
   isOwnerConfigured,
   messageOf,
   newChatKey,
   otterTargetsNote,
   OWNER,
-  pointerOf,
-  sessionOf,
+  startDetached,
   targetOf,
-  tell,
+  TARGETS_HINT,
 } from "./otter.js";
 
 const owner = defineStableChannelIngressIdentity({
@@ -34,12 +36,8 @@ const owner = defineStableChannelIngressIdentity({
   sensitivity: "pii",
 });
 
-async function deliver(ctx, payload) {
-  const account = accountOf(ctx.cfg);
-  const pointer = pointerOf({ sessionKey: ctx.sessionKey, to: ctx.to, payload });
-  await tell(account, pointer, { signal: ctx.signal });
-  return { channel: "otter", messageId: randomUUID(), timestamp: pointer.at };
-}
+let logger;
+const warn = (message) => logger?.warn?.(message);
 
 export const otterChannel = createChatChannelPlugin({
   base: {
@@ -60,18 +58,20 @@ export const otterChannel = createChatChannelPlugin({
         },
       },
     }),
+    // Nothing to keep connected, but a channel that doesn't stay started reads as stopped, and the
+    // gateway's health monitor restarts it every few minutes.
+    gateway: { startAccount: (ctx) => waitUntilAbort(ctx.abortSignal) },
     messaging: {
       targetResolver: {
         looksLikeId: () => true,
-        hint: '"chat:<session key>" for one of Otter\'s chats, "new" for a new chat, or "inbox"',
+        hint: TARGETS_HINT,
       },
-      // A delivery to a chat is kept in its session; to "new", in a chat it starts (the gateway
-      // routes each delivery once, and sends it to that session); any other, in the inbox.
+      // A delivery to a chat is kept in its session; to "chat:new", in a chat it starts (the gateway
+      // routes each delivery once, and sends it to that session).
       resolveOutboundSessionRoute: ({ agentId, target }) => {
         const to = targetOf(target);
-        const sessionKey = isNewChat(to)
-          ? newChatKey(agentId, randomUUID())
-          : sessionOf(target, agentId);
+        if (!to) return null;
+        const sessionKey = isNewChat(to) ? newChatKey(agentId, randomUUID()) : chatOf(to);
         return {
           sessionKey,
           baseSessionKey: sessionKey,
@@ -86,14 +86,19 @@ export const otterChannel = createChatChannelPlugin({
   },
   outbound: {
     deliveryMode: "direct",
-    resolveTarget: (params) => ({ ok: true, to: targetOf(params?.to) }),
-    sendText: (ctx) => deliver(ctx),
-    sendPayload: (ctx) => deliver(ctx, ctx.payload),
+    resolveTarget: (params) => {
+      const to = targetOf(params?.to);
+      return to
+        ? { ok: true, to }
+        : { ok: false, error: new Error(`Otter's targets are ${TARGETS_HINT}.`) };
+    },
+    sendText: (ctx) => deliver(ctx, undefined, { warn }),
+    sendPayload: (ctx) => deliver(ctx, ctx.payload, { warn }),
   },
 });
 
-/** Runs what you sent from Otter as the channel's owner: an inbound message, as from any chat app. */
-async function receive(api, cfg, message) {
+/** What you sent from Otter as the channel's owner: an inbound message, as from any chat app. */
+async function inboundOf(api, message) {
   const { sessionKey, agentId, text, messageId, files } = message;
   const inbound = api.runtime.channel.inbound;
   const saved = await Promise.all(
@@ -120,7 +125,7 @@ async function receive(api, cfg, message) {
     readStoreAllowFrom: async () => [],
   });
   const to = chatTarget(sessionKey);
-  const ctxPayload = await inbound.buildContext({
+  return inbound.buildContext({
     channelIngress,
     channel: "otter",
     accountId: "default",
@@ -138,7 +143,10 @@ async function receive(api, cfg, message) {
       ),
     }),
   });
-  await inbound.dispatch({
+}
+
+function dispatch(api, cfg, { agentId, sessionKey, messageId }, ctxPayload) {
+  return api.runtime.channel.inbound.dispatch({
     cfg,
     channel: "otter",
     accountId: "default",
@@ -156,6 +164,7 @@ export default defineChannelPluginEntry({
   description: "Send what your agents want you to see to Otter.",
   plugin: otterChannel,
   registerFull(api) {
+    logger = api.logger;
     // What Otter's targets are, for a turn in an Otter chat: the Codex harness leaves channels'
     // message-tool hints out of its instructions, but every harness runs this hook.
     api.on("before_prompt_build", (_event, ctx) =>
@@ -174,11 +183,12 @@ export default defineChannelPluginEntry({
         const message = messageOf(params);
         // The run starts outside the request that carried it (the gateway's context-free root,
         // whatever request loaded this plugin), so it's the channel owner's, not that
-        // connection's, and outlives it.
-        runInDetachedAsyncContext(() =>
-          runDetachedWebhookWork(() => receive(api, cfg, message)).catch((error) =>
-            api.logger?.warn?.(`otter: a message from Otter failed: ${String(error)}`),
-          ),
+        // connection's, and outlives it. What fails before it starts fails the request.
+        await startDetached(
+          (work, fail) => runInDetachedAsyncContext(() => runDetachedWebhookWork(work).catch(fail)),
+          () => inboundOf(api, message),
+          (ctxPayload) => dispatch(api, cfg, message, ctxPayload),
+          (error) => warn(`otter: a message from Otter failed: ${String(error)}`),
         );
         return { runId: message.messageId, status: "started" };
       },

package/otter.js

@@ -1,9 +1,5 @@
 // What the plugin does, apart from OpenClaw's SDK, so Otter's tests can run it.
-
-/** Where an agent's deliveries to Otter are kept: one session per agent, read by Otter's apps. */
-export const inboxKey = (agentId) => `agent:${agentId}:otter:inbox`;
-
-export const OTTER_TARGET = "inbox";
+import { randomUUID } from "node:crypto";
 
 /** Who sends what you type in Otter: the gateway's owner once `commands.ownerAllowFrom` lists `otter:owner`. */
 export const OWNER = "owner";
@@ -13,18 +9,23 @@ export const OWNER_ENTRY = `otter:${OWNER}`;
 export const chatTarget = (sessionKey) => `chat:${sessionKey}`;
 
 /** Like posting to a Slack channel rather than in a thread: each delivery starts a chat of its own. */
-export const NEW_CHAT_TARGET = "new";
+export const NEW_CHAT_TARGET = "chat:new";
+
+const bare = (to) => (typeof to === "string" ? to.trim().replace(/^otter:/, "") : "");
 
-export const isNewChat = (to) =>
-  typeof to === "string" && to.trim().replace(/^otter:/, "") === NEW_CHAT_TARGET;
+/** What's sent to the gateway's owner (`otter:owner`) starts a chat, as it names none. */
+export const isNewChat = (to) => bare(to) === NEW_CHAT_TARGET || bare(to) === OWNER;
 
-/** A target as the channel keeps it: one of Otter's chats, a new one each time, or the inbox. */
+/** A target as the channel keeps it: one of Otter's chats, or a new one each time; else none. */
 export function targetOf(to) {
   const chat = chatOf(to);
   if (chat) return chatTarget(chat);
-  return isNewChat(to) ? NEW_CHAT_TARGET : OTTER_TARGET;
+  return isNewChat(to) ? NEW_CHAT_TARGET : undefined;
 }
 
+export const TARGETS_HINT =
+  '"chat:<session key>" for one of Otter\'s chats, or "chat:new" for a new one';
+
 /** A session for a new chat, an Otter chat like one you start. */
 export const newChatKey = (agentId, id) => `agent:${agentId}:otter-mail:${id}`;
 
@@ -35,10 +36,9 @@ export const newChatKey = (agentId, id) => `agent:${agentId}:otter-mail:${id}`;
 export function otterTargetsNote(sessionKey) {
   const here = agentOf(sessionKey) ? chatTarget(sessionKey) : "chat:<session key>";
   return [
-    "Otter delivery targets (channel `otter`), like a thread or a new post in Slack:",
+    "Otter delivery targets (channel `otter`), like replying in a thread or a new post in Slack:",
     `- "${here}": this chat. Any Otter chat is "chat:<its session key>".`,
-    '- "new": a new Otter chat for each delivery (an automation that should post a fresh chat every run, such as a morning brief).',
-    '- "inbox": the agent\'s single Otter inbox chat.',
+    '- "chat:new": a new Otter chat for each delivery (an automation that should post a fresh chat every run, such as a morning brief or an alert).',
   ].join("\n");
 }
 
@@ -49,15 +49,12 @@ export const agentOf = (sessionKey) =>
 
 /** The chat a target names, if it names one. */
 export function chatOf(to) {
-  const target = typeof to === "string" ? to.trim().replace(/^otter:/, "") : "";
+  const target = bare(to);
   if (!target.startsWith("chat:")) return undefined;
   const sessionKey = target.slice("chat:".length);
   return agentOf(sessionKey) ? sessionKey : undefined;
 }
 
-/** The session a delivery to this target is kept in. */
-export const sessionOf = (to, agentId) => chatOf(to) ?? inboxKey(agentId);
-
 export const isOwnerConfigured = (cfg) =>
   Array.isArray(cfg?.commands?.ownerAllowFrom) &&
   cfg.commands.ownerAllowFrom.some((entry) => String(entry).trim() === OWNER_ENTRY);
@@ -77,7 +74,7 @@ export function pointerOf({ sessionKey, to, payload, at = Date.now() }) {
   return {
     kind: approval ? "approval" : question ? "question" : "message",
     agentId,
-    sessionKey: approval || question ? (session ?? null) : (chat ?? inboxKey(agentId)),
+    sessionKey: approval || question ? (session ?? null) : (chat ?? session ?? null),
     ...(approval && {
       approvalId: String(approval.approvalId),
       approvalKind: approval.approvalKind === "plugin" ? "plugin" : "exec",
@@ -111,6 +108,45 @@ export async function tell(account, pointer, { fetch = globalThis.fetch, signal
   return true;
 }
 
+/** A delivery to Otter: kept on the gateway even when the relay can't be told of it. */
+export async function deliver(ctx, payload, { warn, fetch } = {}) {
+  const pointer = pointerOf({ sessionKey: ctx.sessionKey, to: ctx.to, payload });
+  try {
+    await tell(accountOf(ctx.cfg), pointer, { fetch, signal: ctx.signal });
+  } catch (error) {
+    if (ctx.signal?.aborted) throw error;
+    warn?.(`otter: couldn't tell Otter's devices of a delivery: ${String(error)}`);
+  }
+  return { channel: "otter", messageId: randomUUID(), timestamp: pointer.at };
+}
+
+/**
+ * Runs `prepare`, then `run` with what it made, in `detach(work, fail)`: settles once prepared,
+ * with `prepare`'s error or `detach`'s; what `run` throws goes to `warn`.
+ */
+export const startDetached = (detach, prepare, run, warn) =>
+  new Promise((resolve, reject) => {
+    const work = async () => {
+      let ready;
+      try {
+        ready = await prepare();
+      } catch (error) {
+        return reject(error);
+      }
+      resolve();
+      try {
+        await run(ready);
+      } catch (error) {
+        warn?.(error);
+      }
+    };
+    try {
+      detach(work, reject);
+    } catch (error) {
+      reject(error);
+    }
+  });
+
 /** A message sent from Otter, checked: where it goes and what it carries. */
 export function messageOf(params) {
   const { sessionKey, message, idempotencyKey, attachments } = params ?? {};

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@otterware/openclaw-otter",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Otter as an OpenClaw channel: what your agents send you waits in Otter, and Otter tells your devices.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/otterware-app/otter-mail.git",
+    "url": "git+https://github.com/otterware-app/otter.git",
     "directory": "extensions/openclaw/gateway"
   },
   "files": [