@paytaca/opencode-plugin 0.1.13 → 0.1.15

package/dist/bundled/proxy.js

@@ -45,37 +45,6 @@ function log(message) {
   logStream.write(timestamp + ' [Proxy] ' + message + '\\n');
 }
 
-// Heartbeat monitoring - proxy exits if heartbeat is stale
-const HEARTBEAT_FILE = path.join(LOG_DIR, 'heartbeat');
-const HEARTBEAT_TIMEOUT = 300000; // 5 minutes
-
-function checkHeartbeat() {
-  try {
-    if (!fs.existsSync(HEARTBEAT_FILE)) {
-      // No heartbeat file yet, wait a bit
-      return true;
-    }
-    const heartbeat = parseInt(fs.readFileSync(HEARTBEAT_FILE, 'utf8'));
-    if (heartbeat === 0) {
-      // Special value: plugin is stopping
-      log('Heartbeat = 0, shutting down...');
-      return false;
-    }
-    const elapsed = Date.now() - heartbeat;
-    if (elapsed > HEARTBEAT_TIMEOUT) {
-      log('Heartbeat stale (' + elapsed + 'ms), shutting down...');
-      return false;
-    }
-    return true;
-  } catch (err) {
-    // If we can't read heartbeat, keep running (graceful degradation)
-    return true;
-  }
-}
-
-// Heartbeat checker reference (will be started after server creation)
-let heartbeatChecker = null;
-
 // Store pending payment requests per wallet hash
 // Each entry: { body, modelId, displayName, durationMinutes, tiers[], step }
 // step: 'tier_select' (user must pick a tier) or 'approval' (yes/no)
@@ -172,22 +141,19 @@ function sseDone(res) {
   res.write('data: [DONE]\\n\\n');
 }
 
-// Build and stream SSE tier selection prompt
-async function streamTierSelectionPrompt(res, walletHash, modelName, tiers) {
-  res.writeHead(200, {
-    'Content-Type': 'text/event-stream',
-    'Cache-Control': 'no-cache',
-    'X-Payment-Required': 'true',
-    'Connection': 'keep-alive',
-  });
-
-  sseLine(res, {
-    id: 'tier-1',
-    object: 'chat.completion.chunk',
-    created: Math.floor(Date.now() / 1000),
-    model: modelName,
-    choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
-  });
+// Stream the tier-selection prompt body (SSE lines) into an in-progress response.
+// When includeRole is false the leading role delta is skipped, so the body can be
+// appended to a stream that already emitted content (e.g. after a payment failure).
+async function streamTierSelectionBody(res, walletHash, modelName, tiers, includeRole) {
+  if (includeRole !== false) {
+    sseLine(res, {
+      id: 'tier-1',
+      object: 'chat.completion.chunk',
+      created: Math.floor(Date.now() / 1000),
+      model: modelName,
+      choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
+    });
+  }
 
   // Loading sequence
   sseLine(res, {
@@ -275,7 +241,19 @@ async function streamTierSelectionPrompt(res, walletHash, modelName, tiers) {
     choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
     usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
   });
+}
 
+// Build and stream a full tier-selection prompt (headers + body + [DONE]) to the client.
+async function streamTierSelectionPrompt(res, walletHash, modelName, tiers) {
+  if (!res.headersSent) {
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'X-Payment-Required': 'true',
+      'Connection': 'keep-alive',
+    });
+  }
+  await streamTierSelectionBody(res, walletHash, modelName, tiers, true);
   sseDone(res);
   res.end();
 }
@@ -567,8 +545,15 @@ function forceNonStreaming(body) {
 }
 
 // Convert a chat.completion JSON object to SSE format
-function jsonToSse(res, chatCompletion) {
-  const content = chatCompletion.choices?.[0]?.message?.content || '';
+function jsonToSse(res, chatCompletion, opts) {
+  opts = opts || {};
+  if (res.destroyed || res.writableEnded) {
+    log('jsonToSse: response already destroyed/ended, cannot send SSE');
+    return;
+  }
+  const message = chatCompletion.choices?.[0]?.message || {};
+  const content = message.content || '';
+  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : null;
   const model = chatCompletion.model || chatCompletion.model_id || 'deepseek/deepseek-v4-flash';
   const created = chatCompletion.created || Math.floor(Date.now() / 1000);
 
@@ -580,6 +565,7 @@ function jsonToSse(res, chatCompletion) {
         'Connection': 'keep-alive',
       });
     } catch (e) {
+      log('jsonToSse writeHead failed: ' + e.message);
       return;
     }
   }
@@ -593,45 +579,115 @@ function jsonToSse(res, chatCompletion) {
       choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
     });
   } catch (e) {
+    log('jsonToSse: failed to write role delta: ' + e.message);
   }
 
+  const allContent = (opts.prependContent || '') + content;
   const chunkSize = 20;
   let chunksWritten = 0;
