@interactive-inc/claude-funnel 0.53.0 → 0.56.0

package/dist/funnel-doctor-CApCezTq.js

@@ -0,0 +1,82 @@
+//#region lib/services/doctor/funnel-doctor.ts
+/**
+* One-shot diagnose-and-fix entry point. The CLI exposes this as `fnl doctor`,
+* the MCP server exposes it as `fnl_doctor`. Both surfaces should prefer this
+* over chaining FunnelDiagnostics and FunnelRecovery by hand — the orchestration
+* logic (which fixes to attempt, in what order, when to escalate) lives here.
+*/
+var FunnelDoctor = class {
+	constructor(props) {
+		this.props = props;
+		Object.freeze(this);
+	}
+	async run(mode = "off") {
+		if (mode === "off") {
+			const after = await this.props.diagnostics.diagnoseAll();
+			return this.buildReport({
+				before: null,
+				after,
+				appliedActions: [],
+				fixFailed: false
+			});
+		}
+		const before = await this.props.diagnostics.diagnoseAll();
+		const applied = [];
+		let fixFailed = false;
+		if (before.channels.some((ch) => ch.diagnosis.status === "error" && !ch.gateway.running)) {
+			const result = await this.props.recovery.ensureGatewayRunning();
+			applied.push(...result.actions);
+			if (!result.ok) fixFailed = true;
+		}
+		if (before.channels.some((ch) => ch.listeners.some((l) => !l.alive))) {
+			const result = await this.props.recovery.restartAllDeadListeners();
+			applied.push(...result.actions);
+			if (!result.ok && result.actions.length === 0) fixFailed = true;
+		}
+		if (mode === "aggressive") {
+			if (applied.length === 0 || before.channels.some((ch) => ch.diagnosis.status === "error")) {
+				const result = await this.props.recovery.restartGateway();
+				applied.push(...result.actions);
+				if (!result.ok) fixFailed = true;
+			}
+		}
+		const after = await this.props.diagnostics.diagnoseAll();
+		return this.buildReport({
+			before,
+			after,
+			appliedActions: applied,
+			fixFailed
+		});
+	}
+	buildReport(input) {
+		const remaining = input.after.channels.filter((ch) => ch.diagnosis.status !== "ok").map((ch) => ({
+			channel: ch.channel,
+			diagnosis: ch.diagnosis
+		}));
+		const status = input.fixFailed ? "error" : remaining.length === 0 ? "ok" : "warn";
+		return {
+			status,
+			message: buildMessage({
+				mode: input.before === null ? "off" : "fix",
+				status,
+				appliedCount: input.appliedActions.length,
+				remainingCount: remaining.length
+			}),
+			before: input.before,
+			after: input.after,
+			appliedActions: input.appliedActions,
+			remainingIssues: remaining
+		};
+	}
+};
+const buildMessage = (input) => {
+	if (input.mode === "off") {
+		if (input.remainingCount === 0) return "all channels healthy";
+		return `${input.remainingCount} channel(s) need attention — run \`fnl doctor --fix\` to apply suggested fixes`;
+	}
+	if (input.status === "error") return "one or more fix steps failed — check fnl gateway logs";
+	if (input.status === "ok") return `applied ${input.appliedCount} fix(es), all channels healthy`;
+	return `applied ${input.appliedCount} fix(es), ${input.remainingCount} channel(s) still need attention`;
+};
+//#endregion
+export { FunnelDoctor as t };

package/dist/funnel-recovery-BUBsu7WX.d.ts

@@ -0,0 +1,101 @@
+import { t as ChannelConfig } from "./settings-schema-zhnMIa8I.js";
+
+//#region lib/services/recovery/funnel-recovery.d.ts
+/** Narrow gateway control — start / stop / restart and a probe. */
+type RecoveryGatewayControl = {
+  isRunning(): boolean;
+  start(options?: {
+    caffeinate?: boolean;
+  }): Promise<boolean>;
+  restart(options?: {
+    onlyIfRunning?: boolean;
+    caffeinate?: boolean;
+  }): Promise<{
+    ok: boolean;
+    wasRunning: boolean;
+    stopped: boolean;
+    started: boolean;
+  }>;
+};
+/** Narrow listeners client — restart per (channel, connector). */
+type RecoveryListenerControl = {
+  list(): Promise<{
+    state: "ok";
+    listeners: {
+      channelName: string;
+      name: string;
+      alive: boolean;
+    }[];
+  } | {
+    state: "offline";
+  } | {
+    state: "error";
+    reason: string;
+  }>;
+  restart(channelName: string, connectorName: string): Promise<{
+    state: "ok";
+  } | {
+    state: "offline";
+  } | {
+    state: "not-found";
+  } | {
+    state: "error";
+    reason: string;
+  }>;
+};
+/** Narrow channel registry. */
+type RecoveryChannelSource = {
+  list(): ChannelConfig[];
+};
+type Props = {
+  gateway: RecoveryGatewayControl;
+  listeners: RecoveryListenerControl;
+  channels: RecoveryChannelSource;
+};
+type RecoveryAction = {
+  kind: "gateway:started";
+} | {
+  kind: "gateway:already-running";
+} | {
+  kind: "gateway:restarted";
+} | {
+  kind: "listener:restarted";
+  channel: string;
+  connector: string;
+} | {
+  kind: "listener:skipped";
+  channel: string;
+  connector: string;
+  reason: string;
+};
+type RecoveryResult = {
+  ok: boolean;
+  actions: RecoveryAction[];
+  message: string;
+};
+/**
+ * Programmable self-healing primitives. The CLI / MCP / SDK normally drive
+ * these through FunnelDoctor (which decides which fixes to attempt and in
+ * what order). Exposed as a building block for hosts that want fine-grained
+ * control (custom policies, scripted maintenance).
+ *
+ * Every method returns a RecoveryResult so the caller can chain without
+ * throwing.
+ */
+declare class FunnelRecovery {
+  private readonly props;
+  constructor(props: Props);
+  /**
+   * Make sure the gateway daemon is running. Returns immediately if already up.
+   */
+  ensureGatewayRunning(): Promise<RecoveryResult>;
+  restartGateway(): Promise<RecoveryResult>;
+  restartListener(channelName: string, connectorName: string): Promise<RecoveryResult>;
+  /**
+   * Restart every dead listener across every channel. The gateway must already
+   * be running — call ensureGatewayRunning() first if unsure.
+   */
+  restartAllDeadListeners(): Promise<RecoveryResult>;
+}
+//#endregion
+export { RecoveryListenerControl as a, RecoveryGatewayControl as i, RecoveryAction as n, RecoveryResult as o, RecoveryChannelSource as r, FunnelRecovery as t };

