@interactive-inc/claude-funnel 0.8.0 → 0.8.1

package/dist/connectors/slack-adapter.d.ts

@@ -0,0 +1,15 @@
+import { FunnelConnectorAdapter, type CallInput } from "./connector-adapter";
+import type { SlackConnectorConfig } from "./slack-connector-schema";
+export type SlackWebClientLike = {
+    apiCall: (method: string, options?: Record<string, unknown>) => Promise<unknown>;
+};
+type Deps = {
+    config: SlackConnectorConfig;
+    client?: SlackWebClientLike;
+};
+export declare class FunnelSlackAdapter extends FunnelConnectorAdapter {
+    private readonly client;
+    constructor(deps: Deps);
+    call(input: CallInput): Promise<unknown>;
+}
+export {};

package/dist/connectors/slack-connector-schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const slackConnectorSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"slack">;
+    botToken: z.ZodString;
+    appToken: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SlackConnectorConfig = z.infer<typeof slackConnectorSchema>;

package/dist/connectors/slack-event-processor.d.ts

@@ -0,0 +1,27 @@
+export type SlackRawEvent = Record<string, unknown>;
+export type SlackProcessedSkip = {
+    skip: true;
+};
+export type SlackProcessedEmit = {
+    skip: false;
+    content: string;
+    meta: Record<string, string>;
+    shouldReact: boolean;
+    channel: string;
+    timestamp: string;
+};
+export type SlackProcessed = SlackProcessedSkip | SlackProcessedEmit;
+type Props = {
+    ownBotUserId: string;
+    ownBotId: string;
+    now?: () => number;
+};
+export declare class FunnelSlackEventProcessor {
+    private readonly ownBotUserId;
+    private readonly ownBotId;
+    private readonly now;
+    private readonly dedup;
+    constructor(props: Props);
+    process(event: SlackRawEvent): SlackProcessed;
+}
+export {};

package/dist/connectors/slack-listener.d.ts

@@ -0,0 +1,17 @@
+import { FunnelConnectorListener, type NotifyFn } from "./connector-listener";
+import { FunnelLogger } from "../engine/logger/logger";
+import type { SlackConnectorConfig } from "./slack-connector-schema";
+type Deps = {
+    config: SlackConnectorConfig;
+    logger?: FunnelLogger;
+};
+export declare class FunnelSlackListener extends FunnelConnectorListener {
+    private readonly config;
+    private readonly logger;
+    private app;
+    constructor(deps: Deps);
+    start(notify: NotifyFn): Promise<void>;
+    stop(): Promise<void>;
+    isAlive(): boolean;
+}
+export {};

package/dist/engine/channels/channels.d.ts

