@vidit19sharma/opencode-cursor-auth 0.1.0 → 0.3.1

package/dist/index.d.ts

@@ -1,3 +1 @@
-import type { Plugin } from "@opencode-ai/plugin";
-export declare const CursorAuthPlugin: Plugin;
-export default CursorAuthPlugin;
+export { CursorAuthPlugin as default } from "./plugin.js";

package/dist/index.js

@@ -1,128 +1,3 @@
-import { Cursor } from "@cursor/sdk";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { handleChatCompletion } from "./bridge.js";
-const BASE_URL = "http://cursor.local/v1";
-const CACHE_DIR = join(homedir(), ".cache", "opencode-cursor-auth");
-const MODELS_CACHE_PATH = join(CACHE_DIR, "models.json");
-const MODELS_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
-function loadCachedModels() {
-    try {
-        const raw = JSON.parse(readFileSync(MODELS_CACHE_PATH, "utf8"));
-        if (raw?.version === 1 && raw.models && Object.keys(raw.models).length > 0)
-            return raw;
-    }
-    catch {
-        // no cache yet, or unreadable — fall back
-    }
-    return undefined;
-}
-// Live model list from Cursor, cached 24h to keep opencode startup fast.
-// Offline/logged-out: stale cache if present, else just "auto" (Cursor's universal alias).
-async function currentModels() {
-    const cached = loadCachedModels();
-    if (cached && Date.now() - cached.fetchedAt <= MODELS_CACHE_TTL_MS)
-        return cached.models;
-    try {
-        const list = await Cursor.models.list();
-        const models = {};
-        for (const m of list)
-            models[m.id === "default" ? "auto" : m.id] = m.displayName ?? m.id;
-        mkdirSync(CACHE_DIR, { recursive: true });
-        writeFileSync(MODELS_CACHE_PATH, JSON.stringify({ version: 1, fetchedAt: Date.now(), models }));
-        return models;
-    }
-    catch {
-        return cached?.models ?? { auto: "Auto" };
-    }
-}
-async function bodyText(input, init) {
-    const b = init?.body;
-    if (typeof b === "string")
-        return b;
-    if (b instanceof Uint8Array)
-        return new TextDecoder().decode(b);
-    if (input instanceof Request)
-        return input.text();
-    return "";
-}
-let pastedApiKey;
-async function cursorFetch(input, init) {
-    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-    if (url.includes("/chat/completions")) {
-        const body = JSON.parse(await bodyText(input, init));
-        return handleChatCompletion(body, pastedApiKey);
-    }
-    if (url.includes("/models")) {
-        return Response.json({
-            object: "list",
-            data: Object.keys(await currentModels()).map((id) => ({ id, object: "model" })),
-        });
-    }
-    return Response.json({ error: { message: `unsupported endpoint: ${url}` } }, { status: 404 });
-}
-export const CursorAuthPlugin = async () => {
-    return {
-        config: async (config) => {
-            const providers = (config.provider ??= {});
-            const cursor = (providers["cursor"] ??= { models: {} });
-            cursor.npm ??= "@ai-sdk/openai-compatible";
-            cursor.name ??= "Cursor";
-            cursor.options = { ...cursor.options, baseURL: BASE_URL };
-            cursor.models ??= {};
-            for (const [id, displayName] of Object.entries(await currentModels())) {
-                cursor.models[id] ??= { name: displayName };
-                const model = cursor.models[id];
-                model.cost = { input: 0, output: 0, cache_read: 0, cache_write: 0 };
-            }
-        },
-        auth: {
-            provider: "cursor",
-            loader: async (getAuth) => {
-                const auth = await getAuth().catch(() => undefined);
-                if (auth && auth.type === "api" && auth.key !== "cursor-sdk-store")
-                    pastedApiKey = auth.key;
-                return {
-                    apiKey: "cursor-managed",
-                    baseURL: BASE_URL,
-                    fetch: cursorFetch,
-                };
-            },
-            methods: [
-                {
-                    type: "oauth",
-                    label: "Log in with Cursor (browser)",
-                    authorize: async () => {
-                        let resolveUrl;
-                        const urlReady = new Promise((r) => (resolveUrl = r));
-                        const login = Cursor.auth
-                            .login({
-                            apiKeyName: "opencode-cursor-auth",
-                            openBrowser: false,
-                            onLoginUrl: (url) => resolveUrl(url),
-                        })
-                            .catch((err) => err);
-                        const url = await Promise.race([urlReady, login.then(() => "")]);
-                        return {
-                            url: typeof url === "string" && url ? url : "https://cursor.com/dashboard",
-                            instructions: "Complete the login in your browser. The key is stored in ~/.cursor/sdk/auth.json.",
-                            method: "auto",
-                            callback: async () => {
-                                const result = await login;
-                                if (result instanceof Error)
-                                    return { type: "failed" };
-                                return { type: "success", key: "cursor-sdk-store" };
-                            },
-                        };
-                    },
-                },
-                {
-                    type: "api",
-                    label: "Paste a Cursor API key (cursor.com/dashboard)",
-                },
-            ],
-        },
-    };
-};
-export default CursorAuthPlugin;
+// opencode calls EVERY named export of a plugin module as a plugin, so this
+// entry must expose exactly one export; helpers live in plugin.ts.
+export { CursorAuthPlugin as default } from "./plugin.js";

