expandai 0.0.0 → 0.0.2

package/README.md

@@ -1,15 +1,250 @@
-# ts-sdk
+# expandai
 
-To install dependencies:
+Unified CLI and MCP server for [ExpandAI](https://expand.ai). Fetch any URL as
+clean markdown, and wire ExpandAI into Claude Code, Cursor, OpenCode, or Codex
+as an MCP server, a runtime webfetch hook, or a skill.
+
+## Install
+
+```bash
+bun install -g expandai
+# or
+npm install -g expandai
+```
+
+The binary is published as `expandai`. One-off use without install:
+
+```bash
+bunx expandai fetch https://example.com
+```
+
+## Standalone binary
+
+A self-contained `expandai` executable is published with each release — no
+Node, Bun, or npm required at runtime. One command detects your platform,
+downloads the right binary from GitHub Releases, and drops it on your
+`PATH`:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/expandai/expandai-cli/main/install.sh | bash
+```
+
+Then:
+
+```bash
+expandai whoami
+```
+
+The binary bundles everything `expandai mcp run`, `expandai hook claude-code`,
+and `expandai hook opencode` need at runtime, so the MCP server and webfetch
+hooks work straight from `PATH` — no `node`/`bun` needed in your agent's
+environment.
+
+## Quick start
+
+```bash
+expandai login                                            # interactive auth
+expandai fetch https://docs.example.com/api               # full markdown
+expandai fetch https://docs.example.com/api --search auth # semantic snippets
+```
+
+## Supported harnesses
+
+| Harness     | MCP server | Webfetch hook | Skill |
+|-------------|:----------:|:-------------:|:-----:|
+| Claude Code |      ✓     |       ✓       |   ✓   |
+| OpenCode    |      ✓     |       ✓       |   ✓   |
+| Cursor      |      ✓     |       —       |   ✓   |
+| Codex       |      ✓     |       —       |   ✓   |
+
+**Pick one — each integration works standalone.** In rough preference order:
+
+1. **Hook** (Claude Code, OpenCode). `expandai hook install <host> <scope>`
+   — best invisible upgrade: every native web fetch the agent issues comes
+   back as ExpandAI markdown, no prompt changes required. Also wires the MCP
+   server in the same step. See [Recommended: `hook install`](#recommended-hook-install).
+2. **Skill** (all four harnesses). `expandai skill install <host> <scope>`
+   — lightest-weight: drops a `SKILL.md` that teaches the agent when to
+   reach for `expandai fetch`.
+3. **MCP server** (all four harnesses). `expandai mcp install <host> <scope>`
+   — exposes the full `fetch` API (snippets, screenshots, structured
+   extraction) as an MCP-callable tool.
+
+Combinations are fine — installing skill on top of hook, for example, nudges
+the agent to use `mcp__expandai__fetch` for refinement on top of the
+automatic substitution — but any single one is a complete setup.
+
+### Scopes
+
+Every `install` / `uninstall` command takes a `<scope>` argument: `global`
+or `project`.
+
+- `global` — written under your `$HOME`. Applies to every session of the
+  harness, regardless of where the agent is launched. Pick this if you want
+  ExpandAI on by default everywhere.
+- `project` — written under the current working directory. Applies only
+  when the harness is launched from inside that directory (or a
+  subdirectory). Pick this when you want different projects to opt in
+  independently, or when the integration should live in version control
+  alongside the project.
+
+The exact files each scope touches differ per harness and per integration —
+see the path comment next to each `install` line in the sections below.
+
+## Authentication
+
+```bash
+expandai login    # OAuth (browser device flow) or API key
+expandai whoami   # show current auth state
+expandai logout   # clear credentials and optionally remove installed integrations
+```
+
+Credentials are stored at `$XDG_CONFIG_HOME/expandai/config.json` (default
+`~/.config/expandai/config.json`, mode `0600`).
+
+Environment overrides:
+
+- `EXPAND_API_KEY` — overrides the stored auth method.
+- `EXPAND_API_URL` — overrides the API endpoint (defaults to `https://api.expand.ai`).
+
+## fetch
+
+`expandai fetch <url>` returns the rendered page as markdown. Handles
+JavaScript-heavy SPAs and bot-protected sites that plain `curl` can't read.
 
 ```bash
-bun install
+expandai fetch https://example.com                       # markdown (default)
+expandai fetch example.com                               # https:// is added automatically
+expandai fetch https://example.com --format json         # full response with metadata
+expandai fetch https://docs.example.com/api --search "authentication"
 ```
 
-To run:
+Flags:
+
+- `--format text|json` — output mode (default `text`).
+- `--search <query>` — semantic search. Returns relevant snippets instead of the full page.
+- `--max-results <n>` — snippet count when `--search` is set. Default `5`, max `50`.
+- `--min-score <n>` — minimum relevance score, `0`–`1`. Default `0.6`.
+
+## Recommended: `hook install`
+
+`expandai hook install <host> <scope>` is the ideal setup on harnesses that
+support it. One command, two effects:
+
+1. **Installs a runtime webfetch hook** that intercepts the agent's *native*
+   web-fetch tool and silently substitutes ExpandAI's markdown for whatever
+   the agent would have fetched on its own.
+2. **Registers the MCP server** at `<scope>` so the agent can also explicitly
+   call `mcp__expandai__fetch` for the full `select` API (markdown, snippets,
+   screenshot, links, JSON extraction, etc.).
 
 ```bash
-bun run index.ts
+expandai hook install claude-code global
+expandai hook install opencode    project
 ```
 
-This project was created using `bun init` in bun v1.1.4. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.
+**Scope behavior:** `global` writes to the harness's user settings
+(`~/.claude/settings.json` for Claude Code, `~/.config/opencode/plugins/` for
+OpenCode) — the substitution fires for every session of that harness on the
+machine. `project` writes to per-directory equivalents
+(`<cwd>/.claude/settings.json`, `<cwd>/.opencode/plugins/`) — the
+substitution only fires when the harness is launched from that directory.
+
+### Why both, not just one
+
+- The **runtime hook** makes the agent's native fetch path return ExpandAI
+  markdown automatically, so even agents that haven't been told about
+  expand.ai get clean rendered output for SPAs and bot-protected pages.
+  No prompt changes required.
+- The **MCP server alone** requires the agent to consciously choose
+  `mcp__expandai__fetch` over its built-in tool, which it usually won't
+  unless something nudges it (a skill, a prompt).
+- Together, default web access is upgraded transparently, and explicit
+  refinement (snippets, screenshots, structured extraction) is still one
+  MCP tool call away.
+
+### How the substitution actually works
+
+- **Claude Code** — `expandai hook install claude-code <scope>` writes a
+  `PreToolUse` matcher into `settings.json` that scopes to `WebFetch`. When
+  the agent invokes `WebFetch`, the runner reads the SDK's hook payload from
+  stdin, fetches the URL via expand.ai, and emits
+  `{ permissionDecision: "deny", additionalContext: <markdown> }`. The denial
+  blocks the native fetch; `additionalContext` is the documented channel for
+  injecting content into the model's next turn, so the markdown still reaches
+  the model in place of WebFetch's raw output.
+- **OpenCode** — `expandai hook install opencode <scope>` copies an
+  `expandai-webfetch.js` plugin into `.opencode/plugins/`. The plugin hooks
+  `tool.execute.after` on `webfetch`, shells out to `expandai hook opencode`
+  with the URL, and overwrites `output.output` with the returned markdown.
+  (`tool.execute.before` can only mutate args, not replace results, which is
+  why we run in `after`.)
+
+Cursor and Codex don't expose a hook system, so `hook install` only accepts
+`claude-code` and `opencode`. For those harnesses, use `skill install` +
+`mcp install` instead.
+
+## Skill
+
+The CLI ships a `SKILL.md` that teaches an agent when to reach for
+`expandai fetch`. `SKILL.md` is the open-standard format that Claude Code,
+Cursor, OpenCode, and Codex auto-discover for tool guidance.
+
+```bash
+expandai skill install claude-code global    # ~/.claude/skills/expandai/
+expandai skill install cursor      project   # <cwd>/.cursor/skills/expandai/
+expandai skill install opencode    global    # ~/.config/opencode/skills/expandai/
+expandai skill install codex       project   # <cwd>/.agents/skills/expandai/
+```
+
+**Scope behavior:** `global` drops `SKILL.md` into the harness's user-level
+skills directory, so the agent auto-discovers it in every session. `project`
+drops it into the cwd-level skills directory, so it's only discovered when
+the harness is launched from that directory — useful for committing the
+skill alongside a project so collaborators pick it up automatically.
+
+## MCP server
+
+`expandai mcp run` speaks MCP over stdio. Any MCP-aware client can call the
+`fetch` tool, which exposes the full `select` API (markdown, snippets,
+screenshot, links, JSON extraction, etc.).
+
+`hook install` already registers the MCP server on Claude Code and OpenCode,
+so this command is mostly for Cursor and Codex, or for installing the MCP
+server without the runtime hook:
+
+```bash
+expandai mcp install claude-code global    # ~/.claude.json
+expandai mcp install claude-code project   # <cwd>/.mcp.json
+expandai mcp install cursor      global    # ~/.cursor/mcp.json
+expandai mcp install cursor      project   # <cwd>/.cursor/mcp.json
+expandai mcp install opencode    global    # ~/.config/opencode/opencode.json
+expandai mcp install opencode    project   # <cwd>/opencode.json
+expandai mcp install codex       global    # ~/.codex/config.toml
+expandai mcp install codex       project   # <cwd>/.codex/config.toml
+```
+
+**Scope behavior:** `global` writes the `expandai` entry to the harness's
+user-level MCP config — the server is discoverable in every session.
+`project` writes to the per-directory MCP config — the server is only
+discoverable when the harness is launched from that directory, and the
+config file is well-suited for checking into version control.
+
+`expandai mcp uninstall <host> <scope>` removes the entry without touching
+other servers in the same config file.
+
+## Uninstall
+
+```bash
+expandai uninstall                          # everything across every host and scope
+expandai uninstall hook                     # all hooks (claude-code + opencode)
+expandai uninstall mcp cursor global        # just the Cursor global MCP entry
+expandai uninstall skill                    # all skills across all hosts and scopes
+```
+
+`expandai logout` also offers an interactive multi-select cleanup when run in
+a TTY.
+
+## License
+
+Apache-2.0. See `LICENSE`.

package/build/dts/ApiClient.d.ts

@@ -0,0 +1,231 @@
+import { HttpClient } from '@effect/platform';
+import * as Generated from '@expandai/sdk/Generated';
+import { Effect, Schema } from 'effect';
+import { BrowserOAuthService } from './BrowserOAuth.js';
+import { ConfigManager, OAuthTokenExpired } from './Config.js';
+declare const ApiRequestFailed_base: Schema.TaggedErrorClass<ApiRequestFailed, "ApiRequestFailed", {
+    readonly _tag: Schema.tag<"ApiRequestFailed">;
+} & {
+    detail: typeof Schema.String;
+}>;
+/**
+ * Single user-facing error for any failure crossing the API boundary. The
+ * generated client raises a half-dozen status-specific tagged classes plus
+ * transport/decode errors; we collapse them here so the rest of the app sees
+ * one tag with a ready-made `.message` and never has to know about
+ * `Generated.ts` types.
+ */
+export declare class ApiRequestFailed extends ApiRequestFailed_base {
+    get message(): string;
+}
+declare const OAuthAuthMethodChanged_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "OAuthAuthMethodChanged";
+} & Readonly<A>;
+declare class OAuthAuthMethodChanged extends OAuthAuthMethodChanged_base<Record<string, never>> {
+}
+declare const ApiClient_base: Effect.Service.Class<ApiClient, "@expandai/cli/ApiClient", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<HttpClient.HttpClient, never, never>, import("effect/Layer").Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<BrowserOAuthService, import("effect/ConfigError").ConfigError, never>];
+    readonly scoped: Effect.Effect<{
+        readonly fetchFetch: (options: {
+            readonly params: {
+                readonly include?: string | null | undefined;
+            };
+            readonly payload: {
+                readonly url: string;
+                readonly search?: {
+                    readonly query: string;
+                    readonly maxResults?: number | null | undefined;
+                    readonly minScore?: number | null | undefined;
+                } | null | undefined;
+                readonly include?: {
+                    readonly response?: {
+                        readonly includeHeaders?: boolean | null | undefined;
+                    } | null | undefined;
+                    readonly meta?: boolean | null | undefined;
+                    readonly markdown?: boolean | {
+                        readonly [x: string]: unknown;
+                    } | null | undefined;
+                    readonly json?: boolean | null | undefined;
+                    readonly appendix?: boolean | null | undefined;
+                    readonly links?: boolean | {
+                        readonly sameDomainOnly?: boolean | null | undefined;
+                        readonly includePatterns?: readonly string[] | null | undefined;
+                        readonly excludePatterns?: readonly string[] | null | undefined;
+                    } | null | undefined;
+                    readonly screenshot?: boolean | {
+                        readonly fullPage?: boolean | null | undefined;
+                    } | null | undefined;
+                    readonly html?: boolean | {
+                        readonly [x: string]: unknown;
+                    } | null | undefined;
+                    readonly summary?: boolean | {
+                        readonly prompt?: string | null | undefined;
+                    } | null | undefined;
+                } | null | undefined;
+                readonly browserConfig?: {
+                    readonly scrollFullPage?: boolean | null | undefined;
+                } | null | undefined;
+            };
+        }) => Effect.Effect<string, import("./Config.js").ConfigNotWritable | import("./Config.js").ConfigParseError | import("./Config.js").NotAuthenticated | OAuthTokenExpired | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("./BrowserOAuth.js").BrowserOAuthRequestFailed | ApiRequestFailed | OAuthAuthMethodChanged, never>;
+        readonly fetchFetchResult: (options: {
+            readonly params: {
+                readonly include?: string | null | undefined;
+            };
+            readonly payload: {
+                readonly url: string;
+                readonly search?: {
+                    readonly query: string;
+                    readonly maxResults?: number | null | undefined;
+                    readonly minScore?: number | null | undefined;
+                } | null | undefined;
+                readonly include?: {
+                    readonly response?: {
+                        readonly includeHeaders?: boolean | null | undefined;
+                    } | null | undefined;
+                    readonly meta?: boolean | null | undefined;
+                    readonly markdown?: boolean | {
+                        readonly [x: string]: unknown;
+                    } | null | undefined;
+                    readonly json?: boolean | null | undefined;
+                    readonly appendix?: boolean | null | undefined;
+                    readonly links?: boolean | {
+                        readonly sameDomainOnly?: boolean | null | undefined;
+                        readonly includePatterns?: readonly string[] | null | undefined;
+                        readonly excludePatterns?: readonly string[] | null | undefined;
+                    } | null | undefined;
+                    readonly screenshot?: boolean | {
+                        readonly fullPage?: boolean | null | undefined;
+                    } | null | undefined;
+                    readonly html?: boolean | {
+                        readonly [x: string]: unknown;
+                    } | null | undefined;
+                    readonly summary?: boolean | {
+                        readonly prompt?: string | null | undefined;
+                    } | null | undefined;
+                } | null | undefined;
+                readonly browserConfig?: {
+                    readonly scrollFullPage?: boolean | null | undefined;
+                } | null | undefined;
+            };
+        }) => Effect.Effect<import("@expandai/sdk/FetchJson").FetchObjectModeResultWithJson, import("./Config.js").ConfigNotWritable | import("./Config.js").ConfigParseError | import("./Config.js").NotAuthenticated | OAuthTokenExpired | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("./BrowserOAuth.js").BrowserOAuthRequestFailed | ApiRequestFailed | OAuthAuthMethodChanged, never>;
+        readonly fetchFetchJson: (options: {
+            readonly params: {
+                readonly include?: string | null | undefined;
+            };
+            readonly payload: {
+                readonly url: string;
+                readonly search?: {
+                    readonly query: string;
+                    readonly maxResults?: number | null | undefined;
+                    readonly minScore?: number | null | undefined;
+                } | null | undefined;
+                readonly include?: {
+                    readonly response?: {
+                        readonly includeHeaders?: boolean | null | undefined;
+                    } | null | undefined;
+                    readonly meta?: boolean | null | undefined;
+                    readonly markdown?: boolean | {
+                        readonly [x: string]: unknown;
+                    } | null | undefined;
+                    readonly json?: boolean | null | undefined;
+                    readonly appendix?: boolean | null | undefined;
+                    readonly links?: boolean | {
+                        readonly sameDomainOnly?: boolean | null | undefined;
+                        readonly includePatterns?: readonly string[] | null | undefined;
+                        readonly excludePatterns?: readonly string[] | null | undefined;
+                    } | null | undefined;
+                    readonly screenshot?: boolean | {
+                        readonly fullPage?: boolean | null | undefined;
+                    } | null | undefined;
+                    readonly html?: boolean | {
+                        readonly [x: string]: unknown;
+                    } | null | undefined;
+                    readonly summary?: boolean | {
+                        readonly prompt?: string | null | undefined;
+                    } | null | undefined;
+                } | null | undefined;
+                readonly browserConfig?: {
+                    readonly scrollFullPage?: boolean | null | undefined;
+                } | null | undefined;
+            };
+        }) => Effect.Effect<import("@expandai/sdk/FetchJson").FetchObjectModeResultWithJson, import("./Config.js").ConfigNotWritable | import("./Config.js").ConfigParseError | import("./Config.js").NotAuthenticated | OAuthTokenExpired | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("./BrowserOAuth.js").BrowserOAuthRequestFailed | ApiRequestFailed | OAuthAuthMethodChanged, never>;
+        readonly fetchFetchSearch: (options: {
+            readonly search: {
+                readonly query: string;
+                readonly maxResults?: number | null | undefined;
+                readonly minScore?: number | null | undefined;
+            };
+            readonly snapshotId: string;
+            readonly include?: {
+                readonly response?: {
+                    readonly includeHeaders?: boolean | null | undefined;
+                } | null | undefined;
+                readonly meta?: boolean | null | undefined;
+                readonly markdown?: boolean | {
+                    readonly [x: string]: unknown;
+                } | null | undefined;
+                readonly json?: boolean | null | undefined;
+                readonly appendix?: boolean | null | undefined;
+                readonly links?: boolean | {
+                    readonly sameDomainOnly?: boolean | null | undefined;
+                    readonly includePatterns?: readonly string[] | null | undefined;
+                    readonly excludePatterns?: readonly string[] | null | undefined;
+                } | null | undefined;
+                readonly screenshot?: boolean | {
+                    readonly fullPage?: boolean | null | undefined;
+                } | null | undefined;
+                readonly html?: boolean | {
+                    readonly [x: string]: unknown;
+                } | null | undefined;
+                readonly summary?: boolean | {
+                    readonly prompt?: string | null | undefined;
+                } | null | undefined;
+            } | null | undefined;
+        }) => Effect.Effect<import("@expandai/sdk/FetchJson").FetchSnapshotSearchResultWithJson, import("./Config.js").ConfigNotWritable | import("./Config.js").ConfigParseError | import("./Config.js").NotAuthenticated | OAuthTokenExpired | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("./BrowserOAuth.js").BrowserOAuthRequestFailed | ApiRequestFailed | OAuthAuthMethodChanged, never>;
+        readonly fetchBatched: (options: {
+            readonly urls: readonly [string, ...string[]];
+            readonly include?: {
+                readonly response?: {
+                    readonly includeHeaders?: boolean | null | undefined;
+                } | null | undefined;
+                readonly meta?: boolean | null | undefined;
+                readonly markdown?: boolean | {
+                    readonly [x: string]: unknown;
+                } | null | undefined;
+                readonly json?: boolean | null | undefined;
+                readonly appendix?: boolean | null | undefined;
+                readonly links?: boolean | {
+                    readonly sameDomainOnly?: boolean | null | undefined;
+                    readonly includePatterns?: readonly string[] | null | undefined;
+                    readonly excludePatterns?: readonly string[] | null | undefined;
+                } | null | undefined;
+                readonly screenshot?: boolean | {
+                    readonly fullPage?: boolean | null | undefined;
+                } | null | undefined;
+                readonly html?: boolean | {
+                    readonly [x: string]: unknown;
+                } | null | undefined;
+                readonly summary?: boolean | {
+                    readonly prompt?: string | null | undefined;
+                } | null | undefined;
+            } | null | undefined;
+            readonly browserConfig?: {
+                readonly scrollFullPage?: boolean | null | undefined;
+            } | null | undefined;
+        }) => Effect.Effect<Generated.BatchedRun, import("./Config.js").ConfigNotWritable | import("./Config.js").ConfigParseError | import("./Config.js").NotAuthenticated | OAuthTokenExpired | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("./BrowserOAuth.js").BrowserOAuthRequestFailed | ApiRequestFailed | OAuthAuthMethodChanged, never>;
+        readonly fetchGetBatched: (id: string, options: {
+            readonly include?: string | null | undefined;
+            readonly limit?: string | null | undefined;
+            readonly offset?: string | null | undefined;
+        }) => Effect.Effect<Generated.BatchedStatus, import("./Config.js").ConfigNotWritable | import("./Config.js").ConfigParseError | import("./Config.js").NotAuthenticated | OAuthTokenExpired | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("./BrowserOAuth.js").BrowserOAuthRequestFailed | ApiRequestFailed | OAuthAuthMethodChanged, never>;
+    }, never, ConfigManager | BrowserOAuthService | HttpClient.HttpClient>;
+}>;
+/**
+ * Resolves outgoing API auth per call. When the current request scope carries
+ * an `Authorization` header (via `CurrentRequestHeaders`), that value is
+ * forwarded; otherwise auth comes from `~/.config/expandai/config.json`.
+ */
+export declare class ApiClient extends ApiClient_base {
+}
+export {};
+//# sourceMappingURL=ApiClient.d.ts.map