@@ -0,0 +1,106 @@
+import type { CallInput } from "../../connectors/connector-adapter";
+import type { ConnectorConfig } from "../../connectors/connector-config-schema";
+import type { FunnelConnectorFactory } from "../../connectors/connector-factory";
+import type { FunnelConnectorListener } from "../../connectors/connector-listener";
+import type { ScheduleConnectorConfig, ScheduleEntry } from "../../connectors/schedule-connector-schema";
+import type { ProfileChannelChecker } from "../profiles/profile-channel-checker";
+import { FunnelClock } from "../time/clock";
+import { FunnelIdGenerator } from "../id/id-generator";
+import { FunnelSettingsReader } from "../settings/settings-reader";
+import type { ChannelConfig, ChannelDeliveryMode } from "../settings/settings-schema";
+type Deps = {
+    store: FunnelSettingsReader;
+    factory: FunnelConnectorFactory;
+    profileChecker: ProfileChannelChecker;
+    clock?: FunnelClock;
+    idGenerator?: FunnelIdGenerator;
+};
+export type ChannelConnectorView = ConnectorConfig & {
+    channelId: string;
+    channelName: string;
+};
+type AddConnectorInput = {
+    type: "slack";
+    name: string;
+    botToken: string;
+    appToken: string;
+} | {
+    type: "gh";
+    name: string;
+    pollInterval?: number;
+} | {
+    type: "discord";
+    name: string;
+    botToken: string;
+} | {
+    type: "schedule";
+    name: string;
+    entries?: ScheduleEntry[];
+};
+/**
+ * Channels own their connectors. Each channel has a stable id (UUID); the
+ * `name` is the human-facing label used by the CLI. Connectors live nested
+ * inside `channel.connectors[]`, so add/remove/rename are channel-scoped — no
+ * global connector namespace exists. Token uniqueness is enforced across all
+ * channels at add/update time so the same Slack/Discord credentials cannot
+ * be registered twice.
+ */
+export declare class FunnelChannels {
+    private readonly store;
+    private readonly factory;
+    private readonly profileChecker;
+    private readonly clock;
+    private readonly idGenerator;
+    constructor(deps: Deps);
+    list(): ChannelConfig[];
+    get(name: string): ChannelConfig | null;
+    getById(id: string): ChannelConfig | null;
+    add(input: {
+        name: string;
+        delivery?: ChannelDeliveryMode;
+    }): ChannelConfig;
+    setDelivery(name: string, delivery: ChannelDeliveryMode): void;
+    remove(name: string): void;
+    rename(oldName: string, newName: string): void;
+    listConnectors(channelName: string): ConnectorConfig[];
+    getConnector(channelName: string, connectorName: string): ConnectorConfig | null;
+    listAllConnectors(): ChannelConnectorView[];
+    addConnector(channelName: string, input: AddConnectorInput): ConnectorConfig;
+    private fromInput;
+    removeConnector(channelName: string, connectorName: string): void;
+    renameConnector(channelName: string, oldName: string, newName: string): void;
+    updateSlackConnector(channelName: string, connectorName: string, fields: {
+        botToken?: string;
+        appToken?: string;
+    }): void;
+    updateGhConnector(channelName: string, connectorName: string, fields: {
+        pollInterval?: number;
+    }): void;
+    updateDiscordConnector(channelName: string, connectorName: string, fields: {
+        botToken?: string;
+    }): void;
+    listScheduleEntries(channelName: string, connectorName: string): ScheduleEntry[];
+    addScheduleEntry(channelName: string, connectorName: string, entry: Pick<ScheduleEntry, "cron" | "prompt"> & Partial<Pick<ScheduleEntry, "id" | "enabled" | "catchupPolicy">>): ScheduleEntry;
+    removeScheduleEntry(channelName: string, connectorName: string, id: string): void;
+    call(channelName: string, connectorName: string, input: CallInput): Promise<unknown>;
+    createListener(channelName: string, connectorName: string): {
+        config: ConnectorConfig;
+        channelId: string;
+        listener: FunnelConnectorListener;
+    } | null;
+    createAllListeners(): {
+        config: ConnectorConfig;
+        channelId: string;
+        channelName: string;
+        listener: FunnelConnectorListener;
+    }[];
+    private requireChannel;
+    private requireConnector;
+    private requireSlackConnector;
+    private requireGhConnector;
+    private requireDiscordConnector;
+    private requireScheduleConnector;
+    private assertNoTokenCollision;
+    private tokensOf;
+}
+export type { ScheduleConnectorConfig };

package/dist/engine/claude/claude.d.ts

@@ -0,0 +1,49 @@
+import type { FunnelChannels } from "../channels/channels";
+import type { GatewayController } from "./gateway-controller";
+import { FunnelFileSystem } from "../fs/file-system";
+import { FunnelLogger } from "../logger/logger";
+import type { FunnelMcp } from "../mcp/mcp";
+import { FunnelProcessRunner } from "../process/process-runner";
+export type LaunchOptions = {
+    channel: string;
+    cwd?: string;
+    subAgent?: string;
+    userArgs?: string[];
+    profileName?: string;
+};
+type Deps = {
+    channels: FunnelChannels;
+    mcp: FunnelMcp;
+    gateway: GatewayController;
+    process?: FunnelProcessRunner;
+    fs?: FunnelFileSystem;
+    logger?: FunnelLogger;
+    dir?: string;
+};
+/**
+ * Launches Claude Code with funnel pre-wired: ensures the gateway is running,
+ * installs the funnel MCP into the target repo's `.mcp.json` if missing,
+ * injects `FUNNEL_CHANNEL_ID` into the child env, and writes a per-profile
+ * PID file to enforce singleton launches.
+ */
+export declare class FunnelClaude {
+    private readonly channels;
+    private readonly mcp;
+    private readonly gateway;
+    private readonly process;
+    private readonly fs;
+    private readonly logger;
+    private readonly pidDir;
+    constructor(deps: Deps);
+    launch(options: LaunchOptions): Promise<number>;
+    isRunning(profileName: string): boolean;
+    private pidPath;
+    private readPid;
+    private writePidFile;
+    private removePidFile;
+    private installCleanup;
+    private isProcessAlive;
+    private buildArgs;
+    private buildEnv;
+}
+export {};

package/dist/engine/claude/gateway-controller.d.ts

