insta 0.0.61 → 0.0.62

package/dist/commands/compute.js

@@ -589,7 +589,7 @@ export async function computeAlwaysOn(mode, serviceName, opts) {
     if (opts.json)
         return printJson(res.body);
     const on = res.body.service?.always_on;
-    info(`compute ${res.body.service?.name ?? id}: always-on ${on ? 'ENABLED — machines stay warm (no cold starts; idle RAM bills at actual usage)' : 'disabled — scales to zero when idle (default)'}`);
+    info(`compute ${res.body.service?.name ?? id}: always-on ${on ? 'ENABLED — machines stay warm (no cold starts; idle RAM bills at actual usage)' : 'disabled — scales to zero when idle'}`);
 }
 // ---- limits (the resource ceiling; paid plans) ----
 // Parse a human memory value into MB: "512", "512mb", "1gb", "2g", "1.5gb".

package/dist/commands/services.js

@@ -85,7 +85,10 @@ export function servicesAddRequestBody(type, name, branch, opts) {
         type, name, ...(branch ? { branch } : {}), public: !!opts.public,
         ...(opts.image ? { image: opts.image } : {}), ...(opts.port ? { port: parsePort(opts.port) } : {}),
         ...(opts.region ? { region: opts.region } : {}),
-        ...(opts.alwaysOn ? { alwaysOn: true } : {}),
+        // Sent whenever the flag was given, false included: compute is born always-on by default
+        // (insta-platform #385, 2026-09-07), so `--no-always-on` must reach the API as an explicit
+        // false. Omitted means the platform default.
+        ...(opts.alwaysOn !== undefined ? { alwaysOn: opts.alwaysOn } : {}),
         ...(opts.volume !== undefined ? { volumeGib: parseVolumeGib(opts.volume) } : {}),
     };
 }
@@ -102,8 +105,9 @@ export async function servicesAdd(type, name, opts = {}) {
             throw new Error('--port is only valid for compute services');
         parsePort(opts.port); // junk fails here, before any config/network access
     }
