@vaultgradient/pipequery-cli 0.3.2

package/src/tui/hooks/useSSE.ts

@@ -0,0 +1,95 @@
+import { useState, useEffect, useRef } from 'react';
+import http from 'node:http';
+
+interface SSEState {
+  results: Map<number, unknown>;
+  errors: Map<number, string>;
+  connected: boolean;
+}
+
+/**
+ * Hook that connects to the SSE endpoint for real-time dashboard updates.
+ * Falls back to polling if SSE connection fails.
+ */
+export function useSSE(serverUrl: string, queries: string[]) {
+  const [state, setState] = useState<SSEState>({
+    results: new Map(),
+    errors: new Map(),
+    connected: false,
+  });
+  const abortRef = useRef<AbortController | null>(null);
+
+  useEffect(() => {
+    if (queries.length === 0) return;
+
+    const abort = new AbortController();
+    abortRef.current = abort;
+
+    const url = new URL('/api/_control/sse', serverUrl);
+    url.searchParams.set('queries', JSON.stringify(queries));
+
+    // Use Node.js http for SSE (EventSource not available in Node)
+    const connect = () => {
+      const req = http.get(url.toString(), { signal: abort.signal }, (res) => {
+        if (res.statusCode !== 200) {
+          setState((s) => ({ ...s, connected: false }));
+          return;
+        }
+
+        setState((s) => ({ ...s, connected: true }));
+
+        let buffer = '';
+        res.on('data', (chunk: Buffer) => {
+          buffer += chunk.toString();
+          const lines = buffer.split('\n\n');
+          buffer = lines.pop() ?? '';
+
+          for (const block of lines) {
+            const dataLine = block.split('\n').find((l) => l.startsWith('data: '));
+            if (!dataLine) continue;
+
+            try {
+              const event = JSON.parse(dataLine.slice(6)) as { panelIndex: number; result?: unknown; error?: string };
+              setState((s) => {
+                const results = new Map(s.results);
+                const errors = new Map(s.errors);
+                if (event.error) {
+                  errors.set(event.panelIndex, event.error);
+                } else {
+                  results.set(event.panelIndex, event.result);
+                  errors.delete(event.panelIndex);
+                }
+                return { results, errors, connected: true };
+              });
+            } catch {
+              // Ignore parse errors (heartbeats etc.)
+            }
+          }
+        });
+
+        res.on('end', () => {
+          setState((s) => ({ ...s, connected: false }));
+          // Reconnect after 2s
+          if (!abort.signal.aborted) {
+            setTimeout(connect, 2000);
+          }
+        });
+      });
+
+      req.on('error', () => {
+        setState((s) => ({ ...s, connected: false }));
+        if (!abort.signal.aborted) {
+          setTimeout(connect, 2000);
+        }
+      });
+    };
+
+    connect();
+
+    return () => {
+      abort.abort();
+    };
+  }, [serverUrl, queries.join(',')]);
+
+  return state;
+}

package/src/tui/hooks/useServerData.ts

@@ -0,0 +1,37 @@
+import { useState, useEffect, useCallback } from 'react';
+
+interface PanelData {
+  data: unknown;
+  loading: boolean;
+  error?: string;
+}
+
+export function useServerData(serverUrl: string, query: string, refreshMs: number) {
+  const [state, setState] = useState<PanelData>({ data: null, loading: true });
+
+  const fetchData = useCallback(async () => {
+    try {
+      const res = await fetch(`${serverUrl}/api/_control/query`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query }),
+      });
+      const json = await res.json() as { ok: boolean; result?: unknown; error?: string };
+      if (json.ok) {
+        setState({ data: json.result, loading: false });
+      } else {
+        setState({ data: null, loading: false, error: json.error });
+      }
+    } catch (err) {
+      setState({ data: null, loading: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  }, [serverUrl, query]);
+
+  useEffect(() => {
+    fetchData();
+    const timer = setInterval(fetchData, refreshMs);
+    return () => clearInterval(timer);
+  }, [fetchData, refreshMs]);
+
+  return { ...state, refresh: fetchData };
+}

package/src/utils/banner.ts

