@interactive-inc/claude-funnel 0.8.1 → 0.10.1

package/dist/gh-connector-schema-2ml29MBC.js

@@ -0,0 +1,218 @@
+import { t as FunnelConnectorAdapter } from "./connector-adapter-D5Utumgz.js";
+import { r as FunnelConnectorListener, t as NodeFunnelLogger } from "./node-logger-DQz_BGOD.js";
+import { z } from "zod";
+//#region lib/engine/process/process-runner.ts
+/**
+* Process boundary covering one-shot runs, sync runs, foreground attach, and
+* detached background spawns. Default is NodeFunnelProcessRunner (Bun.spawn);
+* MemoryFunnelProcessRunner records calls and lets tests stub responses.
+*/
+var FunnelProcessRunner = class {};
+//#endregion
+//#region lib/engine/process/node-process-runner.ts
+const toEnv = (env) => {
+	if (!env) return void 0;
+	const merged = {};
+	for (const [key, value] of Object.entries(process.env)) if (typeof value === "string") merged[key] = value;
+	for (const [key, value] of Object.entries(env)) merged[key] = value;
+	return merged;
+};
+var NodeFunnelProcessRunner = class extends FunnelProcessRunner {
+	constructor() {
+		super();
+		Object.freeze(this);
+	}
+	runSync(command) {
+		const result = Bun.spawnSync(command, {
+			stdout: "pipe",
+			stderr: "pipe"
+		});
+		return {
+			exitCode: result.exitCode ?? 0,
+			stdout: result.stdout.toString(),
+			stderr: result.stderr.toString()
+		};
+	}
+	async run(command, options = {}) {
+		const proc = Bun.spawn(command, {
+			cwd: options.cwd,
+			env: toEnv(options.env),
+			stdin: options.input !== void 0 ? "pipe" : "ignore",
+			stdout: "pipe",
+			stderr: "pipe"
+		});
+		if (options.input !== void 0 && proc.stdin) {
+			proc.stdin.write(options.input);
+			proc.stdin.end();
+		}
+		return {
+			exitCode: await proc.exited,
+			stdout: await new Response(proc.stdout).text(),
+			stderr: await new Response(proc.stderr).text()
+		};
+	}
+	async attach(command, options = {}) {
+		return await Bun.spawn(command, {
+			cwd: options.cwd,
+			env: toEnv(options.env),
+			stdio: [
+				"inherit",
+				"inherit",
+				"inherit"
+			]
+		}).exited;
+	}
+	detach(command, options = {}) {
+		Bun.spawn(command, {
+			env: toEnv(options.env),
+			stdio: [
+				"ignore",
+				"ignore",
+				"ignore"
+			]
+		}).unref();
+	}
+	kill(pid, signal = "SIGTERM") {
+		try {
+			process.kill(pid, signal);
+		} catch {}
+	}
+};
+//#endregion
+//#region lib/connectors/gh-adapter.ts
+const defaultProcess$1 = new NodeFunnelProcessRunner();
+var FunnelGhAdapter = class extends FunnelConnectorAdapter {
+	process;
+	constructor(deps = {}) {
+		super();
+		this.process = deps.process ?? defaultProcess$1;
+		Object.freeze(this);
+	}
+	async call(input) {
+		const args = ["api", input.path];
+		if (input.method && input.method.toLowerCase() !== "get") args.push("-X", input.method.toUpperCase());
+		const hasBody = input.body && typeof input.body === "object" && Object.keys(input.body).length > 0;
+		if (hasBody) args.push("--input", "-");
+		const result = await this.process.run(["gh", ...args], { input: hasBody ? JSON.stringify(input.body) : void 0 });
+		if (result.exitCode !== 0) throw new Error(`gh api failed: ${result.stderr.trim() || result.stdout.trim()}`);
+		try {
+			return JSON.parse(result.stdout);
+		} catch {
+			return result.stdout;
+		}
+	}
+};
+//#endregion
+//#region lib/connectors/gh-listener.ts
+const ghNotificationSchema = z.object({
+	id: z.string(),
+	reason: z.string(),
+	subject: z.object({
+		type: z.string(),
+		url: z.string(),
+		title: z.string()
+	}),
+	repository: z.object({ full_name: z.string() }),
+	updated_at: z.string()
+});
+const ghNotificationsSchema = z.array(ghNotificationSchema);
+const defaultProcess = new NodeFunnelProcessRunner();
+const defaultLogger = new NodeFunnelLogger();
+const MAX_SEEN = 1e4;
+const KEEP_SEEN = 5e3;
+var FunnelGhListener = class extends FunnelConnectorListener {
+	config;
+	process;
+	logger;
+	now;
+	seen = /* @__PURE__ */ new Map();
+	bootstrapped = false;
+	since;
+	timer = null;
+	constructor(deps) {
+		super();
+		this.config = deps.config;
+		this.process = deps.process ?? defaultProcess;
+		this.logger = deps.logger ?? defaultLogger;
+		this.now = deps.now ?? (() => /* @__PURE__ */ new Date());
+		this.since = this.now().toISOString();
+	}
+	async start(notify) {
+		await this.pollOnce(notify);
+		const interval = this.config.pollInterval ?? 60;
+		this.timer = setInterval(() => void this.pollOnce(notify), interval * 1e3);
+		this.timer.unref();
+	}
+	async stop() {
+		if (!this.timer) return;
+		clearInterval(this.timer);
+		this.timer = null;
+	}
+	isAlive() {
+		return this.timer !== null;
+	}
+	async pollOnce(notify) {
+		const nextSince = this.now().toISOString();
+		const params = new URLSearchParams({
+			since: this.since,
+			all: "false"
+		});
+		try {
+			const result = await this.process.run([
+				"gh",
+				"api",
+				`/notifications?${params}`
+			]);
+			if (result.exitCode !== 0) {
+				this.logger.error("gh poll failed", { stderr: result.stderr });
+				return;
+			}
+			const parsed = ghNotificationsSchema.safeParse(JSON.parse(result.stdout));
+			if (!parsed.success) {
+				this.logger.warn("gh response did not match schema", { error: parsed.error.message });
+				return;
+			}
+			const items = parsed.data;
+			for (const item of items) {
+				if (this.seen.get(item.id) === item.updated_at) continue;
+				this.seen.set(item.id, item.updated_at);
+				if (!this.bootstrapped) continue;
+				const meta = {
+					event_type: "gh",
+					reason: item.reason,
+					subject_type: item.subject.type,
+					subject_url: item.subject.url,
+					repository: item.repository.full_name,
+					thread_id: item.id,
+					updated_at: item.updated_at
+				};
+				await notify(JSON.stringify(item), meta);
+			}
+			if (this.seen.size > MAX_SEEN) {
+				const toDrop = this.seen.size - KEEP_SEEN;
+				let dropped = 0;
+				for (const key of this.seen.keys()) {
+					if (dropped >= toDrop) break;
+					this.seen.delete(key);
+					dropped++;
+				}
+			}
+			this.since = nextSince;
+			this.bootstrapped = true;
+		} catch (error) {
+			this.logger.error("gh poll error", { error: error instanceof Error ? error.message : String(error) });
+		}
+	}
+};
+//#endregion
+//#region lib/connectors/gh-connector-schema.ts
+const ghConnectorSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.literal("gh"),
+	pollInterval: z.number().int().positive().optional(),
+	createdAt: z.string().datetime().optional(),
+	updatedAt: z.string().datetime().optional()
+});
+//#endregion
+export { FunnelProcessRunner as a, NodeFunnelProcessRunner as i, FunnelGhListener as n, FunnelGhAdapter as r, ghConnectorSchema as t };

