openbroker 1.3.2 → 1.4.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to Open Broker will be documented in this file.
 
+## [1.4.0] - 2026-05-31
+
+### Fixed
+- **Library is now runtime-importable by external consumers.** The package entry
+  previously pointed at raw TypeScript source (`main: ./scripts/lib.ts`), so any
+  in-process consumer running outside a TS loader (or under a runner that doesn't
+  transpile `node_modules`, e.g. tsx) imported an **empty module**. Added a build
+  (`npm run build` → `tsc`) that emits compiled JS + type declarations to `dist/`,
+  and pointed `main`/`types`/`exports` at `dist/lib.js` / `dist/lib.d.ts`. The CLI
+  still runs from source via tsx; only the library entry changed. `prepublishOnly`
+  now builds before publishing. No public API changes.
+
 ## [1.3.0] - 2026-05-07
 
 ### Added

package/dist/auto/audit.d.ts

@@ -0,0 +1,57 @@
+export interface AutomationAuditSink {
+    readonly runId: string;
+    readonly dbPath: string;
+    recordLog(level: 'info' | 'warn' | 'error' | 'debug', message: string, timestamp?: number): void;
+    recordEvent(eventType: string, source: 'poll' | 'ws' | 'manual', payload: unknown, timestamp?: number): void;
+    recordAction(args: {
+        actionId?: string;
+        phase: 'request' | 'response' | 'error';
+        method: string;
+        payload?: unknown;
+        result?: unknown;
+        error?: unknown;
+        dryRun?: boolean;
+        timestamp?: number;
+    }): void;
+    recordSnapshot(snapshot: {
+        pollCount: number;
+        equity: number;
+        marginUsed: number;
+        marginUsedPct: number;
+        positions: unknown[];
+        timestamp?: number;
+    }): void;
+    recordOrderUpdate(payload: unknown, timestamp?: number): void;
+    recordFill(payload: unknown, timestamp?: number): void;
+    recordUserEvent(payload: unknown, timestamp?: number): void;
+    recordStateChange(op: 'set' | 'delete' | 'clear', key: string | null, value?: unknown, timestamp?: number): void;
+    recordPublish(message: string, options: unknown, delivered: boolean, timestamp?: number): void;
+    recordError(stage: string, error: unknown, timestamp?: number): void;
+    recordNote(kind: string, payload?: unknown, timestamp?: number): void;
+    recordMetric(name: string, value: number, tags?: Record<string, unknown>, timestamp?: number): void;
+    stop(args: {
+        status: 'stopped' | 'error';
+        stopReason: string;
+        pollCount: number;
+        eventsEmitted: number;
+        timestamp?: number;
+    }): Promise<void>;
+}
+export interface AuditStartOptions {
+    automationId: string;
+    scriptPath: string;
+    dryRun: boolean;
+    verbose: boolean;
+    pollIntervalMs: number;
+    useWebSocket: boolean;
+    accountAddress: string;
+    walletAddress: string;
+    isApiWallet: boolean;
+    initialState?: Record<string, unknown>;
+    persistedState?: Record<string, unknown>;
+}
+export declare const AUDIT_DB_PATH: string;
+export declare const AUDIT_SOCKET_PATH: string;
+export declare function toSerializable<T = unknown>(value: T): T;
+export declare function createAutomationAudit(options: AuditStartOptions): AutomationAuditSink;
+//# sourceMappingURL=audit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../scripts/auto/audit.ts"],"names":[],"mappings":"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"}

package/dist/auto/audit.js

