@paytaca/opencode-plugin 0.1.5 → 0.1.7

package/src/bundled/wrapper.ts

@@ -1,187 +0,0 @@
-// This file contains the bundled payment wrapper script as a string
-// It gets written to ~/.opencode-paytaca/paytaca-pay-wrapper.mjs at runtime
-// Uses the same approach as the original wrapper but finds paytaca-cli dynamically
-
-export const WRAPPER_SCRIPT_CONTENT = `#!/usr/bin/env node
-/**
- * Paytaca Pay Wrapper — handles large request bodies by reading from a file.
- * Imports paytaca-cli modules directly (avoids CLI argument size limits).
- */
-
-import { readFileSync } from 'fs';
-import { execSync } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-
-// Find paytaca-cli installation
-function findPaytacaCliPath() {
-  const possiblePaths = [];
-  
-  // Try to get global npm root
-  try {
-    const globalPath = execSync('npm root -g', { encoding: 'utf8' }).trim();
-    possiblePaths.push(
-      join(globalPath, 'paytaca-cli'),
-      join(globalPath, 'opencode-plugin', 'node_modules', 'paytaca-cli'),
-    );
-  } catch {}
-  
-  // Common global locations
-  possiblePaths.push(
-    '/usr/lib/node_modules/paytaca-cli',
-    '/usr/local/lib/node_modules/paytaca-cli',
-    '/opt/homebrew/lib/node_modules/paytaca-cli',
-  );
-  
-  // Try current file's node_modules (for bundled installs)
-  try {
-    const currentFile = fileURLToPath(import.meta.url);
-    const currentDir = dirname(currentFile);
-    possiblePaths.push(
-      join(currentDir, '..', 'node_modules', 'paytaca-cli'),
-      join(currentDir, '..', '..', 'node_modules', 'paytaca-cli'),
-    );
-  } catch {}
-  
-  // Find first valid path
-  for (const basePath of possiblePaths) {
-    try {
-      const walletPath = join(basePath, 'dist', 'wallet', 'index.js');
-      readFileSync(walletPath);
-      return basePath;
-    } catch {}
-  }
-  
-  throw new Error('paytaca-cli not found. Try reinstalling opencode-plugin: npm install @paytaca/opencode-plugin');
-}
-
-// Load paytaca-cli modules
-let loadMnemonic, loadWallet, LibauthHDWallet, X402Payer, parsePaymentRequiredJson, selectBchPaymentRequirements, BCH_DERIVATION_PATH;
-
-try {
-  const basePath = findPaytacaCliPath();
-  
-  ({ loadMnemonic, loadWallet } = await import(join(basePath, 'dist', 'wallet', 'index.js')));
-  ({ LibauthHDWallet } = await import(join(basePath, 'dist', 'wallet', 'keys.js')));
-  ({ X402Payer } = await import(join(basePath, 'dist', 'wallet', 'x402.js')));
-  ({ parsePaymentRequiredJson, selectBchPaymentRequirements } = await import(join(basePath, 'dist', 'utils', 'x402.js')));
-  ({ BCH_DERIVATION_PATH } = await import(join(basePath, 'dist', 'utils', 'network.js')));
-} catch (err) {
-  console.log(JSON.stringify({ success: false, error: 'Failed to load paytaca-cli: ' + err.message }));
-  process.exit(1);
-}
-
-async function main() {
-  const configPath = process.argv[2];
-  if (!configPath) {
-    console.log(JSON.stringify({ success: false, error: 'Usage: node paytaca-pay-wrapper.mjs <config.json>' }));
-    process.exit(1);
-  }
-
-  const config = JSON.parse(readFileSync(configPath, 'utf8'));
-  const { url, method, headers, bodyFile, chipnet, confirmed } = config;
-
-  const body = readFileSync(bodyFile, 'utf8');
-
-  const data = loadMnemonic();
-  if (!data) {
-    console.log(JSON.stringify({ success: false, error: 'No wallet found. Run paytaca wallet create first.' }));
-    process.exit(1);
-  }
-
-  const wallet = loadWallet();
-  const isChipnet = Boolean(chipnet);
-  const bchWallet = wallet.forNetwork(isChipnet);
-  const hdWallet = new LibauthHDWallet(data.mnemonic, BCH_DERIVATION_PATH, isChipnet ? 'chipnet' : 'mainnet');
-  const x402Payer = new X402Payer({ hdWallet, addressIndex: 0 });
-
-  try {
-    const result = await executePay(url, method, headers, body, bchWallet, x402Payer, isChipnet, confirmed);
-    console.log(JSON.stringify(result, null, 2));
-  } catch (err) {
-    console.log(JSON.stringify({ success: false, error: err.message || String(err) }, null, 2));
-    process.exit(1);
-  }
-}
-
-async function executePay(url, method, headers, body, bchWallet, x402Payer, isChipnet, confirmed) {
-  const response = await fetch(url, {
-    method,
-    headers,
-    body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,
-  });
-
-  const responseHeaders = {};
-  response.headers.forEach((value, key) => { responseHeaders[key] = value; });
-  const responseText = await response.text();
-  let responseData;
-  try { responseData = JSON.parse(responseText); } catch { responseData = responseText; }
-
-  if (response.status === 402) {
-    const paymentRequired = parsePaymentRequiredJson(responseData);
-    if (!paymentRequired) {
-      return { success: false, status: 402, error: 'Could not parse PaymentRequired from 402 response body' };
-    }
-    const requirements = selectBchPaymentRequirements(paymentRequired, isChipnet ? 'chipnet' : 'mainnet');
-    if (!requirements) {
-      return {
-        success: false, status: 402, error: 'Server does not accept BCH payment',
-        data: { acceptedSchemes: paymentRequired.accepts.map(a => ({ scheme: a.scheme, network: a.network })) },
-      };
-    }
-
-    const payerAddress = x402Payer.getPayerAddress();
-    const address = requirements.payTo;
-    const amountBch = Number(requirements.amount) / 1e8;
-    const changeAddressSet = bchWallet.getAddressSetAt(0);
-    const changeAddress = changeAddressSet.change;
-
-    if (!confirmed) {
-      return {
-        success: false, status: 402, error: 'Payment not confirmed.',
-        payment: { required: true, amount: requirements.amount, payTo: address },
-      };
-    }
-
-    const sendResult = await bchWallet.sendBch(amountBch, address, changeAddress);
-    if (!sendResult.success) {
-      return { success: false, status: 402, payment: { required: true, error: sendResult.error }, error: sendResult.error };
-    }
-
-    const txid = sendResult.txid;
-    const paymentPayload = await x402Payer.createPaymentPayload(requirements, paymentRequired.resource.url, txid, 0, requirements.amount);
-    headers['PAYMENT-SIGNATURE'] = JSON.stringify(paymentPayload);
-
-    const retryResponse = await fetch(url, {
-      method,
-      headers,
-      body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,
-    });
-    const retryResponseHeaders = {};
-    retryResponse.headers.forEach((value, key) => { retryResponseHeaders[key] = value; });
-    const retryResponseText = await retryResponse.text();
-    let retryResponseData;
-    try { retryResponseData = JSON.parse(retryResponseText); } catch { retryResponseData = retryResponseText; }
-
-    return {
-      success: retryResponse.ok,
-      status: retryResponse.status,
-      statusText: retryResponse.statusText,
-      headers: retryResponseHeaders,
-      data: retryResponseData,
-      payment: { required: true, txid, recipientAddress: address },
-    };
-  }
-
-  return {
-    success: response.ok,
-    status: response.status,
-    statusText: response.statusText,
-    headers: responseHeaders,
-    data: responseData,
-    payment: { required: false },
-  };
-}
-
-main();
-`;