package/dist/models.d.ts

@@ -0,0 +1,20 @@
+import { type ModelListItem, type ModelParameterValue, type ModelSelection } from "@cursor/sdk";
+type Variant = {
+    params: ModelParameterValue[];
+    context?: number;
+};
+export type ModelInfo = {
+    name: string;
+    context?: number;
+    params?: ModelParameterValue[];
+    variants?: Record<string, Variant>;
+    allowed?: Record<string, string[]>;
+    blocked?: true;
+};
+export declare function parseContext(m: ModelListItem): number | undefined;
+export declare function buildCatalog(list: ModelListItem[]): Record<string, ModelInfo>;
+export declare function currentModels(): Promise<Record<string, ModelInfo>>;
+export declare function resolveModel(opencodeId: string): ModelSelection | undefined;
+export declare function resolveVariant(opencodeId: string, params?: unknown): ModelSelection | string | undefined;
+export declare function markBlocked(opencodeId: string): void;
+export {};

package/dist/models.js

@@ -0,0 +1,134 @@
+import { Cursor } from "@cursor/sdk";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CACHE_DIR = join(homedir(), ".cache", "opencode-cursor-auth");
+const MODELS_CACHE_PATH = join(CACHE_DIR, "models.json");
+const MODELS_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+let catalog = {};
+let fetchedAt = 0;
+function saveCatalog() {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    writeFileSync(MODELS_CACHE_PATH, JSON.stringify({ version: 4, fetchedAt, models: catalog }));
+}
+function contextValue(raw) {
+    const match = raw?.trim().match(/^(\d+)([km]?)$/i);
+    if (!match)
+        return undefined;
+    const unit = match[2].toLowerCase();
+    return Number(match[1]) * (unit === "k" ? 1_000 : unit === "m" ? 1_000_000 : 1);
+}
+export function parseContext(m) {
+    return contextValue(m.parameters?.find((p) => p.id === "context")?.values[0]?.value);
+}
+export function buildCatalog(list) {
+    const models = {};
+    for (const m of list) {
+        const def = m.variants?.find((v) => v.isDefault) ?? m.variants?.[0];
+        const ctxOf = (ps) => contextValue(ps?.find((p) => p.id === "context")?.value);
+        const context = ctxOf(def?.params) ?? parseContext(m);
+        const allowed = {};
+        const allow = (id, value) => {
+            if (!(allowed[id] ??= []).includes(value))
+                allowed[id].push(value);
+        };
+        for (const p of m.parameters ?? [])
+            for (const v of p.values)
+                allow(p.id, v.value);
+        const variants = {};
+        for (const v of m.variants ?? []) {
+            for (const p of v.params)
+                allow(p.id, p.value);
+            const name = v.params
+                .filter((p) => def?.params.find((d) => d.id === p.id)?.value !== p.value)
+                .map((p) => (p.value === "true" ? p.id : p.value === "false" ? `no-${p.id}` : p.value))
+                .join("-");
+            if (!name || variants[name])
+                continue;
+            const vctx = ctxOf(v.params) ?? context;
+            variants[name] = { params: v.params, ...(vctx ? { context: vctx } : {}) };
+        }
+        models[m.id === "default" ? "auto" : m.id] = {
+            name: m.displayName ?? m.id,
+            ...(context ? { context } : {}),
+            ...(def ? { params: def.params, allowed } : {}),
+            ...(Object.keys(variants).length ? { variants } : {}),
+        };
+    }
+    return models;
+}
+function loadCachedModels() {
+    try {
+        const raw = JSON.parse(readFileSync(MODELS_CACHE_PATH, "utf8"));
+        if (raw?.version === 4 && raw.models && Object.keys(raw.models).length > 0)
+            return raw;
+    }
+    catch {
+        // no cache yet, or unreadable — fall back
+    }
+    return undefined;
+}
+// Live model list from Cursor, cached 24h to keep opencode startup fast.
+// Offline/logged-out: stale cache if present, else just "auto" (Cursor's universal alias).
+// Models Cursor has rejected with "Model Blocked" for this account are hidden
+// until the cache file is deleted (the catalog itself carries no entitlement info).
+export async function currentModels() {
+    const cached = loadCachedModels();
+    if (cached && Date.now() - cached.fetchedAt <= MODELS_CACHE_TTL_MS) {
+        catalog = cached.models;
+        fetchedAt = cached.fetchedAt;
+    }
+    else {
+        try {
+            catalog = buildCatalog(await Cursor.models.list());
+            for (const [id, m] of Object.entries(cached?.models ?? {}))
+                if (m.blocked && catalog[id])
+                    catalog[id].blocked = true;
+            fetchedAt = Date.now();
+            saveCatalog();
+        }
+        catch {
+            catalog = cached?.models ?? { auto: { name: "Auto" } };
+            fetchedAt = cached?.fetchedAt ?? 0;
+        }
+    }
+    return Object.fromEntries(Object.entries(catalog).filter(([, m]) => !m.blocked));
+}
+function loadCatalog() {
+    if (Object.keys(catalog).length)
+        return;
+    const cached = loadCachedModels();
+    catalog = cached?.models ?? {};
+    fetchedAt = cached?.fetchedAt ?? 0;
+}
+export function resolveModel(opencodeId) {
+    loadCatalog();
+    const m = catalog[opencodeId];
+    if (!m)
+        return undefined;
+    return m.params ? { id: opencodeId, params: m.params } : { id: opencodeId };
+}
+export function resolveVariant(opencodeId, params) {
+    if (!Array.isArray(params))
+        return resolveModel(opencodeId);
+    loadCatalog();
+    const allowed = catalog[opencodeId]?.allowed ?? {};
+    for (const p of params) {
+        if (!allowed[p?.id]?.includes(p?.value))
+            return `unknown variant param ${p?.id}=${p?.value} for model ${opencodeId}`;
+    }
+    return { id: opencodeId, params: params.map((p) => ({ id: p.id, value: p.value })) };
+}
+export function markBlocked(opencodeId) {
+    loadCatalog();
+    const m = catalog[opencodeId];
+    if (!m || m.blocked)
+        return;
+    m.blocked = true;
+    try {
+        saveCatalog();
+    }
+    catch {
+        // cache dir unwritable — the in-memory flag still hides it for this process
+    }
+}