package/build/dts/ApiClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiClient.d.ts","sourceRoot":"","sources":["../../src/ApiClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAyC,MAAM,kBAAkB,CAAA;AAGpF,OAAO,KAAK,SAAS,MAAM,yBAAyB,CAAA;AAEpD,OAAO,EAA4B,MAAM,EAAiC,MAAM,EAAE,MAAM,QAAQ,CAAA;AAChG,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,EAAE,aAAa,EAAe,iBAAiB,EAAE,MAAM,aAAa,CAAA;;;;;;AAG3E;;;;;;GAMG;AACH,qBAAa,gBAAiB,SAAQ,qBAEpC;IACD,IAAI,OAAO,WAEV;CACD;;;;AAcD,cAAM,sBAAuB,SAAQ,4BAA2C,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DzG;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAwJ7B;CAAG"}

package/build/dts/Authentication.d.ts

@@ -0,0 +1,23 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { BrowserOAuthService } from './BrowserOAuth.js';
+import { ApiKeyConfig, ConfigManager, OAuthConfig } from './Config.js';
+import { Uninstall } from './Install/Uninstall.js';
+type AuthMethod = typeof ApiKeyConfig.Type | typeof OAuthConfig.Type;
+/** Render a user-facing description of the current auth state. Pure given DateTime.now. */
+export declare const formatAuthStatus: (authMethod: AuthMethod) => Effect.Effect<string, never, never>;
+declare const Authentication_base: Effect.Service.Class<Authentication, "@expandai/cli/Authentication", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<BrowserOAuthService, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<Uninstall, import("effect/ConfigError").ConfigError | import("@effect/platform/Error").BadArgument, never>];
+    readonly effect: Effect.Effect<{
+        readonly login: () => Effect.Effect<void, unknown, import("@effect/platform/Terminal").Terminal>;
+        readonly whoami: () => Effect.Effect<void, import("./Config.js").ConfigParseError | import("./Config.js").NotAuthenticated | import("effect/ConfigError").ConfigError | import("@effect/platform/Error").PlatformError, never>;
+        readonly logout: () => Effect.Effect<void, import("./Config.js").ConfigNotWritable | import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("./Install/Domain.js").McpParseError | import("./Install/Domain.js").McpWriteError | import("@effect/platform/Terminal").QuitException, import("@effect/platform/Terminal").Terminal>;
+    }, never, ConfigManager | BrowserOAuthService | Uninstall>;
+}>;
+export declare class Authentication extends Authentication_base {
+}
+export declare const LoginCommand: Command.Command<"login", Authentication | import("@effect/platform/Terminal").Terminal, unknown, {}>;
+export declare const WhoamiCommand: Command.Command<"whoami", Authentication, import("./Config.js").ConfigParseError | import("./Config.js").NotAuthenticated | import("effect/ConfigError").ConfigError | import("@effect/platform/Error").PlatformError, {}>;
+export declare const LogoutCommand: Command.Command<"logout", Authentication | import("@effect/platform/Terminal").Terminal, import("./Config.js").ConfigNotWritable | import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("./Install/Domain.js").McpParseError | import("./Install/Domain.js").McpWriteError | import("@effect/platform/Terminal").QuitException, {}>;
+export {};
+//# sourceMappingURL=Authentication.d.ts.map

