@engram-cli/engram 0.1.0 → 0.1.1

package/README.md

@@ -55,16 +55,25 @@ Add to `~/.cursor/mcp.json` (or Cursor Settings → MCP):
 
 Available tools:
 
+- `engram_status` — backend health + masked key status
 - `engram_load_capsule` — load the saved project capsule
+- `engram_save_capsule` — freeze current Context as the project capsule
+- `engram_list_capsules` — list saved capsules for a project
 - `engram_context` — assemble live Context from Supermemory
 - `engram_search` — search project memories with a natural-language query
+- `engram_emit` — ingest a MemoryEvent (capture path)
+
+MCP resources (when `ENGRAM_PROJECT` is set or cwd resolves a project):
+
+- `engram://{project}/context` — live Context capsule
+- `engram://{project}/capsule` — saved capsule snapshot
 
 ## Development
 
 ```bash
 cd cli
 npm run dev    # tsx src/cli.ts start
-npm run build
+npm run build  # also bundles backend into bundled-backend/
 npm run typecheck
 ```
 
@@ -76,28 +85,53 @@ bash scripts/smoke.sh
 
 ## Publish (npm org `engram-cli`)
 
-Log in as an org owner (`npm login` as `shubh1305`). Publish **contracts**, then the CLI:
+Packages on npm are owned by **`shubh1305`**. You must publish while logged in as that user.
+
+```bash
+npm logout
+npm login          # use the shubh1305 account
+npm whoami         # must print: shubh1305
+
+# If 2FA is enabled on the account:
+export NPM_OTP=123456
+
+# From repo root — publishes contracts@0.1.1 then engram@0.1.1
+bash scripts/publish-npm.sh
+```
+
+The script swaps `@engram-cli/contracts` from `file:../packages/contracts` to `^<version>` for the publish, then restores the monorepo `file:` link.
+
+### Troubleshooting `E404` on publish
+
+`npm error 404 ... you do not have permission` almost always means **wrong npm account**, not a missing package:
+
+| Symptom | Fix |
+| --- | --- |
+| `npm whoami` ≠ `shubh1305` | `npm logout && npm login` as `shubh1305` |
+| `npm whoami` fails (401) | Token expired — run `npm login` again |
+| 2FA enabled | `export NPM_OTP=<6-digit code>` then re-run publish |
+| Still blocked | Confirm access: `npm access list collaborators @engram-cli/engram` |
+
+### After publish
 
 ```bash
-# 1) Contracts
-cd packages/contracts
-npm run build
-npm publish --access public
-
-# 2) CLI — switch the local file: dep to the registry version, then publish
-cd ../../cli
-# in package.json: "@engram-cli/contracts": "^0.1.0"
-npm install
-npm run build
-npm publish --access public
-# restore "file:../packages/contracts" for monorepo work after publishing
+npx @engram-cli/engram@latest start   # bundled backend (works outside monorepo)
+npx @engram-cli/engram@latest init
 ```
 
-After publish:
+`engram start` prefers the monorepo `backend/` when present; otherwise it runs the **bundled Hono backend** shipped inside the npm package. Data defaults to `~/.engram/data`. Configure keys via the extension Setup checklist, dashboard `/settings`, or `PUT /settings/global`.
+
+**Monorepo dev** (uses your local build, not npm):
 
 ```bash
-npx @engram-cli/engram start
-npx @engram-cli/engram init
+cd cli && npm run build && node dist/cli.js start
 ```
 
-Note: `engram start` looks for monorepo `backend/` via path walk. From a published install outside this repo, start the backend from a clone (or keep using the monorepo) until a standalone start path ships.
+### Verified (2026-07-22)
+
+| Check | Expected |
+| --- | --- |
+| `npm view @engram-cli/contracts version` | `0.1.1` |
+| `npm view @engram-cli/engram version` | `0.1.1` |
+| `npx @engram-cli/engram --help` | Includes `share`, `import` |
+| `npx @engram-cli/engram start` (outside repo) | Starts Supermemory + backend |