package/dist/plugin.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { type SdkAuthStatus } from "@cursor/sdk";
+export { parseContext } from "./models.js";
+export declare function keyProblem(status: SdkAuthStatus, nowMs: number): string | undefined;
+export declare const CursorAuthPlugin: Plugin;

package/dist/plugin.js

@@ -0,0 +1,139 @@
+import { Cursor } from "@cursor/sdk";
+import { errorResponse, handleChatCompletion } from "./bridge.js";
+import { currentModels } from "./models.js";
+export { parseContext } from "./models.js";
+const BASE_URL = "http://cursor.local/v1";
+// Cursor publishes no output limit and the bridge never passes max_tokens to Cursor, so output is only an accounting reserve for opencode.
+const DEFAULT_CONTEXT = 200_000;
+const DEFAULT_OUTPUT = 32_000;
+export function keyProblem(status, nowMs) {
+    if (status.status !== "logged-in")
+        return "Cursor SDK key missing — run `opencode auth login` and pick Cursor";
+    if (typeof status.apiKeyExpiresAtMs === "number" && status.apiKeyExpiresAtMs <= nowMs)
+        return `Cursor SDK key expired on ${new Date(status.apiKeyExpiresAtMs).toISOString()} — run \`opencode auth login\` and pick Cursor`;
+    return undefined;
+}
+const KEY_CHECK_TTL_MS = 60_000;
+const EXPIRY_WARN_MS = 7 * 24 * 60 * 60 * 1000;
+let keyStatus;
+let warnedExpiry = false;
+async function checkKey() {
+    if (pastedApiKey || process.env.CURSOR_API_KEY)
+        return undefined;
+    const now = Date.now();
+    if (!keyStatus || now - keyStatus.at > KEY_CHECK_TTL_MS) {
+        keyStatus = { at: now, value: Cursor.auth.status().catch(() => undefined) };
+    }
+    const status = await keyStatus.value;
+    if (!status)
+        return undefined;
+    const exp = status.status === "logged-in" ? status.apiKeyExpiresAtMs : undefined;
+    if (!warnedExpiry && typeof exp === "number" && exp > now && exp - now <= EXPIRY_WARN_MS) {
+        warnedExpiry = true;
+        const days = Math.ceil((exp - now) / (24 * 60 * 60 * 1000));
+        console.error(`[opencode-cursor-auth] Cursor SDK key expires in ${days} days — run \`opencode auth login\` to renew`);
+    }
+    return keyProblem(status, now);
+}
+async function bodyText(input, init) {
+    const b = init?.body;
+    if (typeof b === "string")
+        return b;
+    if (b instanceof Uint8Array)
+        return new TextDecoder().decode(b);
+    if (input instanceof Request)
+        return input.text();
+    return "";
+}
+let pastedApiKey;
+async function cursorFetch(input, init) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    if (url.includes("/chat/completions")) {
+        const problem = await checkKey();
+        if (problem)
+            return errorResponse(problem, 401);
+        const body = JSON.parse(await bodyText(input, init));
+        const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+        const scope = new Headers(init?.headers).get("x-opencode-session") ??
+            (input instanceof Request ? input.headers.get("x-opencode-session") : null) ??
+            undefined;
+        return handleChatCompletion(body, pastedApiKey, signal, scope);
+    }
+    if (url.includes("/models")) {
+        return Response.json({
+            object: "list",
+            data: Object.keys(await currentModels()).map((id) => ({ id, object: "model" })),
+        });
+    }
+    return Response.json({ error: { message: `unsupported endpoint: ${url}` } }, { status: 404 });
+}
+export const CursorAuthPlugin = async () => {
+    return {
+        config: async (config) => {
+            const providers = (config.provider ??= {});
+            const cursor = (providers["cursor"] ??= { models: {} });
+            cursor.npm ??= "@ai-sdk/openai-compatible";
+            cursor.name ??= "Cursor";
+            cursor.options = { ...cursor.options, baseURL: BASE_URL };
+            cursor.models ??= {};
+            for (const [id, { name, context, variants }] of Object.entries(await currentModels())) {
+                cursor.models[id] ??= { name };
+                const model = cursor.models[id];
+                model.cost = { input: 0, output: 0, cache_read: 0, cache_write: 0 };
+                model.limit ??= { context: context ?? DEFAULT_CONTEXT, output: DEFAULT_OUTPUT };
+                if (variants)
+                    model.variants ??= Object.fromEntries(Object.entries(variants).map(([n, v]) => [n, { cursor_params: v.params }]));
+            }
+        },
+        "chat.headers": async (input, output) => {
+            if (input.model.providerID === "cursor")
+                output.headers["x-opencode-session"] = input.sessionID;
+        },
+        auth: {
+            provider: "cursor",
+            loader: async (getAuth) => {
+                const auth = await getAuth().catch(() => undefined);
+                if (auth && auth.type === "api" && auth.key !== "cursor-sdk-store")
+                    pastedApiKey = auth.key;
+                return {
+                    apiKey: "cursor-managed",
+                    baseURL: BASE_URL,
+                    fetch: cursorFetch,
+                };
+            },
+            methods: [
+                {
+                    type: "oauth",
+                    label: "Log in with Cursor (browser)",
+                    authorize: async () => {
+                        let resolveUrl;
+                        const urlReady = new Promise((r) => (resolveUrl = r));
+                        const login = Cursor.auth
+                            .login({
+                            apiKeyName: "opencode-cursor-auth",
+                            openBrowser: false,
+                            onLoginUrl: (url) => resolveUrl(url),
+                        })
+                            .catch((err) => err);
+                        const url = await Promise.race([urlReady, login.then(() => "")]);
+                        return {
+                            url: typeof url === "string" && url ? url : "https://cursor.com/dashboard",
+                            instructions: "Complete the login in your browser. The key is stored in ~/.cursor/sdk/auth.json.",
+                            method: "auto",
+                            callback: async () => {
+                                const result = await login;
+                                if (result instanceof Error)
+                                    return { type: "failed" };
+                                return { type: "success", key: "cursor-sdk-store" };
+                            },
+                        };
+                    },
+                },
+                {
+                    type: "api",
+                    label: "Paste a Cursor API key (cursor.com/dashboard)",
+                },
+            ],
+        },
+    };
+};

