expandai 0.0.3 → 0.0.5

package/build/dts/Init/Service.d.ts

@@ -1,72 +0,0 @@
-import { DateTime, Effect, Schema } from 'effect';
-import { ManualAuthorization } from '../Auth/ManualAuthorization.js';
-import { SetupGrantAuthorization } from '../Auth/SetupGrantAuthorization.js';
-import { Authentication } from '../Authentication.js';
-import { type InitRequest } from './Domain.js';
-import { HarnessRegistry } from './HarnessRegistry.js';
-declare const InitServiceError_base: Schema.TaggedErrorClass<InitServiceError, "InitServiceError", {
-    readonly _tag: Schema.tag<"InitServiceError">;
-} & {
-    code: Schema.Literal<["authorization_failed", "setup_token_rejected", "setup_unreachable", "stored_credential_conflict", "authorization_unreachable", "authorization_denied", "authorization_refused", "credential_health_failed", "credential_save_failed", "credential_storage_insecure", "unsupported_harness", "inspection_failed", "configuration_failed", "policy_blocked", "invalid_adapter_result"]>;
-    recoverable: typeof Schema.Boolean;
-}>;
-export declare class InitServiceError extends InitServiceError_base {
-    get message(): "A managed harness policy blocks this configuration." | "An Expand API key is already stored on this machine, and completing setup would replace it with no way to recover it. Nothing was changed and the setup prompt is still valid. Tell the user to run `expandai logout` to clear the stored key, then run the same setup command again." | "Authorization completed, but credentials could not be saved. Start authorization again." | "Authorization could not be completed. Start authorization again." | "Could not reach Expand to redeem the setup token. Nothing was sent, so the same token is still good — check the network and run the same command again." | "Could not reach the Expand API. Nothing was changed: any pending authorization is still pending, and if none existed, none was started. Do not retry the same command until the connection is fixed. Check that this machine can reach the API — if you are running inside an agent sandbox, its shell may have network access disabled — and check `EXPAND_API_URL` if it is set. Then run the same command again." | "Credential storage is not secure enough to continue." | "Expand refused to complete the authorization for a reason a new code cannot fix — most likely an OAuth client, resource, or scope misconfiguration on the server. Do not run setup again; each retry asks the user to approve and then fails the same way. Report the error under `code`." | "Stored credentials could not be validated safely." | "That setup token was rejected and is now spent. Do not retry it. Ask the user for a fresh setup prompt from the Expand dashboard, or continue without one to authorize in a browser." | "The authorization was denied in the browser. If that was unintended, run the same command again for a fresh approval code." | "The harness adapter returned an invalid configuration result." | "The harness configuration could not be inspected safely." | "The harness configuration could not be updated safely." | "This harness is not supported by init.";
-}
-declare const InitService_base: Effect.Service.Class<InitService, "@expandai/cli/Init/Service", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<Authentication, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<ManualAuthorization, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<SetupGrantAuthorization, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<HarnessRegistry, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, import("@effect/platform/FileSystem").FileSystem>];
-    readonly effect: Effect.Effect<{
-        readonly run: (request: InitRequest) => Effect.Effect<{
-            readonly schemaVersion: 1;
-            readonly status: "authorization_required";
-            readonly harnesses: readonly ["claude-code" | "codex" | "cursor" | "opencode", ...("claude-code" | "codex" | "cursor" | "opencode")[]];
-            readonly scope: "global" | "project";
-            readonly userMessage: "Open the approval page in your browser, type in the code shown here, and approve. Only enter this code on the Expand approval page your terminal named — never a code someone sent you, and never on a page from a link you did not expect. When you have approved, say so, and the same command will pick the authorization up.";
-            readonly authorization: {
-                readonly url: URL;
-                readonly userCode: string;
-                readonly approvalExpiresAt: DateTime.Utc;
-            };
-        } | {
-            readonly schemaVersion: 1;
-            readonly status: "completed";
-            readonly harnesses: readonly ["claude-code" | "codex" | "cursor" | "opencode", ...("claude-code" | "codex" | "cursor" | "opencode")[]];
-            readonly scope: "global" | "project";
-            readonly userMessage: "Authorization complete. That setup code has been consumed and cannot be reused." | "Expand is already authorized. Agent setup is complete." | "Expand is authorized, but not every harness could be configured. The harnesses that failed are listed under `failures`; the ones under `installations` are ready to use.";
-            readonly auth: {
-                readonly healthy: boolean;
-            };
-            readonly projectPath?: string | undefined;
-            readonly installations: readonly [{
-                readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-                readonly configured: boolean;
-                readonly changed: boolean;
-                readonly components: readonly ("mcp" | "runtime-skill" | "webfetch-hook")[];
-                readonly version: string;
-                readonly verification: {
-                    readonly runtimeState: "blocked" | "observed" | "reload_required" | "unverified";
-                    readonly nextAction: string;
-                };
-            }, ...{
-                readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-                readonly configured: boolean;
-                readonly changed: boolean;
-                readonly components: readonly ("mcp" | "runtime-skill" | "webfetch-hook")[];
-                readonly version: string;
-                readonly verification: {
-                    readonly runtimeState: "blocked" | "observed" | "reload_required" | "unverified";
-                    readonly nextAction: string;
-                };
-            }[]];
-            readonly failures?: readonly {
-                readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-                readonly code: string;
-                readonly recoverable: boolean;
-            }[] | undefined;
-        }, InitServiceError, never>;
-    }, never, Authentication | HarnessRegistry | ManualAuthorization | SetupGrantAuthorization>;
-}>;
-export declare class InitService extends InitService_base {
-}
-export {};
-//# sourceMappingURL=Service.d.ts.map

