@ottocode/openclaw-setu 0.1.2 → 0.1.4

package/src/index.ts

@@ -1,197 +0,0 @@
-import type {
-  OpenClawPluginDefinition,
-  OpenClawPluginApi,
-  OpenClawPluginCommandDefinition,
-} from "./types.ts";
-import {
-  loadWallet,
-  ensureWallet,
-  getSetuBalance,
-  getWalletKeyPath,
-} from "./wallet.ts";
-import {
-  buildProviderConfig,
-  injectConfig,
-  isConfigured,
-} from "./config.ts";
-import { isValidPrivateKey } from "@ottocode/ai-sdk";
-
-const DEFAULT_PORT = 8403;
-
-function getPort(api: OpenClawPluginApi): number {
-  const cfg = api.pluginConfig as Record<string, unknown> | undefined;
-  return (cfg?.port as number) ?? DEFAULT_PORT;
-}
-
-const plugin: OpenClawPluginDefinition = {
-  id: "setu",
-  name: "Setu",
-  description: "Pay for AI with Solana USDC — no API keys, just a wallet.",
-  version: "0.1.0",
-
-  async register(api: OpenClawPluginApi) {
-    const port = getPort(api);
-
-    api.registerProvider({
-      id: "setu",
-      label: "Setu (Solana USDC)",
-      aliases: ["setu-solana"],
-      envVars: ["SETU_PRIVATE_KEY"],
-      models: buildProviderConfig(port),
-      auth: [
-        {
-          id: "setu-wallet",
-          label: "Solana Wallet",
-          hint: "Generate or import a Solana wallet — pay per token with USDC",
-          kind: "custom",
-          async run(ctx) {
-            const existing = loadWallet();
-
-            if (existing) {
-              ctx.prompter.note(
-                `Existing Setu wallet found: ${existing.publicKey}`,
-              );
-              return {
-                profiles: [
-                  {
-                    profileId: "setu-wallet",
-                    credential: {
-                      apiKey: "setu-proxy-handles-auth",
-                      type: "wallet",
-                      walletAddress: existing.publicKey,
-                    },
-                  },
-                ],
-                configPatch: {
-                  models: { providers: { setu: buildProviderConfig(port) } },
-                },
-                defaultModel: `setu/claude-sonnet-4-6`,
-                notes: [
-                  `Wallet: ${existing.publicKey}`,
-                  `Fund with USDC on Solana to start using.`,
-                  `Run \`openclaw-setu start\` to start the proxy.`,
-                ],
-              };
-            }
-
-            const keyInput = await ctx.prompter.text({
-              message:
-                "Enter Solana private key (base58) or press Enter to generate a new one:",
-              validate: (value: string) => {
-                if (value && !isValidPrivateKey(value)) {
-                  return "Invalid Solana private key";
-                }
-                return undefined;
-              },
-            });
-
-            const key = typeof keyInput === "string" ? keyInput : "";
-            const wallet = key ? ensureWallet() : ensureWallet();
-            if (key && isValidPrivateKey(key)) {
-              const { saveWallet } = await import("./wallet.ts");
-              saveWallet(key);
-            }
-
-            const finalWallet = loadWallet()!;
-
-            await injectConfig(port);
-
-            return {
-              profiles: [
-                {
-                  profileId: "setu-wallet",
-                  credential: {
-                    apiKey: "setu-proxy-handles-auth",
-                    type: "wallet",
-                    walletAddress: finalWallet.publicKey,
-                  },
-                },
-              ],
-              configPatch: {
-                models: { providers: { setu: buildProviderConfig(port) } },
-              },
-              defaultModel: `setu/claude-sonnet-4-6`,
-              notes: [
-                `Wallet generated: ${finalWallet.publicKey}`,
-                `Key stored at: ${getWalletKeyPath()}`,
-                `Fund with USDC on Solana: ${finalWallet.publicKey}`,
-                `Run \`openclaw-setu start\` to start the proxy.`,
-              ],
-            };
-          },
-        },
-      ],
-    });
-
-    const walletCmd: OpenClawPluginCommandDefinition = {
-      name: "wallet",
-      description: "Show your Setu wallet address and balances",
-      requireAuth: true,
-      async handler() {
-        const wallet = loadWallet();
-        if (!wallet) {
-          return { text: "No Setu wallet found. Run `openclaw-setu setup`." };
-        }
-
-        const balances = await getSetuBalance(wallet.privateKey);
-        const lines = [`Wallet: ${wallet.publicKey}`];
-
-        if (balances.setu) {
-          lines.push(`Setu Balance: $${balances.setu.balance.toFixed(4)}`);
-          lines.push(`Total Spent: $${balances.setu.totalSpent.toFixed(4)}`);
-          lines.push(`Requests: ${balances.setu.requestCount}`);
-        }
-        if (balances.wallet) {
-          lines.push(
-            `On-chain USDC: $${balances.wallet.usdcBalance.toFixed(4)} (${balances.wallet.network})`,
-          );
-        }
-
-        return { text: lines.join("\n") };
-      },
-    };
-
-    api.registerCommand(walletCmd);
-
-    const statusCmd: OpenClawPluginCommandDefinition = {
-      name: "setu-status",
-      description: "Check Setu plugin configuration status",
-      async handler() {
-        const wallet = loadWallet();
-        const configured = isConfigured();
-        const lines = [
-          `Wallet: ${wallet ? wallet.publicKey : "not set up"}`,
-          `OpenClaw config: ${configured ? "injected" : "not configured"}`,
-          `Proxy port: ${port}`,
-        ];
-        return { text: lines.join("\n") };
-      },
-    };
-
-    api.registerCommand(statusCmd);
-
-    api.registerService({
-      id: "setu-proxy",
-      async start() {
-        const wallet = loadWallet();
-        if (!wallet) {
-          api.logger.warn(
-            "Setu: No wallet found. Run `openclaw-setu setup` first.",
-          );
-          return;
-        }
-        try {
-          const { createProxy } = await import("./proxy.ts");
-          createProxy({ port, verbose: false });
-          api.logger.info(
-            `Setu proxy running on http://localhost:${port}`,
-          );
-        } catch (err) {
-          api.logger.error(`Setu proxy failed: ${(err as Error).message}`);
-        }
-      },
-    });
-  },
-};
-
-export default plugin;