package/src/config.ts

@@ -1,105 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { Config } from './types';
-
-// Default production backend
-export const DEFAULT_BACKEND_URL = 'https://api.paytaca.ai';
-export const DEFAULT_PROXY_PORT = 8001;
-
-// Config directory: ~/.opencode-paytaca/
-export function getConfigDir(): string {
-  const home = process.env.HOME || process.env.USERPROFILE || '.';
-  return path.join(home, '.opencode-paytaca');
-}
-
-export function ensureConfigDir(configDir: string): void {
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir, { recursive: true });
-  }
-}
-
-export function getConfigFile(configDir: string): string {
-  return path.join(configDir, 'config.json');
-}
-
-export function loadConfig(configDir: string): Config {
-  const configFile = getConfigFile(configDir);
-  
-  // Priority 1: Environment variable (highest priority, for dev/testing)
-  const envBackendUrl = process.env.PAYTACA_BACKEND_URL;
-  if (envBackendUrl) {
-    return {
-      backendUrl: envBackendUrl,
-      proxyPort: DEFAULT_PROXY_PORT,
-    };
-  }
-  
-  // Priority 2: Config file
-  if (fs.existsSync(configFile)) {
-    try {
-      const content = fs.readFileSync(configFile, 'utf8');
-      const parsed = JSON.parse(content);
-      return {
-        backendUrl: parsed.backendUrl || DEFAULT_BACKEND_URL,
-        proxyPort: parsed.proxyPort || DEFAULT_PROXY_PORT,
-        walletHash: parsed.walletHash,
-        proxyPid: parsed.proxyPid,
-      };
-    } catch (err) {
-      console.error('Failed to parse config:', err);
-    }
-  }
-  
-  // Priority 3: Default production backend
-  return {
-    backendUrl: DEFAULT_BACKEND_URL,
-    proxyPort: DEFAULT_PROXY_PORT,
-  };
-}
-
-export function saveConfig(configDir: string, config: Config): void {
-  const configFile = getConfigFile(configDir);
-  ensureConfigDir(configDir);
-  fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
-}
-
-export function getPidFile(configDir: string): string {
-  return path.join(configDir, 'proxy.pid');
-}
-
-export function getProxyScript(configDir: string): string {
-  return path.join(configDir, 'proxy.js');
-}
-
-export function getLogFile(configDir: string): string {
-  return path.join(configDir, 'proxy.log');
-}
-
-export function getWrapperScript(configDir: string): string {
-  return path.join(configDir, 'paytaca-pay-wrapper.mjs');
-}
-
-export function getHeartbeatFile(configDir: string): string {
-  return path.join(configDir, 'heartbeat');
-}
-
-// Touch the heartbeat file to signal the proxy we're still alive
-export function updateHeartbeat(configDir: string): void {
-  const heartbeatFile = getHeartbeatFile(configDir);
-  try {
-    // Write current timestamp
-    fs.writeFileSync(heartbeatFile, Date.now().toString());
-  } catch (err) {
-    // Ignore errors
-  }
-}
-
-// Start heartbeat interval that updates every 5 seconds
-export function startHeartbeat(configDir: string): NodeJS.Timeout {
-  // Update immediately
-  updateHeartbeat(configDir);
-  // Then every 5 seconds
-  return setInterval(() => {
-    updateHeartbeat(configDir);
-  }, 5000);
-}

