openbroker 1.3.2 → 1.5.0

package/dist/operations/bracket.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env npx tsx
+// Bracket Order - Entry with Take Profit and Stop Loss
+import { fileURLToPath } from 'url';
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs, sleep } from '../core/utils.js';
+function printUsage() {
+    console.log(`
+Open Broker - Bracket Order
+===========================
+
+Execute an entry order with automatic take-profit and stop-loss orders.
+Creates a complete trade setup in one command.
+
+Usage:
+  npx tsx scripts/operations/bracket.ts --coin <COIN> --side <buy|sell> --size <SIZE> --tp <PCT> --sl <PCT>
+
+Options:
+  --coin        Asset to trade (e.g., ETH, BTC)
+  --side        Entry side: buy (long) or sell (short)
+  --size        Position size in base asset
+  --entry       Entry type: market or limit (default: market)
+  --price       Entry price (required if --entry limit)
+  --tp          Take profit distance in % from entry
+  --sl          Stop loss distance in % from entry
+  --slippage    Slippage for market entry in bps (default: 50)
+  --leverage    Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
+  --dry         Dry run - show bracket plan without executing
+
+Take Profit / Stop Loss:
+  For LONG (buy): TP is above entry, SL is below entry
+  For SHORT (sell): TP is below entry, SL is above entry
+
+Examples:
+  # Long ETH with 3% take profit and 1.5% stop loss
+  npx tsx scripts/operations/bracket.ts --coin ETH --side buy --size 0.5 --tp 3 --sl 1.5
+
+  # Short BTC with limit entry at $100k, 5% TP, 2% SL
+  npx tsx scripts/operations/bracket.ts --coin BTC --side sell --size 0.1 --entry limit --price 100000 --tp 5 --sl 2
+
+  # Preview bracket setup
+  npx tsx scripts/operations/bracket.ts --coin SOL --side buy --size 10 --tp 5 --sl 2 --dry
+`);
+}
+export async function runBracket(opts) {
+    const out = opts.output ?? ((line) => console.log(line));
+    const entryType = opts.entryType ?? 'market';
+    const isLong = opts.side === 'buy';
+    if (opts.size <= 0 || isNaN(opts.size))
+        throw new Error('size must be positive');
+    if (opts.tpPct <= 0 || opts.slPct <= 0)
+        throw new Error('tp and sl must be positive percentages');
+    if (entryType === 'limit' && opts.entryPrice === undefined) {
+        throw new Error('entryPrice is required for limit entry');
+    }
+    const client = getClient();
+    if (opts.verbose)
+        client.verbose = true;
+    out('Open Broker - Bracket Order');
+    out('===========================\n');
+    const mids = await client.getAllMids();
+    const midPrice = parseFloat(mids[opts.coin]);
+    if (!midPrice)
+        throw new Error(`No market data for ${opts.coin}`);
+    const entry = entryType === 'limit' ? opts.entryPrice : midPrice;
+    let tpPrice = isLong
+        ? entry * (1 + opts.tpPct / 100)
+        : entry * (1 - opts.tpPct / 100);
+    let slPrice = isLong
+        ? entry * (1 - opts.slPct / 100)
+        : entry * (1 + opts.slPct / 100);
+    const riskReward = opts.tpPct / opts.slPct;
+    const notional = entry * opts.size;
+    out('Bracket Plan');
+    out('------------');
+    out(`Coin:           ${opts.coin}`);
+    out(`Position:       ${isLong ? 'LONG' : 'SHORT'}`);
+    out(`Size:           ${opts.size}`);
+    out(`Entry Type:     ${entryType.toUpperCase()}`);
+    out(`Current Mid:    ${formatUsd(midPrice)}`);
+    out(`Entry Price:    ${formatUsd(entry)}${entryType === 'market' ? ' (approx)' : ''}`);
+    out(`Take Profit:    ${formatUsd(tpPrice)} (+${opts.tpPct}%)`);
+    out(`Stop Loss:      ${formatUsd(slPrice)} (-${opts.slPct}%)`);
+    out(`Risk/Reward:    1:${riskReward.toFixed(2)}`);
+    out(`Est. Notional:  ${formatUsd(notional)}`);
+    const potentialProfit = notional * (opts.tpPct / 100);
+    const potentialLoss = notional * (opts.slPct / 100);
+    out('\nRisk Analysis');
+    out('-------------');
+    out(`Potential Profit: ${formatUsd(potentialProfit)}`);
+    out(`Potential Loss:   ${formatUsd(potentialLoss)}`);
+    if (opts.dryRun) {
+        out('\n🔍 Dry run - bracket not executed');
+        return { status: 'dry', entryPrice: entry, tpPrice, slPrice };
+    }
+    out('\nExecuting bracket...\n');
+    // Step 1: Entry
+    out('Step 1: Entry order');
+    let actualEntry = entry;
+    let entryOid = null;
+    if (entryType === 'market') {
+        const entryResponse = await client.marketOrder(opts.coin, isLong, opts.size, opts.slippage, opts.leverage);
+        if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
+            const status = entryResponse.response.data.statuses[0];
+            if (status?.filled) {
+                actualEntry = parseFloat(status.filled.avgPx);
+                out(`  ✅ Filled @ ${formatUsd(actualEntry)}`);
+            }
+            else if (status?.error) {
+                out(`  ❌ Entry failed: ${status.error}`);
+                out('\n⚠️ Bracket aborted - no position opened');
+                return { status: 'entry_failed', reason: status.error };
+            }
+        }
+        else {
+            const reason = typeof entryResponse.response === 'string' ? entryResponse.response : 'Unknown error';
+            out(`  ❌ Entry failed: ${reason}`);
+            out('\n⚠️ Bracket aborted - no position opened');
+            return { status: 'entry_failed', reason };
+        }
+    }
+    else {
+        const entryResponse = await client.limitOrder(opts.coin, isLong, opts.size, entry, 'Gtc', false, opts.leverage);
+        if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
+            const status = entryResponse.response.data.statuses[0];
+            if (status?.resting) {
+                entryOid = status.resting.oid;
+                out(`  ✅ Limit order placed @ ${formatUsd(entry)} (OID: ${entryOid})`);
+                out(`  ⏳ Waiting for fill before placing TP/SL...`);
+                out('\n⚠️ Note: TP/SL will be placed after entry fills. Monitor manually or use a strategy script.');
+                return { status: 'limit_resting', entryOid, entryPrice: entry };
+            }
+            else if (status?.filled) {
+                actualEntry = parseFloat(status.filled.avgPx);
+                out(`  ✅ Filled immediately @ ${formatUsd(actualEntry)}`);
+            }
+            else if (status?.error) {
+                out(`  ❌ Entry failed: ${status.error}`);
+                return { status: 'entry_failed', reason: status.error };
+            }
+        }
+        else {
+            out(`  ❌ Entry failed`);
+            return { status: 'entry_failed', reason: 'Unknown error' };
+        }
+    }
+    // Recalculate TP/SL based on actual entry
+    if (isLong) {
+        tpPrice = actualEntry * (1 + opts.tpPct / 100);
+        slPrice = actualEntry * (1 - opts.slPct / 100);
+    }
+    else {
+        tpPrice = actualEntry * (1 - opts.tpPct / 100);
+        slPrice = actualEntry * (1 + opts.slPct / 100);
+    }
+    await sleep(500);
+    // Step 2: Take Profit (trigger order)
+    out('\nStep 2: Take Profit order (trigger)');
+    const tpSide = !isLong;
+    const tpResponse = await client.takeProfit(opts.coin, tpSide, opts.size, tpPrice);
+    let tpOid = null;
+    if (tpResponse.status === 'ok' && tpResponse.response && typeof tpResponse.response === 'object') {
+        const status = tpResponse.response.data.statuses[0];
+        if (status?.resting) {
+            tpOid = status.resting.oid;
+            out(`  ✅ TP trigger placed @ ${formatUsd(tpPrice)} (OID: ${tpOid})`);
+        }
+        else if (status?.error) {
+            out(`  ❌ TP failed: ${status.error}`);
+        }
+        else {
+            out(`  ⚠️ TP status: ${JSON.stringify(status)}`);
+        }
+    }
+    else {
+        const reason = typeof tpResponse.response === 'string' ? tpResponse.response : 'Unknown error';
+        out(`  ❌ TP failed: ${reason}`);
+    }
+    await sleep(500);
+    // Step 3: Stop Loss (trigger order)
+    out('\nStep 3: Stop Loss order (trigger)');
+    const slSide = !isLong;
+    const slResponse = await client.stopLoss(opts.coin, slSide, opts.size, slPrice);
+    let slOid = null;
+    if (slResponse.status === 'ok' && slResponse.response && typeof slResponse.response === 'object') {
+        const status = slResponse.response.data.statuses[0];
+        if (status?.resting) {
+            slOid = status.resting.oid;
+            out(`  ✅ SL trigger placed @ ${formatUsd(slPrice)} (OID: ${slOid})`);
+        }
+        else if (status?.error) {
+            out(`  ❌ SL failed: ${status.error}`);
+        }
+        else {
+            out(`  ⚠️ SL status: ${JSON.stringify(status)}`);
+        }
+    }
+    else {
+        const reason = typeof slResponse.response === 'string' ? slResponse.response : 'Unknown error';
+        out(`  ❌ SL failed: ${reason}`);
+    }
+    out('\n========== Bracket Summary ==========');
+    out(`Position:    ${isLong ? 'LONG' : 'SHORT'} ${opts.size} ${opts.coin}`);
+    out(`Entry:       ${formatUsd(actualEntry)}`);
+    out(`Take Profit: ${formatUsd(tpPrice)} (+${opts.tpPct}%) - Trigger order`);
+    out(`Stop Loss:   ${formatUsd(slPrice)} (-${opts.slPct}%) - Trigger order`);
+    if (tpOid && slOid) {
+        out(`\n✅ Bracket complete! TP and SL are trigger orders.`);
+        out(`   They will only execute when price reaches trigger level.`);
+        out(`   When one fills, cancel the other manually.`);
+    }
+    return {
+        status: tpOid && slOid ? 'complete' : 'partial',
+        entryPrice: actualEntry,
+        tpPrice,
+        slPrice,
+        tpOid,
+        slOid,
+    };
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const coin = args.coin;
+    const side = args.side;
+    const size = parseFloat(args.size);
+    const entryType = (args.entry || 'market');
+    const entryPrice = args.price ? parseFloat(args.price) : undefined;
+    const tpPct = parseFloat(args.tp);
+    const slPct = parseFloat(args.sl);
+    const slippage = args.slippage ? parseInt(args.slippage) : undefined;
+    const leverage = args.leverage ? parseInt(args.leverage) : undefined;
+    const dryRun = args.dry;
+    if (!coin || !side || isNaN(size) || isNaN(tpPct) || isNaN(slPct)) {
+        printUsage();
+        process.exit(1);
+    }
+    if (side !== 'buy' && side !== 'sell') {
+        console.error('Error: --side must be "buy" or "sell"');
+        process.exit(1);
+    }
+    try {
+        const result = await runBracket({
+            coin,
+            side: side,
+            size,
+            tpPct,
+            slPct,
+            entryType,
+            entryPrice,
+            slippage,
+            leverage,
+            dryRun,
+            verbose: args.verbose,
+        });
+        if (result.status === 'entry_failed')
+            process.exit(1);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+// Only run when invoked as a script — not when imported as a module
+// (e.g. by `openbroker-plugin` via the lib re-export of `runBracket`).
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+    main();
+}

