@imdeadpool/codex-account-switcher 0.1.5 → 0.1.6

package/dist/tests/save-account-safety.test.js

@@ -0,0 +1,399 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const account_service_1 = require("../lib/accounts/account-service");
+const errors_1 = require("../lib/accounts/errors");
+const auth_parser_1 = require("../lib/accounts/auth-parser");
+function encodeBase64Url(input) {
+    return Buffer.from(input, "utf8")
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/g, "");
+}
+function buildAuthPayload(email, options) {
+    var _a, _b;
+    const accountId = (_a = options === null || options === void 0 ? void 0 : options.accountId) !== null && _a !== void 0 ? _a : "acct-1";
+    const userId = (_b = options === null || options === void 0 ? void 0 : options.userId) !== null && _b !== void 0 ? _b : "user-1";
+    const idTokenPayload = {
+        email,
+        "https://api.openai.com/auth": {
+            chatgpt_account_id: accountId,
+            chatgpt_user_id: userId,
+            chatgpt_plan_type: "team",
+        },
+    };
+    const idToken = `${encodeBase64Url(JSON.stringify({ alg: "none" }))}.${encodeBase64Url(JSON.stringify(idTokenPayload))}.sig`;
+    return JSON.stringify({
+        tokens: {
+            access_token: `token-${email}`,
+            refresh_token: `refresh-${email}`,
+            id_token: idToken,
+            account_id: accountId,
+        },
+    }, null, 2);
+}
+async function withIsolatedCodexDir(t, fn) {
+    const codexDir = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), "codex-auth-save-"));
+    const accountsDir = node_path_1.default.join(codexDir, "accounts");
+    const authPath = node_path_1.default.join(codexDir, "auth.json");
+    await promises_1.default.mkdir(accountsDir, { recursive: true });
+    const previousEnv = {
+        CODEX_AUTH_CODEX_DIR: process.env.CODEX_AUTH_CODEX_DIR,
+        CODEX_AUTH_ACCOUNTS_DIR: process.env.CODEX_AUTH_ACCOUNTS_DIR,
+        CODEX_AUTH_JSON_PATH: process.env.CODEX_AUTH_JSON_PATH,
+        CODEX_AUTH_CURRENT_PATH: process.env.CODEX_AUTH_CURRENT_PATH,
+    };
+    process.env.CODEX_AUTH_CODEX_DIR = codexDir;
+    delete process.env.CODEX_AUTH_ACCOUNTS_DIR;
+    delete process.env.CODEX_AUTH_JSON_PATH;
+    delete process.env.CODEX_AUTH_CURRENT_PATH;
+    t.after(async () => {
+        process.env.CODEX_AUTH_CODEX_DIR = previousEnv.CODEX_AUTH_CODEX_DIR;
+        process.env.CODEX_AUTH_ACCOUNTS_DIR = previousEnv.CODEX_AUTH_ACCOUNTS_DIR;
+        process.env.CODEX_AUTH_JSON_PATH = previousEnv.CODEX_AUTH_JSON_PATH;
+        process.env.CODEX_AUTH_CURRENT_PATH = previousEnv.CODEX_AUTH_CURRENT_PATH;
+        await promises_1.default.rm(codexDir, { recursive: true, force: true });
+    });
+    await fn({ codexDir, accountsDir, authPath });
+}
+(0, node_test_1.default)("saveAccount blocks overwriting snapshot when existing and incoming emails differ", async (t) => {
+    await withIsolatedCodexDir(t, async ({ accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const destinationPath = node_path_1.default.join(accountsDir, "codexina.json");
+        await promises_1.default.writeFile(destinationPath, buildAuthPayload("bia@edixai.com"), "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload("codexina@edixai.com"), "utf8");
+        await strict_1.default.rejects(() => service.saveAccount("codexina"), (error) => error instanceof errors_1.SnapshotEmailMismatchError &&
+            error.message.includes("bia@edixai.com") &&
+            error.message.includes("codexina@edixai.com"));
+        const parsed = await (0, auth_parser_1.parseAuthSnapshotFile)(destinationPath);
+        strict_1.default.equal(parsed.email, "bia@edixai.com");
+    });
+});
+(0, node_test_1.default)("saveAccount allows force overwrite when emails differ", async (t) => {
+    await withIsolatedCodexDir(t, async ({ accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const destinationPath = node_path_1.default.join(accountsDir, "codexina.json");
+        await promises_1.default.writeFile(destinationPath, buildAuthPayload("bia@edixai.com"), "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload("codexina@edixai.com"), "utf8");
+        await service.saveAccount("codexina", { force: true });
+        const parsed = await (0, auth_parser_1.parseAuthSnapshotFile)(destinationPath);
+        strict_1.default.equal(parsed.email, "codexina@edixai.com");
+    });
+});
+(0, node_test_1.default)("saveAccount still overwrites when existing snapshot belongs to same email", async (t) => {
+    await withIsolatedCodexDir(t, async ({ accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const destinationPath = node_path_1.default.join(accountsDir, "codexina.json");
+        await promises_1.default.writeFile(destinationPath, buildAuthPayload("codexina@edixai.com"), "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload("codexina@edixai.com"), "utf8");
+        await strict_1.default.doesNotReject(() => service.saveAccount("codexina"));
+        const parsed = await (0, auth_parser_1.parseAuthSnapshotFile)(destinationPath);
+        strict_1.default.equal(parsed.email, "codexina@edixai.com");
+    });
+});
+(0, node_test_1.default)("saveAccount accepts an email-shaped snapshot name", async (t) => {
+    await withIsolatedCodexDir(t, async ({ accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const accountName = "viktor@edia.com";
+        const destinationPath = node_path_1.default.join(accountsDir, `${accountName}.json`);
+        await promises_1.default.writeFile(authPath, buildAuthPayload("viktor@edia.com"), "utf8");
+        await strict_1.default.doesNotReject(() => service.saveAccount(accountName));
+        const parsed = await (0, auth_parser_1.parseAuthSnapshotFile)(destinationPath);
+        strict_1.default.equal(parsed.email, "viktor@edia.com");
+    });
+});
+(0, node_test_1.default)("saveAccount accepts an email-shaped snapshot name containing plus aliases", async (t) => {
+    await withIsolatedCodexDir(t, async ({ accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const accountName = "viktor+biz@edia.com";
+        const destinationPath = node_path_1.default.join(accountsDir, `${accountName}.json`);
+        await promises_1.default.writeFile(authPath, buildAuthPayload("viktor+biz@edia.com"), "utf8");
+        await strict_1.default.doesNotReject(() => service.saveAccount(accountName));
+        const parsed = await (0, auth_parser_1.parseAuthSnapshotFile)(destinationPath);
+        strict_1.default.equal(parsed.email, "viktor+biz@edia.com");
+    });
+});
+(0, node_test_1.default)("saveAccount blocks overwrite when emails match but account identity differs", async (t) => {
+    await withIsolatedCodexDir(t, async ({ accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const destinationPath = node_path_1.default.join(accountsDir, "work.json");
+        await promises_1.default.writeFile(destinationPath, buildAuthPayload("codexina@edixai.com", {
+            accountId: "acct-a",
+            userId: "user-a",
+        }), "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload("codexina@edixai.com", {
+            accountId: "acct-b",
+            userId: "user-a",
+        }), "utf8");
+        await strict_1.default.rejects(() => service.saveAccount("work"), (error) => error instanceof errors_1.SnapshotEmailMismatchError &&
+            error.message.includes("account:acct-a") &&
+            error.message.includes("account:acct-b"));
+    });
+});
+(0, node_test_1.default)("inferAccountNameFromCurrentAuth returns email-shaped duplicate suffix for same-email different account identities", async (t) => {
+    await withIsolatedCodexDir(t, async ({ accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const firstSnapshotPath = node_path_1.default.join(accountsDir, "codexina@edixai.com.json");
+        await promises_1.default.writeFile(firstSnapshotPath, buildAuthPayload("codexina@edixai.com", {
+            accountId: "acct-a",
+            userId: "user-a",
+        }), "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload("codexina@edixai.com", {
+            accountId: "acct-b",
+            userId: "user-a",
+        }), "utf8");
+        const inferred = await service.inferAccountNameFromCurrentAuth();
+        strict_1.default.equal(inferred, "codexina@edixai.com--dup-2");
+    });
+});
+(0, node_test_1.default)("resolveLoginAccountNameFromCurrentAuth creates an email-shaped duplicate when canonical email snapshot identity differs", async (t) => {
+    await withIsolatedCodexDir(t, async ({ accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const email = "csoves@edixai.com";
+        await promises_1.default.writeFile(node_path_1.default.join(accountsDir, `${email}.json`), buildAuthPayload(email, {
+            accountId: "acct-a",
+            userId: "user-a",
+        }), "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload(email, {
+            accountId: "acct-b",
+            userId: "user-a",
+        }), "utf8");
+        const resolved = await service.resolveLoginAccountNameFromCurrentAuth();
+        strict_1.default.deepEqual(resolved, {
+            name: `${email}--dup-2`,
+            source: "inferred",
+        });
+    });
+});
+(0, node_test_1.default)("resolveLoginAccountNameFromCurrentAuth ignores active alias and infers canonical email snapshot", async (t) => {
+    await withIsolatedCodexDir(t, async ({ codexDir, accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const activeName = "team-primary";
+        const email = "csoves@edixai.com";
+        await promises_1.default.writeFile(node_path_1.default.join(accountsDir, `${activeName}.json`), buildAuthPayload(email, {
+            accountId: "acct-a",
+            userId: "user-a",
+        }), "utf8");
+        await promises_1.default.writeFile(node_path_1.default.join(codexDir, "current"), `${activeName}\n`, "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload(email, {
+            accountId: "acct-b",
+            userId: "user-a",
+        }), "utf8");
+        const resolved = await service.resolveLoginAccountNameFromCurrentAuth();
+        strict_1.default.deepEqual(resolved, {
+            name: email,
+            source: "inferred",
+        });
+    });
+});
+(0, node_test_1.default)("resolveLoginAccountNameFromCurrentAuth infers email snapshot when no existing snapshot matches email", async (t) => {
+    await withIsolatedCodexDir(t, async ({ authPath }) => {
+        const service = new account_service_1.AccountService();
+        const email = "new-user@edixai.com";
+        await promises_1.default.writeFile(authPath, buildAuthPayload(email, {
+            accountId: "acct-new",
+            userId: "user-new",
+        }), "utf8");
+        const resolved = await service.resolveLoginAccountNameFromCurrentAuth();
+        strict_1.default.deepEqual(resolved, {
+            name: email,
+            source: "inferred",
+        });
+    });
+});
+(0, node_test_1.default)("inferAccountNameFromCurrentAuth ignores active alias and still infers email-shaped name", async (t) => {
+    await withIsolatedCodexDir(t, async ({ codexDir, accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const activeName = "work";
+        const currentPath = node_path_1.default.join(codexDir, "current");
+        await promises_1.default.writeFile(node_path_1.default.join(accountsDir, `${activeName}.json`), buildAuthPayload("admin@recodee.com", {
+            accountId: "acct-admin",
+            userId: "user-admin",
+        }), "utf8");
+        await promises_1.default.writeFile(currentPath, `${activeName}\n`, "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload("admin@recodee.com", {
+            accountId: "acct-admin",
+            userId: "user-admin",
+        }), "utf8");
+        const inferred = await service.inferAccountNameFromCurrentAuth();
+        strict_1.default.equal(inferred, "admin@recodee.com");
+    });
+});
+(0, node_test_1.default)("resolveDefaultAccountNameFromCurrentAuth reuses active snapshot name when identity matches", async (t) => {
+    await withIsolatedCodexDir(t, async ({ codexDir, accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const activeName = "itrexsale";
+        const activeSnapshotPath = node_path_1.default.join(accountsDir, `${activeName}.json`);
+        const currentPath = node_path_1.default.join(codexDir, "current");
+        await promises_1.default.writeFile(activeSnapshotPath, buildAuthPayload("codexina@edixai.com", {
+            accountId: "acct-a",
+            userId: "user-a",
+        }), "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload("codexina@edixai.com", {
+            accountId: "acct-a",
+            userId: "user-a",
+        }), "utf8");
+        await promises_1.default.writeFile(currentPath, `${activeName}\n`, "utf8");
+        const resolved = await service.resolveDefaultAccountNameFromCurrentAuth();
+        strict_1.default.deepEqual(resolved, {
+            name: activeName,
+            source: "active",
+        });
+    });
+});
+(0, node_test_1.default)("resolveDefaultAccountNameFromCurrentAuth falls back to inferred email-shaped name when active snapshot mismatches identity", async (t) => {
+    await withIsolatedCodexDir(t, async ({ codexDir, accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const activeName = "itrexsale";
+        const activeSnapshotPath = node_path_1.default.join(accountsDir, `${activeName}.json`);
+        const currentPath = node_path_1.default.join(codexDir, "current");
+        await promises_1.default.writeFile(activeSnapshotPath, buildAuthPayload("other@edixai.com", {
+            accountId: "acct-other",
+            userId: "user-other",
+        }), "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload("codexina@edixai.com", {
+            accountId: "acct-a",
+            userId: "user-a",
+        }), "utf8");
+        await promises_1.default.writeFile(currentPath, `${activeName}\n`, "utf8");
+        const resolved = await service.resolveDefaultAccountNameFromCurrentAuth();
+        strict_1.default.deepEqual(resolved, {
+            name: "codexina@edixai.com",
+            source: "inferred",
+        });
+    });
+});
+(0, node_test_1.default)("listAccountMappings returns active flag and identity metadata for each snapshot", async (t) => {
+    await withIsolatedCodexDir(t, async ({ codexDir, accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const currentPath = node_path_1.default.join(codexDir, "current");
+        await promises_1.default.writeFile(node_path_1.default.join(accountsDir, "itrexsale.json"), buildAuthPayload("itrex@edixai.com", {
+            accountId: "acct-itrex",
+            userId: "user-itrex",
+        }), "utf8");
+        await promises_1.default.writeFile(node_path_1.default.join(accountsDir, "deadpool.json"), buildAuthPayload("deadpool@edixai.com", {
+            accountId: "acct-deadpool",
+            userId: "user-deadpool",
+        }), "utf8");
+        await promises_1.default.writeFile(currentPath, "itrexsale\n", "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload("itrex@edixai.com", {
+            accountId: "acct-itrex",
+            userId: "user-itrex",
+        }), "utf8");
+        await service.saveAccount("itrexsale");
+        const mappings = await service.listAccountMappings();
+        strict_1.default.deepEqual(mappings.map((item) => ({
+            name: item.name,
+            active: item.active,
+            email: item.email,
+            accountId: item.accountId,
+            userId: item.userId,
+        })), [
+            {
+                name: "deadpool",
+                active: false,
+                email: "deadpool@edixai.com",
+                accountId: "acct-deadpool",
+                userId: "user-deadpool",
+            },
+            {
+                name: "itrexsale",
+                active: true,
+                email: "itrex@edixai.com",
+                accountId: "acct-itrex",
+                userId: "user-itrex",
+            },
+        ]);
+    });
+});
+(0, node_test_1.default)("syncExternalAuthSnapshotIfNeeded disables auto-switch and snapshots external codex login into inferred email name", async (t) => {
+    await withIsolatedCodexDir(t, async ({ codexDir, accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const previousName = "odin@recodee.com";
+        const incomingEmail = "odin@edixai.com";
+        const currentPath = node_path_1.default.join(codexDir, "current");
+        const registryPath = node_path_1.default.join(accountsDir, "registry.json");
+        await promises_1.default.writeFile(node_path_1.default.join(accountsDir, `${previousName}.json`), buildAuthPayload(previousName, {
+            accountId: "acct-prev",
+            userId: "user-prev",
+        }), "utf8");
+        await promises_1.default.writeFile(currentPath, `${previousName}\n`, "utf8");
+        await promises_1.default.writeFile(registryPath, `${JSON.stringify({
+            version: 1,
+            autoSwitch: {
+                enabled: true,
+                threshold5hPercent: 10,
+                thresholdWeeklyPercent: 5,
+            },
+            api: {
+                usage: true,
+            },
+            activeAccountName: previousName,
+            accounts: {
+                [previousName]: {
+                    name: previousName,
+                    createdAt: new Date().toISOString(),
+                    email: previousName,
+                },
+            },
+        }, null, 2)}\n`, "utf8");
+        await promises_1.default.writeFile(authPath, buildAuthPayload(incomingEmail, {
+            accountId: "acct-new",
+            userId: "user-new",
+        }), "utf8");
+        const result = await service.syncExternalAuthSnapshotIfNeeded();
+        strict_1.default.deepEqual(result, {
+            synchronized: true,
+            savedName: incomingEmail,
+            autoSwitchDisabled: true,
+        });
+        strict_1.default.equal((await promises_1.default.readFile(currentPath, "utf8")).trim(), incomingEmail);
+        const parsed = await (0, auth_parser_1.parseAuthSnapshotFile)(node_path_1.default.join(accountsDir, `${incomingEmail}.json`));
+        strict_1.default.equal(parsed.email, incomingEmail);
+        const registry = JSON.parse(await promises_1.default.readFile(registryPath, "utf8"));
+        strict_1.default.equal(registry.autoSwitch.enabled, false);
+    });
+});
+(0, node_test_1.default)("syncExternalAuthSnapshotIfNeeded materializes auth symlink so external codex login can no longer overwrite snapshot files", async (t) => {
+    if (process.platform === "win32") {
+        t.skip("symlink conversion behavior is Unix-specific in this test");
+        return;
+    }
+    await withIsolatedCodexDir(t, async ({ codexDir, accountsDir, authPath }) => {
+        const service = new account_service_1.AccountService();
+        const activeName = "team-primary";
+        const snapshotPath = node_path_1.default.join(accountsDir, `${activeName}.json`);
+        const currentPath = node_path_1.default.join(codexDir, "current");
+        await promises_1.default.writeFile(snapshotPath, buildAuthPayload("team-primary@edixai.com"), "utf8");
+        await promises_1.default.symlink(snapshotPath, authPath);
+        await promises_1.default.writeFile(currentPath, `${activeName}\n`, "utf8");
+        const before = await promises_1.default.lstat(authPath);
+        strict_1.default.equal(before.isSymbolicLink(), true);
+        const result = await service.syncExternalAuthSnapshotIfNeeded();
+        strict_1.default.deepEqual(result, {
+            synchronized: false,
+            autoSwitchDisabled: false,
+        });
+        const after = await promises_1.default.lstat(authPath);
+        strict_1.default.equal(after.isSymbolicLink(), false);
+    });
+});
+(0, node_test_1.default)("useAccount writes auth.json as a regular file (never symlink)", async (t) => {
+    await withIsolatedCodexDir(t, async ({ accountsDir }) => {
+        const service = new account_service_1.AccountService();
+        const accountName = "regular-file-check";
+        const sourcePath = node_path_1.default.join(accountsDir, `${accountName}.json`);
+        await promises_1.default.writeFile(sourcePath, buildAuthPayload("regular-file-check@edixai.com"), "utf8");
+        await service.useAccount(accountName);
+        const authStat = await promises_1.default.lstat(node_path_1.default.join(process.env.CODEX_AUTH_CODEX_DIR, "auth.json"));
+        strict_1.default.equal(authStat.isSymbolicLink(), false);
+    });
+});

package/dist/tests/usage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/usage.test.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const usage_1 = require("../lib/accounts/usage");
+const nowSeconds = Math.floor(Date.now() / 1000);
+(0, node_test_1.default)("usageScore uses min remaining window percent", () => {
+    const usage = {
+        source: "api",
+        fetchedAt: new Date().toISOString(),
+        primary: { usedPercent: 30, windowMinutes: 300, resetsAt: nowSeconds + 60 },
+        secondary: { usedPercent: 10, windowMinutes: 10080, resetsAt: nowSeconds + 60 },
+    };
+    strict_1.default.equal((0, usage_1.usageScore)(usage, nowSeconds), 70);
+});
+(0, node_test_1.default)("shouldSwitchCurrent triggers when 5h threshold crossed", () => {
+    const usage = {
+        source: "api",
+        fetchedAt: new Date().toISOString(),
+        primary: { usedPercent: 96, windowMinutes: 300, resetsAt: nowSeconds + 60 },
+    };
+    strict_1.default.equal((0, usage_1.shouldSwitchCurrent)(usage, {
+        threshold5hPercent: 10,
+        thresholdWeeklyPercent: 5,
+    }, nowSeconds), true);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imdeadpool/codex-account-switcher",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "A command-line tool that lets you manage and switch between multiple Codex accounts instantly, no more constant logins and logouts.",
   "license": "MIT",
   "bin": {
@@ -10,7 +10,8 @@
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "npm run build && node --test dist/tests/**/*.test.js"
   },
   "engines": {
     "node": ">=18"
@@ -31,13 +32,13 @@
   "preferGlobal": true,
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Sls0n/codex-account-switcher.git"
+    "url": "git+https://github.com/NagyVikt/codex-account-switcher.git"
   },
   "bugs": {
-    "url": "https://github.com/Sls0n/codex-account-switcher/issues"
+    "url": "https://github.com/NagyVikt/codex-account-switcher/issues"
   },
-  "homepage": "https://github.com/Sls0n/codex-account-switcher#readme",
-  "author": "Sls0n",
+  "homepage": "https://github.com/NagyVikt/codex-account-switcher#readme",
+  "author": "NagyVikt",
   "dependencies": {
     "@oclif/core": "^3.0.0",
     "prompts": "^2.4.2",