package/build/dts/Authentication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Authentication.d.ts","sourceRoot":"","sources":["../../src/Authentication.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,aAAa,CAAA;AAC7C,OAAO,EAA+B,MAAM,EAAiC,MAAM,QAAQ,CAAA;AAE3F,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,EAAU,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9E,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAElD,KAAK,UAAU,GAAG,OAAO,YAAY,CAAC,IAAI,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEpE,2FAA2F;AAC3F,eAAO,MAAM,gBAAgB,iEAe3B,CAAA;;;;;;;;;AAEF,qBAAa,cAAe,SAAQ,mBAyHlC;CAAG;AAEL,eAAO,MAAM,YAAY,sGAGxB,CAAA;AAED,eAAO,MAAM,aAAa,4NAGzB,CAAA;AAED,eAAO,MAAM,aAAa,kXAGzB,CAAA"}

package/build/dts/BrowserOAuth.d.ts

@@ -0,0 +1,99 @@
+import { HttpClient } from '@effect/platform';
+import { Duration, Effect, Schema } from 'effect';
+import { ConfigManager } from './Config.js';
+declare const TokenResponse_base: Schema.Class<TokenResponse, {
+    access_token: typeof Schema.String;
+    refresh_token: Schema.optional<typeof Schema.String>;
+    expires_in: Schema.transform<typeof Schema.Number, typeof Schema.DurationFromSelf>;
+    token_type: typeof Schema.String;
+    scope: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    access_token: typeof Schema.String;
+    refresh_token: Schema.optional<typeof Schema.String>;
+    expires_in: Schema.transform<typeof Schema.Number, typeof Schema.DurationFromSelf>;
+    token_type: typeof Schema.String;
+    scope: Schema.optional<typeof Schema.String>;
+}>, never, {
+    readonly access_token: string;
+} & {
+    readonly expires_in: Duration.Duration;
+} & {
+    readonly token_type: string;
+} & {
+    readonly refresh_token?: string | undefined;
+} & {
+    readonly scope?: string | undefined;
+}, {}, {}>;
+export declare class TokenResponse extends TokenResponse_base {
+}
+declare const BrowserOAuthRequestFailed_base: Schema.TaggedErrorClass<BrowserOAuthRequestFailed, "BrowserOAuthRequestFailed", {
+    readonly _tag: Schema.tag<"BrowserOAuthRequestFailed">;
+} & {
+    endpoint: typeof Schema.String;
+    error: typeof Schema.Defect;
+    status: Schema.optional<typeof Schema.Number>;
+}>;
+export declare class BrowserOAuthRequestFailed extends BrowserOAuthRequestFailed_base {
+    get message(): string;
+}
+declare const BrowserOAuthCallbackError_base: Schema.TaggedErrorClass<BrowserOAuthCallbackError, "BrowserOAuthCallbackError", {
+    readonly _tag: Schema.tag<"BrowserOAuthCallbackError">;
+} & {
+    error: typeof Schema.String;
+    errorDescription: Schema.optional<typeof Schema.String>;
+}>;
+export declare class BrowserOAuthCallbackError extends BrowserOAuthCallbackError_base {
+    get message(): string;
+}
+declare const BrowserOAuthMissingCode_base: Schema.TaggedErrorClass<BrowserOAuthMissingCode, "BrowserOAuthMissingCode", {
+    readonly _tag: Schema.tag<"BrowserOAuthMissingCode">;
+}>;
+export declare class BrowserOAuthMissingCode extends BrowserOAuthMissingCode_base {
+    get message(): string;
+}
+declare const BrowserOAuthStateMismatch_base: Schema.TaggedErrorClass<BrowserOAuthStateMismatch, "BrowserOAuthStateMismatch", {
+    readonly _tag: Schema.tag<"BrowserOAuthStateMismatch">;
+}>;
+export declare class BrowserOAuthStateMismatch extends BrowserOAuthStateMismatch_base {
+    get message(): string;
+}
+declare const BrowserOAuthLoopbackFailed_base: Schema.TaggedErrorClass<BrowserOAuthLoopbackFailed, "BrowserOAuthLoopbackFailed", {
+    readonly _tag: Schema.tag<"BrowserOAuthLoopbackFailed">;
+} & {
+    error: typeof Schema.Defect;
+}>;
+export declare class BrowserOAuthLoopbackFailed extends BrowserOAuthLoopbackFailed_base {
+    get message(): string;
+}
+declare const BrowserOAuthTimedOut_base: Schema.TaggedErrorClass<BrowserOAuthTimedOut, "BrowserOAuthTimedOut", {
+    readonly _tag: Schema.tag<"BrowserOAuthTimedOut">;
+}>;
+export declare class BrowserOAuthTimedOut extends BrowserOAuthTimedOut_base {
+    get message(): string;
+}
+interface AuthorizeUrlInput {
+    readonly apiUrl: URL;
+    readonly redirectUri: URL;
+    readonly state: string;
+    readonly codeChallenge: string;
+}
+interface ExchangeCodeInput {
+    readonly code: string;
+    readonly redirectUri: URL;
+    readonly codeVerifier: string;
+}
+export declare const createCodeChallenge: (codeVerifier: string) => Effect.Effect<string, never, never>;
+export declare const buildAuthorizeUrl: (args_0: AuthorizeUrlInput) => Effect.Effect<URL, never, never>;
+declare const BrowserOAuthService_base: Effect.Service.Class<BrowserOAuthService, "@expandai/cli/BrowserOAuthService", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<HttpClient.HttpClient, never, never>, import("effect/Layer").Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>];
+    readonly effect: Effect.Effect<{
+        readonly exchangeCode: (args_0: ExchangeCodeInput) => Effect.Effect<TokenResponse, import("./Config.js").ConfigParseError | import("effect/ConfigError").ConfigError | import("@effect/platform/Error").PlatformError | BrowserOAuthRequestFailed, never>;
+        readonly refreshToken: (refreshToken: string) => Effect.Effect<TokenResponse, import("./Config.js").ConfigParseError | import("effect/ConfigError").ConfigError | import("@effect/platform/Error").PlatformError | BrowserOAuthRequestFailed, never>;
+        readonly saveToken: (tokenResponse: TokenResponse) => Effect.Effect<void, import("./Config.js").ConfigNotWritable | import("effect/ParseResult").ParseError, never>;
+        readonly login: <R>(openAuthorizeUrl: (authorizeUrl: URL) => Effect.Effect<void, unknown, R>) => Effect.Effect<undefined, unknown, R>;
+    }, never, ConfigManager | HttpClient.HttpClient>;
+}>;
+export declare class BrowserOAuthService extends BrowserOAuthService_base {
+}
+export {};
+//# sourceMappingURL=BrowserOAuth.d.ts.map

