insta 0.0.63 → 0.0.64

package/dist/commands/build.js

@@ -169,7 +169,7 @@ export async function buildReport(dirArg, opts, deps) {
             // NOT "save the generated Dockerfile here": it is not standalone (it COPYs the
             // .nixpacks/nixpkgs-<hash>.nix support files nixpacks writes beside it, which this
             // directory does not have). The detected commands above are the reusable part.
-            nextAction: `to deploy this directory, write a Dockerfile at ${userDockerfilePath} — the detected install/start commands above are the starting point; or connect the repo on GitHub to use the nixpacks lane`,
+            nextAction: `to deploy this directory, write a Dockerfile at ${userDockerfilePath} — the detected install/start commands above are the starting point; or connect the GitHub repo to the service (\`insta compute connect-repo <owner/repo>\`) to use the nixpacks lane`,
         }
         : {
             id: 'dockerfile',
@@ -226,7 +226,7 @@ export function renderReport(r, explain) {
     lines.push(`plan for ${r.dir}:`);
     // The builder line is the first thing read (and the thing an agent scrapes), so it carries the
     // lane caveat too — "builder: nixpacks" on its own reads as a promise `insta deploy <dir>` breaks.
-    const lane = r.plan.builder === 'nixpacks' ? ' — GitHub lane only; `insta deploy <dir>` needs a Dockerfile' : '';
+    const lane = r.plan.builder === 'nixpacks' ? ' — GitHub lane only (`insta compute connect-repo`); `insta deploy <dir>` needs a Dockerfile' : '';
     lines.push(`  builder: ${r.plan.builder ?? 'none'}${r.plan.providers.length ? ` (providers: ${r.plan.providers.join(', ')})` : ''}${lane}`);
     if (r.plan.installCommand)
         lines.push(`  install: ${r.plan.installCommand}`);

package/dist/commands/deploy.js

@@ -15,6 +15,7 @@ export function deployRequestBody(image, branch, opts) {
         group: opts.group,
         port: opts.port ? Number(opts.port) : undefined,
         websocket: opts.websocket ? true : undefined,
+        replaceSource: opts.replaceSource ? true : undefined,
     };
 }
 // A port mismatch is the #1 deploy mistake: the app boots "successfully" but the proxy routes to
@@ -45,7 +46,7 @@ export function noDockerfileMessage(absDir) {
         'Options:',
         `  - add a Dockerfile to ${absDir} (\`insta build ${absDir}\` prints the install/start commands nixpacks detected, as a starting point)`,
         '  - deploy a prebuilt image instead: `insta deploy --image <url>`',
-        "  - connect the app's GitHub repo in the console — that lane builds Dockerfile-less repos with nixpacks server-side",
+        '  - connect the GitHub repo to the service (`insta compute connect-repo <owner/repo>`) — that lane builds Dockerfile-less repos with nixpacks server-side',
     ].join('\n');
 }
 // Deploy either a prebuilt image (`--image`) or a source directory (positional `<dir>`, built

package/dist/commands/github.js

