insta 0.0.4 → 0.0.6

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

@@ -3,6 +3,17 @@ import { existsSync } 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,
+    };
+}
 // 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) {
@@ -14,12 +25,7 @@ export async function deploy(dir, opts) {
     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,
-    });
+    const res = await api.rawRequest('POST', `/projects/${p.projectId}/deploy`, deployRequestBody(image, branch, opts));
     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/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/ensure-skills.js

@@ -11,8 +11,15 @@ import { join } from 'node:path';
 // Codex → .agents/skills/ (.github/skills/ is the third well-known dir). These are regenerable
 // agent context, not the developer's source — keep them out of git.
 const SKILL_DIRS = ['.claude/skills/', '.agents/skills/', '.github/skills/'];
+// `skills` prints a full-screen ASCII banner at the top of every `add`, so our 4 invocations
+// would stack 4 banners. It skips the banner when it detects an agent driving it rather than a
+// human — AI_AGENT is its first-checked signal (any non-empty value ⇒ agent mode). Setting it is
+// honest here (this IS programmatic, not an interactive prompt) and, because we already pin the
+// agents/skills/-y, has no effect on the install beyond quieting the banner. Preserve a caller's
+// existing AI_AGENT (e.g. running inside another agent) rather than clobbering it.
 const defaultRunner = (cmd, args, inherit = false) => new Promise((resolve) => {
-    const p = spawn(cmd, args, { stdio: inherit ? 'inherit' : 'ignore' });
+    const env = { ...process.env, AI_AGENT: process.env.AI_AGENT || 'insta' };
+    const p = spawn(cmd, args, { stdio: inherit ? 'inherit' : 'ignore', env });
     p.on('error', () => resolve({ ok: false })); // e.g. npx not on PATH
     p.on('close', (code) => resolve({ ok: code === 0 }));
 });

package/dist/index.js

@@ -16,6 +16,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})`);
@@ -93,6 +94,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 +116,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 +142,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insta",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "description": "InstaCloud CLI — a thin client of the platform control-plane API.",
   "keywords": ["insta", "insforge", "cli", "backend", "baas", "platform"],