cli-funnel 0.1.0

package/dist/chunk-GF7JASHO.js

@@ -0,0 +1,317 @@
+import {
+  ACCESS_LEVELS,
+  FunnelError
+} from "./chunk-YP5V5YEE.js";
+
+// src/server/handler.ts
+import { timingSafeEqual } from "crypto";
+import { readdir } from "fs/promises";
+import { homedir } from "os";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "path";
+
+// src/server/sse.ts
+var sseHeaders = {
+  "content-type": "text/event-stream",
+  "cache-control": "no-cache, no-transform",
+  connection: "keep-alive"
+};
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+}
+function sse(items, opts = {}) {
+  const enc = new TextEncoder();
+  const it = items[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await it.next();
+        if (done) {
+          if (opts.done) controller.enqueue(enc.encode(`data: ${opts.done}
+
+`));
+          controller.close();
+          return;
+        }
+        controller.enqueue(enc.encode(`data: ${JSON.stringify(value)}
+
+`));
+      } catch (err) {
+        controller.enqueue(enc.encode(`data: ${JSON.stringify({ type: "error", message: String(err) })}
+
+`));
+        controller.close();
+      }
+    },
+    async cancel() {
+      await it.return?.();
+    }
+  });
+}
+
+// src/server/openai.ts
+var text = (c) => typeof c === "string" ? c : (c ?? []).map((p) => p.type === "text" ? p.text ?? "" : "").join("");
+function toPrompt(messages, resumed) {
+  if (resumed) return text([...messages].reverse().find((m) => m.role === "user")?.content ?? "");
+  if (messages.length === 1) return text(messages[0].content);
+  return messages.map((m) => `${m.role.toUpperCase()}: ${text(m.content)}`).join("\n\n");
+}
+var finish = (r) => r === "stop" ? "stop" : r === "cancelled" ? "stop" : r === "denied" ? "content_filter" : "stop";
+var usageOut = (u) => u ? { prompt_tokens: u.inputTokens, completion_tokens: u.outputTokens, total_tokens: u.totalTokens } : void 0;
+async function handleOpenAI(funnel, req, path, defaults = {}, cwdAllowed = () => true) {
+  if (req.method === "GET" && path === "/v1/models") {
+    const ids = Object.keys(funnel.providers);
+    const lists = await Promise.all(ids.map((id2) => funnel.models(id2).catch(() => [])));
+    const data = ids.flatMap((id2, i) => lists[i].map((m) => ({ id: `${id2}/${m.id}`, object: "model", owned_by: id2, name: m.name })));
+    return json({ object: "list", data });
+  }
+  if (req.method !== "POST" || path !== "/v1/chat/completions") return json({ error: { message: "Not found" } }, 404);
+  const body = await req.json();
+  const slash = body.model.indexOf("/");
+  const provider = body.model.slice(0, slash);
+  const model = body.model.slice(slash + 1);
+  if (slash < 0 || !funnel.providers[provider]) {
+    return json({ error: { message: 'model must look like "<provider>/<model>", for example "claude/claude-sonnet-5".' } }, 400);
+  }
+  const access = body.x_funnel?.access ?? defaults.access ?? "accept-edits";
+  if (!ACCESS_LEVELS.includes(access)) return json({ error: { message: `bad access "${access}"` } }, 400);
+  const cwd = body.x_funnel?.cwd ?? defaults.cwd ?? process.cwd();
+  if (body.x_funnel?.cwd && !cwdAllowed(cwd)) return json({ error: { message: "x_funnel.cwd is outside the allowed roots." } }, 403);
+  const input = {
+    selection: {
+      provider,
+      model,
+      effort: body.reasoning_effort,
+      fast: body.x_funnel?.fast,
+      contextWindow: body.x_funnel?.contextWindow,
+      cwd,
+      access
+    },
+    prompt: toPrompt(body.messages, !!body.x_funnel?.sessionId),
+    sessionId: body.x_funnel?.sessionId,
+    signal: req.signal,
+    onApproval: () => "deny"
+  };
+  const id = `chatcmpl-${Date.now().toString(36)}`;
+  const created = Math.floor(Date.now() / 1e3);
+  const chunk = (delta, finish_reason = null, extra = {}) => ({
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model: body.model,
+    choices: [{ index: 0, delta, finish_reason }],
+    ...extra
+  });
+  try {
+    if (!body.stream) {
+      const r = await funnel.run(input);
+      return json({
+        id,
+        object: "chat.completion",
+        created,
+        model: body.model,
+        choices: [{ index: 0, message: { role: "assistant", content: r.text }, finish_reason: finish(r.finishReason) }],
+        usage: usageOut(r.usage),
+        x_funnel: { sessionId: r.sessionId, toolCalls: r.toolCalls, deniedActions: r.deniedActions }
+      });
+    }
+    const stream = funnel.stream(input);
+    const chunks = (async function* () {
+      yield chunk({ role: "assistant" });
+      let usage;
+      let reason = "stop";
+      let sessionId;
+      for await (const e of stream) {
+        if (e.type === "text.delta") yield chunk({ content: e.text });
+        else if (e.type === "session") sessionId = e.sessionId;
+        else if (e.type === "usage") usage = e.usage;
+        else if (e.type === "done") reason = e.finishReason;
+        else if (e.type === "error") throw new Error(e.message);
+      }
+      yield chunk({}, finish(reason), { usage: usageOut(usage), x_funnel: { sessionId } });
+    })();
+    return new Response(sse(chunks, { done: "[DONE]" }), { headers: sseHeaders });
+  } catch (err) {
+    return json({ error: { message: err instanceof Error ? err.message : String(err), type: "cli_funnel_error" } }, 500);
+  }
+}
+
+// src/server/handler.ts
+function createHandler(funnel, options = {}) {
+  const base = (options.basePath ?? "").replace(/\/$/, "");
+  const roots = (options.fsRoots ?? [homedir()]).map((r) => resolve(r));
+  const approvals = /* @__PURE__ */ new Map();
+  const earlyDecisions = /* @__PURE__ */ new Map();
+  const logins = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const insideRoots = (p) => roots.some((r) => p === r || p.startsWith(r + sep));
+  const cwdAllowed = (cwd) => isAbsolute(cwd) && insideRoots(resolve(cwd));
+  const tokenOk = (header) => {
+    const a = Buffer.from(header ?? "");
+    const b = Buffer.from(`Bearer ${options.token}`);
+    return a.length === b.length && timingSafeEqual(a, b);
+  };
+  async function run(req) {
+    const body = await req.json();
+    if (!cwdAllowed(body.selection?.cwd ?? "")) {
+      return json({ error: "cwd is outside the allowed roots. Set fsRoots on the handler." }, 403);
+    }
+    const runId = `run_${++seq}_${Date.now().toString(36)}`;
+    const timeoutMs = (options.approvalTimeoutSec ?? 300) * 1e3;
+    const input = {
+      selection: body.selection,
+      prompt: body.prompt,
+      sessionId: body.sessionId,
+      signal: req.signal,
+      onApproval: (request) => new Promise((resolveDecision) => {
+        const key = `${runId}:${request.id}`;
+        const early = earlyDecisions.get(key);
+        if (early) {
+          earlyDecisions.delete(key);
+          return resolveDecision(early);
+        }
+        const timer = setTimeout(() => finish2("deny"), timeoutMs);
+        const finish2 = (d) => {
+          clearTimeout(timer);
+          approvals.delete(key);
+          resolveDecision(d);
+        };
+        approvals.set(key, { resolve: finish2 });
+      })
+    };
+    const stream = funnel.stream(input);
+    const events = (async function* () {
+      yield { type: "run", runId };
+      try {
+        for await (const e of stream) yield e;
+      } catch (err) {
+        yield { type: "error", message: err instanceof Error ? err.message : String(err), code: err.code };
+      }
+    })();
+    return new Response(sse(events), { headers: sseHeaders });
+  }
+  async function login(id, req) {
+    const session = funnel.login(id, { signal: req.signal });
+    const loginId = `login_${++seq}_${Date.now().toString(36)}`;
+    logins.set(loginId, session);
+    const events = (async function* () {
+      yield { type: "login", loginId };
+      try {
+        yield* session;
+      } finally {
+        logins.delete(loginId);
+      }
+    })();
+    return new Response(sse(events), { headers: sseHeaders });
+  }
+  async function listDirs(url) {
+    const raw = url.searchParams.get("path") || roots[0];
+    const path = resolve(isAbsolute(raw) ? raw : join(roots[0], raw));
+    if (!insideRoots(path)) return json({ error: "Path is outside the allowed roots." }, 403);
+    const entries = await readdir(path, { withFileTypes: true }).catch(() => void 0);
+    if (!entries) return json({ error: "Cannot read directory." }, 404);
+    const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort((a, b) => a.localeCompare(b));
+    const parent = dirname(path);
+    return json({ path, name: basename(path), parent: insideRoots(parent) && parent !== path ? parent : null, dirs });
+  }
+  return async function handle(req) {
+    const url = new URL(req.url);
+    let path = url.pathname;
+    if (base) {
+      if (!path.startsWith(base)) return json({ error: "Not found" }, 404);
+      path = path.slice(base.length) || "/";
+    }
+    if (options.token && !tokenOk(req.headers.get("authorization"))) {
+      return json({ error: "Unauthorized" }, 401);
+    }
+    try {
+      const seg = path.split("/").filter(Boolean);
+      const m = req.method;
+      if (path.startsWith("/v1/")) return await handleOpenAI(funnel, req, path, options.openai, cwdAllowed);
+      if (m === "GET" && path === "/providers") return json(await funnel.overview());
+      if (m === "GET" && path === "/fs") return await listDirs(url);
+      if (m === "POST" && path === "/run") return await run(req);
+      if (seg[0] === "providers" && seg[1]) {
+        const id = seg[1];
+        if (!funnel.providers[id]) return json({ error: `Unknown provider ${id}` }, 404);
+        if (m === "GET" && seg[2] === "models") return json(await funnel.models(id));
+        if (m === "GET" && seg[2] === "auth") return json(await funnel.authStatus(id));
+        if (m === "POST" && seg[2] === "login") return await login(id, req);
+        if (m === "POST" && seg[2] === "logout") {
+          await funnel.logout(id);
+          return json({ ok: true });
+        }
+        if (m === "POST" && seg[2] === "update") return json(await funnel.update(id));
+      }
+      if (m === "POST" && seg[0] === "logins" && seg[1]) {
+        const session = logins.get(seg[1]);
+        if (!session) return json({ error: "Unknown login" }, 404);
+        if (seg[2] === "code") {
+          const { code } = await req.json();
+          session.sendCode(code);
+        } else if (seg[2] === "cancel") session.cancel();
+        return json({ ok: true });
+      }
+      if (m === "POST" && seg[0] === "approvals" && seg[1] && seg[2]) {
+        const key = `${seg[1]}:${seg[2]}`;
+        const { decision } = await req.json();
+        const answer = decision === "allow" ? "allow" : "deny";
+        const pending = approvals.get(key);
+        if (pending) pending.resolve(answer);
+        else {
+          earlyDecisions.set(key, answer);
+          setTimeout(() => earlyDecisions.delete(key), 6e4).unref();
+        }
+        return json({ ok: true });
+      }
+      return json({ error: "Not found" }, 404);
+    } catch (err) {
+      const status = err instanceof FunnelError ? err.code === "invalid-selection" ? 400 : 409 : 500;
+      return json({ error: err instanceof Error ? err.message : String(err), code: err.code }, status);
+    }
+  };
+}
+
+// src/server/node.ts
+import { createServer } from "http";
+import { Readable } from "stream";
+function serveNode(handler, opts = {}) {
+  const host = opts.host ?? "127.0.0.1";
+  const server = createServer(async (nodeReq, nodeRes) => {
+    const ac = new AbortController();
+    nodeRes.on("close", () => ac.abort());
+    const url = `http://${nodeReq.headers.host ?? host}${nodeReq.url ?? "/"}`;
+    const hasBody = nodeReq.method !== "GET" && nodeReq.method !== "HEAD";
+    const req = new Request(url, {
+      method: nodeReq.method,
+      headers: nodeReq.headers,
+      body: hasBody ? Readable.toWeb(nodeReq) : void 0,
+      duplex: "half",
+      signal: ac.signal
+    });
+    const res = await handler(req);
+    nodeRes.writeHead(res.status, Object.fromEntries(res.headers));
+    if (!res.body) return nodeRes.end();
+    const reader = res.body.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        nodeRes.write(value);
+      }
+    } finally {
+      nodeRes.end();
+    }
+  });
+  return new Promise((resolve2) => {
+    server.listen(opts.port ?? 4747, host, () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : opts.port;
+      resolve2({ server, url: `http://${host}:${port}` });
+    });
+  });
+}
+
+export {
+  createHandler,
+  serveNode
+};