package/src/index.ts

@@ -1,70 +0,0 @@
-import { ensureConfigDir, getConfigDir, loadConfig, saveConfig } from './config';
-import { checkWallet, ensureWallet, checkPaytacaCli, ensurePaytacaOnPath } from './wallet';
-import { startProxy } from './proxy';
-
-async function OpencodePlugin(_input?: any, _options?: any) {
-  const configDir = getConfigDir();
-  ensureConfigDir(configDir);
-
-  let config = loadConfig(configDir);
-
-  // Ensure paytaca binary is on PATH for internal use
-  ensurePaytacaOnPath();
-
-  // Check if paytaca-cli is installed
-  const hasPaytacaCli = await checkPaytacaCli();
-  if (!hasPaytacaCli) {
-    console.error('paytaca-cli not found. Install it with: npm install -g paytaca-cli');
-    return {};
-  }
-
-  // Ensure wallet exists (auto-create if needed)
-  try {
-    const wallet = await ensureWallet();
-
-    // Save wallet hash to config
-    if (wallet.hash) {
-      config.walletHash = wallet.hash;
-      saveConfig(configDir, config);
-    }
-  } catch (err: any) {
-    console.error('Wallet setup failed:', err.message);
-    return {};
-  }
-
-  // Start or reuse proxy
-  const proxy = await startProxy(configDir, config);
-
-  return {
-    config: async (cfg: any) => {
-      cfg.provider = cfg.provider || {};
-      cfg.provider['paytaca-ai'] = {
-        npm: '@ai-sdk/openai-compatible',
-        name: 'Paytaca AI',
-        options: {
-          baseURL: `http://localhost:${proxy.port}/v1`
-        },
-        models: {
-          'deepseek-ai/DeepSeek-V4-Flash': {
-            name: 'DeepSeek V4 Flash',
-            limit: {
-              context: 128000,
-              output: 8192
-            }
-          }
-        }
-      };
-    },
-    "chat.headers": async (_input: any, output: any) => {
-      let wallet = await checkWallet();
-      if (!wallet.exists) {
-        wallet = await ensureWallet();
-      }
-      output.headers = {
-        'X-Wallet-Hash': wallet.hash || ''
-      };
-    }
-  };
-}
-
-export = { id: '@paytaca/opencode-plugin', server: OpencodePlugin };