package/dist/operations/cancel.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+//# sourceMappingURL=cancel.d.ts.map

package/dist/operations/cancel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancel.d.ts","sourceRoot":"","sources":["../../scripts/operations/cancel.ts"],"names":[],"mappings":""}

package/dist/operations/cancel.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env npx tsx
+// Cancel orders on Hyperliquid
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs } from '../core/utils.js';
+function printUsage() {
+    console.log(`
+Open Broker - Cancel Orders
+===========================
+
+Cancel open orders.
+
+Usage:
+  npx tsx scripts/operations/cancel.ts [--coin <COIN>] [--oid <ORDER_ID>] [--all]
+
+Options:
+  --coin      Cancel orders for specific coin only
+  --oid       Cancel specific order by ID
+  --all       Cancel all open orders
+  --dry       Dry run - show what would be cancelled
+
+Examples:
+  npx tsx scripts/operations/cancel.ts --all                    # Cancel all orders
+  npx tsx scripts/operations/cancel.ts --coin ETH               # Cancel all ETH orders
+  npx tsx scripts/operations/cancel.ts --coin ETH --oid 123456  # Cancel specific order
+  npx tsx scripts/operations/cancel.ts --all --dry              # Show all orders (dry run)
+`);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const coin = args.coin;
+    const oid = args.oid ? parseInt(args.oid) : undefined;
+    const all = args.all;
+    const dryRun = args.dry;
+    // Must specify something to cancel
+    if (!coin && !oid && !all) {
+        printUsage();
+        process.exit(1);
+    }
+    const client = getClient();
+    console.log('Open Broker - Cancel Orders');
+    console.log('===========================\n');
+    try {
+        // Get open orders
+        const orders = await client.getOpenOrders();
+        // Filter orders based on arguments
+        let targetOrders = orders;
+        if (coin) {
+            targetOrders = orders.filter(o => o.coin === coin);
+        }
+        if (oid) {
+            targetOrders = orders.filter(o => o.oid === oid);
+        }
+        if (targetOrders.length === 0) {
+            if (oid) {
+                console.log(`No order found with ID ${oid}`);
+            }
+            else if (coin) {
+                console.log(`No open orders for ${coin}`);
+            }
+            else {
+                console.log('No open orders to cancel');
+            }
+            return;
+        }
+        // Display orders to be cancelled
+        console.log('Orders to Cancel');
+        console.log('----------------');
+        console.log('Coin     | Side | Size       | Price      | Order ID');
+        console.log('---------|------|------------|------------|----------');
+        for (const order of targetOrders) {
+            const side = order.side === 'B' ? 'BUY ' : 'SELL';
+            console.log(`${order.coin.padEnd(8)} | ${side} | ${parseFloat(order.sz).toFixed(4).padStart(10)} | ` +
+                `${formatUsd(parseFloat(order.limitPx)).padStart(10)} | ${order.oid}`);
+        }
+        console.log(`\nTotal: ${targetOrders.length} order(s)`);
+        if (dryRun) {
+            console.log('\n🔍 Dry run - orders not cancelled');
+            return;
+        }
+        console.log('\nCancelling...');
+        let successCount = 0;
+        let failCount = 0;
+        for (const order of targetOrders) {
+            try {
+                const response = await client.cancel(order.coin, order.oid);
+                if (response.status === 'ok') {
+                    console.log(`✅ Cancelled ${order.coin} order ${order.oid}`);
+                    successCount++;
+                }
+                else {
+                    console.log(`❌ Failed to cancel ${order.coin} order ${order.oid}`);
+                    failCount++;
+                }
+            }
+            catch (err) {
+                console.log(`❌ Error cancelling ${order.coin} order ${order.oid}: ${err}`);
+                failCount++;
+            }
+        }
+        console.log(`\nResult: ${successCount} cancelled, ${failCount} failed`);
+    }
+    catch (error) {
+        console.error('Error:', error);
+        process.exit(1);
+    }
+}
+main();