package/dist/chunk-YP5V5YEE.js

@@ -0,0 +1,15 @@
+// src/types.ts
+var ACCESS_LEVELS = ["supervised", "accept-edits", "auto", "full"];
+var FunnelError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FunnelError";
+  }
+  code;
+};
+
+export {
+  ACCESS_LEVELS,
+  FunnelError
+};

package/dist/client/index.d.ts

@@ -0,0 +1,52 @@
+import { P as ProviderOverview, a as ProviderId, M as ModelInfo, A as AuthStatus, U as UpdateResult, L as LoginEvent, R as RunInput, S as Selection, F as FunnelEvent, b as ApprovalDecision } from '../funnel-CoOj5wr1.js';
+export { c as ACCESS_LEVELS, d as AccessLevel, e as ApiProviderId, f as ApprovalRequest, C as Capabilities, g as CliProviderId, E as EffortOption, h as FinishReason, i as FunnelError, I as Installation, j as LoginSession, k as Provider, l as RunResult, m as Usage } from '../funnel-CoOj5wr1.js';
+
+interface ClientOptions {
+    /** Where the handler is mounted, for example "/api/funnel" or "http://localhost:4747". */
+    baseUrl: string;
+    token?: string;
+    fetch?: typeof fetch;
+}
+type RunEvent = FunnelEvent | {
+    type: "run";
+    runId: string;
+};
+type LoginStreamEvent = LoginEvent | {
+    type: "login";
+    loginId: string;
+};
+interface DirListing {
+    path: string;
+    name: string;
+    parent: string | null;
+    dirs: string[];
+}
+/** Works in browsers, Node and edge runtimes. Talks to `createHandler` from "cli-funnel/server". */
+declare function createClient(options: ClientOptions): {
+    providers: () => Promise<ProviderOverview[]>;
+    models: (id: ProviderId) => Promise<ModelInfo[]>;
+    authStatus: (id: ProviderId) => Promise<AuthStatus>;
+    logout: (id: ProviderId) => Promise<{
+        ok: boolean;
+    }>;
+    update: (id: ProviderId) => Promise<UpdateResult>;
+    listDirs: (path?: string) => Promise<DirListing>;
+    /** Streams login events. The first event is `{ type: "login", loginId }`. */
+    login: (id: ProviderId, signal?: AbortSignal) => AsyncGenerator<LoginStreamEvent, any, any>;
+    sendLoginCode: (loginId: string, code: string) => Promise<{
+        ok: boolean;
+    }>;
+    cancelLogin: (loginId: string) => Promise<{
+        ok: boolean;
+    }>;
+    /** Streams run events. The first event is `{ type: "run", runId }`, needed to answer approvals. */
+    run: (input: Pick<RunInput, "prompt" | "sessionId"> & {
+        selection: Selection;
+    }, signal?: AbortSignal) => AsyncGenerator<RunEvent, any, any>;
+    approve: (runId: string, approvalId: string, decision: ApprovalDecision) => Promise<{
+        ok: boolean;
+    }>;
+};
+type FunnelClient = ReturnType<typeof createClient>;
+
+export { ApprovalDecision, AuthStatus, type ClientOptions, type DirListing, type FunnelClient, FunnelEvent, LoginEvent, type LoginStreamEvent, ModelInfo, ProviderId, ProviderOverview, type RunEvent, RunInput, Selection, UpdateResult, createClient };

