@otterware/openclaw-otter 0.2.4 → 0.2.6

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";
@@ -17,16 +18,16 @@ import {
   accountOf,
   chatOf,
   chatTarget,
+  deliver,
   isNewChat,
   isOwnerConfigured,
   messageOf,
   newChatKey,
   otterTargetsNote,
   OWNER,
-  pointerOf,
+  startDetached,
   targetOf,
   TARGETS_HINT,
-  tell,
 } from "./otter.js";
 
 const owner = defineStableChannelIngressIdentity({
@@ -35,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: {
@@ -61,6 +58,9 @@ 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,
@@ -92,13 +92,13 @@ export const otterChannel = createChatChannelPlugin({
         ? { ok: true, to }
         : { ok: false, error: new Error(`Otter's targets are ${TARGETS_HINT}.`) };
     },
-    sendText: (ctx) => deliver(ctx),
-    sendPayload: (ctx) => deliver(ctx, ctx.payload),
+    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(
@@ -125,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",
@@ -143,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",
@@ -161,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) =>
@@ -169,6 +173,20 @@ export default defineChannelPluginEntry({
         : undefined,
     );
 
+    // OpenClaw tells clients of a compaction inside a run, not of one before it (a transcript
+    // over its byte limit), where a chat would wait on it without a word.
+    const compaction = (phase) => (_event, ctx) => {
+      if (!ctx?.sessionKey) return;
+      api.agent?.events?.emitAgentEvent?.({
+        runId: `${ctx.sessionId ?? ctx.sessionKey}:compaction`,
+        sessionKey: ctx.sessionKey,
+        stream: "otter.compaction",
+        data: phase === "start" ? { phase } : { phase, completed: true },
+      });
+    };
+    api.on("before_compaction", compaction("start"));
+    api.on("after_compaction", compaction("end"));
+
     // What you send in an Otter chat, as the gateway's owner: `chat.send`'s run, with the authority
     // a configured channel owner has (an automation another chat made, for one).
     api.registerGatewayMethod(
@@ -179,11 +197,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,4 +1,5 @@
 // What the plugin does, apart from OpenClaw's SDK, so Otter's tests can run it.
+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";
@@ -107,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.4",
+  "version": "0.2.6",
   "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": [