@bananalink-test/agent-wallet 0.1.0

package/dist/index.mjs

@@ -0,0 +1,478 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { Command } from "commander";
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { createConnection, createServer } from "node:net";
+import { BananalinkClient, ConnectionRejectedError, ConnectionTimeoutError, RequestRejectedError, RequestTimeoutError, SessionClosedError } from "@bananalink-test/client";
+import { parseUnits } from "viem";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+
+//#region src/chain/resolveChain.ts
+const CHAINS = {
+	ethereum: 1,
+	eth: 1,
+	polygon: 137,
+	matic: 137,
+	base: 8453,
+	optimism: 10,
+	op: 10,
+	arbitrum: 42161,
+	arb: 42161,
+	sepolia: 11155111
+};
+function resolveChain(input) {
+	const n = Number(input);
+	if (!Number.isNaN(n) && n > 0) return n;
+	const id = CHAINS[input.toLowerCase()];
+	if (!id) throw new Error(`Unknown chain "${input}". Use a name (ethereum, base, polygon…) or a numeric chain ID.`);
+	return id;
+}
+
+//#endregion
+//#region src/config/CONFIG_DIR.ts
+const CONFIG_DIR = join(homedir(), ".config", "bananalink-agent");
+
+//#endregion
+//#region src/config/PID_FILE.ts
+const PID_FILE = join(CONFIG_DIR, "daemon.pid");
+
+//#endregion
+//#region src/config/SOCKET_PATH.ts
+const SOCKET_PATH = join(CONFIG_DIR, "daemon.sock");
+
+//#endregion
+//#region src/errors/toErrorPayload.ts
+function toErrorPayload(e) {
+	if (e instanceof ConnectionRejectedError) return {
+		error: "ConnectionRejected",
+		message: "Connection was declined."
+	};
+	if (e instanceof ConnectionTimeoutError) return {
+		error: "ConnectionTimeout",
+		message: "Timed out waiting for wallet approval."
+	};
+	if (e instanceof RequestRejectedError) return {
+		error: "RequestRejected",
+		message: "Transaction was declined."
+	};
+	if (e instanceof RequestTimeoutError) return {
+		error: "RequestTimeout",
+		message: "Timed out waiting for transaction approval."
+	};
+	if (e instanceof SessionClosedError) return {
+		error: "SessionClosed",
+		message: "Session expired. Run connect again."
+	};
+	return {
+		error: "Error",
+		message: e instanceof Error ? e.message : String(e)
+	};
+}
+
+//#endregion
+//#region src/output/emit.ts
+function emit(data) {
+	console.log(JSON.stringify(data));
+}
+
+//#endregion
+//#region src/output/info.ts
+function info(msg) {
+	console.error(msg);
+}
+
+//#endregion
+//#region src/schemas/DisconnectCmdSchema.ts
+const DisconnectCmdSchema = z.object({ cmd: z.literal("disconnect") });
+
+//#endregion
+//#region src/schemas/SendCmdSchema.ts
+const SendCmdSchema = z.object({
+	cmd: z.literal("send"),
+	to: z.string(),
+	chainId: z.string().transform(resolveChain),
+	value: z.string().optional(),
+	data: z.string().optional(),
+	notificationTitle: z.string().optional(),
+	notificationBody: z.string().optional()
+});
+
+//#endregion
+//#region src/schemas/StatusCmdSchema.ts
+const StatusCmdSchema = z.object({ cmd: z.literal("status") });
+
+//#endregion
+//#region src/schemas/DaemonCmdSchema.ts
+const DaemonCmdSchema = z.discriminatedUnion("cmd", [
+	StatusCmdSchema,
+	SendCmdSchema,
+	DisconnectCmdSchema
+]);
+
+//#endregion
+//#region src/config/SESSION_FILE.ts
+const SESSION_FILE = join(CONFIG_DIR, "session.json");
+
+//#endregion
+//#region src/schemas/StoredSessionSchema.ts
+const StoredSessionSchema = z.object({
+	dappId: z.string(),
+	accessToken: z.string().optional()
+});
+
+//#endregion
+//#region src/session/loadSession.ts
+function loadSession() {
+	try {
+		if (existsSync(SESSION_FILE)) {
+			const data = readFileSync(SESSION_FILE, "utf8");
+			const result = StoredSessionSchema.safeParse(JSON.parse(data));
+			if (result.success) return result.data;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/session/saveSession.ts
+function saveSession(s) {
+	mkdirSync(CONFIG_DIR, { recursive: true });
+	writeFileSync(SESSION_FILE, JSON.stringify(s, null, 2), { mode: 384 });
+}
+
+//#endregion
+//#region src/daemon/runDaemon.ts
+function makeDapp(dappId) {
+	return {
+		dappId,
+		dappName: "AI Agent",
+		dappStatement: "An AI agent wants to send transactions on your behalf.",
+		domain: "ai.agent",
+		uri: "ai://agent",
+		icons: [],
+		chainId: 1
+	};
+}
+function serveSession(session) {
+	const server = createServer((socket) => {
+		let buf = "";
+		socket.on("data", async (chunk) => {
+			buf += chunk.toString();
+			const newline = buf.indexOf("\n");
+			if (newline === -1) return;
+			const line = buf.slice(0, newline);
+			buf = buf.slice(newline + 1);
+			let response;
+			try {
+				const parseResult = DaemonCmdSchema.safeParse(JSON.parse(line));
+				if (!parseResult.success) {
+					response = {
+						ok: false,
+						error: "InvalidCommand",
+						message: parseResult.error.message
+					};
+					socket.write(`${JSON.stringify(response)}\n`);
+					socket.end();
+					return;
+				}
+				const cmd = parseResult.data;
+				switch (cmd.cmd) {
+					case "status":
+						response = {
+							ok: true,
+							connected: true,
+							address: session.sessionClaims.address
+						};
+						break;
+					case "send": {
+						const valueHex = cmd.value ? `0x${parseUnits(cmd.value, 18).toString(16)}` : void 0;
+						const notification = cmd.notificationTitle && cmd.notificationBody ? {
+							title: cmd.notificationTitle,
+							body: cmd.notificationBody
+						} : void 0;
+						response = {
+							ok: true,
+							txHash: await session.request({
+								method: "eth_sendTransaction",
+								params: [{
+									to: cmd.to,
+									value: valueHex,
+									data: cmd.data ?? "0x",
+									chainId: cmd.chainId,
+									metadata: notification ? { notification } : void 0
+								}]
+							}),
+							to: cmd.to
+						};
+						break;
+					}
+					case "disconnect": {
+						const stored = loadSession();
+						if (stored) saveSession({ dappId: stored.dappId });
+						response = { ok: true };
+						socket.write(`${JSON.stringify(response)}\n`);
+						socket.end();
+						server.close();
+						if (existsSync(SOCKET_PATH)) unlinkSync(SOCKET_PATH);
+						if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
+						process.exit(0);
+					}
+				}
+			} catch (e) {
+				response = {
+					ok: false,
+					...toErrorPayload(e)
+				};
+			}
+			socket.write(`${JSON.stringify(response)}\n`);
+			socket.end();
+		});
+	});
+	server.listen(SOCKET_PATH, () => {
+		chmodSync(SOCKET_PATH, 384);
+	});
+}
+async function runDaemon() {
+	process.stdout.on("error", (err) => {
+		if (err.code !== "EPIPE") throw err;
+	});
+	const stored = loadSession();
+	const dappId = stored?.dappId ?? crypto.randomUUID();
+	const connection = await new BananalinkClient({ dapp: makeDapp(dappId) }).connect(stored?.accessToken ? { accessToken: stored.accessToken } : void 0);
+	if (!stored?.accessToken) {
+		emit({
+			type: "pending",
+			url: connection.connectionUrl
+		});
+		info("Waiting for wallet approval…");
+	}
+	const session = await connection.getSession();
+	saveSession({
+		dappId,
+		accessToken: session.sessionClaims.accessToken
+	});
+	mkdirSync(CONFIG_DIR, { recursive: true });
+	if (existsSync(SOCKET_PATH)) unlinkSync(SOCKET_PATH);
+	serveSession(session);
+	writeFileSync(PID_FILE, String(process.pid), { mode: 384 });
+	emit({
+		type: "connected",
+		ok: true,
+		address: session.sessionClaims.address
+	});
+}
+
+//#endregion
+//#region src/schemas/DisconnectResponseSchema.ts
+const DisconnectResponseSchema = z.object({ ok: z.literal(true) });
+
+//#endregion
+//#region src/schemas/ErrorResponseSchema.ts
+const ErrorResponseSchema = z.object({
+	ok: z.literal(false),
+	error: z.string(),
+	message: z.string()
+});
+
+//#endregion
+//#region src/schemas/NotConnectedResponseSchema.ts
+const NotConnectedResponseSchema = z.object({
+	ok: z.literal(true),
+	connected: z.literal(false)
+});
+
+//#endregion
+//#region src/schemas/SendResponseSchema.ts
+const SendResponseSchema = z.object({
+	ok: z.literal(true),
+	txHash: z.string(),
+	to: z.string()
+});
+
+//#endregion
+//#region src/schemas/StatusResponseSchema.ts
+const StatusResponseSchema = z.object({
+	ok: z.literal(true),
+	connected: z.literal(true),
+	address: z.string()
+});
+
+//#endregion
+//#region src/schemas/DaemonResponseSchema.ts
+const DaemonResponseSchema = z.union([
+	StatusResponseSchema,
+	NotConnectedResponseSchema,
+	SendResponseSchema,
+	DisconnectResponseSchema,
+	ErrorResponseSchema
+]);
+
+//#endregion
+//#region src/ipc/callDaemon.ts
+function callDaemon(command) {
+	return new Promise((resolve, reject) => {
+		const socket = createConnection(SOCKET_PATH);
+		let buf = "";
+		socket.on("connect", () => socket.write(`${JSON.stringify(command)}\n`));
+		socket.on("data", (chunk) => {
+			buf += chunk.toString();
+			const newline = buf.indexOf("\n");
+			if (newline !== -1) {
+				socket.destroy();
+				const data = JSON.parse(buf.slice(0, newline));
+				const result = DaemonResponseSchema.safeParse(data);
+				if (result.success) resolve(result.data);
+				else reject(/* @__PURE__ */ new Error("Unexpected daemon response"));
+			}
+		});
+		socket.on("error", reject);
+	});
+}
+
+//#endregion
+//#region src/ipc/isDaemonRunning.ts
+function isDaemonRunning() {
+	if (!existsSync(PID_FILE) || !existsSync(SOCKET_PATH)) return false;
+	try {
+		const pid = parseInt(readFileSync(PID_FILE, "utf8"), 10);
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* Bananalink Wallet CLI — for use by AI agents
+*
+* Commands:
+*   bananalink-wallet status
+*   bananalink-wallet connect
+*   bananalink-wallet send --to <address> --chain <name|id> --value <eth>
+*   bananalink-wallet disconnect
+*
+* Output: newline-delimited JSON on stdout.
+* Informational messages go to stderr.
+*/
+async function cmdStatus() {
+	if (!isDaemonRunning()) {
+		emit({
+			ok: true,
+			connected: false
+		});
+		return;
+	}
+	emit(await callDaemon({ cmd: "status" }));
+}
+async function cmdConnect() {
+	if (isDaemonRunning()) {
+		emit(await callDaemon({ cmd: "status" }));
+		return;
+	}
+	const [daemonBin, daemonScriptArgs] = process.argv[1].endsWith(".ts") ? ["tsx", [
+		process.argv[1],
+		"connect",
+		"--daemon"
+	]] : [process.execPath, [
+		process.argv[1],
+		"connect",
+		"--daemon"
+	]];
+	const daemon = spawn(daemonBin, daemonScriptArgs, {
+		detached: true,
+		stdio: [
+			"ignore",
+			"pipe",
+			"inherit"
+		]
+	});
+	daemon.unref();
+	let buf = "";
+	daemon.stdout?.on("data", (chunk) => {
+		buf += chunk.toString();
+		const lines = buf.split("\n");
+		buf = lines.pop() ?? "";
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			console.log(line);
+			try {
+				const msg = JSON.parse(line);
+				if (msg.type === "pending" || msg.type === "connected" || msg.ok === false) process.exit(msg.ok === false ? 1 : 0);
+			} catch {}
+		}
+	});
+	daemon.on("error", (err) => {
+		emit({
+			ok: false,
+			error: "DaemonError",
+			message: err.message
+		});
+		process.exit(1);
+	});
+	daemon.on("close", (code) => {
+		emit({
+			ok: false,
+			error: "DaemonError",
+			message: `Daemon exited with code ${code}`
+		});
+		process.exit(1);
+	});
+}
+async function cmdSend(opts) {
+	if (!isDaemonRunning()) throw new Error("No wallet connected. Run: bananalink-wallet connect");
+	emit(await callDaemon({
+		cmd: "send",
+		to: opts.to,
+		chainId: opts.chain,
+		value: opts.value,
+		data: opts.data,
+		notificationTitle: opts.notificationTitle,
+		notificationBody: opts.notificationBody
+	}));
+}
+async function cmdDisconnect() {
+	if (isDaemonRunning()) await callDaemon({ cmd: "disconnect" });
+	else {
+		const stored = loadSession();
+		if (stored) saveSession({ dappId: stored.dappId });
+	}
+	emit({ ok: true });
+}
+const program = new Command("bananalink-wallet").description("Manage wallet sessions and send onchain transactions").addHelpText("after", "\nOutput: newline-delimited JSON on stdout. Errors go to stderr.").exitOverride();
+program.command("status").description("Show the current wallet connection status").action(async () => {
+	await cmdStatus();
+});
+program.command("connect").description("Connect a wallet (spawns background daemon, exits after QR is ready)").option("--daemon", "Run as background daemon (internal use)").action(async (opts) => {
+	if (opts.daemon) await runDaemon();
+	else await cmdConnect();
+});
+program.command("send").description("Send a transaction via the connected wallet").requiredOption("--to <address>", "Recipient address").requiredOption("--chain <name|id>", "Chain to send on (e.g. base, ethereum, 137)").requiredOption("--value <eth>", "Amount in ETH (e.g. 0.01)").option("--data <hex>", "Optional calldata (hex)").option("--notification-title <text>", "Push notification title shown to the wallet user").option("--notification-body <text>", "Push notification body shown to the wallet user").action(async (opts) => {
+	resolveChain(opts.chain);
+	await cmdSend(opts);
+});
+program.command("disconnect").description("Disconnect the wallet and clear the session token").action(async () => {
+	await cmdDisconnect();
+});
+try {
+	await program.parseAsync(process.argv);
+} catch (e) {
+	if (e && typeof e === "object" && "code" in e && typeof e.code === "string") {
+		const code = e.code;
+		if (code === "commander.helpDisplayed" || code === "commander.version") process.exit(0);
+		if (code?.startsWith("commander.")) process.exit(1);
+	}
+	emit({
+		ok: false,
+		...toErrorPayload(e)
+	});
+	process.exit(1);
+}
+
+//#endregion
+export {  };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@bananalink-test/agent-wallet",
+  "version": "0.1.0",
+  "description": "CLI tool that gives AI agents onchain transaction capabilities via a Bananalink wallet",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "bananalink-wallet": "./dist/index.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.15",
+    "tsdown": "^0.20.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "commander": "^14.0.3",
+    "viem": "^2.47.2",
+    "zod": "^4.3.6",
+    "@bananalink-test/client": "0.9.5"
+  },
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "build": "tsdown",
+    "type-check": "tsc --noEmit",
+    "lint": "biome check ."
+  }
+}