cli-funnel 0.1.0

package/dist/funnel-CoOj5wr1.d.ts

@@ -0,0 +1,264 @@
+type CliProviderId = "claude" | "codex" | "agent" | "antigravity";
+type ApiProviderId = "anthropic-api" | "openai-api";
+type ProviderId = CliProviderId | ApiProviderId;
+/** How much the agent may do on the machine. Providers list the levels they can really enforce. */
+type AccessLevel = "supervised" | "accept-edits" | "auto" | "full";
+declare const ACCESS_LEVELS: readonly AccessLevel[];
+interface EffortOption {
+    /** Value passed to the CLI, for example "high". */
+    id: string;
+    label: string;
+}
+/** One selectable model. `id` is always a concrete, versioned model name. Aliases like "latest" never appear here. */
+interface ModelInfo {
+    id: string;
+    name: string;
+    provider: ProviderId;
+    efforts: EffortOption[];
+    defaultEffort?: string;
+    /** Selectable context sizes in tokens. Empty when the CLI fixes it. */
+    contextWindows: number[];
+    defaultContextWindow?: number;
+    /** True when the model has a faster, higher-usage tier. */
+    fast: boolean;
+    /** Where this entry came from. */
+    source: "manifest" | "cli";
+}
+interface Capabilities {
+    /** Access levels this provider can enforce headlessly. `supervised` appears only when approvals can be passed through. Empty means the provider has no machine access (API providers). */
+    access: AccessLevel[];
+    effort: boolean;
+    contextWindow: boolean;
+    fast: boolean;
+    resume: boolean;
+    approvals: boolean;
+}
+/** The whole UI state in one serializable object. Hardcode it or let the UI produce it. */
+interface Selection {
+    provider: ProviderId;
+    model: string;
+    effort?: string;
+    contextWindow?: number;
+    fast?: boolean;
+    /** Absolute project directory the agent works in. */
+    cwd: string;
+    access: AccessLevel;
+}
+interface Usage {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens?: number;
+    reasoningTokens?: number;
+    totalTokens: number;
+    /** Set only when the CLI reports it. Subscription runs often do not. */
+    costUsd?: number;
+}
+type FinishReason = "stop" | "cancelled" | "error" | "denied";
+interface ApprovalRequest {
+    id: string;
+    tool: string;
+    /** Tool input as the CLI reported it. */
+    input: unknown;
+    description?: string;
+}
+type ApprovalDecision = "allow" | "deny";
+type FunnelEvent = {
+    type: "session";
+    sessionId: string;
+    model?: string;
+} | {
+    type: "text.delta";
+    text: string;
+} | {
+    type: "reasoning.delta";
+    text: string;
+} | {
+    type: "tool.start";
+    id: string;
+    name: string;
+    input?: unknown;
+} | {
+    type: "tool.end";
+    id: string;
+    output?: string;
+    error?: string;
+}
+/** A provider yields this, then awaits `onApproval` for the answer. */
+ | {
+    type: "approval.request";
+    request: ApprovalRequest;
+} | {
+    type: "usage";
+    usage: Usage;
+} | {
+    type: "done";
+    text: string;
+    finishReason: FinishReason;
+} | {
+    type: "error";
+    message: string;
+    code?: string;
+};
+/** What `funnel.run()` resolves to. Shaped like an API response. */
+interface RunResult {
+    text: string;
+    provider: ProviderId;
+    model: string;
+    sessionId?: string;
+    usage?: Usage;
+    finishReason: FinishReason;
+    /** Tool calls the agent made, in order. */
+    toolCalls: {
+        id: string;
+        name: string;
+        input?: unknown;
+        error?: string;
+    }[];
+    /** Tool calls the CLI refused because nobody could approve them. */
+    deniedActions: string[];
+}
+interface RunInput {
+    selection: Selection;
+    prompt: string;
+    /** Continue an earlier conversation. Use the `sessionId` from a previous result. */
+    sessionId?: string;
+    signal?: AbortSignal;
+    /** Called for each tool call that needs approval. Required when `selection.access` is "supervised". */
+    onApproval?: (request: ApprovalRequest) => Promise<ApprovalDecision> | ApprovalDecision;
+    /** Extra environment for the CLI process. */
+    env?: Record<string, string>;
+}
+interface Installation {
+    installed: boolean;
+    path?: string;
+    version?: string;
+    /** False when the installed version is outside the range this release was tested against. */
+    testedRange: {
+        min: string;
+        maxExclusive?: string;
+    };
+    withinTestedRange?: boolean;
+}
+interface AuthStatus {
+    loggedIn: boolean;
+    /** Human label such as "claude.ai" or "ChatGPT". */
+    method?: string;
+    account?: string;
+    plan?: string;
+    detail?: string;
+}
+type LoginEvent = 
+/** Show this URL to the user. The CLI usually opens it too. */
+{
+    type: "open-url";
+    url: string;
+}
+/** The CLI waits for a code the user copies from the browser. Answer with `LoginSession.sendCode`. */
+ | {
+    type: "code-prompt";
+    message: string;
+} | {
+    type: "log";
+    text: string;
+}
+/** The provider has no headless login. Run `command` in a terminal. */
+ | {
+    type: "needs-terminal";
+    command: string[];
+} | {
+    type: "done";
+    status: AuthStatus;
+} | {
+    type: "error";
+    message: string;
+};
+interface LoginSession extends AsyncIterable<LoginEvent> {
+    sendCode(code: string): void;
+    cancel(): void;
+}
+interface UpdateResult {
+    from?: string;
+    to?: string;
+    changed: boolean;
+    output: string;
+}
+interface Provider {
+    readonly id: ProviderId;
+    readonly displayName: string;
+    /** Executable name looked up on PATH. */
+    readonly binary: string;
+    readonly capabilities: Capabilities;
+    detect(): Promise<Installation>;
+    authStatus(): Promise<AuthStatus>;
+    login(options?: {
+        signal?: AbortSignal;
+    }): LoginSession;
+    logout(): Promise<void>;
+    update(): Promise<UpdateResult>;
+    models(): Promise<ModelInfo[]>;
+    run(input: RunInput): AsyncIterable<FunnelEvent>;
+}
+declare class FunnelError extends Error {
+    readonly code: "not-installed" | "not-logged-in" | "unsupported" | "invalid-selection" | "cli-failed" | "aborted";
+    constructor(message: string, code: "not-installed" | "not-logged-in" | "unsupported" | "invalid-selection" | "cli-failed" | "aborted");
+}
+
+/** A manifest entry. Same as ModelInfo minus fields the loader fills in. */
+type ManifestModel = Omit<ModelInfo, "provider" | "source"> & {
+    /** Hide the model on CLIs older than this version. */
+    minCliVersion?: string;
+};
+interface ModelManifest {
+    schemaVersion: 1;
+    updated: string;
+    providers: Record<CliProviderId, ManifestModel[]>;
+}
+/**
+ * Returns the remote manifest when `url` is set and reachable, else the bundled one.
+ * The remote copy lets model lists update without an npm release. It is cached for an hour.
+ */
+declare function loadManifest(url?: string): Promise<ModelManifest>;
+
+interface FunnelOptions {
+    /** URL of a models.json to refresh the bundled model list from. Optional. */
+    manifestUrl?: string;
+    /** Skip checking the selected model against the catalog. Use for models released after your manifest. */
+    allowUnlistedModels?: boolean;
+    /** Replace or add providers. Used by tests and by custom providers. */
+    providers?: Partial<Record<ProviderId, Provider>>;
+    /** API keys for the API providers. Falls back to ANTHROPIC_API_KEY and OPENAI_API_KEY. */
+    apiKeys?: {
+        anthropic?: string;
+        openai?: string;
+    };
+}
+interface ProviderOverview {
+    id: ProviderId;
+    displayName: string;
+    capabilities: Provider["capabilities"];
+    installation: Installation;
+    auth?: AuthStatus;
+}
+interface RunStream extends AsyncIterable<FunnelEvent> {
+    /** Resolves to the API-shaped result once the stream is consumed. */
+    result: Promise<RunResult>;
+}
+declare function createFunnel(options?: FunnelOptions): {
+    providers: Record<ProviderId, Provider>;
+    /** Installed and logged-in state for every provider, for a provider picker. */
+    overview(): Promise<ProviderOverview[]>;
+    models: (id: ProviderId) => Promise<ModelInfo[]>;
+    authStatus: (id: ProviderId) => Promise<AuthStatus>;
+    login: (id: ProviderId, opts?: {
+        signal?: AbortSignal;
+    }) => LoginSession;
+    logout: (id: ProviderId) => Promise<void>;
+    update: (id: ProviderId) => Promise<UpdateResult>;
+    manifest: () => Promise<ModelManifest>;
+    stream: (input: RunInput) => RunStream;
+    /** Runs one turn and resolves with the final text, usage and tool calls. */
+    run(input: RunInput): Promise<RunResult>;
+};
+type Funnel = ReturnType<typeof createFunnel>;
+
+export { type AuthStatus as A, type Capabilities as C, type EffortOption as E, type FunnelEvent as F, type Installation as I, type LoginEvent as L, type ModelInfo as M, type ProviderOverview as P, type RunInput as R, type Selection as S, type UpdateResult as U, type ProviderId as a, type ApprovalDecision as b, ACCESS_LEVELS as c, type AccessLevel as d, type ApiProviderId as e, type ApprovalRequest as f, type CliProviderId as g, type FinishReason as h, FunnelError as i, type LoginSession as j, type Provider as k, type RunResult as l, type Usage as m, type Funnel as n, type FunnelOptions as o, type ManifestModel as p, type ModelManifest as q, type RunStream as r, createFunnel as s, loadManifest as t };

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { S as Selection, k as Provider, M as ModelInfo, a as ProviderId, e as ApiProviderId } from './funnel-CoOj5wr1.js';
+export { c as ACCESS_LEVELS, d as AccessLevel, b as ApprovalDecision, f as ApprovalRequest, A as AuthStatus, C as Capabilities, g as CliProviderId, E as EffortOption, h as FinishReason, n as Funnel, i as FunnelError, F as FunnelEvent, o as FunnelOptions, I as Installation, L as LoginEvent, j as LoginSession, p as ManifestModel, q as ModelManifest, P as ProviderOverview, R as RunInput, l as RunResult, r as RunStream, U as UpdateResult, m as Usage, s as createFunnel, t as loadManifest } from './funnel-CoOj5wr1.js';
+
+/** Throws FunnelError("invalid-selection") when the selection asks for something the provider cannot do. */
+declare function validateSelection(selection: Selection, provider: Provider, models?: ModelInfo[]): void;
+
+declare const PROVIDERS: Record<ProviderId, Provider>;
+
+declare const createApiProviders: (keys?: {
+    anthropic?: string;
+    openai?: string;
+}) => Record<ApiProviderId, Provider>;
+
+export { ApiProviderId, ModelInfo, PROVIDERS, Provider, ProviderId, Selection, createApiProviders, validateSelection };

