@kroxy/kroxy 1.0.16 → 1.0.18

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { hireParams, executeHire } from './src/tools/hire.js';
 import { offerParams, executeOffer } from './src/tools/offer.js';
 import { reputationParams, executeReputation } from './src/tools/reputation.js';
@@ -8,6 +9,11 @@ import { browseParams, executeBrowse } from './src/tools/browse.js';
 import { disputeParams, executeDispute } from './src/tools/dispute.js';
 import { historyParams, executeHistory } from './src/tools/history.js';
 import { autoagentParams, executeAutoagent } from './src/tools/autoagent.js';
+const DEFAULT_API_URL = 'https://api-production-1b45.up.railway.app';
+function demoDerivedAddress() {
+    const hash = createHash('sha256').update('kroxy-demo-wallet').digest('hex');
+    return `0x${hash.slice(0, 40)}`;
+}
 export default {
     id: 'kroxy',
     name: 'Kroxy',
@@ -25,6 +31,13 @@ export default {
             process.env.KROXY_DEMO_MODE = cfg.KROXY_DEMO_MODE;
         if (cfg.NEXUS_URL)
             process.env.NEXUS_URL = cfg.NEXUS_URL;
+        if (!process.env.KROXY_API_URL)
+            process.env.KROXY_API_URL = DEFAULT_API_URL;
+        if (!process.env.KROXY_DEMO_MODE && !process.env.KROXY_AGENT_PRIVATE_KEY)
+            process.env.KROXY_DEMO_MODE = '1';
+        if (process.env.KROXY_DEMO_MODE === '1' && !process.env.KROXY_AGENT_WALLET) {
+            process.env.KROXY_AGENT_WALLET = demoDerivedAddress();
+        }
         // ── Setup / Onboarding ────────────────────────────────────────────────────
         // Run this first to check configuration and get guided setup instructions.
         api.registerTool({
@@ -139,4 +152,4 @@ export default {
         }, { optional: true });
     },
 };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/src/client.js

@@ -4,8 +4,9 @@
  * so runtime-injected env vars are always used.
  */
 import { fetchWithRetry } from './utils/fetchWithRetry.js';
+const DEFAULT_API_URL = 'https://api-production-1b45.up.railway.app';
 function apiBase() {
-    return process.env.KROXY_API_URL ?? 'http://localhost:3001';
+    return process.env.KROXY_API_URL ?? DEFAULT_API_URL;
 }
 function authHeaders() {
     const key = process.env.KROXY_API_KEY ?? '';
@@ -149,4 +150,4 @@ export async function pingApi() {
         return false;
     }
 }
-//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map

package/dist/src/tools/autoagent.js

@@ -2,8 +2,9 @@
  * kroxy_autoagent — Autonomous multi-step orchestrator.
  *
  * Takes a natural-language goal, decomposes it into 2–4 subtasks via Claude
- * (or a rule-based fallback if ANTHROPIC_API_KEY is unset), fires kroxy_hire
- * for each subtask sequentially, and returns a unified deliverable.
+ * through Lava's gateway (or a rule-based fallback if keys are unset), fires
+ * kroxy_hire for all subtasks in parallel, then synthesizes outputs into a
+ * unified deliverable via Lava.
  */
 import { Type } from '@sinclair/typebox';
 import { executeHire } from './hire.js';
@@ -20,8 +21,9 @@ export const autoagentParams = Type.Object({
 });
 // ─── Decomposition ────────────────────────────────────────────────────────────
 /**
- * Ask Claude to decompose the goal into 2–4 subtasks.
- * Falls back to rule-based decomposer if ANTHROPIC_API_KEY is absent.
+ * Ask Claude (via Lava) to decompose the goal into 2–4 subtasks.
+ * Falls back to keyword-based decomposer if LAVA_SECRET_KEY or
+ * ANTHROPIC_API_KEY are not set.
  */
 async function decomposeGoal(goal) {
     const hasLava = process.env.LAVA_SECRET_KEY && process.env.ANTHROPIC_API_KEY;
@@ -39,13 +41,13 @@ async function decomposeGoal(goal) {
             });
             const parsed = JSON.parse(text.trim());
             if (Array.isArray(parsed) && parsed.length > 0)
-                return parsed.slice(0, 4);
+                return { subtasks: parsed.slice(0, 4), viaLava: true };
         }
         catch {
             // Fall through to rule-based
         }
     }