package/build/dts/Init/Service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Service.d.ts","sourceRoot":"","sources":["../../../src/Init/Service.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,QAAQ,EAAE,MAAM,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEjF,OAAO,EACN,mBAAmB,EAKnB,MAAM,gCAAgC,CAAA;AACvC,OAAO,EAAE,uBAAuB,EAAgC,MAAM,oCAAoC,CAAA;AAC1G,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAErD,OAAO,EAKN,KAAK,WAAW,EAGhB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,eAAe,EAA+B,MAAM,sBAAsB,CAAA;;;;;;;AAoBnF,qBAAa,gBAAiB,SAAQ,qBAGpC;IACD,IAAI,OAAO,m9DA8CV;CACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsHD,qBAAa,WAAY,SAAQ,gBA6K/B;CAAG"}

package/build/dts/Init/StandardAdapters.d.ts

@@ -1,42 +0,0 @@
-import { FileSystem } from '@effect/platform';
-import { Effect } from 'effect';
-import { CodexMcp } from '../Install/Codex/Mcp.js';
-import { CodexSkill } from '../Install/Codex/Skill.js';
-import { CursorMcp } from '../Install/Cursor/Mcp.js';
-import { CursorSkill } from '../Install/Cursor/Skill.js';
-import { OpencodeHook } from '../Install/Opencode/Hook.js';
-import { OpencodeMcp } from '../Install/Opencode/Mcp.js';
-import { OpencodeSkill } from '../Install/Opencode/Skill.js';
-import { HarnessConfigurationError, type HarnessInspection, HarnessInspectionError } from './HarnessAdapter.js';
-declare const CursorAdapter_base: Effect.Service.Class<CursorAdapter, "@expandai/cli/Init/CursorAdapter", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<CursorMcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<CursorSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
-    readonly effect: Effect.Effect<{
-        readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-        readonly inspect: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessInspectionError, never>;
-        readonly configure: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessConfigurationError, never>;
-    }, never, CursorMcp | CursorSkill>;
-}>;
-export declare class CursorAdapter extends CursorAdapter_base {
-}
-declare const CodexAdapter_base: Effect.Service.Class<CodexAdapter, "@expandai/cli/Init/CodexAdapter", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<CodexMcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<CodexSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
-    readonly effect: Effect.Effect<{
-        readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-        readonly inspect: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessInspectionError, never>;
-        readonly configure: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessConfigurationError, never>;
-    }, never, CodexMcp | CodexSkill>;
-}>;
-export declare class CodexAdapter extends CodexAdapter_base {
-}
-declare const OpencodeAdapter_base: Effect.Service.Class<OpencodeAdapter, "@expandai/cli/Init/OpencodeAdapter", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<OpencodeHook, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<OpencodeMcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<OpencodeSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
-    readonly effect: Effect.Effect<{
-        readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-        readonly inspect: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessInspectionError, never>;
-        readonly configure: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessConfigurationError, never>;
-    }, never, FileSystem.FileSystem | OpencodeHook | OpencodeMcp | OpencodeSkill>;
-}>;
-export declare class OpencodeAdapter extends OpencodeAdapter_base {
-}
-export {};
-//# sourceMappingURL=StandardAdapters.d.ts.map

