@interactive-inc/claude-funnel 0.60.1 → 0.63.0

package/dist/{local-config-json-schema-JyLqOQNX.js → local-config-json-schema-DexV8vX3.js}

@@ -1,6 +1,6 @@
-import { t as discordConnectorSchema } from "./discord-connector-schema-B_N6IXLz.js";
-import { t as ghConnectorSchema } from "./gh-connector-schema-Rzwc1c1N.js";
-import { t as slackConnectorSchema } from "./slack-connector-schema-C1zEf4TG.js";
+import { t as discordConnectorSchema } from "./discord-connector-schema-B4YpWpR3.js";
+import { t as ghConnectorSchema } from "./gh-connector-schema-CAqIhzGr.js";
+import { t as slackConnectorSchema } from "./slack-connector-schema-Dem8to4P.js";
 import { join } from "node:path";
 import { z } from "zod";
 import { stderr, stdin } from "node:process";
@@ -451,6 +451,26 @@ var NodeFunnelTokenPrompter = class extends FunnelTokenPrompter {
 	}
 };
 //#endregion
+//#region lib/engine/token-prompter/memory-token-prompter.ts
+/**
+* Pre-seeded answers keyed by prompt label. Tests configure the map up front;
+* unmapped labels throw so the test surfaces unexpected prompts loudly.
+*/
+var MemoryFunnelTokenPrompter = class extends FunnelTokenPrompter {
+	answers;
+	asked = [];
+	constructor(props = {}) {
+		super();
+		this.answers = new Map(Object.entries(props.answers ?? {}));
+	}
+	async promptSecret(label) {
+		this.asked.push(label);
+		const answer = this.answers.get(label);
+		if (answer === void 0) throw new Error(`no answer seeded for prompt "${label}"`);
+		return answer;
+	}
+};
+//#endregion
 //#region lib/services/local-config/local-config-json-schema.ts
 /**
 * Generates the JSON Schema (draft 2020-12) for `funnel.json`. Useful for
@@ -466,4 +486,4 @@ const funnelJsonSchema = () => {
 	};
 };
 //#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 };
+export { FunnelTokenPrompter as a, channelSpecSchema as c, profileSpecSchema as d, FunnelLocalConfigSync as i, connectorSpecSchema as l, MemoryFunnelTokenPrompter as n, FunnelLocalConfig as o, NodeFunnelTokenPrompter as r, LOCAL_CONFIG_FILENAME as s, funnelJsonSchema as t, localConfigSchema as u };

package/dist/local-config.d.ts

@@ -1,3 +1,40 @@
-import { a as FunnelLocalConfig, c as LOCAL_CONFIG_FILENAME, d as channelSpecSchema, f as connectorSpecSchema, i as FunnelTokenPrompter, l as LocalConfig, m as profileSpecSchema, n as FunnelLocalConfigSync, o as ChannelSpec, p as localConfigSchema, r as LocalConfigSyncResult, s as ConnectorSpec, t as ConnectorSyncOutcome, u as ProfileSpec } from "./local-config-sync-Dh1Croqe.js";
-import { i as funnelJsonSchema, n as NodeFunnelTokenPrompter, r as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-B4sjyaAq.js";
+import { n as FunnelFileSystem } from "./file-system-VhwwXZbm.js";
+import { a as LocalConfigSyncResult, c as ChannelSpec, d as LocalConfig, f as ProfileSpec, g as profileSpecSchema, h as localConfigSchema, i as FunnelLocalConfigSync, l as ConnectorSpec, m as connectorSpecSchema, n as NodeFunnelTokenPrompter, o as FunnelTokenPrompter, p as channelSpecSchema, r as ConnectorSyncOutcome, s as FunnelLocalConfig, t as MemoryFunnelTokenPrompter, u as LOCAL_CONFIG_FILENAME } from "./memory-token-prompter-DP_YV9xX.js";
+
+//#region lib/services/local-config/local-config-json-schema.d.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.
+ */
+declare const funnelJsonSchema: () => Record<string, unknown>;
+//#endregion
+//#region lib/services/local-config/local-config-writer.d.ts
+type Deps = {
+  fs: FunnelFileSystem;
+};
+/**
+ * The one path that mutates the repo-committed funnel.json, and it only ever
+ * inserts `id`. On first launch a repo has no `id`; funnel generates one and
+ * writes it back here so future launches resolve the same `~/.funnel/projects/<id>/`.
+ * Idempotent — a no-op once `id` is present. Kept separate from the read-only
+ * FunnelLocalConfig so reads stay side-effect free.
+ */
+declare class FunnelLocalConfigWriter {
+  private readonly fs;
+  constructor(deps: Deps);
+  /**
+   * Returns the id that ends up persisted in funnel.json. If the file already
+   * has an id, the candidate is ignored and the persisted one wins. Otherwise
+   * the candidate is written and returned. Returns null when there is no
+   * funnel.json (the caller stays on the global ~/.funnel).
+   *
+   * The read+merge+write runs under an exclusive lock so two concurrent
+   * 'fnl claude' launches on the same repo cannot each persist a different
+   * generated id and split state across two ~/.funnel/projects/<id>/ dirs.
+   */
+  ensureId(cwd: string, candidate: string): string | null;
+}
+//#endregion
 export { ChannelSpec, ConnectorSpec, ConnectorSyncOutcome, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelTokenPrompter, LOCAL_CONFIG_FILENAME, LocalConfig, LocalConfigSyncResult, MemoryFunnelTokenPrompter, NodeFunnelTokenPrompter, ProfileSpec, channelSpecSchema, connectorSpecSchema, funnelJsonSchema, localConfigSchema, profileSpecSchema };

