openbroker 1.3.2 → 1.5.0

package/dist/auto/examples/grid.js

@@ -0,0 +1,114 @@
+// Grid Trading — Place buy/sell orders at evenly spaced price levels
+export const config = {
+    description: 'Grid trading — buy/sell orders at evenly spaced price levels',
+    fields: {
+        coin: { type: 'string', description: 'Asset to trade', default: 'HYPE' },
+        lower: { type: 'number', description: 'Lower price bound (default: auto -5% from mid)', default: 0 },
+        upper: { type: 'number', description: 'Upper price bound (default: auto +5% from mid)', default: 0 },
+        grids: { type: 'number', description: 'Number of grid levels', default: 10 },
+        size: { type: 'number', description: 'Size per level in base asset', default: 0.1 },
+        mode: { type: 'string', description: 'Grid mode: neutral, long, or short', default: 'neutral' },
+    },
+};
+export default function grid(api) {
+    const COIN = api.state.get('coin', 'HYPE');
+    const GRIDS = api.state.get('grids', 10);
+    const SIZE = api.state.get('size', 0.1);
+    const MODE = api.state.get('mode', 'neutral');
+    let levels = [];
+    let realizedPnl = api.state.get('realizedPnl', 0);
+    let initialized = false;
+    api.onStart(async () => {
+        const mids = await api.client.getAllMids();
+        const mid = parseFloat(mids[COIN]);
+        if (!mid) {
+            api.log.error(`No price for ${COIN}`);
+            return;
+        }
+        const lower = api.state.get('lower', mid * 0.95);
+        const upper = api.state.get('upper', mid * 1.05);
+        const spacing = (upper - lower) / (GRIDS - 1);
+        api.log.info(`Grid: ${COIN} ${api.utils.formatUsd(lower)}-${api.utils.formatUsd(upper)} | ${GRIDS} levels | ${SIZE}/level | ${MODE}`);
+        // Build and place grid
+        for (let i = 0; i < GRIDS; i++) {
+            const price = lower + spacing * i;
+            let side;
+            if (MODE === 'long')
+                side = 'buy';
+            else if (MODE === 'short')
+                side = 'sell';
+            else
+                side = price < mid ? 'buy' : 'sell';
+            // Skip levels too close to mid
+            if (Math.abs(price - mid) / mid < 0.001)
+                continue;
+            const level = { price, side, size: SIZE };
+            const response = await api.client.limitOrder(COIN, side === 'buy', SIZE, price, 'Gtc', false);
+            if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+                const status = response.response.data.statuses[0];
+                if (status?.resting) {
+                    level.oid = status.resting.oid;
+                    api.log.info(`${side.toUpperCase()} @ ${api.utils.formatUsd(price)} — OID: ${level.oid}`);
+                }
+                else if (status?.filled) {
+                    api.log.info(`${side.toUpperCase()} @ ${api.utils.formatUsd(price)} — filled immediately`);
+                }
+            }
+            levels.push(level);
+            await api.utils.sleep(100);
+        }
+        initialized = true;
+        api.log.info(`Grid initialized: ${levels.filter(l => l.oid).length} open orders`);
+    });
+    // Monitor fills and replace with opposite orders
+    api.on('tick', async () => {
+        if (!initialized || levels.length === 0)
+            return;
+        const openOrders = await api.client.getOpenOrders();
+        const openOids = new Set(openOrders.filter(o => o.coin === COIN).map(o => o.oid));
+        const mids = await api.client.getAllMids();
+        const mid = parseFloat(mids[COIN]);
+        const lower = api.state.get('lower', mid * 0.95);
+        const upper = api.state.get('upper', mid * 1.05);
+        const spacing = (upper - lower) / (GRIDS - 1);
+        for (const level of levels) {
+            if (!level.oid || openOids.has(level.oid))
+                continue;
+            // Order was filled
+            api.log.info(`${level.side.toUpperCase()} FILLED @ ${api.utils.formatUsd(level.price)}`);
+            level.oid = undefined;
+            if (MODE !== 'neutral')
+                continue;
+            // Place opposite order
+            const oppositeSide = level.side === 'buy' ? 'sell' : 'buy';
+            const oppositePrice = level.side === 'buy' ? level.price + spacing : level.price - spacing;
+            if (oppositePrice < lower || oppositePrice > upper)
+                continue;
+            const response = await api.client.limitOrder(COIN, oppositeSide === 'buy', SIZE, oppositePrice, 'Gtc', false);
+            if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+                const status = response.response.data.statuses[0];
+                if (status?.resting) {
+                    const newLevel = { price: oppositePrice, side: oppositeSide, size: SIZE, oid: status.resting.oid };
+                    levels.push(newLevel);
+                    if (level.side === 'buy') {
+                        realizedPnl += (oppositePrice - level.price) * SIZE;
+                    }
+                    api.state.set('realizedPnl', realizedPnl);
+                    api.log.info(`Placed ${oppositeSide.toUpperCase()} @ ${api.utils.formatUsd(oppositePrice)} | PnL: ${api.utils.formatUsd(realizedPnl)}`);
+                }
+            }
+        }
+    });
+    api.onStop(async () => {
+        api.log.info('Cancelling grid orders...');
+        for (const level of levels) {
+            if (level.oid) {
+                try {
+                    await api.client.cancel(COIN, level.oid);
+                }
+                catch { /* may be filled */ }
+            }
+        }
+        api.log.info(`Grid stopped. Realized PnL: ${api.utils.formatUsd(realizedPnl)}`);
+    });
+}

