@agent-store/cli 0.1.0

package/README.md

@@ -0,0 +1,19 @@
+# Agent Store CLI
+
+Agent Store is an online marketplace and resource-supply platform for large numbers of AI agents. Through this CLI, agents can discover products, place orders, make payments, and access the resources they need to operate autonomously.
+
+Install globally:
+
+```bash
+npm install -g @agent-store/cli
+```
+
+Current runtime requirements:
+
+- `bun` must be installed because the published bin runs through Bun
+- macOS, Linux, and WSL terminals are supported in v1
+- `git` and `bash` must be available on `PATH`
+
+Available commands:
+
+- `agent-store init`, opens the wallet setup wizard.

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@agent-store/cli",
+  "version": "0.1.0",
+  "description": "Agent Store CLI",
+  "type": "module",
+  "bin": {
+    "agent-store": "./src/bin/agent-store.ts"
+  },
+  "files": [
+    "README.md",
+    "src"
+  ],
+  "dependencies": {
+    "ora": "latest"
+  }
+}

package/src/bin/agent-store.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env bun
+
+import { main } from "../main.ts";
+
+const exitCode = await main(process.argv.slice(2));
+
+process.exit(exitCode);

package/src/commands/init.ts

@@ -0,0 +1,51 @@
+import { checkPrerequisites, installWallet } from "../init/install-wallet.ts";
+import { runOraInitUi } from "../init/ora-ui.ts";
+import { runPlainInitUi } from "../init/plain-ui.ts";
+
+const resolvePlatform = (): string =>
+  process.env.AGENT_STORE_CLI_FORCE_PLATFORM ?? process.platform;
+
+const usePlainUi = (): boolean =>
+  process.env.AGENT_STORE_CLI_PLAIN === "1" ||
+  !process.stdin.isTTY ||
+  !process.stdout.isTTY;
+
+export const runInitCommand = async (): Promise<number> => {
+  const install = async (
+    onStep: (step: string) => void,
+  ): Promise<{ walletAddress: string }> => {
+    const prerequisites = checkPrerequisites({
+      platform: resolvePlatform(),
+      which: (command) => Bun.which(command) ?? null,
+    });
+
+    if (!prerequisites.ok) {
+      const error = new Error(prerequisites.message) as Error & { step: string };
+
+      error.step = "Checking prerequisites";
+      throw error;
+    }
+
+    return installWallet({
+      onStep: (step) => {
+        if (step !== "Checking prerequisites") {
+          onStep(step);
+        }
+      },
+    });
+  };
+
+  if (usePlainUi()) {
+    const result = await runPlainInitUi({
+      installWallet: install,
+    });
+
+    return result.exitCode;
+  }
+
+  const result = await runOraInitUi({
+    installWallet: install,
+  });
+
+  return result.exitCode;
+};

package/src/index.ts

@@ -0,0 +1 @@
+export { main } from "./main.ts";

package/src/init/install-wallet.ts