package/dist/local-config.js

@@ -1,3 +1,54 @@
-import { a as FunnelLocalConfig, c as connectorSpecSchema, i as FunnelTokenPrompter, l as localConfigSchema, n as NodeFunnelTokenPrompter, o as LOCAL_CONFIG_FILENAME, r as FunnelLocalConfigSync, s as channelSpecSchema, t as funnelJsonSchema, u as profileSpecSchema } from "./local-config-json-schema-JyLqOQNX.js";
-import { n as FunnelLocalConfigWriter, t as MemoryFunnelTokenPrompter } from "./memory-token-prompter-CZde7e6y.js";
+import { a as FunnelTokenPrompter, c as channelSpecSchema, d as profileSpecSchema, i as FunnelLocalConfigSync, l as connectorSpecSchema, n as MemoryFunnelTokenPrompter, o as FunnelLocalConfig, r as NodeFunnelTokenPrompter, s as LOCAL_CONFIG_FILENAME, t as funnelJsonSchema, u as localConfigSchema } from "./local-config-json-schema-DexV8vX3.js";
+import { join } from "node:path";
+//#region lib/services/local-config/local-config-writer.ts
+const isRecord = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const withIdFirst = (config, id) => {
+	const ordered = {};
+	if (config.$schema !== void 0) ordered.$schema = config.$schema;
+	ordered.id = id;
+	for (const key of Object.keys(config)) {
+		if (key === "$schema" || key === "id") continue;
+		ordered[key] = config[key];
+	}
+	return ordered;
+};
+/**
+* The one path that mutates the repo-committed funnel.json, and it only ever
+* inserts `id`. On first launch a repo has no `id`; funnel generates one and
+* writes it back here so future launches resolve the same `~/.funnel/projects/<id>/`.
+* Idempotent — a no-op once `id` is present. Kept separate from the read-only
+* FunnelLocalConfig so reads stay side-effect free.
+*/
+var FunnelLocalConfigWriter = class {
+	fs;
+	constructor(deps) {
+		this.fs = deps.fs;
+		Object.freeze(this);
+	}
+	/**
+	* Returns the id that ends up persisted in funnel.json. If the file already
+	* has an id, the candidate is ignored and the persisted one wins. Otherwise
+	* the candidate is written and returned. Returns null when there is no
+	* funnel.json (the caller stays on the global ~/.funnel).
+	*
+	* The read+merge+write runs under an exclusive lock so two concurrent
+	* 'fnl claude' launches on the same repo cannot each persist a different
+	* generated id and split state across two ~/.funnel/projects/<id>/ dirs.
+	*/
+	ensureId(cwd, candidate) {
+		const path = join(cwd, LOCAL_CONFIG_FILENAME);
+		if (!this.fs.existsSync(path)) return null;
+		return this.fs.withFileLock(`${path}.lock`, () => {
+			const parsed = JSON.parse(this.fs.readFileSync(path));
+			if (!isRecord(parsed)) return null;
+			if (typeof parsed.id === "string" && parsed.id !== "") return parsed.id;
+			const ordered = withIdFirst(parsed, candidate);
+			this.fs.writeFileSync(path, `${JSON.stringify(ordered, null, 2)}\n`);
+			return candidate;
+		});
+	}
+};
+//#endregion
 export { FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelTokenPrompter, LOCAL_CONFIG_FILENAME, MemoryFunnelTokenPrompter, NodeFunnelTokenPrompter, channelSpecSchema, connectorSpecSchema, funnelJsonSchema, localConfigSchema, profileSpecSchema };

