insta 0.1.18 → 0.1.20

package/dist/commands/compute.js

@@ -68,10 +68,26 @@ export function domainGuidanceLines(r, ctx = {}) {
 // where the hostname resolves — we cannot confirm routing, and must not call it serving. A Fly
 // answer carries no `ssl` and has no per-hostname origin concept, so its own verdict stands.
 const reportsOrigin = (r) => r.ssl !== undefined;
+// A deployment with NO edge custody for custom domains (a pre-Cloudflare plane). It reports
+// `origin: ""` exactly like a region whose operator forgot cf-custom-origin, so the pair alone reads
+// it backwards and names a setting this deployment does not have. The plane's own verdict
+// (`originStatus: 'unmanaged'`) decides when relayed; without it, `ssl: 'external'` is the plane's
+// marker for the same deployment class (it manages no edge certificate here) — the same fallback the
+// console uses. Only an unconfirmed origin is reinterpreted: a reported, confirmed origin stands.
+const edgeUnmanaged = (r) => r.originStatus === 'unmanaged' ||
+    (r.originStatus === undefined && r.ssl === 'external' && (r.origin === undefined || r.origin === ''));
 // Where the hostname actually resolves — the region-specific origin the plane requested vs what
 // Cloudflare holds. Each shape carries its action; absent fields are reported as absent.
 export function domainResolveLine(r) {
     const region = r.region ?? 'this region';
+    if (edgeUnmanaged(r)) {
+        // Not ready (routing cannot be confirmed from here), but no operator knob to name either:
+        // setting cf-custom-origin does nothing on a deployment with no edge custody.
+        return {
+            line: `  ${pad('resolves to', 12)}UNMANAGED — ${region} does not manage edge certificates for custom domains, so where ${r.hostname} lands cannot be confirmed from here; if it does not serve, contact support`,
+            ready: false,
+        };
+    }
     if (r.origin === undefined) {
         if (reportsOrigin(r)) {
             return {
@@ -194,6 +210,7 @@ export function domainStatusLines(r, ctx = {}) {
         }
     }
     const ssl = r.ssl ?? (r.configured ? 'active' : undefined);
+    const reasonOnCert = !!r.errorReason && r.status !== 'error' && ssl !== undefined && ssl !== 'active' && ssl !== 'external';
     if (ssl === 'active')
         stage('certificate', 'active', '(edge TLS issued)');
     else if (ssl === 'external')
@@ -203,7 +220,11 @@ export function domainStatusLines(r, ctx = {}) {
         blockers.push('certificate');
     }
     else {
-        stage('certificate', 'pending', `(${ssl} — issues once ownership is verified)`);
+        // A pending certificate with a reason from the plane: the reason IS why it has not issued (a CAA
+        // block, the hostname not pointed at the edge), so it replaces the generic text here and is not
+        // repeated below. An `error` row keeps its reason on its own error line.
+        const detail = reasonOnCert ? `(${ssl}) ${r.errorReason}` : `(${ssl} — issues once ownership is verified)`;
+        stage('certificate', 'pending', detail);
         blockers.push('certificate');
     }
     const resolve = domainResolveLine(r);
@@ -214,9 +235,17 @@ export function domainStatusLines(r, ctx = {}) {
         stage('error', r.status, r.errorReason || '(the plane reported an error state with no reason)');
         blockers.push('the plane reports an error state');
     }
-    else if (r.errorReason) {
-        stage('error', r.status, r.errorReason);
-        blockers.push(r.errorReason);
+    else if (r.errorReason && !reasonOnCert) {
+        // On an ACTIVE row the plane keeps serving and REPORTS what the edge says has regressed (it
+        // never demotes a serving row on an edge read). That is a warning beside a serving hostname,
+        // not a blocker: turning it into one would print "not yet" for a domain taking traffic.
+        // Every other state with a reason is still being set up, and the reason is what blocks it.
+        if (r.status === 'active')
+            stage('warning', r.status, r.errorReason);
+        else {
+            stage('error', r.status, r.errorReason);
+            blockers.push(r.errorReason);
+        }
     }
     // An unconfirmed routing target is one blocker among the others, not a headline that hides them:
     // a user fixing their DNS needs the whole outstanding list, not whichever item sorted first.

package/dist/commands/template.js

@@ -35,6 +35,8 @@ export function normalizeInfoServices(raw) {
         volumeGib: s?.volumeGib ?? s?.volume?.size,
         volume: s?.volume === true || s?.volumeGib != null || s?.volume?.size != null,
         mountPath: typeof s?.mountPath === 'string' ? s.mountPath : undefined,
+        pgVersion: typeof s?.pgVersion === 'number' ? s.pgVersion : undefined,
+        public: typeof s?.public === 'boolean' ? s.public : undefined,
     });
     if (Array.isArray(raw))
         return raw.map((s) => one(s?.name ?? '?', s));
@@ -56,6 +58,20 @@ export function normalizeInfoVariables(raw) {
     }
     return [];
 }
+// The type plus what the manifest fixes about it: a Postgres major, or whether anyone can read a bucket.
+function infoKind(s) {
+    if (s.type === 'postgres' && s.pgVersion !== undefined)
+        return `postgres ${s.pgVersion}`;
+    if (s.type === 'storage')
+        return `storage, ${s.public ? 'public' : 'private'}`;
+    return s.type && s.type !== 'compute' ? s.type : undefined;
+}
+// One line per bucket the template opens to the world, so a deploy never makes one public unannounced.
+export function publicBucketLines(services) {
+    return normalizeInfoServices(services)
+        .filter((s) => s.type === 'storage' && s.public === true)
+        .map((s) => `${s.name}: public bucket, anyone can read its files (anonymous public-read)`);
+}
 // `bold` is injected so the renderer stays pure (tests pass identity; the command passes ANSI
 // bold on a TTY).
 export function templateInfoLines(t, bold = (s) => s) {
@@ -75,7 +91,7 @@ export function templateInfoLines(t, bold = (s) => s) {
             // A size only when the registry still carries one: a manifest names no size any more, so
             // "persistent /data" is all there is to say until the service exists.
             const disk = s.volumeGib ? `${s.volumeGib}Gi volume` : s.volume ? `persistent ${s.mountPath ?? '/data'}` : undefined;
-            const bits = [s.type && s.type !== 'compute' ? s.type : undefined, s.port ? `port ${s.port}` : undefined, disk].filter(Boolean);
+            const bits = [infoKind(s), s.port ? `port ${s.port}` : undefined, disk].filter(Boolean);
             return `${s.name}${bits.length ? ` (${bits.join(', ')})` : ''}`;
         });
         lines.push(`services (${services.length}): ${summary.join(', ')}`);
@@ -325,10 +341,12 @@ export async function templateDeploy(target, opts = {}, deps = {}) {
     let manifest;
     let source;
     let vars;
+    let services; // what the template declares, for the one thing the deployer must be told
     if (mode.kind === 'github') {
         const fetched = await (deps.fetchGitHub ?? ((t) => fetchGitHubTemplate(t)))(mode.target);
         manifest = fetched.manifest;
         source = fetched.source;
+        services = manifest.services;
         vars = collectManifestVariables(manifest);
         // Exactly ONE line in front of today's output. A second "deploying template …" line
         // would read as a duplicate of the "deploying template <code> to branch <branch>" line below,
@@ -339,6 +357,7 @@ export async function templateDeploy(target, opts = {}, deps = {}) {
     }
     else if (mode.kind === 'local') {
         manifest = loadTemplateManifest(mode.dir); // parse + local validation (pinned images, described vars)
+        services = manifest.services;
         vars = collectManifestVariables(manifest);
         if (!quiet)
             info(`deploying local template ${manifest.code}@${manifest.version}`);
@@ -347,6 +366,7 @@ export async function templateDeploy(target, opts = {}, deps = {}) {
         // Learn the variable set up front from the registry so prompting happens before the POST.
         const tpl = await api.request('GET', `/templates/${encodeURIComponent(mode.code)}`);
         vars = normalizeInfoVariables((tpl.template ?? tpl).variables);
+        services = (tpl.template ?? tpl).services;
     }
     // --json asked for parseable output, so a caller that happens to own a TTY still gets the error.
     const tty = !opts.json && !opts.yes && !!process.stdin.isTTY && !!process.stdout.isTTY;
@@ -381,8 +401,11 @@ export async function templateDeploy(target, opts = {}, deps = {}) {
     const deploymentId = res.body.deploymentId ?? (res.body.deployment ?? res.body).id;
     const acceptedRegion = (res.body.deployment ?? res.body).region;
     const codeLabel = manifest?.code ?? target;
-    if (!quiet)
+    if (!quiet) {
         info(`deploying template ${codeLabel} to branch ${branchName}${acceptedRegion ? ` in ${acceptedRegion}` : ''} (${deploymentId})`);
+        for (const line of publicBucketLines(services))
+            info(line);
+    }
     // The poll route is keyed by deployment id, not project: name the project so agent mode signs
     // with the project-bound session (a bootstrap session is rejected as "for a different project").
     const dep = await watchDeployment((id) => api.request('GET', `/template-deployments/${id}`, undefined, { projectId: p.projectId }), deploymentId, quiet ? () => { } : info, deps.wait);

package/dist/index.js

@@ -541,7 +541,7 @@ tpl.command('info <code>').description('Show a template: version, upstream pin,
     .option('--json').action(guard((code, o) => template.templateInfo(code, o)));
 tpl.command('deploy <code-or-dir-or-url>').description('Deploy a template onto a branch — a registry code, a local directory containing insta.template.yaml (a path-looking target is always read as a directory), or a github.com URL (https://github.com/<owner>/<repo>[/tree/<ref>[/<dir>]]) whose manifest is fetched with your own git credentials. Missing required variables are prompted for on a terminal; generator-backed (secret:N) and defaulted ones are resolved by the platform')
     .option('--branch <b>', 'target branch (default: current)')
-    .option('--region <region>', 'region for every service the template creates, e.g. us-east (see `insta config regions`)')
+    .option('--region <region>', 'region for every service the template creates (a storage bucket has none), e.g. us-east (see `insta config regions`)')
     .option('--set <NAME=value>', 'set a template variable (repeatable)', (v, prev) => [...prev, v], [])
     .option('-y, --yes', 'non-interactive: missing required variables fail with a --set list instead of prompting')
     .option('--json')

package/dist/template-manifest.js

@@ -1,7 +1,7 @@
 // Local insta.template.yaml parsing + validation for `insta template deploy ./dir` — the CLI
 // twin of the platform's src/provisioning/templateManifest.ts (THE authority; the executor
 // revalidates every manifest). Local checks exist to fail fast with a file the author can act
-// on, before anything travels, so the rules here mirror the server's exactly — plus two
+// on, before anything travels, so the rules here mirror the server's for web and worker services and leave every other type to it — plus two
 // authoring lints the server does not enforce: images must be pinned, and required variables
 // need a description unless a generator answers for the user. Everything here is pure over the
 // parsed document (unit-tested); only loadTemplateManifest touches disk.
@@ -14,9 +14,10 @@ export const MANIFEST_FILE = 'insta.template.yaml';
 const CODE_RE = /^[a-z0-9][a-z0-9-]{0,38}$/;
 export const ENV_NAME_RE = /^[A-Z][A-Z0-9_]{0,63}$/;
 const GENERATOR_RE = /^secret:([1-9]\d{0,2})$/;
-// The platform provisions these and owns everything about them (platform templateManifest.ts).
-const MANAGED_TYPES = ['postgres', 'redis', 'mysql', 'mongodb'];
-const MANIFEST_TYPES = ['web', 'worker', ...MANAGED_TYPES];
+// The compute vocabulary every CLI has known. Any other type is the platform's to accept or refuse.
+const COMPUTE_TYPES = ['web', 'worker'];
+// Datastores that never gain a url or host. Storage is left off because a public bucket may get an address.
+const NO_ADDRESS_TYPES = ['postgres', 'redis', 'mysql', 'mongodb'];
 // What counts as a digest is the PLATFORM's call, not ours: registry.ts's DIGEST regex, verbatim.
 const DIGEST = /^sha256:[a-f0-9]{64}$/;
 // Why an image must carry a pin: a template is a reproducible deploy, and a tagless ref (implicit
@@ -83,30 +84,9 @@ export function validateManifest(m) {
         const where = `services.${name}`;
         // typeof, not String(): a YAML array like [redis] would otherwise stringify to its lone element.
         const type = typeof svc.type === 'string' ? svc.type : undefined;
-        if (!type || !MANIFEST_TYPES.includes(type)) {
-            problems.push(`${where}.type must be one of ${MANIFEST_TYPES.join(', ')}`);
-        }
-        // A managed datastore is BARE: the platform owns its image, port, sizing, credentials and env,
-        // so every other rule below would be asking about fields it must not carry. Mirrors the
-        // platform's own check (provisioning/templateManifest.ts) so an author hears it here.
-        if (type && MANAGED_TYPES.includes(type)) {
-            const bare = svc;
-            for (const field of ['image', 'build', 'port', 'healthcheck', 'volume', 'volumeGib', 'spec', 'alwaysOn', 'command', 'mountPath']) {
-                if (bare[field] !== undefined) {
-                    problems.push(`${where}.${field}: a ${type} service is platform-managed and carries no ${field} — declare it bare ({ type: ${type} })`);
-                }
-            }
-            const groups = ['fixed', 'generated', 'platform', 'required', 'optional'];
-            const envShell = bare.env;
-            if (envShell !== undefined) {
-                const emptyShell = !!envShell && typeof envShell === 'object' && !Array.isArray(envShell)
-                    && Object.entries(envShell).every(([g, v]) => groups.includes(g) && !!v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length === 0);
-                if (!emptyShell) {
-                    problems.push(`${where}.env: a ${type} service is platform-managed and carries no env — declare it bare ({ type: ${type} })`);
-                }
-            }
+        // Every other type, and every field and env on it, is the platform's to judge. It answers 400 with its own list.
+        if (!type || !COMPUTE_TYPES.includes(type))
             continue;
-        }
         if (svc.image && svc.build)
             problems.push(`${where}: image and build are mutually exclusive`);
         if (!svc.image && !svc.build)
@@ -200,7 +180,7 @@ export function validateManifest(m) {
                     continue;
                 const target = services[svcRef[1]];
                 const targetType = target && typeof target.type === 'string' ? target.type : undefined;
-                if (targetType && MANAGED_TYPES.includes(targetType)) {
+                if (targetType && NO_ADDRESS_TYPES.includes(targetType)) {
                     problems.push(`services.${name}.env.fixed.${varName}: '${svcRef[1]}' is a managed ${targetType}, so it has no url or host. Use its platform credentials instead: \${{services.${svcRef[1]}.<KEY>}} under env.platform`);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insta",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "type": "module",
   "description": "InstaCloud CLI — a thin client of the platform control-plane API.",
   "keywords": [