package/build/dts/Init/StandardAdapters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StandardAdapters.d.ts","sourceRoot":"","sources":["../../../src/Init/StandardAdapters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAG5D,OAAO,EAAE,yBAAyB,EAAE,KAAK,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;;;;;;;;;AAoD/G,qBAAa,aAAc,SAAQ,kBAuBjC;CAAG;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAuBhC;CAAG;;;;;;;;;AAEL,qBAAa,eAAgB,SAAQ,oBA0BnC;CAAG"}

package/build/dts/Init/Status.d.ts

@@ -1,149 +0,0 @@
-import { DateTime, Effect, Schema } from 'effect';
-import { PendingInitStore } from '../Auth/PendingInit.js';
-import { ConfigManager } from '../Config.js';
-import { HarnessRegistry } from './HarnessRegistry.js';
-declare const StatusRequest_base: Schema.Class<StatusRequest, {
-    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
-    scope: Schema.Literal<["project", "global"]>;
-}, Schema.Struct.Encoded<{
-    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
-    scope: Schema.Literal<["project", "global"]>;
-}>, never, {
-    readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-} & {
-    readonly scope: "global" | "project";
-}, {}, {}>;
-export declare class StatusRequest extends StatusRequest_base {
-}
-declare const StatusResult_base: Schema.Class<StatusResult, {
-    schemaVersion: Schema.Literal<[1]>;
-    status: Schema.Literal<["ok"]>;
-    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
-    scope: Schema.Literal<["project", "global"]>;
-    cli: Schema.Struct<{
-        version: Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>;
-    }>;
-    auth: Schema.Struct<{
-        state: Schema.Literal<["absent", "unusable", "refresh_required", "healthy"]>;
-        healthy: typeof Schema.Boolean;
-    }>;
-    pendingAuthorization: Schema.Union<[Schema.Struct<{
-        state: Schema.Literal<["none"]>;
-        count: Schema.Literal<[0]>;
-    }>, Schema.Struct<{
-        state: Schema.Literal<["approval_pending"]>;
-        count: Schema.Literal<[1]>;
-        approvalExpiresAt: typeof Schema.DateTimeUtc;
-    }>]>;
-    installation: Schema.Struct<{
-        configured: typeof Schema.Boolean;
-        integrationVersion: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>>;
-        components: Schema.Struct<{
-            webfetchHook: typeof Schema.Boolean;
-            runtimeSkill: typeof Schema.Boolean;
-            mcp: typeof Schema.Boolean;
-        }>;
-        runtimeState: Schema.Literal<["unverified", "reload_required", "blocked"]>;
-        reloadState: Schema.Literal<["not_required", "required"]>;
-        consentState: Schema.Literal<["not_required", "may_be_required"]>;
-        policyState: Schema.Literal<["unverified", "blocked"]>;
-        policyCodes: Schema.filter<Schema.Array$<Schema.Literal<["managed_policy_blocked", "target_read_only"]>>>;
-    }>;
-}, Schema.Struct.Encoded<{
-    schemaVersion: Schema.Literal<[1]>;
-    status: Schema.Literal<["ok"]>;
-    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
-    scope: Schema.Literal<["project", "global"]>;
-    cli: Schema.Struct<{
-        version: Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>;
-    }>;
-    auth: Schema.Struct<{
-        state: Schema.Literal<["absent", "unusable", "refresh_required", "healthy"]>;
-        healthy: typeof Schema.Boolean;
-    }>;
-    pendingAuthorization: Schema.Union<[Schema.Struct<{
-        state: Schema.Literal<["none"]>;
-        count: Schema.Literal<[0]>;
-    }>, Schema.Struct<{
-        state: Schema.Literal<["approval_pending"]>;
-        count: Schema.Literal<[1]>;
-        approvalExpiresAt: typeof Schema.DateTimeUtc;
-    }>]>;
-    installation: Schema.Struct<{
-        configured: typeof Schema.Boolean;
-        integrationVersion: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>>;
-        components: Schema.Struct<{
-            webfetchHook: typeof Schema.Boolean;
-            runtimeSkill: typeof Schema.Boolean;
-            mcp: typeof Schema.Boolean;
-        }>;
-        runtimeState: Schema.Literal<["unverified", "reload_required", "blocked"]>;
-        reloadState: Schema.Literal<["not_required", "required"]>;
-        consentState: Schema.Literal<["not_required", "may_be_required"]>;
-        policyState: Schema.Literal<["unverified", "blocked"]>;
-        policyCodes: Schema.filter<Schema.Array$<Schema.Literal<["managed_policy_blocked", "target_read_only"]>>>;
-    }>;
-}>, never, {
-    readonly auth: {
-        readonly state: "absent" | "healthy" | "refresh_required" | "unusable";
-        readonly healthy: boolean;
-    };
-} & {
-    readonly cli: {
-        readonly version: string;
-    };
-} & {
-    readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-} & {
-    readonly installation: {
-        readonly configured: boolean;
-        readonly integrationVersion?: string | undefined;
-        readonly components: {
-            readonly webfetchHook: boolean;
-            readonly runtimeSkill: boolean;
-            readonly mcp: boolean;
-        };
-        readonly runtimeState: "blocked" | "reload_required" | "unverified";
-        readonly reloadState: "not_required" | "required";
-        readonly consentState: "may_be_required" | "not_required";
-        readonly policyState: "blocked" | "unverified";
-        readonly policyCodes: readonly ("managed_policy_blocked" | "target_read_only")[];
-    };
-} & {
-    readonly pendingAuthorization: {
-        readonly state: "none";
-        readonly count: 0;
-    } | {
-        readonly state: "approval_pending";
-        readonly count: 1;
-        readonly approvalExpiresAt: DateTime.Utc;
-    };
-} & {
-    readonly schemaVersion: 1;
-} & {
-    readonly scope: "global" | "project";
-} & {
-    readonly status: "ok";
-}, {}, {}>;
-export declare class StatusResult extends StatusResult_base {
-}
-export declare const StatusServiceErrorCode: Schema.Literal<["credential_config_malformed", "credential_storage_insecure", "credential_health_failed", "pending_state_malformed", "pending_state_unavailable", "harness_inspection_failed", "invalid_status_result"]>;
-declare const StatusServiceError_base: Schema.TaggedErrorClass<StatusServiceError, "StatusServiceError", {
-    readonly _tag: Schema.tag<"StatusServiceError">;
-} & {
-    code: Schema.Literal<["credential_config_malformed", "credential_storage_insecure", "credential_health_failed", "pending_state_malformed", "pending_state_unavailable", "harness_inspection_failed", "invalid_status_result"]>;
-    recoverable: typeof Schema.Boolean;
-}>;
-export declare class StatusServiceError extends StatusServiceError_base {
-    get message(): "Credential storage is not secure enough to inspect." | "Local diagnostics returned an invalid result." | "Pending authorization state could not be inspected safely." | "Pending authorization state is malformed." | "Stored credential configuration is malformed." | "Stored credentials could not be inspected safely." | "The harness configuration could not be inspected safely.";
-}
-declare const StatusService_base: Effect.Service.Class<StatusService, "@expandai/cli/Init/StatusService", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<PendingInitStore, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<HarnessRegistry, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, import("@effect/platform/FileSystem").FileSystem>];
-    readonly effect: Effect.Effect<{
-        readonly run: (request: StatusRequest) => Effect.Effect<StatusResult, StatusServiceError, never>;
-    }, never, ConfigManager | HarnessRegistry | PendingInitStore>;
-}>;
-export declare class StatusService extends StatusService_base {
-}
-export {};
-//# sourceMappingURL=Status.d.ts.map