@@ -0,0 +1,6 @@
+export type GatewayController = {
+    isRunning(): boolean;
+    start(options?: {
+        caffeinate?: boolean;
+    }): Promise<boolean>;
+};

package/dist/engine/fs/file-system.d.ts

@@ -0,0 +1,24 @@
+export type FileStat = {
+    mtimeMs: number;
+    /** POSIX mode bits (e.g. 0o600). `null` when the underlying FS does not expose mode. */
+    mode: number | null;
+};
+/**
+ * Filesystem boundary used everywhere funnel reads or writes.
+ * Default is NodeFunnelFileSystem (real `node:fs`); MemoryFunnelFileSystem
+ * provides a sandbox for tests and embedded use.
+ */
+export declare abstract class FunnelFileSystem {
+    abstract existsSync(path: string): boolean;
+    abstract readFileSync(path: string): string;
+    abstract writeFileSync(path: string, data: string): void;
+    /** Write `data` and ensure the resulting file is owner-only (0600). Use for tokens and any file that may contain secrets. */
+    abstract writeSecretFileSync(path: string, data: string): void;
+    abstract appendFileSync(path: string, data: string): void;
+    abstract unlink(path: string): void;
+    abstract mkdirSync(path: string, options?: {
+        recursive?: boolean;
+    }): void;
+    abstract readdirSync(path: string): string[];
+    abstract statSync(path: string): FileStat;
+}

package/dist/engine/fs/memory-file-system.d.ts

@@ -0,0 +1,31 @@
+import { type FileStat, FunnelFileSystem } from "./file-system";
+type Props = {
+    dirs?: string[];
+    files?: Record<string, string>;
+    mtimes?: Record<string, number>;
+    modes?: Record<string, number>;
+    now?: () => number;
+};
+export declare class MemoryFunnelFileSystem extends FunnelFileSystem {
+    private readonly dirs;
+    private readonly files;
+    private readonly mtimes;
+    private readonly modes;
+    private readonly now;
+    constructor(props?: Props);
+    existsSync(path: string): boolean;
+    readFileSync(path: string): string;
+    writeFileSync(path: string, data: string): void;
+    writeSecretFileSync(path: string, data: string): void;
+    appendFileSync(path: string, data: string): void;
+    unlink(path: string): void;
+    mkdirSync(path: string, options?: {
+        recursive?: boolean;
+    }): void;
+    readdirSync(path: string): string[];
+    statSync(path: string): FileStat;
+    setMtime(path: string, mtimeMs: number): void;
+    setMode(path: string, mode: number): void;
+    private touch;
+}
+export {};

package/dist/engine/fs/node-file-system.d.ts

@@ -0,0 +1,15 @@
+import { type FileStat, FunnelFileSystem } from "./file-system";
+export declare class NodeFunnelFileSystem extends FunnelFileSystem {
+    constructor();
+    existsSync(path: string): boolean;
+    readFileSync(path: string): string;
+    writeFileSync(path: string, data: string): void;
+    writeSecretFileSync(path: string, data: string): void;
+    appendFileSync(path: string, data: string): void;
+    unlink(path: string): void;
+    mkdirSync(path: string, options?: {
+        recursive?: boolean;
+    }): void;
+    readdirSync(path: string): string[];
+    statSync(path: string): FileStat;
+}

package/dist/engine/http/http-client.d.ts

@@ -0,0 +1,15 @@
+export type HttpRequest = {
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: string;
+};
+export type HttpResponse = {
+    status: number;
+    ok: boolean;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+};
+export declare abstract class FunnelHttpClient {
+    abstract fetch(request: HttpRequest): Promise<HttpResponse>;
+}

package/dist/engine/http/memory-http-client.d.ts

@@ -0,0 +1,12 @@
+import { FunnelHttpClient, type HttpRequest, type HttpResponse } from "./http-client";
+export type MemoryHttpResponse = {
+    status?: number;
+    body?: string;
+};
+export type MemoryHttpHandler = (request: HttpRequest) => MemoryHttpResponse | Promise<MemoryHttpResponse>;
+export declare class MemoryFunnelHttpClient extends FunnelHttpClient {
+    readonly calls: HttpRequest[];
+    private handler;
+    on(handler: MemoryHttpHandler): this;
+    fetch(request: HttpRequest): Promise<HttpResponse>;
+}

package/dist/engine/http/node-http-client.d.ts