package/bundled-backend/app.js

@@ -0,0 +1,41 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { healthRoutes } from "./routes/health.js";
+import { eventRoutes } from "./routes/event.js";
+import { contextRoutes } from "./routes/context.js";
+import { capsuleRoutes } from "./routes/capsule.js";
+import { searchRoutes } from "./routes/search.js";
+import { projectRoutes } from "./routes/projects.js";
+import { settingsRoutes } from "./routes/settings.js";
+import { globalSettingsRoutes } from "./routes/global-settings.js";
+import { sharesRoutes } from "./routes/shares.js";
+const CORS_ORIGINS = [
+    "http://localhost:5173",
+    "http://localhost:3000",
+    "https://engram-context.vercel.app",
+    process.env.ENGRAM_LANDING_ORIGIN,
+].filter((o) => Boolean(o));
+export function createApp() {
+    const app = new Hono();
+    app.use("*", cors({
+        origin: CORS_ORIGINS,
+        allowMethods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+        allowHeaders: ["Content-Type"],
+        credentials: false,
+    }));
+    app.route("/", healthRoutes);
+    app.route("/", eventRoutes);
+    app.route("/", contextRoutes);
+    app.route("/", capsuleRoutes);
+    app.route("/", searchRoutes);
+    app.route("/", projectRoutes);
+    app.route("/", settingsRoutes);
+    app.route("/", globalSettingsRoutes);
+    app.route("/", sharesRoutes);
+    app.notFound((c) => c.json({ error: "not_found" }, 404));
+    app.onError((err, c) => {
+        console.error("[engram] unhandled:", err);
+        return c.json({ error: "internal_error", message: err.message }, 500);
+    });
+    return app;
+}

package/bundled-backend/capsule-assembler.js