package/build/dts/Init/Status.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Status.d.ts","sourceRoot":"","sources":["../../../src/Init/Status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAOzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAEzD,OAAO,EAAE,aAAa,EAA+D,MAAM,cAAc,CAAA;AAKzG,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;;;;;;;;;;;;AAKtD,qBAAa,aAAc,SAAQ,kBAGjC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCL,qBAAa,YAAa,SAAQ,iBAShC;CAAG;AAEL,eAAO,MAAM,sBAAsB,0NAQlC,CAAA;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAGtC;IACD,IAAI,OAAO,8XAiBV;CACD;;;;;;;AAoGD,qBAAa,aAAc,SAAQ,kBAqDjC;CAAG"}

package/build/dts/Install/Claude/Hook.d.ts

@@ -1,120 +0,0 @@
-import { Effect, Schema } from 'effect';
-import { type CliCommand, ConfigIo } from '../Domain.js';
-/** Claude Code WebFetch hook invocation persisted in harness settings. */
-export declare const HOOK_INVOCATION = "expandai hook claude-code";
-export declare const HOOK_COMMAND = "expandai hook claude-code";
-/**
- * The hook line for a resolved CLI. Defaults to the bare `expandai` command;
- * when the CLI is not on PATH — an `npx expandai init` with no global install —
- * `CliInvocation` resolves to the npx form and the written hook stays runnable.
- */
-export declare function hookCommandFor(cli?: CliCommand): string;
-export declare const WEBFETCH_MATCHER = "WebFetch";
-export declare const HookCommandEntry: Schema.TypeLiteral<{
-    type: Schema.Literal<["command"]>;
-    command: typeof Schema.String;
-    expandaiProfileVersion: Schema.optional<typeof Schema.String>;
-    /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
-    expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
-}, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>;
-export declare const HookMatcher: Schema.TypeLiteral<{
-    matcher: Schema.optional<typeof Schema.String>;
-    hooks: Schema.Array$<Schema.TypeLiteral<{
-        type: Schema.Literal<["command"]>;
-        command: typeof Schema.String;
-        expandaiProfileVersion: Schema.optional<typeof Schema.String>;
-        /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
-        expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
-    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
-}, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>;
-declare const HooksSection: Schema.TypeLiteral<{
-    PreToolUse: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
-        matcher: Schema.optional<typeof Schema.String>;
-        hooks: Schema.Array$<Schema.TypeLiteral<{
-            type: Schema.Literal<["command"]>;
-            command: typeof Schema.String;
-            expandaiProfileVersion: Schema.optional<typeof Schema.String>;
-            /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
-            expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
-        }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
-    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>>;
-}, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>;
-export declare const SettingsSchema: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.TypeLiteral<{
-    hooks: Schema.optionalWith<Schema.TypeLiteral<{
-        PreToolUse: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
-            matcher: Schema.optional<typeof Schema.String>;
-            hooks: Schema.Array$<Schema.TypeLiteral<{
-                type: Schema.Literal<["command"]>;
-                command: typeof Schema.String;
-                expandaiProfileVersion: Schema.optional<typeof Schema.String>;
-                /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
-                expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
-            }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
-        }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>>;
-    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
-        default: () => typeof HooksSection.Type;
-    }>;
-    permissions: Schema.optional<Schema.TypeLiteral<{
-        deny: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
-}, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
-export interface ClaudeHookPlan {
-    readonly changed: boolean;
-    readonly settings: typeof SettingsSchema.Type;
-}
-export declare function isExpandaiHookCommand(command: string): boolean;
-/**
- * `expandaiManagedDeny` records whether *we* added `WebFetch` to
- * `permissions.deny`, so uninstall can tell our entry from an identical one the
- * user set first. A deny entry is a bare string with nowhere to carry that, and
- * "our hook is present" is not the same claim: installing over a settings file
- * that already denied `WebFetch` leaves the hook without us having written the
- * rule, and removing it then revokes a control its owner chose.
- */
-export declare function makeExpandaiMatcher(profileVersion: string, cli?: CliCommand, managedDeny?: boolean): typeof HookMatcher.Type;
-/** True only when our own hook entry says we wrote the deny rule. */
-export declare function expandaiOwnsWebFetchDeny(settings: typeof SettingsSchema.Type): boolean;
-export declare const expandaiMatcher: {
-    readonly [x: string]: unknown;
-    readonly matcher?: string | undefined;
-    readonly hooks: readonly {
-        readonly [x: string]: unknown;
-        readonly type: "command";
-        readonly command: string;
-        readonly expandaiProfileVersion?: string | undefined;
-        readonly expandaiManagedDeny?: boolean | undefined;
-    }[];
-};
-/**
- * Denying `WebFetch` removes it from the toolset rather than blocking it per call,
- * so the agent reaches for Expand's tool instead of being refused. That difference
- * is the whole point: a hook can only answer a WebFetch call with `deny`, which
- * Claude Code renders to the user as `Error:` on every single fetch.
- *
- * The hook stays installed as the fallback. With the deny rule in force WebFetch is
- * never called, so the hook never fires; if the rule is ever absent or overridden,
- * the hook still intercepts — with the red line, but correctly.
- */
-export declare function planClaudeWebFetchDeny(settings: typeof SettingsSchema.Type): ClaudeHookPlan;
-/**
- * Drops the `WebFetch` entry; anything else the user denied is left alone.
- *
- * A deny entry is a bare string with nowhere to record who wrote it, so this
- * cannot tell our rule from an identical one the user added themselves. The
- * caller supplies that evidence — see `uninstall`.
- */
-export declare function planClaudeWebFetchDenyRemoval(settings: typeof SettingsSchema.Type): ClaudeHookPlan;
-export declare function planClaudeHook(settings: typeof SettingsSchema.Type, profileVersion?: string, cli?: CliCommand): ClaudeHookPlan;
-export declare function planClaudeHookRemoval(settings: typeof SettingsSchema.Type): ClaudeHookPlan;
-declare const ClaudeHook_base: Effect.Service.Class<ClaudeHook, "@expandai/cli/Install/Claude/Hook", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<void, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, ConfigIo>;
-}>;
-export declare class ClaudeHook extends ClaudeHook_base {
-}
-export {};
-//# sourceMappingURL=Hook.d.ts.map