-  for (let i = 0; i < content.length; i += chunkSize) {
+  for (let i = 0; i < allContent.length; i += chunkSize) {
     try {
       sseLine(res, {
         id: 'chatcmpl-' + (i + 2),
         object: 'chat.completion.chunk',
         created,
         model,
-        choices: [{ index: 0, delta: { content: content.slice(i, i + chunkSize) }, finish_reason: null }],
+        choices: [{ index: 0, delta: { content: allContent.slice(i, i + chunkSize) }, finish_reason: null }],
       });
       chunksWritten++;
     } catch (e) {
+      log('jsonToSse: failed to write content chunk ' + (i / chunkSize) + ': ' + e.message);
       break;
     }
   }
 
+  let finishReason = 'stop';
+  if (toolCalls && toolCalls.length > 0) {
+    const toolCallDeltas = [];
+    for (let i = 0; i < toolCalls.length; i++) {
+      const tc = toolCalls[i] || {};
+      const fn = tc.function || {};
+      let args = fn.arguments;
+      if (args !== undefined && typeof args !== 'string') {
+        try { args = JSON.stringify(args); } catch (e) { args = String(args); }
+      }
+      toolCallDeltas.push({
+        index: i,
+        id: tc.id || ('call_' + i),
+        type: 'function',
+        function: {
+          name: fn.name || '',
+          arguments: args === undefined || args === null ? '' : String(args),
+        },
+      });
+    }
+    try {
+      sseLine(res, {
+        id: 'chatcmpl-tools',
+        object: 'chat.completion.chunk',
+        created,
+        model,
+        choices: [{ index: 0, delta: { tool_calls: toolCallDeltas }, finish_reason: null }],
+      });
+    } catch (e) {
+      log('jsonToSse: failed to write tool_calls: ' + e.message);
+    }
+    finishReason = 'tool_calls';
+  }
+
   try {
     sseLine(res, {
       id: 'chatcmpl-done',
       object: 'chat.completion.chunk',
       created,
       model,
-      choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+      choices: [{ index: 0, delta: {}, finish_reason: finishReason }],
       usage: chatCompletion.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
     });
   } catch (e) {
+    log('jsonToSse: failed to write final delta: ' + e.message);
   }
 
   try {
     sseDone(res);
   } catch (e) {
+    log('jsonToSse: failed to write [DONE]: ' + e.message);
+  }
+
+  try {
+    res.end();
+  } catch (e) {
+    log('jsonToSse: res.end() failed: ' + e.message);
   }
+}
 
+// Stream a payment-failure message, then re-show the tier-selection prompt so the
+// user can retry the same or a different plan without sending another message.
+// The pending payment is restored to the tier-select step so the next tier pick is
+// handled by the proxy instead of being forwarded fresh to Django.
+async function streamPaymentFailureAndRetry(res, walletHash, pendingPayload, message) {
+  try {
+    sseLine(res, {
+      id: 'pay-err',
+      object: 'chat.completion.chunk',
+      created: Math.floor(Date.now() / 1000),
+      model: 'deepseek/deepseek-v4-flash',
+      choices: [{ index: 0, delta: { content: message }, finish_reason: 'stop' }],
+    });
+  } catch (e) {
+  }
+  pendingPayload.step = 'tier_select';
+  pendingPayload.durationMinutes = null;
+  pendingPayments.set(walletHash, pendingPayload);
   try {
+    const tiers = Array.isArray(pendingPayload.tiers) ? pendingPayload.tiers : [];
+    if (tiers.length > 0) {
+      await streamTierSelectionBody(res, walletHash, pendingPayload.displayName || pendingPayload.modelId || 'AI Model', tiers, false);
+    }
+    sseDone(res);
     res.end();
   } catch (e) {
+    try { res.end(); } catch (e2) {}
   }
 }
 
@@ -696,7 +752,17 @@ function runPaytacaPay(djangoUrl, body, walletHash, extraHeaders, callback) {
         callback(new Error('Could not parse paytaca pay response: ' + err.message));
       }
     } else {
-      callback(new Error(stderr.trim() || 'paytaca pay wrapper exited with code ' + code));
+      // Try to extract error from stdout (wrapper writes JSON errors to stdout, not stderr)
+      let wrapperErr = stderr.trim();
+      if (!wrapperErr) {
+        try {
+          const parsed = JSON.parse(stdout.trim());
+          wrapperErr = parsed.error || 'Unknown error';
+        } catch {
+          wrapperErr = stdout.trim() || 'paytaca pay wrapper exited with code ' + code;
+        }
+      }
+      callback(new Error(wrapperErr));
     }
   });
 
@@ -1062,42 +1128,49 @@ const server = http.createServer(async (req, res) => {
               res.write(': keepalive\\n\\n');
             }, 2000);
 