package/src/proxy.ts

@@ -1,283 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { spawn, execSync } from 'child_process';
-import { Config, ProxyInfo } from './types';
-import { 
-  getConfigDir, 
-  getPidFile, 
-  getProxyScript, 
-  getLogFile, 
-  getWrapperScript,
-  getHeartbeatFile,
-  saveConfig, 
-  loadConfig,
-  ensureConfigDir
-} from './config';
-import { PROXY_SCRIPT_CONTENT } from './bundled/proxy';
-import { WRAPPER_SCRIPT_CONTENT } from './bundled/wrapper';
-
-// Store heartbeat interval reference
-let heartbeatInterval: NodeJS.Timeout | null = null;
-
-// Get path to paytaca binary (multi-strategy resolution)
-function getPaytacaCommand(): string {
-  // Priority 1: Local node_modules (via require.resolve)
-  try {
-    const paytacaCliPkg = require.resolve('paytaca-cli/package.json');
-    return path.resolve(path.dirname(paytacaCliPkg), 'bin', 'paytaca.js');
-  } catch {}
-
-  // Priority 2: Local .bin symlink
-  const localPaytaca = path.join(__dirname, '..', 'node_modules', '.bin', 'paytaca');
-  if (fs.existsSync(localPaytaca)) {
-    return localPaytaca;
-  }
-
-  // Priority 3: Global npm root
-  try {
-    const globalRoot = execSync('npm root -g', { encoding: 'utf8' }).trim();
-    const pathsToCheck = [
-      path.join(globalRoot, 'paytaca-cli', 'bin', 'paytaca.js'),
-      path.join(globalRoot, '@paytaca', 'opencode-plugin', 'node_modules', 'paytaca-cli', 'bin', 'paytaca.js'),
-    ];
-    for (const p of pathsToCheck) {
-      if (fs.existsSync(p)) {
-        return p;
-      }
-    }
-  } catch {}
-
-  // Priority 4: Common global installation paths
-  const commonPaths = [
-    '/usr/lib/node_modules/paytaca-cli/bin/paytaca.js',
-    '/usr/local/lib/node_modules/paytaca-cli/bin/paytaca.js',
-    '/opt/homebrew/lib/node_modules/paytaca-cli/bin/paytaca.js',
-  ];
-  for (const p of commonPaths) {
-    if (fs.existsSync(p)) {
-      return p;
-    }
-  }
-
-  // Priority 5: which/where on PATH
-  try {
-    const which = process.platform === 'win32' ? 'where' : 'which';
-    const result = execSync(`${which} paytaca`, { encoding: 'utf8' }).trim().split('\n')[0];
-    if (result) {
-      return result;
-    }
-  } catch {}
-
-  // Priority 6: Bare command (rely on PATH at runtime)
-  return 'paytaca';
-}
-
-export async function isPortAvailable(port: number): Promise<boolean> {
-  return new Promise((resolve) => {
-    const server = require('net').createServer();
-    server.once('error', () => {
-      resolve(false);
-    });
-    server.once('listening', () => {
-      server.close();
-      resolve(true);
-    });
-    server.listen(port, '127.0.0.1');
-  });
-}
-
-export async function findAvailablePort(startPort: number = 8001, endPort: number = 8010): Promise<number> {
-  for (let port = startPort; port <= endPort; port++) {
-    if (await isPortAvailable(port)) {
-      return port;
-    }
-  }
-  throw new Error(`No available ports in range ${startPort}-${endPort}`);
-}
-
-export function isProcessRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function getProxyStatus(configDir: string): Promise<{ running: boolean; port?: number; pid?: number }> {
-  const pidFile = getPidFile(configDir);
-  
-  if (!fs.existsSync(pidFile)) {
-    return { running: false };
-  }
-  
-  try {
-    const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim());
-    if (isProcessRunning(pid)) {
-      const config = loadConfig(configDir);
-      return { running: true, port: config.proxyPort, pid };
-    }
-  } catch {
-    // Invalid PID file
-  }
-  
-  return { running: false };
-}
-
-export async function startProxy(configDir: string, config: Config): Promise<ProxyInfo> {
-  const pidFile = getPidFile(configDir);
-  const proxyScript = getProxyScript(configDir);
-  const logFile = getLogFile(configDir);
-  const wrapperScript = getWrapperScript(configDir);
-  
-  // Ensure config directory exists
-  ensureConfigDir(configDir);
-  
-  // Check if proxy already running
-  const existingStatus = await getProxyStatus(configDir);
-  if (existingStatus.running && existingStatus.pid && existingStatus.port) {
-    // Just reuse existing proxy, update heartbeat
-    const heartbeatFile = getHeartbeatFile(configDir);
-    fs.writeFileSync(heartbeatFile, Date.now().toString());
-    
-    // Start heartbeat updates
-    if (heartbeatInterval) {
-      clearInterval(heartbeatInterval);
-    }
-    heartbeatInterval = setInterval(() => {
-      try {
-        fs.writeFileSync(heartbeatFile, Date.now().toString());
-      } catch {}
-    }, 5000);
-    
-    return {
-      port: existingStatus.port,
-      pid: existingStatus.pid
-    };
-  }
-  
-  // Find available port
-  const port = await findAvailablePort(8001, 8010);
-  
-  // Write bundled proxy script to config directory
-  fs.writeFileSync(proxyScript, PROXY_SCRIPT_CONTENT, 'utf8');
-  fs.chmodSync(proxyScript, '755');
-  
-  // Write bundled wrapper script to config directory
-  fs.writeFileSync(wrapperScript, WRAPPER_SCRIPT_CONTENT, 'utf8');
-  fs.chmodSync(wrapperScript, '755');
-  
-  // Start proxy (detached to avoid receiving SIGINT from terminal)
-  const paytacaCmd = getPaytacaCommand();
-  const proxy = spawn('node', [
-    proxyScript,
-    config.backendUrl,
-    port.toString()
-  ], {
-    detached: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env: {
-      ...process.env,
-      PAYTACA_CMD: paytacaCmd
-    }
-  });
-  
-  proxy.unref();
-  
-  if (!proxy.pid) {
-    throw new Error('Failed to start proxy: no PID available');
-  }
-  
-  // Write PID file
-  fs.writeFileSync(pidFile, proxy.pid.toString());
-  
-  // Update config - new proxy (preserve wallet hash from passed config)
-  config.proxyPort = port;
-  config.proxyPid = proxy.pid;
-  saveConfig(configDir, config);
-  
-  // Initialize heartbeat file
-  const heartbeatFile = getHeartbeatFile(configDir);
-  fs.writeFileSync(heartbeatFile, Date.now().toString());
-  
-  // Start heartbeat updates
-  if (heartbeatInterval) {
-    clearInterval(heartbeatInterval);
-  }
-  heartbeatInterval = setInterval(() => {
-    try {
-      fs.writeFileSync(heartbeatFile, Date.now().toString());
-    } catch {}
-  }, 5000);
-  
-  // Handle proxy output
-  const logStream = fs.createWriteStream(logFile, { flags: 'a' });
-  proxy.stdout?.pipe(logStream);
-  proxy.stderr?.pipe(logStream);
-  
-  // Wait for proxy to be ready
-  await waitForProxy(port);
-  
-  return {
-    port,
-    pid: proxy.pid
-  };
-}
-
-export async function stopProxy(configDir: string): Promise<void> {
-  // Stop heartbeat updates
-  if (heartbeatInterval) {
-    clearInterval(heartbeatInterval);
-    heartbeatInterval = null;
-  }
-  
-  // Note: We don't kill the proxy here anymore.
-  // The proxy monitors the heartbeat file and exits itself when stale.
-  // This handles multi-window scenarios correctly.
-  
-  // Optional: Write a special "stopping" timestamp to speed up proxy shutdown
-  const heartbeatFile = getHeartbeatFile(configDir);
-  try {
-    fs.writeFileSync(heartbeatFile, '0');  // Special value: stopping
-    // Remove heartbeat file after a short delay
-    setTimeout(() => {
-      try {
-        if (fs.existsSync(heartbeatFile)) {
-          fs.unlinkSync(heartbeatFile);
-        }
-      } catch {}
-    }, 100);
-  } catch {}
-}
-
-async function waitForProxy(port: number, timeout: number = 10000): Promise<void> {
-  const start = Date.now();
-  
-  while (Date.now() - start < timeout) {
-    try {
-      const response = await fetch(`http://localhost:${port}/v1/config`, {
-        signal: AbortSignal.timeout(1000)
-      });
-      if (response.ok) {
-        return;
-      }
-    } catch {
-      // Not ready yet
-    }
-    await new Promise(resolve => setTimeout(resolve, 500));
-  }
-  
-  throw new Error(`Proxy failed to start on port ${port} within ${timeout}ms`);
-}
-
-export async function getProxyConfig(configDir: string): Promise<{ backendUrl: string; port: number } | null> {
-  const status = await getProxyStatus(configDir);
-  if (status.running && status.port) {
-    const config = loadConfig(configDir);
-    return {
-      backendUrl: config.backendUrl,
-      port: status.port
-    };
-  }
-  return null;
-}

package/src/types.ts

@@ -1,26 +0,0 @@
-export interface Config {
-  backendUrl: string;
-  proxyPort: number;
-  walletHash?: string;
-  proxyPid?: number;
-}
-
-export interface WalletInfo {
-  exists: boolean;
-  hash?: string;
-  address?: string;
-  balance?: string;
-  mnemonic?: string;
-}
-
-export interface ProxyStatus {
-  running: boolean;
-  port?: number;
-  pid?: number;
-  url?: string;
-}
-
-export interface ProxyInfo {
-  port: number;
-  pid: number;
-}