@burmese/cli 3.1.0

package/dist/index.js

@@ -0,0 +1,920 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from "node:child_process";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { fileURLToPath } from "node:url";
+import { allowedReactions, createOpenPetsClient, OpenPetsClientError } from "@burmese/client";
+import { claudeHookEvents, classifyCodexConfigText, doctorClaudeHooks, openPetsHookMarker, removeOpenPetsHooks, runClaudeHookFromStdin, updateCodexConfigText, validateOpenPetsPetArg, writeCodexConfig } from "@burmese/claude";
+import { buildCursorRulesPreview, buildOpenPetsOnlyPreview, classifyCursorMcpStatus, classifyCursorRulesStatus, executeCursorMcpWrite, executeCursorRulesWrite, getCursorProjectMcpPath, getCursorProjectRulesPath, planCursorMcpInstall, planCursorMcpReplace, planCursorRulesInstall, planCursorRulesRemove, planCursorRulesReplace, readCursorMcpConfig, readCursorOpenPetsRules } from "@burmese/cursor";
+import { prepareOpenCodeProjectSetup, writePreparedOpenCodeProjectSetup } from "@burmese/opencode";
+import { pluginTemplateNames, pluginTemplates } from "./plugin-templates.js";
+import { validatePluginFolder } from "./plugin-validate.js";
+export const cliPackageName = "@burmese/cli";
+const require = createRequire(import.meta.url);
+async function main() {
+    const [command, ...args] = process.argv.slice(2);
+    if (!command || command === "--help" || command === "-h") {
+        printUsage();
+        return;
+    }
+    if (command === "configure") {
+        if (hasHelp(args)) {
+            printConfigureUsage();
+            return;
+        }
+        await configureProject(parseConfigureArgs(args));
+        return;
+    }
+    if (command === "install") {
+        if (hasHelp(args)) {
+            printInstallUsage();
+            return;
+        }
+        await installPetFromCatalog(parseInstallArgs(args));
+        return;
+    }
+    if (command === "status") {
+        if (hasHelp(args)) {
+            printStatusUsage();
+            return;
+        }
+        await showStatus(args);
+        return;
+    }
+    if (command === "pets") {
+        if (hasHelp(args)) {
+            printPetsUsage();
+            return;
+        }
+        await showPets(args);
+        return;
+    }
+    if (command === "doctor") {
+        if (hasHelp(args)) {
+            printDoctorUsage();
+            return;
+        }
+        await runDoctor(parseDoctorArgs(args));
+        return;
+    }
+    if (command === "react") {
+        if (hasHelp(args)) {
+            printReactUsage();
+            return;
+        }
+        await sendReaction(parseReactArgs(args));
+        return;
+    }
+    if (command === "say") {
+        if (hasHelp(args)) {
+            printSayUsage();
+            return;
+        }
+        await sendMessage(parseSayArgs(args));
+        return;
+    }
+    if (command === "mcp") {
+        if (hasHelp(args)) {
+            printMcpUsage();
+            return;
+        }
+        await runMcp(args);
+        return;
+    }
+    if (command === "hook") {
+        if (hasHelp(args)) {
+            printHookUsage();
+            return;
+        }
+        const hookEvent = readHookEventArg(args);
+        const code = await runClaudeHookFromStdin(process.stdin, { configuredPetId: readPetArg(args), clientLabel: readHookClientLabelArg(args, hookEvent), projectLocal: hasProjectLocalArg(args), eventName: hookEvent, debug: process.env.OPENPETS_DEBUG === "1" });
+        process.exitCode = code;
+        return;
+    }
+    if (command === "plugin") {
+        const [subcommand, ...rest] = args;
+        if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+            printPluginUsage();
+            return;
+        }
+        if (subcommand === "new" || subcommand === "init") {
+            if (hasHelp(rest)) {
+                printPluginUsage();
+                return;
+            }
+            scaffoldPlugin(parsePluginNewArgs(rest));
+            return;
+        }
+        if (subcommand === "validate") {
+            if (hasHelp(rest)) {
+                printPluginUsage();
+                return;
+            }
+            const target = rest.find((arg) => !arg.startsWith("--")) ?? ".";
+            const result = validatePluginFolder(target);
+            if (result.ok) {
+                process.stdout.write(`Plugin manifest and declared files look valid: ${resolve(target)}\n`);
+                return;
+            }
+            process.stderr.write(`Plugin validation failed (${result.issues.length} issue${result.issues.length === 1 ? "" : "s"}):\n`);
+            for (const issue of result.issues)
+                process.stderr.write(`  ${issue.path}: ${issue.message}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        throw new CliError(`Unknown plugin subcommand: ${subcommand}`);
+    }
+    throw new CliError(`Unknown command: ${command}`);
+}
+async function installPetFromCatalog(options) {
+    const client = createOpenPetsClient({ responseTimeoutMs: 60_000 });
+    const result = await client.installPet(options.petId);
+    process.stdout.write(`Installed OpenPets pet: ${sanitizeTerminalText(result.displayName)} (${result.petId})\n`);
+}
+async function showStatus(args) {
+    if (args.length !== 0)
+        throw new CliError(`Unknown status option: ${args[0]}`);
+    const result = await createOpenPetsClient().status();
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    if (!result.ok || !result.appRunning)
+        process.exitCode = 1;
+}
+export function parseDoctorArgs(args) {
+    let cwd = process.cwd();
+    let json = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--json")
+            json = true;
+        else if (arg === "--cwd") {
+            cwd = readRequiredArg(args, index, "--cwd");
+            index += 1;
+        }
+        else if (arg.startsWith("--cwd="))
+            cwd = arg.slice("--cwd=".length);
+        else
+            throw new CliError(`Unknown doctor option: ${arg}`);
+    }
+    return { cwd, json };
+}
+export async function runDoctor(options) {
+    const claude = doctorClaudeHooks();
+    const projectDir = resolveProjectDir(options.cwd);
+    const cursorConfigPath = getCursorProjectMcpPath(projectDir);
+    const cursorRead = readCursorMcpConfig(cursorConfigPath);
+    const cursor = classifyCursorMcpStatus(cursorRead, cursorConfigPath, { mcpVersion: getPackageVersion() });
+    const codexConfigPath = getProjectCodexConfigPath(projectDir);
+    const codex = classifyCodexConfigText(existsSync(codexConfigPath) ? readFileSync(codexConfigPath, "utf8") : "", codexConfigPath);
+    const appStatus = await createOpenPetsClient().status();
+    const app = { running: appStatus.appRunning, reason: appStatus.unavailableReason };
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            claude: { status: claude.status, settingsPath: claude.settingsPath, asyncSupported: claude.asyncSupported },
+            codex: { status: codex.status, configPath: codex.configPath, hookTrustStatus: codex.hookTrustStatus, hookTrustMessage: codex.hookTrustMessage },
+            cursor: { status: cursor.status, configPath: cursor.configPath },
+            app,
+        }, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(`- Claude hooks: ${claude.status} (${claude.settingsPath})\n`);
+        process.stdout.write(`- Codex setup: ${codex.status} (${codex.configPath})\n`);
+        if (codex.hookTrustStatus !== "unknown")
+            process.stdout.write(`- Codex hook permission: ${codex.hookTrustStatus} (${codex.hookTrustMessage})\n`);
+        process.stdout.write(`- Cursor MCP: ${cursor.status} (${cursor.configPath})\n`);
+        process.stdout.write(`- OpenPets app: ${app.running ? "running" : `not running${app.reason ? ` (${app.reason})` : ""}`}\n`);
+    }
+    if (claude.status === "error" || codex.status === "error" || cursor.status === "error" || cursor.status === "invalid")
+        process.exitCode = 1;
+}
+async function showPets(args) {
+    if (args.length !== 0)
+        throw new CliError(`Unknown pets option: ${args[0]}`);
+    const result = await createOpenPetsClient().listPets();
+    for (const pet of result.pets) {
+        const flags = [pet.id === result.defaultPetId ? "default" : undefined, pet.broken ? "broken" : undefined].filter(Boolean).join(", ");
+        process.stdout.write(`${sanitizeTerminalText(pet.displayName)} (${pet.id})${flags ? ` [${flags}]` : ""}\n`);
+    }
+}
+async function sendReaction(options) {
+    await createOpenPetsClient({ source: "cli" }).react(options.reaction);
+    process.stdout.write(`OpenPets reaction sent: ${options.reaction}\n`);
+}
+async function sendMessage(options) {
+    await createOpenPetsClient({ source: "cli" }).say(options.message, options.reaction ? { reaction: options.reaction } : undefined);
+    process.stdout.write("OpenPets message sent.\n");
+}
+export async function configureProject(options) {
+    const projectDir = resolveProjectDir(options.cwd);
+    if (options.agent === "cursor") {
+        await configureCursorProject(options, projectDir);
+        return;
+    }
+    if (options.agent === "opencode") {
+        await configureOpenCodeProject(options, projectDir);
+        return;
+    }
+    if (options.agent === "codex") {
+        await configureCodexProject(options, projectDir);
+        return;
+    }
+    assertClaudeAvailable();
+    assertSafeProjectHookPath(projectDir);
+    const client = createOpenPetsClient();
+    const selectedPet = await resolveConfiguredPet(client, options.petId);
+    const petId = selectedPet.id;
+    const packageVersion = getPackageVersion();
+    const mcpCommand = options.localDev ? createLocalDevCliCommand(["mcp", "--pet", petId]) : createVersionPinnedCliCommand(packageVersion, ["mcp", "--pet", petId]);
+    const hookCommand = formatShellCommand(options.localDev ? createLocalDevCliCommand(["hook", openPetsHookMarker, "--project-local", "--pet", petId]) : createVersionPinnedCliCommand(packageVersion, ["hook", openPetsHookMarker, "--project-local", "--pet", petId]));
+    const mcpConfig = { type: "stdio", command: mcpCommand.command, args: mcpCommand.args, env: {} };
+    const preparedHooks = prepareProjectLocalHooks(projectDir, hookCommand);
+    runClaudeMcpAddJson(projectDir, mcpConfig, options.force);
+    writePreparedHooks(preparedHooks);
+    process.stdout.write(`OpenPets configured for Claude in ${projectDir}.\nPet: ${sanitizeTerminalText(selectedPet.displayName)} (${selectedPet.id})\n`);
+}
+async function configureCodexProject(options, projectDir) {
+    assertSafeProjectCodexConfigPath(projectDir);
+    const client = createOpenPetsClient();
+    const selectedPet = await resolveConfiguredPet(client, options.petId);
+    const petId = selectedPet.id;
+    const packageVersion = getPackageVersion();
+    const mcpCommand = options.localDev ? createLocalDevCliCommand(["mcp", "--pet", petId]) : createVersionPinnedCliCommand(packageVersion, ["mcp", "--pet", petId]);
+    const hookCommand = options.localDev ? createLocalDevCliCommand(["hook", openPetsHookMarker, "--project-local", "--pet", petId]) : createVersionPinnedCliCommand(packageVersion, ["hook", openPetsHookMarker, "--project-local", "--pet", petId]);
+    const configPath = getProjectCodexConfigPath(projectDir);
+    const current = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+    const next = updateCodexConfigText(current, { mcpCommand, hookCommand }, options.force);
+    writeCodexConfig(configPath, next);
+    process.stdout.write(`OpenPets configured for Codex in ${projectDir}.\nPet: ${sanitizeTerminalText(selectedPet.displayName)} (${selectedPet.id})\nConfig: ${configPath}\nRestart Codex in this project, run /hooks, and trust the OpenPets hooks before reactions can run.\n`);
+}
+async function configureCursorProject(options, projectDir) {
+    const configPath = getCursorProjectMcpPath(projectDir);
+    const rulesPath = getCursorProjectRulesPath(projectDir);
+    if (options.cursorRulesMode === "only") {
+        configureCursorRulesOnly(projectDir, rulesPath, options.force);
+        return;
+    }
+    if (options.cursorRulesMode === "remove") {
+        removeCursorRulesOnly(projectDir, rulesPath);
+        return;
+    }
+    const client = createOpenPetsClient();
+    const selectedPet = await resolveConfiguredPet(client, options.petId);
+    const packageVersion = getPackageVersion();
+    const previewOptions = { mcpVersion: packageVersion, petId: selectedPet.id, commandMode: options.localDev ? "local" : "published", mcpEntryPath: options.localDev ? require.resolve("@burmese/mcp") : undefined };
+    const readResult = readCursorMcpConfig(configPath);
+    const status = classifyCursorMcpStatus(readResult, configPath, previewOptions);
+    process.stdout.write(`Cursor config: ${configPath}\nStatus: ${status.status} - ${status.message}\nOpenPets MCP preview:\n${JSON.stringify(buildOpenPetsOnlyPreview(previewOptions), null, 2)}\n`);
+    const rulesRequested = options.cursorRulesMode === "with";
+    const rulesReadResult = rulesRequested ? readCursorOpenPetsRules(projectDir) : undefined;
+    const rulesStatus = rulesReadResult ? classifyCursorRulesStatus(rulesReadResult, rulesPath) : undefined;
+    if (rulesStatus) {
+        process.stdout.write(`Cursor rules: ${rulesPath}\nRules status: ${rulesStatus.status} - ${rulesStatus.message}\nOpenPets rules preview:\n${buildCursorRulesPreview()}\n`);
+    }
+    if (status.status === "installed" && (!rulesRequested || rulesStatus?.status === "installed")) {
+        process.stdout.write(`OpenPets is already configured for Cursor in ${projectDir}.\nRestart or reload Cursor or start a new chat in this project to load OpenPets.\n`);
+        return;
+    }
+    if (status.status === "invalid" || status.status === "error") {
+        throw new CliError(`${status.message} Fix ${configPath}, then rerun setup.`);
+    }
+    if (status.status === "conflict" && !options.force) {
+        throw new CliError(`Cursor already has a non-OpenPets openpets MCP entry. Rerun with --force to replace only mcpServers.openpets.`);
+    }
+    if (rulesStatus && (rulesStatus.status === "invalid" || rulesStatus.status === "error")) {
+        throw new CliError(`${rulesStatus.message} Fix ${rulesPath}, then rerun setup.`);
+    }
+    if (rulesStatus?.status === "conflict" && !options.force) {
+        throw new CliError("Cursor already has .cursor/rules/openpets.mdc with user content. Rerun with --force to replace only that file.");
+    }
+    const plan = status.status === "installed" ? undefined : status.status === "conflict" ? planCursorMcpReplace(configPath, previewOptions) : planCursorMcpInstall(configPath, previewOptions, options.force);
+    if (plan && "ok" in plan)
+        throw new CliError(plan.message);
+    const rulesPlan = rulesRequested && rulesStatus?.status !== "installed" ? rulesStatus?.status === "conflict" ? planCursorRulesReplace(projectDir) : planCursorRulesInstall(projectDir, options.force) : undefined;
+    if (rulesPlan && "ok" in rulesPlan)
+        throw new CliError(rulesPlan.message);
+    if (plan)
+        executeCursorMcpWrite(plan);
+    if (rulesPlan)
+        executeCursorRulesWrite(rulesPlan);
+    const backups = [plan?.backupPath ? `MCP backup: ${plan.backupPath}` : undefined, rulesPlan?.backupPath ? `Rules backup: ${rulesPlan.backupPath}` : undefined].filter(Boolean).join("\n");
+    process.stdout.write(`OpenPets configured for Cursor in ${projectDir}.\nPet: ${sanitizeTerminalText(selectedPet.displayName)} (${selectedPet.id})\n${backups ? `${backups}\n` : ""}Restart or reload Cursor or start a new chat in this project to load OpenPets.\nTo remove MCP, delete mcpServers.openpets from ${configPath}. To remove rules, run with --remove-rules.\n`);
+}
+function configureCursorRulesOnly(projectDir, rulesPath, force) {
+    const readResult = readCursorOpenPetsRules(projectDir);
+    const status = classifyCursorRulesStatus(readResult, rulesPath);
+    process.stdout.write(`Cursor rules: ${rulesPath}\nRules status: ${status.status} - ${status.message}\nOpenPets rules preview:\n${buildCursorRulesPreview()}\n`);
+    if (status.status === "installed") {
+        process.stdout.write("OpenPets Cursor rules are already installed. Cursor may use changed rules in a new or refreshed chat.\n");
+        return;
+    }
+    if (status.status === "invalid" || status.status === "error")
+        throw new CliError(`${status.message} Fix ${rulesPath}, then rerun setup.`);
+    if (status.status === "conflict" && !force)
+        throw new CliError("Cursor already has .cursor/rules/openpets.mdc with user content. Rerun with --force to replace only that file.");
+    const plan = status.status === "conflict" ? planCursorRulesReplace(projectDir) : planCursorRulesInstall(projectDir, force);
+    if ("ok" in plan)
+        throw new CliError(plan.message);
+    executeCursorRulesWrite(plan);
+    process.stdout.write(`Installed OpenPets Cursor rules in ${projectDir}.\nRules file: ${rulesPath}\n${plan.backupPath ? `Backup: ${plan.backupPath}\n` : ""}Cursor may use changed rules in a new or refreshed chat.\n`);
+}
+function removeCursorRulesOnly(projectDir, rulesPath) {
+    const readResult = readCursorOpenPetsRules(projectDir);
+    const status = classifyCursorRulesStatus(readResult, rulesPath);
+    process.stdout.write(`Cursor rules: ${rulesPath}\nRules status: ${status.status} - ${status.message}\n`);
+    if (status.status === "missing") {
+        process.stdout.write("OpenPets Cursor rules are already absent.\n");
+        return;
+    }
+    if (status.status === "invalid" || status.status === "error")
+        throw new CliError(`${status.message} Fix ${rulesPath}, then rerun setup.`);
+    if (status.status === "conflict")
+        throw new CliError("Cannot remove .cursor/rules/openpets.mdc because it is not managed by OpenPets.");
+    const plan = planCursorRulesRemove(projectDir);
+    if ("ok" in plan)
+        throw new CliError(plan.message);
+    executeCursorRulesWrite(plan);
+    process.stdout.write(`Removed OpenPets Cursor rules from ${projectDir}.\n${plan.backupPath ? `Backup: ${plan.backupPath}\n` : ""}Cursor may use changed rules in a new or refreshed chat.\n`);
+}
+async function configureOpenCodeProject(options, projectDir) {
+    const client = createOpenPetsClient();
+    const selectedPet = await resolveConfiguredPet(client, options.petId);
+    const packageVersion = getPackageVersion();
+    const prepared = prepareOpenCodeProjectSetup({ projectDir, petId: selectedPet.id, cliVersion: packageVersion, commandMode: options.localDev ? "local" : "published", cliEntryPath: options.localDev ? fileURLToPath(import.meta.url) : undefined });
+    writePreparedOpenCodeProjectSetup(prepared);
+    process.stdout.write(`OpenPets configured for OpenCode in ${projectDir}.\nPet: ${sanitizeTerminalText(selectedPet.displayName)} (${selectedPet.id})\nConfig: ${prepared.configPath}\nInstructions: ${prepared.instructionPath}\nWarning: .opencode config/instructions can be committed and include the selected pet id.\nRestart OpenCode in this project to load OpenPets.\n`);
+}
+export async function resolveConfiguredPet(client, petId) {
+    if (petId) {
+        const id = validateOpenPetsPetArg(petId);
+        return { id, displayName: id };
+    }
+    const petList = await getInstalledPets(client);
+    const id = validateOpenPetsPetArg(await pickPet(petList.pets));
+    const selectedPet = petList.pets.find((pet) => pet.id === id);
+    if (!selectedPet || selectedPet.broken)
+        throw new CliError(`Pet is not installed or usable: ${id}`);
+    return { id: selectedPet.id, displayName: selectedPet.displayName };
+}
+export function parseConfigureArgs(args) {
+    let agent = "claude";
+    let petId;
+    let cwd = process.cwd();
+    let yes = false;
+    let force = false;
+    let localDev = false;
+    let cursorRulesMode;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--yes" || arg === "-y")
+            yes = true;
+        else if (arg === "--force" || arg === "--replace")
+            force = true;
+        else if (arg === "--local-dev")
+            localDev = true;
+        else if (arg === "--with-rules")
+            cursorRulesMode = setCursorRulesMode(cursorRulesMode, "with");
+        else if (arg === "--rules-only")
+            cursorRulesMode = setCursorRulesMode(cursorRulesMode, "only");
+        else if (arg === "--remove-rules")
+            cursorRulesMode = setCursorRulesMode(cursorRulesMode, "remove");
+        else if (arg === "--agent") {
+            agent = readRequiredArg(args, index, "--agent");
+            index += 1;
+        }
+        else if (arg.startsWith("--agent="))
+            agent = arg.slice("--agent=".length);
+        else if (arg === "--pet") {
+            petId = validateOpenPetsPetArg(readRequiredArg(args, index, "--pet"));
+            index += 1;
+        }
+        else if (arg.startsWith("--pet="))
+            petId = validateOpenPetsPetArg(arg.slice("--pet=".length));
+        else if (arg === "--cwd") {
+            cwd = readRequiredArg(args, index, "--cwd");
+            index += 1;
+        }
+        else if (arg.startsWith("--cwd="))
+            cwd = arg.slice("--cwd=".length);
+        else
+            throw new CliError(`Unknown configure option: ${arg}`);
+    }
+    if (agent !== "claude" && agent !== "opencode" && agent !== "cursor" && agent !== "codex")
+        throw new CliError(`Unsupported agent: ${agent}. Supported agents: claude, codex, opencode, cursor.`);
+    if (cursorRulesMode && agent !== "cursor")
+        throw new CliError("Cursor rules flags require --agent cursor.");
+    return { agent, petId, cwd, yes, force, localDev, cursorRulesMode };
+}
+function setCursorRulesMode(current, next) {
+    if (current && current !== next)
+        throw new CliError("Use only one of --with-rules, --rules-only, or --remove-rules.");
+    return next;
+}
+export function parseInstallArgs(args) {
+    if (args.length !== 1)
+        throw new CliError("Usage: openpets install <pet-id>");
+    return { petId: validateOpenPetsPetArg(args[0] ?? "") };
+}
+export function parsePluginNewArgs(args) {
+    let name;
+    let id;
+    let dir;
+    let author;
+    let template;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--id") {
+            id = readRequiredArg(args, index, "--id");
+            index += 1;
+        }
+        else if (arg.startsWith("--id="))
+            id = arg.slice("--id=".length);
+        else if (arg === "--dir") {
+            dir = readRequiredArg(args, index, "--dir");
+            index += 1;
+        }
+        else if (arg.startsWith("--dir="))
+            dir = arg.slice("--dir=".length);
+        else if (arg === "--author") {
+            author = readRequiredArg(args, index, "--author");
+            index += 1;
+        }
+        else if (arg.startsWith("--author="))
+            author = arg.slice("--author=".length);
+        else if (arg === "--template") {
+            template = readRequiredArg(args, index, "--template");
+            index += 1;
+        }
+        else if (arg.startsWith("--template="))
+            template = arg.slice("--template=".length);
+        else if (arg.startsWith("--"))
+            throw new CliError(`Unknown plugin new option: ${arg}`);
+        else if (name === undefined)
+            name = arg;
+        else
+            throw new CliError(`Unexpected argument: ${arg}`);
+    }
+    const cleanName = (name ?? "").trim();
+    if (!cleanName)
+        throw new CliError("Usage: openpets plugin new <name> [--template <template>] [--id <id>] [--dir <path>] [--author <name>]");
+    if (cleanName.length > 60 || /[\x00-\x1F\x7F]/.test(cleanName))
+        throw new CliError("Plugin name must be 1-60 printable characters.");
+    const slug = slugifyPluginName(cleanName);
+    if (!slug)
+        throw new CliError("Plugin name must contain at least one letter or number.");
+    const finalId = (id ?? `local.${slug}`).trim();
+    if (!isValidPluginId(finalId))
+        throw new CliError("Plugin id must be 1-64 chars (letters, numbers, dot, dash, underscore) and cannot start with a dot.");
+    const finalTemplate = (template ?? "blank").trim();
+    if (!pluginTemplateNames.includes(finalTemplate))
+        throw new CliError(`Unknown plugin template: ${finalTemplate}. Templates: ${pluginTemplateNames.join(", ")}.`);
+    return { name: cleanName, id: finalId, dir: dir ?? slug, author: author?.trim() || undefined, template: finalTemplate };
+}
+function slugifyPluginName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function isValidPluginId(id) {
+    return /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(id);
+}
+export function scaffoldPlugin(options) {
+    const targetDir = resolve(options.dir);
+    const manifestPath = join(targetDir, "openpets.plugin.json");
+    const entryPath = join(targetDir, "index.js");
+    if (existsSync(manifestPath) || existsSync(entryPath))
+        throw new CliError(`A plugin already exists at ${targetDir}. Choose another --dir.`);
+    mkdirSync(targetDir, { recursive: true });
+    const dirStats = lstatSync(targetDir);
+    if (dirStats.isSymbolicLink() || !dirStats.isDirectory())
+        throw new CliError("Target plugin path must be a directory.");
+    const template = pluginTemplates[options.template];
+    const manifest = {
+        $schema: "https://openpets.dev/schemas/openpets.plugin.schema.json",
+        manifestVersion: 3,
+        id: options.id,
+        name: options.name,
+        version: "1.0.0",
+        description: `${options.name} — ${template.description}`,
+        runtime: "javascript",
+        entry: "index.js",
+        sdkVersion: "3.0.0",
+        permissions: template.permissions,
+        configSchema: template.configSchema,
+    };
+    const templateContext = { id: options.id, name: options.name };
+    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+    writeFileSync(entryPath, template.entry(templateContext), { encoding: "utf8", flag: "wx" });
+    writeFileSync(join(targetDir, "test.js"), template.test(templateContext), { encoding: "utf8", flag: "wx" });
+    // Templates that localize host-rendered strings ($t:) or runtime bodies
+    // (ctx.t) ship a source locales/en.json; the host loads locales/<locale>.json
+    // and falls back to en. Write it whenever the template declares one.
+    if (template.locales) {
+        const localesDir = join(targetDir, "locales");
+        mkdirSync(localesDir, { recursive: true });
+        writeFileSync(join(localesDir, "en.json"), `${JSON.stringify(template.locales(templateContext), null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+    }
+    const packageJsonPath = join(targetDir, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        writeFileSync(packageJsonPath, `${JSON.stringify({ name: slugifyPluginName(options.name) || "openpets-plugin", private: true, type: "module", scripts: { test: "node test.js" }, devDependencies: { "@burmese/plugin-sdk": "^3.0.0" } }, null, 2)}\n`, { encoding: "utf8" });
+    }
+    const readmePath = join(targetDir, "README.md");
+    if (!existsSync(readmePath))
+        writeFileSync(readmePath, pluginReadmeTemplate(options, targetDir), { encoding: "utf8" });
+    process.stdout.write(`Created OpenPets plugin "${sanitizeTerminalText(options.name)}" (${options.id}) from the ${options.template} template\n  ${targetDir}\n\n` +
+        "Next steps:\n" +
+        "  1. npm install              # pulls @burmese/plugin-sdk for types + the test kit\n" +
+        "  2. npm test                 # deterministic harness, no app needed\n" +
+        "  3. From the OpenPets repo root, run it live with hot reload:\n" +
+        `     OPENPETS_DEV_PLUGIN_PATHS=${targetDir} pnpm dev:desktop\n` +
+        "  4. Open Tray → Plugins, enable it, then right-click your pet.\n\n" +
+        `Validate anytime: openpets plugin validate ${targetDir}\n` +
+        "Docs: https://openpets.dev/sdk\n");
+    return { dir: targetDir, manifestPath, entryPath };
+}
+function pluginReadmeTemplate(options, targetDir) {
+    return `# ${options.name}
+
+An OpenPets plugin (\`${options.id}\`).
+
+## Develop
+
+\`\`\`bash
+# optional: editor autocomplete + type-checking
+npm i -D @burmese/plugin-sdk
+
+# from the OpenPets repo root, load this folder and launch the app
+OPENPETS_DEV_PLUGIN_PATHS=${targetDir} pnpm dev:desktop
+\`\`\`
+
+Then open **Tray → Plugins**, enable the plugin, and right-click your pet to
+run its commands.
+
+## Learn more
+
+- SDK guide: https://openpets.dev/sdk
+- Reference: https://openpets.dev/docs/plugin-sdk
+`;
+}
+export function parseReactArgs(args) {
+    if (args.length !== 1)
+        throw new CliError("Usage: openpets react <reaction>");
+    return { reaction: parseReaction(args[0] ?? "") };
+}
+export function parseSayArgs(args) {
+    let reaction;
+    const messageParts = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--reaction") {
+            reaction = parseReaction(readRequiredArg(args, index, "--reaction"));
+            index += 1;
+        }
+        else if (arg.startsWith("--reaction=")) {
+            reaction = parseReaction(arg.slice("--reaction=".length));
+        }
+        else if (arg.startsWith("--")) {
+            throw new CliError(`Unknown say option: ${arg}`);
+        }
+        else {
+            messageParts.push(arg);
+        }
+    }
+    const message = messageParts.join(" ").trim();
+    if (!message)
+        throw new CliError("Usage: openpets say <message> [--reaction <reaction>]");
+    return { message, reaction };
+}
+function parseReaction(value) {
+    if (!allowedReactions.includes(value)) {
+        throw new CliError(`Invalid OpenPets reaction: ${value}. Allowed reactions: ${allowedReactions.join(", ")}.`);
+    }
+    return value;
+}
+export function createVersionPinnedCliCommand(version, args) {
+    return { command: "npx", args: ["-y", `${cliPackageName}@${version}`, ...args] };
+}
+export function createLocalDevCliCommand(args) {
+    return { command: process.execPath, args: [fileURLToPath(import.meta.url), ...args] };
+}
+export function createClaudeMcpAddJsonArgs(config) {
+    return ["mcp", "add-json", "openpets", JSON.stringify(config), "--scope", "local"];
+}
+export function installProjectLocalHooks(projectDir, hookCommand) {
+    writePreparedHooks(prepareProjectLocalHooks(projectDir, hookCommand));
+}
+export function prepareProjectLocalHooks(projectDir, hookCommand) {
+    assertSafeProjectHookPath(projectDir);
+    const settingsPath = getProjectLocalSettingsPath(realpathSync(projectDir));
+    const current = readJsonObject(settingsPath);
+    const cleaned = removeOpenPetsHooks(current);
+    const hooks = isRecord(cleaned.hooks) ? { ...cleaned.hooks } : {};
+    for (const event of claudeHookEvents) {
+        if (hooks[event] !== undefined && !Array.isArray(hooks[event]))
+            throw new CliError(`Claude local settings hooks.${event} must be an array.`);
+        const existing = Array.isArray(hooks[event]) ? hooks[event] : [];
+        hooks[event] = [...existing, { hooks: [createHookCommandEntry(hookCommand)] }];
+    }
+    return { settingsPath, settings: { ...cleaned, hooks } };
+}
+function writePreparedHooks(prepared) {
+    writeJsonFile(prepared.settingsPath, prepared.settings);
+}
+function createHookCommandEntry(command) {
+    return { type: "command", command, timeout: 10, async: true, asyncRewake: false };
+}
+export function runClaudeMcpAddJson(projectDir, config, force = false) {
+    if (force)
+        runClaudeMcpRemove(projectDir);
+    const result = spawnSync("claude", createClaudeMcpAddJsonArgs(config), { cwd: projectDir, encoding: "utf8", shell: false, stdio: ["ignore", "pipe", "pipe"], timeout: 10_000 });
+    if (result.error)
+        throw new CliError(`Claude Code is unavailable on PATH: ${result.error.message}`);
+    if (result.status !== 0)
+        throw new CliError(`Claude MCP configuration failed: ${(result.stderr || result.stdout || "unknown error").trim()}`);
+}
+function runClaudeMcpRemove(projectDir) {
+    const result = spawnSync("claude", ["mcp", "remove", "openpets", "--scope", "local"], { cwd: projectDir, encoding: "utf8", shell: false, stdio: ["ignore", "pipe", "pipe"], timeout: 10_000 });
+    if (result.error)
+        throw new CliError(`Claude Code is unavailable on PATH: ${result.error.message}`);
+    const output = `${result.stderr || ""}\n${result.stdout || ""}`;
+    if (result.status !== 0 && !/not found|does not exist|no server|unknown/i.test(output)) {
+        throw new CliError(`Claude MCP remove failed: ${(result.stderr || result.stdout || "unknown error").trim()}`);
+    }
+}
+async function runMcp(args) {
+    const entry = require.resolve("@burmese/mcp");
+    await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(process.execPath, [entry, ...args], { stdio: "inherit" });
+        const forwardSigint = () => { child.kill("SIGINT"); };
+        const forwardSigterm = () => { child.kill("SIGTERM"); };
+        process.once("SIGINT", forwardSigint);
+        process.once("SIGTERM", forwardSigterm);
+        child.on("error", rejectPromise);
+        child.on("exit", (code, signal) => {
+            process.off("SIGINT", forwardSigint);
+            process.off("SIGTERM", forwardSigterm);
+            if (signal) {
+                process.kill(process.pid, signal);
+                return;
+            }
+            process.exitCode = code ?? 1;
+            resolvePromise();
+        });
+    });
+}
+async function getInstalledPets(client) {
+    try {
+        return await client.listPets();
+    }
+    catch (error) {
+        if (error instanceof OpenPetsClientError && error.code === "unknown_method")
+            throw new CliError("OpenPets desktop app is too old for project setup. Update/restart OpenPets and try again.");
+        throw new CliError("OpenPets desktop app is not running. Open OpenPets, then run this command again.");
+    }
+}
+async function pickPet(pets) {
+    const usable = pets.filter((pet) => !pet.broken);
+    if (usable.length === 0)
+        throw new CliError("No usable installed pets found. Open OpenPets and install a pet first.");
+    if (!process.stdin.isTTY)
+        throw new CliError("Missing --pet <id>. Non-interactive shells must pass --pet.");
+    process.stdout.write("Pick pet for this project:\n");
+    usable.forEach((pet, index) => process.stdout.write(`  ${index + 1}. ${sanitizeTerminalText(pet.displayName)} (${pet.id})\n`));
+    const rl = createInterface({ input, output });
+    try {
+        const answer = await rl.question("Pet number: ");
+        const index = Number(answer.trim()) - 1;
+        if (!Number.isInteger(index) || !usable[index])
+            throw new CliError("Invalid pet selection.");
+        return usable[index].id;
+    }
+    finally {
+        rl.close();
+    }
+}
+function sanitizeTerminalText(value) {
+    return value.replace(/[\x00-\x1F\x7F]/g, "").slice(0, 100);
+}
+function resolveProjectDir(cwd) {
+    const resolved = resolve(cwd);
+    const stats = lstatSync(resolved);
+    if (stats.isSymbolicLink())
+        throw new CliError("Project directory cannot be a symlink.");
+    if (!stats.isDirectory())
+        throw new CliError("Project path must be a directory.");
+    return realpathSync(resolved);
+}
+function assertClaudeAvailable() {
+    const result = spawnSync("claude", ["--version"], { shell: false, stdio: "ignore", timeout: 5_000 });
+    if (result.error || result.status !== 0)
+        throw new CliError("Claude Code is unavailable on PATH. Install Claude Code, then try again.");
+}
+export function assertSafeProjectHookPath(projectDir) {
+    const projectReal = realpathSync(projectDir);
+    const claudeDir = join(projectReal, ".claude");
+    if (existsSync(claudeDir)) {
+        const claudeStats = lstatSync(claudeDir);
+        if (claudeStats.isSymbolicLink())
+            throw new CliError("Project .claude directory cannot be a symlink.");
+        if (!claudeStats.isDirectory())
+            throw new CliError("Project .claude path must be a directory.");
+        const rel = relative(projectReal, realpathSync(claudeDir));
+        if (rel.startsWith("..") || isAbsolute(rel))
+            throw new CliError("Project .claude directory escapes the project.");
+    }
+    const settingsPath = getProjectLocalSettingsPath(projectReal);
+    if (existsSync(settingsPath)) {
+        const settingsStats = lstatSync(settingsPath);
+        if (settingsStats.isSymbolicLink())
+            throw new CliError("Project Claude local settings file cannot be a symlink.");
+        if (!settingsStats.isFile())
+            throw new CliError("Project Claude local settings path must be a file.");
+    }
+    const settingsRel = relative(projectReal, resolve(settingsPath));
+    if (settingsRel.startsWith("..") || isAbsolute(settingsRel))
+        throw new CliError("Project Claude local settings path escapes the project.");
+}
+export function assertSafeProjectCodexConfigPath(projectDir) {
+    const projectReal = realpathSync(projectDir);
+    const codexDir = join(projectReal, ".codex");
+    if (existsSync(codexDir)) {
+        const codexStats = lstatSync(codexDir);
+        if (codexStats.isSymbolicLink())
+            throw new CliError("Project .codex directory cannot be a symlink.");
+        if (!codexStats.isDirectory())
+            throw new CliError("Project .codex path must be a directory.");
+        const rel = relative(projectReal, realpathSync(codexDir));
+        if (rel.startsWith("..") || isAbsolute(rel))
+            throw new CliError("Project .codex directory escapes the project.");
+    }
+    const configPath = getProjectCodexConfigPath(projectReal);
+    if (existsSync(configPath)) {
+        const configStats = lstatSync(configPath);
+        if (configStats.isSymbolicLink())
+            throw new CliError("Project Codex config file cannot be a symlink.");
+        if (!configStats.isFile())
+            throw new CliError("Project Codex config path must be a file.");
+    }
+    const configRel = relative(projectReal, resolve(configPath));
+    if (configRel.startsWith("..") || isAbsolute(configRel))
+        throw new CliError("Project Codex config path escapes the project.");
+}
+function getProjectLocalSettingsPath(projectDir) {
+    return join(projectDir, ".claude", "settings.local.json");
+}
+function getProjectCodexConfigPath(projectDir) {
+    return join(projectDir, ".codex", "config.toml");
+}
+function readJsonObject(path) {
+    if (!existsSync(path))
+        return {};
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!isRecord(parsed) || Array.isArray(parsed))
+        throw new CliError("Claude local settings must be a JSON object.");
+    if (parsed.hooks !== undefined && !isRecord(parsed.hooks))
+        throw new CliError("Claude local settings hooks field must be an object.");
+    return parsed;
+}
+function writeJsonFile(path, value) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const parentStats = lstatSync(dirname(path));
+    if (parentStats.isSymbolicLink() || !parentStats.isDirectory())
+        throw new CliError("Project .claude directory is unsafe after creation.");
+    const tempPath = `${path}.${process.pid}.tmp`;
+    writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    renameSync(tempPath, path);
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch { /* best effort */ }
+}
+function readPetArg(args) {
+    const equals = args.find((arg) => arg.startsWith("--pet="));
+    if (equals)
+        return validateOpenPetsPetArg(equals.slice("--pet=".length));
+    const index = args.indexOf("--pet");
+    const value = index >= 0 ? args[index + 1] : undefined;
+    if (index >= 0 && (!value || value.startsWith("--")))
+        throw new CliError("Missing value for --pet.");
+    return value && value.length > 0 ? validateOpenPetsPetArg(value) : undefined;
+}
+function hasProjectLocalArg(args) {
+    return args.includes("--project-local");
+}
+function readHookEventArg(args) {
+    const equals = args.find((arg) => arg.startsWith("--hook-event="));
+    const value = equals ? equals.slice("--hook-event=".length) : args.includes("--hook-event") ? args[args.indexOf("--hook-event") + 1] : undefined;
+    if (args.includes("--hook-event") && (!value || value.startsWith("--")))
+        throw new CliError("Missing value for --hook-event.");
+    if (value === undefined)
+        return undefined;
+    if (!["UserPromptSubmit", "PreToolUse", "PostToolUse", "PermissionRequest", "Notification", "Stop", "StopFailure"].includes(value))
+        throw new CliError(`Unsupported hook event: ${value}.`);
+    return value;
+}
+function readHookClientLabelArg(args, eventName) {
+    const equals = args.find((arg) => arg.startsWith("--client-label="));
+    const value = equals ? equals.slice("--client-label=".length) : args.includes("--client-label") ? args[args.indexOf("--client-label") + 1] : undefined;
+    if (args.includes("--client-label") && (!value || value.startsWith("--")))
+        throw new CliError("Missing value for --client-label.");
+    if (value !== undefined)
+        return sanitizeHookClientLabel(value);
+    return eventName ? "Codex" : undefined;
+}
+function sanitizeHookClientLabel(value) {
+    const label = value.replace(/[\x00-\x1F\x7F]/g, "").trim().slice(0, 40);
+    if (label.length === 0)
+        throw new CliError("Invalid --client-label.");
+    return label;
+}
+function readRequiredArg(args, index, flag) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("--"))
+        throw new CliError(`Missing value for ${flag}.`);
+    return value;
+}
+function formatShellCommand(command) {
+    return [command.command, ...command.args].map(shellQuote).join(" ");
+}
+function shellQuote(value) {
+    if (/^[a-zA-Z0-9_@%+=:,./-]+$/.test(value))
+        return value;
+    if (/[\r\n"]/.test(value) || value.includes("\0"))
+        throw new CliError("Command argument contains unsupported shell characters.");
+    return `"${value.replaceAll("\\", "\\\\").replaceAll("$", "\\$").replaceAll("`", "\\`")}"`;
+}
+function getPackageVersion() {
+    const parsed = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    if (!isRecord(parsed) || typeof parsed.version !== "string")
+        throw new CliError("Cannot read OpenPets CLI package version.");
+    return parsed.version;
+}
+function printUsage() {
+    process.stdout.write("Usage:\n  openpets status\n  openpets doctor [--cwd <path>] [--json]\n  openpets pets\n  openpets react <reaction>\n  openpets say <message> [--reaction <reaction>]\n  openpets install <pet-id>\n  openpets configure [--agent claude|codex|opencode|cursor] [--pet <id>] [--cwd <path>] [--yes] [--force] [--with-rules|--rules-only|--remove-rules]\n  openpets plugin new <name> [--id <id>] [--dir <path>] [--author <name>]\n  openpets mcp [--pet <id>]\n  openpets hook --openpets-managed [--pet <id>] [--hook-event <event>]\n\nRun `openpets <command> --help` for command options.\n");
+}
+function printPluginUsage() {
+    process.stdout.write("Usage:\n" +
+        "  openpets plugin new <name> [--template <template>] [--id <id>] [--dir <path>] [--author <name>]\n" +
+        "  openpets plugin validate [dir]\n\n" +
+        "plugin new scaffolds a typed SDK v3 plugin with a manifest, a working entry, and a passing\n" +
+        "test built on @burmese/plugin-sdk/testing. plugin validate checks the manifest, config\n" +
+        "schema, declared assets/panels, permissions, and network hosts at author time.\n\n" +
+        "Options:\n" +
+        `  --template <t>   Template: ${pluginTemplateNames.join(", ")}. Defaults to blank.\n` +
+        "  --id <id>        Plugin id (reverse-DNS style). Defaults to local.<name-slug>.\n" +
+        "  --dir <path>     Target directory. Defaults to ./<name-slug>.\n" +
+        "  --author <name>  Author name (informational).\n" +
+        "  -h, --help       Show this help.\n\n" +
+        "Learn more: https://openpets.dev/sdk\n");
+}
+function printInstallUsage() {
+    process.stdout.write("Usage:\n  openpets install <pet-id>\n\nDownloads a gallery pet through the running OpenPets desktop app and installs it locally.\n");
+}
+function printStatusUsage() {
+    process.stdout.write("Usage:\n  openpets status\n\nChecks whether the OpenPets desktop app is reachable and prints the status response as JSON.\n");
+}
+function printDoctorUsage() {
+    process.stdout.write("Usage:\n  openpets doctor [--cwd <path>] [--json]\n\nReports whether Claude hooks, project Codex setup, project Cursor MCP, and the OpenPets desktop app are installed, need an update, or are broken.\n\nOptions:\n  --cwd <path>   Project directory to inspect for .codex/config.toml and .cursor/mcp.json. Defaults to current directory.\n  --json         Print the report as JSON instead of labeled lines.\n  -h, --help     Show this help.\n");
+}
+function printPetsUsage() {
+    process.stdout.write("Usage:\n  openpets pets\n\nLists pets installed in the running OpenPets desktop app.\n");
+}
+function printReactUsage() {
+    process.stdout.write(`Usage:\n  openpets react <reaction>\n\nSends a reaction to the running OpenPets desktop app.\nAllowed reactions: ${allowedReactions.join(", ")}.\n`);
+}
+function printSayUsage() {
+    process.stdout.write(`Usage:\n  openpets say <message> [--reaction <reaction>]\n\nShows a short message in the running OpenPets desktop app. Optionally sends a reaction with the message.\nAllowed reactions: ${allowedReactions.join(", ")}.\n`);
+}
+function printConfigureUsage() {
+    process.stdout.write("Usage:\n  openpets configure [--agent claude|codex|opencode|cursor] [--pet <id>] [--cwd <path>] [--yes] [--force] [--with-rules|--rules-only|--remove-rules]\n\nOptions:\n  --pet <id>           Pet id to use for this project. If omitted, prompts with installed pets. Cursor --rules-only/--remove-rules do not need a pet.\n  --agent <agent>      Agent to configure: claude, codex, opencode, or cursor. Defaults to claude.\n  --cwd <path>         Project directory to configure. Defaults to current directory. Codex uses <cwd>/.codex/config.toml; Cursor uses <cwd>/.cursor/mcp.json and <cwd>/.cursor/rules/openpets.mdc.\n  --with-rules         For Cursor, install MCP config and project rules after preflighting both writes.\n  --rules-only         For Cursor, install/update only .cursor/rules/openpets.mdc.\n  --remove-rules       For Cursor, remove only managed .cursor/rules/openpets.mdc.\n  --yes, -y            Accepted for scripts; no confirmation prompt is shown.\n  --force              Replace supported managed entries where applicable. Required for conflicting Cursor rules or custom Codex openpets MCP tables.\n  --replace            Alias for --force.\n  --local-dev          Use local development command paths where supported.\n  -h, --help           Show this help.\n");
+}
+function printMcpUsage() {
+    process.stdout.write("Usage:\n  openpets mcp [--pet <id>]\n\nStarts the OpenPets MCP server wrapper. This command is written into Claude MCP config by `openpets configure`.\n");
+}
+function printHookUsage() {
+    process.stdout.write("Usage:\n  openpets hook --openpets-managed [--pet <id>] [--hook-event <event>]\n\nRuns one Claude Code or Codex hook event from stdin. This command is written into managed agent hooks by `openpets configure`.\n");
+}
+function hasHelp(args) {
+    return args.includes("--help") || args.includes("-h");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+class CliError extends Error {
+}
+if (isMainModule()) {
+    main().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}
+function isMainModule() {
+    if (!process.argv[1])
+        return false;
+    try {
+        return realpathSync(resolve(process.argv[1])) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+    }
+}
+//# sourceMappingURL=index.js.map