package/dist/funnel-recovery-D9CxD5Zs.js

@@ -0,0 +1,134 @@
+//#region lib/services/recovery/funnel-recovery.ts
+/**
+* Programmable self-healing primitives. The CLI / MCP / SDK normally drive
+* these through FunnelDoctor (which decides which fixes to attempt and in
+* what order). Exposed as a building block for hosts that want fine-grained
+* control (custom policies, scripted maintenance).
+*
+* Every method returns a RecoveryResult so the caller can chain without
+* throwing.
+*/
+var FunnelRecovery = class {
+	constructor(props) {
+		this.props = props;
+		Object.freeze(this);
+	}
+	/**
+	* Make sure the gateway daemon is running. Returns immediately if already up.
+	*/
+	async ensureGatewayRunning() {
+		if (this.props.gateway.isRunning()) return {
+			ok: true,
+			actions: [{ kind: "gateway:already-running" }],
+			message: "gateway is already running"
+		};
+		if (!await this.props.gateway.start()) return {
+			ok: false,
+			actions: [],
+			message: "gateway failed to start — check `fnl gateway logs`"
+		};
+		return {
+			ok: true,
+			actions: [{ kind: "gateway:started" }],
+			message: "gateway started"
+		};
+	}
+	async restartGateway() {
+		if (!(await this.props.gateway.restart()).ok) return {
+			ok: false,
+			actions: [],
+			message: "gateway restart failed — check `fnl gateway logs`"
+		};
+		return {
+			ok: true,
+			actions: [{ kind: "gateway:restarted" }],
+			message: "gateway restarted"
+		};
+	}
+	async restartListener(channelName, connectorName) {
+		const op = await this.props.listeners.restart(channelName, connectorName);
+		if (op.state === "offline") return {
+			ok: false,
+			actions: [],
+			message: "gateway is not running — call ensureGatewayRunning() first"
+		};
+		if (op.state === "not-found") return {
+			ok: false,
+			actions: [{
+				kind: "listener:skipped",
+				channel: channelName,
+				connector: connectorName,
+				reason: "not-found"
+			}],
+			message: `listener not found: ${channelName}/${connectorName}`
+		};
+		if (op.state === "error") return {
+			ok: false,
+			actions: [{
+				kind: "listener:skipped",
+				channel: channelName,
+				connector: connectorName,
+				reason: op.reason
+			}],
+			message: `listener restart failed: ${op.reason}`
+		};
+		return {
+			ok: true,
+			actions: [{
+				kind: "listener:restarted",
+				channel: channelName,
+				connector: connectorName
+			}],
+			message: `restarted ${channelName}/${connectorName}`
+		};
+	}
+	/**
+	* Restart every dead listener across every channel. The gateway must already
+	* be running — call ensureGatewayRunning() first if unsure.
+	*/
+	async restartAllDeadListeners() {
+		const listed = await this.props.listeners.list();
+		if (listed.state === "offline") return {
+			ok: false,
+			actions: [],
+			message: "gateway is not running — call ensureGatewayRunning() first"
+		};
+		if (listed.state === "error") return {
+			ok: false,
+			actions: [],
+			message: `could not list listeners: ${listed.reason}`
+		};
+		const dead = listed.listeners.filter((l) => !l.alive);
+		if (dead.length === 0) return {
+			ok: true,
+			actions: [],
+			message: "no dead listeners found"
+		};
+		const actions = [];
+		for (const listener of dead) {
+			const op = await this.props.listeners.restart(listener.channelName, listener.name);
+			if (op.state === "ok") actions.push({
+				kind: "listener:restarted",
+				channel: listener.channelName,
+				connector: listener.name
+			});
+			else {
+				const reason = op.state === "error" ? op.reason : op.state;
+				actions.push({
+					kind: "listener:skipped",
+					channel: listener.channelName,
+					connector: listener.name,
+					reason
+				});
+			}
+		}
+		const restartedCount = actions.filter((a) => a.kind === "listener:restarted").length;
+		return {
+			ok: restartedCount > 0,
+			actions,
+			message: `restarted ${restartedCount}/${dead.length} dead listener(s)`
+		};
+	}
+};
+//#endregion
+export { FunnelRecovery as t };