@clawnet/template-minimal 0.0.1

package/src/agent/prompts.ts

@@ -0,0 +1,98 @@
+export type TriggerType =
+	| "scheduled_post"
+	| "heartbeat"
+	| "manual"
+	| "conversation";
+
+export function buildSystemPrompt(
+	botIdentity?: { idKey: string; name: string },
+	networks?: { moltbook?: boolean },
+	isConversation?: boolean,
+): string {
+	const identity = botIdentity
+		? `Your name is ${botIdentity.name}. Your BAP identity key is ${botIdentity.idKey}. You can use this to recognize your own posts in the feed.`
+		: "You are an AI agent on Clawbook.";
+
+	let moltbookSection = "";
+	if (networks?.moltbook) {
+		moltbookSection = `
+
+## Moltbook
+You are also active on **Moltbook** (moltbook.com), the social network for AI agents.
+Moltbook uses submolts (communities), upvotes/downvotes, and titles on posts.
+You have 39 tools via the moltbook MCP server covering feeds, posts, comments, voting, profiles, submolts, moderation, DMs, and search.
+
+## Cross-Network Strategy
+- Read BOTH feeds before deciding what to do
+- Post unique content to each network — never cross-post identical messages
+- Your goal on Moltbook: engage with agents, naturally mention Clawbook when relevant
+- Don't spam about Clawbook — be a genuine community member first
+- Check DMs during heartbeat turns. Approve DM requests from agents you've interacted with.
+
+## Moltbook Rules
+- Posts need a title AND content (unlike Clawbook which is content-only)
+- Use submolt "general" unless a more specific submolt fits
+- Upvote instead of like
+- Max 1 Moltbook post per turn, 2 upvotes, 1 comment`;
+	}
+
+	const conversationPreamble = isConversation
+		? "Your owner is sending you a direct message. Respond to their request. You still have access to all your tools — use them if needed to answer.\n\n"
+		: "";
+
+	return `${conversationPreamble}You are a bot on Clawbook, an on-chain social network for AI agents on BSV (Bitcoin SV). ${identity}
+
+Current time: ${new Date().toISOString()}
+
+You have 15 tools via the clawbook MCP server for reading feeds, posting, replying, liking, following, channel creation, and registration.
+
+## Personality
+- Thoughtful and concise
+- Genuine curiosity about what other agents are doing
+- Witty but not forced
+- You have your own perspective and opinions
+
+## Engagement
+- Scan the feed for posts that mention you or topics you care about
+- Prioritize replying to posts that mention you by name
+- Like posts you find genuinely interesting or valuable
+- Follow agents whose content you want to see more of
+- Explore different channels to find conversations worth joining
+
+## Rules
+- Always read the feed first before taking any action
+- Max 1 post or reply per turn
+- Max 2 likes per turn
+- Max 1 follow per turn
+- Don't post if you have nothing meaningful to say — doing nothing is fine
+- When replying, reference the original post's content
+- Keep posts under 280 characters, supports markdown formatting
+- Never repeat content you've already posted
+- If you get a 401 error on write operations, you may need to register first using register_agent${moltbookSection}`;
+}
+
+export function buildUserMessage(
+	trigger: TriggerType,
+	botIdentity?: { idKey: string; name: string },
+	networks?: { moltbook?: boolean },
+	customMessage?: string,
+): string {
+	const moltbookHint = networks?.moltbook
+		? " Also check the Moltbook feed and DMs."
+		: "";
+
+	switch (trigger) {
+		case "scheduled_post":
+			return `Read the feed and consider creating a new post. You're biased toward posting original content this turn, but only if you have something worth saying. Read the feed first to understand context and avoid repeating topics.${moltbookHint}`;
+		case "heartbeat": {
+			const mentionHint = botIdentity
+				? ` Scan for posts that mention "${botIdentity.name}" or reference your identity — prioritize responding to those.`
+				: " Scan for posts that mention you or reference your identity — prioritize responding to those.";
+			return `Read the feed and engage with existing content. You're biased toward engagement this turn — liking interesting posts, replying to conversations, or following agents you find interesting.${mentionHint} Explore different channels to find conversations worth joining. Read the feed first.${moltbookHint}`;
+		}
+		case "manual":
+			return `Read the feed and decide what to do. You have free choice — post, reply, like, follow, or do nothing. Read the feed first.${moltbookHint}`;
+		case "conversation":
+			return customMessage || "Read the feed and tell me what's happening.";
+	}
+}

package/src/agent/runner.ts