package/build/dts/Install/Claude/Hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Hook.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Hook.ts"],"names":[],"mappings":"AACA,OAAO,EAA0B,MAAM,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEtE,OAAO,EAAE,KAAK,UAAU,EAAE,QAAQ,EAA+B,MAAM,cAAc,CAAA;AAGrF,0EAA0E;AAC1E,eAAO,MAAM,eAAe,8BAA8B,CAAA;AAC1D,eAAO,MAAM,YAAY,8BAAkB,CAAA;AAG3C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,GAAE,UAAuB,GAAG,MAAM,CAEnE;AACD,eAAO,MAAM,gBAAgB,aAAa,CAAA;AAE1C,eAAO,MAAM,gBAAgB;;;;IAK3B,uFAAuF;;0EAIxF,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;QANtB,uFAAuF;;;0EAYxF,CAAA;AAED,QAAA,MAAM,YAAY;;;;;;;YAdhB,uFAAuF;;;;0EAiBxF,CAAA;AAOD,eAAO,MAAM,cAAc;;;;;;;;gBAxBzB,uFAAuF;;;;;uBA2BpB,OAAO,YAAY,CAAC,IAAI;;;;;2EAM5F,CAAA;AAED,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,cAAc,CAAC,IAAI,CAAA;CAC7C;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAW9D;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAClC,cAAc,EAAE,MAAM,EACtB,GAAG,GAAE,UAAuB,EAC5B,WAAW,UAAO,GAChB,OAAO,WAAW,CAAC,IAAI,CAYzB;AAED,qEAAqE;AACrE,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,OAAO,cAAc,CAAC,IAAI,GAAG,OAAO,CAItF;AAMD,eAAO,MAAM,eAAe;;;;;;;;;;CAAmC,CAAA;AAS/D;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,OAAO,cAAc,CAAC,IAAI,GAAG,cAAc,CAU3F;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,OAAO,cAAc,CAAC,IAAI,GAAG,cAAc,CAMlG;AAED,wBAAgB,cAAc,CAC7B,QAAQ,EAAE,OAAO,cAAc,CAAC,IAAI,EACpC,cAAc,GAAE,MAAoB,EACpC,GAAG,GAAE,UAAuB,GAC1B,cAAc,CA8BhB;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,OAAO,cAAc,CAAC,IAAI,GAAG,cAAc,CAY1F;;;;;;;;;AAED,qBAAa,UAAW,SAAQ,eAyE9B;CAAG"}