@@ -0,0 +1,122 @@
+import { ApiClient, requireProject } from '../api.js';
+import { info, printJson } from '../util.js';
+import { resolveSoleService, parsePort, q } from './services.js';
+export function parseRepoRef(raw) {
+    const s = raw.trim().replace(/^https?:\/\//i, '').replace(/^(www\.)?github\.com\//i, '').replace(/\/+$/, '').replace(/\.git$/i, '');
+    const m = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(s);
+    if (!m)
+        throw new Error(`not a GitHub repository reference: ${raw} (use owner/repo or https://github.com/owner/repo)`);
+    return { owner: m[1], repo: m[2] };
+}
+// "", ".", "/", "./" all mean the repo root, which the platform spells null.
+function normalizeRootDir(raw) {
+    if (raw === undefined)
+        return null;
+    const s = raw.trim().replace(/^\.\//, '').replace(/^\/+/, '').replace(/\/+$/, '');
+    return s === '' || s === '.' ? null : s;
+}
+export function pickCandidate(candidates, rootDir) {
+    if (candidates.length === 0)
+        throw new Error('no deployable service detected in this repository (no Dockerfile and nothing nixpacks recognises)');
+    if (rootDir !== undefined) {
+        const want = normalizeRootDir(rootDir);
+        const hit = candidates.find((c) => c.rootDir === want);
+        if (!hit)
+            throw new Error(`no deployable directory at ${want ?? '(repo root)'} — detected: ${candidates.map((c) => c.rootDir ?? '(repo root)').join(', ')}`);
+        return hit;
+    }
+    if (candidates.length === 1)
+        return candidates[0];
+    throw new Error([
+        `this repository has ${candidates.length} deployable directories; pass --root-dir to choose which one deploys into the service:`,
+        ...candidates.map((c) => `  ${(c.rootDir ?? '(repo root)').padEnd(24)} ${c.builder}${c.startCommand ? `  start: ${c.startCommand}` : ''}`),
+    ].join('\n'));
+}
+// Build/start come from detection only: the platform's nixpacks lane fails a build whose commands differ from it.
+// autoDeploy rides along only when switched off: a public repo 400s on autoDeploy: true.
+export function sourceBody(src, c, o) {
+    const repo = src.source === 'app'
+        ? { installationId: src.installationId, repoId: src.repoId, owner: src.owner, repo: src.repo }
+        : { public: true, owner: src.owner, repo: src.repo };
+    return {
+        ...repo,
+        rootDir: c.rootDir,
+        buildCommand: c.buildCommand,
+        startCommand: c.startCommand,
+        port: o.port !== undefined ? parsePort(o.port) : c.port,
+        ...(o.repoBranch ? { branch: o.repoBranch } : {}),
+        ...(o.autoDeploy === false ? { autoDeploy: false } : {}),
+    };
+}
+export function repoLine(serviceName, s) {
+    if (s.type !== 'github')
+        return `compute ${serviceName}: no repository connected${s.image ? ` (runs image ${s.image})` : ''} — connect one with \`insta compute connect-repo <owner/repo> ${serviceName}\``;
+    const how = s.public
+        ? 'public repo, deploys are manual (pushes do not redeploy)'
+        : s.auto_deploy ? `every push to ${s.branch} redeploys it` : 'auto-deploy off (pushes do not redeploy)';
+    const where = s.root_dir ? ` (${s.root_dir}/)` : '';
+    return `compute ${serviceName}: deploys from ${s.owner}/${s.repo}@${s.branch}${where} — ${how}`;
+}
+export async function findInstalledRepo(api, orgId, ref) {
+    if (!orgId)
+        throw new Error('this directory is linked without an org — set INSTA_ORG_ID alongside INSTA_PROJECT_ID, or link it with `insta project link`');
+    const { installations = [] } = await api.request('GET', `/github/installations?orgId=${encodeURIComponent(orgId)}`);
+    if (installations.length === 0) {
+        throw new Error('no GitHub App installation for this org — connect GitHub in the console first (Add Service → GitHub Repo → Connect GitHub), or pass --public for a public repository');
+    }
+    for (const inst of installations) {
+        const { repos = [] } = await api.request('GET', `/github/installations/${encodeURIComponent(inst.installation_id)}/repos?orgId=${encodeURIComponent(orgId)}`);
+        const hit = repos.find((r) => r.owner.toLowerCase() === ref.owner.toLowerCase() && r.repo.toLowerCase() === ref.repo.toLowerCase());
+        if (hit)
+            return { installationId: Number(inst.installation_id), repoId: hit.id };
+    }
+    const accounts = installations.map((i) => i.account_login ?? i.installation_id).join(', ');
+    throw new Error(`${ref.owner}/${ref.repo} is not visible to the org's GitHub App installation (installed on: ${accounts}) — grant the App access to it in the console (Configure GitHub app), or pass --public for a public repository`);
+}
+async function targetService(api, projectId, branch, serviceName) {
+    const { services } = await api.request('GET', `/projects/${projectId}/services${q(branch)}`);
+    return resolveSoleService(services, 'compute', serviceName);
+}
+export async function computeRepo(serviceName, opts) {
+    const api = await ApiClient.load();
+    const p = await requireProject();
+    const branch = opts.branch ?? p.branch;
+    const svc = await targetService(api, p.projectId, branch, serviceName);
+    // insta-oss keys compute ids per group, not per branch, so the read carries the branch (the cloud ignores it).
+    const { source } = await api.request('GET', `/projects/${p.projectId}/services/${svc.id}/source${q(branch)}`);
+    if (opts.json)
+        return printJson({ service: { id: svc.id, name: svc.name }, source });
+    info(repoLine(svc.name, source));
+}
+export async function computeConnectRepo(rawRef, serviceName, opts) {
+    const ref = parseRepoRef(rawRef);
+    const api = await ApiClient.load();
+    const p = await requireProject();
+    const svc = await targetService(api, p.projectId, opts.branch ?? p.branch, serviceName);
+    const src = opts.public
+        ? { source: 'public', ...ref }
+        : { source: 'app', ...(await findInstalledRepo(api, p.orgId, ref)), ...ref };
+    // Detection must scan the branch that will be built: the build refuses commands that differ from what it detects there.
+    const detected = await api.request('POST', `/projects/${p.projectId}/github/detect`, { ...src, ...(opts.repoBranch ? { ref: opts.repoBranch } : {}) });
+    const candidate = pickCandidate(detected.services, opts.rootDir);
+    const res = await api.request('PUT', `/projects/${p.projectId}/services/${svc.id}/source`, sourceBody(src, candidate, opts));
+    if (opts.json)
+        return printJson({ ...res, service: { id: svc.id, name: svc.name } });
+    const branch = res.source.branch;
+    const where = candidate.rootDir ? `${candidate.rootDir}/, ${candidate.builder}` : candidate.builder;
+    const now = res.build.queued ? `building ${branch} now` : `${branch} is already live at this commit`;
+    const how = src.source === 'public' ? 'deploys are manual from here: pushes will not redeploy (public repo)'
+        : opts.autoDeploy === false ? 'auto-deploy is off: redeploy with `insta compute connect-repo` again or from the console'
+            : `every push to ${branch} redeploys it`;
+    info(`connected ${ref.owner}/${ref.repo} → compute ${svc.name} (${where}): ${now} — ${how}`);
+}
+export async function computeDisconnectRepo(serviceName, opts) {
+    const api = await ApiClient.load();
+    const p = await requireProject();
+    const svc = await targetService(api, p.projectId, opts.branch ?? p.branch, serviceName);
+    const res = await api.request('DELETE', `/projects/${p.projectId}/services/${svc.id}/source`);
+    if (opts.json)
+        return printJson({ ...res, service: { id: svc.id, name: svc.name } });
+    info(`disconnected the repository from compute ${svc.name} — it keeps running its current image; pushes no longer deploy it`);
+}
+//# sourceMappingURL=github.js.map

package/dist/commands/regions.js

@@ -1,8 +1,8 @@
 import { ApiClient } from '../api.js';
 import { info, printJson } from '../util.js';
 // insta regions — list the regions a postgres/compute service can be created in.
-export async function regionsList(opts = {}) {
-    const api = await ApiClient.load();
+export async function regionsList(opts = {}, deps) {
+    const api = deps?.api ?? await ApiClient.load();
     const { regions } = await api.request('GET', '/regions');
     if (opts.json)
         return printJson(regions);

package/dist/index.js

@@ -22,6 +22,7 @@ import * as secretsCmd from './commands/secrets.js';
 import { deploy } from './commands/deploy.js';
 import { build } from './commands/build.js';
 import * as computeCmd from './commands/compute.js';
+import * as githubCmd from './commands/github.js';
 import * as dbCmd from './commands/db.js';
 import * as dbQueryCmd from './commands/db-query.js';
 import * as storageCmd from './commands/storage.js';
@@ -209,6 +210,7 @@ program.command('build [dir]').description('Verify a source directory would buil
 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)')
+    .option('--replace-source', 'the service deploys from a connected GitHub repo: switch it to this image and remove the repo connection (admin); without it such a deploy is refused')
     .option('--json', 'print the deploy result as JSON (build progress goes to stderr)')
     .action(guard((dir, o) => deploy(dir, o)));
 // `insta compute exec` needs the command verbatim after a literal `--`; split it out of argv here,
@@ -244,6 +246,18 @@ const execCmd = compute.command('exec [service]').description("Run a one-shot co
 // new option cannot reach the CLI surface while the split still reads it as part of the command.
 for (const [flags, description] of computeCmd.EXEC_OPTIONS)
     execCmd.option(flags, description);
+compute.command('repo [service]').description('Show what a compute service deploys from: the image it runs, or the GitHub repository — owner/repo, the branch it builds, root directory, and whether pushes redeploy it')
+    .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((service, o) => githubCmd.computeRepo(service, o)));
+compute.command('connect-repo <owner/repo> [service]').description("Connect a GitHub repository to an EXISTING compute service: the repo is built (its Dockerfile, or nixpacks when there is none) and deployed into that service, and every later push to the tracked repository branch redeploys it. The repo must be reachable through the org's GitHub App installation — connect GitHub in the console first (Add Service → GitHub Repo) — or be public. Build and start commands come from detection and cannot be set. Connecting again replaces the service's current source")
+    .option('--public', 'the repo is public and no GitHub App installation is needed (deploys are manual; pushes cannot redeploy)')
+    .option('--root-dir <dir>', 'the directory of the repo to build (a monorepo with several deployable directories lists them and exits 1 without it)')
+    .option('--repo-branch <name>', "the repository branch to build (default: the repo's default branch)")
+    .option('--no-auto-deploy', 'do not rebuild on pushes; redeploy by connecting again or from the console')
+    .option('--port <n>', 'port the app listens on (default: detected)')
+    .option('--branch <branch>', 'branch (default: current) — the environment the service is on')
+    .option('--json').action(guard((ref, service, o) => githubCmd.computeConnectRepo(ref, service, o)));
+compute.command('disconnect-repo [service]').description('Disconnect the GitHub repository from a compute service. The service keeps running its current image; pushes no longer deploy it, and its build history stays')
+    .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((service, o) => githubCmd.computeDisconnectRepo(service, o)));
 compute.command('volume [service]').description("Show, attach, grow, or delete a compute service's persistent /data volume. No flag: print size, mount path, and the plan cap (any plan). --size on a volumeless service ATTACHES one (any plan at the default 10Gi, the free cap; larger is paid and plan-capped; the disk mounts at /data on the next deploy); on a volume-bearing one it grows (paid plans; grow-only — a provisioned disk cannot shrink). --delete DESTROYS the disk and ALL its data immediately (no detach, no undo; billing stops now, and suspend fast-wake + scale-out return). Billing is actual data stored — the size is a cap, not a price")
     .option('--size <gi>', 'new size in whole Gi, e.g. 10 (must be ≥ the current size)')
     .option('--delete', 'destroy the volume and ALL its data (irreversible; download anything you need first)')

package/dist/resolve-service.js

@@ -7,8 +7,7 @@
 import * as clack from '@clack/prompts';
 import { SERVICE_TYPES, assertServiceName, parsePort } from './commands/services.js';
 import { CliCancel } from './util.js';
-// Same order, labels and default names as the dashboard's Add Service menu. Github Repo is left
-// out: the platform has no repo path yet, so a CLI entry could only say "coming soon".
+// The CLI connects repos to existing services only; "GitHub Repo" is not a service kind here.
 export const SERVICE_KINDS = [
     { id: 'image', label: 'Docker Image', type: 'compute', hint: 'run an existing container image', needsImage: true },
     { id: 'postgres', label: 'Postgres', type: 'postgres', hint: 'relational DB, usable as soon as it is added', defaultName: 'main-db' },

package/package.json

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