package/dist/auto/examples/mm-maker.d.ts

@@ -0,0 +1,4 @@
+import type { AutomationAPI, AutomationConfig } from '../types.js';
+export declare const config: AutomationConfig;
+export default function mmMaker(api: AutomationAPI): void;
+//# sourceMappingURL=mm-maker.d.ts.map

package/dist/auto/examples/mm-maker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mm-maker.d.ts","sourceRoot":"","sources":["../../../scripts/auto/examples/mm-maker.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEnE,eAAO,MAAM,MAAM,EAAE,gBASpB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,GAAG,EAAE,aAAa,QA6GjD"}

package/dist/auto/examples/mm-maker.js

@@ -0,0 +1,131 @@
+// Maker-Only Market Making — ALO orders that guarantee maker rebates
+export const config = {
+    description: 'Maker-only market making — ALO orders for guaranteed maker rebates',
+    fields: {
+        coin: { type: 'string', description: 'Asset to market make', default: 'HYPE' },
+        size: { type: 'number', description: 'Order size on each side (base asset)', default: 0.1 },
+        offsetBps: { type: 'number', description: 'Offset from best bid/ask in bps', default: 1 },
+        maxPosition: { type: 'number', description: 'Max net position (default: 3x size)', default: 0.3 },
+        skewFactor: { type: 'number', description: 'Inventory skew aggressiveness', default: 2.0 },
+    },
+};
+export default function mmMaker(api) {
+    const COIN = api.state.get('coin', 'HYPE');
+    const SIZE = api.state.get('size', 0.1);
+    const OFFSET_BPS = api.state.get('offsetBps', 1);
+    const MAX_POS = api.state.get('maxPosition', SIZE * 3);
+    const SKEW = api.state.get('skewFactor', 2.0);
+    let bidOid;
+    let askOid;
+    let bidPrice = 0;
+    let askPrice = 0;
+    let totalBought = 0;
+    let totalSold = 0;
+    let totalBuyCost = 0;
+    let totalSellRevenue = 0;
+    let rejections = 0;
+    const offsetFraction = OFFSET_BPS / 10000;
+    api.onStart(() => {
+        api.log.info(`Maker MM: ${COIN} | ${SIZE}/side | ${OFFSET_BPS}bps offset | ALO only`);
+    });
+    api.on('tick', async () => {
+        const book = await api.client.getL2Book(COIN);
+        if (book.bestBid === 0 || book.bestAsk === 0)
+            return;
+        // Get position
+        const userState = await api.client.getUserState();
+        const pos = userState.assetPositions.find(p => p.position.coin === COIN);
+        const position = pos ? parseFloat(pos.position.szi) : 0;
+        // Check fills
+        const openOrders = await api.client.getOpenOrders();
+        const openOids = new Set(openOrders.filter(o => o.coin === COIN).map(o => o.oid));
+        if (bidOid && !openOids.has(bidOid)) {
+            totalBought += SIZE;
+            totalBuyCost += bidPrice * SIZE;
+            api.log.info(`BID FILLED @ ${api.utils.formatUsd(bidPrice)} | Pos: ${position.toFixed(4)} | +rebate`);
+            bidOid = undefined;
+        }
+        if (askOid && !openOids.has(askOid)) {
+            totalSold += SIZE;
+            totalSellRevenue += askPrice * SIZE;
+            api.log.info(`ASK FILLED @ ${api.utils.formatUsd(askPrice)} | Pos: ${position.toFixed(4)} | +rebate`);
+            askOid = undefined;
+        }
+        // Inventory skew
+        const ratio = Math.max(-1, Math.min(1, position / MAX_POS));
+        const bidSkewMult = 1 + ratio * SKEW;
+        const askSkewMult = 1 - ratio * SKEW;
+        const targetBid = book.bestBid * (1 - offsetFraction * Math.max(0.1, bidSkewMult));
+        const targetAsk = book.bestAsk * (1 + offsetFraction * Math.max(0.1, askSkewMult));
+        // Ensure no crossing
+        const safeBid = Math.min(targetBid, book.bestAsk * 0.9999);
+        const safeAsk = Math.max(targetAsk, book.bestBid * 1.0001);
+        const shouldBid = position < MAX_POS;
+        const shouldAsk = position > -MAX_POS;
+        // Cancel stale quotes
+        if (bidOid) {
+            const drift = Math.abs(bidPrice - safeBid) / book.midPrice;
+            if (drift > 0.0005 || !shouldBid) {
+                try {
+                    await api.client.cancel(COIN, bidOid);
+                }
+                catch { /* */ }
+                bidOid = undefined;
+            }
+        }
+        if (askOid) {
+            const drift = Math.abs(askPrice - safeAsk) / book.midPrice;
+            if (drift > 0.0005 || !shouldAsk) {
+                try {
+                    await api.client.cancel(COIN, askOid);
+                }
+                catch { /* */ }
+                askOid = undefined;
+            }
+        }
+        // Place ALO bid
+        if (shouldBid && !bidOid && safeBid < book.bestAsk) {
+            const resp = await api.client.limitOrder(COIN, true, SIZE, safeBid, 'Alo', false);
+            if (resp.status === 'ok' && resp.response && typeof resp.response === 'object') {
+                const s = resp.response.data.statuses[0];
+                if (s?.resting) {
+                    bidOid = s.resting.oid;
+                    bidPrice = safeBid;
+                }
+                else if (s?.error) {
+                    rejections++;
+                }
+            }
+        }
+        // Place ALO ask
+        if (shouldAsk && !askOid && safeAsk > book.bestBid) {
+            const resp = await api.client.limitOrder(COIN, false, SIZE, safeAsk, 'Alo', false);
+            if (resp.status === 'ok' && resp.response && typeof resp.response === 'object') {
+                const s = resp.response.data.statuses[0];
+                if (s?.resting) {
+                    askOid = s.resting.oid;
+                    askPrice = safeAsk;
+                }
+                else if (s?.error) {
+                    rejections++;
+                }
+            }
+        }
+    });
+    api.onStop(async () => {
+        if (bidOid)
+            try {
+                await api.client.cancel(COIN, bidOid);
+            }
+            catch { /* */ }
+        if (askOid)
+            try {
+                await api.client.cancel(COIN, askOid);
+            }
+            catch { /* */ }
+        const pnl = totalSellRevenue - totalBuyCost;
+        const volume = totalBuyCost + totalSellRevenue;
+        const rebates = volume * 0.00003;
+        api.log.info(`Maker MM stopped. PnL: ${api.utils.formatUsd(pnl)} | Rebates: ~${api.utils.formatUsd(rebates)} | Rejections: ${rejections}`);
+    });
+}