package/build/dts/Install/Claude/Mcp.d.ts

@@ -1,48 +0,0 @@
-import { Effect, Schema } from 'effect';
-import { type CliCommand, ConfigIo, McpParseError, McpServersConfigSchema, McpWriteError } from '../Domain.js';
-declare const Entry_base: Schema.Class<Entry, {
-    type: Schema.Literal<["stdio"]>;
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-}, Schema.Struct.Encoded<{
-    type: Schema.Literal<["stdio"]>;
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-}>, never, {
-    readonly env?: {
-        readonly [x: string]: string;
-    } | undefined;
-} & {
-    readonly args: readonly string[];
-} & {
-    readonly command: string;
-} & {
-    readonly type: "stdio";
-}, {}, {}>;
-/** Claude Code MCP descriptor stored under the Expand-owned server key. */
-export declare class Entry extends Entry_base {
-}
-export interface ClaudeMcpPlan {
-    readonly changed: boolean;
-    readonly config: typeof McpServersConfigSchema.Type;
-}
-/** Claude execs the descriptor directly, so `command`/`args` stay separate. */
-export declare function claudeMcpEntry(cli?: CliCommand): Entry;
-export declare const CLAUDE_MCP_ENTRY: Entry;
-export declare function planClaudeMcp(config: typeof McpServersConfigSchema.Type, cli?: CliCommand): ClaudeMcpPlan;
-export declare function planClaudeMcpRemoval(config: typeof McpServersConfigSchema.Type): ClaudeMcpPlan;
-declare const ClaudeMcp_base: Effect.Service.Class<ClaudeMcp, "@expandai/cli/Install/Claude/Mcp", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly isInstalled: (scope: "global" | "project") => Effect.Effect<boolean, McpParseError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, ConfigIo>;
-}>;
-export declare class ClaudeMcp extends ClaudeMcp_base {
-}
-export {};
-//# sourceMappingURL=Mcp.d.ts.map