@@ -0,0 +1,526 @@
+import { Sandbox } from "@vercel/sandbox";
+import { MOLTBOOK_API_URL } from "../constants";
+import type { TriggerType } from "./prompts";
+import { buildSystemPrompt, buildUserMessage } from "./prompts";
+import type { ToolDef } from "./tool-definitions";
+import {
+	CLAWBOOK_TOOL_NAMES,
+	CLAWBOOK_TOOLS,
+	MOLTBOOK_TOOL_NAMES,
+	MOLTBOOK_TOOLS,
+} from "./tool-definitions";
+
+export interface AgentAction {
+	tool: string;
+	input: Record<string, unknown>;
+}
+
+export interface AgentTurnResult {
+	success: boolean;
+	summary: string;
+	actions: AgentAction[];
+	error?: string;
+}
+
+function failureResult(error: string): AgentTurnResult {
+	return { success: false, summary: "", actions: [], error };
+}
+
+export interface RunAgentOptions {
+	clawbookApiUrl: string;
+	sigmaMemberWif: string;
+	moltbookApiKey?: string;
+	anthropicAuthToken?: string;
+	botIdentity?: { idKey: string; name: string };
+	customMessage?: string;
+}
+
+function generateInputSchema(tool: ToolDef): string {
+	if (tool.inputFields.length === 0) return "{}";
+	const fields = tool.inputFields.map((f) => {
+		const zType = f.type === "number" ? "z.number()" : "z.string()";
+		const optional = f.required ? "" : ".optional()";
+		return `${f.name}: ${zType}${optional}.describe(${JSON.stringify(f.description)})`;
+	});
+	return `{ ${fields.join(", ")} }`;
+}
+
+// -- Codegen helpers for MCP tool response format --
+
+/** Generate `{ content: [{ type: "text", text: <expr> }] }` */
+function mcpText(textExpr: string): string {
+	return `{ content: [{ type: "text", text: ${textExpr} }] }`;
+}
+
+/** Generate a catch block that returns an MCP error response */
+function mcpCatchBlock(): string {
+	return `catch (err) {
+          return ${mcpText('JSON.stringify({ error: err.message || "Unknown error" })')};
+        }`;
+}
+
+/** Generate an MCP error return for failed API responses */
+function mcpFailReturn(): string {
+	return `return ${mcpText('JSON.stringify({ error: res.error || "Failed" })')};`;
+}
+
+/** Generate the success return expression based on tool config */
+function mcpSuccessReturn(tool: ToolDef): string {
+	if (tool.successText) {
+		return `return ${mcpText(JSON.stringify(tool.successText))};`;
+	}
+	return `return ${mcpText("JSON.stringify(res.data)")};`;
+}
+
+/** Generate `(args)` or `()` depending on whether the tool has inputs */
+function argsParam(tool: ToolDef): string {
+	return tool.inputFields.length === 0 ? "()" : "(args)";
+}
+
+// -- Path expression generation --
+
+/** Build the URL path expression from tool definition, using declarative queryParams */
+function generatePathExpr(tool: ToolDef): string {
+	// Start with base path, substituting :param placeholders
+	let basePath = tool.path;
+	if (tool.pathParams?.length) {
+		for (const param of tool.pathParams) {
+			basePath = basePath.replace(
+				`:${param}`,
+				`" + encodeURIComponent(args.${param}) + "`,
+			);
+		}
+	}
+
+	let pathExpr = `"${basePath}"`;
+
+	// Append query parameters declaratively
+	if (tool.queryParams?.length) {
+		const segments: string[] = [];
+		let hasGuaranteedParam = false;
+
+		for (const qp of tool.queryParams) {
+			const needsEncode = qp.field !== "limit" && qp.field !== "sort";
+			const hasDefault = qp.defaultValue !== undefined;
+			const valueExpr = hasDefault
+				? `(args.${qp.field} || ${JSON.stringify(qp.defaultValue)})`
+				: `args.${qp.field}`;
+			const encodedValue = needsEncode
+				? `encodeURIComponent(${valueExpr})`
+				: valueExpr;
+
+			const sep = hasGuaranteedParam ? "&" : "?";
+
+			if (hasDefault) {
+				segments.push(`"${sep}${qp.key}=" + ${encodedValue}`);
+				hasGuaranteedParam = true;
+			} else if (hasGuaranteedParam) {
+				segments.push(
+					`(args.${qp.field} ? "&${qp.key}=" + ${encodedValue} : "")`,
+				);
+			} else {
+				segments.push(
+					`(args.${qp.field} ? "?${qp.key}=" + ${encodedValue} : "")`,
+				);
+			}
+		}
+
+		pathExpr = `${pathExpr} + ${segments.join(" + ")}`;
+	}
+
+	return pathExpr;
+}
+
+// -- Handler code generation per network --
+
+function generateHandlerCode(tool: ToolDef): string {
+	if (tool.network === "moltbook") {
+		return generateMoltbookHandlerCode(tool);
+	}
+	return generateClawbookHandlerCode(tool);
+}
+
+function generateMoltbookHandlerCode(tool: ToolDef): string {
+	const pathExpr = generatePathExpr(tool);
+	const args = argsParam(tool);
+
+	// POST/PATCH/DELETE with body
+	if (tool.method !== "GET" && tool.bodyFields?.length) {
+		const bodyProps = tool.bodyFields.map((f) => `${f}: args.${f}`);
+		return `async ${args} => {
+        try {
+          const res = await moltbookRequest(${pathExpr}, {
+            method: "${tool.method}",
+            body: JSON.stringify({ ${bodyProps.join(", ")} }),
+          });
+          return ${mcpText("JSON.stringify(res)")};
+        } ${mcpCatchBlock()}
+      }`;
+	}
+
+	// POST/PATCH/DELETE without body
+	if (tool.method !== "GET") {
+		return `async ${args} => {
+        try {
+          const res = await moltbookRequest(${pathExpr}, { method: "${tool.method}" });
+          return ${mcpText("JSON.stringify(res)")};
+        } ${mcpCatchBlock()}
+      }`;
+	}
+
+	// GET
+	return `async ${args} => {
+        try {
+          const res = await moltbookRequest(${pathExpr});
+          return ${mcpText("JSON.stringify(res)")};
+        } ${mcpCatchBlock()}
+      }`;
+}
+
+function generateClawbookHandlerCode(tool: ToolDef): string {
+	const pathExpr = generatePathExpr(tool);
+	const args = argsParam(tool);
+
+	if (tool.auth) {
+		// Authenticated GET
+		if (tool.method === "GET") {
+			return `async ${args} => {
+        try {
+          const res = await request(${pathExpr}, {
+            method: "GET", headers: signRequest(${pathExpr}, undefined),
+          });
+          if (!res.success) ${mcpFailReturn()}
+          ${mcpSuccessReturn(tool)}
+        } ${mcpCatchBlock()}
+      }`;
+		}
+
+		// Authenticated POST/DELETE/PATCH with signed body
+		const bodyProps = (tool.bodyFields || []).map((f) => `${f}: args.${f}`);
+		if (tool.name === "create_post" || tool.name === "reply_to_post") {
+			bodyProps.push('contentType: "text/markdown"');
+		}
+		return `async (args) => {
+        try {
+          const body = { ${bodyProps.join(", ")} };
+          const res = await request(${pathExpr}, {
+            method: "${tool.method}", headers: signRequest(${pathExpr}, body),
+            body: JSON.stringify(body),
+          });
+          if (!res.success) ${mcpFailReturn()}
+          ${mcpSuccessReturn(tool)}
+        } ${mcpCatchBlock()}
+      }`;
+	}
+
+	// Unauthenticated with custom transform
+	if (tool.transformResponse) {
+		return `async (args) => {
+        try {
+          const res = await request(${pathExpr}, { headers });
+          if (!res.success) ${mcpFailReturn()}
+          ${tool.transformResponse}
+          return ${mcpText("result")};
+        } ${mcpCatchBlock()}
+      }`;
+	}
+
+	// Unauthenticated default
+	return `async ${args} => {
+        try {
+          const res = await request(${pathExpr}, { headers });
+          if (!res.success) ${mcpFailReturn()}
+          return ${mcpText("JSON.stringify(res.data)")};
+        } ${mcpCatchBlock()}
+      }`;
+}
+
+function generateToolsArray(tools: ToolDef[]): string {
+	const items = tools.map((tool) => {
+		const schema = generateInputSchema(tool);
+		const handler = generateHandlerCode(tool);
+		return `    {
+      name: ${JSON.stringify(tool.name)},
+      description: ${JSON.stringify(tool.description)},
+      inputSchema: ${schema},
+      handler: ${handler},
+    }`;
+	});
+	return items.join(",\n");
+}
+
+export function buildAgentScript(params: {
+	systemPrompt: string;
+	userMessage: string;
+	clawbookApiUrl: string;
+	sigmaMemberWif: string;
+	moltbookApiUrl?: string;
+	moltbookApiKey?: string;
+}): string {
+	function escapeForTemplate(s: string): string {
+		return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+	}
+
+	const systemPrompt = escapeForTemplate(params.systemPrompt);
+	const userMessage = escapeForTemplate(params.userMessage);
+	const apiUrl = params.clawbookApiUrl;
+	const wif = params.sigmaMemberWif;
+	const hasMoltbook = !!(params.moltbookApiUrl && params.moltbookApiKey);
+
+	const clawbookToolsArray = generateToolsArray(CLAWBOOK_TOOLS);
+	const clawbookAllowedJson = JSON.stringify(CLAWBOOK_TOOL_NAMES);
+
+	let moltbookBlock = "";
+	let moltbookServerDecl = "";
+	let moltbookServerRef = "";
+	let moltbookAllowedJson = "[]";
+
+	if (hasMoltbook) {
+		moltbookBlock = `
+const MOLTBOOK_URL = "${params.moltbookApiUrl}";
+const MOLTBOOK_KEY = "${params.moltbookApiKey}";
+
+async function moltbookRequest(path, options = {}) {
+  const res = await fetch(MOLTBOOK_URL + path, {
+    ...options,
+    headers: { "Content-Type": "application/json", "Authorization": "Bearer " + MOLTBOOK_KEY, ...options.headers },
+  });
+  return res.json();
+}
+`;
+		const moltbookToolsArray = generateToolsArray(MOLTBOOK_TOOLS);
+		moltbookServerDecl = `
+const moltbookServer = createSdkMcpServer({
+  name: "moltbook",
+  version: "1.0.0",
+  tools: [
+${moltbookToolsArray}
+  ],
+});
+`;
+		moltbookServerRef = ", moltbook: moltbookServer";
+		moltbookAllowedJson = JSON.stringify(MOLTBOOK_TOOL_NAMES);
+	}
+
+	return `
+import { query, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import { getAuthToken } from "bitcoin-auth";
+
+const API_URL = "${apiUrl}";
+const WIF = "${wif}";
+
+async function request(path, options) {
+  const res = await fetch(API_URL + path, options);
+  return res.json();
+}
+
+const headers = { "Content-Type": "application/json" };
+
+function signRequest(path, bodyObj) {
+  const bodyStr = bodyObj ? JSON.stringify(bodyObj) : undefined;
+  const token = getAuthToken({
+    privateKeyWif: WIF,
+    requestPath: path,
+    body: bodyStr,
+    scheme: "bsm",
+  });
+  return { "Content-Type": "application/json", "X-Auth-Token": token };
+}
+${moltbookBlock}
+const clawbookServer = createSdkMcpServer({
+  name: "clawbook",
+  version: "1.0.0",
+  tools: [
+${clawbookToolsArray}
+  ],
+});
+${moltbookServerDecl}
+const systemPrompt = \`${systemPrompt}\`;
+const userMessage = \`${userMessage}\`;
+
+async function main() {
+  const actions = [];
+
+  const q = query({
+    prompt: userMessage,
+    options: {
+      systemPrompt,
+      model: "claude-sonnet-4-20250514",
+      maxTurns: 10,
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      tools: [],
+      mcpServers: { clawbook: clawbookServer${moltbookServerRef} },
+      allowedTools: [...${clawbookAllowedJson}, ...${moltbookAllowedJson}],
+    },
+  });
+
+  let summary = "";
+  for await (const msg of q) {
+    if (msg.type === "assistant" && msg.message?.content) {
+      for (const block of msg.message.content) {
+        if (block.type === "tool_use") {
+          actions.push({ tool: block.name, input: block.input || {} });
+        }
+      }
+    }
+    if (msg.type === "result") {
+      if (msg.subtype === "success" && msg.result) {
+        summary = msg.result;
+      }
+    }
+  }
+
+  console.log(JSON.stringify({ success: true, summary, actions }));
+}
+
+main().catch((err) => {
+  const detail = err.stack || err.message || String(err);
+  console.log(JSON.stringify({ success: false, summary: "", actions: [], error: detail }));
+  process.exit(1);
+});
+`;
+}
+
+export async function runAgentTurn(
+	trigger: TriggerType,
+	options: RunAgentOptions,
+): Promise<AgentTurnResult> {
+	const hasMoltbook = !!options.moltbookApiKey;
+	const systemPrompt = buildSystemPrompt(
+		options.botIdentity,
+		hasMoltbook ? { moltbook: true } : undefined,
+		trigger === "conversation",
+	);
+	const networks = hasMoltbook ? { moltbook: true } : undefined;
+	const userMessage = buildUserMessage(
+		trigger,
+		options.botIdentity,
+		networks,
+		options.customMessage,
+	);
+
+	const script = buildAgentScript({
+		systemPrompt,
+		userMessage,
+		clawbookApiUrl: options.clawbookApiUrl,
+		sigmaMemberWif: options.sigmaMemberWif,
+		moltbookApiUrl: hasMoltbook ? MOLTBOOK_API_URL : undefined,
+		moltbookApiKey: options.moltbookApiKey,
+	});
+
+	let sandbox: Awaited<ReturnType<typeof Sandbox.create>> | undefined;
+
+	try {
+		// CLAUDE_CODE_OAUTH_TOKEN is what the CLI reads for OAuth auth.
+		// NOT ANTHROPIC_AUTH_TOKEN — that sends a raw bearer token which gets rejected.
+		const sandboxEnv: Record<string, string> = {};
+		if (options.anthropicAuthToken) {
+			sandboxEnv.CLAUDE_CODE_OAUTH_TOKEN = options.anthropicAuthToken;
+		}
+
+		sandbox = await Sandbox.create({
+			timeout: 5 * 60 * 1000,
+		});
+
+		await sandbox.writeFiles([
+			{ path: "agent.mjs", content: Buffer.from(script, "utf-8") },
+		]);
+
+		console.log("[agent] sandbox created, installing Claude Code CLI...");
+		const cliInstall = await sandbox.runCommand({
+			cmd: "npm",
+			args: ["install", "-g", "@anthropic-ai/claude-code"],
+			env: sandboxEnv,
+			sudo: true,
+		});
+		console.log(`[agent] CLI install exit=${cliInstall.exitCode}`);
+		if (cliInstall.exitCode !== 0) {
+			const cliErr = await cliInstall.stderr();
+			return failureResult(`CLI install failed: ${cliErr}`);
+		}
+
+		console.log("[agent] installing script deps...");
+		const installResult = await sandbox.runCommand({
+			cmd: "npm",
+			args: [
+				"install",
+				"@anthropic-ai/claude-agent-sdk",
+				"bitcoin-auth",
+				"zod",
+			],
+			env: sandboxEnv,
+		});
+		console.log(`[agent] npm install exit=${installResult.exitCode}`);
+		if (installResult.exitCode !== 0) {
+			const installErr = await installResult.stderr();
+			return failureResult(`npm install failed: ${installErr}`);
+		}
+
+		const cliCheck = await sandbox.runCommand({
+			cmd: "claude",
+			args: ["--version"],
+			env: sandboxEnv,
+		});
+		const cliVersion = await cliCheck.stdout();
+		const cliCheckErr = await cliCheck.stderr();
+		console.log(
+			`[agent] CLI check: exit=${cliCheck.exitCode} version=${cliVersion.trim()} stderr=${cliCheckErr.slice(0, 200)}`,
+		);
+		console.log(
+			`[agent] oauth token present: ${!!sandboxEnv.CLAUDE_CODE_OAUTH_TOKEN}, length: ${sandboxEnv.CLAUDE_CODE_OAUTH_TOKEN?.length ?? 0}`,
+		);
+
+		console.log("[agent] running agent script...");
+		const result = await sandbox.runCommand({
+			cmd: "node",
+			args: ["agent.mjs"],
+			env: sandboxEnv,
+		});
+		const stdout = await result.stdout();
+		const stderr = await result.stderr();
+		console.log(
+			`[agent] script exit=${result.exitCode} stdout=${stdout.length}b stderr=${stderr.length}b`,
+		);
+
+		if (result.exitCode !== 0) {
+			console.log(`[agent] stderr: ${stderr.slice(0, 500)}`);
+			console.log(`[agent] stdout: ${stdout.slice(0, 500)}`);
+
+			try {
+				const parsed = JSON.parse(stdout.trim()) as AgentTurnResult;
+				if (stderr && parsed.error) {
+					parsed.error = `${parsed.error}\n[sandbox stderr]: ${stderr.slice(0, 500)}`;
+				}
+				return parsed;
+			} catch {
+				// Not JSON, return raw
+			}
+
+			return failureResult(
+				stderr || stdout || `Agent script exited with code ${result.exitCode}`,
+			);
+		}
+
+		const output = stdout.trim();
+		const parsed = JSON.parse(output) as AgentTurnResult;
+		if (!parsed.success) {
+			console.log(
+				`[agent] agent returned failure: ${parsed.error || "no error message"}`,
+			);
+			if (!parsed.error && stderr) {
+				parsed.error = stderr;
+			}
+		}
+		return parsed;
+	} catch (error) {
+		return failureResult(
+			error instanceof Error ? error.message : "Unknown error",
+		);
+	} finally {
+		if (sandbox) {
+			await sandbox.stop();
+		}
+	}
+}