vibeadmin 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VibeAdmin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,10 @@
-# Temporary Holding Version
+# vibeadmin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Set up [VibeAdmin](https://www.easy-admin.solutions) from your terminal.
+
+```bash
+npx vibeadmin init   # detect your stack, create a project and a development API key
+npx vibeadmin dev    # verify the integration with a test user and event
+```
+
+Run `npx vibeadmin --help` for options. License: MIT

package/bin/vibeadmin.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import("../dist/index.js")
+  .then((m) => m.main(process.argv.slice(2)))
+  .catch((e) => {
+    console.error(e instanceof Error ? e.message : e);
+    process.exit(1);
+  });

package/dist/api.js

@@ -0,0 +1,47 @@
+export class ApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "ApiError";
+    }
+}
+/** Minimal JSON client. `token` is a session bearer token (dashboard API) or an API key (/v1). */
+export function createClient(origin, token, fetchImpl = fetch) {
+    const base = origin.replace(/\/+$/, "");
+    async function call(method, path, body) {
+        const res = await fetchImpl(`${base}${path}`, {
+            method,
+            headers: {
+                accept: "application/json",
+                "user-agent": "vibeadmin-cli",
+                ...(body !== undefined ? { "content-type": "application/json" } : {}),
+                ...(token ? { authorization: `Bearer ${token}` } : {}),
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: AbortSignal.timeout(20_000),
+        });
+        const text = await res.text();
+        let json;
+        try {
+            json = text ? JSON.parse(text) : undefined;
+        }
+        catch {
+            json = undefined;
+        }
+        if (!res.ok) {
+            const j = json;
+            const msg = typeof j?.error === "string"
+                ? j.error
+                : (j?.error?.message ?? j?.error_description ?? `HTTP ${res.status}`);
+            throw new ApiError(msg, res.status);
+        }
+        return json;
+    }
+    return {
+        origin: base,
+        get: (p) => call("GET", p),
+        post: (p, b) => call("POST", p, b ?? {}),
+        del: (p) => call("DELETE", p),
+    };
+}

package/dist/detect.js

@@ -0,0 +1,106 @@
+const LABEL = {
+    nextjs: "Next.js",
+    react: "React",
+    node: "Node.js",
+    python: "Python",
+    other: "your app",
+};
+export function detectFromFiles(files) {
+    let pkg = {};
+    try {
+        if (files.packageJson)
+            pkg = JSON.parse(files.packageJson);
+    }
+    catch {
+        // an unreadable package.json is treated as absent
+    }
+    const deps = { ...pkg.devDependencies, ...pkg.dependencies };
+    const has = (...names) => names.some((n) => n in deps);
+    const py = `${files.requirements ?? ""}\n${files.pyproject ?? ""}`.toLowerCase();
+    let framework = "other";
+    if (has("next"))
+        framework = "nextjs";
+    else if (has("react", "vite", "react-dom"))
+        framework = "react";
+    else if (has("express", "fastify", "hono", "koa", "@nestjs/core", "@hapi/hapi"))
+        framework = "node";
+    else if (files.packageJson)
+        framework = "node";
+    else if (files.requirements || files.pyproject)
+        framework = "python";
+    return {
+        framework,
+        label: LABEL[framework],
+        supabase: has("@supabase/supabase-js", "@supabase/ssr") || /\bsupabase\b/.test(py),
+        firebase: has("firebase", "firebase-admin", "firebase-functions") || /firebase[-_]admin/.test(py),
+        clerk: Object.keys(deps).some((d) => d.startsWith("@clerk/")) || /\bclerk\b/.test(py),
+        name: pkg.name,
+    };
+}
+export function parseEnv(text) {
+    const out = {};
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const m = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+        if (!m)
+            continue;
+        let v = m[2].trim();
+        if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'")))
+            v = v.slice(1, -1);
+        else
+            v = v.replace(/\s+#.*$/, "");
+        out[m[1]] = v;
+    }
+    return out;
+}
+const SUPABASE_URL_KEYS = [
+    "SUPABASE_URL",
+    "NEXT_PUBLIC_SUPABASE_URL",
+    "VITE_SUPABASE_URL",
+    "EXPO_PUBLIC_SUPABASE_URL",
+];
+const SUPABASE_SERVICE_KEYS = ["SUPABASE_SERVICE_ROLE_KEY", "SUPABASE_SERVICE_KEY"];
+export function findSupabase(env) {
+    const url = SUPABASE_URL_KEYS.map((k) => env[k]).find((v) => v && /^https:\/\//.test(v));
+    if (!url)
+        return null;
+    const serviceRoleKey = SUPABASE_SERVICE_KEYS.map((k) => env[k]).find(Boolean);
+    return { url: url.replace(/\/+$/, ""), serviceRoleKey };
+}
+/** Sets KEY=value, replacing an existing assignment and keeping everything else untouched. */
+export function upsertEnvVar(text, key, value) {
+    const line = `${key}=${value}`;
+    const re = new RegExp(`^(?:export\\s+)?${key}\\s*=.*$`, "m");
+    if (re.test(text))
+        return text.replace(re, line);
+    const sep = text && !text.endsWith("\n") ? "\n" : "";
+    return `${text}${sep}${line}\n`;
+}
+/** True when .env.local (or a matching pattern) is ignored, so the key we write cannot be committed by accident. */
+export function gitignoreCoversEnv(gitignore) {
+    if (gitignore === undefined)
+        return false;
+    return gitignore
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .some((l) => [".env.local", ".env*.local", ".env*", ".env", "*.local", ".env.*"].includes(l));
+}
+export function nextSteps(d, ids, origin) {
+    const guide = `${origin}/o/${ids.org}/p/${ids.project}/development/onboarding`;
+    const common = [`Open ${guide} to finish setup and get a prompt for your coding agent.`];
+    const push = {
+        nextjs: "Call POST /v1/users from your signup code and POST /v1/events for key actions (server-side only).",
+        react: "Call the API from your backend or a serverless function, never from browser code.",
+        node: "Call POST /v1/users when users sign up and POST /v1/events for key actions.",
+        python: "Call POST /v1/users when users sign up and POST /v1/events for key actions (requests or httpx).",
+        other: "Call POST /v1/users when users sign up and POST /v1/events for key actions.",
+    }[d.framework];
+    const extra = [];
+    if (d.firebase)
+        extra.push("Firebase: forward new users from an auth.user().onCreate Cloud Function. See /admin-dashboard-for-firebase.");
+    if (d.clerk)
+        extra.push("Clerk: forward user.created webhooks to the API. See /admin-dashboard-for-clerk.");
+    return [push, ...extra, ...common, "Run `vibeadmin dev` to verify the connection."];
+}

package/dist/dev.js

@@ -0,0 +1,63 @@
+import { ApiError, createClient } from "./api.js";
+import { parseEnv } from "./detect.js";
+import { ENV_FILES } from "./fs.js";
+export const PROBE_ID = "vibeadmin-dev-probe";
+export function loadKey(files, env) {
+    const fromFiles = Object.assign({}, ...ENV_FILES.slice()
+        .reverse()
+        .map((f) => parseEnv(files.read(f) ?? "")));
+    return {
+        key: env.VIBEADMIN_API_KEY || fromFiles.VIBEADMIN_API_KEY,
+        origin: env.VIBEADMIN_URL || fromFiles.VIBEADMIN_URL,
+    };
+}
+/** Verifies the integration end to end with a clearly named probe user and event. Never touches real users. */
+export async function runDev(opts, io) {
+    if (!opts.key) {
+        io.warn("No VIBEADMIN_API_KEY found in the environment or .env files. Run `vibeadmin init` first.");
+        return false;
+    }
+    if (opts.key.startsWith("adm_live_")) {
+        io.warn("This is a production (adm_live_) key. `vibeadmin dev` only runs against development keys.");
+        return false;
+    }
+    if (!opts.key.startsWith("adm_test_")) {
+        io.warn("That does not look like a VibeAdmin API key (expected adm_test_…).");
+        return false;
+    }
+    const api = createClient(opts.origin, opts.key, opts.fetch);
+    try {
+        await api.get("/v1/stats");
+        io.ok("API key accepted (development)");
+        await api.post("/v1/users", {
+            id: PROBE_ID,
+            email: "vibeadmin-dev-probe@example.invalid",
+            name: "VibeAdmin CLI probe",
+        });
+        io.ok("Test user created");
+        await api.post("/v1/events", { name: "vibeadmin.dev.check", userId: PROBE_ID });
+        const events = await api.get(`/v1/events?name=vibeadmin.dev.check&userId=${PROBE_ID}&limit=1`);
+        if (!events.data.length)
+            throw new Error("The test event was accepted but could not be read back.");
+        io.ok("Test event recorded");
+        try {
+            await api.del(`/v1/users/${PROBE_ID}`);
+            io.ok("Test data removed");
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.status === 403)
+                io.out(`  The key cannot delete users, so the user "${PROBE_ID}" was left in place. Delete it from the dashboard if you like.`);
+            else
+                throw e;
+        }
+        io.out("Your integration works.");
+        return true;
+    }
+    catch (e) {
+        const msg = e instanceof ApiError && e.status === 401
+            ? "The API key was rejected (revoked, or for another environment)."
+            : e.message;
+        io.warn(`Check failed: ${msg}`);
+        return false;
+    }
+}

package/dist/device.js

@@ -0,0 +1,37 @@
+import { ApiError } from "./api.js";
+export const CLIENT_ID = "vibeadmin-cli";
+const GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+/** OAuth device flow (RFC 8628) against Better Auth. Returns a session token usable as a bearer token. */
+export async function deviceLogin(anon, show, sleep = (ms) => new Promise((r) => setTimeout(r, ms))) {
+    const c = await anon.post("/api/auth/device/code", { client_id: CLIENT_ID });
+    show({ url: c.verification_uri_complete ?? c.verification_uri, code: c.user_code });
+    let interval = Math.max(1, c.interval) * 1000;
+    const deadline = Date.now() + c.expires_in * 1000;
+    while (Date.now() < deadline) {
+        await sleep(interval);
+        try {
+            const t = await anon.post("/api/auth/device/token", {
+                grant_type: GRANT,
+                device_code: c.device_code,
+                client_id: CLIENT_ID,
+            });
+            if (t.access_token)
+                return t.access_token;
+        }
+        catch (e) {
+            const msg = e instanceof ApiError ? e.message : "";
+            if (/authorization_pending|pending/i.test(msg))
+                continue;
+            if (/slow_down/i.test(msg)) {
+                interval += 5000;
+                continue;
+            }
+            if (/access_denied|denied/i.test(msg))
+                throw new Error("The sign-in was denied in the browser.");
+            if (/expired/i.test(msg))
+                throw new Error("The code expired. Run the command again.");
+            throw e;
+        }
+    }
+    throw new Error("Timed out waiting for browser approval. Run the command again.");
+}

package/dist/fs.js

@@ -0,0 +1,23 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export function diskFiles(cwd) {
+    return {
+        read: (name) => {
+            const p = join(cwd, name);
+            return existsSync(p) ? readFileSync(p, "utf8") : undefined;
+        },
+        // Mode 0600: the file holds an API key.
+        write: (name, content) => writeFileSync(join(cwd, name), content, { mode: 0o600 }),
+    };
+}
+export function memoryFiles(initial = {}) {
+    const files = { ...initial };
+    return {
+        files,
+        read: (n) => files[n],
+        write: (n, c) => {
+            files[n] = c;
+        },
+    };
+}
+export const ENV_FILES = [".env.local", ".env", ".env.development.local", ".env.development"];

package/dist/index.js

@@ -0,0 +1,63 @@
+import { loadKey, runDev } from "./dev.js";
+import { diskFiles } from "./fs.js";
+import { DEFAULT_ORIGIN, runInit } from "./init.js";
+import { consoleIo } from "./io.js";
+const HELP = `vibeadmin: set up the VibeAdmin admin dashboard for your app
+
+Usage
+  vibeadmin init   Detect your stack, create a project and a development API key
+  vibeadmin dev    Verify the integration with a test user and event
+
+Options
+  --url <origin>   VibeAdmin server (default ${DEFAULT_ORIGIN}, or VIBEADMIN_URL)
+  --yes            Accept defaults without prompting (init)
+  --no-env         Print the key instead of writing .env.local (init)
+  --help           Show this help
+`;
+export function parseArgs(argv) {
+    const p = { yes: false, noEnv: false, help: false };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--yes" || a === "-y")
+            p.yes = true;
+        else if (a === "--no-env")
+            p.noEnv = true;
+        else if (a === "--help" || a === "-h")
+            p.help = true;
+        else if (a === "--url")
+            p.url = argv[++i];
+        else if (a.startsWith("--url="))
+            p.url = a.slice(6);
+        else if (!a.startsWith("-") && !p.command)
+            p.command = a;
+        else
+            throw new Error(`Unknown option: ${a}\n\n${HELP}`);
+    }
+    return p;
+}
+export async function main(argv) {
+    const a = parseArgs(argv);
+    if (a.help || !a.command) {
+        console.log(HELP);
+        return;
+    }
+    const cwd = process.cwd();
+    const files = diskFiles(cwd);
+    const io = consoleIo({ yes: a.yes });
+    const saved = loadKey(files, process.env);
+    const origin = (a.url ?? saved.origin ?? DEFAULT_ORIGIN).replace(/\/+$/, "");
+    if (!/^https:\/\//.test(origin) &&
+        !/^http:\/\/(localhost|127\.0\.0\.1|\[::1\])(:|\/|$)/.test(origin))
+        throw new Error("--url must be https (http is allowed only for localhost).");
+    if (a.command === "init") {
+        await runInit({ origin, yes: a.yes, writeEnv: !a.noEnv, cwd }, files, io);
+    }
+    else if (a.command === "dev") {
+        const ok = await runDev({ origin, key: saved.key }, io);
+        if (!ok)
+            process.exitCode = 1;
+    }
+    else {
+        throw new Error(`Unknown command: ${a.command}\n\n${HELP}`);
+    }
+}

