@interactive-inc/claude-funnel 0.41.0 → 0.50.0

package/dist/local-config-json-schema-8IHjS4Q7.js

@@ -0,0 +1,439 @@
+import { join } from "node:path";
+import { z } from "zod";
+import { stderr, stdin } from "node:process";
+//#region lib/engine/local-config/local-config-schema.ts
+/**
+* Per-repo launch config (`funnel.json`).
+*
+* `fnl claude` reads this when no global --profile preset is used. It picks one
+* of the declared channels (`--channel <name>` selects by name; otherwise the
+* first entry wins) and materializes its transport (connectors / delivery) into
+* the repo's scoped settings (`~/.funnel/projects/<id>/settings.json`) on launch.
+* Connectors carry no tokens here — a token absent from settings is prompted for
+* at launch (TTY) and saved there, never in the repo.
+*
+* The launch recipe (`options` / `env` / `resume`) lives on `profiles[]`, not on
+* the channel: a channel only describes where events come from. `fnl claude`
+* applies the first profile bound to the chosen channel; the recipe is passed
+* straight to the launcher and is not persisted into the global profile list.
+* These profiles are selected by their `channel` binding, not by name.
+*/
+const slackConnectorSpecSchema = z.object({
+	type: z.literal("slack"),
+	name: z.string(),
+	/** Shrink raw Slack events before fanout. Defaults to true. */
+	minify: z.boolean().optional()
+});
+const discordConnectorSpecSchema = z.object({
+	type: z.literal("discord"),
+	name: z.string()
+});
+const ghConnectorSpecSchema = z.object({
+	type: z.literal("gh"),
+	name: z.string(),
+	pollInterval: z.number().int().positive().optional()
+});
+const scheduleConnectorSpecSchema = z.object({
+	type: z.literal("schedule"),
+	name: z.string()
+});
+const connectorSpecSchema = z.discriminatedUnion("type", [
+	slackConnectorSpecSchema,
+	discordConnectorSpecSchema,
+	ghConnectorSpecSchema,
+	scheduleConnectorSpecSchema
+]);
+const channelSpecSchema = z.object({
+	name: z.string(),
+	connectors: z.array(connectorSpecSchema).optional()
+});
+const profileSpecSchema = z.object({
+	/** Handle for `fnl claude --profile <name>`. A profile is only launchable by this name. */
+	name: z.string(),
+	/** Name of the channel (declared in `channels[]`) this profile binds. The profile depends on the channel, never the reverse. */
+	channel: z.string(),
+	/** Args prepended to the claude argv on every launch through this profile. */
+	options: z.array(z.string()).optional(),
+	/** Env vars layered under the launched claude process. process.env wins on collision. */
+	env: z.record(z.string(), z.string()).optional(),
+	/**
+	* When true (the default), funnel injects `--session-id <uuid>` so that
+	* relaunching from the same cwd resumes the previous claude session
+	* without bleeding into other channels or workspaces. Set to false for
+	* profiles that should always start a fresh session.
+	*/
+	resume: z.boolean().optional()
+});
+const localConfigSchema = z.object({
+	$schema: z.string().optional(),
+	/**
+	* Stable per-repo identifier. funnel writes this on first launch when absent;
+	* all funnel state for this repo lives under `~/.funnel/projects/<id>/`, so the
+	* repo itself never holds settings or tokens. Committed alongside funnel.json.
+	*/
+	id: z.string().optional(),
+	/** Declared channels (transport only). First entry is the default; --channel <name> selects by name. */
+	channels: z.array(channelSpecSchema).min(1),
+	/** Launch presets bound to a channel. First entry bound to the chosen channel is the default. */
+	profiles: z.array(profileSpecSchema).optional()
+});
+const LOCAL_CONFIG_FILENAME = "funnel.json";
+//#endregion
+//#region lib/engine/local-config/local-config.ts
+/**
+* Reads `funnel.json` from a directory. Returns `null` when the file is
+* absent so callers can fall through to other resolution paths (default
+* profile, help). Throws on present-but-invalid files so misconfiguration
+* surfaces loudly instead of silently launching the wrong channel.
+*/
+var FunnelLocalConfig = class {
+	fs;
+	constructor(deps) {
+		this.fs = deps.fs;
+		Object.freeze(this);
+	}
+	read(cwd) {
+		const path = join(cwd, LOCAL_CONFIG_FILENAME);
+		if (!this.fs.existsSync(path)) return null;
+		const raw = this.fs.readFileSync(path);
+		const parsed = (() => {
+			try {
+				return JSON.parse(raw);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				throw new Error(`${LOCAL_CONFIG_FILENAME} is not valid JSON: ${message}`);
+			}
+		})();
+		const result = localConfigSchema.safeParse(parsed);
+		if (!result.success) throw new Error(`${LOCAL_CONFIG_FILENAME} is invalid: ${result.error.message}`);
+		this.assertProfilesValid(result.data);
+		return result.data;
+	}
+	assertProfilesValid(config) {
+		const profiles = config.profiles ?? [];
+		if (profiles.length === 0) return;
+		const channelNames = new Set(config.channels.map((channel) => channel.name));
+		const seenNames = /* @__PURE__ */ new Set();
+		for (const profile of profiles) {
+			if (!channelNames.has(profile.channel)) throw new Error(`${LOCAL_CONFIG_FILENAME} is invalid: profile "${profile.name}" binds channel "${profile.channel}", which is not declared in channels[]`);
+			if (seenNames.has(profile.name)) throw new Error(`${LOCAL_CONFIG_FILENAME} is invalid: more than one profile is named "${profile.name}" — names must be unique`);
+			seenNames.add(profile.name);
+		}
+	}
+};
+//#endregion
+//#region lib/engine/token-prompter/token-prompter.ts
+/**
+* Asks the user for a secret value on stdin. Used as a last resort when a
+* funnel.json token field is absent and not present in `~/.funnel`. The Node
+* implementation refuses to prompt when stdin is not a TTY so non-interactive
+* launches (CI, agent spawning agent, daemons) fail fast instead of hanging.
+*/
+var FunnelTokenPrompter = class {};
+//#endregion
+//#region lib/engine/local-config/local-config-sync.ts
+/**
+* Reconciles a single funnel.json channel spec with `~/.funnel/settings.json`.
+* The spec is the source of truth for the channel it declares:
+*
+*   - missing channel → created
+*   - declared connector matched by name → tokens reconciled
+*   - declared connector matched by token in the same channel under a
+*     different name → renamed in place (then tokens reconciled)
+*   - declared connector with no match → added
+*   - any connector left in the channel that the spec did not touch → removed
+*
+* Removal only fires when the channel spec has a `connectors` field. An
+* absent field means "do not manage connectors from here" and leaves
+* everything in `~/.funnel` alone. Other channels in funnel.json (not
+* passed to this call) are untouched.
+*
+* Returns the per-connector change set so callers (e.g. the claude launcher)
+* can drive listener hot-reload on the gateway after settings are written.
+*/
+var FunnelLocalConfigSync = class {
+	channels;
+	prompter;
+	constructor(deps) {
+		this.channels = deps.channels;
+		this.prompter = deps.prompter;
+		Object.freeze(this);
+	}
+	async ensure(channel) {
+		if (!this.channels.get(channel.name)) this.channels.add({ name: channel.name });
+		if (channel.connectors === void 0) return {
+			touched: [],
+			removed: []
+		};
+		const touched = [];
+		const touchedIds = /* @__PURE__ */ new Set();
+		for (const spec of channel.connectors) {
+			const outcome = await this.ensureConnector(channel.name, spec);
+			touched.push({
+				name: outcome.name,
+				changed: outcome.changed
+			});
+			touchedIds.add(outcome.id);
+		}
+		return {
+			touched,
+			removed: this.removeExtras(channel.name, touchedIds)
+		};
+	}
+	async ensureConnector(channelName, spec) {
+		if (spec.type === "slack") return await this.ensureSlack(channelName, spec);
+		if (spec.type === "discord") return await this.ensureDiscord(channelName, spec);
+		if (spec.type === "gh") return this.ensureGh(channelName, spec);
+		return this.ensureSchedule(channelName, spec);
+	}
+	async ensureSlack(channelName, spec) {
+		const byName = this.findExistingSlack(channelName, spec.name);
+		const bot = await this.resolveSlot({
+			label: `${spec.name}.botToken`,
+			existingLiteral: byName?.botToken,
+			existingEnv: byName?.botTokenEnv
+		});
+		const app = await this.resolveSlot({
+			label: `${spec.name}.appToken`,
+			existingLiteral: byName?.appToken,
+			existingEnv: byName?.appTokenEnv
+		});
+		const update = {
+			botToken: bot.token,
+			botTokenEnv: bot.tokenEnv,
+			appToken: app.token,
+			appTokenEnv: app.tokenEnv
+		};
+		if (byName) {
+			if (!(byName.botToken === bot.token && byName.botTokenEnv === bot.tokenEnv && byName.appToken === app.token && byName.appTokenEnv === app.tokenEnv)) {
+				this.channels.updateSlackConnector(channelName, spec.name, update);
+				return {
+					id: byName.id,
+					name: spec.name,
+					changed: true
+				};
+			}
+			return {
+				id: byName.id,
+				name: spec.name,
+				changed: false
+			};
+		}
+		return {
+			id: this.channels.addConnector(channelName, {
+				type: "slack",
+				name: spec.name,
+				...update,
+				...spec.minify !== void 0 ? { minify: spec.minify } : {}
+			}).id,
+			name: spec.name,
+			changed: true
+		};
+	}
+	async ensureDiscord(channelName, spec) {
+		const byName = this.findExistingDiscord(channelName, spec.name);
+		const bot = await this.resolveSlot({
+			label: `${spec.name}.botToken`,
+			existingLiteral: byName?.botToken,
+			existingEnv: byName?.botTokenEnv
+		});
+		const update = {
+			botToken: bot.token,
+			botTokenEnv: bot.tokenEnv
+		};
+		if (byName) {
+			if (byName.botToken !== bot.token || byName.botTokenEnv !== bot.tokenEnv) {
+				this.channels.updateDiscordConnector(channelName, spec.name, update);
+				return {
+					id: byName.id,
+					name: spec.name,
+					changed: true
+				};
+			}
+			return {
+				id: byName.id,
+				name: spec.name,
+				changed: false
+			};
+		}
+		return {
+			id: this.channels.addConnector(channelName, {
+				type: "discord",
+				name: spec.name,
+				...update
+			}).id,
+			name: spec.name,
+			changed: true
+		};
+	}
+	ensureGh(channelName, spec) {
+		const existing = this.channels.getConnector(channelName, spec.name);
+		if (existing && existing.type !== "gh") throw new Error(`connector "${spec.name}" exists in channel "${channelName}" with type "${existing.type}", funnel.json declares "gh"`);
+		if (existing && existing.type === "gh") {
+			if (spec.pollInterval !== void 0 && existing.pollInterval !== spec.pollInterval) {
+				this.channels.updateGhConnector(channelName, spec.name, { pollInterval: spec.pollInterval });
+				return {
+					id: existing.id,
+					name: spec.name,
+					changed: true
+				};
+			}
+			return {
+				id: existing.id,
+				name: spec.name,
+				changed: false
+			};
+		}
+		return {
+			id: this.channels.addConnector(channelName, {
+				type: "gh",
+				name: spec.name,
+				...spec.pollInterval !== void 0 ? { pollInterval: spec.pollInterval } : {}
+			}).id,
+			name: spec.name,
+			changed: true
+		};
+	}
+	ensureSchedule(channelName, spec) {
+		const existing = this.channels.getConnector(channelName, spec.name);
+		if (existing && existing.type !== "schedule") throw new Error(`connector "${spec.name}" exists in channel "${channelName}" with type "${existing.type}", funnel.json declares "schedule"`);
+		if (existing && existing.type === "schedule") return {
+			id: existing.id,
+			name: spec.name,
+			changed: false
+		};
+		return {
+			id: this.channels.addConnector(channelName, {
+				type: "schedule",
+				name: spec.name
+			}).id,
+			name: spec.name,
+			changed: true
+		};
+	}
+	findExistingSlack(channelName, connectorName) {
+		const existing = this.channels.getConnector(channelName, connectorName);
+		if (!existing) return null;
+		if (existing.type !== "slack") throw new Error(`connector "${connectorName}" exists in channel "${channelName}" with type "${existing.type}", funnel.json declares "slack"`);
+		return existing;
+	}
+	findExistingDiscord(channelName, connectorName) {
+		const existing = this.channels.getConnector(channelName, connectorName);
+		if (!existing) return null;
+		if (existing.type !== "discord") throw new Error(`connector "${connectorName}" exists in channel "${channelName}" with type "${existing.type}", funnel.json declares "discord"`);
+		return existing;
+	}
+	removeExtras(channelName, touched) {
+		const channel = this.channels.get(channelName);
+		if (!channel) return [];
+		const stale = channel.connectors.filter((c) => !touched.has(c.id));
+		for (const connector of stale) this.channels.removeConnector(channelName, connector.name);
+		return stale.map((c) => c.name);
+	}
+	/**
+	* Decides how a single token slot is stored in settings.json. funnel.json
+	* never carries tokens, so the only sources are a value already in
+	* settings.json (carried over verbatim, whichever form it was — literal or an
+	* `env`-var reference set via the CLI) or, on first sync, a TTY prompt for a
+	* literal (throws when stdin is not a TTY). Either way the secret lands in the
+	* repo-scoped settings, never in the repo itself.
+	*/
+	async resolveSlot(input) {
+		if (input.existingEnv !== void 0) return {
+			token: void 0,
+			tokenEnv: input.existingEnv
+		};
+		if (input.existingLiteral !== void 0) return {
+			token: input.existingLiteral,
+			tokenEnv: void 0
+		};
+		return {
+			token: await this.prompter.promptSecret(input.label),
+			tokenEnv: void 0
+		};
+	}
+};
+//#endregion
+//#region lib/engine/token-prompter/node-token-prompter.ts
+const STAR = "*";
+const CR = "\r";
+const LF = "\n";
+const BACKSPACE = String.fromCharCode(8);
+const DEL = String.fromCharCode(127);
+const CTRL_C = String.fromCharCode(3);
+const CTRL_D = String.fromCharCode(4);
+/**
+* Reads a secret from stdin in raw mode. Echoes a `*` per byte so the user
+* can see progress without exposing the token. Refuses to prompt when stdin
+* is not a TTY — callers should surface the resulting error with a hint
+* pointing at the corresponding env var or CLI command.
+*/
+var NodeFunnelTokenPrompter = class extends FunnelTokenPrompter {
+	async promptSecret(label) {
+		if (!stdin.isTTY) throw new Error(`cannot prompt for "${label}": stdin is not a TTY. Set the matching env var or run \`fnl channels <ch> connectors add ...\` first.`);
+		stderr.write(`${label}: `);
+		const wasRaw = stdin.isRaw;
+		stdin.setRawMode(true);
+		stdin.resume();
+		try {
+			return await this.readSecret();
+		} finally {
+			stdin.setRawMode(wasRaw);
+			stdin.pause();
+			stderr.write(LF);
+		}
+	}
+	readSecret() {
+		return new Promise((resolve, reject) => {
+			let buffer = "";
+			const onData = (chunk) => {
+				for (const byte of chunk) {
+					const char = String.fromCharCode(byte);
+					if (char === LF || char === CR) {
+						stdin.off("data", onData);
+						resolve(buffer);
+						return;
+					}
+					if (char === CTRL_C) {
+						stdin.off("data", onData);
+						reject(/* @__PURE__ */ new Error("prompt cancelled"));
+						return;
+					}
+					if (char === CTRL_D) {
+						stdin.off("data", onData);
+						if (buffer.length === 0) reject(/* @__PURE__ */ new Error("prompt cancelled"));
+						else resolve(buffer);
+						return;
+					}
+					if (char === BACKSPACE || char === DEL) {
+						if (buffer.length > 0) {
+							buffer = buffer.slice(0, -1);
+							stderr.write("\b \b");
+						}
+						continue;
+					}
+					buffer += char;
+					stderr.write(STAR);
+				}
+			};
+			stdin.on("data", onData);
+		});
+	}
+};
+//#endregion
+//#region lib/engine/local-config/local-config-json-schema.ts
+/**
+* Generates the JSON Schema (draft 2020-12) for `funnel.json`. Useful for
+* `$schema` references in committed `funnel.json` files so editors can give
+* autocomplete and validation for channels[] (transport) and profiles[]
+* (launch recipe) without anyone hand-maintaining a separate schema.
+*/
+const funnelJsonSchema = () => {
+	return {
+		...z.toJSONSchema(localConfigSchema, { target: "draft-2020-12" }),
+		title: "Funnel per-repo launch config",
+		description: "Used by `fnl claude` to declare channels (transport: connectors to materialize into ~/.funnel/settings.json on launch) and profiles (launch recipe: options / env / resume) bound to those channels."
+	};
+};
+//#endregion
+export { FunnelLocalConfig as a, connectorSpecSchema as c, FunnelTokenPrompter as i, localConfigSchema as l, NodeFunnelTokenPrompter as n, LOCAL_CONFIG_FILENAME as o, FunnelLocalConfigSync as r, channelSpecSchema as s, funnelJsonSchema as t, profileSpecSchema as u };