package/src/proxy.ts

@@ -1,149 +0,0 @@
-import { createSetuFetch, createWalletContext } from "@ottocode/ai-sdk";
-import { loadWallet } from "./wallet.ts";
-
-const DEFAULT_PORT = 8403;
-const DEFAULT_BASE_URL = "https://api.setu.ottocode.io";
-
-export interface ProxyOptions {
-  port?: number;
-  baseURL?: string;
-  verbose?: boolean;
-}
-
-export function createProxy(options: ProxyOptions = {}) {
-  const port = options.port ?? DEFAULT_PORT;
-  const baseURL = options.baseURL ?? DEFAULT_BASE_URL;
-  const verbose = options.verbose ?? false;
-
-  const wallet = loadWallet();
-  if (!wallet) {
-    throw new Error(
-      "No wallet found. Run `openclaw-setu setup` or `openclaw-setu wallet generate` first.",
-    );
-  }
-
-  const log = verbose
-    ? (msg: string) => console.log(`[setu-proxy] ${msg}`)
-    : (_msg: string) => {};
-
-  const walletCtx = createWalletContext({ privateKey: wallet.privateKey });
-
-  const setuFetch = createSetuFetch({
-    wallet: walletCtx,
-    baseURL,
-    callbacks: {
-      onPaymentRequired: (amountUsd) => {
-        log(`Payment required: $${amountUsd.toFixed(4)}`);
-      },
-      onPaymentComplete: (data) => {
-        log(
-          `Payment complete: $${data.amountUsd.toFixed(4)} | balance: $${data.newBalance.toFixed(4)}`,
-        );
-      },
-      onPaymentError: (error) => {
-        console.error(`[setu-proxy] Payment error: ${error}`);
-      },
-      onBalanceUpdate: (update) => {
-        log(
-          `Cost: $${update.costUsd.toFixed(4)} | remaining: $${update.balanceRemaining.toFixed(4)}`,
-        );
-      },
-    },
-  });
-
-  const proxyBaseURL = baseURL;
-
-  const server = Bun.serve({
-    port,
-    async fetch(req: Request): Promise<Response> {
-      const url = new URL(req.url);
-
-      if (url.pathname === "/health") {
-        return Response.json({
-          status: "ok",
-          wallet: wallet.publicKey,
-          provider: "setu",
-        });
-      }
-
-      if (url.pathname === "/v1/models") {
-        log("GET /v1/models");
-        const resp = await setuFetch(`${proxyBaseURL}/v1/models`, {
-          method: "GET",
-          headers: { "Content-Type": "application/json" },
-        });
-        return new Response(resp.body, {
-          status: resp.status,
-          headers: {
-            "Content-Type":
-              resp.headers.get("Content-Type") ?? "application/json",
-            "Access-Control-Allow-Origin": "*",
-          },
-        });
-      }
-
-      const isCompletions = url.pathname === "/v1/chat/completions";
-      const isResponses = url.pathname === "/v1/responses";
-      if (!isCompletions && !isResponses) {
-        const targetURL = `${proxyBaseURL}${url.pathname}`;
-        log(`Proxying ${req.method} ${url.pathname}`);
-        const resp = await setuFetch(targetURL, {
-          method: req.method,
-          headers: { "Content-Type": "application/json" },
-          body: req.method !== "GET" ? await req.text() : undefined,
-        });
-        return new Response(resp.body, {
-          status: resp.status,
-          headers: {
-            "Content-Type":
-              resp.headers.get("Content-Type") ?? "application/json",
-            "Access-Control-Allow-Origin": "*",
-          },
-        });
-      }
-
-      const body = await req.text();
-      let parsed: Record<string, unknown> = {};
-      try {
-        parsed = JSON.parse(body);
-      } catch {
-        return Response.json({ error: "Invalid JSON body" }, { status: 400 });
-      }
-
-      const model = parsed.model as string;
-      const stream = parsed.stream as boolean;
-      log(
-        `${isCompletions ? "POST /v1/chat/completions" : "POST /v1/responses"} model=${model} stream=${stream}`,
-      );
-
-      const targetURL = `${proxyBaseURL}${url.pathname}`;
-      const resp = await setuFetch(targetURL, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body,
-      });
-
-      if (stream && resp.body) {
-        return new Response(resp.body, {
-          status: resp.status,
-          headers: {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive",
-            "Access-Control-Allow-Origin": "*",
-          },
-        });
-      }
-
-      return new Response(resp.body, {
-        status: resp.status,
-        headers: {
-          "Content-Type": "application/json",
-          "Access-Control-Allow-Origin": "*",
-        },
-      });
-    },
-  });
-
-  return { server, port, wallet };
-}