package/build/dts/Install/Claude/Mcp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvE,OAAO,EACN,KAAK,UAAU,EACf,QAAQ,EAER,aAAa,EACb,sBAAsB,EACtB,aAAa,EAEb,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGrB,2EAA2E;AAC3E,qBAAa,KAAM,SAAQ,UAKzB;CAAG;AAEL,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,sBAAsB,CAAC,IAAI,CAAA;CACnD;AAID,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,GAAG,GAAE,UAAuB,GAAG,KAAK,CAOlE;AAED,eAAO,MAAM,gBAAgB,OAAmB,CAAA;AAqBhD,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,sBAAsB,CAAC,IAAI,EAAE,GAAG,GAAE,UAAuB,GAAG,aAAa,CAUrH;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,sBAAsB,CAAC,IAAI,GAAG,aAAa,CAM9F;;;;;;;;;;AAED,qBAAa,SAAU,SAAQ,cAiD7B;CAAG"}

package/build/dts/Install/Claude/Skill.d.ts

@@ -1,23 +0,0 @@
-import { FileSystem, Path } from '@effect/platform';
-import { Effect } from 'effect';
-export declare const SKILL_NAME = "expandai";
-export declare const SKILL_FILE_NAME = "SKILL.md";
-export interface ClaudeSkillPlan {
-    readonly changed: boolean;
-    readonly text: string;
-}
-export declare function renderClaudeSkill(source: string, profileVersion?: string): string;
-export declare function planClaudeSkill(current: string | undefined, source: string, profileVersion?: string): ClaudeSkillPlan;
-declare const ClaudeSkill_base: Effect.Service.Class<ClaudeSkill, "@expandai/cli/Install/Claude/Skill", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<Path.Path, never, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-        readonly source: () => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-    }, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, FileSystem.FileSystem | Path.Path>;
-}>;
-export declare class ClaudeSkill extends ClaudeSkill_base {
-}
-export {};
-//# sourceMappingURL=Skill.d.ts.map

package/build/dts/Install/Claude/Skill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAI9C,eAAO,MAAM,UAAU,aAAa,CAAA;AACpC,eAAO,MAAM,eAAe,aAAa,CAAA;AAGzC,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACrB;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,GAAE,MAAoB,GAAG,MAAM,CAK9F;AAED,wBAAgB,eAAe,CAC9B,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,MAAM,EAAE,MAAM,EACd,cAAc,GAAE,MAAoB,GAClC,eAAe,CAGjB;;;;;;;;;;AA2CD,qBAAa,WAAY,SAAQ,gBAG/B;CAAG"}

package/build/dts/Install/Codex/Mcp.d.ts