package/installation.md

@@ -0,0 +1,139 @@
+# Install @vidit19sharma/opencode-cursor-auth
+
+These instructions are designed for AI coding agents.
+
+The plugin lets opencode use a Cursor subscription through the official `@cursor/sdk`, in-process. Supported on macOS/Linux; Windows untested.
+
+## Prerequisites
+
+### Check opencode version
+
+```bash
+opencode --version
+```
+
+You should see `1.19` or newer. If older or missing, ask the user to install or upgrade opencode before continuing.
+
+### Check Node version
+
+```bash
+node --version
+```
+
+You should see `v22.13` or newer. opencode installs plugins with Bun, but `@cursor/sdk` spawns the `cursor-agent` binary and requires Node >= 22.13. If older, ask the user to upgrade Node.
+
+### Check the Cursor CLI
+
+```bash
+cursor-agent --version
+```
+
+If this prints a version, continue. If it fails with `command not found`, install it:
+
+```bash
+curl https://cursor.com/install -fsS | bash
+```
+
+Then open a new shell, or add `~/.local/bin` to `PATH`, and re-run `cursor-agent --version`.
+
+A Cursor subscription (Pro, Business, or team) is required. `cursor-agent login` is not required (the plugin has its own login) but is harmless.
+
+## Installation
+
+### Step 1: Remove the old open-cursor setup (only if present)
+
+If `~/.config/opencode/plugin/cursor-acp.js` exists or the opencode config has a `cursor-acp` provider, the user has the old `@rama_nigg/open-cursor` proxy setup. Remove it:
+
+1. Delete the `cursor-acp` block under `provider` in the opencode config.
+2. Delete the file: `rm ~/.config/opencode/plugin/cursor-acp.js`
+3. Uninstall it: `npm uninstall -g @rama_nigg/open-cursor`
+
+Skip this step if none of these exist.
+
+### Step 2: Add the plugin to the opencode config
+
+The config file is `~/.config/opencode/opencode.json`. Some users have `~/.config/opencode/opencode.jsonc` instead; edit whichever exists.
+
+If neither exists, create `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["@vidit19sharma/opencode-cursor-auth@latest"]
+}
+```
+
+If the file exists and has no top-level `plugin` array, add one:
+
+```json
+"plugin": ["@vidit19sharma/opencode-cursor-auth@latest"]
+```
+
+If a `plugin` array already exists, append `"@vidit19sharma/opencode-cursor-auth@latest"` and keep every existing entry.
+
+Do not add a `provider.cursor` block by hand. On startup the plugin registers the `cursor` provider and its model list automatically. No `npm install` is needed; opencode installs the package at startup.
+
+### Step 3: Authenticate
+
+Pick one method.
+
+**Browser login.** This step needs the user. Ask them to run:
+
+```bash
+opencode auth login
+```
+
+and choose provider **Cursor**, then **Log in with Cursor (browser)**. A browser opens; they sign in to Cursor. This mints a 90-day SDK key stored at `~/.cursor/sdk/auth.json` (written by `@cursor/sdk`, not by the plugin). When the key expires, requests return a 401 telling the user to run `opencode auth login` again; a warning is printed to stderr during the last 7 days.
+
+**API key.** In `opencode auth login`, choose **Cursor**, then **Paste a Cursor API key**. Keys come from cursor.com/dashboard (Integrations / API keys). Alternatively, set `CURSOR_API_KEY` in the environment before starting opencode.
+
+## Verification
+
+```bash
+opencode models | grep cursor/
+```
+
+You should see `cursor/auto`, `cursor/gpt-5.5`, `cursor/claude-opus-5-5`, and more. The first run fetches the catalog from Cursor (about 3 s); it is cached for 24 h at `~/.cache/opencode-cursor-auth/models.json`.
+
+Variants are not separate ids. In the TUI, press Ctrl+T on a cursor model to pick its effort, thinking, fast, or context variant.
+
+```bash
+opencode run -m cursor/gpt-5.5 "Reply with exactly: CURSOR-AUTH-OK"
+```
+
+You should see `CURSOR-AUTH-OK`. In some setups `opencode run` does not exit on its own because of other plugins; Ctrl-C after the reply is fine.
+
+Optional: to see which models the account is actually allowed to use, clone the repo, run `bun install`, then `bun spike/probe-models.ts`. It sends one tiny request per model.
+
+## Upgrading
+
+With `@latest` in the `plugin` array, restarting opencode picks up new versions. If it stays on an old version, clear the cached package and restart opencode:
+
+```bash
+rm -rf ~/.cache/opencode/packages/@vidit19sharma/opencode-cursor-auth@latest
+```
+
+## Done
+
+The plugin is installed. Every model the user's Cursor plan includes is available as `cursor/*` in opencode.
+
+## Troubleshooting
+
+- **`Cannot connect to API`, or nothing happens on cursor models**: the auth entry is missing. Run `opencode auth login` and pick Cursor.
+- **401 `Cursor SDK key missing/expired`**: run `opencode auth login`.
+- **403 `permission_error` "Model Blocked"**: a team admin disabled that model for the account. It is hidden from `opencode models` from then on; delete `~/.cache/opencode-cursor-auth/models.json` to re-check.
+- **400 `Cannot use this model`**: the model id is not in Cursor's catalog for this account.
+- **`cursor-agent: command not found` at request time**: install the Cursor CLI (see Prerequisites) and make sure it is on `PATH` for the shell that launches opencode.
+- **Model list empty or only `cursor/auto`**: the catalog fetch failed (offline or not logged in). Fix auth, delete `~/.cache/opencode-cursor-auth/models.json`, restart opencode.
+- **Stray `cursor-agent` processes**: check with `pgrep -fl cursor-agent`. A single `worker-server` is the SDK's idle singleton and is normal.
+
+### Paths
+
+| Path | Contents |
+| --- | --- |
+| `~/.cursor/sdk/auth.json` | SDK key from browser login |
+| `~/.cache/opencode-cursor-auth/models.json` | Model catalog, 24 h |
+| `~/.cache/opencode-cursor-auth/sessions.json` | Conversation to Cursor agent map, 7 days |
+| `~/.local/share/opencode/auth.json` | opencode's auth registry; the Cursor entry is a sentinel, the real key lives in the SDK file |
+
+See the [README](README.md) for more detail.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidit19sharma/opencode-cursor-auth",
-  "version": "0.1.0",
+  "version": "0.3.1",
   "description": "OpenCode plugin that uses your Cursor subscription via the official @cursor/sdk \u2014 no proxy server, no separate login.",
   "type": "module",
   "main": "dist/index.js",
@@ -8,6 +8,8 @@
   "files": [
     "dist",
     "README.md",
+    "installation.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "author": "Vidit Sharma <vidit19sharma@gmail.com> (https://github.com/vidit19sharma)",