@@ -0,0 +1,407 @@
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import { once } from 'events';
+import net from 'net';
+import path from 'path';
+import readline from 'readline';
+import { setTimeout as delay } from 'timers/promises';
+import { fileURLToPath } from 'url';
+import { ensureConfigDir } from '../core/config.js';
+export const AUDIT_DB_PATH = process.env.OPENBROKER_AUDIT_DB_PATH
+    || path.join(ensureConfigDir(), 'automation-audit.sqlite');
+export const AUDIT_SOCKET_PATH = process.env.OPENBROKER_AUDIT_SOCKET_PATH
+    || (process.platform === 'win32'
+        ? '\\\\.\\pipe\\openbroker-automation-audit-v2'
+        : path.join(ensureConfigDir(), 'automation-audit.v2.sock'));
+function internalWarn(automationId, message) {
+    console.error(`[auto:${automationId}:audit] ${message}`);
+}
+export function toSerializable(value) {
+    const seen = new WeakSet();
+    const encoded = JSON.stringify(value, (_key, currentValue) => {
+        if (typeof currentValue === 'bigint') {
+            return currentValue.toString();
+        }
+        if (currentValue instanceof Error) {
+            return {
+                name: currentValue.name,
+                message: currentValue.message,
+                stack: currentValue.stack,
+            };
+        }
+        if (currentValue instanceof Map) {
+            return Object.fromEntries(currentValue.entries());
+        }
+        if (currentValue instanceof Set) {
+            return [...currentValue.values()];
+        }
+        if (typeof currentValue === 'object' && currentValue !== null) {
+            if (seen.has(currentValue)) {
+                return '[Circular]';
+            }
+            seen.add(currentValue);
+        }
+        return currentValue;
+    });
+    if (encoded === undefined) {
+        return null;
+    }
+    return JSON.parse(encoded);
+}
+class NoopAuditSink {
+    runId = randomUUID();
+    dbPath = AUDIT_DB_PATH;
+    recordLog() { }
+    recordEvent() { }
+    recordAction() { }
+    recordSnapshot() { }
+    recordOrderUpdate() { }
+    recordFill() { }
+    recordUserEvent() { }
+    recordStateChange() { }
+    recordPublish() { }
+    recordError() { }
+    recordNote() { }
+    recordMetric() { }
+    async stop() { }
+}
+class DaemonAuditSink {
+    automationId;
+    runId = randomUUID();
+    dbPath = AUDIT_DB_PATH;
+    socketPath = AUDIT_SOCKET_PATH;
+    socket = null;
+    lineReader = null;
+    connectPromise = null;
+    flushPromise = null;
+    closed = false;
+    daemonSpawnedAt = 0;
+    pendingQueue = [];
+    inFlight = new Map();
+    ackWaiters = new Map();
+    constructor(automationId, options) {
+        this.automationId = automationId;
+        this.enqueue({
+            type: 'init',
+            payload: {
+                runId: this.runId,
+                automationId: options.automationId,
+                scriptPath: options.scriptPath,
+                dryRun: options.dryRun,
+                verbose: options.verbose,
+                pollIntervalMs: options.pollIntervalMs,
+                useWebSocket: options.useWebSocket,
+                accountAddress: options.accountAddress,
+                walletAddress: options.walletAddress,
+                isApiWallet: options.isApiWallet,
+                initialState: toSerializable(options.initialState ?? {}),
+                persistedState: toSerializable(options.persistedState ?? {}),
+                pid: process.pid,
+                startedAt: Date.now(),
+            },
+        });
+    }
+    handleSocketClose() {
+        if (this.lineReader) {
+            this.lineReader.close();
+            this.lineReader = null;
+        }
+        const inflight = [...this.inFlight.values()];
+        this.inFlight.clear();
+        if (inflight.length > 0) {
+            this.pendingQueue = inflight.concat(this.pendingQueue);
+        }
+        this.socket = null;
+        if (!this.closed) {
+            void this.ensureConnected();
+        }
+    }
+    handleResponse(line) {
+        let response;
+        try {
+            response = JSON.parse(line);
+        }
+        catch (error) {
+            internalWarn(this.automationId, `failed to parse audit daemon response: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        this.inFlight.delete(response.messageId);
+        const waiter = this.ackWaiters.get(response.messageId);
+        if (!waiter)
+            return;
+        this.ackWaiters.delete(response.messageId);
+        if (response.ok) {
+            waiter.resolve();
+        }
+        else {
+            waiter.reject(new Error(response.error || 'audit daemon returned an error'));
+        }
+    }
+    async openConnection() {
+        const socket = net.createConnection(this.socketPath);
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const onConnect = () => {
+                if (settled)
+                    return;
+                settled = true;
+                socket.off('error', onError);
+                resolve();
+            };
+            const onError = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                socket.off('connect', onConnect);
+                socket.destroy();
+                reject(error);
+            };
+            socket.once('connect', onConnect);
+            socket.once('error', onError);
+        });
+        socket.setEncoding('utf8');
+        socket.on('close', () => this.handleSocketClose());
+        socket.on('error', (error) => {
+            if (!this.closed) {
+                internalWarn(this.automationId, `audit socket error: ${error.message}`);
+            }
+        });
+        this.lineReader = readline.createInterface({
+            input: socket,
+            crlfDelay: Infinity,
+        });
+        this.lineReader.on('line', (line) => this.handleResponse(line));
+        this.socket = socket;
+    }
+    async spawnDaemon() {
+        const now = Date.now();
+        if (now - this.daemonSpawnedAt < 1_000)
+            return;
+        this.daemonSpawnedAt = now;
+        const daemonPath = fileURLToPath(new URL('./audit-daemon.js', import.meta.url));
+        const child = spawn(process.execPath, ['--no-warnings', '--experimental-sqlite', daemonPath, this.dbPath, this.socketPath], {
+            detached: true,
+            stdio: 'ignore',
+            env: { ...process.env },
+        });
+        child.unref();
+    }
+    async ensureConnected() {
+        if (this.closed)
+            return;
+        if (this.socket && !this.socket.destroyed)
+            return;
+        if (this.connectPromise)
+            return this.connectPromise;
+        this.connectPromise = (async () => {
+            try {
+                await this.openConnection();
+            }
+            catch {
+                await this.spawnDaemon();
+                let lastError = null;
+                for (let attempt = 0; attempt < 30 && !this.closed; attempt++) {
+                    try {
+                        await delay(100 + (attempt * 50));
+                        await this.openConnection();
+                        lastError = null;
+                        break;
+                    }
+                    catch (error) {
+                        lastError = error instanceof Error ? error : new Error(String(error));
+                    }
+                }
+                if (lastError) {
+                    throw lastError;
+                }
+            }
+            await this.flushQueue();
+        })().catch((error) => {
+            internalWarn(this.automationId, `audit daemon unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        }).finally(() => {
+            this.connectPromise = null;
+        });
+        return this.connectPromise;
+    }
+    enqueue(message) {
+        const payload = message.type === 'init'
+            ? message.payload
+            : { runId: this.runId, ...message.payload };
+        const wire = {
+            messageId: randomUUID(),
+            type: message.type,
+            payload,
+        };
+        this.pendingQueue.push(wire);
+        void this.ensureConnected();
+        if (this.socket && !this.socket.destroyed) {
+            void this.flushQueue();
+        }
+        return wire;
+    }
+    async flushQueue() {
+        if (this.flushPromise)
+            return this.flushPromise;
+        this.flushPromise = (async () => {
+            while (!this.closed && this.socket && !this.socket.destroyed && this.pendingQueue.length > 0) {
+                const message = this.pendingQueue.shift();
+                this.inFlight.set(message.messageId, message);
+                const line = `${JSON.stringify(message)}\n`;
+                const writable = this.socket.write(line);
+                if (!writable && this.socket) {
+                    await once(this.socket, 'drain');
+                }
+            }
+        })().finally(() => {
+            this.flushPromise = null;
+        });
+        return this.flushPromise;
+    }
+    send(message, waitForAck = false) {
+        if (this.closed)
+            return Promise.resolve();
+        const wire = this.enqueue(message);
+        if (!waitForAck)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            this.ackWaiters.set(wire.messageId, { resolve, reject });
+            void this.flushQueue();
+        });
+    }
+    recordLog(level, message, timestamp = Date.now()) {
+        void this.send({ type: 'log', payload: { timestamp, level, message } });
+    }
+    recordEvent(eventType, source, payload, timestamp = Date.now()) {
+        void this.send({ type: 'event', payload: { timestamp, eventType, source, payload: toSerializable(payload) } });
+    }
+    recordAction(args) {
+        void this.send({
+            type: 'action',
+            payload: {
+                timestamp: args.timestamp ?? Date.now(),
+                actionId: args.actionId ?? randomUUID(),
+                phase: args.phase,
+                method: args.method,
+                payload: toSerializable(args.payload),
+                result: toSerializable(args.result),
+                error: toSerializable(args.error),
+                dryRun: args.dryRun ?? false,
+            },
+        });
+    }
+    recordSnapshot(snapshot) {
+        void this.send({
+            type: 'snapshot',
+            payload: {
+                timestamp: snapshot.timestamp ?? Date.now(),
+                pollCount: snapshot.pollCount,
+                equity: snapshot.equity,
+                marginUsed: snapshot.marginUsed,
+                marginUsedPct: snapshot.marginUsedPct,
+                positions: toSerializable(snapshot.positions),
+            },
+        });
+    }
+    recordOrderUpdate(payload, timestamp = Date.now()) {
+        void this.send({ type: 'order_update', payload: { timestamp, payload: toSerializable(payload) } });
+    }
+    recordFill(payload, timestamp = Date.now()) {
+        void this.send({ type: 'fill', payload: { timestamp, payload: toSerializable(payload) } });
+    }
+    recordUserEvent(payload, timestamp = Date.now()) {
+        void this.send({ type: 'user_event', payload: { timestamp, payload: toSerializable(payload) } });
+    }
+    recordStateChange(op, key, value, timestamp = Date.now()) {
+        void this.send({
+            type: 'state_change',
+            payload: {
+                timestamp,
+                op,
+                key,
+                value: toSerializable(value),
+            },
+        });
+    }
+    recordPublish(message, options, delivered, timestamp = Date.now()) {
+        void this.send({
+            type: 'publish',
+            payload: {
+                timestamp,
+                message,
+                options: toSerializable(options),
+                delivered,
+            },
+        });
+    }
+    recordError(stage, error, timestamp = Date.now()) {
+        void this.send({
+            type: 'error',
+            payload: {
+                timestamp,
+                stage,
+                error: toSerializable(error),
+            },
+        });
+    }
+    recordNote(kind, payload, timestamp = Date.now()) {
+        void this.send({
+            type: 'note',
+            payload: {
+                timestamp,
+                kind,
+                payload: toSerializable(payload),
+            },
+        });
+    }
+    recordMetric(name, value, tags, timestamp = Date.now()) {
+        void this.send({
+            type: 'metric',
+            payload: {
+                timestamp,
+                name,
+                value,
+                tags: toSerializable(tags ?? {}),
+            },
+        });
+    }
+    async stop(args) {
+        if (this.closed)
+            return;
+        try {
+            await this.send({
+                type: 'stop',
+                payload: {
+                    timestamp: args.timestamp ?? Date.now(),
+                    status: args.status,
+                    stopReason: args.stopReason,
+                    pollCount: args.pollCount,
+                    eventsEmitted: args.eventsEmitted,
+                },
+            }, true);
+        }
+        catch (error) {
+            internalWarn(this.automationId, `failed to flush stop audit message: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        this.closed = true;
+        if (this.lineReader) {
+            this.lineReader.close();
+            this.lineReader = null;
+        }
+        if (this.socket && !this.socket.destroyed) {
+            this.socket.end();
+        }
+        this.socket = null;
+        this.pendingQueue = [];
+        this.inFlight.clear();
+        this.ackWaiters.clear();
+    }
+}
+export function createAutomationAudit(options) {
+    try {
+        return new DaemonAuditSink(options.automationId, options);
+    }
+    catch (error) {
+        internalWarn(options.automationId, `audit disabled: ${error instanceof Error ? error.message : String(error)}`);
+        return new NoopAuditSink();
+    }
+}

package/dist/auto/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

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

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