package/dist/gh-connector-schema-BZFAS-p-.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+
+//#region lib/engine/process/process-runner.d.ts
+type RunOptions = {
+  cwd?: string;
+  env?: Record<string, string>;
+  input?: string;
+};
+type RunResult = {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+};
+type AttachOptions = {
+  cwd?: string;
+  env?: Record<string, string>;
+};
+type DetachOptions = {
+  env?: Record<string, string>;
+};
+/**
+ * Process boundary covering one-shot runs, sync runs, foreground attach, and
+ * detached background spawns. Default is NodeFunnelProcessRunner (Bun.spawn);
+ * MemoryFunnelProcessRunner records calls and lets tests stub responses.
+ */
+declare abstract class FunnelProcessRunner {
+  abstract run(command: string[], options?: RunOptions): Promise<RunResult>;
+  abstract runSync(command: string[]): RunResult;
+  abstract attach(command: string[], options?: AttachOptions): Promise<number>;
+  abstract detach(command: string[], options?: DetachOptions): void;
+  abstract kill(pid: number, signal?: string): void;
+}
+//#endregion
+//#region lib/connectors/gh-connector-schema.d.ts
+declare const ghConnectorSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"gh">;
+  pollInterval: z.ZodOptional<z.ZodNumber>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GhConnectorConfig = z.infer<typeof ghConnectorSchema>;
+//#endregion
+export { FunnelProcessRunner as a, DetachOptions as i, ghConnectorSchema as n, RunOptions as o, AttachOptions as r, RunResult as s, GhConnectorConfig as t };