@ottocode/openclaw-setu 0.1.3 → 0.1.4

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,
-  };
-}