spendos 0.1.0

package/acp-seller/config.json

@@ -0,0 +1,34 @@
+{
+  "SESSION_TOKEN": {
+    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOjIyMTA4NCwiaWF0IjoxNzc1MzI5NzgxLCJleHAiOjE3NzUzMzE1ODF9.EwIOdP25HzmHqXcBUaBQFT6SuD_F1cJ01iSONvgRVvQ"
+  },
+  "agents": [
+    {
+      "id": 24346,
+      "name": "sigilx",
+      "walletAddress": "0xC643569c6e08A56740aD1B3EE884dce334418737",
+      "active": false
+    },
+    {
+      "id": 34005,
+      "name": "sandbox-agent-0",
+      "walletAddress": "0xCd07e40729aba5DD3336Aa4Dfd0e6eb6257EC7Ab",
+      "active": false
+    },
+    {
+      "id": 41550,
+      "name": "Signal Sink",
+      "walletAddress": "0xaD2dd9E11E5B281ACb2a7b9Fb7E6c116A17FBE8f",
+      "active": false
+    },
+    {
+      "id": 41754,
+      "name": "spendos",
+      "walletAddress": "0xAa79D5240F736E2176a925179403e25D0A94756d",
+      "apiKey": "acp-1e9eaea050d72b42d42c",
+      "active": true
+    }
+  ],
+  "LITE_AGENT_API_KEY": "acp-1e9eaea050d72b42d42c",
+  "SELLER_PID": 93548
+}

package/acp-seller/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@agent-pulse/acp-seller",
+  "version": "0.3.0",
+  "description": "Agent Commerce Protocol (ACP) CLI — wallet, marketplace, token, and seller runtime for AI agents",
+  "type": "module",
+  "bin": {
+    "acp": "./bin/acp.ts"
+  },
+  "scripts": {
+    "start": "tsx src/seller/runtime/seller.ts",
+    "acp": "tsx bin/acp.ts",
+    "setup": "tsx bin/acp.ts setup",
+    "offering:create": "tsx bin/acp.ts sell create",
+    "offering:delete": "tsx bin/acp.ts sell delete",
+    "resource:create": "tsx bin/acp.ts sell resource create",
+    "resource:delete": "tsx bin/acp.ts sell resource delete",
+    "seller:run": "tsx bin/acp.ts serve start",
+    "seller:stop": "tsx bin/acp.ts serve stop",
+    "seller:check": "tsx bin/acp.ts serve status",
+    "build": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepare": "husky",
+    "test": "node ./scripts/run-node-tests.mjs",
+    "test:cert": "vitest run --config vitest.cert.config.ts",
+    "test:watch": "vitest",
+    "test:vitest": "vitest run",
+    "preflight": "tsx scripts/validate-offerings-preflight.ts",
+    "preflight:strict": "tsx scripts/validate-offerings-preflight.ts --strict"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.96.0",
+    "axios": "^1.13.4",
+    "dotenv": "^16.4.5",
+    "socket.io-client": "^4.8.1",
+    "tsx": "^4.19.2",
+    "viem": "^2.45.1",
+    "@agent-pulse/compute-modal": "workspace:*",
+    "@agent-pulse/training-prime": "workspace:*",
+    "@agent-pulse/telemetry-wandb": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "prettier": "^3.4.2",
+    "typescript": "^5.7.2",
+    "vitest": "^4.0.18"
+  },
+  "lint-staged": {
+    "*.{ts,tsx,js,jsx,json,md}": "prettier --write"
+  }
+}

package/acp-seller/src/commands/agent.ts