@@ -0,0 +1,238 @@
+import { CAPS, CAPSULE_SCHEMA_VERSION, truncateBytes, } from "@engram-cli/contracts";
+import { projectContainerTag } from "@engram-cli/contracts";
+import { getSupermemory } from "./supermemory.js";
+function asMeta(raw) {
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        return raw;
+    }
+    return {};
+}
+function metaString(meta, key) {
+    const v = meta[key];
+    if (typeof v === "string" && v.length > 0)
+        return v;
+    if (typeof v === "number" || typeof v === "boolean")
+        return String(v);
+    return undefined;
+}
+function metaNumber(meta, key) {
+    const v = meta[key];
+    if (typeof v === "number" && Number.isFinite(v))
+        return v;
+    if (typeof v === "string" && v !== "" && !Number.isNaN(Number(v))) {
+        return Number(v);
+    }
+    return undefined;
+}
+async function listRecentDocs(containerTag, limit = 40) {
+    const sm = getSupermemory();
+    const res = await sm.documents.list({
+        containerTags: [containerTag],
+        includeContent: true,
+        limit,
+        sort: "createdAt",
+        order: "desc",
+    });
+    return (res.memories ?? []).map((m) => ({
+        id: m.id,
+        content: m.content,
+        summary: m.summary,
+        title: m.title,
+        createdAt: m.createdAt,
+        metadata: asMeta(m.metadata),
+    }));
+}
+function eventTypeOf(doc) {
+    const t = metaString(doc.metadata, "event_type");
+    return t;
+}
+function textOf(doc) {
+    return (doc.content || doc.summary || doc.title || "").trim();
+}
+function buildRecentFiles(docs) {
+    const files = [];
+    const seen = new Set();
+    for (const doc of docs) {
+        const t = eventTypeOf(doc);
+        if (t !== "file_open" && t !== "file_save")
+            continue;
+        const path = metaString(doc.metadata, "file_path") ||
+            textOf(doc).replace(/^(opened|saved):\s*/i, "").trim();
+        if (!path || seen.has(path))
+            continue;
+        seen.add(path);
+        files.push(path);
+        if (files.length >= CAPS.recentFiles)
+            break;
+    }
+    return files;
+}
+function buildErrors(docs) {
+    const errors = [];
+    for (const doc of docs) {
+        if (eventTypeOf(doc) !== "error")
+            continue;
+        const message = textOf(doc).replace(/^error:\s*/i, "").trim() || "error";
+        // Strip trailing " in path:line" if present for cleaner message; keep path from meta.
+        const file_path = metaString(doc.metadata, "file_path");
+        const line = metaNumber(doc.metadata, "line");
+        let clean = message;
+        if (file_path) {
+            const suffix = ` in ${file_path}${line != null ? `:${line}` : ""}`;
+            if (clean.endsWith(suffix))
+                clean = clean.slice(0, -suffix.length).trim();
+        }
+        errors.push({ message: clean, file_path, line });
+        if (errors.length >= CAPS.errors)
+            break;
+    }
+    return errors;
+}
+function buildFailedCommands(docs) {
+    const out = [];
+    for (const doc of docs) {
+        if (eventTypeOf(doc) !== "command")
+            continue;
+        const exit = metaNumber(doc.metadata, "exit_code") ?? 0;
+        if (exit === 0)
+            continue;
+        const raw = textOf(doc);
+        // "cmd (exit N): <firstline>\n<stderr...>"
+        const withoutPrefix = raw.replace(/^cmd \(exit \d+\):\s*/i, "");
+        const [first, ...rest] = withoutPrefix.split("\n");
+        const command = (first ?? withoutPrefix).trim();
+        const stderr = rest.join("\n").trim();
+        out.push({
+            command,
+            exit_code: exit,
+            stderr_tail: stderr
+                ? truncateBytes(stderr, CAPS.stderrBytes)
+                : undefined,
+            cwd: metaString(doc.metadata, "cwd"),
+        });
+        if (out.length >= CAPS.failedCommands)
+            break;
+    }
+    return out;
+}
+function buildGit(docs) {
+    let branch;
+    let last_commit;
+    for (const doc of docs) {
+        const t = eventTypeOf(doc);
+        if (t === "branch_switch" && !branch) {
+            branch = textOf(doc).replace(/^branch:\s*/i, "").trim();
+        }
+        if (t === "commit" && !last_commit) {
+            last_commit = textOf(doc).replace(/^commit:\s*/i, "").trim();
+        }
+        if (branch && last_commit)
+            break;
+    }
+    return { branch, last_commit };
+}
+function buildManualNotes(docs) {
+    const notes = [];
+    for (const doc of docs) {
+        const t = eventTypeOf(doc);
+        if (t !== "code_selection" && t !== "clipboard" && t !== "chat_summary") {
+            continue;
+        }
+        let text = textOf(doc);
+        if (t === "code_selection")
+            text = text.replace(/^selection:\s*/i, "");
+        if (t === "clipboard")
+            text = text.replace(/^clipboard:\s*/i, "");
+        if (t === "chat_summary") {
+            text = text.replace(/^chat_summary(?:\[[^\]]*\])?:\s*/i, "");
+        }
+        notes.push({
+            kind: t,
+            text: text.trim(),
+            file_path: metaString(doc.metadata, "file_path"),
+            chat_label: metaString(doc.metadata, "chat_label"),
+        });
+        if (notes.length >= CAPS.manualNotes)
+            break;
+    }
+    return notes;
+}
+function buildSummary(parts) {
+    const lines = [];
+    if (parts.profileLine)
+        lines.push(parts.profileLine);
+    if (parts.git.branch)
+        lines.push(`On branch ${parts.git.branch}.`);
+    if (parts.git.last_commit)
+        lines.push(`Last commit: ${parts.git.last_commit}.`);
+    if (parts.recent_files.length) {
+        lines.push(`Recent files: ${parts.recent_files.slice(0, 5).join(", ")}.`);
+    }
+    if (parts.errors.length) {
+        const e = parts.errors[0];
+        const loc = e.file_path
+            ? `${e.file_path}${e.line != null ? `:${e.line}` : ""}`
+            : "unknown";
+        lines.push(`Error at ${loc}: ${e.message}`);
+    }
+    if (parts.failed_commands.length) {
+        const c = parts.failed_commands[0];
+        lines.push(`Failed: \`${c.command}\` (exit ${c.exit_code}).`);
+    }
+    if (parts.manual_notes.length) {
+        const n = parts.manual_notes[0];
+        lines.push(`Note (${n.kind}): ${n.text}`);
+    }
+    if (!lines.length)
+        lines.push("No recent Engram context for this project.");
+    return truncateBytes(lines.join(" "), CAPS.summaryBytes);
+}
+export async function assembleCapsule(opts) {
+    const containerTag = projectContainerTag(opts.project);
+    const sm = getSupermemory();
+    let profileLine;
+    try {
+        const profile = await sm.profile({
+            containerTag,
+            q: "current work session",
+        });
+        const dynamic = profile.profile?.dynamic ?? [];
+        const staticFacts = profile.profile?.static ?? [];
+        const pick = [...dynamic, ...staticFacts].find((s) => typeof s === "string" && s.trim().length > 0);
+        if (pick)
+            profileLine = String(pick).trim();
+    }
+    catch (err) {
+        console.warn("[engram] profile() failed (continuing with structured fields):", err instanceof Error ? err.message : err);
+    }
+    const docs = await listRecentDocs(containerTag);
+    const recent_files = buildRecentFiles(docs);
+    const errors = buildErrors(docs);
+    const failed_commands = buildFailedCommands(docs);
+    const git = buildGit(docs);
+    const manual_notes = buildManualNotes(docs);
+    // Prefer IDE from most recent doc metadata when not provided.
+    const sourceIde = opts.sourceIde ||
+        docs.map((d) => metaString(d.metadata, "ide")).find(Boolean);
+    const summary = buildSummary({
+        recent_files,
+        errors,
+        failed_commands,
+        git,
+        manual_notes,
+        profileLine,
+    });
+    return {
+        capsule_id: opts.capsuleId ?? crypto.randomUUID(),
+        project: opts.project,
+        created_at: opts.createdAt ?? new Date().toISOString(),
+        source_ide: sourceIde,
+        schema_version: CAPSULE_SCHEMA_VERSION,
+        summary,
+        recent_files,
+        errors,
+        failed_commands,
+        git,
+        manual_notes,
+    };
+}

