@clawos-dev/clawd 0.2.679 → 0.2.680

package/dist/cli.cjs

@@ -57210,7 +57210,8 @@ function writeRpcToolMcpConfig(args) {
     }
   };
   import_node_fs33.default.mkdirSync(args.dataDir, { recursive: true });
-  import_node_fs33.default.writeFileSync(cfgPath, JSON.stringify(content, null, 2), "utf8");
+  import_node_fs33.default.writeFileSync(cfgPath, JSON.stringify(content, null, 2), { encoding: "utf8", mode: 384 });
+  import_node_fs33.default.chmodSync(cfgPath, 384);
   return cfgPath;
 }
 
@@ -75335,7 +75336,7 @@ function computeMethodAccess(args) {
 }
 
 // src/version.ts
-var version = "0.2.679".length > 0 ? "0.2.679" : "dev";
+var version = "0.2.680".length > 0 ? "0.2.680" : "dev";
 
 // src/cli-probe/probe.ts
 var fs86 = __toESM(require("fs"), 1);
@@ -75418,9 +75419,11 @@ function buildReadyFrame(deps, client) {
   };
 }
 function buildMetaHandlers(deps) {
-  const info = async () => ({
-    response: { type: "info", ...buildReadyFrame(deps) }
-  });
+  const info = async (_frame, client) => {
+    const frame = buildReadyFrame(deps);
+    if (client.transport === "http") delete frame.httpToken;
+    return { response: { type: "info", ...frame } };
+  };
   const ping = async () => ({
     response: { type: "pong", at: Date.now() }
   });

package/dist/rpc-tool/mcp-server.cjs

@@ -21125,6 +21125,17 @@ function log(msg, extra) {
   } catch {
   }
 }
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_MAX_RESULT_CHARS = 6e4;
+function positiveIntFromEnv(name, fallback) {
+  const n = Number(process.env[name]);
+  return Number.isInteger(n) && n > 0 ? n : fallback;
+}
+function truncateResult(text, max) {
+  if (max === void 0 || text.length <= max) return text;
+  return text.slice(0, max) + `
+\u2026[truncated: ${text.length - max} of ${text.length} chars omitted. Narrow the call: pass \`slim:true\` to history:read, or use limit/offset/cursor where the method supports them.]`;
+}
 async function handleCallToolCall(input, ctx) {
   const f = ctx.fetch ?? fetch;
   const args = input.args ?? {};
@@ -21142,9 +21153,23 @@ async function handleCallToolCall(input, ctx) {
         "content-type": "application/json",
         authorization: `Bearer ${ctx.daemonToken}`
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(ctx.timeoutMs ?? DEFAULT_TIMEOUT_MS)
     });
   } catch (err) {
+    if (err instanceof Error && err.name === "TimeoutError") {
+      const secs = Math.round((ctx.timeoutMs ?? DEFAULT_TIMEOUT_MS) / 1e3);
+      log("call timed out", { url, secs });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `RPC timed out after ${secs}s waiting for ${input.method}. The daemon may still be running it \u2014 check the result before retrying a method that writes.`
+          }
+        ],
+        isError: true
+      };
+    }
     const msg = err instanceof Error ? err.message : String(err);
     log("call fetch threw", { url, msg });
     return {
@@ -21170,9 +21195,27 @@ async function handleCallToolCall(input, ctx) {
     };
   }
   log("call ok", { url });
-  return { content: [{ type: "text", text: JSON.stringify(json.result) }] };
+  return { content: [{ type: "text", text: truncateResult(JSON.stringify(json.result), ctx.maxResultChars) }] };
 }