package/dist/client/index.js

@@ -0,0 +1,63 @@
+import {
+  ACCESS_LEVELS,
+  FunnelError
+} from "../chunk-YP5V5YEE.js";
+
+// src/client/index.ts
+function createClient(options) {
+  const doFetch = options.fetch ?? fetch;
+  const base = options.baseUrl.replace(/\/$/, "");
+  const headers = (extra) => ({
+    ...options.token ? { authorization: `Bearer ${options.token}` } : {},
+    ...extra
+  });
+  async function request(path, init) {
+    const res = await doFetch(base + path, { ...init, headers: headers({ "content-type": "application/json" }) });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(body.error ?? `HTTP ${res.status}`);
+    return body;
+  }
+  async function* events(path, body, signal) {
+    const res = await doFetch(base + path, {
+      method: "POST",
+      body: JSON.stringify(body),
+      signal,
+      headers: headers({ "content-type": "application/json" })
+    });
+    if (!res.ok || !res.body) throw new Error((await res.json().catch(() => ({}))).error ?? `HTTP ${res.status}`);
+    const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
+    let buffer = "";
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      buffer += value;
+      let i;
+      while ((i = buffer.indexOf("\n\n")) >= 0) {
+        const line = buffer.slice(0, i).trim();
+        buffer = buffer.slice(i + 2);
+        if (line.startsWith("data:")) yield JSON.parse(line.slice(5).trim());
+      }
+    }
+  }
+  const post = (path, body = {}) => request(path, { method: "POST", body: JSON.stringify(body) });
+  return {
+    providers: () => request("/providers"),
+    models: (id) => request(`/providers/${id}/models`),
+    authStatus: (id) => request(`/providers/${id}/auth`),
+    logout: (id) => post(`/providers/${id}/logout`),
+    update: (id) => request(`/providers/${id}/update`, { method: "POST", body: "{}" }),
+    listDirs: (path) => request(`/fs${path ? `?path=${encodeURIComponent(path)}` : ""}`),
+    /** Streams login events. The first event is `{ type: "login", loginId }`. */
+    login: (id, signal) => events(`/providers/${id}/login`, {}, signal),
+    sendLoginCode: (loginId, code) => post(`/logins/${loginId}/code`, { code }),
+    cancelLogin: (loginId) => post(`/logins/${loginId}/cancel`),
+    /** Streams run events. The first event is `{ type: "run", runId }`, needed to answer approvals. */
+    run: (input, signal) => events("/run", input, signal),
+    approve: (runId, approvalId, decision) => post(`/approvals/${runId}/${approvalId}`, { decision })
+  };
+}
+export {
+  ACCESS_LEVELS,
+  FunnelError,
+  createClient
+};