@@ -1,45 +0,0 @@
-import { Effect, Schema } from 'effect';
-import { CliInvocation, ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
-declare const Entry_base: Schema.Class<Entry, {
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-    enabled: typeof Schema.Boolean;
-}, Schema.Struct.Encoded<{
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-    enabled: typeof Schema.Boolean;
-}>, never, {
-    readonly env?: {
-        readonly [x: string]: string;
-    } | undefined;
-} & {
-    readonly args: readonly string[];
-} & {
-    readonly command: string;
-} & {
-    readonly enabled: boolean;
-}, {}, {}>;
-export declare class Entry extends Entry_base {
-}
-declare const CodexMcp_base: Effect.Service.Class<CodexMcp, "@expandai/cli/Install/Codex/Mcp", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>, import("effect/Layer").Layer<CliInvocation, import("effect/ConfigError").ConfigError, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError | import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError | import("@effect/platform/Error").PlatformError, never>;
-        readonly isInstalled: (scope: "global" | "project") => Effect.Effect<boolean, McpParseError | import("@effect/platform/Error").PlatformError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, CliInvocation | ConfigIo>;
-}>;
-/**
- * Codex MCP descriptor — Codex stores MCP servers in TOML config under
- * `[mcp_servers.<name>]`.
- *
- *   - global  → `~/.codex/config.toml`
- *   - project → `<cwd>/.codex/config.toml`
- */
-export declare class CodexMcp extends CodexMcp_base {
-}
-export {};
-//# sourceMappingURL=Mcp.d.ts.map

package/build/dts/Install/Codex/Mcp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Codex/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEvE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAc,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGhG,qBAAa,KAAM,SAAQ,UAKzB;CAAG;;;;;;;;;;AAgBL;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,aA+E5B;CAAG"}

package/build/dts/Install/Codex/Skill.d.ts

@@ -1,22 +0,0 @@
-import { Effect } from 'effect';
-import { SkillIo } from '../Domain.js';
-/**
- * Codex skills use the open agent skills locations:
- *
- *   - global  → `~/.agents/skills/<name>/`
- *   - project → `<cwd>/.agents/skills/<name>/`
- */
-export declare const SKILL_NAME = "expandai";
-declare const CodexSkill_base: Effect.Service.Class<CodexSkill, "@expandai/cli/Install/Codex/Skill", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<SkillIo, import("@effect/platform/Error").BadArgument, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly isCurrent: (scope: "global" | "project") => Effect.Effect<boolean, import("@effect/platform/Error").PlatformError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, SkillIo>;
-}>;
-export declare class CodexSkill extends CodexSkill_base {
-}
-export {};
-//# sourceMappingURL=Skill.d.ts.map

package/build/dts/Install/Codex/Skill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Codex/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGtC;;;;;GAKG;AAEH,eAAO,MAAM,UAAU,aAAa,CAAA;;;;;;;;;;AAEpC,qBAAa,UAAW,SAAQ,eA6B9B;CAAG"}

package/build/dts/Install/Cursor/Mcp.d.ts

@@ -1,45 +0,0 @@
-import { Effect, Schema } from 'effect';
-import { CliInvocation, ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
-declare const Entry_base: Schema.Class<Entry, {
-    type: Schema.Literal<["stdio"]>;
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-}, Schema.Struct.Encoded<{
-    type: Schema.Literal<["stdio"]>;
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-}>, never, {
-    readonly env?: {
-        readonly [x: string]: string;
-    } | undefined;
-} & {
-    readonly args: readonly string[];
-} & {
-    readonly command: string;
-} & {
-    readonly type: "stdio";
-}, {}, {}>;
-/**
- * Cursor MCP descriptor — same `mcpServers` shape as Claude Code, different
- * paths.
- *
- *   - global  → `~/.cursor/mcp.json`
- *   - project → `<cwd>/.cursor/mcp.json`
- */
-export declare class Entry extends Entry_base {
-}
-declare const CursorMcp_base: Effect.Service.Class<CursorMcp, "@expandai/cli/Install/Cursor/Mcp", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>, import("effect/Layer").Layer<CliInvocation, import("effect/ConfigError").ConfigError, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly isInstalled: (scope: "global" | "project") => Effect.Effect<boolean, McpParseError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, CliInvocation | ConfigIo>;
-}>;
-export declare class CursorMcp extends CursorMcp_base {
-}
-export {};
-//# sourceMappingURL=Mcp.d.ts.map

package/build/dts/Install/Cursor/Mcp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Cursor/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAA0B,aAAa,EAAc,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGxH;;;;;;GAMG;AACH,qBAAa,KAAM,SAAQ,UAKzB;CAAG;;;;;;;;;;AAEL,qBAAa,SAAU,SAAQ,cAiE7B;CAAG"}