@@ -0,0 +1,328 @@
+// =============================================================================
+// acp agent list    — Show all agents (fetches from server, auto-login if needed)
+// acp agent switch  — Switch active agent (auto-login if needed)
+// acp agent create  — Create a new agent (auto-login if needed)
+// =============================================================================
+
+import readline from "readline";
+import * as output from "../lib/output.js";
+import {
+  readConfig,
+  writeConfig,
+  getActiveAgent,
+  findAgentByName,
+  activateAgent,
+  findSellerPid,
+  isProcessRunning,
+  removePidFromConfig,
+  type AgentEntry,
+  findAgentByWalletAddress,
+} from "../lib/config.js";
+import {
+  ensureSession,
+  fetchAgents,
+  createAgentApi,
+  regenerateApiKey,
+  syncAgentsToConfig,
+  isAgentApiKeyValid,
+} from "../lib/auth.js";
+
+function redactApiKey(key: string | undefined): string {
+  if (!key || key.length < 8) return "(not available)";
+  return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}
+
+function confirmPrompt(prompt: string): Promise<boolean> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      resolve(a === "y" || a === "yes" || a === "");
+    });
+  });
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function killSellerProcess(pid: number): Promise<boolean> {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  // Wait up to 2 seconds for process to stop without blocking the event loop
+  for (let i = 0; i < 10; i++) {
+    await sleep(200);
+    if (!isProcessRunning(pid)) {
+      removePidFromConfig();
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if seller runtime is running. If so, warn the user and ask for
+ * confirmation to stop it. Returns true if it's safe to proceed (no seller
+ * running, or seller was stopped). Returns false if the user cancelled.
+ * Calls output.fatal (exits) if the seller could not be killed.
+ */
+export async function stopSellerIfRunning(): Promise<boolean> {
+  const sellerPid = findSellerPid();
+  if (sellerPid === undefined) return true;
+
+  const active = getActiveAgent();
+  const activeName = active ? `"${active.name}"` : "the current agent";
+
+  let offeringNames: string[] = [];
+  try {
+    const { getMyAgentInfo } = await import("../lib/wallet.js");
+    const info = await getMyAgentInfo();
+    offeringNames = (info.jobs ?? []).map((j: any) => j.name);
+  } catch {
+    // Non-fatal — just won't show offering names
+  }
+
+  const offeringsLine =
+    offeringNames.length > 0
+      ? `\n  Active Job Offerings being served: ${offeringNames.join(", ")}\n`
+      : "";
+  output.warn(
+    `Seller runtime process is running (PID ${sellerPid}) for ${activeName}. ` +
+      `It must be stopped before switching agents, because the runtime ` +
+      `is tied to the current agent's API key.${offeringsLine}\n`,
+  );
+  const ok = await confirmPrompt(
+    "  Stop the seller runtime process and continue? (Y/n): ",
+  );
+  if (!ok) {
+    return false;
+  }
+  output.log(`  Stopping seller runtime (PID ${sellerPid})...`);
+  const stopped = await killSellerProcess(sellerPid);
+  if (stopped) {
+    output.log(`  Seller runtime stopped.\n`);
+    return true;
+  }
+  output.fatal(
+    `Could not stop seller process (PID ${sellerPid}). Try: kill -9 ${sellerPid}`,
+  );
+  return false; // unreachable (fatal exits), but satisfies TS
+}
+
+function displayAgents(agents: AgentEntry[]): void {
+  output.heading("Agents");
+  for (const a of agents) {
+    const marker = a.active ? output.colors.green(" (active)") : "";
+    output.log(`  ${output.colors.bold(a.name)}${marker}`);
+    output.log(`    ${output.colors.dim("Wallet")}  ${a.walletAddress}`);
+    if (a.apiKey) {
+      output.log(
+        `    ${output.colors.dim("API Key")} ${redactApiKey(a.apiKey)}`,
+      );
+    }
+    output.log("");
+  }
+}
+
+export async function list(): Promise<void> {
+  const sessionToken = await ensureSession();
+  let agents: AgentEntry[];
+
+  try {
+    const serverAgents = await fetchAgents(sessionToken);
+    agents = syncAgentsToConfig(serverAgents);
+  } catch (e) {
+    output.warn(
+      `Could not fetch agents from server: ${e instanceof Error ? e.message : String(e)}`,
+    );
+    output.log("  Showing locally saved agents.\n");
+    agents = readConfig().agents ?? [];
+  }
+
+  if (agents.length === 0) {
+    output.output({ agents: [] }, () => {
+      output.log(
+        "  No agents found. Run `acp agent create <name>` to create one.\n",
+      );
+    });
+    return;
+  }
+
+  output.output(
+    agents.map((a) => ({
+      name: a.name,
+      id: a.id,
+      walletAddress: a.walletAddress,
+      active: a.active,
+    })),
+    () => displayAgents(agents),
+  );
+}
+
+export async function switchAgentByName(name: string): Promise<void> {
+  const target = findAgentByName(name);
+  if (!target) {
+    output.fatal(`Agent "${name}" not found. Run \`acp agent list\` first.`);
+  }
+
+  const agents = readConfig().agents ?? [];
+  const matchingAgents = agents.filter(
+    (a) => a.name.toLowerCase() === name.toLowerCase(),
+  );
+  if (matchingAgents.length > 1) {
+    output.fatal(
+      `Multiple agents with name "${name}".\nAvailable: ${matchingAgents
+        .map((a) => `${a.name} (${a.walletAddress})`)
+        .join(
+          ", ",
+        )}.\nRun \`acp agent switch --wallet <walletAddress>\` to switch to one of them.`,
+    );
+  }
+
+  return await switchAgent(target.walletAddress);
+}
+
+export async function switchAgent(walletAddress: string): Promise<void> {
+  if (!walletAddress) {
+    output.fatal("Usage: acp agent switch <walletAddress>");
+  }
+
+  const target = findAgentByWalletAddress(walletAddress);
+  if (!target) {
+    const config = readConfig();
+    const agentList = (config.agents ?? [])
+      .map((a) => `${a.name} (${a.walletAddress})`)
+      .join(", ");
+    output.fatal(
+      `Agent "${walletAddress}" not found. Run \`acp agent list\` first. Available: ${
+        agentList || "(none)"
+      }`,
+    );
+  }
+
+  if (target.active) {
+    output.log(`  Agent ${target.name} is already active.\n`);
+    return;
+  }
+
+  // Stop seller runtime if running (API key will change)
+  const proceed = await stopSellerIfRunning();
+  if (!proceed) {
+    output.log("  Agent switch cancelled.\n");
+    throw new Error("Agent switch cancelled");
+  }
+
+  const sessionToken = await ensureSession();
+
+  output.log(`  Switching to ${target.name}...\n`);
+  try {
+    let apiKey: string = "";
+    let valid = false;
+
+    if (target.apiKey) {
+      valid = await isAgentApiKeyValid(target.apiKey);
+      if (valid) {
+        apiKey = target.apiKey;
+      }
+    }
+
+    if (!valid) {
+      const result = await regenerateApiKey(sessionToken, target.walletAddress);
+      apiKey = result.apiKey;
+    }
+
+    if (!apiKey) {
+      output.fatal("Failed to switch agent — no API key returned.");
+    }
+
+    activateAgent(target.id, apiKey);
+
+    output.output(
+      {
+        switched: true,
+        name: target.name,
+        walletAddress: target.walletAddress,
+      },
+      () => {
+        output.success(`Switched to agent: ${target.name}`);
+        output.log(`    Wallet:  ${target.walletAddress}`);
+      },
+    );
+  } catch (e) {
+    output.fatal(
+      `Failed to switch agent: ${e instanceof Error ? e.message : String(e)}`,
+    );
+  }
+}
+
+export async function create(name: string): Promise<void> {
+  if (!name) {
+    output.fatal("Usage: acp agent create <name>");
+  }
+
+  // Stop seller runtime if running (API key will change)
+  const proceed = await stopSellerIfRunning();
+  if (!proceed) {
+    output.log("  Agent creation cancelled.\n");
+    return;
+  }
+
+  const sessionToken = await ensureSession();
+
+  try {
+    const result = await createAgentApi(sessionToken, name);
+    if (!result?.apiKey) {
+      output.fatal("Create agent failed — no API key returned.");
+    }
+
+    // Add to local config and activate
+    const config = readConfig();
+    const updatedAgents = (config.agents ?? []).map((a) => ({
+      ...a,
+      active: false,
+      apiKey: undefined, // clear other agents' keys
+    })) as AgentEntry[];
+
+    const newAgent: AgentEntry = {
+      id: result.id,
+      name: result.name || name,
+      walletAddress: result.walletAddress,
+      apiKey: result.apiKey,
+      active: true,
+    };
+    updatedAgents.push(newAgent);
+
+    writeConfig({
+      ...config,
+      LITE_AGENT_API_KEY: result.apiKey,
+      agents: updatedAgents,
+    });
+
+    output.output(
+      {
+        created: true,
+        name: newAgent.name,
+        id: newAgent.id,
+        walletAddress: newAgent.walletAddress,
+      },
+      () => {
+        output.success(`Agent created: ${newAgent.name}`);
+        output.log(`    Wallet:  ${newAgent.walletAddress}`);
+        output.log(
+          `    API Key: ${redactApiKey(newAgent.apiKey)} (saved to config.json)\n`,
+        );
+      },
+    );
+  } catch (e) {
+    output.fatal(
+      `Create agent failed: ${e instanceof Error ? e.message : String(e)}`,
+    );
+  }
+}