package/build/dts/BrowserOAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserOAuth.d.ts","sourceRoot":"","sources":["../../src/BrowserOAuth.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAyC,MAAM,kBAAkB,CAAA;AAEpF,OAAO,EAAY,QAAQ,EAAE,MAAM,EAAyB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAClF,OAAO,EAAE,aAAa,EAAe,MAAM,aAAa,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAexD,qBAAa,aAAc,SAAQ,kBAMjC;CAAG;;;;;;;;AAEL,qBAAa,yBAA0B,SAAQ,8BAO9C;IACA,IAAI,OAAO,WAEV;CACD;;;;;;;AAED,qBAAa,yBAA0B,SAAQ,8BAM9C;IACA,IAAI,OAAO,WAEV;CACD;;;;AAED,qBAAa,uBAAwB,SAAQ,4BAG5C;IACA,IAAI,OAAO,WAEV;CACD;;;;AAED,qBAAa,yBAA0B,SAAQ,8BAG9C;IACA,IAAI,OAAO,WAEV;CACD;;;;;;AAED,qBAAa,0BAA2B,SAAQ,+BAK/C;IACA,IAAI,OAAO,WAEV;CACD;;;;AAED,qBAAa,oBAAqB,SAAQ,yBAAsE;IAC/G,IAAI,OAAO,WAEV;CACD;AAID,UAAU,iBAAiB;IAC1B,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAA;IACpB,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;CAC9B;AAED,UAAU,iBAAiB;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAA;IACzB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAC7B;AAgBD,eAAO,MAAM,mBAAmB,+DAE9B,CAAA;AAEF,eAAO,MAAM,iBAAiB,iEAe5B,CAAA;;;;;;;yBA6LgE,CAAC,mCAC/B,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;;;AAhF3E,qBAAa,mBAAoB,SAAQ,wBAkHvC;CAAG"}

