@biznetgio/neo-app 0.4.68 → 0.4.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biznetgio/neo-app",
-  "version": "0.4.68",
+  "version": "0.4.70",
   "description": "NEO App CLI — one-command agent onboarding, MCP server, and project ops for coding agents (Codex, Claude Code).",
   "type": "module",
   "bin": {

package/src/api.js

@@ -101,6 +101,22 @@ export class NeoApi {
     return this.request('DELETE', path, opts);
   }
 
+  // estimate asks the control-plane for the canonical cost of a set of resources (#170):
+  // the server's planCost is the SOLE price authority, so the CLI never computes money
+  // locally. Scope is a project (access + org context) OR an org (project-less quote).
+  // Returns { cost, delta? } where cost is the normalized contract
+  // ({ currency, hourly, monthly, breakdown, variable, upfront, priceBook,
+  //    priceBookVersion, billingQuantum, assumptions, pricingUnavailable }).
+  async estimate({ projectId, orgId }, { resources, current, environment } = {}) {
+    const body = { resources: resources || [] };
+    if (environment) body.environment = environment;
+    if (current && current.length) body.current = current;
+    const path = projectId
+      ? `/api/v1/projects/${projectId}/estimate`
+      : `/api/v1/orgs/${orgId}/estimate`;
+    return (await this.post(path, body)).data;
+  }
+
   // whoami composes the two calls the server needs for identity (no combined endpoint).
   async whoami() {
     const me = (await this.get('/api/v1/auth/me')).data;

package/src/commands/deploy.js

@@ -8,6 +8,7 @@ import { getCredential } from '../creds.js';
 import { NeoApi } from '../api.js';
 import { readLink } from '../link.js';
 import { deploySource } from '../deploySource.js';
+import { formatCost } from '../cost.js';
 import { log, ok, fail, warn, step, c, confirm } from '../util.js';
 
 function isGitUrl(s) {
@@ -32,7 +33,8 @@ function isDir(s) {
 function showCost(r) {
   if (r?.estimatedCost) {
     const e = r.estimatedCost;
-    log(c.bold(`Estimated cost: ~${e.monthly} ${e.currency}/mo (${e.hourly}/h)`) + (e.assumptions ? c.dim(` — ${e.assumptions}`) : ''));
+    const note = (e.assumptions || []).join('; ');
+    log(c.bold(`Estimated cost: ${formatCost(e)}`) + (note ? c.dim(` — ${note}`) : ''));
   }
 }
 

package/src/cost.js

@@ -0,0 +1,41 @@
+// cost.js — the ONE place the CLI turns a flat service spec into the server's resource
+// list and renders the server's normalized cost (#170). The control-plane `planCost`
+// (POST /estimate) is the SOLE price authority; nothing here computes money. The old
+// local engine (pricing.js `estimateCost`, which prorated monthly÷730 itself) is gone —
+// it drifted from the server, which is exactly the divergence #170 removes.
+
+// specToResources maps the CLI's flat quote spec to the server's planResourceSpec[]:
+//   { computeTier | (vcpu + memoryMB), storageGB, objectStorageGB, replicas }
+// A tier OR custom (unbundled) compute → one app resource; persistent storage → a
+// database; object storage → a bucket. Returns [] when nothing billable is specified
+// (callers treat that as "no estimate" rather than sending an empty request).
+export function specToResources(spec = {}) {
+  const resources = [];
+  const replicas = spec.replicas && spec.replicas > 0 ? spec.replicas : undefined;
+  if (spec.computeTier) {
+    resources.push({ kind: 'app', name: 'service', computeTier: spec.computeTier, replicas });
+  } else if (spec.vcpu || spec.memoryMB) {
+    resources.push({
+      kind: 'app',
+      name: 'service',
+      billingMode: 'unbundled',
+      cpuLimit: spec.vcpu ? String(spec.vcpu) : undefined,
+      memoryLimit: spec.memoryMB ? `${spec.memoryMB}Mi` : undefined,
+      replicas,
+    });
+  }
+  if (spec.storageGB) resources.push({ kind: 'database', name: 'storage', volumeSize: `${spec.storageGB}Gi` });
+  if (spec.objectStorageGB) resources.push({ kind: 'bucket', name: 'object', quotaGB: spec.objectStorageGB });
+  return resources;
+}
+
+// formatCost renders the server cost contract as a single-line money summary — the one
+// renderer every gate shares (de-dups the three `~${monthly} ${currency}/mo (${hourly}/h)`
+// copies that drifted across tools.js / deploySource.js / deploy.js). Object-storage
+// upfront is shown separately (it has no hourly equivalent — #170), never folded in.
+export function formatCost(cost) {
+  if (!cost) return '';
+  const base = `~${cost.monthly} ${cost.currency}/mo (${cost.hourly}/h)`;
+  const upfront = (cost.upfront || []).reduce((sum, l) => sum + (l.monthly || 0), 0);
+  return upfront ? `${base} + ${upfront} ${cost.currency} upfront` : base;
+}

package/src/deploySource.js

@@ -7,7 +7,7 @@ import { existsSync, readFileSync, readdirSync, writeFileSync, rmSync } from 'no
 import { execFileSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import { createHash } from 'node:crypto';
-import { estimateCost } from './pricing.js';
+import { specToResources, formatCost } from './cost.js';
 
 // deployToken binds a dry-run to its real deploy: a short hash of the resolved spec
 // that actually deploys. The dry-run returns it; the real call, if given confirmToken,
@@ -306,15 +306,15 @@ export async function deploySource(api, { projectId, src, name, port, build, ser
   const buildPreview = async () => {
     let estimatedCost;
     try {
-      const book = (await api.get('/api/v1/pricing')).data;
-      estimatedCost = estimateCost(book, { computeTier: 'micro' });
-    } catch { /* price book unavailable — skip the estimate */ }
+      // The server /estimate is the price authority (#170); deploys default to micro compute.
+      estimatedCost = (await api.estimate({ projectId }, { resources: specToResources({ computeTier: 'micro' }) })).cost;
+    } catch { /* estimate unavailable — skip it (best-effort) */ }
     // Include the acting account/env/project so a wrong-account or wrong-environment deploy
     // is obvious before it happens (JNG #131). Best-effort — never fail the preview on it.
     let ident = {};
     try { if (typeof api.actingIdentity === 'function') ident = await api.actingIdentity(); } catch { /* ignore */ }
     const acting = { ...ident, environment: targetEnv, project: projectId };
-    return { dryRun: true, plan, service: svc, environment: targetEnv, serviceType: svcType, estimatedCost, confirmToken: token, acting };
+    return { dryRun: true, plan, service: svc, environment: targetEnv, serviceType: svcType, estimatedCost, priceBookVersion: estimatedCost?.priceBookVersion, confirmToken: token, acting };
   };
 
   // Preview path (explicit dry-run OR an unapproved real deploy). No mutation ran above,
@@ -327,7 +327,7 @@ export async function deploySource(api, { projectId, src, name, port, build, ser
     const prev = await buildPreview();
     if (prev.estimatedCost) {
       const build = svcType === 'static_site' ? 'native nginx static hosting (not Railpack)' : 'built server-side';
-      log(`[dry-run] estimated cost (${svcType}, ${build}, default micro compute): ~${prev.estimatedCost.monthly} ${prev.estimatedCost.currency}/mo (${prev.estimatedCost.hourly}/h) — ${prev.estimatedCost.assumptions}. Use neo_estimate for a specific size.`);
+      log(`[dry-run] estimated cost (${svcType}, ${build}, default micro compute): ${formatCost(prev.estimatedCost)} — ${(prev.estimatedCost.assumptions || []).join('; ')}. Use neo_estimate for a specific size.`);
     }
     if (dryRun) return prev;
     return { ...prev, requiresConfirmation: true, note: 'Billable deploy — show the user the cost, then re-call with this confirmToken (or confirm:true) to deploy. Nothing was deployed.' };

package/src/mcp/tools.js

@@ -6,7 +6,7 @@ import { resolve, basename } from 'node:path';
 import { statSync, readFileSync } from 'node:fs';
 import { deploySource } from '../deploySource.js';
 import { pkgVersion } from '../util.js';
-import { estimateCost } from '../pricing.js';
+import { specToResources, formatCost } from '../cost.js';
 
 const str = (description) => ({ type: 'string', description });
 const int = (description) => ({ type: 'integer', description });
@@ -157,16 +157,21 @@ async function confirmCost(api, args, spec) {
   if (args.confirm === true) return null;
   let orgId = null;
   try { orgId = await api.resolveOrgId(args.orgId); } catch { orgId = null; }
-  let book = null;
-  try { book = (await api.get(orgId ? `/api/v1/orgs/${orgId}/pricing` : '/api/v1/pricing')).data; }
-  catch { try { book = (await api.get('/api/v1/pricing')).data; } catch { book = null; } }
+  // The server's /estimate is the sole price authority (#170) — the CLI no longer prices
+  // locally. Prefer the project scope (exact org context); fall back to org scope for a
+  // project-less quote. Best-effort: a failed estimate must never fail the gate.
   let cost = null;
-  if (book) { try { cost = estimateCost(book, spec); } catch { cost = null; } } // never fail the gate on an estimate error
+  const resources = specToResources(spec);
+  if (resources.length && (args.projectId || orgId)) {
+    try { cost = (await api.estimate(args.projectId ? { projectId: args.projectId } : { orgId }, { resources })).cost; }
+    catch { cost = null; }
+  }
   return {
     requiresConfirmation: true,
     cost,
+    priceBookVersion: cost?.priceBookVersion, // pins the quote to a price-book snapshot (#170)
     acting: await actingOf(api, { orgId, projectId: args.projectId }), // whose/where — JNG #131
-    priceBook: orgId ? `org:${orgId}` : 'global-defaults',
+    priceBook: cost?.priceBook || (orgId ? `org:${orgId}` : 'global-defaults'),
     message: 'Billable resource — show the user this cost (and the acting account/org), then re-call with confirm:true to create. For an immutable, server-pinned quote use neo_plan_stack → neo_apply_stack.',
   };
 }
@@ -181,15 +186,16 @@ async function confirmCost(api, args, spec) {
 async function billableGate(api, { projectId, kind, name, confirmationId, confirm, environment }, spec) {
   if (confirmationId) return { query: `?confirmationId=${encodeURIComponent(confirmationId)}` };
 
-  // Estimate the cost (best-effort) for display and the confirmation summary.
+  // Estimate the cost (best-effort) for display and the confirmation summary — the server's
+  // /estimate is the price authority (#170). billableGate always runs inside a project.
   let orgId = null;
   try { orgId = await api.resolveOrgId(); } catch { orgId = null; }
-  let book = null;
-  try { book = (await api.get(orgId ? `/api/v1/orgs/${orgId}/pricing` : '/api/v1/pricing')).data; }
-  catch { try { book = (await api.get('/api/v1/pricing')).data; } catch { book = null; } }
   let cost = null;
-  if (book) { try { cost = estimateCost(book, spec); } catch { cost = null; } }
-  const costNote = cost ? `~${cost.monthly} ${cost.currency}/mo (${cost.hourly}/h)` : '';
+  const resources = specToResources(spec);
+  if (resources.length) {
+    try { cost = (await api.estimate({ projectId }, { resources })).cost; } catch { cost = null; }
+  }
+  const costNote = cost ? formatCost(cost) : '';
 
   // Mint a server-side billable_create confirmation bound to this exact resource.
   // Retry a transient 5xx/dropped connection: minting has no lasting side effect (an
@@ -197,7 +203,7 @@ async function billableGate(api, { projectId, kind, name, confirmationId, confir
   // from failing an otherwise-fine create (same spirit as the api-layer idempotent retry).
   let mint;
   for (let attempt = 1; ; attempt++) {
-    try { mint = (await api.post('/api/v1/confirmations', { action: 'billable_create', projectId, kind, name, environment, estimatedCost: costNote })).data; break; }
+    try { mint = (await api.post('/api/v1/confirmations', { action: 'billable_create', projectId, kind, name, environment, estimatedCost: costNote, priceBookVersion: cost?.priceBookVersion })).data; break; }
     catch (e) {
       if (attempt < 3 && (e?.status >= 500 || e?.status === 0)) { await new Promise((r) => setTimeout(r, 300 * attempt)); continue; }
       throw e;
@@ -212,8 +218,9 @@ async function billableGate(api, { projectId, kind, name, confirmationId, confir
   return {
     requiresConfirmation: true,
     cost,
+    priceBookVersion: cost?.priceBookVersion, // pins the quote to a price-book snapshot (#170)
     acting: await actingOf(api, { orgId, projectId }), // whose/where — JNG #131
-    priceBook: orgId ? `org:${orgId}` : 'global-defaults',
+    priceBook: cost?.priceBook || (orgId ? `org:${orgId}` : 'global-defaults'),
     confirmationId: id,
     message: `Billable ${kind} — show the user this cost AND the acting account/org, then approve server-side: neo_confirm_action("${id}", "approve"), and re-call this tool with confirmationId="${id}". (Shortcut: re-call with confirm:true.) Nothing was created.`,
   };
@@ -270,6 +277,25 @@ export const TOOLS = [
       return { environment: sessionEnv, ...acct };
     },
   },
+  {
+    name: 'neo_list_tokens',
+    description: 'List your API tokens — the agent/MCP & CLI SESSIONS that can act as you (JNG #109). Returns id, name, scope, createdAt, and lastUsed (so you can spot stale or unexpected sessions). Token secrets are never returned (write-only). Use with neo_revoke_token to terminate a session.',
+    mutating: false,
+    schema: { type: 'object', properties: {} },
+    async call(api) {
+      return (await api.get('/api/v1/tokens')).data;
+    },
+  },
+  {
+    name: 'neo_revoke_token',
+    description: 'Revoke (terminate) an API token / agent session by id — the token stops working immediately and cannot be restored (JNG #109). DESTRUCTIVE: confirm with the user which session to revoke first, and do NOT revoke the token this session is currently using unless the user explicitly wants to end it. Use neo_list_tokens to find the id.',
+    mutating: true,
+    destructive: true,
+    schema: { type: 'object', properties: { tokenId: str('Token/session id (from neo_list_tokens)') }, required: ['tokenId'] },
+    async call(api, args) {
+      return (await api.del(`/api/v1/tokens/${args.tokenId}`)).data;
+    },
+  },
   {
     name: 'neo_get_capabilities',
     description:
@@ -313,7 +339,7 @@ export const TOOLS = [
         controlPlane,
         resourceTypes,
         // Verbs this MCP build exposes today (no create-DB/queue/cron/bucket, no costed plan/apply yet).
-        lifecycleVerbs: ['plan', 'apply', 'plan_promotion', 'get_operation', 'wait_operation', 'delete_stack', 'reconcile_usage', 'service_usage', 'create', 'list', 'get', 'update', 'verify', 'enable_public_access', 'disable_public_access', 'deploy', 'scale', 'add_domain', 'remove_domain', 'domain_status', 'logs', 'get_variables', 'set_variable', 'estimate', 'scan_repo', 'bind', 'unbind', 'run_cron', 'cron_questionnaire', 'presign_object', 'backup', 'restore', 'delete', 'delete_project', 'list_approvals', 'get_approval', 'get_credit', 'list_templates'],
+        lifecycleVerbs: ['plan', 'apply', 'plan_promotion', 'get_operation', 'wait_operation', 'delete_stack', 'reconcile_usage', 'service_usage', 'create', 'list', 'get', 'update', 'verify', 'enable_public_access', 'disable_public_access', 'deploy', 'scale', 'add_domain', 'remove_domain', 'domain_status', 'logs', 'get_variables', 'set_variable', 'estimate', 'scan_repo', 'bind', 'unbind', 'run_cron', 'cron_questionnaire', 'presign_object', 'backup', 'restore', 'delete', 'delete_project', 'list_approvals', 'get_approval', 'get_credit', 'list_templates', 'list_tokens', 'revoke_token'],
         promotion: { supported: true, byCopy: true, tool: 'neo_plan_promotion', note: 'staging→production promotion by copy (JNG #112 §8.7): an immutable costed prod stack plan; applied with neo_apply_stack; copies build/compute/env/bound foundations, never custom domains or secret values, never mutates the source.' },
         bindings: { supported: true, targets: ['neo_db', 'neo_queue', 'neo_object_storage'], writeOnly: true, note: 'neo_bind_resource + neo_plan_stack bindings inject DATABASE_URL / NATS_URL (+ NATS_HOST/PORT/USER/PASSWORD) / S3_* server-side at deploy; secrets never returned (handoff 5)' },
         sourceTypes: ['git', 'image', 'dockerfile', 'local', 'template'],
@@ -912,17 +938,15 @@ export const TOOLS = [
       },
     },
     async call(api, args) {
-      // Prefer the org price book (applies overrides); fall back to global defaults.
+      // The server /estimate is the sole price authority (#170) — no local money math.
+      // Quote at org scope (applies that org's overrides); the cost depends only on the org.
       let orgId = args.orgId;
       if (!orgId) { try { orgId = await api.resolveOrgId(); } catch { orgId = null; } }
-      let book;
-      try {
-        book = (await api.get(orgId ? `/api/v1/orgs/${orgId}/pricing` : '/api/v1/pricing')).data;
-      } catch {
-        book = (await api.get('/api/v1/pricing')).data; // org book may 404; global always readable
-      }
-      const est = estimateCost(book, args);
-      return { ...est, priceBook: orgId ? `org:${orgId}` : 'global-defaults' };
+      if (!orgId) throw new Error('no organization for this account — cannot estimate cost');
+      const resources = specToResources(args);
+      if (!resources.length) throw new Error('nothing to estimate — pass computeTier (or vcpu+memoryMB), storageGB, and/or objectStorageGB');
+      const { cost } = await api.estimate({ orgId }, { resources });
+      return cost; // normalized contract: currency/hourly/monthly/breakdown/variable/upfront/priceBook/priceBookVersion/assumptions
     },
   },
   {

package/src/pricing.js

@@ -1,77 +0,0 @@
-// Cost estimation from the NEO App price book (handoff 3.3/3.4 — cost consent).
-// Pure + dependency-free so it's trivially testable and reusable by both the
-// neo_estimate MCP tool and the deploy dry-run. The price book is the live
-// `/pricing` response: { prices: [{metric,key,rate,unit,currency,active}], tiers:[{key,vcpu,memoryMB,defaultRate}] }.
-// defaultRate is IDR/MONTH; hourly SKUs prorate over 730 hours/month.
-
-export const HOURS_PER_MONTH = 730;
-
-// priceOf finds an active price entry for a metric (+ optional tier key), or null.
-function priceOf(prices, metric, key = '') {
-  return (prices || []).find((x) => x.metric === metric && (x.key || '') === key && x.active !== false) || null;
-}
-
-// The price book is NOT self-describing by metric name: `compute_tier_hour`
-// actually carries unit:"month" with a MONTHLY rate, while `vcpu_hour`/`gb_ram_hour`
-// are genuinely hourly. So always normalize by the entry's `unit`, never the name.
-function hourlyFrom(price) {
-  if (!price) return null;
-  return /month/i.test(price.unit || '') ? price.rate / HOURS_PER_MONTH : price.rate;
-}
-function monthlyFrom(price) {
-  if (!price) return null;
-  return /month/i.test(price.unit || '') ? price.rate : price.rate * HOURS_PER_MONTH;
-}
-
-// estimateCost returns { currency, hourly, monthly, breakdown, assumptions } for
-// a spec: { computeTier?, vcpu?, memoryMB?, storageGB?, objectStorageGB?, replicas? }.
-// Compute is a bundled tier (compute_tier_hour, else the tier's defaultRate/730)
-// or custom (vcpu_hour*vCPU + gb_ram_hour*GB-RAM). Storage/object use their SKUs.
-export function estimateCost(book, spec = {}) {
-  const prices = book?.prices || [];
-  const tiers = book?.tiers || [];
-  const replicas = spec.replicas && spec.replicas > 0 ? spec.replicas : 1;
-  const breakdown = [];
-  let hourly = 0;
-  let monthlyExtra = 0; // monthly-only SKUs (storage/object)
-
-  if (spec.computeTier) {
-    let h = hourlyFrom(priceOf(prices, 'compute_tier_hour', spec.computeTier));
-    if (h == null) {
-      const tier = tiers.find((t) => t.key === spec.computeTier);
-      h = tier ? tier.defaultRate / HOURS_PER_MONTH : null; // defaultRate is monthly
-    }
-    if (h == null) {
-      const known = tiers.map((t) => t.key).join(', ') || 'none in price book';
-      throw new Error(`unknown compute tier "${spec.computeTier}" — known tiers: ${known}`);
-    }
-    hourly += h * replicas;
-    breakdown.push({ item: `compute ${spec.computeTier}${replicas > 1 ? ` x${replicas}` : ''}`, hourly: h * replicas });
-  } else if (spec.vcpu || spec.memoryMB) {
-    const vc = hourlyFrom(priceOf(prices, 'vcpu_hour')) || 0;
-    const gr = hourlyFrom(priceOf(prices, 'gb_ram_hour')) || 0;
-    const h = (vc * (spec.vcpu || 0) + gr * ((spec.memoryMB || 0) / 1024)) * replicas;
-    hourly += h;
-    breakdown.push({ item: `compute custom (${spec.vcpu || 0} vCPU, ${spec.memoryMB || 0} MB)${replicas > 1 ? ` x${replicas}` : ''}`, hourly: h });
-  }
-
-  if (spec.storageGB) {
-    const m = monthlyFrom(priceOf(prices, 'storage_gb_month') || priceOf(prices, 'gb_storage_hour'));
-    if (m != null) { monthlyExtra += m * spec.storageGB; breakdown.push({ item: `storage ${spec.storageGB} GB`, monthly: m * spec.storageGB }); }
-  }
-  if (spec.objectStorageGB) {
-    const m = monthlyFrom(priceOf(prices, 'object_gb_month') || priceOf(prices, 'object_gb_hour')) || 0;
-    monthlyExtra += m * spec.objectStorageGB;
-    breakdown.push({ item: `object storage ${spec.objectStorageGB} GB`, monthly: m * spec.objectStorageGB });
-  }
-
-  const monthly = hourly * HOURS_PER_MONTH + monthlyExtra;
-  const currency = (prices.find((p) => p.currency)?.currency) || 'IDR';
-  return {
-    currency,
-    hourly: Math.round(hourly * 10000) / 10000,
-    monthly: Math.round(monthly),
-    breakdown,
-    assumptions: `${HOURS_PER_MONTH} hours/month; variable usage (queue messages, cron runs, egress) not included — this is an estimate, not a quote`,
-  };
-}