@@ -0,0 +1,5 @@
+import { FunnelHttpClient, type HttpRequest, type HttpResponse } from "./http-client";
+export declare class NodeFunnelHttpClient extends FunnelHttpClient {
+    constructor();
+    fetch(request: HttpRequest): Promise<HttpResponse>;
+}

package/dist/engine/id/id-generator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ID generator boundary. Default NodeFunnelIdGenerator wraps `crypto.randomUUID()`;
+ * MemoryFunnelIdGenerator emits `<prefix>-1, <prefix>-2, ...` for deterministic tests.
+ */
+export declare abstract class FunnelIdGenerator {
+    abstract generate(): string;
+}

package/dist/engine/id/memory-id-generator.d.ts

@@ -0,0 +1,11 @@
+import { FunnelIdGenerator } from "./id-generator";
+type Props = {
+    prefix?: string;
+};
+export declare class MemoryFunnelIdGenerator extends FunnelIdGenerator {
+    private counter;
+    private readonly prefix;
+    constructor(props?: Props);
+    generate(): string;
+}
+export {};

package/dist/engine/id/node-id-generator.d.ts

@@ -0,0 +1,4 @@
+import { FunnelIdGenerator } from "./id-generator";
+export declare class NodeFunnelIdGenerator extends FunnelIdGenerator {
+    generate(): string;
+}

package/dist/engine/logger/logger.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Structured logger with three levels and an optional log-file path.
+ * Defaults to NodeFunnelLogger (appends to /tmp/funnel/funnel.log);
+ * MemoryFunnelLogger captures entries in memory and NoopFunnelLogger silences output.
+ */
+export declare abstract class FunnelLogger {
+    abstract info(message: string, meta?: Record<string, unknown>): void;
+    abstract warn(message: string, meta?: Record<string, unknown>): void;
+    abstract error(message: string, meta?: Record<string, unknown>): void;
+    abstract readonly file: string | null;
+}

package/dist/engine/logger/memory-logger.d.ts

@@ -0,0 +1,14 @@
+import { FunnelLogger } from "./logger";
+export type LogEntry = {
+    level: "info" | "warn" | "error";
+    message: string;
+    meta?: Record<string, unknown>;
+};
+export declare class MemoryFunnelLogger extends FunnelLogger {
+    readonly file: null;
+    readonly entries: LogEntry[];
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+    clear(): void;
+}

package/dist/engine/logger/node-logger.d.ts

@@ -0,0 +1,15 @@
+import { FunnelLogger } from "./logger";
+type Props = {
+    file?: string;
+    now?: () => Date;
+};
+export declare class NodeFunnelLogger extends FunnelLogger {
+    readonly file: string;
+    private readonly now;
+    constructor(props?: Props);
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+    private write;
+}
+export {};

package/dist/engine/logger/noop-logger.d.ts

@@ -0,0 +1,7 @@
+import { FunnelLogger } from "./logger";
+export declare class NoopFunnelLogger extends FunnelLogger {
+    readonly file: null;
+    info(): void;
+    warn(): void;
+    error(): void;
+}

package/dist/engine/mcp/channel-server.d.ts

@@ -0,0 +1 @@
+export declare const startChannelServer: () => Promise<void>;

package/dist/engine/mcp/mcp.d.ts

@@ -0,0 +1,22 @@
+import { FunnelFileSystem } from "../fs/file-system";
+export declare const FUNNEL_MCP_COMMAND = "funnel";
+export declare const FUNNEL_MCP_NAME = "funnel";
+type Deps = {
+    fs?: FunnelFileSystem;
+};
+/**
+ * Installs/uninstalls the funnel MCP entry into a target repository's
+ * `.mcp.json`. Detects an existing entry by command match so renaming is
+ * preserved across re-installs.
+ */
+export declare class FunnelMcp {
+    private readonly fs;
+    constructor(deps?: Deps);
+    install(repoPath: string): void;
+    uninstall(repoPath: string): void;
+    findInstalledName(cwd: string): string | null;
+    private findServerName;
+    private readConfig;
+    private writeConfig;
+}
+export {};

package/dist/engine/process/memory-process-runner.d.ts