@@ -0,0 +1,70 @@
+import chalk from 'chalk';
+
+const LOGO = [
+  '  ██████╗  ██╗ ██████╗  ███████╗  ██████╗  ██╗   ██╗ ███████╗ ██████╗  ██╗   ██╗',
+  '  ██╔══██╗ ██║ ██╔══██╗ ██╔════╝ ██╔═══██╗ ██║   ██║ ██╔════╝ ██╔══██╗ ╚██╗ ██╔╝',
+  '  ██████╔╝ ██║ ██████╔╝ █████╗   ██║   ██║ ██║   ██║ █████╗   ██████╔╝  ╚████╔╝ ',
+  '  ██╔═══╝  ██║ ██╔═══╝  ██╔══╝   ██║▄▄ ██║ ██║   ██║ ██╔══╝   ██╔══██╗   ╚██╔╝  ',
+  '  ██║      ██║ ██║      ███████╗  ╚██████╔╝ ╚██████╔╝ ███████╗ ██║  ██║    ██║   ',
+  '  ╚═╝      ╚═╝ ╚═╝      ╚══════╝   ╚══▀▀═╝   ╚═════╝  ╚══════╝ ╚═╝  ╚═╝    ╚═╝   ',
+];
+
+// Gradient from cyan → blue → magenta
+const GRADIENT_COLORS = [
+  '#06b6d4', // cyan
+  '#0891b2',
+  '#0e7490',
+  '#2563eb', // blue
+  '#4f46e5',
+  '#7c3aed', // violet
+];
+
+function applyGradient(line: string, colorIndex: number): string {
+  const color = GRADIENT_COLORS[colorIndex % GRADIENT_COLORS.length];
+  return chalk.hex(color)(line);
+}
+
+export function printBanner() {
+  console.log();
+  LOGO.forEach((line, i) => {
+    console.log(applyGradient(line, i));
+  });
+  console.log();
+  console.log(chalk.dim(`  v0.1.0 — data sources, aggregations, APIs, and terminal dashboards`));
+  console.log();
+}
+
+export function printCompactBanner() {
+  console.log();
+  console.log(
+    chalk.hex('#06b6d4').bold('  ╔═╗ ╦ ╔═╗ ╔═╗ ╔═╗ ╦ ╦ ╔═╗ ╦═╗ ╦ ╦'),
+  );
+  console.log(
+    chalk.hex('#4f46e5').bold('  ╠═╝ ║ ╠═╝ ║╣  ║═╬╗║ ║ ║╣  ╠╦╝ ╚╦╝'),
+  );
+  console.log(
+    chalk.hex('#7c3aed').bold('  ╩   ╩ ╩   ╚═╝ ╚═╝╚╚═╝ ╚═╝ ╩╚═  ╩ '),
+  );
+  console.log();
+}
+
+export function printServerStartup(opts: {
+  url: string;
+  sourceCount: number;
+  endpointCount: number;
+}) {
+  const { url, sourceCount, endpointCount } = opts;
+
+  console.log(chalk.hex('#06b6d4').bold('  ● Server running'));
+  console.log();
+  console.log(`  ${chalk.dim('URL')}        ${chalk.white.bold(url)}`);
+  console.log(`  ${chalk.dim('Sources')}    ${chalk.white(String(sourceCount))} loaded`);
+  console.log(`  ${chalk.dim('Endpoints')}  ${chalk.white(String(endpointCount))} registered`);
+  console.log();
+  console.log(chalk.dim('  Press Ctrl+C to stop'));
+  console.log();
+}
+
+export function printSection(title: string) {
+  console.log(chalk.hex('#4f46e5').bold(`  ${title}`));
+}

package/src/utils/logger.ts

@@ -0,0 +1,10 @@
+import chalk from 'chalk';
+
+export const log = {
+  info: (msg: string) => console.log(chalk.hex('#06b6d4')('  ●'), msg),
+  success: (msg: string) => console.log(chalk.hex('#10b981')('  ✓'), msg),
+  warn: (msg: string) => console.log(chalk.hex('#f59e0b')('  ⚠'), msg),
+  error: (msg: string) => console.error(chalk.hex('#ef4444')('  ✗'), msg),
+  dim: (msg: string) => console.log(chalk.dim(`    ${msg}`)),
+  step: (msg: string) => console.log(chalk.hex('#4f46e5')('  →'), msg),
+};

package/src/utils/parseDuration.ts

