insta 0.1.17 → 0.1.19

package/dist/commands/compute.js

@@ -1883,7 +1883,8 @@ export async function computeSSH(serviceName, opts, deps = {}) {
     const mint = deps.mint ?? mintCert;
     const emit = deps.emit ?? info;
     const api = await (deps.loadApi ?? ApiClient.load)();
-    const p = await (deps.loadProject ?? requireProject)();
+    // 'main' is what a link records by default; anything else makes assertAliasFree refuse a setup of the same service from a linked directory.
+    const p = opts.project !== undefined ? { projectId: opts.project, branch: 'main' } : await (deps.loadProject ?? requireProject)();
     const branch = opts.branch ?? p.branch;
     const { services } = await api.request('GET', `/projects/${p.projectId}/services${q(branch)}`);
     const svc = resolveSoleService(services, 'compute', serviceName);

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

@@ -388,6 +388,7 @@ compute.command('ssh [service]')
     .description("Issue a short-lived SSH certificate for a compute service and print the command that uses it -- this command does NOT open the session itself, it makes `ssh` work. `--setup` does the one-time work: it generates a dedicated key under ~/.insta/ssh (your existing keys are never touched), has the platform sign a SHORT-LIVED certificate for it, adds one @cert-authority line to ~/.ssh/known_hosts so every region is trusted without per-node fingerprint prompts, and writes an ssh_config block AT THE TOP of ~/.ssh/config giving each compute service the alias `<service>.insta`. After that it is plain `ssh api.insta`, scp and -L: the block renews that alias's certificate for you while OpenSSH parses the config. Needs an interactive login -- API keys are refused; use `insta compute exec` for one-shot commands from CI")
     .option('--setup', 'do the one-time client setup as well as issuing a certificate')
     .option('--ensure-cert <alias>', 'renew the certificate for an alias such as api.insta if it is close to expiry, then exit (used by the ssh_config hook; silent by design)')
+    .option('--project <id>', 'project to use instead of the linked one; the directory is not linked (branch defaults to main)')
     .option('-b, --branch <branch>', 'branch (default: linked)')
     .option('--json', 'machine-readable output')
     .action(guard((service, o) => computeCmd.computeSSH(service, o)));
@@ -540,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.17",
+  "version": "0.1.19",
   "type": "module",
   "description": "InstaCloud CLI — a thin client of the platform control-plane API.",
   "keywords": [