package/dist/auto/examples/mm-spread.d.ts

@@ -0,0 +1,4 @@
+import type { AutomationAPI, AutomationConfig } from '../types.js';
+export declare const config: AutomationConfig;
+export default function mmSpread(api: AutomationAPI): void;
+//# sourceMappingURL=mm-spread.d.ts.map

package/dist/auto/examples/mm-spread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mm-spread.d.ts","sourceRoot":"","sources":["../../../scripts/auto/examples/mm-spread.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEnE,eAAO,MAAM,MAAM,EAAE,gBASpB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,GAAG,EAAE,aAAa,QAmGlD"}

package/dist/auto/examples/mm-spread.js

@@ -0,0 +1,119 @@
+// Market Making (Spread) — Quote bid/ask around mid with inventory skewing
+export const config = {
+    description: 'Market making — quote bid/ask around mid price with inventory skewing',
+    fields: {
+        coin: { type: 'string', description: 'Asset to market make', default: 'HYPE' },
+        size: { type: 'number', description: 'Order size on each side (base asset)', default: 0.1 },
+        spreadBps: { type: 'number', description: 'Spread in bps from mid price', default: 10 },
+        maxPosition: { type: 'number', description: 'Max net position before pausing side (default: 3x size)', default: 0.3 },
+        skewFactor: { type: 'number', description: 'Inventory skew aggressiveness', default: 2.0 },
+    },
+};
+export default function mmSpread(api) {
+    const COIN = api.state.get('coin', 'HYPE');
+    const SIZE = api.state.get('size', 0.1);
+    const SPREAD_BPS = api.state.get('spreadBps', 10);
+    const MAX_POS = api.state.get('maxPosition', SIZE * 3);
+    const SKEW = api.state.get('skewFactor', 2.0);
+    let bidOid;
+    let askOid;
+    let bidPrice = 0;
+    let askPrice = 0;
+    let totalBought = 0;
+    let totalSold = 0;
+    let totalBuyCost = 0;
+    let totalSellRevenue = 0;
+    const halfSpread = SPREAD_BPS / 10000 / 2;
+    api.onStart(() => {
+        api.log.info(`MM Spread: ${COIN} | ${SIZE}/side | ${SPREAD_BPS}bps | Max: ±${MAX_POS}`);
+    });
+    api.on('tick', async () => {
+        const mids = await api.client.getAllMids();
+        const mid = parseFloat(mids[COIN]);
+        if (!mid)
+            return;
+        // Get position
+        const userState = await api.client.getUserState();
+        const pos = userState.assetPositions.find(p => p.position.coin === COIN);
+        const position = pos ? parseFloat(pos.position.szi) : 0;
+        // Check fills
+        const openOrders = await api.client.getOpenOrders();
+        const openOids = new Set(openOrders.filter(o => o.coin === COIN).map(o => o.oid));
+        if (bidOid && !openOids.has(bidOid)) {
+            totalBought += SIZE;
+            totalBuyCost += bidPrice * SIZE;
+            api.log.info(`BID FILLED @ ${api.utils.formatUsd(bidPrice)} | Pos: ${position.toFixed(4)}`);
+            bidOid = undefined;
+        }
+        if (askOid && !openOids.has(askOid)) {
+            totalSold += SIZE;
+            totalSellRevenue += askPrice * SIZE;
+            api.log.info(`ASK FILLED @ ${api.utils.formatUsd(askPrice)} | Pos: ${position.toFixed(4)}`);
+            askOid = undefined;
+        }
+        // Inventory skew
+        const ratio = Math.max(-1, Math.min(1, position / MAX_POS));
+        const bidSkew = halfSpread * (1 + ratio * SKEW);
+        const askSkew = halfSpread * (1 - ratio * SKEW);
+        const targetBid = mid * (1 - Math.max(0.0001, bidSkew));
+        const targetAsk = mid * (1 + Math.max(0.0001, askSkew));
+        const shouldBid = position < MAX_POS;
+        const shouldAsk = position > -MAX_POS;
+        // Cancel stale quotes
+        if (bidOid) {
+            const drift = Math.abs(bidPrice - targetBid) / mid;
+            if (drift > 0.001 || !shouldBid) {
+                try {
+                    await api.client.cancel(COIN, bidOid);
+                }
+                catch { /* */ }
+                bidOid = undefined;
+            }
+        }
+        if (askOid) {
+            const drift = Math.abs(askPrice - targetAsk) / mid;
+            if (drift > 0.001 || !shouldAsk) {
+                try {
+                    await api.client.cancel(COIN, askOid);
+                }
+                catch { /* */ }
+                askOid = undefined;
+            }
+        }
+        // Place new quotes
+        if (shouldBid && !bidOid) {
+            const resp = await api.client.limitOrder(COIN, true, SIZE, targetBid, 'Gtc', false);
+            if (resp.status === 'ok' && resp.response && typeof resp.response === 'object') {
+                const s = resp.response.data.statuses[0];
+                if (s?.resting) {
+                    bidOid = s.resting.oid;
+                    bidPrice = targetBid;
+                }
+            }
+        }
+        if (shouldAsk && !askOid) {
+            const resp = await api.client.limitOrder(COIN, false, SIZE, targetAsk, 'Gtc', false);
+            if (resp.status === 'ok' && resp.response && typeof resp.response === 'object') {
+                const s = resp.response.data.statuses[0];
+                if (s?.resting) {
+                    askOid = s.resting.oid;
+                    askPrice = targetAsk;
+                }
+            }
+        }
+    });
+    api.onStop(async () => {
+        if (bidOid)
+            try {
+                await api.client.cancel(COIN, bidOid);
+            }
+            catch { /* */ }
+        if (askOid)
+            try {
+                await api.client.cancel(COIN, askOid);
+            }
+            catch { /* */ }
+        const pnl = totalSellRevenue - totalBuyCost;
+        api.log.info(`MM stopped. Bought: ${totalBought.toFixed(6)} | Sold: ${totalSold.toFixed(6)} | PnL: ${api.utils.formatUsd(pnl)}`);
+    });
+}