@@ -0,0 +1,173 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+
+import { INSTALL_STEPS } from "./state.ts";
+
+const AWP_WALLET_REPOSITORY_URL = "https://github.com/awp-core/awp-wallet.git";
+const WALLET_ADDRESS_COMMAND =
+  `bash -lc "TOKEN=\\$(awp-wallet unlock --duration 3600 | jq -r '.sessionToken'); ` +
+  `awp-wallet status --token \\$TOKEN  | jq '.address'"`;
+
+export class InstallWalletError extends Error {
+  step: string;
+
+  constructor(step: string, message: string) {
+    super(message);
+    this.name = "InstallWalletError";
+    this.step = step;
+  }
+}
+
+export const checkPrerequisites = (input: {
+  platform: string;
+  which: (command: string) => string | null;
+}): { ok: true } | { ok: false; message: string } => {
+  if (input.platform !== "darwin" && input.platform !== "linux") {
+    return {
+      ok: false,
+      message:
+        "agent-store init currently supports macOS, Linux, and WSL terminals only.",
+    };
+  }
+
+  for (const command of ["bun", "git", "bash", "jq"] as const) {
+    if (!input.which(command)) {
+      return {
+        ok: false,
+        message: `Missing required command: ${command}`,
+      };
+    }
+  }
+
+  return { ok: true };
+};
+
+const runSpawnedCommand = async (input: {
+  command: string;
+  cwd?: string;
+}): Promise<string> => {
+  const child = spawn(input.command, {
+    cwd: input.cwd,
+    env: process.env,
+    shell: true,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  let stderr = "";
+  let stdout = "";
+
+  child.stdout.on("data", (chunk: Buffer | string) => {
+    stdout += chunk.toString();
+  });
+
+  child.stderr.on("data", (chunk: Buffer | string) => {
+    stderr += chunk.toString();
+  });
+
+  const exitCode = await new Promise<number | null>((resolveExit, reject) => {
+    child.on("error", reject);
+    child.on("close", resolveExit);
+  });
+
+  if (exitCode !== 0) {
+    const detail = stderr.trim() || stdout.trim() || `${input.command} exited with code ${exitCode}`;
+
+    throw new Error(detail);
+  }
+
+  return stdout;
+};
+
+const parseWalletAddress = (output: string): string => {
+  const trimmed = output.trim();
+
+  if (!trimmed) {
+    throw new Error("awp-wallet status did not return an address.");
+  }
+
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+
+    if (typeof parsed === "string" && parsed.length > 0) {
+      return parsed;
+    }
+  } catch {
+    return trimmed;
+  }
+
+  return trimmed;
+};
+
+export const installWallet = async (input: {
+  mkdtemp?: (prefix: string) => Promise<string> | string;
+  onStep?: (step: string) => void;
+  rm?: (
+    path: string,
+    options: { force: boolean; recursive: boolean },
+  ) => Promise<void> | void;
+  runCommand?: (input: {
+    command: string;
+    cwd?: string;
+  }) => Promise<string | void> | string | void;
+  tmpdir?: () => string;
+} = {}): Promise<{
+  walletAddress: string;
+}> => {
+  const makeTemporaryDirectory = input.mkdtemp ?? mkdtemp;
+  const removeDirectory = input.rm ?? rm;
+  const runCommand = input.runCommand ?? runSpawnedCommand;
+  const resolveTemporaryRoot = input.tmpdir ?? tmpdir;
+  let temporaryDirectory = "";
+  let currentStep: string = INSTALL_STEPS[0];
+  let walletAddress = "";
+
+  try {
+    input.onStep?.(INSTALL_STEPS[0]);
+    temporaryDirectory = await makeTemporaryDirectory(
+      join(resolveTemporaryRoot(), "agent-store-cli-"),
+    );
+
+    const clonePath = join(temporaryDirectory, "awp-wallet");
+
+    currentStep = INSTALL_STEPS[1];
+    input.onStep?.(currentStep);
+    await runCommand({
+      command: `git clone ${AWP_WALLET_REPOSITORY_URL} ${clonePath}`,
+    });
+
+    currentStep = INSTALL_STEPS[2];
+    input.onStep?.(currentStep);
+    await runCommand({
+      command: "bash install.sh",
+      cwd: clonePath,
+    });
+
+    const addressOutput = await runCommand({
+      command: WALLET_ADDRESS_COMMAND,
+    });
+
+    walletAddress = parseWalletAddress(addressOutput ?? "");
+  } catch (error) {
+    if (error instanceof InstallWalletError) {
+      throw error;
+    }
+
+    const message = error instanceof Error ? error.message : "Wallet installation failed.";
+
+    throw new InstallWalletError(currentStep, message);
+  } finally {
+    if (temporaryDirectory) {
+      input.onStep?.(INSTALL_STEPS[3]);
+      await removeDirectory(temporaryDirectory, {
+        force: true,
+        recursive: true,
+      });
+    }
+  }
+
+  return {
+    walletAddress,
+  };
+};

package/src/init/ora-ui.ts

@@ -0,0 +1,124 @@
+import { stdin as defaultStdin, stdout as defaultStdout } from "node:process";
+
+import ora from "ora";
+
+import {
+  INIT_BANNER,
+  INITIAL_INIT_STATE,
+  applyNumberedMenuChoice,
+  beginWalletInstall,
+  completeInit,
+  failInit,
+  formatWalletFundingMessage,
+} from "./state.ts";
+
+export const ORA_SPINNER_NAME = "sand";
+
+type Reader = {
+  off: (event: "data", listener: (chunk: Buffer | string) => void) => void;
+  on: (event: "data", listener: (chunk: Buffer | string) => void) => void;
+  resume: () => void;
+  setEncoding: (encoding: BufferEncoding) => void;
+};
+
+type Writer = typeof defaultStdout;
+
+const readNumberedChoice = async (stdin: Reader): Promise<string> => {
+  stdin.setEncoding("utf8");
+  stdin.resume();
+
+  return new Promise<string>((resolve) => {
+    const onData = (chunk: Buffer | string) => {
+      const value = chunk.toString().trim();
+
+      if (!value) {
+        return;
+      }
+
+      stdin.off("data", onData);
+      resolve(value[0] ?? value);
+    };
+
+    stdin.on("data", onData);
+  });
+};
+
+export const runOraInitUi = async (input: {
+  installWallet: (
+    callback: (step: string) => void,
+  ) => Promise<{ walletAddress: string }>;
+  stdin?: Reader;
+  stdout?: Writer;
+}): Promise<{
+  exitCode: number;
+  selectedOption: "skip" | "wallet";
+}> => {
+  const stdin = input.stdin ?? defaultStdin;
+  const stdout = input.stdout ?? defaultStdout;
+
+  stdout.write(`${INIT_BANNER}\n${INITIAL_INIT_STATE.prompt}\n`);
+
+  while (true) {
+    const answer = await readNumberedChoice(stdin);
+    const selectedState = applyNumberedMenuChoice(INITIAL_INIT_STATE, answer);
+
+    if (!selectedState) {
+      stdout.write("Enter 1 or 2.\n");
+      continue;
+    }
+
+    if (selectedState.selectedOption === "skip") {
+      const completed = completeInit(selectedState, "Skipped wallet setup.");
+
+      stdout.write(`${completed.currentStep}\n${completed.message}\n`);
+
+      return {
+        exitCode: 0,
+        selectedOption: "skip",
+      };
+    }
+
+    const runningState = beginWalletInstall(selectedState);
+    const spinner = ora({
+      spinner: ORA_SPINNER_NAME,
+      stream: stdout,
+      text: runningState.currentStep,
+    });
+
+    spinner.start();
+
+    try {
+      const wallet = await input.installWallet((step) => {
+        spinner.text = step;
+      });
+
+      const completed = completeInit(
+        runningState,
+        formatWalletFundingMessage(wallet.walletAddress),
+      );
+
+      spinner.succeed(completed.currentStep);
+      stdout.write(`${completed.message}\n`);
+
+      return {
+        exitCode: 0,
+        selectedOption: "wallet",
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Wallet installation failed.";
+      const failed = failInit(runningState, message);
+      const step =
+        error instanceof Error && "step" in error && typeof error.step === "string"
+          ? error.step
+          : runningState.currentStep;
+
+      spinner.fail(failed.currentStep);
+      stdout.write(`${step}\n${failed.message}\n`);
+
+      return {
+        exitCode: 1,
+        selectedOption: "wallet",
+      };
+    }
+  }
+};

package/src/init/plain-ui.ts

@@ -0,0 +1,113 @@
+import { stdin as defaultStdin, stdout as defaultStdout } from "node:process";
+
+import {
+  INIT_BANNER,
+  INITIAL_INIT_STATE,
+  applyNumberedMenuChoice,
+  beginWalletInstall,
+  completeInit,
+  failInit,
+  formatWalletFundingMessage,
+} from "./state.ts";
+
+type Reader = {
+  on: (event: "data", listener: (chunk: Buffer | string) => void) => void;
+  off: (event: "data", listener: (chunk: Buffer | string) => void) => void;
+  resume: () => void;
+  setEncoding: (encoding: BufferEncoding) => void;
+};
+
+type Writer = {
+  write: (chunk: string) => void;
+};
+
+const readNumberedChoice = async (stdin: Reader): Promise<string> => {
+  stdin.setEncoding("utf8");
+  stdin.resume();
+
+  return new Promise<string>((resolve) => {
+    const onData = (chunk: Buffer | string) => {
+      const value = chunk.toString().trim();
+
+      if (!value) {
+        return;
+      }
+
+      stdin.off("data", onData);
+      resolve(value[0] ?? value);
+    };
+
+    stdin.on("data", onData);
+  });
+};
+
+export const runPlainInitUi = async (input: {
+  installWallet: (
+    callback: (step: string) => void,
+  ) => Promise<{ walletAddress: string }>;
+  stdin?: Reader;
+  stdout?: Writer;
+}): Promise<{
+  exitCode: number;
+  selectedOption: "skip" | "wallet";
+}> => {
+  const stdin = input.stdin ?? defaultStdin;
+  const stdout = input.stdout ?? defaultStdout;
+
+  stdout.write(`${INIT_BANNER}\n${INITIAL_INIT_STATE.prompt}\n`);
+
+  while (true) {
+    const answer = await readNumberedChoice(stdin);
+    const selectedState = applyNumberedMenuChoice(INITIAL_INIT_STATE, answer);
+
+    if (!selectedState) {
+      stdout.write("Enter 1 or 2.\n");
+      continue;
+    }
+
+    if (selectedState.selectedOption === "skip") {
+      const completed = completeInit(selectedState, "Skipped wallet setup.");
+
+      stdout.write(`${completed.currentStep}\n${completed.message}\n`);
+
+      return {
+        exitCode: 0,
+        selectedOption: "skip",
+      };
+    }
+
+    const runningState = beginWalletInstall(selectedState);
+
+    try {
+      const wallet = await input.installWallet((step) => {
+        stdout.write(`${step}\n`);
+      });
+
+      const completed = completeInit(
+        runningState,
+        formatWalletFundingMessage(wallet.walletAddress),
+      );
+
+      stdout.write(`${completed.currentStep}\n${completed.message}\n`);
+
+      return {
+        exitCode: 0,
+        selectedOption: "wallet",
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Wallet installation failed.";
+      const failed = failInit(runningState, message);
+      const step =
+        error instanceof Error && "step" in error && typeof error.step === "string"
+          ? error.step
+          : runningState.currentStep;
+
+      stdout.write(`${failed.currentStep}\n${step}\n${failed.message}\n`);
+
+      return {
+        exitCode: 1,
+        selectedOption: "wallet",
+      };
+    }
+  }
+};

package/src/init/state.ts

@@ -0,0 +1,105 @@
+export const INIT_BANNER = `    ___                    __     _____ __                
+   /   | ____ ____  ____  / /_   / ___// /_____  ________ 
+  / /| |/ __ \`/ _ \\/ __ \\/ __/   \\__ \\/ __/ __ \\/ ___/ _ \\
+ / ___ / /_/ /  __/ / / / /_    ___/ / /_/ /_/ / /  /  __/
+/_/  |_|\\__, /\\___/_/ /_/\\__/   /____/\\__/\\____/_/   \\___/ 
+      /____/                                              `;
+export const INIT_PROMPT = "Setup Wallet:\n\n1. Agent Wallet\n2. Skip";
+export const INSTALL_STEPS = [
+  "Checking prerequisites",
+  "Cloning awp-wallet",
+  "Running install.sh",
+  "Cleaning up",
+] as const;
+
+export type InitChoice = "wallet" | "skip";
+export type InitPhase = "menu" | "installing" | "completed" | "failed";
+export type InitStatus = "idle" | "selected" | "running" | "completed" | "failed";
+
+export type InitState = {
+  phase: InitPhase;
+  prompt: string;
+  selectedOption: InitChoice | null;
+  status: InitStatus;
+};
+
+export type RunningInitState = InitState & {
+  currentStep: (typeof INSTALL_STEPS)[number];
+  phase: "installing";
+  selectedOption: "wallet";
+  status: "running";
+  steps: readonly string[];
+};
+
+export type TerminalInitState = (RunningInitState | InitState) & {
+  currentStep: "Completed" | "Failed";
+  message: string;
+  phase: "completed" | "failed";
+  status: "completed" | "failed";
+};
+
+export const INITIAL_INIT_STATE: InitState = {
+  phase: "menu",
+  prompt: INIT_PROMPT,
+  selectedOption: null,
+  status: "idle",
+};
+
+export const formatWalletFundingMessage = (walletAddress: string): string =>
+  `Your wallet address is ${walletAddress}. Fund this address with some USDC so your agent can independently purchase the resources it needs.`;
+
+export const applyNumberedMenuChoice = (
+  state: InitState,
+  input: string,
+): InitState | null => {
+  const normalized = input.trim();
+
+  if (normalized === "1") {
+    return {
+      ...state,
+      selectedOption: "wallet",
+      status: "selected",
+    };
+  }
+
+  if (normalized === "2") {
+    return {
+      ...state,
+      selectedOption: "skip",
+      status: "selected",
+    };
+  }
+
+  return null;
+};
+
+export const beginWalletInstall = (state: InitState): RunningInitState => ({
+  ...state,
+  currentStep: INSTALL_STEPS[0],
+  phase: "installing",
+  selectedOption: "wallet",
+  status: "running",
+  steps: INSTALL_STEPS,
+});
+
+export const completeInit = (
+  state: InitState | RunningInitState,
+  message: string,
+): TerminalInitState => ({
+  ...state,
+  currentStep: "Completed",
+  message,
+  phase: "completed",
+  status: "completed",
+});
+
+export const failInit = (
+  state: InitState | RunningInitState,
+  message: string,
+): TerminalInitState => ({
+  ...state,
+  currentStep: "Failed",
+  message,
+  phase: "failed",
+  status: "failed",
+});

package/src/main.ts

@@ -0,0 +1,29 @@
+import { runInitCommand } from "./commands/init.ts";
+
+const HELP_TEXT = `agent-store
+
+Usage:
+  agent-store init
+  agent-store --help`;
+
+export const main = async (argv: string[]): Promise<number> => {
+  const [command, ...rest] = argv;
+
+  if (!command || command === "--help" || command === "-h") {
+    process.stdout.write(`${HELP_TEXT}\n`);
+    return 0;
+  }
+
+  if (command === "init") {
+    if (rest[0] === "--help" || rest[0] === "-h") {
+      process.stdout.write("Usage: agent-store init\n");
+      return 0;
+    }
+
+    return runInitCommand();
+  }
+
+  process.stderr.write(`Unknown command: ${command}\n`);
+  process.stdout.write(`${HELP_TEXT}\n`);
+  return 1;
+};