package/dist/logger.js

@@ -1,4 +1,4 @@
-import { t as FunnelLogSqliteSink } from "./funnel-log-sqlite-sink-kqJbx2H7.js";
+import { t as FunnelLogSqliteSink } from "./funnel-log-sqlite-sink-DLYkY0pZ.js";
 import { dirname } from "node:path";
 import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, unlinkSync } from "node:fs";
 //#region lib/logger/funnel-log.ts

package/dist/loopback-fetch-CVNuN3YZ.js

@@ -0,0 +1,40 @@
+//#region lib/engine/http/gateway-base-url.ts
+/**
+* The HTTP base URL of a gateway daemon on the loopback interface. The daemon
+* always binds 127.0.0.1 for its management API (only the WS `/ws` endpoint is
+* ever exposed off-box), so every in-process HTTP client — publisher, listeners
+* client, MCP channel server — talks to it here. Centralizing the construction
+* keeps the host/port shape in one place instead of re-spelling
+* `http://127.0.0.1:${port}` at each call site.
+*/
+function gatewayLoopbackUrl(port) {
+	return `http://127.0.0.1:${port}`;
+}
+//#endregion
+//#region lib/engine/http/loopback-fetch.ts
+/**
+* Default ceiling on every loopback request to the gateway daemon. Five
+* seconds is well above the daemon's normal /status latency (microseconds)
+* but short enough that a wedged daemon does not hang the CLI / MCP / SDK
+* caller for any meaningful time.
+*/
+const DEFAULT_LOOPBACK_TIMEOUT_MS = 5e3;
+/**
+* Wraps `fetch` with an automatic abort signal so a wedged gateway daemon
+* cannot hang the caller forever. Composes with a host-supplied
+* `init.signal`: if either the timeout or the host signal aborts, the
+* request is cancelled and `fetch` rejects with an AbortError.
+*
+* Returns the raw `Response` so callers can branch on `res.ok` / parse body
+* however they like — this is the lowest-level wrapper, not a JSON helper.
+*/
+const loopbackFetch = async (url, init = {}, timeoutMs = DEFAULT_LOOPBACK_TIMEOUT_MS) => {
+	const timeoutSignal = AbortSignal.timeout(timeoutMs);
+	const signal = init.signal ? AbortSignal.any([init.signal, timeoutSignal]) : timeoutSignal;
+	return fetch(url, {
+		...init,
+		signal
+	});
+};
+//#endregion
+export { gatewayLoopbackUrl as n, loopbackFetch as t };

package/dist/{local-config-sync-Dh1Croqe.d.ts → memory-token-prompter-DP_YV9xX.d.ts}

@@ -1,5 +1,5 @@
-import { n as FunnelFileSystem } from "./file-system-o51IsM0W.js";
-import { r as FunnelChannels } from "./channels-2g_BU1N0.js";
+import { n as FunnelFileSystem } from "./file-system-VhwwXZbm.js";
+import { r as FunnelChannels } from "./channels-B8RQPrVq.js";
 import { z } from "zod";
 
 //#region lib/services/local-config/local-config-schema.d.ts
@@ -166,4 +166,31 @@ declare class FunnelLocalConfigSync {
   private resolveSlot;
 }
 //#endregion