package/src/types.ts

@@ -1,154 +0,0 @@
-export type ModelApi =
-  | "openai-completions"
-  | "openai-responses"
-  | "anthropic-messages"
-  | "google-generative-ai"
-  | "github-copilot"
-  | "bedrock-converse-stream";
-
-export type ModelDefinitionConfig = {
-  id: string;
-  name: string;
-  api?: ModelApi;
-  reasoning?: boolean;
-  input?: Array<"text" | "image">;
-  cost?: {
-    input: number;
-    output: number;
-    cacheRead?: number;
-    cacheWrite?: number;
-  };
-  contextWindow?: number;
-  maxTokens?: number;
-  headers?: Record<string, string>;
-};
-
-export type ModelProviderConfig = {
-  baseUrl: string;
-  apiKey?: string;
-  api?: ModelApi;
-  headers?: Record<string, string>;
-  authHeader?: boolean;
-  models: ModelDefinitionConfig[];
-};
-
-export type AuthProfileCredential = {
-  apiKey?: string;
-  type?: string;
-  [key: string]: unknown;
-};
-
-export type ProviderAuthResult = {
-  profiles: Array<{ profileId: string; credential: AuthProfileCredential }>;
-  configPatch?: Record<string, unknown>;
-  defaultModel?: string;
-  notes?: string[];
-};
-
-export type WizardPrompter = {
-  text: (opts: {
-    message: string;
-    validate?: (value: string) => string | undefined;
-  }) => Promise<string | symbol>;
-  note: (message: string) => void;
-  progress: (message: string) => { stop: (message?: string) => void };
-};
-
-export type ProviderAuthContext = {
-  config: Record<string, unknown>;
-  agentDir?: string;
-  workspaceDir?: string;
-  prompter: WizardPrompter;
-  runtime: { log: (message: string) => void };
-  isRemote: boolean;
-  openUrl: (url: string) => Promise<void>;
-};
-
-export type ProviderAuthMethod = {
-  id: string;
-  label: string;
-  hint?: string;
-  kind: "oauth" | "api_key" | "token" | "device_code" | "custom";
-  run: (ctx: ProviderAuthContext) => Promise<ProviderAuthResult>;
-};
-
-export type ProviderPlugin = {
-  id: string;
-  label: string;
-  docsPath?: string;
-  aliases?: string[];
-  envVars?: string[];
-  models?: ModelProviderConfig;
-  auth: ProviderAuthMethod[];
-  formatApiKey?: (cred: AuthProfileCredential) => string;
-};
-
-export type PluginLogger = {
-  debug?: (message: string) => void;
-  info: (message: string) => void;
-  warn: (message: string) => void;
-  error: (message: string) => void;
-};
-
-export type OpenClawPluginService = {
-  id: string;
-  start: () => void | Promise<void>;
-  stop?: () => void | Promise<void>;
-};
-
-export type OpenClawPluginApi = {
-  id: string;
-  name: string;
-  version?: string;
-  description?: string;
-  source: string;
-  config: Record<string, unknown> & {
-    models?: { providers?: Record<string, ModelProviderConfig> };
-    agents?: Record<string, unknown>;
-  };
-  pluginConfig?: Record<string, unknown>;
-  logger: PluginLogger;
-  registerProvider: (provider: ProviderPlugin) => void;
-  registerTool: (tool: unknown, opts?: unknown) => void;
-  registerHook: (events: string | string[], handler: unknown, opts?: unknown) => void;
-  registerHttpRoute: (params: { path: string; handler: unknown }) => void;
-  registerService: (service: OpenClawPluginService) => void;
-  registerCommand: (command: unknown) => void;
-  resolvePath: (input: string) => string;
-  on: (hookName: string, handler: unknown, opts?: unknown) => void;
-};
-
-export type OpenClawPluginDefinition = {
-  id?: string;
-  name?: string;
-  description?: string;
-  version?: string;
-  register?: (api: OpenClawPluginApi) => void | Promise<void>;
-  activate?: (api: OpenClawPluginApi) => void | Promise<void>;
-};
-
-export type PluginCommandContext = {
-  senderId?: string;
-  channel: string;
-  isAuthorizedSender: boolean;
-  args?: string;
-  commandBody: string;
-  config: Record<string, unknown>;
-};
-
-export type PluginCommandResult = {
-  text?: string;
-  isError?: boolean;
-};
-
-export type PluginCommandHandler = (
-  ctx: PluginCommandContext,
-) => PluginCommandResult | Promise<PluginCommandResult>;
-
-export type OpenClawPluginCommandDefinition = {
-  name: string;
-  description: string;
-  acceptsArgs?: boolean;
-  requireAuth?: boolean;
-  handler: PluginCommandHandler;
-};