package/dist/auto/examples/price-alert.d.ts

@@ -0,0 +1,4 @@
+import type { AutomationAPI, AutomationConfig } from '../types.js';
+export declare const config: AutomationConfig;
+export default function priceAlert(api: AutomationAPI): void;
+//# sourceMappingURL=price-alert.d.ts.map

package/dist/auto/examples/price-alert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"price-alert.d.ts","sourceRoot":"","sources":["../../../scripts/auto/examples/price-alert.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEnE,eAAO,MAAM,MAAM,EAAE,gBAQpB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,GAAG,EAAE,aAAa,QAgFpD"}

package/dist/auto/examples/price-alert.js

@@ -0,0 +1,85 @@
+// Price Alert — Real-time price monitoring via WebSocket
+// Showcases WebSocket-driven price_change and order_update events
+export const config = {
+    description: 'Real-time price alerts via WebSocket — log price moves and order updates',
+    fields: {
+        coin: { type: 'string', description: 'Asset to monitor', default: 'BTC' },
+        threshold: { type: 'number', description: 'Min price change % to alert on', default: 0.1 },
+        above: { type: 'number', description: 'Alert when price goes above this level (0 = disabled)', default: 0 },
+        below: { type: 'number', description: 'Alert when price goes below this level (0 = disabled)', default: 0 },
+    },
+};
+export default function priceAlert(api) {
+    const COIN = api.state.get('coin', 'BTC');
+    const THRESHOLD = api.state.get('threshold', 0.1);
+    const ABOVE = api.state.get('above', 0);
+    const BELOW = api.state.get('below', 0);
+    let alertCount = 0;
+    let lastAlertPrice = 0;
+    let aboveTriggered = false;
+    let belowTriggered = false;
+    api.onStart(() => {
+        api.log.info(`Monitoring ${COIN} via WebSocket`);
+        api.log.info(`Threshold: ${THRESHOLD}% change`);
+        if (ABOVE > 0)
+            api.log.info(`Alert above: $${ABOVE}`);
+        if (BELOW > 0)
+            api.log.info(`Alert below: $${BELOW}`);
+    });
+    // Real-time price changes via WebSocket
+    api.on('price_change', ({ coin, oldPrice, newPrice, changePct }) => {
+        if (coin !== COIN)
+            return;
+        // Threshold alerts — fires when move exceeds configured %
+        if (Math.abs(changePct) >= THRESHOLD) {
+            const dir = changePct > 0 ? 'UP' : 'DOWN';
+            api.log.info(`${COIN} ${dir} ${changePct.toFixed(3)}%: $${oldPrice.toFixed(2)} -> $${newPrice.toFixed(2)}`);
+            alertCount++;
+            lastAlertPrice = newPrice;
+        }
+        // Level alerts — fires once when price crosses a level, resets when it crosses back
+        if (ABOVE > 0) {
+            if (newPrice >= ABOVE && !aboveTriggered) {
+                aboveTriggered = true;
+                api.log.info(`${COIN} ABOVE $${ABOVE}: now $${newPrice.toFixed(2)}`);
+                api.publish(`${COIN} broke above $${ABOVE} — now $${newPrice.toFixed(2)}`, { name: 'price-alert' });
+            }
+            else if (newPrice < ABOVE) {
+                aboveTriggered = false;
+            }
+        }
+        if (BELOW > 0) {
+            if (newPrice <= BELOW && !belowTriggered) {
+                belowTriggered = true;
+                api.log.info(`${COIN} BELOW $${BELOW}: now $${newPrice.toFixed(2)}`);
+                api.publish(`${COIN} dropped below $${BELOW} — now $${newPrice.toFixed(2)}`, { name: 'price-alert' });
+            }
+            else if (newPrice > BELOW) {
+                belowTriggered = false;
+            }
+        }
+    });
+    // Real-time order lifecycle via WebSocket
+    api.on('order_update', ({ coin, oid, side, size, price, status }) => {
+        if (status === 'filled') {
+            api.log.info(`ORDER FILLED: ${side.toUpperCase()} ${size} ${coin} @ $${price.toFixed(2)} (oid: ${oid})`);
+        }
+        else if (status === 'canceled' || status.includes('Canceled') || status.includes('Rejected')) {
+            api.log.warn(`ORDER ${status.toUpperCase()}: ${side} ${size} ${coin} @ $${price.toFixed(2)} (oid: ${oid})`);
+        }
+    });
+    // Liquidation alerts via WebSocket
+    api.on('liquidation', ({ liquidatedNtlPos, liquidatedAccountValue }) => {
+        api.log.error(`LIQUIDATION: $${liquidatedNtlPos.toFixed(2)} notional, account value: $${liquidatedAccountValue.toFixed(2)}`);
+        api.publish(`LIQUIDATED: $${liquidatedNtlPos.toFixed(2)} notional, account value: $${liquidatedAccountValue.toFixed(2)}`, { name: 'liquidation-alert' });
+    });
+    // Periodic summary via REST heartbeat
+    api.on('tick', ({ pollCount }) => {
+        if (pollCount % 10 === 0 && alertCount > 0) {
+            api.log.info(`Summary: ${alertCount} alerts fired, last price: $${lastAlertPrice.toFixed(2)}`);
+        }
+    });
+    api.onStop(() => {
+        api.log.info(`Stopped. Total alerts: ${alertCount}`);
+    });
+}