-    if (opts.alwaysOn && type !== 'compute')
-        throw new Error('--always-on is only valid for compute services (for postgres, use `insta db always-on on` after creation)');
+    // Presence, not truthiness: `--no-always-on` is an explicit false and is just as compute-only.
+    if (opts.alwaysOn !== undefined && type !== 'compute')
+        throw new Error('--always-on / --no-always-on is only valid for compute services (for postgres, use `insta db always-on on|off` after creation)');
     if (opts.volume !== undefined) {
         if (type !== 'compute')
             throw new Error('--volume is only valid for compute services (postgres has one by default — grow it with `insta db volume --size`)');

package/dist/github-source.js

@@ -2,13 +2,17 @@
 // credentials. Parsing, ref resolution and the shallow clone live here; the deploy path stays in
 // commands/template.ts. See docs/superpowers/specs/2026-09-04-template-deploy-github-url-design.md.
 import { spawn as nodeSpawn } from 'node:child_process';
-import { mkdtempSync, rmSync, existsSync, realpathSync, statSync } from 'node:fs';
+import { mkdtempSync, rmSync, existsSync, realpathSync, statSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, sep } from 'node:path';
-import { loadTemplateManifest, MANIFEST_FILE } from './template-manifest.js';
+import { parseManifestYaml, MANIFEST_FILE } from './template-manifest.js';
 const GITHUB_HOST = /^(?:https?:\/\/)?(?:www\.)?github\.com\//i;
 // An explicit address: a scheme, or an scp-style user@host:path. Never a local path.
-const EXPLICIT_ADDRESS = /^[a-z][a-z0-9+.-]*:\/\/|^[^/\\]+@[^/\\]+:/i;
+// A scheme (with or without its slashes) or an scp-style user@host:path. The slashes are optional
+// because `https:/github.com/o/r`, a URL that lost one, must be named as a bad address rather than
+// resolved as a directory called `https:`. Two or more scheme characters are required so a Windows
+// drive letter (`C:\src`, `C:/src`) stays a path.
+const EXPLICIT_ADDRESS = /^[a-z][a-z0-9+.-]+:|^[^/\\]+@[^/\\]+:/i;
 // Scheme-less first segments we still read as a host. A bare `<name>/<path>` is otherwise a LOCAL
 // PATH: `v1.0/templates` and `my.app/bot` are directories, and reading every dotted first segment
 // as a host broke them. Only names that unambiguously host code belong here.
@@ -251,6 +255,11 @@ export async function resolveGitHubRef(t, run) {
         throw new Error(`no branch or tag ${t.refAndPath} in ${t.owner}/${t.repo}`);
     return split;
 }
+/** What to call the manifest in a message: where the user pointed, never the temporary clone that
+ *  is deleted before they read it. */
+export function manifestLabel(t, r) {
+    return `${t.owner}/${t.repo}@${r.ref}:${r.path ? `${r.path}/` : ''}${MANIFEST_FILE}`;
+}
 export function missingManifestMessage(t, r) {
     return [
         `no ${MANIFEST_FILE} at ${t.owner}/${t.repo}@${r.ref}:${r.path || '/'}.`,
@@ -271,7 +280,7 @@ function containedRealPath(root, candidate) {
 /** Resolve the ref, shallow-clone it, read the commit that was checked out, prove the manifest
  *  sits inside the clone, parse it, delete the clone. Nothing on disk outlives this call: not the
  *  variable prompt, not the POST, not the watcher. */
-export async function fetchGitHubTemplate(target, run = defaultGitRunner, load = loadTemplateManifest) {
+export async function fetchGitHubTemplate(target, run = defaultGitRunner, parse = parseManifestYaml) {
     const resolved = await resolveGitHubRef(target, run);
     const dir = mkdtempSync(join(tmpdir(), 'insta-tpl-gh-'));
     try {
@@ -303,7 +312,9 @@ export async function fetchGitHubTemplate(target, run = defaultGitRunner, load =
         const real = containedRealPath(dir, join(manifestDir, MANIFEST_FILE));
         if (!real || !statSync(real).isFile())
             throw new Error(escapedManifestMessage(target, resolved));
-        const manifest = load(manifestDir);
+        // Read and parse separately so a validation failure names where the user pointed. Handing the
+        // loader a directory makes it report the temp path, which is gone by the time they see it.
+        const manifest = parse(readFileSync(real, 'utf8'), manifestLabel(target, resolved));
         return {
             source: { repo: `${target.owner}/${target.repo}`, ref: resolved.ref, path: resolved.path, commit },
             manifest,

package/dist/index.js

@@ -131,7 +131,8 @@ svc.command('add [type] [name]').description('Provision a service on demand (ass
     .option('--public', 'storage only: serve the bucket with anonymous public-read (default private)')
     .option('--image <url>', 'compute only: run this container image at creation')
     .option('--port <n>', 'compute only: port the image listens on (default 8080)')
-    .option('--always-on', 'compute only: create as always-on — never scales to zero (all plans; billing is actual usage either way)')
+    .option('--always-on', 'compute only: create as always-on — never scales to zero (the default for new compute services; all plans; billing is actual usage either way)')
+    .option('--no-always-on', 'compute only: create as scale-to-zero — idle machines suspend and wake on the next request')
     .option('--volume <gi>', 'compute only: attach a persistent /data volume of this many whole Gi (also attachable later: `insta compute volume <name> --size <gi>`; any plan may attach at the default 10 (the free cap, on every plan); larger sizes are paid and plan-capped). Volume services keep 1 machine and stop (cold wake) instead of suspend when idle')
     .option('--json')
     .action(guard(async (type, name, o) => {
@@ -223,7 +224,7 @@ compute.command('status [service]').description("Show a compute service's desire
 compute.command('limits [service]').description("Show or set a compute service's resource ceiling (any plan within the free cap; raising above it needs a paid plan). --memory is the dial; cpu derives from it unless --cpu is given. Billing is actual usage — the ceiling caps what the app may burn, it is not a price")
     .option('--memory <size>', 'memory ceiling, e.g. 512mb or 1gb').option('--cpu <n>', 'vCPU ceiling override (provider sizes: 1, 2, 4, 6, 8)')
     .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((service, o) => computeCmd.computeLimits(service, o)));
-compute.command('always-on <mode> [service]').description('Set a compute service always-on (mode: on|off). on = machines never scale to zero; off = default scale-to-zero. All plans; billing is actual usage either way')
+compute.command('always-on <mode> [service]').description('Set a compute service always-on (mode: on|off). on = machines never scale to zero (the default for new compute services); off = scale-to-zero. All plans; billing is actual usage either way')
     .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((mode, service, o) => computeCmd.computeAlwaysOn(mode, service, o)));
 const execCmd = compute.command('exec [service]').description("Run a one-shot command inside a compute service's machine (`insta compute exec [service] -- <command> [args…]`) — no interactive shell/PTY: `command` is argv, no shell is invoked (use [\"sh\", \"-c\", \"...\"] for shell features). Wakes the machine first if it's scaled to zero — expect a few seconds of latency, billed as uptime, not an error. Exits with the remote command's own exit code (agents rely on this)")
     .action(guard((service, o) => computeCmd.computeExec(service, execCommand, o, { windowsFallback: execWindowsFallback })));

package/dist/template-manifest.js

@@ -78,8 +78,30 @@ export function validateManifest(m) {
     for (const name of names) {
         const svc = services[name] ?? {};
         const where = `services.${name}`;
-        if (svc.type !== 'web' && svc.type !== 'worker')
-            problems.push(`${where}.type must be web or worker`);
+        if (svc.type !== 'web' && svc.type !== 'worker' && svc.type !== 'postgres') {
+            problems.push(`${where}.type must be web, worker or postgres`);
+        }
+        // A managed postgres service 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 (svc.type === 'postgres') {
+            const bare = svc;
+            for (const field of ['image', 'build', 'port', 'healthcheck', 'volume', 'volumeGib', 'spec', 'alwaysOn']) {
+                if (bare[field] !== undefined) {
+                    problems.push(`${where}.${field}: a postgres service is platform-managed and carries no ${field} — declare it bare ({ type: postgres })`);
+                }
+            }
+            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 postgres service is platform-managed and carries no env — declare it bare ({ type: postgres })`);
+                }
+            }
+            continue;
+        }
         if (svc.image && svc.build)
             problems.push(`${where}: image and build are mutually exclusive`);
         if (!svc.image && !svc.build)

package/package.json

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