spendos 0.1.0

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

@@ -0,0 +1,414 @@
+// =============================================================================
+// acp serve deploy railway            — Deploy current agent to Railway
+// acp serve deploy railway setup      — Create Railway project for current agent
+// acp serve deploy railway status     — Show current agent's deployment status
+// acp serve deploy railway logs       — Show current agent's deployment logs
+// acp serve deploy railway teardown   — Remove current agent's deployment
+// acp serve deploy railway env        — List env vars on current agent's project
+// acp serve deploy railway env set    — Set an env var
+// acp serve deploy railway env delete — Remove an env var
+//
+// Each agent gets its own Railway project. Switching agents and deploying
+// creates a separate instance — both keep running independently.
+// =============================================================================
+
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import readline from "readline";
+import * as output from "../lib/output.js";
+import {
+  readConfig,
+  writeConfig,
+  getActiveAgent,
+  sanitizeAgentName,
+  ROOT,
+} from "../lib/config.js";
+import type { DeployInfo, AgentEntry } from "../lib/config.js";
+import { generateDockerfile, generateDockerignore } from "../deploy/docker.js";
+import * as railway from "../deploy/railway.js";
+import type { LogFilter } from "../deploy/railway.js";
+
+const DOCKERFILE_PATH = path.resolve(ROOT, "Dockerfile");
+const DOCKERIGNORE_PATH = path.resolve(ROOT, ".dockerignore");
+
+function getOfferingsRoot(agentName: string): string {
+  return path.resolve(
+    ROOT,
+    "src",
+    "seller",
+    "offerings",
+    sanitizeAgentName(agentName),
+  );
+}
+
+// -- Helpers --
+
+function prompt(question: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) =>
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    }),
+  );
+}
+
+function installRailwayCli(): void {
+  output.log("  Installing Railway CLI...\n");
+  execSync("npm install -g @railway/cli", {
+    cwd: ROOT,
+    stdio: "inherit",
+  });
+  const check = railway.checkCli();
+  if (!check.installed) {
+    output.fatal(
+      "Installation failed. Try manually: npm install -g @railway/cli",
+    );
+  }
+  output.success(`Railway CLI installed (${check.version})`);
+}
+
+async function requireCli(): Promise<void> {
+  const { installed } = railway.checkCli();
+  if (!installed) {
+    const answer = await prompt(
+      "  Railway CLI not found. Install it now? (Y/n): ",
+    );
+    if (answer.toLowerCase() === "n") {
+      output.fatal(
+        "Railway CLI is required. Install manually:\n\n" +
+          "  npm install -g @railway/cli\n",
+      );
+    }
+    installRailwayCli();
+  }
+}
+
+function requireAgent(): AgentEntry {
+  const agent = getActiveAgent();
+  if (!agent) {
+    output.fatal("No active agent. Run `acp setup` first.");
+  }
+  return agent;
+}
+
+/**
+ * Ensure the Railway CLI is pointing at the current agent's project.
+ * Reads the stored Railway project config for this agent and writes it
+ * to .railway/config.json so all subsequent `railway` commands target it.
+ */
+async function linkToCurrentAgent(): Promise<AgentEntry> {
+  await requireCli();
+  const agent = requireAgent();
+  const config = readConfig();
+  const deployInfo = config.DEPLOYS?.[agent.id];
+
+  if (!deployInfo?.railwayConfig) {
+    output.fatal(
+      `No Railway project for agent "${agent.name}".\n` +
+        "  Run `acp serve deploy railway setup` first.",
+    );
+  }
+
+  railway.writeRailwayConfig(deployInfo.railwayConfig);
+  return agent;
+}
+
+function getDeployInfo(agentId: string): DeployInfo | undefined {
+  const config = readConfig();
+  return config.DEPLOYS?.[agentId];
+}
+
+function saveDeployInfo(agentId: string, info: DeployInfo): void {
+  const config = readConfig();
+  if (!config.DEPLOYS) config.DEPLOYS = {};
+  config.DEPLOYS[agentId] = info;
+  writeConfig(config);
+}
+
+function removeDeployInfo(agentId: string): void {
+  const config = readConfig();
+  if (config.DEPLOYS) {
+    delete config.DEPLOYS[agentId];
+    if (Object.keys(config.DEPLOYS).length === 0) {
+      delete config.DEPLOYS;
+    }
+    writeConfig(config);
+  }
+}
+
+function listLocalOfferings(agentName: string): string[] {
+  const offeringsRoot = getOfferingsRoot(agentName);
+  if (!fs.existsSync(offeringsRoot)) return [];
+  const entries = fs.readdirSync(offeringsRoot, { withFileTypes: true });
+  return entries
+    .filter((entry) => {
+      if (!entry.isDirectory()) return false;
+      const dir = path.join(offeringsRoot, entry.name);
+      return (
+        fs.existsSync(path.join(dir, "handlers.ts")) &&
+        fs.existsSync(path.join(dir, "offering.json"))
+      );
+    })
+    .map((entry) => entry.name);
+}
+
+function ensureDockerFiles(): void {
+  if (fs.existsSync(DOCKERFILE_PATH)) {
+    output.log("  Using existing Dockerfile.");
+  } else {
+    fs.writeFileSync(DOCKERFILE_PATH, generateDockerfile());
+    output.success("Generated Dockerfile");
+  }
+
+  if (fs.existsSync(DOCKERIGNORE_PATH)) {
+    output.log("  Using existing .dockerignore.");
+  } else {
+    fs.writeFileSync(DOCKERIGNORE_PATH, generateDockerignore());
+    output.success("Generated .dockerignore");
+  }
+}
+
+// -- Commands --
+
+export async function setup(): Promise<void> {
+  // 1. Check CLI (auto-install if missing)
+  await requireCli();
+  const { version } = railway.checkCli();
+  output.log(`  Railway CLI: ${version}`);
+
+  const agent = requireAgent();
+
+  // 2. Check if this agent already has a Railway project
+  const existing = getDeployInfo(agent.id);
+  if (existing) {
+    output.log(`  Agent "${agent.name}" already has a Railway project.`);
+    output.log("  Run `acp serve deploy railway` to deploy.\n");
+    return;
+  }
+
+  // 3. Check login
+  if (!railway.isLoggedIn()) {
+    output.log("  Logging in to Railway...");
+    railway.login();
+  }
+  output.success("Logged in to Railway");
+
+  // 4. Check if there's already a Railway project linked to this directory
+  let railwayConfig = railway.readRailwayConfig();
+  if (railwayConfig) {
+    output.log(`  Found existing Railway project linked to this directory.`);
+  } else {
+    // Create new Railway project for this agent
+    output.log(`  Creating Railway project for agent "${agent.name}"...`);
+    railway.initProject(`acp-${agent.name}`);
+
+    railwayConfig = railway.readRailwayConfig();
+    if (!railwayConfig) {
+      output.fatal(
+        "Failed to read Railway project config after init. Try running `railway init` manually.",
+      );
+    }
+  }
+
+  // 6. Save project config for this agent
+  // (API key will be set during deploy, after the service is created)
+  saveDeployInfo(agent.id, {
+    provider: "railway",
+    agentName: agent.name,
+    offerings: [],
+    deployedAt: "",
+    railwayConfig,
+  });
+
+  output.output(
+    { provider: "railway", agent: agent.name, status: "setup_complete" },
+    () => {
+      output.heading("Railway Setup Complete");
+      output.field("Agent", agent.name);
+      output.field("Railway Project", `acp-${agent.name}`);
+      output.log("\n  Next steps:");
+      output.log("    1. Create offerings:   acp sell init <name>");
+      output.log("    2. Register on ACP:    acp sell create <name>");
+      output.log("    3. Deploy:             acp serve deploy railway\n");
+    },
+  );
+}
+
+export async function deploy(): Promise<void> {
+  const agent = await linkToCurrentAgent();
+
+  // Check offerings exist locally
+  const offerings = listLocalOfferings(agent.name);
+  if (offerings.length === 0) {
+    output.fatal(
+      "No offerings found. Create at least one offering first:\n\n" +
+        "  acp sell init <name>\n" +
+        "  acp sell create <name>",
+    );
+  }
+
+  // Generate Docker files if missing
+  ensureDockerFiles();
+
+  // Show what's being deployed
+  output.log(`\n  Agent:     ${agent.name}`);
+  output.log(`  Offerings: ${offerings.join(", ")}`);
+  output.log("");
+
+  // Deploy (this creates the service on first run)
+  output.log("  Deploying to Railway...\n");
+  railway.up();
+
+  // Link the service if not already linked (railway up creates it but doesn't auto-link)
+  if (!railway.hasLinkedService()) {
+    const projectName = `acp-${agent.name}`;
+    try {
+      railway.linkService(projectName);
+      output.success(`Linked service ${projectName}`);
+    } catch {
+      output.warn(
+        "Could not auto-link service. Link manually:\n" +
+          `  railway service link ${projectName}`,
+      );
+    }
+  }
+
+  // Set API key on the service
+  const config = readConfig();
+  const apiKey = config.LITE_AGENT_API_KEY;
+  if (apiKey) {
+    try {
+      railway.setVariable("LITE_AGENT_API_KEY", apiKey);
+      output.success("Set LITE_AGENT_API_KEY on Railway");
+    } catch {
+      output.warn(
+        "Could not set LITE_AGENT_API_KEY. Set it manually:\n" +
+          "  acp serve deploy railway env set LITE_AGENT_API_KEY=" +
+          apiKey,
+      );
+    }
+  }
+
+  // Update deploy tracking
+  const existing = getDeployInfo(agent.id)!;
+  saveDeployInfo(agent.id, {
+    ...existing,
+    offerings,
+    deployedAt: new Date().toISOString(),
+  });
+
+  output.output(
+    { provider: "railway", status: "deployed", agent: agent.name, offerings },
+    () => {
+      output.heading("Deployed to Railway");
+      output.field("Agent", agent.name);
+      output.field("Offerings", offerings.join(", "));
+      output.log("");
+      output.log("  Check status:  acp serve deploy railway status");
+      output.log("  View logs:     acp serve deploy railway logs --follow");
+      output.log("  Tear down:     acp serve deploy railway teardown\n");
+    },
+  );
+}
+
+export async function status(): Promise<void> {
+  const agent = await linkToCurrentAgent();
+  const deployInfo = getDeployInfo(agent.id);
+
+  output.heading(`Railway Deployment — ${agent.name}`);
+  if (deployInfo && deployInfo.deployedAt) {
+    output.field("Offerings", deployInfo.offerings.join(", "));
+    output.field("Deployed at", deployInfo.deployedAt);
+  }
+  output.log("");
+  const statusText = railway.getStatus();
+  output.log(statusText);
+  output.log("");
+}
+
+export async function logs(
+  follow: boolean = false,
+  filter: LogFilter = {},
+): Promise<void> {
+  await linkToCurrentAgent();
+  railway.streamLogs(follow, filter);
+}
+
+export async function teardown(): Promise<void> {
+  const agent = await linkToCurrentAgent();
+  output.log(`  Removing deployment for agent "${agent.name}"...\n`);
+  railway.down();
+
+  removeDeployInfo(agent.id);
+
+  output.output(
+    { provider: "railway", agent: agent.name, status: "torn_down" },
+    () => {
+      output.success(`Deployment for "${agent.name}" removed.`);
+      output.log(
+        "  The Railway project still exists — re-deploy anytime with:",
+      );
+      output.log("    acp serve deploy railway\n");
+    },
+  );
+}
+
+export async function env(): Promise<void> {
+  const agent = await linkToCurrentAgent();
+  output.heading(`Railway Env Vars — ${agent.name}`);
+  output.log("");
+  const vars = railway.listVariables();
+  if (vars) {
+    output.log(vars);
+  } else {
+    output.log("  No environment variables set.");
+  }
+  output.log("");
+}
+
+export async function envSet(keyValue: string): Promise<void> {
+  await linkToCurrentAgent();
+
+  const eqIdx = keyValue.indexOf("=");
+  if (eqIdx === -1) {
+    output.fatal(
+      "Invalid format. Use: acp serve deploy railway env set KEY=value",
+    );
+  }
+
+  const key = keyValue.slice(0, eqIdx);
+  const value = keyValue.slice(eqIdx + 1);
+
+  if (!key) {
+    output.fatal("Key cannot be empty.");
+  }
+
+  railway.setVariable(key, value);
+
+  output.output({ action: "set", key }, () => {
+    output.success(`Set ${key} on Railway`);
+    output.log("  Redeploy for changes to take effect:");
+    output.log("    acp serve deploy railway\n");
+  });
+}
+
+export async function envDelete(key: string): Promise<void> {
+  await linkToCurrentAgent();
+
+  if (!key) {
+    output.fatal("Usage: acp serve deploy railway env delete <KEY>");
+  }
+
+  railway.deleteVariable(key);
+
+  output.output({ action: "deleted", key }, () => {
+    output.success(`Deleted ${key} from Railway`);
+    output.log("  Redeploy for changes to take effect:");
+    output.log("    acp serve deploy railway\n");
+  });
+}

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