-            runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, (err, responseJson) => {
+            runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, async (err, responseJson) => {
               pendingPayments.delete(walletHash);
               clearInterval(keepalive);
 
               if (err) {
                 log('paytaca pay failed: ' + err.message);
-                if (res.headersSent) {
+                if (res.headersSent && !res.destroyed && !res.writableEnded) {
+                  await streamPaymentFailureAndRetry(res, walletHash, pendingPayload, '\\n\\n❌ Payment failed: ' + err.message + '\\n\\n');
+                } else if (!res.headersSent) {
                   try {
-                    sseLine(res, { id: 'pay-err', object: 'chat.completion.chunk', created: Math.floor(Date.now() / 1000), model: 'deepseek/deepseek-v4-flash', choices: [{ index: 0, delta: { content: '\\n\\n❌ Payment failed: ' + err.message }, finish_reason: 'stop' }] });
-                    sseLine(res, { id: 'pay-err-done', object: 'chat.completion.chunk', choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] });
-                    sseDone(res);
-                    res.end();
-                  } catch (e) {}
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Payment failed', message: err.message, details: 'Please check your wallet balance and try again.' }));
+                  } catch (e) { log('Failed to send payment error response: ' + e.message); }
                 } else {
-                  res.writeHead(500, { 'Content-Type': 'application/json' });
-                  res.end(JSON.stringify({ error: 'Payment failed', message: err.message, details: 'Please check your wallet balance and try again.' }));
+                  log('Cannot send payment failure — response already ended or destroyed');
                 }
                 return;
               }
               
               if (!responseJson.success) {
                 const isTimeout = responseJson.timeout;
-                const sseContent = isTimeout ? '\\n\\n⏱️ Response timed out. Your payment was processed \\u2014 check credits with \\'credits\\' and try again' : '\\n\\n❌ Payment failed: ' + (responseJson.error || 'Unknown error');
+                const sseContent = isTimeout ? '\\n\\n⏱️ Response timed out. Your payment was processed \\u2014 check credits with \\'credits\\' and try again' : '\\n\\n❌ Payment failed: ' + (responseJson.error || 'Unknown error') + '\\n\\n';
                 const errLabel = isTimeout ? 'Response timeout' : 'Payment failed';
                 const errMsg = isTimeout ? 'Response timed out. Payment was processed.' : responseJson.error;
                 const errDetails = isTimeout ? 'Try again or check credits with \\'credits\\'.' : 'Please check your balance and try again.';
-                if (res.headersSent) {
+                if (res.headersSent && !res.destroyed && !res.writableEnded) {
+                  if (isTimeout) {
+                    try {
+                      sseLine(res, { id: 'pay-err', object: 'chat.completion.chunk', created: Math.floor(Date.now() / 1000), model: 'deepseek/deepseek-v4-flash', choices: [{ index: 0, delta: { content: sseContent }, finish_reason: 'stop' }] });
+                      sseLine(res, { id: 'pay-err-done', object: 'chat.completion.chunk', choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] });
+                      sseDone(res);
+                      res.end();
+                    } catch (e) { log('Failed to send timeout error via SSE: ' + e.message); }
+                  } else {
+                    await streamPaymentFailureAndRetry(res, walletHash, pendingPayload, sseContent);
+                  }
+                } else if (!res.headersSent) {
                   try {
-                    sseLine(res, { id: 'pay-err', object: 'chat.completion.chunk', created: Math.floor(Date.now() / 1000), model: 'deepseek/deepseek-v4-flash', choices: [{ index: 0, delta: { content: sseContent }, finish_reason: 'stop' }] });
-                    sseLine(res, { id: 'pay-err-done', object: 'chat.completion.chunk', choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] });
-                    sseDone(res);
-                    res.end();
-                  } catch (e) {}
+                    res.writeHead(responseJson.status || 500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: errLabel, message: errMsg, details: errDetails }));
+                  } catch (e) { log('Failed to send payment error JSON: ' + e.message); }
                 } else {
-                  res.writeHead(responseJson.status || 500, { 'Content-Type': 'application/json' });
-                  res.end(JSON.stringify({ error: errLabel, message: errMsg, details: errDetails }));
+                  log('Cannot send payment error — response already ended or destroyed');
                 }
                 return;
               }
@@ -1111,15 +1184,22 @@ const server = http.createServer(async (req, res) => {
               
               log('paytaca pay succeeded. Returning chat response.');
               
+              if (res.destroyed || res.writableEnded) {
+                log('Payment succeeded but response connection is gone — cannot deliver chat response');
+                return;
+              }
+
               if (wasStreaming) {
                 try {
-                  jsonToSse(res, chatCompletion);
-                } catch (e) {}
+                  jsonToSse(res, chatCompletion, { prependContent: '\\n💳 Payment successful — generating your response...\\n\\n' });
+                } catch (e) { log('jsonToSse threw: ' + e.message); }
               } else {
                 try {
-                  res.writeHead(200, { 'Content-Type': 'application/json' });
+                  if (!res.headersSent) {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                  }
                   res.end(JSON.stringify(chatCompletion));
-                } catch (e) {}
+                } catch (e) { log('Failed to send non-streaming response: ' + e.message); }
               }
             });
             return;
@@ -1161,16 +1241,20 @@ const server = http.createServer(async (req, res) => {
             clearInterval(keepalive);
             if (err) {
               log('paytaca pay failed: ' + err.message);
-              if (res.headersSent) {
+              if (res.headersSent && !res.destroyed && !res.writableEnded) {
                 try {
                   sseLine(res, { id: 'pay-err', object: 'chat.completion.chunk', created: Math.floor(Date.now() / 1000), model: 'deepseek/deepseek-v4-flash', choices: [{ index: 0, delta: { content: '\\n\\n❌ Payment failed: ' + err.message }, finish_reason: 'stop' }] });
                   sseLine(res, { id: 'pay-err-done', object: 'chat.completion.chunk', choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] });
                   sseDone(res);
                   res.end();
-                } catch (e) {}
+                } catch (e) { log('Failed to send payment error via SSE: ' + e.message); }
+              } else if (!res.headersSent) {
+                try {
+                  res.writeHead(500, { 'Content-Type': 'application/json' });
+                  res.end(JSON.stringify({ error: 'Payment failed', message: err.message, details: 'Please check your wallet balance and try again.' }));
+                } catch (e) { log('Failed to send payment error JSON: ' + e.message); }
               } else {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Payment failed', message: err.message, details: 'Please check your wallet balance and try again.' }));
+                log('Cannot send payment failure — response already ended or destroyed');
               }
               return;
             }
@@ -1181,16 +1265,20 @@ const server = http.createServer(async (req, res) => {
               const errLabel = isTimeout ? 'Response timeout' : 'Payment failed';
               const errMsg = isTimeout ? 'Response timed out. Payment was processed.' : responseJson.error;
               const errDetails = isTimeout ? 'Try again or check credits with \\'credits\\'.' : 'Please check your balance and try again.';
-              if (res.headersSent) {
+              if (res.headersSent && !res.destroyed && !res.writableEnded) {
                 try {
                   sseLine(res, { id: 'pay-err', object: 'chat.completion.chunk', created: Math.floor(Date.now() / 1000), model: 'deepseek/deepseek-v4-flash', choices: [{ index: 0, delta: { content: sseContent }, finish_reason: 'stop' }] });
                   sseLine(res, { id: 'pay-err-done', object: 'chat.completion.chunk', choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] });
                   sseDone(res);
                   res.end();
-                } catch (e) {}
+                } catch (e) { log('Failed to send error via SSE: ' + e.message); }
+              } else if (!res.headersSent) {
+                try {
+                  res.writeHead(responseJson.status || 500, { 'Content-Type': 'application/json' });
+                  res.end(JSON.stringify({ error: errLabel, message: errMsg, details: errDetails }));
+                } catch (e) { log('Failed to send error JSON: ' + e.message); }
               } else {
-                res.writeHead(responseJson.status || 500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: errLabel, message: errMsg, details: errDetails }));
+                log('Cannot send payment error — response already ended or destroyed');
               }
               return;
             }