package/dist/auto/keep-awake.d.ts

@@ -0,0 +1,11 @@
+type KeepAwakeLogger = {
+    info(message: string): void;
+    warn(message: string): void;
+};
+export interface KeepAwakeHandle {
+    backend: string;
+    stop(): void;
+}
+export declare function startKeepAwake(reason: string, log: KeepAwakeLogger): KeepAwakeHandle | null;
+export {};
+//# sourceMappingURL=keep-awake.d.ts.map

package/dist/auto/keep-awake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keep-awake.d.ts","sourceRoot":"","sources":["../../scripts/auto/keep-awake.ts"],"names":[],"mappings":"AAEA,KAAK,eAAe,GAAG;IACrB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,IAAI,IAAI,CAAC;CACd;AA6ED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,eAAe,GAAG,IAAI,CAY3F"}

package/dist/auto/keep-awake.js

@@ -0,0 +1,70 @@
+import { spawn } from 'child_process';
+function createHandle(child, backend, log) {
+    let stopping = false;
+    child.once('error', (error) => {
+        if (!stopping) {
+            log.warn(`keep-awake unavailable via ${backend}: ${error.message}`);
+        }
+    });
+    child.once('exit', (code, signal) => {
+        if (!stopping) {
+            const suffix = signal ? `signal ${signal}` : `code ${code ?? 'unknown'}`;
+            log.warn(`keep-awake helper ${backend} exited unexpectedly (${suffix}); host may sleep.`);
+        }
+    });
+    return {
+        backend,
+        stop() {
+            stopping = true;
+            if (!child.killed)
+                child.kill();
+        },
+    };
+}
+function startDarwin(log) {
+    const child = spawn('caffeinate', ['-i', '-w', String(process.pid)], {
+        stdio: 'ignore',
+    });
+    return createHandle(child, 'caffeinate', log);
+}
+function startLinux(reason, log) {
+    const child = spawn('systemd-inhibit', [
+        '--what=sleep',
+        '--who=OpenBroker',
+        `--why=${reason}`,
+        '--mode=block',
+        'sh',
+        '-c',
+        'while kill -0 "$1" 2>/dev/null; do sleep 30; done',
+        'sh',
+        String(process.pid),
+    ], { stdio: 'ignore' });
+    return createHandle(child, 'systemd-inhibit', log);
+}
+function startWindows(log) {
+    const script = [
+        'Add-Type -Namespace OpenBroker -Name Native -MemberDefinition',
+        '\'"[DllImport(\\\"kernel32.dll\\\")] public static extern uint SetThreadExecutionState(uint esFlags);"\';',
+        '[OpenBroker.Native]::SetThreadExecutionState(0x80000001) | Out-Null;',
+        `Wait-Process -Id ${process.pid};`,
+        '[OpenBroker.Native]::SetThreadExecutionState(0x80000000) | Out-Null;',
+    ].join(' ');
+    const child = spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], {
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    return createHandle(child, 'SetThreadExecutionState', log);
+}
+export function startKeepAwake(reason, log) {
+    switch (process.platform) {
+        case 'darwin':
+            return startDarwin(log);
+        case 'linux':
+            return startLinux(reason, log);
+        case 'win32':
+            return startWindows(log);
+        default:
+            log.warn(`keep-awake is not supported on platform ${process.platform}; host may sleep.`);
+            return null;
+    }
+}

