openbroker 1.0.75 → 1.0.80

package/scripts/auto/audit.ts

@@ -0,0 +1,552 @@
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import { once } from 'events';
+import net, { type Socket } 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 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>;
+}
+
+type AuditMessageType =
+  | 'init'
+  | 'log'
+  | 'event'
+  | 'action'
+  | 'snapshot'
+  | 'order_update'
+  | 'fill'
+  | 'user_event'
+  | 'state_change'
+  | 'publish'
+  | 'error'
+  | 'note'
+  | 'metric'
+  | 'stop';
+
+type AuditPayload = Record<string, unknown>;
+
+type AuditMessage = {
+  messageId: string;
+  type: AuditMessageType;
+  payload: AuditPayload;
+};
+
+type AuditResponse = {
+  messageId: string;
+  ok: boolean;
+  error?: string;
+};
+
+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 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: string, message: string): void {
+  console.error(`[auto:${automationId}:audit] ${message}`);
+}
+
+export function toSerializable<T = unknown>(value: T): T {
+  const seen = new WeakSet<object>();
+  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 as T;
+  }
+  return JSON.parse(encoded) as T;
+}
+
+class NoopAuditSink implements AutomationAuditSink {
+  readonly runId = randomUUID();
+  readonly dbPath = AUDIT_DB_PATH;
+  recordLog(): void {}
+  recordEvent(): void {}
+  recordAction(): void {}
+  recordSnapshot(): void {}
+  recordOrderUpdate(): void {}
+  recordFill(): void {}
+  recordUserEvent(): void {}
+  recordStateChange(): void {}
+  recordPublish(): void {}
+  recordError(): void {}
+  recordNote(): void {}
+  recordMetric(): void {}
+  async stop(): Promise<void> {}
+}
+
+class DaemonAuditSink implements AutomationAuditSink {
+  readonly runId = randomUUID();
+  readonly dbPath = AUDIT_DB_PATH;
+
+  private socketPath = AUDIT_SOCKET_PATH;
+  private socket: Socket | null = null;
+  private lineReader: readline.Interface | null = null;
+  private connectPromise: Promise<void> | null = null;
+  private flushPromise: Promise<void> | null = null;
+  private closed = false;
+  private daemonSpawnedAt = 0;
+  private pendingQueue: AuditMessage[] = [];
+  private inFlight = new Map<string, AuditMessage>();
+  private ackWaiters = new Map<string, { resolve: () => void; reject: (error: Error) => void }>();
+
+  constructor(private readonly automationId: string, options: AuditStartOptions) {
+    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(),
+      },
+    });
+  }
+
+  private handleSocketClose(): void {
+    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();
+    }
+  }
+
+  private handleResponse(line: string): void {
+    let response: AuditResponse;
+    try {
+      response = JSON.parse(line) as AuditResponse;
+    } 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'));
+    }
+  }
+
+  private async openConnection(): Promise<void> {
+    const socket = net.createConnection(this.socketPath);
+
+    await new Promise<void>((resolve, reject) => {
+      let settled = false;
+
+      const onConnect = () => {
+        if (settled) return;
+        settled = true;
+        socket.off('error', onError);
+        resolve();
+      };
+
+      const onError = (error: 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;
+  }
+
+  private async spawnDaemon(): Promise<void> {
+    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();
+  }
+
+  private async ensureConnected(): Promise<void> {
+    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: Error | null = 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;
+  }
+
+  private enqueue(message: { type: AuditMessageType; payload: AuditPayload }): AuditMessage {
+    const payload = message.type === 'init'
+      ? message.payload
+      : { runId: this.runId, ...message.payload };
+
+    const wire: AuditMessage = {
+      messageId: randomUUID(),
+      type: message.type,
+      payload,
+    };
+    this.pendingQueue.push(wire);
+    void this.ensureConnected();
+    if (this.socket && !this.socket.destroyed) {
+      void this.flushQueue();
+    }
+    return wire;
+  }
+
+  private async flushQueue(): Promise<void> {
+    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;
+  }
+
+  private send(message: { type: AuditMessageType; payload: AuditPayload }, waitForAck = false): Promise<void> {
+    if (this.closed) return Promise.resolve();
+
+    const wire = this.enqueue(message);
+    if (!waitForAck) return Promise.resolve();
+
+    return new Promise<void>((resolve, reject) => {
+      this.ackWaiters.set(wire.messageId, { resolve, reject });
+      void this.flushQueue();
+    });
+  }
+
+  recordLog(level: 'info' | 'warn' | 'error' | 'debug', message: string, timestamp: number = Date.now()): void {
+    void this.send({ type: 'log', payload: { timestamp, level, message } });
+  }
+
+  recordEvent(eventType: string, source: 'poll' | 'ws' | 'manual', payload: unknown, timestamp: number = Date.now()): void {
+    void this.send({ type: 'event', payload: { timestamp, eventType, source, payload: toSerializable(payload) } });
+  }
+
+  recordAction(args: {
+    actionId?: string;
+    phase: 'request' | 'response' | 'error';
+    method: string;
+    payload?: unknown;
+    result?: unknown;
+    error?: unknown;
+    dryRun?: boolean;
+    timestamp?: number;
+  }): void {
+    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: {
+    pollCount: number;
+    equity: number;
+    marginUsed: number;
+    marginUsedPct: number;
+    positions: unknown[];
+    timestamp?: number;
+  }): void {
+    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: unknown, timestamp: number = Date.now()): void {
+    void this.send({ type: 'order_update', payload: { timestamp, payload: toSerializable(payload) } });
+  }
+
+  recordFill(payload: unknown, timestamp: number = Date.now()): void {
+    void this.send({ type: 'fill', payload: { timestamp, payload: toSerializable(payload) } });
+  }
+
+  recordUserEvent(payload: unknown, timestamp: number = Date.now()): void {
+    void this.send({ type: 'user_event', payload: { timestamp, payload: toSerializable(payload) } });
+  }
+
+  recordStateChange(op: 'set' | 'delete' | 'clear', key: string | null, value?: unknown, timestamp: number = Date.now()): void {
+    void this.send({
+      type: 'state_change',
+      payload: {
+        timestamp,
+        op,
+        key,
+        value: toSerializable(value),
+      },
+    });
+  }
+
+  recordPublish(message: string, options: unknown, delivered: boolean, timestamp: number = Date.now()): void {
+    void this.send({
+      type: 'publish',
+      payload: {
+        timestamp,
+        message,
+        options: toSerializable(options),
+        delivered,
+      },
+    });
+  }
+
+  recordError(stage: string, error: unknown, timestamp: number = Date.now()): void {
+    void this.send({
+      type: 'error',
+      payload: {
+        timestamp,
+        stage,
+        error: toSerializable(error),
+      },
+    });
+  }
+
+  recordNote(kind: string, payload?: unknown, timestamp: number = Date.now()): void {
+    void this.send({
+      type: 'note',
+      payload: {
+        timestamp,
+        kind,
+        payload: toSerializable(payload),
+      },
+    });
+  }
+
+  recordMetric(name: string, value: number, tags?: Record<string, unknown>, timestamp: number = Date.now()): void {
+    void this.send({
+      type: 'metric',
+      payload: {
+        timestamp,
+        name,
+        value,
+        tags: toSerializable(tags ?? {}),
+      },
+    });
+  }
+
+  async stop(args: {
+    status: 'stopped' | 'error';
+    stopReason: string;
+    pollCount: number;
+    eventsEmitted: number;
+    timestamp?: number;
+  }): Promise<void> {
+    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: AuditStartOptions): AutomationAuditSink {
+  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/scripts/auto/cli.ts

@@ -1,10 +1,16 @@
 // CLI entry point for `openbroker auto` commands
 
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import path from 'path';
 import { parseArgs } from '../core/utils.js';
 import { resolveScriptPath, resolveExamplePath, listAutomations, listExamples, loadExampleConfigs, ensureAutomationsDir } from './loader.js';
 import { startAutomation, getRunningAutomations, getRegisteredAutomations } from './runtime.js';
 import { unregisterAutomation, cleanRegistry } from './registry.js';
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 function printUsage() {
   console.log(`
 OpenBroker Automations — event-driven trading scripts
@@ -12,6 +18,7 @@ OpenBroker Automations — event-driven trading scripts
 Usage:
   openbroker auto run <script> [options]    Run an automation script
   openbroker auto run --example <name>      Run a bundled example automation
+  openbroker auto report <id>               Read the local audit report for an automation
   openbroker auto examples                  List bundled example automations
   openbroker auto stop <id>                 Unregister an automation (won't restart)
   openbroker auto list                      List available automations
@@ -45,6 +52,7 @@ Examples:
   openbroker auto run --example dca --set coin=BTC --set amount=50 --dry
   openbroker auto run --example grid --set coin=ETH --set lower=3000 --set upper=4000
   openbroker auto run my-strategy --dry
+  openbroker auto report hype-mm-v2-live-r4
   openbroker auto examples
 `);
 }
@@ -270,6 +278,27 @@ function cleanCommand() {
   console.log('Cleaned stale entries from registry');
 }
 
+function reportCommand(rawArgs: string[]) {
+  const scriptPath = path.join(__dirname, 'report.ts');
+  const result = spawnSync(
+    process.execPath,
+    ['--experimental-sqlite', '--no-warnings', '--import', 'tsx', scriptPath, ...rawArgs],
+    {
+      stdio: 'inherit',
+      cwd: path.resolve(__dirname, '../..'),
+      env: { ...process.env },
+    },
+  );
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (typeof result.status === 'number' && result.status !== 0) {
+    process.exit(result.status);
+  }
+}
+
 async function main() {
   const rawArgs = process.argv.slice(2);
 
@@ -322,6 +351,9 @@ async function main() {
     case 'clean':
       cleanCommand();
       break;
+    case 'report':
+      reportCommand(restArgs);
+      break;
     default:
       console.error(`Unknown subcommand: ${subcommand}`);
       console.log('Run "openbroker auto --help" for usage');