@@ -1203,16 +1291,23 @@ const server = http.createServer(async (req, res) => {
             } catch {}
             
             log('paytaca pay succeeded. Returning chat response.');
+
+            if (res.destroyed || res.writableEnded) {
+              log('Payment succeeded but response connection is gone — cannot deliver chat response');
+              return;
+            }
             
             if (wasStreaming) {
               try {
-                jsonToSse(res, chatCompletion);
-              } catch (e) {}
+                jsonToSse(res, chatCompletion, { prependContent: '\\n💳 Payment successful — generating your response...\\n\\n' });
+              } catch (e) { log('jsonToSse threw: ' + e.message); }
             } else {
               try {
-                res.writeHead(200, { 'Content-Type': 'application/json' });
+                if (!res.headersSent) {
+                  res.writeHead(200, { 'Content-Type': 'application/json' });
+                }
                 res.end(JSON.stringify(chatCompletion));
-              } catch (e) {}
+              } catch (e) { log('Failed to send non-streaming response: ' + e.message); }
             }
           });
           return;
@@ -1311,6 +1406,7 @@ const server = http.createServer(async (req, res) => {
           pendingPayments.set(walletHash, {
             body: body,
             modelId: modelId,
+            displayName: displayName,
             durationMinutes: null,
             tiers: tiers,
             step: tiers ? 'tier_select' : 'approval'
@@ -1425,24 +1521,11 @@ server.on('error', (err) => {
 
 server.listen(PROXY_PORT, () => {
   log('Paytaca AI Proxy running on http://localhost:' + PROXY_PORT);
-  log('Forwarding to Django at ' + BACKEND_URL);
+  log('Forwarding to ' + BACKEND_URL);
   log('Discovery: http://localhost:' + PROXY_PORT + '/v1/config');
   log('Managed by OpenCode plugin');
 });
 
-// Start heartbeat checker after server is created
-heartbeatChecker = setInterval(() => {
-  if (!checkHeartbeat()) {
-    clearInterval(heartbeatChecker);
-    log('Closing server due to missing heartbeat');
-    server.close(() => {
-      process.exit(0);
-    });
-    // Force exit after 2 seconds if graceful shutdown fails
-    setTimeout(() => process.exit(0), 2000);
-  }
-}, 5000);
-
 // Graceful shutdown
 process.on('SIGTERM', () => {
   log('Shutting down proxy...');

package/dist/bundled/proxy.js.map

@@ -1 +1 @@
-{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/bundled/proxy.ts"],"names":[],"mappings":";AAAA,0DAA0D;AAC1D,6DAA6D;;;AAEhD,QAAA,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA06CnC,CAAC"}
+{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/bundled/proxy.ts"],"names":[],"mappings":";AAAA,0DAA0D;AAC1D,6DAA6D;;;AAEhD,QAAA,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6/CnC,CAAC"}

package/dist/bundled/wrapper.d.ts

@@ -1,2 +1,2 @@
-export declare const WRAPPER_SCRIPT_CONTENT = "#!/usr/bin/env node\n/**\n * Paytaca Pay Wrapper \u2014 handles large request bodies by reading from a file.\n * Imports paytaca-cli modules directly (avoids CLI argument size limits).\n */\n\nimport { readFileSync } from 'fs';\nimport { execSync } from 'child_process';\nimport { fileURLToPath } from 'url';\nimport { dirname, join } from 'path';\n\n// Find paytaca-cli installation\nfunction findPaytacaCliPath() {\n  const possiblePaths = [];\n  \n  // Try to get global npm root\n  try {\n    const globalPath = execSync('npm root -g', { encoding: 'utf8' }).trim();\n    possiblePaths.push(\n      join(globalPath, 'paytaca-cli'),\n      join(globalPath, 'opencode-plugin', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Common global locations\n  possiblePaths.push(\n    '/usr/lib/node_modules/paytaca-cli',\n    '/usr/local/lib/node_modules/paytaca-cli',\n    '/opt/homebrew/lib/node_modules/paytaca-cli',\n  );\n  \n  // Try current file's node_modules (for bundled installs)\n  try {\n    const currentFile = fileURLToPath(import.meta.url);\n    const currentDir = dirname(currentFile);\n    possiblePaths.push(\n      join(currentDir, '..', 'node_modules', 'paytaca-cli'),\n      join(currentDir, '..', '..', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Find first valid path\n  for (const basePath of possiblePaths) {\n    try {\n      const walletPath = join(basePath, 'dist', 'wallet', 'index.js');\n      readFileSync(walletPath);\n      return basePath;\n    } catch {}\n  }\n  \n  throw new Error('paytaca-cli not found. Try reinstalling opencode-plugin: npm install @paytaca/opencode-plugin');\n}\n\n// Load paytaca-cli modules\nlet loadMnemonic, loadWallet, LibauthHDWallet, X402Payer, parsePaymentRequiredJson, selectBchPaymentRequirements, BCH_DERIVATION_PATH;\n\ntry {\n  const basePath = findPaytacaCliPath();\n  \n  ({ loadMnemonic, loadWallet } = await import(join(basePath, 'dist', 'wallet', 'index.js')));\n  ({ LibauthHDWallet } = await import(join(basePath, 'dist', 'wallet', 'keys.js')));\n  ({ X402Payer } = await import(join(basePath, 'dist', 'wallet', 'x402.js')));\n  ({ parsePaymentRequiredJson, selectBchPaymentRequirements } = await import(join(basePath, 'dist', 'utils', 'x402.js')));\n  ({ BCH_DERIVATION_PATH } = await import(join(basePath, 'dist', 'utils', 'network.js')));\n} catch (err) {\n  console.log(JSON.stringify({ success: false, error: 'Failed to load paytaca-cli: ' + err.message }));\n  process.exit(1);\n}\n\nasync function main() {\n  const configPath = process.argv[2];\n  if (!configPath) {\n    console.log(JSON.stringify({ success: false, error: 'Usage: node paytaca-pay-wrapper.mjs <config.json>' }));\n    process.exit(1);\n  }\n\n  const config = JSON.parse(readFileSync(configPath, 'utf8'));\n  const { url, method, headers, bodyFile, chipnet, confirmed } = config;\n\n  const body = readFileSync(bodyFile, 'utf8');\n\n  const data = loadMnemonic();\n  if (!data) {\n    console.log(JSON.stringify({ success: false, error: 'No wallet found. Run paytaca wallet create first.' }));\n    process.exit(1);\n  }\n\n  const wallet = loadWallet();\n  const isChipnet = Boolean(chipnet);\n  const bchWallet = wallet.forNetwork(isChipnet);\n  const hdWallet = new LibauthHDWallet(data.mnemonic, BCH_DERIVATION_PATH, isChipnet ? 'chipnet' : 'mainnet');\n  const x402Payer = new X402Payer({ hdWallet, addressIndex: 0 });\n\n  try {\n    const result = await executePay(url, method, headers, body, bchWallet, x402Payer, isChipnet, confirmed);\n    console.log(JSON.stringify(result, null, 2));\n  } catch (err) {\n    console.log(JSON.stringify({ success: false, error: err.message || String(err) }, null, 2));\n    process.exit(1);\n  }\n}\n\nasync function executePay(url, method, headers, body, bchWallet, x402Payer, isChipnet, confirmed) {\n  const response = await fetch(url, {\n    method,\n    headers,\n    body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n    signal: AbortSignal.timeout(120000),\n  });\n\n  const responseHeaders = {};\n  response.headers.forEach((value, key) => { responseHeaders[key] = value; });\n  const responseText = await response.text();\n  let responseData;\n  try { responseData = JSON.parse(responseText); } catch { responseData = responseText; }\n\n  if (response.status === 402) {\n    const paymentRequired = parsePaymentRequiredJson(responseData);\n    if (!paymentRequired) {\n      return { success: false, status: 402, error: 'Could not parse PaymentRequired from 402 response body' };\n    }\n    const requirements = selectBchPaymentRequirements(paymentRequired, isChipnet ? 'chipnet' : 'mainnet');\n    if (!requirements) {\n      return {\n        success: false, status: 402, error: 'Server does not accept BCH payment',\n        data: { acceptedSchemes: paymentRequired.accepts.map(a => ({ scheme: a.scheme, network: a.network })) },\n      };\n    }\n\n    const payerAddress = x402Payer.getPayerAddress();\n    const address = requirements.payTo;\n    const amountBch = Number(requirements.amount) / 1e8;\n    const changeAddressSet = bchWallet.getAddressSetAt(0);\n    const changeAddress = changeAddressSet.change;\n\n    if (!confirmed) {\n      return {\n        success: false, status: 402, error: 'Payment not confirmed.',\n        payment: { required: true, amount: requirements.amount, payTo: address },\n      };\n    }\n\n    const sendResult = await bchWallet.sendBch(amountBch, address, changeAddress);\n    if (!sendResult.success) {\n      return { success: false, status: 402, payment: { required: true, error: sendResult.error }, error: sendResult.error };\n    }\n\n    const txid = sendResult.txid;\n    const paymentPayload = await x402Payer.createPaymentPayload(requirements, paymentRequired.resource.url, txid, 0, requirements.amount);\n    headers['PAYMENT-SIGNATURE'] = JSON.stringify(paymentPayload);\n\n    let retryResponse;\n    try {\n      retryResponse = await fetch(url, {\n        method,\n        headers,\n        body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n        signal: AbortSignal.timeout(120000),\n      });\n    } catch (e) {\n      if (e.name === 'AbortError') {\n        return { success: false, timeout: true, error: 'Response timed out from server.' };\n      }\n      throw e;\n    }\n    const retryResponseHeaders = {};\n    retryResponse.headers.forEach((value, key) => { retryResponseHeaders[key] = value; });\n    const retryResponseText = await retryResponse.text();\n    let retryResponseData;\n    try { retryResponseData = JSON.parse(retryResponseText); } catch { retryResponseData = retryResponseText; }\n\n    return {\n      success: retryResponse.ok,\n      status: retryResponse.status,\n      statusText: retryResponse.statusText,\n      headers: retryResponseHeaders,\n      data: retryResponseData,\n      payment: { required: true, txid, recipientAddress: address },\n    };\n  }\n\n  return {\n    success: response.ok,\n    status: response.status,\n    statusText: response.statusText,\n    headers: responseHeaders,\n    data: responseData,\n    payment: { required: false },\n  };\n}\n\nmain();\n";
+export declare const WRAPPER_SCRIPT_CONTENT = "#!/usr/bin/env node\n/**\n * Paytaca Pay Wrapper \u2014 handles large request bodies by reading from a file.\n * Imports paytaca-cli modules directly (avoids CLI argument size limits).\n */\n\nimport { readFileSync } from 'fs';\nimport { execSync } from 'child_process';\nimport { fileURLToPath } from 'url';\nimport { dirname, join } from 'path';\n\n// How long to wait for the server to respond before treating the payment as timed out.\n// Default 240s so heavy non-streaming generations (large context / long output) can\n// complete; override with PAYTACA_PAY_TIMEOUT_MS.\nconst PAY_TIMEOUT_MS = Number(process.env.PAYTACA_PAY_TIMEOUT_MS || 240000);\n\n// Find paytaca-cli installation\nfunction findPaytacaCliPath() {\n  const possiblePaths = [];\n  \n  // Try to get global npm root\n  try {\n    const globalPath = execSync('npm root -g', { encoding: 'utf8' }).trim();\n    possiblePaths.push(\n      join(globalPath, 'paytaca-cli'),\n      join(globalPath, 'opencode-plugin', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Common global locations\n  possiblePaths.push(\n    '/usr/lib/node_modules/paytaca-cli',\n    '/usr/local/lib/node_modules/paytaca-cli',\n    '/opt/homebrew/lib/node_modules/paytaca-cli',\n  );\n  \n  // Try current file's node_modules (for bundled installs)\n  try {\n    const currentFile = fileURLToPath(import.meta.url);\n    const currentDir = dirname(currentFile);\n    possiblePaths.push(\n      join(currentDir, '..', 'node_modules', 'paytaca-cli'),\n      join(currentDir, '..', '..', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Find first valid path\n  for (const basePath of possiblePaths) {\n    try {\n      const walletPath = join(basePath, 'dist', 'wallet', 'index.js');\n      readFileSync(walletPath);\n      return basePath;\n    } catch {}\n  }\n  \n  throw new Error('paytaca-cli not found. Try reinstalling opencode-plugin: npm install @paytaca/opencode-plugin');\n}\n\n// Load paytaca-cli modules\nlet loadMnemonic, loadWallet, LibauthHDWallet, X402Payer, parsePaymentRequiredJson, selectBchPaymentRequirements, BCH_DERIVATION_PATH;\n\ntry {\n  const basePath = findPaytacaCliPath();\n  \n  ({ loadMnemonic, loadWallet } = await import(join(basePath, 'dist', 'wallet', 'index.js')));\n  ({ LibauthHDWallet } = await import(join(basePath, 'dist', 'wallet', 'keys.js')));\n  ({ X402Payer } = await import(join(basePath, 'dist', 'wallet', 'x402.js')));\n  ({ parsePaymentRequiredJson, selectBchPaymentRequirements } = await import(join(basePath, 'dist', 'utils', 'x402.js')));\n  ({ BCH_DERIVATION_PATH } = await import(join(basePath, 'dist', 'utils', 'network.js')));\n} catch (err) {\n  console.log(JSON.stringify({ success: false, error: 'Failed to load paytaca-cli: ' + err.message }));\n  process.exit(1);\n}\n\nasync function main() {\n  const configPath = process.argv[2];\n  if (!configPath) {\n    console.log(JSON.stringify({ success: false, error: 'Usage: node paytaca-pay-wrapper.mjs <config.json>' }));\n    process.exit(1);\n  }\n\n  const config = JSON.parse(readFileSync(configPath, 'utf8'));\n  const { url, method, headers, bodyFile, chipnet, confirmed } = config;\n\n  const body = readFileSync(bodyFile, 'utf8');\n\n  const data = loadMnemonic();\n  if (!data) {\n    console.log(JSON.stringify({ success: false, error: 'No wallet found. Run paytaca wallet create first.' }));\n    process.exit(1);\n  }\n\n  const wallet = loadWallet();\n  const isChipnet = Boolean(chipnet);\n  const bchWallet = wallet.forNetwork(isChipnet);\n  const hdWallet = new LibauthHDWallet(data.mnemonic, BCH_DERIVATION_PATH, isChipnet ? 'chipnet' : 'mainnet');\n  const x402Payer = new X402Payer({ hdWallet, addressIndex: 0 });\n\n  try {\n    const result = await executePay(url, method, headers, body, bchWallet, x402Payer, isChipnet, confirmed);\n    console.log(JSON.stringify(result, null, 2));\n  } catch (err) {\n    console.log(JSON.stringify({ success: false, error: err.message || String(err) }, null, 2));\n    process.exit(1);\n  }\n}\n\nasync function executePay(url, method, headers, body, bchWallet, x402Payer, isChipnet, confirmed) {\n  const response = await fetch(url, {\n    method,\n    headers,\n    body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n    signal: AbortSignal.timeout(PAY_TIMEOUT_MS),\n  });\n\n  const responseHeaders = {};\n  response.headers.forEach((value, key) => { responseHeaders[key] = value; });\n  const responseText = await response.text();\n  let responseData;\n  try { responseData = JSON.parse(responseText); } catch { responseData = responseText; }\n\n  if (response.status === 402) {\n    const paymentRequired = parsePaymentRequiredJson(responseData);\n    if (!paymentRequired) {\n      return { success: false, status: 402, error: 'Could not parse PaymentRequired from 402 response body' };\n    }\n    const requirements = selectBchPaymentRequirements(paymentRequired, isChipnet ? 'chipnet' : 'mainnet');\n    if (!requirements) {\n      return {\n        success: false, status: 402, error: 'Server does not accept BCH payment',\n        data: { acceptedSchemes: paymentRequired.accepts.map(a => ({ scheme: a.scheme, network: a.network })) },\n      };\n    }\n\n    const payerAddress = x402Payer.getPayerAddress();\n    const address = requirements.payTo;\n    const amountBch = Number(requirements.amount) / 1e8;\n    const changeAddressSet = bchWallet.getAddressSetAt(0);\n    const changeAddress = changeAddressSet.change;\n\n    if (!confirmed) {\n      return {\n        success: false, status: 402, error: 'Payment not confirmed.',\n        payment: { required: true, amount: requirements.amount, payTo: address },\n      };\n    }\n\n    const sendResult = await bchWallet.sendBch(amountBch, address, changeAddress);\n    if (!sendResult.success) {\n      return { success: false, status: 402, payment: { required: true, error: sendResult.error }, error: sendResult.error };\n    }\n\n    const txid = sendResult.txid;\n    const paymentPayload = await x402Payer.createPaymentPayload(requirements, paymentRequired.resource.url, txid, 0, requirements.amount);\n    headers['PAYMENT-SIGNATURE'] = JSON.stringify(paymentPayload);\n\n    let retryResponse;\n    try {\n      retryResponse = await fetch(url, {\n        method,\n        headers,\n        body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n        signal: AbortSignal.timeout(PAY_TIMEOUT_MS),\n      });\n    } catch (e) {\n      if (e.name === 'AbortError') {\n        return { success: false, timeout: true, error: 'Response timed out from server.' };\n      }\n      throw e;\n    }\n    const retryResponseHeaders = {};\n    retryResponse.headers.forEach((value, key) => { retryResponseHeaders[key] = value; });\n    const retryResponseText = await retryResponse.text();\n    let retryResponseData;\n    try { retryResponseData = JSON.parse(retryResponseText); } catch { retryResponseData = retryResponseText; }\n\n    return {\n      success: retryResponse.ok,\n      status: retryResponse.status,\n      statusText: retryResponse.statusText,\n      headers: retryResponseHeaders,\n      data: retryResponseData,\n      payment: { required: true, txid, recipientAddress: address },\n    };\n  }\n\n  return {\n    success: response.ok,\n    status: response.status,\n    statusText: response.statusText,\n    headers: responseHeaders,\n    data: responseData,\n    payment: { required: false },\n  };\n}\n\nmain();\n";
 //# sourceMappingURL=wrapper.d.ts.map

package/dist/bundled/wrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,i/NAgMlC,CAAC"}
+{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,ozOAqMlC,CAAC"}

package/dist/bundled/wrapper.js

@@ -15,6 +15,11 @@ import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 
+// How long to wait for the server to respond before treating the payment as timed out.
+// Default 240s so heavy non-streaming generations (large context / long output) can
+// complete; override with PAYTACA_PAY_TIMEOUT_MS.
+const PAY_TIMEOUT_MS = Number(process.env.PAYTACA_PAY_TIMEOUT_MS || 240000);
+
 // Find paytaca-cli installation
 function findPaytacaCliPath() {
   const possiblePaths = [];
@@ -111,7 +116,7 @@ async function executePay(url, method, headers, body, bchWallet, x402Payer, isCh
     method,
     headers,
     body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,
-    signal: AbortSignal.timeout(120000),
+    signal: AbortSignal.timeout(PAY_TIMEOUT_MS),
   });
 
   const responseHeaders = {};
@@ -161,7 +166,7 @@ async function executePay(url, method, headers, body, bchWallet, x402Payer, isCh
         method,
         headers,
         body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,
-        signal: AbortSignal.timeout(120000),
+        signal: AbortSignal.timeout(PAY_TIMEOUT_MS),
       });
     } catch (e) {
       if (e.name === 'AbortError') {

package/dist/bundled/wrapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrapper.js","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":";AAAA,oEAAoE;AACpE,4EAA4E;AAC5E,mFAAmF;;;AAEtE,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMrC,CAAC"}
+{"version":3,"file":"wrapper.js","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":";AAAA,oEAAoE;AACpE,4EAA4E;AAC5E,mFAAmF;;;AAEtE,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqMrC,CAAC"}

package/dist/config.d.ts

@@ -10,7 +10,4 @@ export declare function getPidFile(configDir: string): string;
 export declare function getProxyScript(configDir: string): string;
 export declare function getLogFile(configDir: string): string;
 export declare function getWrapperScript(configDir: string): string;
-export declare function getHeartbeatFile(configDir: string): string;
-export declare function updateHeartbeat(configDir: string): void;
-export declare function startHeartbeat(configDir: string): NodeJS.Timeout;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGjC,eAAO,MAAM,mBAAmB,2BAA2B,CAAC;AAC5D,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAGvC,wBAAgB,YAAY,IAAI,MAAM,CAGrC;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAIvD;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAiCpD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAIlE;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D;AAGD,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQvD;AAGD,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAOhE"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGjC,eAAO,MAAM,mBAAmB,2BAA2B,CAAC;AAC5D,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAGvC,wBAAgB,YAAY,IAAI,MAAM,CAGrC;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAIvD;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAkCpD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAIlE;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/dist/config.js

@@ -43,9 +43,6 @@ exports.getPidFile = getPidFile;
 exports.getProxyScript = getProxyScript;
 exports.getLogFile = getLogFile;
 exports.getWrapperScript = getWrapperScript;
-exports.getHeartbeatFile = getHeartbeatFile;
-exports.updateHeartbeat = updateHeartbeat;
-exports.startHeartbeat = startHeartbeat;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 // Default production backend
@@ -84,6 +81,7 @@ function loadConfig(configDir) {
                 proxyPort: parsed.proxyPort || exports.DEFAULT_PROXY_PORT,
                 walletHash: parsed.walletHash,
                 proxyPid: parsed.proxyPid,
+                proxyScriptHash: parsed.proxyScriptHash,
             };
         }
         catch (err) {
@@ -113,27 +111,4 @@ function getLogFile(configDir) {
 function getWrapperScript(configDir) {
     return path.join(configDir, 'paytaca-pay-wrapper.mjs');
 }
-function getHeartbeatFile(configDir) {
-    return path.join(configDir, 'heartbeat');
-}
-// Touch the heartbeat file to signal the proxy we're still alive
-function updateHeartbeat(configDir) {
-    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
-function startHeartbeat(configDir) {
-    // Update immediately
-    updateHeartbeat(configDir);
-    // Then every 5 seconds
-    return setInterval(() => {
-        updateHeartbeat(configDir);
-    }, 5000);
-}
 //# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,oCAGC;AAED,0CAIC;AAED,sCAEC;AAED,gCAkCC;AAED,gCAIC;AAED,gCAEC;AAED,wCAEC;AAED,gCAEC;AAED,4CAEC;AAhFD,uCAAyB;AACzB,2CAA6B;AAG7B,6BAA6B;AAChB,QAAA,mBAAmB,GAAG,wBAAwB,CAAC;AAC/C,QAAA,kBAAkB,GAAG,IAAI,CAAC;AAEvC,yCAAyC;AACzC,SAAgB,YAAY;IAC1B,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC;IAChE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;AAC9C,CAAC;AAED,SAAgB,eAAe,CAAC,SAAiB;IAC/C,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;QAC9B,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC;AAED,SAAgB,aAAa,CAAC,SAAiB;IAC7C,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;AAC7C,CAAC;AAED,SAAgB,UAAU,CAAC,SAAiB;IAC1C,MAAM,UAAU,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;IAE5C,uEAAuE;IACvE,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;IACtD,IAAI,aAAa,EAAE,CAAC;QAClB,OAAO;YACL,UAAU,EAAE,aAAa;YACzB,SAAS,EAAE,0BAAkB;SAC9B,CAAC;IACJ,CAAC;IAED,0BAA0B;IAC1B,IAAI,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;QAC9B,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,EAAE,CAAC,YAAY,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;YACpD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACnC,OAAO;gBACL,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,2BAAmB;gBACpD,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,0BAAkB;gBACjD,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,eAAe,EAAE,MAAM,CAAC,eAAe;aACxC,CAAC;QACJ,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,yBAAyB,EAAE,GAAG,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAED,yCAAyC;IACzC,OAAO;QACL,UAAU,EAAE,2BAAmB;QAC/B,SAAS,EAAE,0BAAkB;KAC9B,CAAC;AACJ,CAAC;AAED,SAAgB,UAAU,CAAC,SAAiB,EAAE,MAAc;IAC1D,MAAM,UAAU,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;IAC5C,eAAe,CAAC,SAAS,CAAC,CAAC;IAC3B,EAAE,CAAC,aAAa,CAAC,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;AAChE,CAAC;AAED,SAAgB,UAAU,CAAC,SAAiB;IAC1C,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;AAC3C,CAAC;AAED,SAAgB,cAAc,CAAC,SAAiB;IAC9C,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;AAC1C,CAAC;AAED,SAAgB,UAAU,CAAC,SAAiB;IAC1C,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;AAC3C,CAAC;AAED,SAAgB,gBAAgB,CAAC,SAAiB;IAChD,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,yBAAyB,CAAC,CAAC;AACzD,CAAC"}

package/dist/proxy.d.ts

@@ -8,7 +8,6 @@ export declare function getProxyStatus(configDir: string): Promise<{
     pid?: number;
 }>;
 export declare function startProxy(configDir: string, config: Config): Promise<ProxyInfo>;
-export declare function stopProxy(configDir: string): Promise<void>;
 export declare function getProxyConfig(configDir: string): Promise<{
     backendUrl: string;
     port: number;