package/build/dts/Commands/Fetch.d.ts

@@ -0,0 +1,30 @@
+import { Command, HelpDoc } from '@effect/cli';
+import { Effect, Option, Schema } from 'effect';
+declare const MarkdownUnavailable_base: Schema.TaggedErrorClass<MarkdownUnavailable, "MarkdownUnavailable", {
+    readonly _tag: Schema.tag<"MarkdownUnavailable">;
+} & {
+    url: typeof Schema.String;
+}>;
+export declare class MarkdownUnavailable extends MarkdownUnavailable_base {
+    get message(): string;
+}
+declare const SnippetsUnavailable_base: Schema.TaggedErrorClass<SnippetsUnavailable, "SnippetsUnavailable", {
+    readonly _tag: Schema.tag<"SnippetsUnavailable">;
+} & {
+    url: typeof Schema.String;
+    query: typeof Schema.String;
+}>;
+export declare class SnippetsUnavailable extends SnippetsUnavailable_base {
+    get message(): string;
+}
+export declare const parseUrlArg: (raw: string) => Effect.Effect<URL, HelpDoc.HelpDoc, never>;
+interface FetchCommandConfig {
+    readonly url: URL;
+    readonly format: 'text' | 'json';
+    readonly search: Option.Option<string>;
+    readonly maxResults: number;
+    readonly minScore: number;
+}
+export declare const FetchCommand: Command.Command<'fetch', never, unknown, FetchCommandConfig>;
+export {};
+//# sourceMappingURL=Fetch.d.ts.map