@@ -0,0 +1,217 @@
+// =============================================================================
+// acp job create <wallet> <offering> [--requirements '{}']
+// acp job status <jobId>
+// acp job active
+// acp job completed
+// =============================================================================
+
+import client from "../lib/client.js";
+import { formatPrice } from "../lib/config.js";
+import * as output from "../lib/output.js";
+import { getBountyByJobId } from "../lib/bounty.js";
+
+function renderDeliverable(deliverable: unknown): string {
+  if (typeof deliverable === "string") return deliverable;
+  return JSON.stringify(deliverable);
+}
+
+export async function create(
+  agentWalletAddress: string,
+  jobOfferingName: string,
+  serviceRequirements: Record<string, unknown>,
+): Promise<void> {
+  if (!agentWalletAddress || !jobOfferingName) {
+    output.fatal(
+      "Usage: acp job create <agentWalletAddress> <jobOfferingName> [--requirements '<json>']",
+    );
+  }
+
+  try {
+    const job = await client.post<{ data: { jobId: number } }>("/acp/jobs", {
+      providerWalletAddress: agentWalletAddress,
+      jobOfferingName,
+      serviceRequirements,
+    });
+
+    output.output(job.data, (data) => {
+      output.heading("Job Created");
+      output.field("Job ID", data.data?.jobId ?? data.jobId);
+      output.log(
+        "\n  Job submitted. Use `acp job status <jobId>` to check progress.\n",
+      );
+    });
+  } catch (e) {
+    output.fatal(
+      `Failed to create job: ${e instanceof Error ? e.message : String(e)}`,
+    );
+  }
+}
+
+export async function status(jobId: string): Promise<void> {
+  if (!jobId) {
+    output.fatal("Usage: acp job status <jobId>");
+  }
+
+  try {
+    const job = await client.get(`/acp/jobs/${jobId}`);
+
+    if (!job?.data?.data) {
+      output.fatal(`Job not found: ${jobId}`);
+    }
+
+    const data = job.data.data;
+
+    if (job.data.errors && job.data.errors.length > 0) {
+      output.output(job.data.errors, (errors) => {
+        output.heading(`Job ${jobId} messages`);
+        errors.forEach((error: string, i: number) =>
+          output.field(`Error ${i + 1}`, error),
+        );
+      });
+      // return;
+    }
+
+    const memoHistory = (data.memos || []).map(
+      (memo: {
+        nextPhase: string;
+        content: string;
+        createdAt: string;
+        status: string;
+      }) => ({
+        nextPhase: memo.nextPhase,
+        content: memo.content,
+        createdAt: memo.createdAt,
+        status: memo.status,
+      }),
+    );
+
+    const result = {
+      jobId: data.id,
+      phase: data.phase,
+      providerName: data.providerName ?? null,
+      providerWalletAddress: data.providerAddress ?? null,
+      clientName: data.clientName ?? null,
+      clientWalletAddress: data.clientAddress ?? null,
+      deliverable: data.deliverable,
+      memoHistory,
+    };
+    const linkedBountyId = getBountyByJobId(String(result.jobId))?.bountyId;
+
+    output.output(result, (r) => {
+      output.heading(`Job ${r.jobId} details`);
+      output.field("Phase", r.phase);
+      output.field("Client", r.clientName || "-");
+      output.field("Client Wallet", r.clientWalletAddress || "-");
+      output.field("Provider", r.providerName || "-");
+      output.field("Provider Wallet", r.providerWalletAddress || "-");
+      if (r.deliverable) {
+        output.log(`\n  Deliverable:\n    ${renderDeliverable(r.deliverable)}`);
+      }
+      if (r.memoHistory.length > 0) {
+        output.log("\n  History:");
+        for (const m of r.memoHistory) {
+          output.log(`    [${m.nextPhase}] ${m.content} (${m.createdAt})`);
+        }
+      }
+      if (linkedBountyId) {
+        output.log(`\n  This job is linked to bounty ${linkedBountyId}.`);
+        output.log(
+          `  Run \`acp bounty status ${linkedBountyId}\` to sync bounty status.\n`,
+        );
+      }
+      output.log("");
+    });
+  } catch (e) {
+    output.fatal(
+      `Failed to get job status: ${e instanceof Error ? e.message : String(e)}`,
+    );
+  }
+}
+
+type JobListItem = {
+  id: number | string;
+  phase?: unknown;
+  price?: unknown;
+  priceType?: unknown;
+  clientAddress?: unknown;
+  providerAddress?: unknown;
+  name?: unknown;
+  deliverable?: unknown;
+};
+
+export type JobListOptions = {
+  page?: number;
+  pageSize?: number;
+};
+
+export async function active(options: JobListOptions = {}): Promise<void> {
+  try {
+    const params: Record<string, number> = {};
+    if (options.page != null) params.page = options.page;
+    if (options.pageSize != null) params.pageSize = options.pageSize;
+    const res = await client.get<{ data: JobListItem[] }>("/acp/jobs/active", {
+      params,
+    });
+    const jobs = res.data.data;
+
+    output.output({ jobs }, ({ jobs: list }) => {
+      output.heading("Active Jobs");
+      if (list.length === 0) {
+        output.log("  No active jobs.\n");
+        return;
+      }
+      for (const j of list) {
+        output.field("Job ID", j.id);
+        if (j.phase) output.field("Phase", j.phase);
+        if (j.name) output.field("Name", j.name);
+        if (j.price != null)
+          output.field("Price", formatPrice(j.price, j.priceType));
+        if (j.clientAddress) output.field("Client", j.clientAddress);
+        if (j.providerAddress) output.field("Provider", j.providerAddress);
+        if (j.deliverable) output.field("Deliverable", j.deliverable);
+        output.log("");
+      }
+    });
+  } catch (e) {
+    output.fatal(
+      `Failed to get active jobs: ${e instanceof Error ? e.message : String(e)}`,
+    );
+  }
+}
+
+export async function completed(options: JobListOptions = {}): Promise<void> {
+  try {
+    const params: Record<string, number> = {};
+    if (options.page != null) params.page = options.page;
+    if (options.pageSize != null) params.pageSize = options.pageSize;
+    const res = await client.get<{ data: JobListItem[] }>(
+      "/acp/jobs/completed",
+      {
+        params,
+      },
+    );
+    const jobs = res.data.data;
+
+    output.output({ jobs }, ({ jobs: list }) => {
+      output.heading("Completed Jobs");
+      if (list.length === 0) {
+        output.log("  No completed jobs.\n");
+        return;
+      }
+      for (const j of list) {
+        output.field("Job ID", j.id);
+        if (j.name) output.field("Name", j.name);
+        if (j.price != null)
+          output.field("Price", formatPrice(j.price, j.priceType));
+        if (j.clientAddress) output.field("Client", j.clientAddress);
+        if (j.providerAddress) output.field("Provider", j.providerAddress);
+        if (j.deliverable) output.field("Deliverable", j.deliverable);
+        output.log("");
+      }
+    });
+  } catch (e) {
+    output.fatal(
+      `Failed to get completed jobs: ${e instanceof Error ? e.message : String(e)}`,
+    );
+  }
+}

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