package/src/wallet.ts

@@ -1,79 +0,0 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import {
-  generateWallet,
-  importWallet,
-  isValidPrivateKey,
-  fetchBalance,
-  fetchWalletUsdcBalance,
-} from "@ottocode/ai-sdk";
-import type { WalletInfo } from "@ottocode/ai-sdk";
-
-const WALLET_DIR = join(homedir(), ".openclaw", "setu");
-const WALLET_KEY_PATH = join(WALLET_DIR, "wallet.key");
-
-export function getWalletKeyPath(): string {
-  return WALLET_KEY_PATH;
-}
-
-export function loadWallet(): WalletInfo | null {
-  try {
-    if (!existsSync(WALLET_KEY_PATH)) return null;
-    const privateKey = readFileSync(WALLET_KEY_PATH, "utf-8").trim();
-    if (!isValidPrivateKey(privateKey)) return null;
-    return importWallet(privateKey);
-  } catch {
-    return null;
-  }
-}
-
-export function saveWallet(privateKey: string): WalletInfo {
-  if (!isValidPrivateKey(privateKey)) {
-    throw new Error("Invalid Solana private key");
-  }
-  const wallet = importWallet(privateKey);
-  mkdirSync(WALLET_DIR, { recursive: true });
-  writeFileSync(WALLET_KEY_PATH, privateKey, { mode: 0o600 });
-  return wallet;
-}
-
-export function ensureWallet(): WalletInfo {
-  const existing = loadWallet();
-  if (existing) return existing;
-  const wallet = generateWallet();
-  saveWallet(wallet.privateKey);
-  return wallet;
-}
-
-export function exportWalletKey(): string | null {
-  try {
-    if (!existsSync(WALLET_KEY_PATH)) return null;
-    return readFileSync(WALLET_KEY_PATH, "utf-8").trim();
-  } catch {
-    return null;
-  }
-}
-
-export async function getSetuBalance(privateKey: string): Promise<{
-  setu: { balance: number; totalSpent: number; requestCount: number } | null;
-  wallet: { usdcBalance: number; network: string } | null;
-}> {
-  const [setu, wallet] = await Promise.all([
-    fetchBalance({ privateKey }),
-    fetchWalletUsdcBalance({ privateKey }),
-  ]);
-
-  return {
-    setu: setu
-      ? {
-          balance: setu.balance,
-          totalSpent: setu.totalSpent,
-          requestCount: setu.requestCount,
-        }
-      : null,
-    wallet: wallet
-      ? { usdcBalance: wallet.usdcBalance, network: wallet.network }
-      : null,
-  };
-}