-export { FunnelLocalConfig as a, LOCAL_CONFIG_FILENAME as c, channelSpecSchema as d, connectorSpecSchema as f, FunnelTokenPrompter as i, LocalConfig as l, profileSpecSchema as m, FunnelLocalConfigSync as n, ChannelSpec as o, localConfigSchema as p, LocalConfigSyncResult as r, ConnectorSpec as s, ConnectorSyncOutcome as t, ProfileSpec as u };
+//#region lib/engine/token-prompter/node-token-prompter.d.ts
+/**
+ * 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.
+ */
+declare class NodeFunnelTokenPrompter extends FunnelTokenPrompter {
+  promptSecret(label: string): Promise<string>;
+  private readSecret;
+}
+//#endregion
+//#region lib/engine/token-prompter/memory-token-prompter.d.ts
+type Props = {
+  answers?: Record<string, string>;
+};
+/**
+ * Pre-seeded answers keyed by prompt label. Tests configure the map up front;
+ * unmapped labels throw so the test surfaces unexpected prompts loudly.
+ */
+declare class MemoryFunnelTokenPrompter extends FunnelTokenPrompter {
+  private readonly answers;
+  readonly asked: string[];
+  constructor(props?: Props);
+  promptSecret(label: string): Promise<string>;
+}
+//#endregion
+export { LocalConfigSyncResult as a, ChannelSpec as c, LocalConfig as d, ProfileSpec as f, profileSpecSchema as g, localConfigSchema as h, FunnelLocalConfigSync as i, ConnectorSpec as l, connectorSpecSchema as m, NodeFunnelTokenPrompter as n, FunnelTokenPrompter as o, channelSpecSchema as p, ConnectorSyncOutcome as r, FunnelLocalConfig as s, MemoryFunnelTokenPrompter as t, LOCAL_CONFIG_FILENAME as u };

package/dist/node-file-system-BOXIHW_Q.js

