insta 0.0.5 → 0.0.8

package/dist/commands/billing.js

@@ -1,26 +1,51 @@
 import { ApiClient, requireProject } from '../api.js';
 import { die, info, openUrl, printJson } from '../util.js';
+import { cycleLine, dimensionLines } from './metrics.js';
 // Resolve the target org: explicit --org, else the linked project's org.
 async function resolveOrgId(opts) {
     if (opts.org)
         return opts.org;
     return (await requireProject()).orgId;
 }
-// insta billing — current cycle summary for the org.
+// Format the billing overview into printable lines (pure, so it's unit-testable).
+export function billingLines(s) {
+    const t = s.totals;
+    const lines = [
+        `tier:      ${s.tier}`,
+        `status:    ${s.billingStatus}`,
+        cycleLine(s.window),
+        `included:  $${Number(t.includedUsd).toFixed(2)}`,
+        `used:      $${Number(t.usedUsd).toFixed(4)}`,
+        `overage:   $${Number(t.overageUsd).toFixed(4)}`,
+        `credits:   $${Number(t.creditsUsd).toFixed(2)}`,
+        `forecast:  $${Number(t.forecastUsd).toFixed(4)}  (predicted full cycle)`,
+    ];
+    if (s.subscriptionStatus)
+        lines.push(`subscription: ${s.subscriptionStatus}`);
+    if (s.billingStatus === 'suspended') {
+        lines.push('⚠  org suspended — billing limit reached; resumes next cycle (or `insta billing upgrade pro`)');
+    }
+    if (s.byDimension?.length) {
+        lines.push('by dimension:');
+        for (const l of dimensionLines(s.byDimension))
+            lines.push(`  ${l}`);
+    }
+    if (s.byProject?.length) {
+        lines.push('by project:');
+        for (const pr of s.byProject)
+            lines.push(`  ${pr.name}: $${Number(pr.totalCostUsd ?? 0).toFixed(4)}`);
+    }
+    return lines;
+}
+// insta billing — current cycle overview for the org (totals, credits, forecast, breakdowns).
 export async function billing(opts) {
     const api = await ApiClient.load();
     const orgId = await resolveOrgId(opts);
-    const s = await api.request('GET', `/orgs/${orgId}/billing`);
+    const s = await api.request('GET', `/orgs/${orgId}/billing/overview`);
     if (opts.json)
         return printJson(s);
-    info(`tier:     ${s.tier}`);
-    info(`status:   ${s.status}`);
-    info(`cycle:    ${String(s.cycleStart).slice(0, 10)} → ${String(s.cycleEnd).slice(0, 10)}`);
-    info(`included: $${Number(s.includedUsd).toFixed(2)}`);
-    info(`used:     $${Number(s.usedUsd).toFixed(4)}`);
-    info(`overage:  $${Number(s.overageUsd).toFixed(4)}`);
-    if (s.status === 'suspended')
-        info('⚠  org suspended — billing limit reached; resumes next cycle (or `insta billing upgrade pro`)');
+    for (const l of billingLines(s))
+        info(l);
 }
 // insta billing upgrade <tier> — start a Stripe Checkout to subscribe the org to a paid tier.
 export async function billingUpgrade(tier, opts) {

package/dist/commands/deploy.js

@@ -1,8 +1,31 @@
 import { resolve, join } from 'node:path';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { ApiClient, requireProject } from '../api.js';
 import { info, die, handleApproval } from '../util.js';
 import { flyctlBuildAndPush, ensureFlyctl } from '../flyctl-build.js';
+// Map CLI options to the platform deploy request body. Pure, so it's unit-tested. --websocket is only
+// sent when set (plain deploys unchanged).
+export function deployRequestBody(image, branch, opts) {
+    return {
+        image,
+        branch,
+        group: opts.group,
+        port: opts.port ? Number(opts.port) : undefined,
+        websocket: opts.websocket ? true : undefined,
+    };
+}
+// A port mismatch is the #1 deploy mistake: the app boots "successfully" but the proxy routes to
+// the wrong internal port and every request is refused. For source deploys the Dockerfile states
+// the truth — use its (last) EXPOSE as the default instead of a blind 8080.
+export function dockerfileExposedPort(dockerfile) {
+    let port;
+    for (const line of dockerfile.split('\n')) {
+        const m = /^\s*EXPOSE\s+(\d+)/i.exec(line);
+        if (m)
+            port = Number(m[1]);
+    }
+    return port;
+}
 // Deploy either a prebuilt image (`--image`) or a source directory (positional `<dir>`, built
 // remotely on Fly and pushed with a short-lived platform-minted token). Exactly one mode.
 export async function deploy(dir, opts) {
@@ -13,13 +36,18 @@ export async function deploy(dir, opts) {
     const api = await ApiClient.load();
     const p = await requireProject();
     const branch = opts.branch ?? p.branch;
-    const image = dir ? await buildFromSource(api, p.projectId, dir, branch, opts) : opts.image;
-    const res = await api.rawRequest('POST', `/projects/${p.projectId}/deploy`, {
-        image,
-        branch,
-        group: opts.group,
-        port: opts.port ? Number(opts.port) : undefined,
-    });
+    let port = opts.port ? Number(opts.port) : undefined;
+    if (dir && port === undefined) {
+        const dockerfile = join(resolve(process.cwd(), dir), 'Dockerfile');
+        const exposed = existsSync(dockerfile) ? dockerfileExposedPort(readFileSync(dockerfile, 'utf8')) : undefined;
+        if (exposed) {
+            port = exposed;
+            info(`using port ${exposed} (Dockerfile EXPOSE) — override with --port`);
+        }
+    }
+    const effOpts = { ...opts, port: port?.toString() };
+    const image = dir ? await buildFromSource(api, p.projectId, dir, branch, effOpts) : opts.image;
+    const res = await api.rawRequest('POST', `/projects/${p.projectId}/deploy`, deployRequestBody(image, branch, effOpts));
     if (handleApproval(res))
         return;
     info(`deployed ${image} -> ${res.body.url} (branch ${res.body.branch}, group ${res.body.group})`);

package/dist/commands/metrics.js

@@ -28,16 +28,22 @@ export async function metrics(component, group, opts) {
 const DIMENSION_LABEL = { ram: 'memory' };
 // Window line. Defaults to the current billing cycle; `to` is the exclusive next-cycle start, so
 // show the inclusive last day (to − 1 day) — e.g. an org created on the 5th reads "…-05 → …next-04".
-function cycleLine(res) {
+export function cycleLine(res) {
     const day = (sec) => new Date(sec * 1000).toISOString().slice(0, 10);
     return `billing cycle ${day(res.from)} → ${day(res.to - 86400)}`;
 }
-function printDimensions(dims) {
-    for (const d of dims) {
+// Pure: format the per-dimension lines (label: qty unit (cost)). Shared by `insta usage` and
+// `insta billing` so both render dimensions identically.
+export function dimensionLines(dims) {
+    return dims.map((d) => {
         const label = DIMENSION_LABEL[d.dimension] ?? d.dimension;
         const cost = d.costUsd != null ? `  ($${Number(d.costUsd).toFixed(4)})` : '';
-        info(`${label}: ${d.quantity} ${d.unit}${cost}`);
-    }
+        return `${label}: ${d.quantity} ${d.unit}${cost}`;
+    });
+}
+function printDimensions(dims) {
+    for (const l of dimensionLines(dims))
+        info(l);
 }
 // insta usage — usage across the 5 billing dimensions (cpu/memory/volume/egress/storage) for the
 // current billing cycle. Shows the whole ORG by default (with a per-project breakdown); pass --proj

package/dist/commands/setup.js

@@ -0,0 +1,34 @@
+// `insta setup agent` — make this machine's coding agents InstaCloud-native in one step
+// (the Railway `railway setup agent` pattern). Installs the `insta` skill USER-GLOBALLY for
+// every agent the skills tool knows: the skill is pure product knowledge with brand-gated
+// triggers — no project state in it (the project binding is carried by ./.insta/project.json
+// at command time), so one machine-level copy is strictly better than per-project copies.
+// Stack skills (neon/tigris/better-auth) intentionally stay per-project: their presence in a
+// project doubles as its stack manifest — that install happens on `project create|link`.
+import { spawn } from 'node:child_process';
+import { info } from '../util.js';
+const defaultRunner = (cmd, args) => new Promise((resolve) => {
+    const env = { ...process.env, AI_AGENT: process.env.AI_AGENT || 'insta' };
+    const p = spawn(cmd, args, { stdio: 'inherit', env });
+    p.on('error', () => resolve({ ok: false }));
+    p.on('close', (code) => resolve({ ok: code === 0 }));
+});
+// -g = user-level (machine-global); -a '*' = every agent dir the skills tool supports
+// (Claude Code, Codex, Cursor, OpenCode, Copilot, …); --copy = real files, not cache symlinks.
+export const SETUP_ARGS = ['skills', 'add', 'InsForge/insta-skills', '-s', 'insta', '-a', '*', '-g', '-y', '--copy'];
+export async function setupAgent(opts, run = defaultRunner) {
+    if (!opts.yes && !process.stdout.isTTY) {
+        info('non-interactive shell — assuming -y');
+    }
+    info('installing the insta skill (user-global, all agents) …');
+    const res = await run('npx', SETUP_ARGS);
+    if (!res.ok) {
+        info('  skill install failed — install manually with:');
+        info('    npx skills add InsForge/insta-skills -s insta -a "*" -g -y --copy');
+        process.exitCode = 1;
+        return;
+    }
+    info('done — agents on this machine now know InstaCloud.');
+    info('next: `insta login --oauth github` (cloud) or run instad locally (insta-oss), then `insta project create <name>`.');
+}
+//# sourceMappingURL=setup.js.map

package/dist/commands/upgrade.js

@@ -0,0 +1,151 @@
+// Self-update: `insta upgrade` updates the CLI in place, channel-aware (native binary via the
+// release installer; npm via `npm i -g`). A background version check (detached, cached 24h in
+// ~/.insta/update-check.json) powers an update nudge — and, since the CLI is young and moves
+// fast, AUTO-UPDATE IS ON BY DEFAULT: when a newer version is known, the next invocation spawns
+// a quiet detached upgrade. `insta autoupdate off` (or INSTA_NO_AUTOUPDATE=1) disables that,
+// leaving just the stderr nudge.
+import { spawn } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { readGlobal, writeGlobal } from '../config.js';
+import { info } from '../util.js';
+const INSTALL_SH = 'https://raw.githubusercontent.com/InsForge/insta-cli/main/install.sh';
+const REGISTRY_LATEST = 'https://registry.npmjs.org/insta/latest';
+const CHECK_TTL_MS = 24 * 60 * 60 * 1000; // re-check the registry at most once a day
+const AUTO_THROTTLE_MS = 60 * 60 * 1000; //  don't respawn a failed auto-upgrade more than hourly
+const cachePath = () => process.env.INSTA_UPDATE_CACHE ?? join(homedir(), '.insta', 'update-check.json');
+// How is this CLI running? Bun standalone → execPath IS the insta binary (not node);
+// npm global → the module lives under node_modules; anything else is a source checkout.
+export function detectChannel(execPath = process.execPath, moduleUrl = import.meta.url) {
+    if (!/node(\.exe)?$/.test(execPath))
+        return 'binary';
+    if (moduleUrl.includes('/node_modules/'))
+        return 'npm';
+    return 'source';
+}
+// -1 / 0 / 1 for a<b / a==b / a>b on dotted numeric versions ("0.0.4" style).
+export function cmpSemver(a, b) {
+    const pa = a.split('.').map((n) => parseInt(n, 10) || 0);
+    const pb = b.split('.').map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d < 0 ? -1 : 1;
+    }
+    return 0;
+}
+export function readCache() {
+    try {
+        return JSON.parse(readFileSync(cachePath(), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCache(c) {
+    mkdirSync(dirname(cachePath()), { recursive: true });
+    writeFileSync(cachePath(), JSON.stringify(c));
+}
+// Pure decision for what start-up should do given the cache. Exported for tests.
+export function decideAction(cache, current, autoUpdate, channel, now = Date.now()) {
+    if (!cache || cmpSemver(cache.latest, current) <= 0)
+        return 'none';
+    if (!autoUpdate || channel === 'source')
+        return 'nudge';
+    if (cache.lastAutoAt && now - cache.lastAutoAt < AUTO_THROTTLE_MS)
+        return 'nudge';
+    return 'auto';
+}
+// `insta upgrade` — synchronous, visible self-update on the detected channel.
+export async function upgrade() {
+    const channel = detectChannel();
+    if (channel === 'source') {
+        info('running from a source checkout — `git pull` to update');
+        return;
+    }
+    info(`upgrading insta via ${channel} …`);
+    let cmd;
+    let args;
+    let env = process.env;
+    if (channel === 'binary') {
+        cmd = 'sh';
+        args = ['-c', `curl -fsSL ${INSTALL_SH} | sh`];
+        env = { ...process.env, INSTA_INSTALL_DIR: dirname(process.execPath) };
+    }
+    else {
+        cmd = 'npm';
+        args = ['install', '-g', 'insta@latest'];
+    }
+    await new Promise((resolve, reject) => {
+        const p = spawn(cmd, args, { stdio: 'inherit', env });
+        p.on('error', reject);
+        p.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`upgrade failed (exit ${code})`))));
+    });
+}
+// Hidden `insta __update-check` — runs detached in the background: fetch latest, refresh cache.
+export async function backgroundCheck() {
+    try {
+        const ctl = new AbortController();
+        const t = setTimeout(() => ctl.abort(), 5000);
+        const res = await fetch(REGISTRY_LATEST, { signal: ctl.signal });
+        clearTimeout(t);
+        if (!res.ok)
+            return;
+        const { version } = (await res.json());
+        if (version)
+            writeCache({ ...(readCache() ?? { checkedAt: 0, latest: '0.0.0' }), checkedAt: Date.now(), latest: version });
+    }
+    catch { /* offline / registry down — try again next TTL */ }
+}
+// `insta autoupdate [on|off]` — toggle / show the auto-update preference (default: on).
+export async function autoupdate(mode) {
+    const cfg = await readGlobal();
+    if (mode === 'on' || mode === 'off') {
+        await writeGlobal({ ...cfg, autoUpdate: mode === 'on' });
+        info(`autoupdate ${mode}`);
+        return;
+    }
+    const enabled = cfg.autoUpdate !== false && !process.env.INSTA_NO_AUTOUPDATE;
+    info(`autoupdate: ${enabled ? 'on' : 'off'} (default on while the CLI is pre-1.0 — \`insta autoupdate off\` to disable)`);
+}
+// Called once at CLI start-up. Never blocks: reads the cache synchronously, prints at most one
+// stderr line, and (when due) spawns detached children for the registry check / quiet upgrade.
+export function maybeUpdate(current, argv) {
+    const cmd = argv[2];
+    if (cmd === 'upgrade' || cmd === 'autoupdate' || cmd === '__update-check')
+        return;
+    const channel = detectChannel();
+    const cache = readCache();
+    // keep the cache fresh (detached; survives this process exiting)
+    if (!cache || Date.now() - cache.checkedAt > CHECK_TTL_MS) {
+        respawnDetached(['__update-check']);
+    }
+    let auto = !process.env.INSTA_NO_AUTOUPDATE;
+    try { // config read is async elsewhere; a tiny sync read keeps start-up non-blocking
+        const raw = JSON.parse(readFileSync(join(homedir(), '.insta', 'config.json'), 'utf8'));
+        if (raw.autoUpdate === false)
+            auto = false;
+    }
+    catch { /* no config yet */ }
+    const action = decideAction(cache, current, auto, channel);
+    if (action === 'nudge') {
+        console.error(`↑ insta ${cache.latest} is available (you have ${current}) — run \`insta upgrade\``);
+    }
+    else if (action === 'auto') {
+        writeCache({ ...cache, lastAutoAt: Date.now() });
+        respawnDetached(['upgrade']);
+        console.error(`↑ auto-updating insta ${current} → ${cache.latest} in the background (\`insta autoupdate off\` to disable)`);
+    }
+}
+// Re-invoke this same CLI (binary or node+script) detached, output discarded.
+function respawnDetached(args) {
+    try {
+        const script = process.argv[1];
+        const argv = /node(\.exe)?$/.test(process.execPath) && script ? [script, ...args] : args;
+        const p = spawn(process.execPath, argv, { detached: true, stdio: 'ignore' });
+        p.unref();
+    }
+    catch { /* best-effort */ }
+}
+//# sourceMappingURL=upgrade.js.map

package/dist/config.js

@@ -6,14 +6,17 @@ const GLOBAL_DIR = join(homedir(), '.insta');
 const GLOBAL_FILE = join(GLOBAL_DIR, 'config.json');
 const PROJECT_DIR = '.insta';
 const PROJECT_FILE = 'project.json';
-const DEFAULT_API = process.env.INSTA_API_URL ?? 'https://beta-api.insta.insforge.dev';
+const DEFAULT_API = 'https://beta-api.insta.insforge.dev';
 export async function readGlobal() {
+    // INSTA_API_URL overrides the persisted apiUrl, not just the default — otherwise the
+    // env var is silently ignored as soon as any login has written a config file.
+    const envApi = process.env.INSTA_API_URL;
     try {
         const parsed = JSON.parse(await readFile(GLOBAL_FILE, 'utf8'));
-        return { ...parsed, apiUrl: parsed.apiUrl ?? DEFAULT_API };
+        return { ...parsed, apiUrl: envApi ?? parsed.apiUrl ?? DEFAULT_API };
     }
     catch {
-        return { apiUrl: DEFAULT_API };
+        return { apiUrl: envApi ?? DEFAULT_API };
     }
 }
 export async function writeGlobal(c) {

package/dist/index.js

@@ -4,6 +4,7 @@ import { Command } from 'commander';
 import { ApiError } from './api.js';
 import { die } from './util.js';
 import * as auth from './commands/auth.js';
+import * as setup from './commands/setup.js';
 import * as org from './commands/org.js';
 import * as project from './commands/project.js';
 import * as branch from './commands/branch.js';
@@ -16,6 +17,7 @@ import * as govern from './commands/govern.js';
 import * as observe from './commands/observe.js';
 import * as obs from './commands/metrics.js';
 import { billing, billingUpgrade, billingPortal } from './commands/billing.js';
+import * as selfUpdate from './commands/upgrade.js';
 function onError(e) {
     if (e instanceof ApiError)
         die(`${e.message} (HTTP ${e.status})`);
@@ -54,6 +56,11 @@ program.command('login').description('Log in with email + password, or --oauth <
     .action(guard((o) => auth.login(o)));
 program.command('logout').description('Log out and clear local tokens').action(guard(() => auth.logout()));
 program.command('status').description('Show login + linked project').option('--json').action(guard((o) => auth.status(o)));
+// ---- agent setup (the `curl … | sh --agents` target) ----
+const setupCmd = program.command('setup').description('Set up this machine for InstaCloud agent workflows');
+setupCmd.command('agent').description('Install the insta skill user-globally for all coding agents')
+    .option('-y, --yes', 'non-interactive')
+    .action(guard((o) => setup.setupAgent(o)));
 // ---- org ----
 const orgCmd = program.command('org').description('Manage organizations');
 orgCmd.command('list').option('--json').action(guard((o) => org.orgList(o)));
@@ -93,6 +100,7 @@ sec.command('unset <name>').description('Remove a user secret')
 // ---- deploy ----
 program.command('deploy [dir]').description('Deploy a source directory (built remotely on Fly) or a prebuilt --image to a branch compute group')
     .option('--image <url>', 'prebuilt container image to deploy (instead of a source dir)').option('--branch <b>').option('--group <g>').option('--port <p>')
+    .option('--websocket', 'run a WebSocket app (larger guest + connection-based concurrency)')
     .action(guard((dir, o) => deploy(dir, o)));
 // ---- compute custom domains (bring your own domain → Fly cert + routing) ----
 const compute = program.command('compute').description('Compute custom domains (bring your own domain)');
@@ -114,7 +122,7 @@ program.command('logs <target> [group]').description('Service runtime logs (targ
 program.command('usage').description('Usage for the current billing cycle by billing dimension (org by default; --proj for one project)')
     .option('--from <unix>').option('--to <unix>').option('--proj [id]', 'show one project (the linked one, or a given id) instead of the whole org').option('--json')
     .action(guard((o) => obs.usage(o)));
-const bill = program.command('billing').description('Current billing cycle summary (tier / credit / used / overage)')
+const bill = program.command('billing').description('Current billing cycle overview (tier / used / included / overage / credits / forecast + per-dimension & per-project breakdown)')
     .option('--org <id>', 'target org (default: linked project\'s org)').option('--json')
     .action(guard((o) => billing(o)));
 bill.command('upgrade <tier>').description('Subscribe the org to a paid tier (pro|enterprise) via Stripe Checkout')
@@ -140,5 +148,12 @@ ob.command('sync').description('Upload findings into the project timeline').acti
 const pol = program.command('policy').description('Governance policy');
 pol.command('get').option('--json').action(guard((o) => govern.policyGet(o)));
 pol.command('set <action> <decision>').description('action: secrets.read|secrets.write|deploy|project.delete|branch.delete|service.add|service.remove|service.scale|service.upgrade; decision: allow|deny|approve').action(guard((a, d) => govern.policySet(a, d)));
+// ---- self-update ----
+program.command('upgrade').description('Update the insta CLI to the latest release (binary or npm install)')
+    .action(guard(() => selfUpdate.upgrade()));
+program.command('autoupdate [mode]').description('Show or set auto-update: on | off (default: on while pre-1.0)')
+    .action(guard((mode) => selfUpdate.autoupdate(mode)));
+program.command('__update-check', { hidden: true }).action(guard(() => selfUpdate.backgroundCheck()));
+selfUpdate.maybeUpdate(resolveVersion(), process.argv);
 program.parseAsync(process.argv);
 //# sourceMappingURL=index.js.map

package/dist/observe/install.js

@@ -55,8 +55,11 @@ function materialize(cwd, assetDir) {
     writeFileSync(join(dest, 'VERSION'), cliVersion() + '\n');
 }
 function claudeEntry() {
-    return { matcher: '*', hooks: [{ type: 'command', command: 'node',
-                args: ['${CLAUDE_PROJECT_DIR}/.insta/observe/hook.js'], timeout: 15, _insta: MARKER }] };
+    // Claude Code executes `command` as ONE shell string with $CLAUDE_PROJECT_DIR in the env —
+    // there is no `args` field in its hooks schema, so a ${…} template in args reaches node
+    // verbatim and throws MODULE_NOT_FOUND after every tool call.
+    return { matcher: '*', hooks: [{ type: 'command',
+                command: 'node "$CLAUDE_PROJECT_DIR/.insta/observe/hook.js"', timeout: 15, _insta: MARKER }] };
 }
 function codexEntry(cwd) {
     const abs = join(cwd, '.insta', 'observe', 'hook.js'); // Codex doesn't expand ${CLAUDE_PROJECT_DIR}; use an absolute path

package/package.json

@@ -1,17 +1,37 @@
 {
   "name": "insta",
-  "version": "0.0.5",
+  "version": "0.0.8",
   "type": "module",
   "description": "InstaCloud CLI — a thin client of the platform control-plane API.",
-  "keywords": ["insta", "insforge", "cli", "backend", "baas", "platform"],
+  "keywords": [
+    "insta",
+    "insforge",
+    "cli",
+    "backend",
+    "baas",
+    "platform"
+  ],
   "license": "Apache-2.0",
   "homepage": "https://github.com/InsForge/insta-cli#readme",
-  "repository": { "type": "git", "url": "git+https://github.com/InsForge/insta-cli.git" },
-  "bugs": { "url": "https://github.com/InsForge/insta-cli/issues" },
-  "bin": { "insta": "dist/index.js" },
-  "files": ["dist/**/*.js"],
-  "engines": { "node": ">=18" },
-  "publishConfig": { "access": "public" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/InsForge/insta-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/InsForge/insta-cli/issues"
+  },
+  "bin": {
+    "insta": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",