spendos 0.1.0

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

@@ -0,0 +1,883 @@
+// =============================================================================
+// acp sell init <name>     — Scaffold a new offering
+// acp sell create <name>   — Validate + register offering on ACP
+// acp sell delete <name>   — Delist offering from ACP
+// acp sell list            — Show all offerings with status
+// acp sell inspect <name>  — Detailed view of single offering
+//
+// acp sell resource init <name>     — Scaffold a new resource
+// acp sell resource create <name>   — Validate + register resource on ACP
+// acp sell resource delete <name>   — Delete resource from ACP
+// acp sell resource list            — Show all resources with status
+// =============================================================================
+
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import * as output from "../lib/output.js";
+import {
+  createJobOffering,
+  deleteJobOffering,
+  upsertResourceApi,
+  deleteResourceApi,
+  type JobOfferingData,
+  type PriceV2,
+  type Resource,
+} from "../lib/api.js";
+import { getMyAgentInfo } from "../lib/wallet.js";
+import {
+  formatPrice,
+  getActiveAgent,
+  sanitizeAgentName,
+} from "../lib/config.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/** Offerings base: src/seller/offerings/ */
+const OFFERINGS_BASE = path.resolve(__dirname, "..", "seller", "offerings");
+
+/** Offerings root for the current agent: src/seller/offerings/<agent-name>/ */
+function getOfferingsRoot(): string {
+  const agent = getActiveAgent();
+  if (!agent) {
+    console.error("Error: No active agent. Run `acp setup` first.");
+    process.exit(1);
+  }
+  return path.resolve(OFFERINGS_BASE, sanitizeAgentName(agent.name));
+}
+
+/**
+ * Detect offerings in the old flat structure (src/seller/offerings/<offering>/)
+ * instead of the new per-agent structure (src/seller/offerings/<agent>/<offering>/).
+ * Warns the user and shows the move command.
+ */
+export async function checkForLegacyOfferings(): Promise<void> {
+  if (!fs.existsSync(OFFERINGS_BASE)) return;
+
+  const agent = getActiveAgent();
+  if (!agent) return;
+  const agentDir = sanitizeAgentName(agent.name);
+
+  const entries = fs.readdirSync(OFFERINGS_BASE, { withFileTypes: true });
+  const legacyOfferings = entries.filter((e) => {
+    if (!e.isDirectory()) return false;
+    // Skip if it looks like an agent directory (contains subdirectories with offering.json)
+    const subPath = path.join(OFFERINGS_BASE, e.name);
+    const hasOfferingJson = fs.existsSync(path.join(subPath, "offering.json"));
+    const hasHandlers = fs.existsSync(path.join(subPath, "handlers.ts"));
+    // It's a legacy offering if it has offering.json + handlers.ts directly
+    return hasOfferingJson && hasHandlers;
+  });
+
+  if (legacyOfferings.length === 0) return;
+
+  const agentInfo = await getMyAgentInfo();
+  const registeredOfferingNames = new Set(
+    agentInfo.jobs?.map((job) => job.name) || [],
+  );
+
+  const agentLegacyOfferings = legacyOfferings.filter((e) => {
+    if (registeredOfferingNames.has(e.name)) {
+      return true;
+    }
+    try {
+      const offeringJsonPath = path.join(
+        OFFERINGS_BASE,
+        e.name,
+        "offering.json",
+      );
+      if (fs.existsSync(offeringJsonPath)) {
+        const offeringJson: OfferingJson = JSON.parse(
+          fs.readFileSync(offeringJsonPath, "utf-8"),
+        );
+        return registeredOfferingNames.has(offeringJson.name);
+      }
+    } catch {
+      // If we can't read the file, skip this check
+    }
+    return false;
+  });
+
+  // Only show warning if there are legacy offerings that belong to the current agent
+  if (agentLegacyOfferings.length === 0) return;
+
+  const names = agentLegacyOfferings.map((e) => e.name);
+  output.warn(
+    `Found ${names.length} offering(s) in the legacy directory structure:\n` +
+      names.map((n) => `    - src/seller/offerings/${n}/`).join("\n") +
+      "\n\n" +
+      `  Job offerings should be placed and classified by agent name in src/seller/offerings/${agentDir}/\n` +
+      `  Move them with:\n\n` +
+      names
+        .map(
+          (n) =>
+            `    mv src/seller/offerings/${n} src/seller/offerings/${agentDir}/${n}`,
+        )
+        .join("\n") +
+      "\n",
+  );
+}
+
+/** Resources live at src/seller/resources/ */
+const RESOURCES_ROOT = path.resolve(__dirname, "..", "seller", "resources");
+
+interface OfferingJson {
+  name: string;
+  description: string;
+  jobFee: number;
+  jobFeeType: "fixed" | "percentage";
+  priceV2?: PriceV2;
+  slaMinutes?: number;
+  requiredFunds: boolean;
+  requirement?: Record<string, any>;
+  deliverable?: string;
+}
+
+interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+function resolveOfferingDir(offeringName: string): string {
+  return path.resolve(getOfferingsRoot(), offeringName);
+}
+
+function validateOfferingJson(filePath: string): ValidationResult {
+  const result: ValidationResult = { valid: true, errors: [], warnings: [] };
+
+  if (!fs.existsSync(filePath)) {
+    result.valid = false;
+    result.errors.push(`offering.json not found at ${filePath}`);
+    return result;
+  }
+
+  let json: any;
+  try {
+    json = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch (err) {
+    result.valid = false;
+    result.errors.push(`Invalid JSON in offering.json: ${err}`);
+    return result;
+  }
+
+  if (!json.name || typeof json.name !== "string" || json.name.trim() === "") {
+    result.valid = false;
+    result.errors.push(
+      'offering.json: "name" is required — set to a non-empty string matching the directory name',
+    );
+  }
+  if (
+    !json.description ||
+    typeof json.description !== "string" ||
+    json.description.trim() === ""
+  ) {
+    result.valid = false;
+    result.errors.push(
+      'offering.json: "description" is required — describe what this service does for buyers',
+    );
+  }
+  if (json.jobFee === undefined || json.jobFee === null) {
+    result.valid = false;
+    // Validate jobFee presence, type, and value based on jobFeeType
+    if (json.jobFee === undefined || json.jobFee === null) {
+      result.valid = false;
+      result.errors.push(
+        'offering.json: "jobFee" is required — set to a number (see "jobFeeType" docs)',
+      );
+    } else if (typeof json.jobFee !== "number") {
+      result.valid = false;
+      result.errors.push('offering.json: "jobFee" must be a number');
+    }
+
+    if (json.jobFeeType === undefined || json.jobFeeType === null) {
+      result.valid = false;
+      result.errors.push(
+        'offering.json: "jobFeeType" is required ("fixed" or "percentage")',
+      );
+    } else if (
+      json.jobFeeType !== "fixed" &&
+      json.jobFeeType !== "percentage"
+    ) {
+      result.valid = false;
+      result.errors.push(
+        'offering.json: "jobFeeType" must be either "fixed" or "percentage"',
+      );
+    }
+
+    // Additional validation if both jobFee is a number and jobFeeType is set
+    if (typeof json.jobFee === "number" && json.jobFeeType) {
+      if (json.jobFeeType === "fixed") {
+        if (json.jobFee < 0) {
+          result.valid = false;
+          result.errors.push(
+            'offering.json: "jobFee" must be a non-negative number (fee in USDC per job) for fixed fee type',
+          );
+        }
+        if (json.jobFee === 0) {
+          result.warnings.push(
+            'offering.json: "jobFee" is 0; jobs will pay no fee to seller',
+          );
+        }
+      } else if (json.jobFeeType === "percentage") {
+        if (json.jobFee < 0.001 || json.jobFee > 0.99) {
+          result.valid = false;
+          result.errors.push(
+            'offering.json: "jobFee" must be >= 0.001 and <= 0.99 (value in decimals, eg. 50% = 0.5) for percentage fee type',
+          );
+        }
+      }
+    }
+  }
+  if (json.requiredFunds === undefined || json.requiredFunds === null) {
+    result.valid = false;
+    result.errors.push(
+      'offering.json: "requiredFunds" is required — set to true if the job needs additional token transfer beyond the fee, false otherwise',
+    );
+  } else if (typeof json.requiredFunds !== "boolean") {
+    result.valid = false;
+    result.errors.push('offering.json: "requiredFunds" must be true or false');
+  }
+
+  return result;
+}
+
+function validateHandlers(
+  filePath: string,
+  requiredFunds?: boolean,
+): ValidationResult {
+  const result: ValidationResult = { valid: true, errors: [], warnings: [] };
+
+  if (!fs.existsSync(filePath)) {
+    result.valid = false;
+    result.errors.push(`handlers.ts not found at ${filePath}`);
+    return result;
+  }
+
+  const content = fs.readFileSync(filePath, "utf-8");
+
+  const executeJobPatterns = [
+    /export\s+(async\s+)?function\s+executeJob\s*\(/,
+    /export\s+const\s+executeJob\s*=\s*(async\s*)?\(/,
+    /export\s+const\s+executeJob\s*=\s*(async\s*)?function/,
+    /export\s*\{\s*[^}]*executeJob[^}]*\}/,
+  ];
+
+  if (!executeJobPatterns.some((p) => p.test(content))) {
+    result.valid = false;
+    result.errors.push(
+      'handlers.ts: must export an "executeJob" function — this is the required handler that runs your service logic',
+    );
+  }
+
+  const hasValidate = [
+    /export\s+(async\s+)?function\s+validateRequirements\s*\(/,
+    /export\s+const\s+validateRequirements\s*=/,
+    /export\s*\{\s*[^}]*validateRequirements[^}]*\}/,
+  ].some((p) => p.test(content));
+
+  const hasFunds = [
+    /export\s+(async\s+)?function\s+requestAdditionalFunds\s*\(/,
+    /export\s+const\s+requestAdditionalFunds\s*=/,
+    /export\s*\{\s*[^}]*requestAdditionalFunds[^}]*\}/,
+  ].some((p) => p.test(content));
+
+  if (!hasValidate) {
+    result.warnings.push(
+      'handlers.ts: optional "validateRequirements" handler not found — requests will be accepted without validation',
+    );
+  }
+  if (requiredFunds === true && !hasFunds) {
+    result.valid = false;
+    result.errors.push(
+      'handlers.ts: "requiredFunds" is true in offering.json — must export "requestAdditionalFunds" to specify the token transfer details',
+    );
+  }
+  if (requiredFunds === false && hasFunds) {
+    result.valid = false;
+    result.errors.push(
+      'handlers.ts: "requiredFunds" is false in offering.json — must NOT export "requestAdditionalFunds" (remove it, or set requiredFunds to true)',
+    );
+  }
+
+  return result;
+}
+
+function buildAcpPayload(json: OfferingJson): JobOfferingData {
+  return {
+    name: json.name,
+    description: json.description,
+    priceV2: json.priceV2 ?? { type: json.jobFeeType, value: json.jobFee },
+    slaMinutes: json.slaMinutes ?? 5,
+    requiredFunds: json.requiredFunds,
+    requirement: json.requirement ?? {},
+    deliverable: json.deliverable ?? "string",
+  };
+}
+
+// -- Init: scaffold a new offering --
+
+export async function init(offeringName: string): Promise<void> {
+  await checkForLegacyOfferings();
+  if (!offeringName) {
+    output.fatal("Usage: acp sell init <offering_name>");
+  }
+
+  const dir = resolveOfferingDir(offeringName);
+  if (fs.existsSync(dir)) {
+    output.fatal(`Offering directory already exists: ${dir}`);
+  }
+
+  fs.mkdirSync(dir, { recursive: true });
+
+  const offeringJson: Record<string, unknown> = {
+    name: offeringName,
+    description: "",
+    jobFee: null,
+    jobFeeType: null,
+    requiredFunds: null,
+    requirement: {},
+  };
+
+  fs.writeFileSync(
+    path.join(dir, "offering.json"),
+    JSON.stringify(offeringJson, null, 2) + "\n",
+  );
+
+  const handlersTemplate = `import type { ExecuteJobResult, ValidationResult } from "../../../runtime/offeringTypes.js";
+
+// Required: implement your service logic here
+export async function executeJob(request: any): Promise<ExecuteJobResult> {
+  // TODO: Implement your service
+  return { deliverable: "TODO: Return your result" };
+}
+
+// Optional: validate incoming requests
+export function validateRequirements(request: any): ValidationResult {
+  // Return { valid: true } to accept, or { valid: false, reason: "explanation" } to reject
+  return { valid: true };
+}
+
+// Optional: provide custom payment request message
+export function requestPayment(request: any): string {
+  // Return a custom message/reason for the payment request
+  return "Request accepted";
+}
+`;
+
+  fs.writeFileSync(path.join(dir, "handlers.ts"), handlersTemplate);
+
+  const agent = getActiveAgent();
+  const agentDir = agent ? sanitizeAgentName(agent.name) : "unknown";
+  output.output({ created: dir }, () => {
+    output.heading("Offering Scaffolded");
+    output.log(`  Created: src/seller/offerings/${agentDir}/${offeringName}/`);
+    output.log(
+      `    - offering.json  (edit name, description, fee, feeType, requirements)`,
+    );
+    output.log(`    - handlers.ts    (implement executeJob)`);
+    output.log(
+      `\n  Next: edit the files, then run: acp sell create ${offeringName}\n`,
+    );
+  });
+}
+
+// -- Create: validate + register --
+
+export async function create(offeringName: string): Promise<void> {
+  await checkForLegacyOfferings();
+  if (!offeringName) {
+    output.fatal("Usage: acp sell create <offering_name>");
+  }
+
+  const dir = resolveOfferingDir(offeringName);
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    output.fatal(
+      `Offering directory not found: ${dir}\n  Create it with: acp sell init ${offeringName}`,
+    );
+  }
+
+  output.log(`\nValidating offering: "${offeringName}"\n`);
+
+  const allErrors: string[] = [];
+  const allWarnings: string[] = [];
+
+  // Validate offering.json
+  output.log("  Checking offering.json...");
+  const jsonPath = path.join(dir, "offering.json");
+  const jsonResult = validateOfferingJson(jsonPath);
+  allErrors.push(...jsonResult.errors);
+  allWarnings.push(...jsonResult.warnings);
+
+  let parsedOffering: OfferingJson | null = null;
+  if (jsonResult.valid) {
+    parsedOffering = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+    output.log(`    Valid — Name: "${parsedOffering!.name}"`);
+    output.log(`             Fee: ${parsedOffering!.jobFee} USDC`);
+    output.log(`             Funds required: ${parsedOffering!.requiredFunds}`);
+  } else {
+    output.log("    Invalid");
+  }
+
+  // Validate handlers.ts
+  output.log("\n  Checking handlers.ts...");
+  const handlersPath = path.join(dir, "handlers.ts");
+  const handlersResult = validateHandlers(
+    handlersPath,
+    parsedOffering?.requiredFunds,
+  );
+  allErrors.push(...handlersResult.errors);
+  allWarnings.push(...handlersResult.warnings);
+
+  if (handlersResult.valid) {
+    output.log("    Valid — executeJob handler found");
+  } else {
+    output.log("    Invalid");
+  }
+
+  output.log("\n" + "-".repeat(50));
+
+  if (allWarnings.length > 0) {
+    output.log("\n  Warnings:");
+    allWarnings.forEach((w) => output.log(`    - ${w}`));
+  }
+
+  if (allErrors.length > 0) {
+    output.log("\n  Errors:");
+    allErrors.forEach((e) => output.log(`    - ${e}`));
+    output.fatal("\n  Validation failed. Fix the errors above.");
+  }
+
+  output.log("\n  Validation passed!\n");
+
+  // Register with ACP
+  const json: OfferingJson = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+  const acpPayload = buildAcpPayload(json);
+
+  output.log("  Registering offering with ACP...");
+  const result = await createJobOffering(acpPayload);
+
+  if (result.success) {
+    output.log("    Offering registered successfully.\n");
+  } else {
+    output.fatal("  Failed to register offering with ACP.");
+  }
+
+  // Start seller if not running
+  output.log("  Tip: Run `acp serve start` to begin accepting jobs.\n");
+}
+
+// -- Delete: delist offering --
+
+export async function del(offeringName: string): Promise<void> {
+  if (!offeringName) {
+    output.fatal("Usage: acp sell delete <offering_name>");
+  }
+
+  output.log(`\n  Delisting offering: "${offeringName}"...\n`);
+
+  const result = await deleteJobOffering(offeringName);
+
+  if (result.success) {
+    output.log("  Offering delisted from ACP. Local files remain.\n");
+  } else {
+    output.fatal("  Failed to delist offering from ACP.");
+  }
+}
+
+// -- List: show all offerings with status --
+
+interface LocalOffering {
+  dirName: string;
+  name: string;
+  description: string;
+  jobFee: number;
+  jobFeeType: "fixed" | "percentage";
+  requiredFunds: boolean;
+}
+
+function listLocalOfferings(): LocalOffering[] {
+  const offeringsRoot = getOfferingsRoot();
+  if (!fs.existsSync(offeringsRoot)) return [];
+
+  return fs
+    .readdirSync(offeringsRoot, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => {
+      const configPath = path.join(offeringsRoot, d.name, "offering.json");
+      if (!fs.existsSync(configPath)) return null;
+      try {
+        const json = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        return {
+          dirName: d.name,
+          name: json.name ?? d.name,
+          description: json.description ?? "",
+          jobFee: json.jobFee ?? 0,
+          jobFeeType: json.jobFeeType ?? "fixed",
+          requiredFunds: json.requiredFunds ?? false,
+        };
+      } catch {
+        return null;
+      }
+    })
+    .filter((o): o is LocalOffering => o !== null);
+}
+
+interface AcpOffering {
+  name: string;
+  priceV2?: { type: string; value: number };
+  slaMinutes?: number;
+  requiredFunds?: boolean;
+}
+
+async function fetchAcpOfferings(): Promise<AcpOffering[]> {
+  try {
+    const agentInfo = await getMyAgentInfo();
+    return agentInfo.jobs ?? [];
+  } catch {
+    // API error — can't determine ACP status
+    return [];
+  }
+}
+
+function acpOfferingNames(acpOfferings: AcpOffering[]): Set<string> {
+  return new Set(acpOfferings.map((o) => o.name));
+}
+
+export async function list(): Promise<void> {
+  await checkForLegacyOfferings();
+  const acpOfferings = await fetchAcpOfferings();
+  const acpNames = acpOfferingNames(acpOfferings);
+  const localOfferings = listLocalOfferings();
+  const localNames = new Set(localOfferings.map((o) => o.name));
+
+  const localData = localOfferings.map((o) => ({
+    ...o,
+    listed: acpNames.has(o.name),
+    acpOnly: false as const,
+  }));
+
+  // ACP-only offerings: listed on ACP but no local directory
+  const acpOnlyData = acpOfferings
+    .filter((o) => !localNames.has(o.name))
+    .map((o) => ({
+      dirName: "",
+      name: o.name,
+      description: "",
+      jobFee: o.priceV2?.value ?? 0,
+      jobFeeType: o.priceV2?.type ?? "fixed",
+      requiredFunds: o.requiredFunds ?? false,
+      listed: true,
+      acpOnly: true as const,
+    }));
+
+  const data = [...localData, ...acpOnlyData];
+
+  output.output(data, (offerings) => {
+    output.heading("Job Offerings");
+
+    if (offerings.length === 0) {
+      output.log(
+        "  No offerings found. Run `acp sell init <name>` to create one.\n",
+      );
+      return;
+    }
+
+    for (const o of offerings) {
+      const status = o.acpOnly
+        ? "Listed on ACP (no local files)"
+        : o.listed
+          ? "Listed"
+          : "Local only";
+      output.log(`\n  ${o.name}`);
+      if (!o.acpOnly) {
+        output.field("    Description", o.description);
+      }
+      output.field("    Fee", `${formatPrice(o.jobFee, o.jobFeeType)}`);
+      output.field("    Funds required", String(o.requiredFunds));
+      output.field("    Status", status);
+      if (o.acpOnly) {
+        output.log(
+          "    Tip: Run `acp sell delete " + o.name + "` to delist from ACP",
+        );
+      }
+    }
+    output.log("");
+  });
+}
+
+// -- Inspect: detailed view --
+
+function detectHandlers(offeringDir: string): string[] {
+  const handlersPath = path.join(
+    getOfferingsRoot(),
+    offeringDir,
+    "handlers.ts",
+  );
+  if (!fs.existsSync(handlersPath)) return [];
+
+  const content = fs.readFileSync(handlersPath, "utf-8");
+  const found: string[] = [];
+
+  if (/export\s+(async\s+)?function\s+executeJob\s*\(/.test(content)) {
+    found.push("executeJob");
+  }
+  if (
+    /export\s+(async\s+)?function\s+validateRequirements\s*\(/.test(content)
+  ) {
+    found.push("validateRequirements");
+  }
+  if (/export\s+(async\s+)?function\s+requestPayment\s*\(/.test(content)) {
+    found.push("requestPayment");
+  }
+  if (
+    /export\s+(async\s+)?function\s+requestAdditionalFunds\s*\(/.test(content)
+  ) {
+    found.push("requestAdditionalFunds");
+  }
+
+  return found;
+}
+
+export async function inspect(offeringName: string): Promise<void> {
+  if (!offeringName) {
+    output.fatal("Usage: acp sell inspect <offering_name>");
+  }
+
+  const dir = resolveOfferingDir(offeringName);
+  const configPath = path.join(dir, "offering.json");
+
+  if (!fs.existsSync(configPath)) {
+    output.fatal(`Offering not found: ${offeringName}`);
+  }
+
+  const json = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  const acpOfferings = await fetchAcpOfferings();
+  const isListed = acpOfferingNames(acpOfferings).has(json.name);
+  const handlers = detectHandlers(offeringName);
+
+  const data = {
+    ...json,
+    listed: isListed,
+    handlers,
+  };
+
+  output.output(data, (d) => {
+    output.heading(`Offering: ${d.name}`);
+    output.field("Description", d.description);
+    output.field("Fee", `${d.jobFee} USDC`);
+    output.field("Funds required", String(d.requiredFunds));
+    output.field("Status", d.listed ? "Listed on ACP" : "Local only");
+    output.field("Handlers", d.handlers.join(", ") || "(none)");
+    if (d.requirement) {
+      output.log("\n  Requirement Schema:");
+      output.log(
+        JSON.stringify(d.requirement, null, 4)
+          .split("\n")
+          .map((line: string) => `    ${line}`)
+          .join("\n"),
+      );
+    }
+    output.log("");
+  });
+}
+
+// =============================================================================
+// Resource Management
+// =============================================================================
+
+function resolveResourceDir(resourceName: string): string {
+  return path.resolve(RESOURCES_ROOT, resourceName);
+}
+
+interface LocalResource {
+  dirName: string;
+  name: string;
+  description: string;
+  url: string;
+}
+
+async function fetchAcpResourceNames(): Promise<Resource[]> {
+  try {
+    const agentInfo = (await getMyAgentInfo()) as {
+      jobs?: unknown[];
+      resources?: Resource[];
+    };
+    return agentInfo.resources ?? [];
+  } catch {
+    return [];
+  }
+}
+
+export async function resourceList(): Promise<void> {
+  const resources = await fetchAcpResourceNames();
+
+  output.output(resources, (resources) => {
+    output.heading("Resources");
+
+    if (resources.length === 0) {
+      output.log(
+        "  No resources found. Run `acp sell resource init <name>` to create one.\n",
+      );
+      return;
+    }
+
+    for (const r of resources) {
+      output.log(`\n  ${r.name}`);
+      if (!r.acpOnly) {
+        output.field("    Description", r.description);
+        output.field("    URL", r.url);
+      }
+    }
+    output.log("");
+  });
+}
+
+function validateResourceJson(filePath: string): ValidationResult {
+  const result: ValidationResult = { valid: true, errors: [], warnings: [] };
+
+  if (!fs.existsSync(filePath)) {
+    result.valid = false;
+    result.errors.push(`resources.json not found at ${filePath}`);
+    return result;
+  }
+
+  let json: any;
+  try {
+    json = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch (err) {
+    result.valid = false;
+    result.errors.push(`Invalid JSON in resources.json: ${err}`);
+    return result;
+  }
+
+  if (!json.name || typeof json.name !== "string" || json.name.trim() === "") {
+    result.valid = false;
+    result.errors.push('"name" field is required (non-empty string)');
+  }
+  if (
+    !json.description ||
+    typeof json.description !== "string" ||
+    json.description.trim() === ""
+  ) {
+    result.valid = false;
+    result.errors.push('"description" field is required (non-empty string)');
+  }
+  if (!json.url || typeof json.url !== "string" || json.url.trim() === "") {
+    result.valid = false;
+    result.errors.push('"url" field is required (non-empty string)');
+  }
+  if (json.params !== undefined && json.params !== null) {
+    if (typeof json.params !== "object" || Array.isArray(json.params)) {
+      result.valid = false;
+      result.errors.push('"params" field must be an object if provided');
+    }
+  }
+
+  return result;
+}
+
+// -- Resource Init: scaffold a new resource --
+
+export async function resourceInit(resourceName: string): Promise<void> {
+  if (!resourceName) {
+    output.fatal("Usage: acp sell resource init <resource_name>");
+  }
+
+  const dir = resolveResourceDir(resourceName);
+  if (fs.existsSync(dir)) {
+    output.fatal(`Resource directory already exists: ${dir}`);
+  }
+
+  fs.mkdirSync(dir, { recursive: true });
+
+  const resourceJson = {
+    name: resourceName,
+    description: "TODO: Describe what this resource provides",
+    url: "https://api.example.com/endpoint",
+  };
+
+  fs.writeFileSync(
+    path.join(dir, "resources.json"),
+    JSON.stringify(resourceJson, null, 2) + "\n",
+  );
+
+  output.output({ created: dir }, () => {
+    output.heading("Resource Scaffolded");
+    output.log(`  Created: src/seller/resources/${resourceName}/`);
+    output.log(`    - resources.json  (edit name, description, url, params)`);
+    output.log(
+      `\n  Next: edit the file, then run: acp sell resource create ${resourceName}\n`,
+    );
+  });
+}
+
+// -- Resource Create: validate + register --
+
+export async function resourceCreate(resourceName: string): Promise<void> {
+  if (!resourceName) {
+    output.fatal("Usage: acp sell resource create <resource_name>");
+  }
+
+  const dir = resolveResourceDir(resourceName);
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    output.fatal(
+      `Resource directory not found: ${dir}\n  Create it with: acp sell resource init ${resourceName}`,
+    );
+  }
+
+  output.log(`\nValidating resource: "${resourceName}"\n`);
+
+  const jsonPath = path.join(dir, "resources.json");
+  const validation = validateResourceJson(jsonPath);
+
+  if (!validation.valid) {
+    output.log("  Errors:");
+    validation.errors.forEach((e) => output.log(`    - ${e}`));
+    output.fatal("\n  Validation failed. Fix the errors above.");
+  }
+
+  if (validation.warnings.length > 0) {
+    output.log("  Warnings:");
+    validation.warnings.forEach((w) => output.log(`    - ${w}`));
+  }
+
+  output.log("  Validation passed!\n");
+
+  // Register with ACP
+  const json: any = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+  const resource: Resource = {
+    name: json.name,
+    description: json.description,
+    url: json.url,
+    params: json.params,
+  };
+
+  output.log("  Registering resource with ACP...");
+  const result = await upsertResourceApi(resource);
+
+  if (result.success) {
+    output.log("    Resource registered successfully.\n");
+  } else {
+    output.fatal("  Failed to register resource with ACP.");
+  }
+}
+
+// -- Resource Delete: delete resource --
+
+export async function resourceDelete(resourceName: string): Promise<void> {
+  if (!resourceName) {
+    output.fatal("Usage: acp sell resource delete <resource_name>");
+  }
+
+  output.log(`\n  Deleting resource: "${resourceName}"...\n`);
+
+  const result = await deleteResourceApi(resourceName);
+
+  if (result.success) {
+    output.log("  Resource deleted from ACP.\n");
+  } else {
+    output.fatal("  Failed to delete resource from ACP.");
+  }
+}