package/dist/init.js

@@ -0,0 +1,109 @@
+import { basename } from "node:path";
+import { createClient } from "./api.js";
+import { detectFromFiles, findSupabase, gitignoreCoversEnv, nextSteps, parseEnv, upsertEnvVar, } from "./detect.js";
+import { deviceLogin } from "./device.js";
+import { ENV_FILES } from "./fs.js";
+// Scopes for the key init creates: enough to sync users and send events, nothing destructive.
+export const INIT_SCOPES = ["users.read", "users.write", "events.write", "analytics.read"];
+export const DEFAULT_ORIGIN = "https://www.easy-admin.solutions";
+export async function runInit(opts, files, io) {
+    const d = detectFromFiles({
+        packageJson: files.read("package.json"),
+        requirements: files.read("requirements.txt"),
+        pyproject: files.read("pyproject.toml"),
+    });
+    io.ok(`Detected ${d.label}`);
+    if (d.supabase)
+        io.ok("Detected Supabase");
+    if (d.firebase)
+        io.ok("Detected Firebase");
+    if (d.clerk)
+        io.ok("Detected Clerk");
+    const anon = createClient(opts.origin, undefined, opts.fetch);
+    const token = await deviceLogin(anon, ({ url, code }) => {
+        io.out();
+        io.out(`Open ${url}`);
+        io.out(`and confirm the code: ${code}`);
+        io.out("Waiting for approval…");
+    }, opts.sleep);
+    const api = createClient(opts.origin, token, opts.fetch);
+    io.ok("Signed in");
+    let orgs = await api.get("/api/orgs");
+    let org;
+    if (!orgs.length) {
+        const name = await io.ask("Organization name", "My organization");
+        org = await api.post("/api/orgs", { name });
+        orgs = [org];
+        io.ok(`Created organization "${org.name}"`);
+    }
+    else if (orgs.length === 1) {
+        org = orgs[0];
+    }
+    else {
+        for (const [i, o] of orgs.entries())
+            io.out(`  ${i + 1}. ${o.name}`);
+        const n = Number(await io.ask("Which organization? Enter a number", "1"));
+        org = orgs[Number.isInteger(n) && n >= 1 && n <= orgs.length ? n - 1 : 0];
+    }
+    const defaultName = (d.name ?? basename(opts.cwd)).replace(/^@[^/]+\//, "") || "my-app";
+    const projectName = await io.ask("Project name", defaultName);
+    const created = await api.post(`/api/orgs/${org.id}/projects`, { name: projectName });
+    io.ok(`Created project "${created.project.name}"`);
+    const dev = created.environments.find((e) => e.kind === "development");
+    if (!dev)
+        throw new Error("The new project has no development environment.");
+    const key = await api.post(`/api/orgs/${org.id}/environments/${dev.id}/api-keys`, {
+        name: `cli-${created.project.slug}`.slice(0, 120),
+        scopes: INIT_SCOPES,
+    });
+    io.ok("Created a development API key");
+    // Offer the Supabase connector only if the credentials are already on this machine; never ask for them to be typed.
+    if (d.supabase) {
+        const env = Object.assign({}, ...ENV_FILES.slice()
+            .reverse()
+            .map((f) => parseEnv(files.read(f) ?? "")));
+        const sb = findSupabase(env);
+        if (sb?.serviceRoleKey) {
+            const yes = await io.confirm(`Connect Supabase (${sb.url})? Your service-role key is sent to VibeAdmin, stored encrypted, and used read-only.`, false);
+            if (yes) {
+                try {
+                    await api.post(`/api/orgs/${org.id}/environments/${dev.id}/integrations`, {
+                        provider: "supabase",
+                        config: { url: sb.url },
+                        credentials: { serviceRoleKey: sb.serviceRoleKey },
+                        grantedPermissions: ["read_users"],
+                    });
+                    io.ok("Connected Supabase (read-only). Users will appear after the first sync.");
+                }
+                catch (e) {
+                    io.warn(`Could not connect Supabase: ${e.message}. You can do it from the Integrations page.`);
+                }
+            }
+        }
+        else if (sb) {
+            io.out("Supabase found, but no service-role key in your env files. Add it on the Integrations page to import users.");
+        }
+    }
+    if (opts.writeEnv) {
+        let text = files.read(".env.local") ?? "";
+        text = upsertEnvVar(text, "VIBEADMIN_API_KEY", key.secret);
+        if (opts.origin !== DEFAULT_ORIGIN)
+            text = upsertEnvVar(text, "VIBEADMIN_URL", opts.origin);
+        files.write(".env.local", text);
+        io.out();
+        io.ok("Added to .env.local:");
+        io.out(`VIBEADMIN_API_KEY=${key.secret.slice(0, 12)}…`);
+        if (!gitignoreCoversEnv(files.read(".gitignore")))
+            io.warn(".env.local is not in your .gitignore. Add it so the key is never committed.");
+    }
+    else {
+        io.out();
+        io.out("Add this to your environment (shown once):");
+        io.out(`VIBEADMIN_API_KEY=${key.secret}`);
+    }
+    io.out();
+    io.out("Next:");
+    for (const s of nextSteps(d, { org: org.slug, project: created.project.slug }, opts.origin))
+        io.out(`  - ${s}`);
+    return { key: key.secret, slug: org.slug, project: created.project.slug };
+}

package/dist/io.js

@@ -0,0 +1,48 @@
+import { createInterface } from "node:readline/promises";
+export function consoleIo(opts) {
+    const tty = process.stdout.isTTY;
+    const c = (code, s) => (tty ? `\x1b[${code}m${s}\x1b[0m` : s);
+    let rl;
+    const readline = () => (rl ??= createInterface({ input: process.stdin, output: process.stdout }));
+    const io = {
+        out: (l = "") => console.log(l),
+        ok: (l) => console.log(`${c(32, "✓")} ${l}`),
+        warn: (l) => console.log(`${c(33, "!")} ${l}`),
+        async ask(q, fallback) {
+            if (opts.yes || !process.stdin.isTTY)
+                return fallback ?? "";
+            const a = (await readline().question(`${q}${fallback ? ` (${fallback})` : ""}: `)).trim();
+            return a || fallback || "";
+        },
+        async confirm(q, fallback) {
+            if (opts.yes)
+                return fallback;
+            if (!process.stdin.isTTY)
+                return false;
+            const a = (await readline().question(`${q} ${fallback ? "[Y/n]" : "[y/N]"} `))
+                .trim()
+                .toLowerCase();
+            return a ? a.startsWith("y") : fallback;
+        },
+    };
+    process.on("exit", () => rl?.close());
+    return io;
+}
+/** In-memory Io for tests: records output, answers prompts from a queue. */
+export function testIo(answers = []) {
+    const lines = [];
+    const io = {
+        out: (l = "") => void lines.push(l),
+        ok: (l) => void lines.push(`ok ${l}`),
+        warn: (l) => void lines.push(`warn ${l}`),
+        ask: async (_q, fallback) => {
+            const a = answers.shift();
+            return typeof a === "string" ? a : (fallback ?? "");
+        },
+        confirm: async (_q, fallback) => {
+            const a = answers.shift();
+            return typeof a === "boolean" ? a : fallback;
+        },
+    };
+    return { io, lines };
+}

package/dist/run.js

@@ -0,0 +1,6 @@
+// Dev entry (pnpm vibeadmin …) so the CLI can run from source without a build.
+import { main } from "./index.js";
+main(process.argv.slice(2)).catch((e) => {
+    console.error(e instanceof Error ? e.message : e);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "vibeadmin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Set up VibeAdmin from your terminal: npx vibeadmin init",
+  "license": "MIT",
+  "bin": {
+    "vibeadmin": "bin/vibeadmin.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leovegas/vibeadmin.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://www.easy-admin.solutions",
+  "bugs": {
+    "url": "https://github.com/leovegas/vibeadmin/issues"
+  },
+  "keywords": [
+    "vibeadmin",
+    "admin",
+    "cli",
+    "setup"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.build.json"
+  }
 }