package/dist/index.js

@@ -0,0 +1,20 @@
+import {
+  PROVIDERS,
+  createApiProviders,
+  createFunnel,
+  loadManifest,
+  validateSelection
+} from "./chunk-2FZ64BNF.js";
+import {
+  ACCESS_LEVELS,
+  FunnelError
+} from "./chunk-YP5V5YEE.js";
+export {
+  ACCESS_LEVELS,
+  FunnelError,
+  PROVIDERS,
+  createApiProviders,
+  createFunnel,
+  loadManifest,
+  validateSelection
+};

package/dist/server/index.d.ts

@@ -0,0 +1,34 @@
+import { d as AccessLevel, n as Funnel } from '../funnel-CoOj5wr1.js';
+import { Server } from 'node:http';
+
+interface OpenAIDefaults {
+    /** Project directory the agent works in. Default: the server's cwd. */
+    cwd?: string;
+    /** Access level for chat-completions calls. Default "accept-edits". "supervised" is denied here because the wire format has no approve button. */
+    access?: AccessLevel;
+}
+
+interface HandlerOptions {
+    /** Path prefix the routes live under, for example "/api/funnel". Default "". */
+    basePath?: string;
+    /** Require `Authorization: Bearer <token>` on every request. Set this whenever the server is reachable by anyone but you. */
+    token?: string;
+    /** Directories the folder picker may browse and runs may use as their project folder. Default: the home directory. */
+    fsRoots?: string[];
+    /** Defaults for the OpenAI-compatible endpoints, which cannot carry a full Selection. */
+    openai?: OpenAIDefaults;
+    /** Seconds to wait for an approval before denying it. Default 300. */
+    approvalTimeoutSec?: number;
+}
+declare function createHandler(funnel: Funnel, options?: HandlerOptions): (req: Request) => Promise<Response>;
+
+/** Serves a fetch-style handler with node:http. Binds to localhost unless told otherwise. */
+declare function serveNode(handler: (req: Request) => Promise<Response>, opts?: {
+    port?: number;
+    host?: string;
+}): Promise<{
+    server: Server;
+    url: string;
+}>;
+
+export { type HandlerOptions, type OpenAIDefaults, createHandler, serveNode };

package/dist/server/index.js

@@ -0,0 +1,9 @@
+import {
+  createHandler,
+  serveNode
+} from "../chunk-GF7JASHO.js";
+import "../chunk-YP5V5YEE.js";
+export {
+  createHandler,
+  serveNode
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "cli-funnel",
+  "version": "0.1.0",
+  "description": "Use Claude Code, Codex, Cursor Agent and Antigravity CLIs like an API, on your subscription.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "cli-funnel": "dist/bin/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "data"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SuperTost100/cli-funnel.git",
+    "directory": "packages/cli-funnel"
+  },
+  "homepage": "https://github.com/SuperTost100/cli-funnel#readme",
+  "bugs": {
+    "url": "https://github.com/SuperTost100/cli-funnel/issues"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "cursor-agent",
+    "antigravity",
+    "cli",
+    "ai",
+    "agent",
+    "openai-compatible",
+    "subscription"
+  ]
+}