@@ -0,0 +1,174 @@
+import { t as FunnelFileSystem } from "./file-system-Wvzc2ePY.js";
+import { basename, dirname } from "node:path";
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+//#region lib/engine/fs/node-file-system.ts
+const SECRET_MODE = 384;
+/**
+* Random suffix for the temp file used by the atomic write path. Cannot use
+* crypto.randomUUID directly because Bun spec restricts where it works; a
+* pid+counter pair is enough for in-process uniqueness, which is all we need
+* (the temp file lives at most a few ms before rename).
+*/
+let tempCounter = 0;
+const nextTempSuffix = () => {
+	tempCounter = tempCounter + 1 | 0;
+	return `${process.pid}-${tempCounter}-${Math.floor(Math.random() * 1e9)}`;
+};
+var NodeFunnelFileSystem = class extends FunnelFileSystem {
+	constructor() {
+		super();
+		Object.freeze(this);
+	}
+	existsSync(path) {
+		return existsSync(path);
+	}
+	readFileSync(path) {
+		return readFileSync(path, "utf-8");
+	}
+	writeFileSync(path, data) {
+		atomicWrite(path, data, null);
+	}
+	writeSecretFileSync(path, data) {
+		atomicWrite(path, data, SECRET_MODE);
+	}
+	appendFileSync(path, data) {
+		appendFileSync(path, data);
+	}
+	unlink(path) {
+		try {
+			unlinkSync(path);
+		} catch (error) {
+			if (isErrnoCode(error, "ENOENT")) return;
+			throw error;
+		}
+	}
+	mkdirSync(path, options) {
+		mkdirSync(path, { recursive: options?.recursive ?? false });
+	}
+	readdirSync(path) {
+		return readdirSync(path);
+	}
+	statSync(path) {
+		const stat = statSync(path);
+		return {
+			mtimeMs: stat.mtimeMs,
+			mode: stat.mode & 511
+		};
+	}
+	withFileLock(lockPath, fn) {
+		const fd = acquireLock(lockPath);
+		try {
+			return fn();
+		} finally {
+			try {
+				closeSync(fd);
+			} catch {}
+			try {
+				unlinkSync(lockPath);
+			} catch {}
+		}
+	}
+};
+const LOCK_RETRY_BASE_MS = 10;
+const LOCK_RETRY_MAX_MS = 100;
+const LOCK_TIMEOUT_MS = 5e3;
+const LOCK_STALE_AFTER_MS = 3e4;
+/**
+* Acquire an exclusive lock by atomically creating `lockPath` (`O_EXCL`).
+* Retries with bounded backoff up to LOCK_TIMEOUT_MS. If the existing lock
+* file is older than LOCK_STALE_AFTER_MS or owned by a dead pid, break it
+* and try again. The pid is written to the lock file so the staleness check
+* can be precise (mtime alone is fooled by clock jumps).
+*/
+const acquireLock = (lockPath) => {
+	const deadline = performance.now() + LOCK_TIMEOUT_MS;
+	let attempt = 0;
+	while (true) try {
+		const fd = openSync(lockPath, "wx", 384);
+		writeFileSync(fd, String(process.pid));
+		return fd;
+	} catch (error) {
+		if (!isErrnoCode(error, "EEXIST")) throw error;
+		if (performance.now() >= deadline) throw new Error(`failed to acquire file lock ${lockPath} within ${LOCK_TIMEOUT_MS}ms`);
+		breakIfStale(lockPath);
+		sleepSyncMs(Math.min(LOCK_RETRY_MAX_MS, LOCK_RETRY_BASE_MS * 2 ** Math.min(attempt, 4)));
+		attempt = attempt + 1;
+	}
+};
+const breakIfStale = (lockPath) => {
+	let pid;
+	let mtimeMs;
+	try {
+		mtimeMs = statSync(lockPath).mtimeMs;
+		pid = Number(readFileSync(lockPath, "utf-8").trim());
+	} catch {
+		return;
+	}
+	if (Date.now() - mtimeMs > LOCK_STALE_AFTER_MS) {
+		try {
+			unlinkSync(lockPath);
+		} catch {}
+		return;
+	}
+	if (pid > 0 && !isPidAlive(pid)) try {
+		unlinkSync(lockPath);
+	} catch {}
+};
+const isPidAlive = (pid) => {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		if (isErrnoCode(error, "EPERM")) return true;
+		return false;
+	}
+};
+/**
+* Sleep synchronously for `ms` by spinning on Atomics.wait against a private
+* SharedArrayBuffer. Required because the lock acquisition path is itself
+* synchronous (every settings-mutating call site is sync) and cannot await.
+* The spin is bounded by LOCK_RETRY_MAX_MS so total wall time stays low.
+*/
+const sleepSyncMs = (ms) => {
+	const sab = new SharedArrayBuffer(4);
+	const view = new Int32Array(sab);
+	Atomics.wait(view, 0, 0, ms);
+};
+/**
+* Narrow `unknown` to a Node errno-typed error and check whether its `code`
+* matches the expected value. Avoids `as NodeJS.ErrnoException` casts at
+* each call site while still letting callers distinguish ENOENT / EACCES /
+* etc. without falling back to message-string matching.
+*/
+const isErrnoCode = (error, code) => {
+	if (!(error instanceof Error)) return false;
+	if (!("code" in error)) return false;
+	return error.code === code;
+};
+/**
+* Atomic write via temp + rename. `rename(2)` is atomic on POSIX when source
+* and target share a filesystem, which is guaranteed because the temp file
+* lives in the same directory as the target. A failed write unlinks the
+* temp file so we do not leak `.foo.json.<pid>.tmp` leftovers.
+*
+* `mode` controls the perm bits on both temp and final file. Pass `null` for
+* the OS default (umask-derived), or `0o600` for secret-bearing files.
+*/
+const atomicWrite = (path, data, mode) => {
+	const tempPath = `${dirname(path)}/.${basename(path)}.${nextTempSuffix()}.tmp`;
+	const writeOptions = mode === null ? void 0 : { mode };
+	try {
+		writeFileSync(tempPath, data, writeOptions);
+		if (mode !== null) try {
+			chmodSync(tempPath, mode);
+		} catch {}
+		renameSync(tempPath, path);
+	} catch (error) {
+		try {
+			unlinkSync(tempPath);
+		} catch {}
+		throw error;
+	}
+};
+//#endregion
+export { NodeFunnelFileSystem as t };

package/dist/{profiles-DSzTeKQw.js → profiles-ZHLONml4.js}

@@ -1,4 +1,4 @@
-import { t as NodeFunnelFileSystem } from "./node-file-system-Blr8pAir.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-BOXIHW_Q.js";
 import { join } from "node:path";
 import { homedir } from "node:os";
 //#region lib/engine/profiles/profiles.ts