package/dist/operations/chase.d.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env npx tsx
+export interface ChaseOptions {
+    coin: string;
+    side: 'buy' | 'sell';
+    size: number;
+    offsetBps?: number;
+    timeoutSec?: number;
+    intervalMs?: number;
+    maxChaseBps?: number;
+    leverage?: number;
+    reduceOnly?: boolean;
+    dryRun?: boolean;
+    verbose?: boolean;
+    /** Receives each output line. Defaults to console.log. */
+    output?: (line: string) => void;
+}
+export interface ChaseResult {
+    status: 'dry' | 'filled' | 'timeout' | 'max_chase_exceeded';
+    iterations: number;
+    durationSec: number;
+    startMid: number;
+    endMid: number;
+}
+export declare function runChase(opts: ChaseOptions): Promise<ChaseResult>;
+//# sourceMappingURL=chase.d.ts.map

package/dist/operations/chase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chase.d.ts","sourceRoot":"","sources":["../../scripts/operations/chase.ts"],"names":[],"mappings":";AAuCA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,oBAAoB,CAAC;IAC5D,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CA2JvE"}

package/dist/operations/chase.js

@@ -0,0 +1,215 @@
+#!/usr/bin/env npx tsx
+// Chase Order - Follow price with limit orders until filled
+import { fileURLToPath } from 'url';
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs, sleep } from '../core/utils.js';
+function printUsage() {
+    console.log(`
+Open Broker - Chase Order
+=========================
+
+Place a limit order that chases the price until filled.
+Keeps adjusting the order to stay near the best price while avoiding taker fees.
+
+Usage:
+  npx tsx scripts/operations/chase.ts --coin <COIN> --side <buy|sell> --size <SIZE>
+
+Options:
+  --coin        Asset to trade (e.g., ETH, BTC)
+  --side        Order side: buy or sell
+  --size        Order size in base asset
+  --offset      Offset from mid price in bps (default: 5 = 0.05%)
+  --timeout     Max time to chase in seconds (default: 300 = 5 min)
+  --interval    Update interval in ms (default: 2000)
+  --max-chase   Max price to chase to in bps from start (default: 100 = 1%)
+  --leverage    Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
+  --reduce      Reduce-only order
+  --dry         Dry run - show chase parameters without executing
+
+Examples:
+  # Chase buy 0.5 ETH with 5 bps offset, 5 min timeout
+  npx tsx scripts/operations/chase.ts --coin ETH --side buy --size 0.5
+
+  # Chase sell with tighter offset and longer timeout
+  npx tsx scripts/operations/chase.ts --coin BTC --side sell --size 0.1 --offset 2 --timeout 600
+`);
+}
+export async function runChase(opts) {
+    const out = opts.output ?? ((line) => console.log(line));
+    const offsetBps = opts.offsetBps ?? 5;
+    const timeoutSec = opts.timeoutSec ?? 300;
+    const intervalMs = opts.intervalMs ?? 2000;
+    const maxChaseBps = opts.maxChaseBps ?? 100;
+    const isBuy = opts.side === 'buy';
+    if (opts.size <= 0 || isNaN(opts.size))
+        throw new Error('size must be positive');
+    const client = getClient();
+    if (opts.verbose)
+        client.verbose = true;
+    out('Open Broker - Chase Order');
+    out('=========================\n');
+    const mids = await client.getAllMids();
+    const startMid = parseFloat(mids[opts.coin]);
+    if (!startMid)
+        throw new Error(`No market data for ${opts.coin}`);
+    const maxChasePrice = isBuy
+        ? startMid * (1 + maxChaseBps / 10000)
+        : startMid * (1 - maxChaseBps / 10000);
+    out('Chase Parameters');
+    out('----------------');
+    out(`Coin:          ${opts.coin}`);
+    out(`Side:          ${isBuy ? 'BUY' : 'SELL'}`);
+    out(`Size:          ${opts.size}`);
+    out(`Start Mid:     ${formatUsd(startMid)}`);
+    out(`Offset:        ${offsetBps} bps (${(offsetBps / 100).toFixed(2)}%)`);
+    out(`Max Chase:     ${maxChaseBps} bps to ${formatUsd(maxChasePrice)}`);
+    out(`Timeout:       ${timeoutSec}s`);
+    out(`Update Rate:   ${intervalMs}ms`);
+    out(`Order Type:    ALO (post-only)`);
+    if (opts.dryRun) {
+        out('\n🔍 Dry run - chase not started');
+        return { status: 'dry', iterations: 0, durationSec: 0, startMid, endMid: startMid };
+    }
+    out('\nChasing...\n');
+    const startTime = Date.now();
+    let currentOid = null;
+    let lastPrice = null;
+    let iteration = 0;
+    let filled = false;
+    let exitReason = 'timeout';
+    while (Date.now() - startTime < timeoutSec * 1000) {
+        iteration++;
+        const currentMids = await client.getAllMids();
+        const currentMid = parseFloat(currentMids[opts.coin]);
+        if (isBuy && currentMid > maxChasePrice) {
+            out(`\n⚠️ Price ${formatUsd(currentMid)} exceeded max chase ${formatUsd(maxChasePrice)}`);
+            exitReason = 'max_chase_exceeded';
+            break;
+        }
+        if (!isBuy && currentMid < maxChasePrice) {
+            out(`\n⚠️ Price ${formatUsd(currentMid)} exceeded max chase ${formatUsd(maxChasePrice)}`);
+            exitReason = 'max_chase_exceeded';
+            break;
+        }
+        const orderPrice = isBuy
+            ? currentMid * (1 - offsetBps / 10000)
+            : currentMid * (1 + offsetBps / 10000);
+        const priceChanged = !lastPrice || Math.abs(orderPrice - lastPrice) / lastPrice > 0.0001;
+        if (priceChanged) {
+            if (currentOid !== null) {
+                try {
+                    await client.cancel(opts.coin, currentOid);
+                }
+                catch {
+                    // Order might have filled
+                }
+                currentOid = null;
+            }
+            const orders = await client.getOpenOrders();
+            const ourOrder = orders.find(o => o.coin === opts.coin && o.oid === currentOid);
+            if (!ourOrder && currentOid !== null) {
+                const state = await client.getUserState();
+                const pos = state.assetPositions.find(p => p.position.coin === opts.coin);
+                if (pos && Math.abs(parseFloat(pos.position.szi)) >= opts.size * 0.99) {
+                    filled = true;
+                    exitReason = 'filled';
+                    out(`\n✅ Order filled!`);
+                    break;
+                }
+            }
+            out(`[${iteration}] Mid: ${formatUsd(currentMid)} → Order: ${formatUsd(orderPrice)}...`);
+            const response = await client.limitOrder(opts.coin, isBuy, opts.size, orderPrice, 'Alo', opts.reduceOnly, opts.leverage);
+            if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+                const status = response.response.data.statuses[0];
+                if (status?.resting) {
+                    currentOid = status.resting.oid;
+                    lastPrice = orderPrice;
+                    out(`OID: ${currentOid}`);
+                }
+                else if (status?.filled) {
+                    filled = true;
+                    exitReason = 'filled';
+                    out(`✅ Filled @ ${formatUsd(parseFloat(status.filled.avgPx))}`);
+                    break;
+                }
+                else if (status?.error) {
+                    out(`❌ ${status.error}`);
+                }
+            }
+            else {
+                out(`❌ Failed`);
+            }
+        }
+        else {
+            if (currentOid !== null) {
+                const orders = await client.getOpenOrders();
+                const ourOrder = orders.find(o => o.oid === currentOid);
+                if (!ourOrder) {
+                    filled = true;
+                    exitReason = 'filled';
+                    out(`\n✅ Order filled!`);
+                    break;
+                }
+            }
+        }
+        await sleep(intervalMs);
+    }
+    if (currentOid !== null && !filled) {
+        out(`\nCancelling unfilled order...`);
+        try {
+            await client.cancel(opts.coin, currentOid);
+            out(`✅ Cancelled`);
+        }
+        catch {
+            out(`⚠️ Could not cancel (may have filled)`);
+        }
+    }
+    const elapsed = (Date.now() - startTime) / 1000;
+    const endMid = parseFloat((await client.getAllMids())[opts.coin]);
+    const priceMove = ((endMid - startMid) / startMid) * 10000;
+    out('\n========== Chase Summary ==========');
+    out(`Duration:     ${elapsed.toFixed(1)}s`);
+    out(`Iterations:   ${iteration}`);
+    out(`Start Mid:    ${formatUsd(startMid)}`);
+    out(`End Mid:      ${formatUsd(endMid)} (${priceMove >= 0 ? '+' : ''}${priceMove.toFixed(1)} bps)`);
+    out(`Result:       ${filled ? '✅ Filled' : '❌ Not filled'}`);
+    return { status: exitReason, iterations: iteration, durationSec: elapsed, startMid, endMid };
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const coin = args.coin;
+    const side = args.side;
+    const size = parseFloat(args.size);
+    if (!coin || !side || isNaN(size)) {
+        printUsage();
+        process.exit(1);
+    }
+    if (side !== 'buy' && side !== 'sell') {
+        console.error('Error: --side must be "buy" or "sell"');
+        process.exit(1);
+    }
+    try {
+        await runChase({
+            coin,
+            side: side,
+            size,
+            offsetBps: args.offset ? parseInt(args.offset) : undefined,
+            timeoutSec: args.timeout ? parseInt(args.timeout) : undefined,
+            intervalMs: args.interval ? parseInt(args.interval) : undefined,
+            maxChaseBps: args['max-chase'] ? parseInt(args['max-chase']) : undefined,
+            leverage: args.leverage ? parseInt(args.leverage) : undefined,
+            reduceOnly: args.reduce,
+            dryRun: args.dry,
+            verbose: args.verbose,
+        });
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+// Only run when invoked as a script — not when imported as a module
+// (e.g. by `openbroker-plugin` via the lib re-export of `runChase`).
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+    main();
+}

package/dist/operations/limit-order.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+//# sourceMappingURL=limit-order.d.ts.map

package/dist/operations/limit-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limit-order.d.ts","sourceRoot":"","sources":["../../scripts/operations/limit-order.ts"],"names":[],"mappings":""}