-    return ruleBasedDecompose(goal);
+    return { subtasks: ruleBasedDecompose(goal), viaLava: false };
 }
 /** Keyword-based decomposer — works without any API key. */
 function ruleBasedDecompose(goal) {
@@ -70,30 +72,73 @@ function ruleBasedDecompose(goal) {
     }
     return subtasks.slice(0, 4);
 }
+// ─── Synthesis ────────────────────────────────────────────────────────────────
+/**
+ * Use Lava/Claude to merge individual subtask deliverables into a single
+ * coherent summary. Best-effort — silently skipped if Lava is unavailable.
+ */
+async function synthesizeDeliverables(goal, receipts) {
+    const hasLava = process.env.LAVA_SECRET_KEY && process.env.ANTHROPIC_API_KEY;
+    if (!hasLava || receipts.length === 0)
+        return null;
+    const snippets = receipts
+        .filter(d => d?.deliverable?.summary)
+        .map((d, i) => `[Subtask ${i + 1}]\n${d.deliverable.summary}`)
+        .join('\n\n');
+    if (!snippets)
+        return null;
+    try {
+        return await lavaAnthropic({
+            model: 'claude-haiku-4-5-20251001',
+            max_tokens: 512,
+            system: 'You are a synthesis assistant. Given outputs from multiple AI agent subtasks, ' +
+                'write a concise unified summary (3–5 sentences) that integrates all key findings ' +
+                'into a coherent deliverable for the original goal.',
+            messages: [{ role: 'user', content: `Original goal: ${goal}\n\nSubtask outputs:\n${snippets}` }],
+        });
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Orchestrator ─────────────────────────────────────────────────────────────
 export async function executeAutoagent(params) {
     const goal = params.goal;
     const maxBudget = params.maxBudget ?? 20;
     // 1. Decompose
-    const subtasks = await decomposeGoal(goal);
+    const { subtasks, viaLava } = await decomposeGoal(goal);
     const pricePerTask = parseFloat((maxBudget / subtasks.length).toFixed(2));
+    const modeLabel = viaLava
+        ? 'LLM decomposition via Lava'
+        : '⚠ Keyword fallback — set LAVA_SECRET_KEY + ANTHROPIC_API_KEY for intelligent decomposition';
     const lines = [
         `AutoAgent: ${goal.slice(0, 80)}`,
         `${'─'.repeat(50)}`,
         `Budget: $${maxBudget} USDC across ${subtasks.length} subtask${subtasks.length === 1 ? '' : 's'} ($${pricePerTask} each)`,
+        `Mode:   ${modeLabel}`,
         '',
     ];
+    // 2. List all subtasks upfront before firing
+    subtasks.forEach(({ task, capability }, i) => {
+        lines.push(`[${i + 1}/${subtasks.length}] ${capability.toUpperCase()}: ${task.slice(0, 70)}`);
+    });
+    lines.push('', `Firing all ${subtasks.length} subtask${subtasks.length === 1 ? '' : 's'} in parallel…`, '');
+    // 3. Fire all hires concurrently
+    const settled = await Promise.allSettled(
+        subtasks.map(({ task, capability }) =>
+            executeHire({ task, maxPrice: pricePerTask, capability })
+        )
+    );
     const receipts = [];
     let totalSpent = 0;
-    // 2. Fire kroxy_hire for each subtask sequentially
-    for (let i = 0; i < subtasks.length; i++) {
+    for (let i = 0; i < settled.length; i++) {
+        const result = settled[i];
         const { task, capability } = subtasks[i];
-        lines.push(`[${i + 1}/${subtasks.length}] ${capability.toUpperCase()}: ${task.slice(0, 70)}`);
-        try {
-            const result = await executeHire({ task, maxPrice: pricePerTask, capability });
-            const d = result.details;
-            const paid = parseFloat(d?.amountPaid ?? '0');
-            totalSpent += paid;
+        lines.push(`[${i + 1}] ${capability.toUpperCase()}: ${task.slice(0, 60)}`);
+        if (result.status === 'fulfilled') {
+            const d = result.value.details;
+            const paid = parseFloat(String(d?.amountPaid ?? '0'));
+            totalSpent += isNaN(paid) ? 0 : paid;
             lines.push(`  ✓ Completed in ${d?.duration ?? '?'} — paid $${d?.amountPaid ?? '?'}`);
             lines.push(`  Escrow: ${d?.escrowId ?? '?'}`);
             if (d?.deliverable?.summary) {
@@ -102,15 +147,20 @@ export async function executeAutoagent(params) {
             lines.push('');
             receipts.push(d);
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
+        else {
+            const msg = result.reason instanceof Error ? result.reason.message : String(result.reason);
             lines.push(`  ✗ Failed: ${msg.slice(0, 120)}`);
             lines.push('');
         }
     }
+    // 4. Synthesize outputs into a unified deliverable (via Lava — best-effort)
+    const synthesis = await synthesizeDeliverables(goal, receipts);
     lines.push(`${'─'.repeat(50)}`);
     lines.push(`Total spent: $${totalSpent.toFixed(2)} USDC / $${maxBudget} budget`);
     lines.push(`Subtasks completed: ${receipts.length}/${subtasks.length}`);
+    if (synthesis) {
+        lines.push('', '── Unified Deliverable ──', synthesis);
+    }
     return {
         content: [{ type: 'text', text: lines.join('\n') }],
         details: {
@@ -119,7 +169,8 @@ export async function executeAutoagent(params) {
             receipts,
             totalSpent: totalSpent.toFixed(2),
             budgetUsed: `$${totalSpent.toFixed(2)} / $${maxBudget}`,
+            synthesis: synthesis ?? undefined,
         },
     };
 }
-//# sourceMappingURL=autoagent.js.map
+//# sourceMappingURL=autoagent.js.map

package/dist/src/tools/hire.js

@@ -1,19 +1,23 @@
-import { randomBytes } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { Type } from '@sinclair/typebox';
 import { findAgents, postJob, acceptBid, pollJob, } from '../client.js';
+const DEFAULT_API_URL = 'https://api-production-1b45.up.railway.app';
 export const hireParams = Type.Object({
     task: Type.String({ description: 'What you want the hired agent to do, e.g. "Research the top AI payment startups"' }),
     maxPrice: Type.Optional(Type.Number({ minimum: 0.01, description: 'Maximum USDC budget, default 5.00' })),
-    capability: Type.Optional(Type.String({ description: 'Agent capability to match: research, writing, coding. Auto-detected from task if omitted.' })),
+    capability: Type.Optional(Type.String({ description: 'Agent capability to match: research, writing, coding, planning. Auto-detected from task if omitted.' })),
     minRep: Type.Optional(Type.Number({ minimum: 0, maximum: 100, description: 'Minimum reputation score (0–100) required. Default: 0 (any agent accepted).' })),
 });
 function detectCapability(task) {
-    if (/research|find|search|analyz|summariz|look up/i.test(task))
-        return 'research';
-    if (/write|draft|essay|blog|article|copy/i.test(task))
-        return 'writing';
-    if (/code|script|function|implement|build|program/i.test(task))
+    // Check coding first — "build" would otherwise fall through to planning
+    if (/code|script|function|implement|develop|engineer|program|smart contract/i.test(task))
         return 'coding';
+    if (/write|draft|essay|blog|article|copy|content|landing page|marketing|email/i.test(task))
+        return 'writing';
+    if (/plan|roadmap|strateg|architect|design|outline|milestone|go-to-market/i.test(task))
+        return 'planning';
+    if (/research|find|search|analyz|summariz|look up|investigat|gather|survey/i.test(task))
+        return 'research';
     return 'research';
 }
 function buildConditions(nexusUrl, jobId) {
@@ -49,6 +53,10 @@ function formatDuration(startMs) {
     const mins = Math.floor(secs / 60);
     return `${mins}m ${secs % 60}s`;
 }
+function demoDerivedAddress() {
+    const hash = createHash('sha256').update('kroxy-demo-wallet').digest('hex');
+    return `0x${hash.slice(0, 40)}`;
+}
 function buildReceipt(opts) {
     const lines = [
         `✅ Job Complete — ${opts.task.slice(0, 60)}${opts.task.length > 60 ? '…' : ''}`,
@@ -70,10 +78,10 @@ function buildReceipt(opts) {
     return lines.join('\n');
 }
 export async function executeHire(params) {
-    const wallet = process.env.KROXY_AGENT_WALLET;
     const privateKey = process.env.KROXY_AGENT_PRIVATE_KEY;
-    const demoMode = process.env.KROXY_DEMO_MODE === '1';
-    const apiBase = process.env.KROXY_API_URL ?? 'http://localhost:3001';
+    const demoMode = process.env.KROXY_DEMO_MODE === '1' || (!process.env.KROXY_DEMO_MODE && !privateKey);
+    const wallet = process.env.KROXY_AGENT_WALLET ?? (demoMode ? demoDerivedAddress() : undefined);
+    const apiBase = process.env.KROXY_API_URL ?? DEFAULT_API_URL;
     // In demo mode, point at the embedded demo agent in the API if NEXUS_URL not explicitly set
     const nexusUrl = process.env.NEXUS_URL ?? (demoMode ? `${apiBase}/demo-agent` : 'http://localhost:3003');
     if (!wallet)
@@ -160,4 +168,4 @@ export async function executeHire(params) {
         details,
     };
 }
-//# sourceMappingURL=hire.js.map
+//# sourceMappingURL=hire.js.map

package/dist/src/tools/offer.js

@@ -1,4 +1,5 @@
 import { Type } from '@sinclair/typebox';
+import { createHash } from 'node:crypto';
 import { registerProvider } from '../client.js';
 export const offerParams = Type.Object({
     capability: Type.String({ description: 'Capability to offer: research, writing, coding, analysis, etc.' }),
@@ -6,8 +7,14 @@ export const offerParams = Type.Object({
     endpoint: Type.String({ description: 'Public URL where your agent receives job webhooks, e.g. https://myagent.example.com' }),
     name: Type.Optional(Type.String({ description: 'Display name for your agent on the Kroxy job board' })),
 });
+function demoDerivedAddress() {
+    const hash = createHash('sha256').update('kroxy-demo-wallet').digest('hex');
+    return `0x${hash.slice(0, 40)}`;
+}
 export async function executeOffer(params) {
-    const wallet = process.env.KROXY_AGENT_WALLET;
+    const privateKey = process.env.KROXY_AGENT_PRIVATE_KEY;
+    const demoMode = process.env.KROXY_DEMO_MODE === '1' || (!process.env.KROXY_DEMO_MODE && !privateKey);
+    const wallet = process.env.KROXY_AGENT_WALLET ?? (demoMode ? demoDerivedAddress() : undefined);
     if (!wallet)
         throw new Error('KROXY_AGENT_WALLET is not configured');
     const agent = await registerProvider({
@@ -33,4 +40,4 @@ export async function executeOffer(params) {
         details: result,
     };
 }
-//# sourceMappingURL=offer.js.map
+//# sourceMappingURL=offer.js.map

package/dist/src/tools/setup.js

@@ -2,6 +2,7 @@ import { Type } from '@sinclair/typebox';
 import { createHash } from 'node:crypto';
 import { pingApi } from '../client.js';
 export const setupParams = Type.Object({});
+const DEFAULT_API_URL = 'https://api-production-1b45.up.railway.app';
 function icon(s) {
     return s === 'ok' ? '✅' : s === 'warn' ? '⚠️ ' : '❌';
 }
@@ -19,11 +20,11 @@ function demoDerivedAddress() {
     return `0x${hash.slice(0, 40)}`;
 }
 export async function executeSetup(_params) {
-    const apiUrl = process.env.KROXY_API_URL ?? 'http://localhost:3001';
+    const apiUrl = process.env.KROXY_API_URL ?? DEFAULT_API_URL;
     const apiKey = process.env.KROXY_API_KEY;
     const wallet = process.env.KROXY_AGENT_WALLET;
     const privateKey = process.env.KROXY_AGENT_PRIVATE_KEY;
-    const demoMode = process.env.KROXY_DEMO_MODE === '1';
+    const demoMode = process.env.KROXY_DEMO_MODE === '1' || (!process.env.KROXY_DEMO_MODE && !privateKey);
     const nexusUrl = process.env.NEXUS_URL;
     const checks = [];
     let blockingIssues = 0;
@@ -55,10 +56,13 @@ export async function executeSetup(_params) {
     else {
         checks.push({
             item: 'API key (KROXY_API_KEY)',
-            status: 'error',
-            hint: 'Required for posting jobs and hiring agents. Set in plugin config.',
+            status: demoMode ? 'warn' : 'error',
+            hint: demoMode
+                ? 'Optional in demo mode. Add an API key for higher rate limits and live usage.'
+                : 'Required for posting jobs and hiring agents. Set in plugin config.',
         });
-        blockingIssues++;
+        if (!demoMode)
+            blockingIssues++;
     }
     // 4. Agent wallet
     let suggestedWallet;
@@ -138,4 +142,4 @@ export async function executeSetup(_params) {
         details: result,
     };
 }
-//# sourceMappingURL=setup.js.map
+//# sourceMappingURL=setup.js.map

package/index.ts

@@ -1,4 +1,5 @@
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+import { createHash } from 'node:crypto';
 import { hireParams, executeHire } from './src/tools/hire.js';
 import { offerParams, executeOffer } from './src/tools/offer.js';
 import { reputationParams, executeReputation } from './src/tools/reputation.js';
@@ -21,6 +22,13 @@ type DisputeToolParams = Parameters<typeof executeDispute>[0];
 type HistoryToolParams = Parameters<typeof executeHistory>[0];
 type AutoagentToolParams = Parameters<typeof executeAutoagent>[0];
 
+const DEFAULT_API_URL = 'https://api-production-1b45.up.railway.app';
+
+function demoDerivedAddress(): string {
+  const hash = createHash('sha256').update('kroxy-demo-wallet').digest('hex');
+  return `0x${hash.slice(0, 40)}`;
+}
+
 export default {
   id: 'kroxy',
   name: 'Kroxy',
@@ -33,6 +41,12 @@ export default {
     if (cfg.KROXY_DEMO_MODE) process.env.KROXY_DEMO_MODE = cfg.KROXY_DEMO_MODE;
     if (cfg.NEXUS_URL) process.env.NEXUS_URL = cfg.NEXUS_URL;
 
+    if (!process.env.KROXY_API_URL) process.env.KROXY_API_URL = DEFAULT_API_URL;
+    if (!process.env.KROXY_DEMO_MODE && !process.env.KROXY_AGENT_PRIVATE_KEY) process.env.KROXY_DEMO_MODE = '1';
+    if (process.env.KROXY_DEMO_MODE === '1' && !process.env.KROXY_AGENT_WALLET) {
+      process.env.KROXY_AGENT_WALLET = demoDerivedAddress();
+    }
+
     // ── Setup / Onboarding ────────────────────────────────────────────────────
     // Run this first to check configuration and get guided setup instructions.
     api.registerTool({

package/openclaw.plugin.json

@@ -8,12 +8,20 @@
     "type": "object",
     "additionalProperties": false,
     "properties": {
-      "KROXY_API_URL": { "type": "string" },
+      "KROXY_API_URL": {
+        "type": "string",
+        "default": "https://api-production-1b45.up.railway.app"
+      },
       "KROXY_API_KEY": { "type": "string" },
       "KROXY_AGENT_WALLET": { "type": "string" },
       "KROXY_AGENT_PRIVATE_KEY": { "type": "string" },
       "NEXUS_URL": { "type": "string" },
-      "KROXY_DEMO_MODE": { "type": "string" }
+      "LAVA_SECRET_KEY": { "type": "string" },
+      "ANTHROPIC_API_KEY": { "type": "string" },
+      "KROXY_DEMO_MODE": {
+        "type": "string",
+        "default": "1"
+      }
     },
     "required": []
   },
@@ -25,6 +33,14 @@
     "KROXY_AGENT_PRIVATE_KEY": {
       "label": "Kroxy Private Key",
       "sensitive": true
+    },
+    "LAVA_SECRET_KEY": {
+      "label": "Lava Secret Key (enables intelligent decomposition)",
+      "sensitive": true
+    },
+    "ANTHROPIC_API_KEY": {
+      "label": "Anthropic API Key (required with Lava)",
+      "sensitive": true
     }
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kroxy/kroxy",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "type": "module",
   "description": "Trustless agent-to-agent payments via USDC escrow on Base blockchain",
   "license": "MIT",
@@ -17,7 +17,8 @@
   "files": [
     "dist",
     "index.ts",
-    "openclaw.plugin.json"
+    "openclaw.plugin.json",
+    "scripts"
   ],
   "dependencies": {
     "@sinclair/typebox": "^0.32.0"
@@ -29,8 +30,13 @@
   "peerDependencies": {
     "openclaw": "*"
   },
+  "bin": {
+    "kroxy-setup": "./scripts/setup-openclaw.mjs"
+  },
   "scripts": {
     "build": "tsc",
-    "dev": "tsc --watch"
+    "dev": "tsc --watch",
+    "postinstall": "node ./scripts/setup-openclaw.mjs --postinstall",
+    "setup:openclaw": "node ./scripts/setup-openclaw.mjs"
   }
 }

package/scripts/setup-openclaw.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import readline from 'node:readline/promises';
+
+const DEFAULT_API_URL = 'https://api-production-1b45.up.railway.app';
+
+function demoDerivedAddress() {
+  const hash = createHash('sha256').update('kroxy-demo-wallet').digest('hex');
+  return `0x${hash.slice(0, 40)}`;
+}
+
+function resolveConfigPath() {
+  const explicit = process.env.OPENCLAW_CONFIG_PATH?.trim();
+  if (explicit) return explicit;
+  const stateDir = process.env.OPENCLAW_STATE_DIR?.trim() || path.join(os.homedir(), '.openclaw');
+  return path.join(stateDir, 'openclaw.json');
+}
+
+function ensureObject(parent, key) {
+  const current = parent[key];
+  if (!current || typeof current !== 'object' || Array.isArray(current)) {
+    parent[key] = {};
+  }
+  return parent[key];
+}
+
+async function askYesNo(rl, question, defaultYes = true) {
+  const suffix = defaultYes ? ' [Y/n] ' : ' [y/N] ';
+  const answer = (await rl.question(`${question}${suffix}`)).trim().toLowerCase();
+  if (!answer) return defaultYes;
+  if (['y', 'yes'].includes(answer)) return true;
+  if (['n', 'no'].includes(answer)) return false;
+  return defaultYes;
+}
+
+function parseJsonConfig(raw, configPath) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('top-level JSON value must be an object');
+    }
+    return parsed;
+  } catch (err) {
+    throw new Error(
+      `Could not parse ${configPath} as strict JSON (${String(err)}).\n` +
+      'Run: openclaw config set plugins.entries.kroxy.config.KROXY_API_URL ' +
+      `"${DEFAULT_API_URL}"`
+    );
+  }
+}
+
+async function runSetup({ postinstall }) {
+  const configPath = resolveConfigPath();
+  const commandHint = 'node ~/.openclaw/extensions/kroxy/scripts/setup-openclaw.mjs';
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    if (postinstall) {
+      console.log(`[kroxy] Skipping interactive setup (non-interactive terminal). Run ${commandHint}`);
+    }
+    return 0;
+  }
+
+  if (!fs.existsSync(configPath)) {
+    console.log(`[kroxy] OpenClaw config not found at ${configPath}.`);
+    console.log('[kroxy] Run OpenClaw once, then run this setup wizard again.');
+    return 0;
+  }
+
+  const raw = fs.readFileSync(configPath, 'utf8');
+  const cfg = parseJsonConfig(raw, configPath);
+  const plugins = ensureObject(cfg, 'plugins');
+  const entries = ensureObject(plugins, 'entries');
+  const kroxy = ensureObject(entries, 'kroxy');
+  const pluginConfig = ensureObject(kroxy, 'config');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const start = await askYesNo(rl, 'Configure Kroxy in OpenClaw now?', true);
+    if (!start) return 0;
+
+    if (await askYesNo(rl, `Set KROXY_API_URL to ${DEFAULT_API_URL}?`, !pluginConfig.KROXY_API_URL)) {
+      pluginConfig.KROXY_API_URL = DEFAULT_API_URL;
+    }
+
+    const defaultDemo = pluginConfig.KROXY_DEMO_MODE !== '0';
+    if (await askYesNo(rl, 'Enable demo mode by default (recommended for first run)?', defaultDemo)) {
+      pluginConfig.KROXY_DEMO_MODE = '1';
+    } else if (pluginConfig.KROXY_DEMO_MODE === '1') {
+      delete pluginConfig.KROXY_DEMO_MODE;
+    }
+
+    if (pluginConfig.KROXY_DEMO_MODE === '1') {
+      const shouldSetDemoWallet = await askYesNo(
+        rl,
+        'Auto-set a demo wallet address for KROXY_AGENT_WALLET?',
+        !pluginConfig.KROXY_AGENT_WALLET
+      );
+      if (shouldSetDemoWallet) {
+        pluginConfig.KROXY_AGENT_WALLET = pluginConfig.KROXY_AGENT_WALLET || demoDerivedAddress();
+      }
+    }
+
+    const setApiKeyNow = await askYesNo(rl, 'Set KROXY_API_KEY now?', false);
+    if (setApiKeyNow) {
+      const key = (await rl.question('Paste KROXY_API_KEY: ')).trim();
+      if (key) pluginConfig.KROXY_API_KEY = key;
+    }
+
+    const save = await askYesNo(rl, `Save changes to ${configPath}?`, true);
+    if (!save) {
+      console.log('[kroxy] Setup canceled; no changes saved.');
+      return 0;
+    }
+
+    fs.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}\n`, 'utf8');
+    console.log('[kroxy] Saved OpenClaw config for plugin "kroxy".');
+    console.log('[kroxy] Restart the gateway to load the new config.');
+    return 0;
+  } finally {
+    rl.close();
+  }
+}
+
+const postinstall = process.argv.includes('--postinstall');
+runSetup({ postinstall }).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
+    console.error(`[kroxy] Setup wizard failed: ${String(err)}`);
+    process.exitCode = 1;
+  }
+);