create-sati-agent 0.1.0 → 0.1.1

package/dist/bin/cli.js

@@ -1,5 +1,755 @@
 #!/usr/bin/env node
-import { run } from "@stricli/core";
-import { app } from "../app.js";
-import { buildContext } from "../context.js";
+import { buildApplication, buildCommand, buildRouteMap, numberParser, run } from "@stricli/core";
+import { cancel, intro, isCancel, log, outro, select, spinner, text } from "@clack/prompts";
+import pc from "picocolors";
+
+//#region src/lib/api.ts
+const DEFAULT_BASE_URL = "https://sati.cascade.fyi";
+var PaymentRequiredError = class extends Error {
+	constructor(paymentHeaders, body) {
+		super("Payment required ($0.30 USDC)");
+		this.paymentHeaders = paymentHeaders;
+		this.body = body;
+	}
+};
+var ApiError = class extends Error {
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+	}
+};
+var SatiApiClient = class {
+	baseUrl;
+	constructor(baseUrl) {
+		this.baseUrl = baseUrl ?? process.env.SATI_API_URL ?? DEFAULT_BASE_URL;
+	}
+	async register(data, paymentHeader) {
+		const url = `${this.baseUrl}/api/register`;
+		const awUrl = process.env.AGENT_WALLET_URL;
+		const awUsername = process.env.AGENT_WALLET_USERNAME;
+		if (awUrl && awUsername) {
+			const proxyUrl = `${awUrl}/api/wallets/${awUsername}/actions/x402/fetch`;
+			const res = await fetch(proxyUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					url,
+					method: "POST",
+					body: data,
+					preferredChain: "solana"
+				})
+			});
+			if (!res.ok) {
+				const body = await res.json().catch(() => ({}));
+				throw new ApiError(res.status, body.error ?? "AgentWallet proxy request failed");
+			}
+			const json = await res.json();
+			return json.response?.body ?? json;
+		}
+		const headers = { "Content-Type": "application/json" };
+		if (paymentHeader) headers["X-PAYMENT"] = paymentHeader;
+		const res = await fetch(url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(data)
+		});
+		if (res.status === 402) {
+			const paymentHeaders = {};
+			for (const [key, value] of res.headers.entries()) paymentHeaders[key] = value;
+			throw new PaymentRequiredError(paymentHeaders, await res.text());
+		}
+		if (!res.ok) {
+			const body = await res.json().catch(() => ({}));
+			throw new ApiError(res.status, body.error ?? `Request failed (${res.status})`);
+		}
+		return res.json();
+	}
+	async listAgents(opts) {
+		const params = new URLSearchParams();
+		params.set("network", opts?.network ?? "mainnet");
+		if (opts?.name) params.set("name", opts.name);
+		if (opts?.owner) params.set("owner", opts.owner);
+		if (opts?.limit) params.set("limit", String(opts.limit));
+		const res = await fetch(`${this.baseUrl}/api/agents?${params}`);
+		if (!res.ok) {
+			const body = await res.json().catch(() => ({}));
+			throw new ApiError(res.status, body.error ?? "Failed to list agents");
+		}
+		return res.json();
+	}
+	async getAgent(mint, network = "mainnet") {
+		const res = await fetch(`${this.baseUrl}/api/agents/${mint}?network=${network}`);
+		if (!res.ok) {
+			const body = await res.json().catch(() => ({}));
+			throw new ApiError(res.status, body.error ?? "Failed to load agent");
+		}
+		return res.json();
+	}
+	async submitFeedback(data) {
+		const res = await fetch(`${this.baseUrl}/api/feedback`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(data)
+		});
+		if (!res.ok) {
+			const body = await res.json().catch(() => ({}));
+			throw new ApiError(res.status, body.error ?? "Failed to submit feedback");
+		}
+		return res.json();
+	}
+	async listFeedback(mint, opts) {
+		const params = new URLSearchParams();
+		params.set("network", opts?.network ?? "mainnet");
+		if (opts?.clientAddress) params.set("clientAddress", opts.clientAddress);
+		if (opts?.tag1) params.set("tag1", opts.tag1);
+		if (opts?.tag2) params.set("tag2", opts.tag2);
+		const res = await fetch(`${this.baseUrl}/api/feedback/${mint}?${params}`);
+		if (!res.ok) {
+			const body = await res.json().catch(() => ({}));
+			throw new ApiError(res.status, body.error ?? "Failed to list feedback");
+		}
+		return res.json();
+	}
+	async getReputation(mint, opts) {
+		const params = new URLSearchParams();
+		params.set("network", opts?.network ?? "mainnet");
+		if (opts?.tag1) params.set("tag1", opts.tag1);
+		if (opts?.tag2) params.set("tag2", opts.tag2);
+		const res = await fetch(`${this.baseUrl}/api/reputation/${mint}?${params}`);
+		if (!res.ok) {
+			const body = await res.json().catch(() => ({}));
+			throw new ApiError(res.status, body.error ?? "Failed to get reputation");
+		}
+		return res.json();
+	}
+};
+
+//#endregion
+//#region src/lib/format.ts
+function truncateAddress(addr, len = 4) {
+	if (addr.length <= len * 2 + 3) return addr;
+	return `${addr.slice(0, len)}...${addr.slice(-len)}`;
+}
+function formatAgent(agent) {
+	const lines = [];
+	lines.push(`${pc.bold(agent.name)} ${pc.dim(`#${agent.memberNumber}`)}`);
+	lines.push(`  ${pc.dim("Mint:")}    ${pc.cyan(agent.mint)}`);
+	lines.push(`  ${pc.dim("Owner:")}   ${agent.owner}`);
+	lines.push(`  ${pc.dim("Status:")}  ${agent.active ? pc.green("active") : pc.red("inactive")}`);
+	if (agent.description) lines.push(`  ${pc.dim("About:")}   ${agent.description}`);
+	if (agent.services?.length) {
+		const serviceNames = agent.services.map((s) => s.name).join(", ");
+		lines.push(`  ${pc.dim("Services:")} ${serviceNames}`);
+		for (const svc of agent.services) lines.push(`    ${pc.dim("-")} ${svc.name}: ${pc.blue(svc.endpoint)}${svc.version ? pc.dim(` v${svc.version}`) : ""}`);
+	}
+	if (agent.reputation) {
+		lines.push("");
+		lines.push(`  ${pc.dim("Reputation:")}`);
+		lines.push(`    ${formatReputation(agent.reputation)}`);
+	}
+	if (agent.uri) lines.push(`  ${pc.dim("URI:")}    ${agent.uri}`);
+	return lines.join("\n");
+}
+function formatAgentList(agents) {
+	if (agents.length === 0) return pc.dim("  No agents found");
+	const lines = [];
+	for (const [i, agent] of agents.entries()) {
+		const num = pc.dim(`${String(i + 1).padStart(3)}.`);
+		const name = pc.bold(agent.name);
+		const mint = pc.cyan(truncateAddress(agent.mint, 6));
+		const owner = truncateAddress(agent.owner, 4);
+		const services = agent.services?.length ? agent.services.map((s) => s.name).join(", ") : pc.dim("none");
+		lines.push(`${num} ${name}`);
+		lines.push(`     ${pc.dim("Mint:")} ${mint}  ${pc.dim("Owner:")} ${owner}  ${pc.dim("Services:")} ${services}`);
+		if (agent.description) {
+			const desc = agent.description.length > 80 ? `${agent.description.slice(0, 77)}...` : agent.description;
+			lines.push(`     ${pc.dim(desc)}`);
+		}
+	}
+	return lines.join("\n");
+}
+function formatReputation(rep) {
+	if (rep.count === 0) return pc.dim("No feedback yet");
+	return `${pc.bold(String(rep.summaryValue))}/100 from ${rep.count} review${rep.count === 1 ? "" : "s"}`;
+}
+function formatRegistration(result) {
+	const lines = [];
+	lines.push(`  ${pc.dim("Mint:")}     ${pc.green(result.mint)}`);
+	lines.push(`  ${pc.dim("Agent ID:")} ${result.agentId}`);
+	lines.push(`  ${pc.dim("Member:")}   #${result.memberNumber}`);
+	lines.push(`  ${pc.dim("IPFS:")}     ${result.uri}`);
+	lines.push(`  ${pc.dim("Tx:")}       ${result.signature}`);
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/commands/register.ts
+const registerCommand = buildCommand({
+	docs: { brief: "Register a new AI agent on-chain ($0.30 USDC via x402)" },
+	parameters: {
+		flags: {
+			name: {
+				kind: "parsed",
+				parse: String,
+				brief: "Agent name (max 32 chars)",
+				optional: true
+			},
+			description: {
+				kind: "parsed",
+				parse: String,
+				brief: "What the agent does",
+				optional: true
+			},
+			image: {
+				kind: "parsed",
+				parse: String,
+				brief: "Avatar image URL",
+				optional: true
+			},
+			owner: {
+				kind: "parsed",
+				parse: String,
+				brief: "Solana wallet address (NFT minted to this address)",
+				optional: true
+			},
+			mcpEndpoint: {
+				kind: "parsed",
+				parse: String,
+				brief: "MCP server endpoint URL",
+				optional: true
+			},
+			a2aEndpoint: {
+				kind: "parsed",
+				parse: String,
+				brief: "A2A endpoint URL",
+				optional: true
+			},
+			network: {
+				kind: "enum",
+				values: ["devnet", "mainnet"],
+				brief: "Solana network",
+				default: "mainnet"
+			},
+			paymentHeader: {
+				kind: "parsed",
+				parse: String,
+				brief: "Pre-computed x402 payment header",
+				optional: true
+			},
+			json: {
+				kind: "boolean",
+				brief: "Output raw JSON",
+				optional: true
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: []
+		}
+	},
+	async func(flags) {
+		const isJson = flags.json;
+		if (!isJson) {
+			intro(pc.cyan("SATI - Register Agent"));
+			log.info("Registration costs $0.30 USDC via x402 protocol");
+		}
+		let name = flags.name;
+		let description = flags.description;
+		let image = flags.image;
+		let owner = flags.owner;
+		if (!name) {
+			const result = await text({
+				message: "Agent name:",
+				validate: (v) => {
+					if (!v.trim()) return "Name is required";
+					if (new TextEncoder().encode(v).length > 32) return "Max 32 bytes";
+				}
+			});
+			if (isCancel(result)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			name = result;
+		}
+		if (!description) {
+			const result = await text({
+				message: "Description:",
+				validate: (v) => !v.trim() ? "Description is required" : void 0
+			});
+			if (isCancel(result)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			description = result;
+		}
+		if (!image) {
+			const result = await text({
+				message: "Avatar image URL:",
+				validate: (v) => !v.trim() ? "Image URL is required" : void 0
+			});
+			if (isCancel(result)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			image = result;
+		}
+		if (!owner) {
+			const result = await text({
+				message: "Solana wallet address (NFT owner):",
+				validate: (v) => v.length < 32 ? "Must be a valid Solana address" : void 0
+			});
+			if (isCancel(result)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			owner = result;
+		}
+		const services = [];
+		if (flags.mcpEndpoint) services.push({
+			name: "MCP",
+			endpoint: flags.mcpEndpoint,
+			version: "2025-06-18"
+		});
+		if (flags.a2aEndpoint) services.push({
+			name: "A2A",
+			endpoint: flags.a2aEndpoint
+		});
+		if (!flags.mcpEndpoint && !flags.a2aEndpoint && !isJson) {
+			const mcpResult = await text({ message: "MCP endpoint (leave empty to skip):" });
+			if (isCancel(mcpResult)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			if (mcpResult.trim()) services.push({
+				name: "MCP",
+				endpoint: mcpResult.trim(),
+				version: "2025-06-18"
+			});
+		}
+		const s = !isJson ? spinner() : null;
+		s?.start("Registering agent on Solana...");
+		try {
+			const result = await new SatiApiClient().register({
+				name,
+				description,
+				image,
+				ownerAddress: owner,
+				services: services.length > 0 ? services : void 0,
+				active: true,
+				supportedTrust: ["reputation"],
+				network: flags.network
+			}, flags.paymentHeader);
+			if (isJson) {
+				console.log(JSON.stringify(result, null, 2));
+				return;
+			}
+			s?.stop(pc.green("Agent registered!"));
+			console.log();
+			console.log(formatRegistration(result));
+			console.log();
+			outro(pc.dim("Your agent identity is now on Solana"));
+		} catch (error) {
+			s?.stop(pc.red("Registration failed"));
+			if (error instanceof PaymentRequiredError) {
+				log.warn("Registration requires x402 payment ($0.30 USDC on Solana)");
+				console.log();
+				console.log(pc.bold("  How to pay:"));
+				console.log();
+				console.log(`  ${pc.dim("1.")} Set up AgentWallet (recommended for agents):`);
+				console.log(`     Set AGENT_WALLET_URL and AGENT_WALLET_USERNAME env vars`);
+				console.log(`     ${pc.dim("See:")} https://agentwallet.mcpay.tech/skill.md`);
+				console.log();
+				console.log(`  ${pc.dim("2.")} Provide a pre-computed payment header:`);
+				console.log(`     create-sati-agent register --payment-header "<header>"`);
+				console.log();
+				return;
+			}
+			throw error;
+		}
+	}
+});
+
+//#endregion
+//#region src/commands/discover.ts
+const discoverCommand = buildCommand({
+	docs: { brief: "Search and list registered agents" },
+	parameters: {
+		flags: {
+			name: {
+				kind: "parsed",
+				parse: String,
+				brief: "Filter agents by name",
+				optional: true
+			},
+			owner: {
+				kind: "parsed",
+				parse: String,
+				brief: "Filter by owner wallet address",
+				optional: true
+			},
+			limit: {
+				kind: "parsed",
+				parse: numberParser,
+				brief: "Max results (1-50)",
+				optional: true
+			},
+			network: {
+				kind: "enum",
+				values: ["devnet", "mainnet"],
+				brief: "Solana network",
+				default: "mainnet"
+			},
+			json: {
+				kind: "boolean",
+				brief: "Output raw JSON",
+				optional: true
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: []
+		}
+	},
+	async func(flags) {
+		if (flags.json) {
+			const result = await new SatiApiClient().listAgents({
+				name: flags.name,
+				owner: flags.owner,
+				limit: flags.limit,
+				network: flags.network
+			});
+			console.log(JSON.stringify(result, null, 2));
+			return;
+		}
+		intro(pc.cyan("SATI - Discover Agents"));
+		const s = spinner();
+		s.start("Searching agents...");
+		try {
+			const result = await new SatiApiClient().listAgents({
+				name: flags.name,
+				owner: flags.owner,
+				limit: flags.limit,
+				network: flags.network
+			});
+			s.stop(`Found ${result.count} agent(s) on ${flags.network}`);
+			console.log();
+			console.log(formatAgentList(result.agents));
+			console.log();
+			outro(pc.dim("Use 'create-sati-agent info <mint>' for details"));
+		} catch (error) {
+			s.stop(pc.red("Failed"));
+			throw error;
+		}
+	}
+});
+
+//#endregion
+//#region src/commands/info.ts
+const infoCommand = buildCommand({
+	docs: { brief: "Get detailed agent information and reputation" },
+	parameters: {
+		flags: {
+			network: {
+				kind: "enum",
+				values: ["devnet", "mainnet"],
+				brief: "Solana network",
+				default: "mainnet"
+			},
+			json: {
+				kind: "boolean",
+				brief: "Output raw JSON",
+				optional: true
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Agent mint address",
+				parse: String,
+				placeholder: "mint"
+			}]
+		}
+	},
+	async func(flags, mint) {
+		if (flags.json) {
+			const agent = await new SatiApiClient().getAgent(mint, flags.network);
+			console.log(JSON.stringify(agent, null, 2));
+			return;
+		}
+		intro(pc.cyan("SATI - Agent Info"));
+		const s = spinner();
+		s.start("Loading agent...");
+		try {
+			const agent = await new SatiApiClient().getAgent(mint, flags.network);
+			s.stop("Agent loaded");
+			console.log();
+			console.log(formatAgent(agent));
+			console.log();
+			outro(pc.dim(`Network: ${flags.network}`));
+		} catch (error) {
+			s.stop(pc.red("Failed"));
+			throw error;
+		}
+	}
+});
+
+//#endregion
+//#region src/commands/feedback.ts
+const feedbackCommand = buildCommand({
+	docs: { brief: "Give feedback on an agent (free, recorded on-chain)" },
+	parameters: {
+		flags: {
+			agent: {
+				kind: "parsed",
+				parse: String,
+				brief: "Agent mint address to review",
+				optional: true
+			},
+			value: {
+				kind: "parsed",
+				parse: numberParser,
+				brief: "Score value",
+				optional: true
+			},
+			valueDecimals: {
+				kind: "parsed",
+				parse: numberParser,
+				brief: "Decimal places for value",
+				optional: true
+			},
+			tag1: {
+				kind: "parsed",
+				parse: String,
+				brief: "Primary dimension (starred, reachable, uptime, etc.)",
+				optional: true
+			},
+			tag2: {
+				kind: "parsed",
+				parse: String,
+				brief: "Secondary dimension",
+				optional: true
+			},
+			endpoint: {
+				kind: "parsed",
+				parse: String,
+				brief: "Specific service endpoint being reviewed",
+				optional: true
+			},
+			reviewer: {
+				kind: "parsed",
+				parse: String,
+				brief: "Your Solana address (for attribution)",
+				optional: true
+			},
+			network: {
+				kind: "enum",
+				values: ["devnet", "mainnet"],
+				brief: "Solana network",
+				default: "mainnet"
+			},
+			json: {
+				kind: "boolean",
+				brief: "Output raw JSON",
+				optional: true
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: []
+		}
+	},
+	async func(flags) {
+		const isJson = flags.json;
+		if (!isJson) intro(pc.cyan("SATI - Give Feedback"));
+		let agentMint = flags.agent;
+		let value = flags.value;
+		let tag1 = flags.tag1;
+		if (!agentMint) {
+			const result = await text({
+				message: "Agent mint address:",
+				validate: (v) => v.length < 32 ? "Must be a valid Solana address" : void 0
+			});
+			if (isCancel(result)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			agentMint = result;
+		}
+		if (!tag1) {
+			const result = await select({
+				message: "Feedback category:",
+				options: [
+					{
+						value: "starred",
+						label: "Overall Rating (0-100)"
+					},
+					{
+						value: "reachable",
+						label: "Reachability (0 or 1)"
+					},
+					{
+						value: "uptime",
+						label: "Uptime %"
+					},
+					{
+						value: "responseTime",
+						label: "Response Time (ms)"
+					},
+					{
+						value: "successRate",
+						label: "Success Rate %"
+					}
+				]
+			});
+			if (isCancel(result)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			tag1 = result;
+		}
+		if (value === void 0) {
+			const result = await text({
+				message: "Value:",
+				validate: (v) => {
+					const n = Number(v);
+					return Number.isNaN(n) ? "Must be a number" : void 0;
+				}
+			});
+			if (isCancel(result)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			value = Number(result);
+		}
+		const s = !isJson ? spinner() : null;
+		s?.start("Submitting feedback on-chain...");
+		try {
+			const result = await new SatiApiClient().submitFeedback({
+				agentMint,
+				value,
+				valueDecimals: flags.valueDecimals,
+				tag1,
+				tag2: flags.tag2,
+				endpoint: flags.endpoint,
+				reviewerAddress: flags.reviewer,
+				network: flags.network
+			});
+			if (isJson) {
+				console.log(JSON.stringify(result, null, 2));
+				return;
+			}
+			s?.stop(pc.green("Feedback submitted!"));
+			console.log();
+			console.log(`  ${pc.dim("Tx:")}          ${result.txSignature}`);
+			console.log(`  ${pc.dim("Attestation:")} ${result.attestationAddress}`);
+			console.log();
+			outro(pc.dim("Feedback recorded on Solana"));
+		} catch (error) {
+			s?.stop(pc.red("Failed"));
+			throw error;
+		}
+	}
+});
+
+//#endregion
+//#region src/commands/reputation.ts
+const reputationCommand = buildCommand({
+	docs: { brief: "Get reputation summary for an agent" },
+	parameters: {
+		flags: {
+			tag1: {
+				kind: "parsed",
+				parse: String,
+				brief: "Filter by primary tag (starred, reachable, uptime, etc.)",
+				optional: true
+			},
+			tag2: {
+				kind: "parsed",
+				parse: String,
+				brief: "Filter by secondary tag",
+				optional: true
+			},
+			network: {
+				kind: "enum",
+				values: ["devnet", "mainnet"],
+				brief: "Solana network",
+				default: "mainnet"
+			},
+			json: {
+				kind: "boolean",
+				brief: "Output raw JSON",
+				optional: true
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Agent mint address",
+				parse: String,
+				placeholder: "mint"
+			}]
+		}
+	},
+	async func(flags, mint) {
+		if (flags.json) {
+			const rep = await new SatiApiClient().getReputation(mint, {
+				tag1: flags.tag1,
+				tag2: flags.tag2,
+				network: flags.network
+			});
+			console.log(JSON.stringify(rep, null, 2));
+			return;
+		}
+		intro(pc.cyan("SATI - Reputation"));
+		const s = spinner();
+		s.start("Fetching reputation...");
+		try {
+			const rep = await new SatiApiClient().getReputation(mint, {
+				tag1: flags.tag1,
+				tag2: flags.tag2,
+				network: flags.network
+			});
+			s.stop("Reputation loaded");
+			console.log();
+			console.log(`  ${pc.dim("Agent:")} ${truncateAddress(mint, 6)}`);
+			console.log(`  ${pc.dim("Score:")} ${formatReputation(rep)}`);
+			if (flags.tag1) console.log(`  ${pc.dim("Tag:")}   ${flags.tag1}`);
+			console.log();
+			outro(pc.dim(`Network: ${flags.network}`));
+		} catch (error) {
+			s.stop(pc.red("Failed"));
+			throw error;
+		}
+	}
+});
+
+//#endregion
+//#region src/app.ts
+const routes = buildRouteMap({
+	routes: {
+		register: registerCommand,
+		discover: discoverCommand,
+		info: infoCommand,
+		feedback: feedbackCommand,
+		reputation: reputationCommand
+	},
+	docs: { brief: "On-chain identity for AI agents on Solana" }
+});
+const app = buildApplication(routes, {
+	name: "create-sati-agent",
+	versionInfo: { currentVersion: "0.1.1" },
+	scanner: { caseStyle: "allow-kebab-for-camel" }
+});
+
+//#endregion
+//#region src/context.ts
+function buildContext(process) {
+	return { process };
+}
+
+//#endregion
+//#region src/bin/cli.ts
 await run(app, process.argv.slice(2), buildContext(process));
+
+//#endregion
+export {  };