@interactive-inc/claude-funnel 0.53.0 → 0.56.0

package/dist/funnel-diagnostics-qWy5tPSq.d.ts

@@ -0,0 +1,176 @@
+import { t as ChannelConfig } from "./settings-schema-zhnMIa8I.js";
+
+//#region lib/gateway/diagnostic-log/diagnostic-sql-reader.d.ts
+type Props$1 = {
+  /** SQLite file holding the raw (pre-filter) table. */rawPath: string; /** SQLite file holding the processed (verdict) table. */
+  processedPath: string; /** SQLite file holding the connection (lifecycle) table. */
+  connectionPath: string;
+};
+type Row = Record<string, unknown>;
+/**
+ * Read-only SQL surface over the three diagnostic tables, for Claude to query
+ * the log with arbitrary `SELECT`s. It opens all files read-only and exposes
+ * three views — `raw`, `processed`, `connection` — that hide the storage
+ * details (the physical table is `leuco_log` and each row's columns live
+ * inside a JSON `event` blob): the views surface the columns as plain fields,
+ * with `payload` already pulled out of the nested JSON.
+ *
+ * The tables are separate files. `raw` and `processed` share an `event_id`,
+ * so a `JOIN` answers "the event arrived, but what verdict did it get?";
+ * `connection` answers the other half — "did the listener ever connect at
+ * all?". Writes are impossible: the connection is read-only and `query`
+ * rejects anything but a single `SELECT`.
+ */
+declare class ConnectorDiagnosticSqlReader {
+  private readonly db;
+  constructor(props: Props$1);
+  /**
+   * Run one read-only `SELECT` and return the rows. Returns an `Error` (rather
+   * than throwing) for a non-SELECT statement or a SQL error, so the caller
+   * can surface the message without a stack trace.
+   */
+  query(sql: string, params?: (string | number | null)[]): Row[] | Error;
+  close(): void;
+}
+//#endregion
+//#region lib/services/diagnostics/diagnostic-event.d.ts
+type DiagnosticEvent = {
+  seq: number | null;
+  ts: number | null;
+  type: string;
+  outcome: string;
+  eventId: string | null;
+  payload: string | null;
+  payloadParsed: Record<string, unknown> | null;
+  preview: string | null;
+};
+type DiagnosticConnectionError = {
+  seq: number | null;
+  ts: number | null;
+  type: string;
+  status: string;
+  detail: string | null;
+};
+declare const previewOf: (payload: unknown) => string | null;
+declare const toDiagnosticEvent: (row: Record<string, unknown>) => DiagnosticEvent;
+declare const toDiagnosticConnectionError: (row: Record<string, unknown>) => DiagnosticConnectionError;
+declare const queryRows: (reader: ConnectorDiagnosticSqlReader, sql: string, params: (string | number | null)[]) => Record<string, unknown>[] | Error;
+//#endregion
+//#region lib/services/diagnostics/funnel-diagnostics.d.ts
+/** Narrow channel registry — only `list()` is needed. */
+type DiagnosticsChannelSource = {
+  list(): ChannelConfig[];
+};
+/** Narrow gateway probe — only the daemon status is needed. */
+type DiagnosticsGatewayProbe = {
+  getStatus(): {
+    running: boolean;
+    pid: number | null;
+    port: number;
+  };
+};
+/** Narrow token reader — diagnostics only needs to read the token, never to mint or rotate it. */
+type DiagnosticsTokenReader = {
+  read(): string | null;
+};
+/** Narrow publisher used only for replay. */
+type DiagnosticsPublisher = {
+  publish(channelName: string, request: {
+    content: string;
+    connector?: string;
+  }): Promise<{
+    state: "ok";
+    offset: number;
+  } | {
+    state: "offline";
+  } | {
+    state: "error";
+    reason: string;
+  }>;
+};
+type Props = {
+  gateway: DiagnosticsGatewayProbe;
+  gatewayToken: DiagnosticsTokenReader;
+  channels: DiagnosticsChannelSource;
+  publisher: DiagnosticsPublisher;
+  tmpDir: string;
+};
+type DiagnosisStatus = "ok" | "warn" | "error";
+type ChannelDiagnosis = {
+  channel: string;
+  channelId: string;
+  gateway: {
+    running: boolean;
+    pid: number | null;
+    port: number | null;
+    uptimeMs: number | null;
+  };
+  listeners: Array<{
+    name: string;
+    type: string;
+    alive: boolean;
+    events: number;
+    errors: number;
+    lastEventAt: string | null;
+  }>;
+  claudeClients: number;
+  recentEvents: DiagnosticEvent[];
+  connectionErrors: DiagnosticConnectionError[];
+  diagnosis: {
+    status: DiagnosisStatus;
+    message: string;
+    nextActions: string[];
+    rootCause: string | null;
+  };
+};
+type DiagnoseAllReport = {
+  summary: {
+    total: number;
+    ok: number;
+    warn: number;
+    error: number;
+    criticalChannels: string[];
+    warnChannels: string[];
+    suggestedActions: string[];
+  };
+  channels: ChannelDiagnosis[];
+};
+type ReplayResult = {
+  state: "ok";
+  seq: number | null;
+  offset: number;
+  preview: string | null;
+} | {
+  state: "offline";
+} | {
+  state: "error";
+  reason: string;
+} | {
+  state: "not-found";
+};
+type StorePaths = {
+  rawPath: string;
+  processedPath: string;
+  connectionPath: string;
+};
+/**
+ * Programmable diagnostics surface — used by both the CLI (fnl debug …) and
+ * the MCP tools (fnl_debug, fnl_recent_events, …). Pure read-side, no
+ * mutation; pair with FunnelRecovery for self-healing actions.
+ */
+declare class FunnelDiagnostics {
+  private readonly props;
+  constructor(props: Props);
+  diagnose(channelName?: string): Promise<ChannelDiagnosis | null>;
+  diagnoseAll(): Promise<DiagnoseAllReport>;
+  recentEvents(channelName: string | null, limit?: number): Promise<DiagnosticEvent[]>;
+  droppedEvents(channelName: string | null, limit?: number): Promise<DiagnosticEvent[]>;
+  connectionErrors(channelName: string | null, limit?: number): Promise<DiagnosticConnectionError[]>;
+  replay(channelName: string, seq?: number): Promise<ReplayResult>;
+  resolveStore(): StorePaths | null;
+  private resolveChannelId;
+  private fetchGatewayStatus;
+  private buildChannelDiagnosis;
+}
+//#endregion
+export { DiagnosticsGatewayProbe as a, FunnelDiagnostics as c, DiagnosticEvent as d, previewOf as f, ConnectorDiagnosticSqlReader as g, toDiagnosticEvent as h, DiagnosticsChannelSource as i, ReplayResult as l, toDiagnosticConnectionError as m, DiagnoseAllReport as n, DiagnosticsPublisher as o, queryRows as p, DiagnosisStatus as r, DiagnosticsTokenReader as s, ChannelDiagnosis as t, DiagnosticConnectionError as u };

package/dist/funnel-docs-dXPokzr5.d.ts

@@ -0,0 +1,18 @@
+//#region lib/services/docs/funnel-docs.d.ts
+type DocsTopicListing = {
+  name: string;
+  summary: string;
+};
+/**
+ * Programmable docs surface — used by both the CLI (fnl docs <topic>) and the
+ * MCP / SDK consumers. Docs are embedded into the build so a Claude session
+ * can self-discover funnel's vocabulary without external network access.
+ */
+declare class FunnelDocs {
+  constructor();
+  list(): DocsTopicListing[];
+  get(topic: string): string | null;
+  topics(): string[];
+}
+//#endregion
+export { FunnelDocs as n, DocsTopicListing as t };