@@ -0,0 +1,43 @@
+import { type AttachOptions, type DetachOptions, FunnelProcessRunner, type RunOptions, type RunResult } from "./process-runner";
+export type MemoryProcessResponse = {
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+};
+export type MemoryProcessHandler = (command: string[]) => MemoryProcessResponse | Promise<MemoryProcessResponse>;
+export type MemoryProcessSyncHandler = (command: string[]) => MemoryProcessResponse;
+export type MemoryProcessCall = {
+    kind: "run";
+    command: string[];
+    options: RunOptions;
+} | {
+    kind: "runSync";
+    command: string[];
+} | {
+    kind: "attach";
+    command: string[];
+    options: AttachOptions;
+} | {
+    kind: "detach";
+    command: string[];
+    options: DetachOptions;
+} | {
+    kind: "kill";
+    command: string[];
+};
+export declare class MemoryFunnelProcessRunner extends FunnelProcessRunner {
+    readonly calls: MemoryProcessCall[];
+    readonly killed: {
+        pid: number;
+        signal: string;
+    }[];
+    private handler;
+    private syncHandler;
+    on(handler: MemoryProcessHandler): this;
+    onSync(handler: MemoryProcessSyncHandler): this;
+    run(command: string[], options?: RunOptions): Promise<RunResult>;
+    runSync(command: string[]): RunResult;
+    attach(command: string[], options?: AttachOptions): Promise<number>;
+    detach(command: string[], options?: DetachOptions): void;
+    kill(pid: number, signal?: string): void;
+}

package/dist/engine/process/node-process-runner.d.ts

@@ -0,0 +1,9 @@
+import { type AttachOptions, type DetachOptions, FunnelProcessRunner, type RunOptions, type RunResult } from "./process-runner";
+export declare class NodeFunnelProcessRunner extends FunnelProcessRunner {
+    constructor();
+    runSync(command: string[]): RunResult;
+    run(command: string[], options?: RunOptions): Promise<RunResult>;
+    attach(command: string[], options?: AttachOptions): Promise<number>;
+    detach(command: string[], options?: DetachOptions): void;
+    kill(pid: number, signal?: string): void;
+}

package/dist/engine/process/process-runner.d.ts

@@ -0,0 +1,29 @@
+export type RunOptions = {
+    cwd?: string;
+    env?: Record<string, string>;
+    input?: string;
+};
+export type RunResult = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+export type AttachOptions = {
+    cwd?: string;
+    env?: Record<string, string>;
+};
+export 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.
+ */
+export 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;
+}

package/dist/engine/profiles/profile-channel-checker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Read-side dependency that lets FunnelChannels ask whether a profile
+ * references a given channel id, without depending on FunnelProfiles directly.
+ */
+export type ProfileChannelChecker = {
+    hasChannelRef(channelId: string): boolean;
+};

package/dist/engine/profiles/profiles.d.ts

@@ -0,0 +1,31 @@
+import { FunnelSettingsReader } from "../settings/settings-reader";
+import type { ProfileConfig } from "../settings/settings-schema";
+type Deps = {
+    store: FunnelSettingsReader;
+};
+/**
+ * Named launch presets for `fnl claude`. Each profile bundles a working
+ * directory, a sub-agent name, and the channel id its Claude instance will
+ * subscribe to. Implements ProfileChannelChecker so FunnelChannels can refuse
+ * to remove a channel that is still referenced.
+ *
+ * The first entry in the persisted array is treated as the default profile;
+ * `asDefault` reorders the array to put a named profile first.
+ *
+ * `channelId` always stores the channel's stable id (uuid). CLI surfaces
+ * resolve channel name → id before calling `add`/`update` here.
+ */
+export declare class FunnelProfiles {
+    private readonly store;
+    constructor(deps: Deps);
+    list(): ProfileConfig[];
+    get(name: string): ProfileConfig | null;
+    getDefault(): ProfileConfig | null;
+    add(config: ProfileConfig): void;
+    remove(name: string): void;
+    rename(oldName: string, newName: string): void;
+    asDefault(name: string): void;
+    hasChannelRef(channelId: string): boolean;
+    update(name: string, fields: Partial<Omit<ProfileConfig, "name">>): void;
+}
+export {};

package/dist/engine/settings/mock-settings-reader.d.ts

@@ -0,0 +1,9 @@
+import { FunnelSettingsReader } from "./settings-reader";
+import type { Settings } from "./settings-schema";
+export declare const createSettings: (partial?: Partial<Settings>) => Settings;
+export declare class MockFunnelSettingsReader extends FunnelSettingsReader {
+    private state;
+    constructor(initial?: Partial<Settings>);
+    read(): Settings;
+    write(settings: Settings): void;
+}

package/dist/engine/settings/settings-reader.d.ts

@@ -0,0 +1,5 @@
+import type { Settings } from "./settings-schema";
+export declare abstract class FunnelSettingsReader {
+    abstract read(): Settings;
+    abstract write(settings: Settings): void;
+}