-async function handleListToolCall(ctx) {
+var SUMMARY_MAX_CHARS = 100;
+function summarize(description) {
+  const end = description.search(/。|\. |\n/);
+  const first = end === -1 ? description : description.slice(0, end + (description[end] === "." ? 1 : 0));
+  return first.length > SUMMARY_MAX_CHARS ? first.slice(0, SUMMARY_MAX_CHARS) + "\u2026" : first;
+}
+async function handleListToolCall(callerCtx, opts = {}) {
+  const ctx = { ...callerCtx, maxResultChars: void 0 };
+  if (opts.method) {
+    const one = await handleCallToolCall({ method: "meta:methods", args: { method: opts.method } }, ctx);
+    if (one.isError) return one;
+    try {
+      const entry = JSON.parse(one.content[0].text).methods[0];
+      if (!entry) throw new Error("empty");
+      return { content: [{ type: "text", text: JSON.stringify(entry, null, 2) }] };
+    } catch {
+      return { content: [{ type: "text", text: "meta:methods returned an unexpected shape" }], isError: true };
+    }
+  }
   const raw = await handleCallToolCall({ method: "meta:methods" }, ctx);
   if (raw.isError) return raw;
   let methods;
@@ -21181,6 +21224,13 @@ async function handleListToolCall(ctx) {
   } catch {
     return { content: [{ type: "text", text: "meta:methods returned an unexpected shape" }], isError: true };
   }
+  if (opts.prefix) {
+    const prefix = opts.prefix;
+    methods = methods.filter((m) => m.name.startsWith(prefix));
+    if (methods.length === 0) {
+      return { content: [{ type: "text", text: `No methods start with "${prefix}". Call list with no arguments to see all.` }] };
+    }
+  }
   return { content: [{ type: "text", text: formatMethodList(methods) }] };
 }
 function formatMethodList(methods) {
@@ -21199,7 +21249,7 @@ function formatMethodList(methods) {
     for (const [reason, group2] of byReason) {
       if (reason) lines.push(`(${reason})`);
       for (const m of group2) {
-        lines.push(m.description ? `- ${m.name} \u2014 ${m.description}` : `- ${m.name}`);
+        lines.push(m.description ? `- ${m.name} \u2014 ${summarize(m.description)}` : `- ${m.name}`);
         if (m.args && m.args.length > 0) {
           lines.push(`    args: ${m.args.map((a) => a.required ? `${a.name}*` : a.name).join(", ")}`);
         } else if (m.args === null) {
@@ -21211,35 +21261,42 @@ function formatMethodList(methods) {
     }
     lines.push("");
   }
-  lines.push("Call any of these with the `call` tool: call({ method, args }). `*` marks required args.");
+  lines.push(
+    "Call any of these with the `call` tool: call({ method, args }). `*` marks required args. Descriptions are shortened here: list({ method }) returns one method in full with its args schema."
+  );
   return lines.join("\n");
 }
 async function main() {
   const daemonUrl = process.env.CLAWD_DAEMON_URL;
   const daemonToken = process.env.CLAWD_DAEMON_TOKEN;
   const sessionId = process.env.CLAWD_SESSION_ID;
-  log("boot", { pid: process.pid, hasSessionId: Boolean(sessionId), logPath: RPC_LOG ?? "(stderr)" });
+  const timeoutMs = positiveIntFromEnv("CLAWD_RPC_TIMEOUT_MS", DEFAULT_TIMEOUT_MS);
+  const maxResultChars = positiveIntFromEnv("CLAWD_RPC_MAX_RESULT_CHARS", DEFAULT_MAX_RESULT_CHARS);
+  log("boot", { pid: process.pid, hasSessionId: Boolean(sessionId), logPath: RPC_LOG ?? "(stderr)", timeoutMs, maxResultChars });
   const server = new McpServer({ name: "clawd-rpc", version: "0.1.0" });
   server.registerTool(
     "call",
     {
       title: "Call a clawd daemon RPC method",
-      description: 'Call a clawd daemon RPC method over the authenticated local channel. `method` is the canonical method name (e.g. "attachment.signUrl", "persona:list", "session:list"); `args` is the JSON body for that method. sessionId is auto-filled from this session unless explicitly provided in args. The daemon is the sole authority on method existence and authorization \u2014 unknown methods or missing permissions surface as errors from the daemon.',
+      description: 'Call a clawd daemon RPC method over the authenticated local channel. `method` is the canonical method name (e.g. "attachment.signUrl", "persona:list", "session:list"); `args` is the JSON body for that method. sessionId is auto-filled from this session unless explicitly provided in args. The daemon is the sole authority on method existence and authorization \u2014 unknown methods or missing permissions surface as errors from the daemon. Gives up after the timeout, and long results are truncated with a hint to narrow the call.',
       inputSchema: {
         method: external_exports.string().min(1).describe('canonical RPC method name, e.g. "persona:list"'),
         args: external_exports.record(external_exports.unknown()).optional().describe("JSON arguments for the method")
       }
     },
-    async (input) => handleCallToolCall(input, { daemonUrl, daemonToken, sessionId })
+    async (input) => handleCallToolCall(input, { daemonUrl, daemonToken, sessionId, timeoutMs, maxResultChars })
   );
   server.registerTool(
     "list",
     {
       title: "List callable clawd daemon RPC methods",
-      description: "List every RPC method this daemon exposes, grouped by whether THIS connection can call it. Use it before guessing a method name \u2014 the daemon has 100+ methods and `call` does no local validation. Takes no arguments.",
-      inputSchema: {}
+      description: 'List the RPC methods this daemon exposes, grouped by whether THIS connection can call it, one shortened line per method. The daemon has 100+ methods and `call` does no local validation, so prefer `prefix` (e.g. "session:") to narrow the list, and `method` to get one method in full with its args schema. With no arguments it lists everything.',
+      inputSchema: {
+        prefix: external_exports.string().min(1).optional().describe('only methods whose name starts with this, e.g. "session:"'),
+        method: external_exports.string().min(1).optional().describe("one exact method name: returns its full description and args schema")
+      }
     },
-    async () => handleListToolCall({ daemonUrl, daemonToken, sessionId })
+    async (input) => handleListToolCall({ daemonUrl, daemonToken, sessionId, timeoutMs }, input)
   );
   await server.connect(new StdioServerTransport());
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.679",
+  "version": "0.2.680",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",