package/dist/auto/loader.d.ts

@@ -0,0 +1,22 @@
+import type { AutomationFactory, AutomationConfig } from './types.js';
+/** Resolve a script path from a name or path */
+export declare function resolveScriptPath(nameOrPath: string): string;
+/** Resolve a bundled example by name */
+export declare function resolveExamplePath(name: string): string;
+/** List bundled example automations */
+export declare function listExamples(): Array<{
+    name: string;
+    path: string;
+}>;
+/** Load config metadata from all bundled examples */
+export declare function loadExampleConfigs(): Promise<Record<string, AutomationConfig>>;
+/** Load an automation module and validate the default export */
+export declare function loadAutomation(scriptPath: string): Promise<AutomationFactory>;
+/** List available automation scripts in ~/.openbroker/automations/ */
+export declare function listAutomations(): Array<{
+    name: string;
+    path: string;
+}>;
+/** Ensure the automations directory exists */
+export declare function ensureAutomationsDir(): void;
+//# sourceMappingURL=loader.d.ts.map

package/dist/auto/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../scripts/auto/loader.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAQtE,gDAAgD;AAChD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA2B5D;AAED,wCAAwC;AACxC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOvD;AAED,uCAAuC;AACvC,wBAAgB,YAAY,IAAI,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CASpE;AAED,qDAAqD;AACrD,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAiBpF;AAmCD,gEAAgE;AAChE,wBAAsB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAenF;AAED,sEAAsE;AACtE,wBAAgB,eAAe,IAAI,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CASvE;AAED,8CAA8C;AAC9C,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C"}