@@ -43,44 +43,44 @@ var FunnelProfiles = class {
 		return this.list()[0] ?? null;
 	}
 	add(input) {
-		const settings = this.store.read();
-		if (settings.profiles.some((p) => p.name === input.name)) throw new Error(`profile "${input.name}" already exists`);
-		if (!settings.channels.some((c) => c.id === input.channelId)) throw new Error(`channel id "${input.channelId}" not found`);
-		settings.profiles.push({
-			id: this.idGenerator.generate(),
-			name: input.name,
-			path: input.path,
-			channelId: input.channelId,
-			options: input.options ?? [],
-			env: input.env ?? {},
-			resume: input.resume ?? true
+		this.store.update((settings) => {
+			if (settings.profiles.some((p) => p.name === input.name)) throw new Error(`profile "${input.name}" already exists`);
+			if (!settings.channels.some((c) => c.id === input.channelId)) throw new Error(`channel id "${input.channelId}" not found`);
+			settings.profiles.push({
+				id: this.idGenerator.generate(),
+				name: input.name,
+				path: input.path,
+				channelId: input.channelId,
+				options: input.options ?? [],
+				env: input.env ?? {},
+				resume: input.resume ?? true
+			});
 		});
-		this.store.write(settings);
 	}
 	remove(name) {
-		const settings = this.store.read();
-		const index = settings.profiles.findIndex((p) => p.name === name);
-		if (index < 0) throw new Error(`profile "${name}" not found`);
-		settings.profiles.splice(index, 1);
-		this.store.write(settings);
+		this.store.update((settings) => {
+			const index = settings.profiles.findIndex((p) => p.name === name);
+			if (index < 0) throw new Error(`profile "${name}" not found`);
+			settings.profiles.splice(index, 1);
+		});
 	}
 	rename(oldName, newName) {
-		const settings = this.store.read();
-		const profile = settings.profiles.find((p) => p.name === oldName);
-		if (!profile) throw new Error(`profile "${oldName}" not found`);
-		if (settings.profiles.some((p) => p.name === newName)) throw new Error(`profile "${newName}" already exists`);
-		profile.name = newName;
-		this.store.write(settings);
+		this.store.update((settings) => {
+			const profile = settings.profiles.find((p) => p.name === oldName);
+			if (!profile) throw new Error(`profile "${oldName}" not found`);
+			if (settings.profiles.some((p) => p.name === newName)) throw new Error(`profile "${newName}" already exists`);
+			profile.name = newName;
+		});
 	}
 	asDefault(name) {
-		const settings = this.store.read();
-		const index = settings.profiles.findIndex((p) => p.name === name);
-		if (index < 0) throw new Error(`profile "${name}" not found`);
-		if (index === 0) return;
-		const [profile] = settings.profiles.splice(index, 1);
-		if (!profile) return;
-		settings.profiles.unshift(profile);
-		this.store.write(settings);
+		this.store.update((settings) => {
+			const index = settings.profiles.findIndex((p) => p.name === name);
+			if (index < 0) throw new Error(`profile "${name}" not found`);
+			if (index === 0) return;
+			const [profile] = settings.profiles.splice(index, 1);
+			if (!profile) return;
+			settings.profiles.unshift(profile);
+		});
 	}
 	hasChannelRef(channelId) {
 		return this.store.read().profiles.some((p) => p.channelId === channelId);
@@ -91,11 +91,11 @@ var FunnelProfiles = class {
 	}
 	/** Records the claude session id this profile launched, overwriting any prior one. */
 	setSessionId(id, sessionId) {
-		const settings = this.store.read();
-		const profile = settings.profiles.find((p) => p.id === id);
-		if (!profile) throw new Error(`profile id "${id}" not found`);
-		profile.sessionId = sessionId;
-		this.store.write(settings);
+		this.store.update((settings) => {
+			const profile = settings.profiles.find((p) => p.id === id);
+			if (!profile) throw new Error(`profile id "${id}" not found`);
+			profile.sessionId = sessionId;
+		});
 	}
 	/**
 	* Mirrors claude's session storage path
@@ -111,18 +111,18 @@ var FunnelProfiles = class {
 		return this.fs.readFileSync(path).trim().length > 0;
 	}
 	update(name, fields) {
-		const settings = this.store.read();
-		const profile = settings.profiles.find((p) => p.name === name);
-		if (!profile) throw new Error(`profile "${name}" not found`);
-		if (fields.channelId !== void 0) {
-			if (!settings.channels.some((c) => c.id === fields.channelId)) throw new Error(`channel id "${fields.channelId}" not found`);
-			profile.channelId = fields.channelId;
-		}
-		if (fields.path !== void 0) profile.path = fields.path;
-		if (fields.options !== void 0) profile.options = fields.options;
-		if (fields.env !== void 0) profile.env = fields.env;
-		if (fields.resume !== void 0) profile.resume = fields.resume;
-		this.store.write(settings);
+		this.store.update((settings) => {
+			const profile = settings.profiles.find((p) => p.name === name);
+			if (!profile) throw new Error(`profile "${name}" not found`);
+			if (fields.channelId !== void 0) {
+				if (!settings.channels.some((c) => c.id === fields.channelId)) throw new Error(`channel id "${fields.channelId}" not found`);
+				profile.channelId = fields.channelId;
+			}
+			if (fields.path !== void 0) profile.path = fields.path;
+			if (fields.options !== void 0) profile.options = fields.options;
+			if (fields.env !== void 0) profile.env = fields.env;
+			if (fields.resume !== void 0) profile.resume = fields.resume;
+		});
 	}
 };
 //#endregion

package/dist/{profiles-Cy5wXQ0L.d.ts → profiles-cVZQkM69.d.ts}

@@ -1,6 +1,6 @@
-import { r as ProfileConfig } from "./settings-schema-D1xcOqRu.js";
-import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-BIFB_j2f.js";
-import { n as FunnelFileSystem } from "./file-system-o51IsM0W.js";
+import { r as ProfileConfig } from "./settings-schema-BL_c2Udm.js";
+import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-BNxjsxCB.js";
+import { n as FunnelFileSystem } from "./file-system-VhwwXZbm.js";
 
 //#region lib/engine/profiles/profiles.d.ts
 type Deps = {

package/dist/profiles.d.ts

@@ -1,2 +1,2 @@
-import { t as FunnelProfiles } from "./profiles-Cy5wXQ0L.js";
+import { t as FunnelProfiles } from "./profiles-cVZQkM69.js";
 export { FunnelProfiles };

package/dist/profiles.js

@@ -1,2 +1,2 @@
-import { t as FunnelProfiles } from "./profiles-DSzTeKQw.js";
+import { t as FunnelProfiles } from "./profiles-ZHLONml4.js";
 export { FunnelProfiles };

package/dist/recovery.d.ts

@@ -1,2 +1,2 @@
-import { a as RecoveryListenerControl, i as RecoveryGatewayControl, n as RecoveryAction, o as RecoveryResult, r as RecoveryChannelSource, t as FunnelRecovery } from "./funnel-recovery-DnLrdWO9.js";
+import { a as RecoveryListenerControl, i as RecoveryGatewayControl, n as RecoveryAction, o as RecoveryResult, r as RecoveryChannelSource, t as FunnelRecovery } from "./funnel-recovery-CMhY8Jfk.js";
 export { FunnelRecovery, RecoveryAction, RecoveryChannelSource, RecoveryGatewayControl, RecoveryListenerControl, RecoveryResult };

package/dist/recovery.js

@@ -1,2 +1,2 @@
-import { t as FunnelRecovery } from "./funnel-recovery-BFdPjL6Z.js";
+import { t as FunnelRecovery } from "./funnel-recovery-DKnEutUS.js";
 export { FunnelRecovery };

package/dist/resolve-connector-token-DxDG9mhf.js

@@ -0,0 +1,22 @@
+//#region lib/engine/connectors/resolve-connector-token.ts
+/**
+* Resolves a connector token from either a literal value or the name of an env
+* var. A connector config carries one or the other per slot (see
+* slack-connector-schema): literals are inlined into settings.json, references
+* keep the secret in `process.env` and out of settings.json.
+*
+* Errors loudly when neither yields a value — a misconfigured connector should
+* fail at listener start, not connect with an empty token and silently never
+* receive events.
+*/
+const resolveConnectorToken = (props) => {
+	if (props.literal !== void 0 && props.literal !== "") return props.literal;
+	if (props.envVar !== void 0 && props.envVar !== "") {
+		const fromEnv = props.env[props.envVar];
+		if (fromEnv !== void 0 && fromEnv !== "") return fromEnv;
+		throw new Error(`${props.label} references env var "${props.envVar}" but it is not set in the environment`);
+	}
+	throw new Error(`${props.label} has neither a literal token nor an env var reference`);
+};
+//#endregion
+export { resolveConnectorToken as t };