package/bundled-backend/capsule-store.js

@@ -0,0 +1,108 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { CapsuleSchema, toMarkdown, } from "@engram-cli/contracts";
+import { config } from "./config.js";
+import { assertSafeProjectSlug } from "./project-slug.js";
+const CURRENT_FILE = "current.json";
+function projectDir(project) {
+    const safe = assertSafeProjectSlug(project);
+    return path.join(config.dataDir, "capsules", safe);
+}
+function currentPath(project) {
+    return path.join(projectDir(project), CURRENT_FILE);
+}
+export async function ensureDataDirs() {
+    await fs.mkdir(path.join(config.dataDir, "capsules"), { recursive: true });
+}
+/**
+ * One capsule per project at current.json.
+ * If missing, migrate the newest legacy {uuid}.json and remove the rest.
+ */
+export async function ensureCurrentCapsule(project) {
+    const dir = projectDir(project);
+    const current = currentPath(project);
+    try {
+        const raw = await fs.readFile(current, "utf8");
+        return CapsuleSchema.parse(JSON.parse(raw));
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    let files;
+    try {
+        files = await fs.readdir(dir);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+    const legacy = [];
+    for (const file of files) {
+        if (!file.endsWith(".json") || file === CURRENT_FILE)
+            continue;
+        try {
+            const raw = await fs.readFile(path.join(dir, file), "utf8");
+            const capsule = CapsuleSchema.parse(JSON.parse(raw));
+            legacy.push({ file, capsule });
+        }
+        catch {
+            // skip corrupt
+        }
+    }
+    if (!legacy.length)
+        return null;
+    legacy.sort((a, b) => b.capsule.created_at.localeCompare(a.capsule.created_at));
+    const newest = legacy[0];
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(current, JSON.stringify(newest.capsule, null, 2), "utf8");
+    for (const item of legacy) {
+        try {
+            await fs.unlink(path.join(dir, item.file));
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
+    return newest.capsule;
+}
+export async function saveCapsule(capsule, opts) {
+    const parsed = CapsuleSchema.parse(capsule);
+    const dir = projectDir(parsed.project);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(currentPath(parsed.project), JSON.stringify(parsed, null, 2), "utf8");
+    // Remove any leftover legacy UUID files after upsert
+    try {
+        const files = await fs.readdir(dir);
+        for (const file of files) {
+            if (file.endsWith(".json") && file !== CURRENT_FILE) {
+                await fs.unlink(path.join(dir, file)).catch(() => undefined);
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    if (opts?.projectRoot) {
+        const mdPath = path.join(opts.projectRoot, "ENGRAM_CONTEXT.md");
+        await fs.writeFile(mdPath, toMarkdown(parsed), "utf8");
+    }
+    return parsed;
+}
+/** Load the single project capsule (migrates legacy files if needed). */
+export async function loadCapsule(project) {
+    return ensureCurrentCapsule(project);
+}
+export async function listCapsules(project) {
+    const capsule = await ensureCurrentCapsule(project);
+    if (!capsule)
+        return [];
+    return [
+        {
+            capsule_id: capsule.capsule_id,
+            created_at: capsule.created_at,
+            summary: capsule.summary.slice(0, 200),
+        },
+    ];
+}

package/bundled-backend/config.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const config = {
+    port: Number(process.env.ENGRAM_PORT ?? 7731),
+    dataDir: path.resolve(process.env.ENGRAM_DATA_DIR ?? path.join(__dirname, "..", "data")),
+    supermemoryApiKey: process.env.SUPERMEMORY_API_KEY ?? "",
+    supermemoryBaseUrl: process.env.SUPERMEMORY_BASE_URL ?? "http://localhost:6767",
+    databaseUrl: process.env.DATABASE_URL ?? "",
+    supabaseUrl: process.env.SUPABASE_URL ?? "",
+    supabaseAnonKey: process.env.SUPABASE_ANON_KEY ?? "",
+    supabaseServiceRoleKey: process.env.SUPABASE_SERVICE_ROLE_KEY ?? "",
+    shareBaseUrl: process.env.ENGRAM_SHARE_BASE_URL ?? "http://localhost:3000",
+};
+/** Hot-reload Supermemory credentials after /settings/global write. */
+export function reloadSupermemoryKey(apiKey, baseUrl) {
+    config.supermemoryApiKey = apiKey;
+    process.env.SUPERMEMORY_API_KEY = apiKey;
+    if (baseUrl) {
+        config.supermemoryBaseUrl = baseUrl;
+        process.env.SUPERMEMORY_BASE_URL = baseUrl;
+    }
+    // Lazy import to avoid circular deps at module load
+    void import("./supermemory.js").then((m) => m.resetSupermemoryClient());
+}
+export function assertConfig() {
+    if (!config.supermemoryApiKey) {
+        console.warn("[engram] SUPERMEMORY_API_KEY not set — configure via PUT /settings/global or .env. " +
+            "Capture/search will fail until a key is set.");
+    }
+}

package/bundled-backend/env-files.js

@@ -0,0 +1,96 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const LLM_ENV_KEYS = {
+    groq: "GROQ_API_KEY",
+    openai: "OPENAI_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+};
+export function findEnvRoot() {
+    if (process.env.ENGRAM_PROJECT_ROOT) {
+        return path.resolve(process.env.ENGRAM_PROJECT_ROOT);
+    }
+    try {
+        const gitRoot = execSync("git rev-parse --show-toplevel", {
+            cwd: process.cwd(),
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (gitRoot)
+            return gitRoot;
+    }
+    catch {
+        // not a git repo
+    }
+    // Monorepo fallback: backend/src → repo root
+    const monorepo = path.resolve(__dirname, "..", "..");
+    if (fs.existsSync(path.join(monorepo, "backend")))
+        return monorepo;
+    return process.cwd();
+}
+export function envFilePath() {
+    return path.join(findEnvRoot(), ".env");
+}
+export function supermemoryEnvPath() {
+    return path.join(os.homedir(), ".supermemory", "env");
+}
+export function supermemoryApiKeyPath() {
+    return path.join(os.homedir(), ".supermemory", "api-key");
+}
+export function readEnvValue(filePath, key) {
+    try {
+        const text = fs.readFileSync(filePath, "utf8");
+        const match = text.match(new RegExp(`^${key}=([^\\r\\n]*)`, "m"));
+        return match?.[1]?.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function upsertEnvValue(filePath, key, value) {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    let text = "";
+    try {
+        text = fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        text = "";
+    }
+    const line = `${key}=${value}`;
+    const re = new RegExp(`^${key}=.*$`, "m");
+    if (re.test(text)) {
+        text = text.replace(re, line);
+    }
+    else {
+        text = text.trimEnd();
+        text = text ? `${text}\n${line}\n` : `${line}\n`;
+    }
+    fs.writeFileSync(filePath, text, "utf8");
+}
+export function maskKey(key) {
+    if (!key || key.length < 8) {
+        return { configured: Boolean(key) };
+    }
+    return {
+        configured: true,
+        prefix: `${key.slice(0, 6)}…`,
+    };
+}
+export function detectLlmProvider() {
+    const envPath = supermemoryEnvPath();
+    for (const [provider, envKey] of Object.entries(LLM_ENV_KEYS)) {
+        const val = readEnvValue(envPath, envKey);
+        if (val)
+            return { provider, configured: true };
+    }
+    // Also check process.env (loaded at boot)
+    for (const [provider, envKey] of Object.entries(LLM_ENV_KEYS)) {
+        if (process.env[envKey])
+            return { provider, configured: true };
+    }
+    return { provider: null, configured: false };
+}

package/bundled-backend/index.js

@@ -0,0 +1,22 @@
+import { serve } from "@hono/node-server";
+import { createApp } from "./app.js";
+import { assertConfig, config } from "./config.js";
+import { ensureDataDirs } from "./capsule-store.js";
+import { bootSupermemorySettings } from "./supermemory.js";
+async function main() {
+    assertConfig();
+    await ensureDataDirs();
+    await bootSupermemorySettings();
+    const app = createApp();
+    console.log(`[engram] listening on http://localhost:${config.port}`);
+    console.log(`[engram] data dir: ${config.dataDir}`);
+    console.log(`[engram] supermemory: ${config.supermemoryBaseUrl}`);
+    serve({
+        fetch: app.fetch,
+        port: config.port,
+    });
+}
+main().catch((err) => {
+    console.error("[engram] fatal:", err);
+    process.exit(1);
+});

package/bundled-backend/intent-filter.js

@@ -0,0 +1,21 @@
+import { CAPS, truncateBytes, } from "@engram-cli/contracts";
+const NOISY_SUCCESS = /^(ls|cd|pwd|echo|clear|which|true|false|history|dirname|basename)\b/;
+/** Authoritative ingest filter — clients stay dumb. */
+export function intentFilter(event) {
+    const content = event.content.trim();
+    if (!content) {
+        return { keep: false, reason: "empty_content" };
+    }
+    if (event.event_type === "command") {
+        const exit = event.exit_code ?? 0;
+        const firstLine = content.split("\n")[0]?.trim() ?? content;
+        if (exit === 0 && NOISY_SUCCESS.test(firstLine)) {
+            return { keep: false, reason: "noisy_successful_command" };
+        }
+    }
+    const truncated = {
+        ...event,
+        content: truncateBytes(content, CAPS.contentBytes),
+    };
+    return { keep: true, event: truncated };
+}

package/bundled-backend/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@engram-cli/bundled-backend",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "index.js"
+}