@@ -0,0 +1,12 @@
+const UNITS: Record<string, number> = {
+  ms: 1,
+  s: 1000,
+  m: 60_000,
+  h: 3_600_000,
+};
+
+export function parseDuration(input: string): number {
+  const match = input.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)$/);
+  if (!match) throw new Error(`Invalid duration: "${input}". Use format like "30s", "5m", "1h".`);
+  return parseFloat(match[1]) * UNITS[match[2]];
+}

package/src/utils/server-discovery.ts

@@ -0,0 +1,43 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { findConfigPath } from '../config/loader.js';
+import { readYaml } from './yaml.js';
+
+interface ServerInfo {
+  url: string;
+  pid: number;
+}
+
+export async function getServerUrl(): Promise<string> {
+  const cwd = process.cwd();
+
+  // 1. Check .pipequery/server.json for running local server
+  const serverJsonPath = resolve(cwd, '.pipequery', 'server.json');
+  if (existsSync(serverJsonPath)) {
+    try {
+      const info = JSON.parse(await readFile(serverJsonPath, 'utf-8')) as ServerInfo;
+      // Verify the server is actually running
+      const res = await fetch(`${info.url}/health`).catch(() => null);
+      if (res?.ok) return info.url;
+    } catch {
+      // Fall through
+    }
+  }
+
+  // 2. Check config for remote URL
+  const configPath = findConfigPath(cwd);
+  if (configPath) {
+    try {
+      const config = await readYaml<{ remote?: { url: string } }>(configPath);
+      if (config.remote?.url) {
+        const res = await fetch(`${config.remote.url}/health`).catch(() => null);
+        if (res?.ok) return config.remote.url;
+      }
+    } catch {
+      // Fall through
+    }
+  }
+
+  throw new Error('No running PipeQuery server found. Start one with: pq serve');
+}

package/src/utils/sync-output.ts

@@ -0,0 +1,62 @@
+/**
+ * Patches process.stdout.write to use Synchronized Output protocol.
+ * This prevents flickering in terminals that support it (iTerm2, kitty, etc).
+ *
+ * The protocol wraps each write in Begin/End markers so the terminal
+ * buffers the output and paints it all at once instead of progressively.
+ *
+ * See: https://gist.github.com/christianparpart/d8a62cc1ab659194571cd72825afb6e0
+ */
+
+const BEGIN_SYNC = '\x1B[?2026h';
+const END_SYNC = '\x1B[?2026l';
+
+let patched = false;
+let pendingTimer: ReturnType<typeof setTimeout> | null = null;
+let inSync = false;
+
+export function enableSyncOutput() {
+  if (patched) return;
+  patched = true;
+
+  const originalWrite = process.stdout.write.bind(process.stdout);
+
+  process.stdout.write = function (
+    chunk: string | Uint8Array,
+    encodingOrCallback?: BufferEncoding | ((err?: Error | null) => void),
+    callback?: (err?: Error | null) => void,
+  ): boolean {
+    // Start a synchronized update block
+    if (!inSync) {
+      inSync = true;
+      originalWrite(BEGIN_SYNC);
+    }
+
+    // Clear any pending end-sync timer
+    if (pendingTimer) {
+      clearTimeout(pendingTimer);
+    }
+
+    // Schedule ending the sync block after a microtask
+    // This batches all writes in the same tick
+    pendingTimer = setTimeout(() => {
+      originalWrite(END_SYNC);
+      inSync = false;
+      pendingTimer = null;
+    }, 0);
+
+    return originalWrite(chunk, encodingOrCallback as BufferEncoding, callback);
+  } as typeof process.stdout.write;
+}
+
+export function disableSyncOutput() {
+  // Nothing needed — process exits or we restore stdout
+  if (inSync) {
+    process.stdout.write('\x1B[?2026l');
+    inSync = false;
+  }
+  if (pendingTimer) {
+    clearTimeout(pendingTimer);
+    pendingTimer = null;
+  }
+}

package/src/utils/yaml.ts

@@ -0,0 +1,12 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import YAML from 'yaml';
+
+export async function readYaml<T>(path: string): Promise<T> {
+  const content = await readFile(path, 'utf-8');
+  return YAML.parse(content) as T;
+}
+
+export async function writeYaml(path: string, data: unknown): Promise<void> {
+  const content = YAML.stringify(data, { lineWidth: 120 });
+  await writeFile(path, content, 'utf-8');
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "declaration": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  target: 'node18',
+  platform: 'node',
+  clean: true,
+  splitting: false,
+  banner: {
+    js: '#!/usr/bin/env node',
+  },
+});