@@ -0,0 +1,71 @@
+// =============================================================================
+// acp profile show    — Show agent profile
+// acp profile update  — Update agent info (name, description, profilePic)
+// =============================================================================
+
+import client from "../lib/client.js";
+import { getMyAgentInfo } from "../lib/wallet.js";
+import * as output from "../lib/output.js";
+
+export async function show(): Promise<void> {
+  try {
+    const info = await getMyAgentInfo();
+
+    output.output(info, (data) => {
+      output.heading("Agent Profile");
+      output.field("Name", data.name);
+      output.field("Description", data.description || "(none)");
+      output.field("Wallet", data.walletAddress);
+      output.field(
+        "Token",
+        data.token?.symbol
+          ? `${data.token.symbol} (${data.tokenAddress})`
+          : data.tokenAddress || "(none)",
+      );
+      if (data.jobs?.length > 0) {
+        output.log("\n  Job Offerings:");
+        for (const o of data.jobs) {
+          const price = o.priceV2
+            ? `${o.priceV2.value} ${o.priceV2.type === "fixed" ? "USDC" : ""} (${o.priceV2.type})`
+            : "-";
+          output.log(`    - ${o.name}  fee: ${price}  sla: ${o.slaMinutes}min`);
+        }
+      }
+      output.log("");
+    });
+  } catch (e) {
+    output.fatal(
+      `Failed to get profile: ${e instanceof Error ? e.message : String(e)}`,
+    );
+  }
+}
+
+export async function update(key: string, value: string): Promise<void> {
+  const supportedKeys = ["name", "description", "profilePic"];
+
+  if (!key?.trim() || !value?.trim()) {
+    output.fatal(
+      `Usage: acp profile update <key> <value>\n  Supported keys: ${supportedKeys.join(", ")}`,
+    );
+  }
+
+  if (!supportedKeys.includes(key)) {
+    output.fatal(
+      `Invalid key: ${key}. Supported keys: ${supportedKeys.join(", ")}`,
+    );
+  }
+
+  try {
+    const agent = await client.put("/acp/me", { [key]: value });
+
+    output.output(agent.data, (data) => {
+      output.heading("Profile Updated");
+      output.log(`  ${key} set to: "${value}"`);
+      output.log("");
+    });
+  } catch (e) {
+    output.fatal(
+      `Failed to update profile: ${e instanceof Error ? e.message : String(e)}`,
+    );
+  }
+}