@apso/cli 0.19.0 → 0.21.0

package/dist/commands/deploy.d.ts

@@ -6,6 +6,18 @@ export default class Deploy extends BaseCommand {
         "no-wait": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         "skip-migrate": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        "skip-push": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        repo: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        branch: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
     };
     run(): Promise<void>;
+    /**
+     * Push the local scaffold to the service's GitHub repo with the user's own
+     * git, and make sure the repo is connected to the service so the provisioner
+     * can clone it at deploy time. No code passes through Apso — we read the local
+     * git and push straight to GitHub.
+     */
+    private syncCodeToGithub;
+    /** Let the user pick one of their GitHub repos to deploy from. */
+    private promptRepoSelection;
 }

package/dist/commands/deploy.js

@@ -5,6 +5,8 @@ const core_1 = require("@oclif/core");
 const base_command_1 = tslib_1.__importDefault(require("../lib/base-command"));
 const config_1 = require("../lib/config");
 const services_1 = require("../lib/api/services");
+const upgrade_1 = require("../lib/upgrade");
+const git = tslib_1.__importStar(require("../lib/git"));
 const apsorc_parser_1 = require("../lib/apsorc-parser");
 const sandbox_1 = require("../lib/migrate/sandbox");
 const spinner_1 = require("../lib/utils/spinner");
@@ -62,9 +64,14 @@ class Deploy extends base_command_1.default {
                 this.log("No schema changes detected.");
             }
         }
+        // Sync local code to the connected GitHub repo (the deploy builds from it).
+        // Skip for redeploys of already-synced code.
+        if (!flags["skip-push"]) {
+            await this.syncCodeToGithub(service, flags.repo, flags.branch);
+        }
         // Determine source
-        if (service.githubRepo) {
-            this.log(`Deploying "${service.name}" from ${service.githubRepo}#${service.githubBranch || "main"}...`);
+        if (service.githubRepo || flags.repo) {
+            this.log(`Deploying "${service.name}" from ${service.githubRepo || flags.repo}#${flags.branch}...`);
         }
         else {
             this.log(`Deploying "${service.name}" via Apso Platform...`);
@@ -86,7 +93,7 @@ class Deploy extends base_command_1.default {
             }
         }
         // Trigger build
-        const build = await services_1.buildApi.trigger(link.workspaceSlug, link.serviceSlug);
+        const build = await (0, upgrade_1.withUpgradeRetry)(() => services_1.buildApi.trigger(link.workspaceSlug, link.serviceSlug));
         this.log(`Build started: ${build.id}`);
         if (flags["no-wait"]) {
             this.log("Deploy triggered. Run 'apso status' to check progress.");
@@ -115,6 +122,65 @@ class Deploy extends base_command_1.default {
             this.exit(1);
         }
     }
+    /**
+     * Push the local scaffold to the service's GitHub repo with the user's own
+     * git, and make sure the repo is connected to the service so the provisioner
+     * can clone it at deploy time. No code passes through Apso — we read the local
+     * git and push straight to GitHub.
+     */
+    async syncCodeToGithub(service, repoFlag, branch) {
+        const cwd = process.cwd();
+        if (!git.gitAvailable()) {
+            this.error("git is required to deploy. Install git and try again.");
+        }
+        git.initRepo(cwd);
+        // Pick the repo: prefer what the local project is already wired to, then the
+        // service's connected repo, then --repo, then ask.
+        const conn = await services_1.githubApi.getConnection();
+        if (!conn.connected || !conn.connectionId) {
+            this.error("GitHub is not connected. Run 'apso github connect' first, then re-run deploy.");
+        }
+        let repoFullName = git.localRepoFullName(cwd) || service.githubRepo || repoFlag;
+        if (!repoFullName) {
+            repoFullName = await this.promptRepoSelection(conn.connectionId);
+        }
+        // Connect the repo to the service (records ServiceRepository) unless the
+        // service is already linked to this exact repo.
+        if (service.githubRepo !== repoFullName) {
+            this.log(`Connecting repository ${repoFullName}...`);
+            await services_1.githubApi.connectRepo(service.id, conn.connectionId, repoFullName);
+        }
+        // Point the local repo at it and push with the user's git credentials.
+        git.setOrigin(cwd, git.httpsUrlFor(repoFullName));
+        const committed = git.commitAll(cwd, "Deploy via Apso CLI");
+        this.log(committed
+            ? `Committed local changes; pushing to ${repoFullName}#${branch}...`
+            : `Pushing to ${repoFullName}#${branch}...`);
+        try {
+            git.pushHead(cwd, branch);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.error(`git push to ${repoFullName} failed. Ensure you have push access and your git credentials are set up.\n${msg}`);
+        }
+    }
+    /** Let the user pick one of their GitHub repos to deploy from. */
+    async promptRepoSelection(connectionId) {
+        const repos = await services_1.githubApi.listRepos("", { connectionId, pageSize: 100 });
+        if (!repos.data.length) {
+            this.error("No GitHub repositories available. Create one on GitHub (or pass --repo owner/name).");
+        }
+        const inquirer = await Promise.resolve().then(() => tslib_1.__importStar(require("inquirer")));
+        const { repo } = await inquirer.default.prompt([
+            {
+                type: "list",
+                name: "repo",
+                message: "Select a GitHub repository to deploy from:",
+                choices: repos.data.map((r) => ({ name: r.fullName, value: r.fullName })),
+            },
+        ]);
+        return repo;
+    }
 }
 Deploy.description = "Deploy the linked service";
 Deploy.examples = [
@@ -137,5 +203,16 @@ Deploy.flags = {
         description: "Skip local migration validation",
         default: false,
     }),
+    "skip-push": core_1.Flags.boolean({
+        description: "Skip uploading + pushing code (redeploy current code)",
+        default: false,
+    }),
+    repo: core_1.Flags.string({
+        description: "GitHub repo (owner/name) to connect when none is linked yet",
+    }),
+    branch: core_1.Flags.string({
+        description: "Branch to push to",
+        default: "main",
+    }),
 };
 exports.default = Deploy;

package/dist/commands/generate.js

@@ -184,17 +184,36 @@ class Generate extends base_command_1.default {
             await (0, file_system_1.createFile)(fullPath, file.content);
         }
         generatedFileCount += indexFiles.length;
-        // Format generated files (TypeScript only).
-        // Run prettier directly against the generated output directory so we never
-        // reformat hand-written code elsewhere in the project tree (the project's
-        // `npm run format` script targets a broad glob like `{src,test}/**/*.ts`).
+        // Format generated files (TypeScript only) with Biome — bundled with the
+        // CLI and invoked directly, so it's a fast native pass (~ms) with no npx
+        // download and no dependence on the project having a formatter installed.
+        // Scoped to the autogen directory so we never touch hand-written code
+        // elsewhere in the project tree.
         if (language === "typescript" && !skipFormat && generatedFileCount > 0) {
             const formatStart = perf_hooks_1.performance.now();
             console.log("[apso] Formatting generated files...");
-            const formatGlob = path.join(autogenPath, "**", "*.ts");
-            await this.runCommand("npx", ["prettier", "--write", formatGlob], true);
-            const formatTime = perf_hooks_1.performance.now() - formatStart;
-            console.log(`[apso] Finished formatting in ${formatTime.toFixed(2)} ms`);
+            try {
+                const biomeBin = require.resolve("@biomejs/biome/bin/biome");
+                // Use the CLI's bundled Biome config: 2-space style (Biome defaults to
+                // tabs) and, critically, unsafeParameterDecoratorsEnabled so Biome can
+                // parse NestJS parameter decorators (@Body(), @ParsedRequest(), ...);
+                // without it Biome aborts with parse errors on the generated controllers.
+                const biomeConfigDir = path.join(__dirname, "..", "lib", "biome");
+                await this.runCommand("node", [
+                    biomeBin,
+                    "format",
+                    "--write",
+                    `--config-path=${biomeConfigDir}`,
+                    autogenPath,
+                ], true);
+                const formatTime = perf_hooks_1.performance.now() - formatStart;
+                console.log(`[apso] Finished formatting in ${formatTime.toFixed(2)} ms`);
+            }
+            catch (error) {
+                // Formatting is best-effort — never fail generation over it.
+                const msg = error instanceof Error ? error.message : String(error);
+                console.warn(`[apso] Skipped formatting (${msg})`);
+            }
         }
         else if (skipFormat) {
             console.log("[apso] Skipping formatting (--skip-format flag set)");

package/dist/commands/github/connect.d.ts

@@ -0,0 +1,19 @@
+import BaseCommand from "../../lib/base-command";
+/**
+ * `apso github connect` — walk the user through connecting their GitHub
+ * account so the CLI can push generated code to a real repository.
+ *
+ * The GitHub OAuth handshake is a browser+cookie flow on the app, so we open
+ * the app's authorize URL (where the user is signed in) and poll the platform
+ * until the connection appears — the same pattern as `apso login`.
+ */
+export default class GithubConnect extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        "workspace-id": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/github/connect.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const child_process_1 = require("child_process");
+const base_command_1 = tslib_1.__importDefault(require("../../lib/base-command"));
+const config_1 = require("../../lib/config");
+const services_1 = require("../../lib/api/services");
+/**
+ * Open a URL in the default browser (best-effort).
+ */
+function openBrowser(url) {
+    return new Promise((resolve) => {
+        const platform = process.platform;
+        const command = platform === "darwin"
+            ? `open "${url}"`
+            : platform === "win32"
+                ? `start "" "${url}"`
+                : `xdg-open "${url}"`;
+        (0, child_process_1.exec)(command, () => resolve());
+    });
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * `apso github connect` — walk the user through connecting their GitHub
+ * account so the CLI can push generated code to a real repository.
+ *
+ * The GitHub OAuth handshake is a browser+cookie flow on the app, so we open
+ * the app's authorize URL (where the user is signed in) and poll the platform
+ * until the connection appears — the same pattern as `apso login`.
+ */
+class GithubConnect extends base_command_1.default {
+    async run() {
+        var _a;
+        const { flags } = await this.parse(GithubConnect);
+        if (!config_1.credentials.isValid()) {
+            this.error("Not authenticated. Run 'apso login' first.");
+        }
+        const workspaceId = flags["workspace-id"] ||
+            process.env.APSO_WORKSPACE_ID ||
+            ((_a = config_1.projectLink.read()) === null || _a === void 0 ? void 0 : _a.workspaceId);
+        if (!workspaceId) {
+            this.error("No workspace. Run 'apso link' first, or pass --workspace-id.");
+        }
+        // Already connected?
+        const existing = await services_1.githubApi.getConnection();
+        if (existing.connected) {
+            this.log(`GitHub is already connected${existing.login ? ` as ${existing.login}` : ""}.`);
+            return;
+        }
+        const config = config_1.globalConfig.read();
+        const authorizeUrl = `${config.webUrl}/api/github/authorize?workspaceId=${workspaceId}`;
+        this.log("Opening GitHub authorization in your browser...");
+        this.log("");
+        this.log("If the browser doesn't open, visit this URL:");
+        this.log(`  ${authorizeUrl}`);
+        this.log("");
+        this.log("You must be signed in to the Apso app in your browser to authorize.");
+        this.log("");
+        await openBrowser(authorizeUrl);
+        this.log("Waiting for the GitHub connection to complete...");
+        const deadline = Date.now() + flags.timeout * 1000;
+        /* eslint-disable no-await-in-loop */
+        while (Date.now() < deadline) {
+            await sleep(3000);
+            try {
+                const conn = await services_1.githubApi.getConnection();
+                if (conn.connected) {
+                    this.log("");
+                    this.log(`Connected to GitHub${conn.login ? ` as ${conn.login}` : ""}.`);
+                    this.log("Next: run 'apso deploy' to push your code and deploy.");
+                    return;
+                }
+            }
+            catch {
+                // transient; keep polling
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+        this.error("Timed out waiting for the GitHub connection. Re-run 'apso github connect' to try again.");
+    }
+}
+GithubConnect.description = "Connect a GitHub account to push generated code to a repo";
+GithubConnect.examples = ["$ apso github connect"];
+GithubConnect.flags = {
+    help: core_1.Flags.help({ char: "h" }),
+    "workspace-id": core_1.Flags.string({
+        description: "Workspace id to connect (defaults to the linked project)",
+    }),
+    timeout: core_1.Flags.integer({
+        description: "Seconds to wait for the connection",
+        default: 300,
+    }),
+};
+exports.default = GithubConnect;

package/dist/commands/init.js

@@ -9,6 +9,7 @@ const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
 const base_command_1 = tslib_1.__importDefault(require("../lib/base-command"));
 const config_1 = require("../lib/config");
 const services_1 = require("../lib/api/services");
+const upgrade_1 = require("../lib/upgrade");
 const template_1 = require("../lib/utils/template");
 class Init extends base_command_1.default {
     async run() {
@@ -175,9 +176,10 @@ class Init extends base_command_1.default {
         ]);
         // Create service on platform
         this.log(`Creating service "${projectName}" in workspace "${workspace.name}"...`);
-        const service = await services_1.servicesApi.create(workspace.slug, {
-            name: projectName,
-        });
+        const serviceName = projectName;
+        const service = await (0, upgrade_1.withUpgradeRetry)(() => services_1.servicesApi.create(workspace.slug, {
+            name: serviceName,
+        }));
         // Clone template
         (0, template_1.cloneTemplate)(projectPath, language, this.log.bind(this));
         (0, template_1.initGitRepo)(projectPath);

package/dist/commands/link.js

@@ -8,6 +8,7 @@ const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
 const base_command_1 = tslib_1.__importDefault(require("../lib/base-command"));
 const config_1 = require("../lib/config");
 const services_1 = require("../lib/api/services");
+const upgrade_1 = require("../lib/upgrade");
 class Link extends base_command_1.default {
     async run() {
         const { flags } = await this.parse(Link);
@@ -96,9 +97,9 @@ class Link extends base_command_1.default {
                     },
                 ]);
                 this.log(`Creating service "${serviceName}"...`);
-                service = await services_1.servicesApi.create(workspace.slug, {
+                service = await (0, upgrade_1.withUpgradeRetry)(() => services_1.servicesApi.create(workspace.slug, {
                     name: serviceName,
-                });
+                }));
             }
         }
         // Write link

package/dist/hooks/init/telemetry.d.ts

@@ -0,0 +1,7 @@
+import { Hook } from "@oclif/core";
+/**
+ * Runs before any command. Initializes PostHog + Sentry and records that a
+ * command was invoked. Best-effort: never blocks or fails the command.
+ */
+declare const hook: Hook<"init">;
+export default hook;

package/dist/hooks/init/telemetry.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const telemetry_1 = require("../../lib/telemetry/telemetry");
+/**
+ * Runs before any command. Initializes PostHog + Sentry and records that a
+ * command was invoked. Best-effort: never blocks or fails the command.
+ */
+const hook = async function (opts) {
+    (0, telemetry_1.initTelemetry)();
+    if (opts.id) {
+        (0, telemetry_1.track)("cli_command_started", { command: opts.id });
+    }
+};
+exports.default = hook;

package/dist/hooks/postrun/telemetry.d.ts

@@ -0,0 +1,8 @@
+import { Hook } from "@oclif/core";
+/**
+ * Runs after a command completes successfully. Records completion + duration,
+ * then flushes both clients before the short-lived CLI process exits (posthog
+ * batches, so an explicit flush is required or events are lost).
+ */
+declare const hook: Hook<"postrun">;
+export default hook;

package/dist/hooks/postrun/telemetry.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const telemetry_1 = require("../../lib/telemetry/telemetry");
+/**
+ * Runs after a command completes successfully. Records completion + duration,
+ * then flushes both clients before the short-lived CLI process exits (posthog
+ * batches, so an explicit flush is required or events are lost).
+ */
+const hook = async function (opts) {
+    var _a;
+    (0, telemetry_1.track)("cli_command_completed", {
+        command: (_a = opts.Command) === null || _a === void 0 ? void 0 : _a.id,
+        duration_ms: (0, telemetry_1.elapsedMs)(),
+        success: true,
+    });
+    await (0, telemetry_1.shutdownTelemetry)();
+};
+exports.default = hook;

package/dist/lib/api/client.d.ts

@@ -15,11 +15,20 @@ import { ApiRequestOptions } from "./types";
 export declare class ApiClientError extends Error {
     statusCode: number;
     details?: Record<string, unknown> | undefined;
+    /** Machine code from the server (e.g. SERVICE_LIMIT_REACHED), when present. */
+    code?: string;
+    /** Relative URL to send the user to resolve the error (e.g. an upgrade page). */
+    upgradeUrl?: string;
     constructor(message: string, statusCode: number, details?: Record<string, unknown> | undefined);
     /**
      * Check if error is due to authentication failure
      */
     isAuthError(): boolean;
+    /**
+     * Check if error is an entitlement/plan limit that the user can resolve by
+     * upgrading (e.g. the free-tier service or deploy limit).
+     */
+    isLimitError(): boolean;
     /**
      * Check if error is a rate limit error
      */

package/dist/lib/api/client.js

@@ -40,6 +40,16 @@ class ApiClientError extends Error {
     isAuthError() {
         return this.statusCode === 401;
     }
+    /**
+     * Check if error is an entitlement/plan limit that the user can resolve by
+     * upgrading (e.g. the free-tier service or deploy limit).
+     */
+    isLimitError() {
+        return (this.statusCode === 403 &&
+            (this.code === "SERVICE_LIMIT_REACHED" ||
+                this.code === "LIMIT_REACHED" ||
+                Boolean(this.upgradeUrl)));
+    }
     /**
      * Check if error is a rate limit error
      */
@@ -82,6 +92,40 @@ function sleep(ms) {
         setTimeout(resolve, ms);
     });
 }
+/**
+ * Pull an entitlement/limit code + upgrade URL out of an error body. Handles
+ * both a flat body ({ code, upgradeUrl, message }) and the BFF's wrapped shape
+ * where the backend error is a JSON string in `.error`.
+ */
+function extractLimitInfo(errorData) {
+    const candidates = [];
+    if (errorData && typeof errorData === "object") {
+        const obj = errorData;
+        candidates.push(obj);
+        if (typeof obj.error === "string") {
+            try {
+                const parsed = JSON.parse(obj.error);
+                if (parsed && typeof parsed === "object")
+                    candidates.push(parsed);
+            }
+            catch {
+                /* not JSON — ignore */
+            }
+        }
+    }
+    for (const c of candidates) {
+        const code = typeof c.code === "string" ? c.code : undefined;
+        const upgradeUrl = typeof c.upgradeUrl === "string" ? c.upgradeUrl : undefined;
+        if (code || upgradeUrl) {
+            return {
+                code,
+                upgradeUrl,
+                message: typeof c.message === "string" ? c.message : undefined,
+            };
+        }
+    }
+    return {};
+}
 /**
  * Calculate backoff delay with jitter
  */
@@ -148,6 +192,7 @@ async function refreshAccessToken() {
  */
 /* eslint-disable no-await-in-loop */
 async function apiRequest(path, options = {}) {
+    var _a;
     const { method = "GET", body, params, headers = {}, timeout = DEFAULT_TIMEOUT, skipAuth = false, } = options;
     const config = config_1.globalConfig.read();
     const url = buildUrl(config.apiUrl, path, params);
@@ -175,6 +220,16 @@ async function apiRequest(path, options = {}) {
         if (freshCreds) {
             requestHeaders.Authorization = `Bearer ${freshCreds.tokens.accessToken}`;
         }
+        // The BFF's workspace-scoped routes read the active workspace from an
+        // X-Workspace-Id header for Bearer clients (browsers use a signed cookie).
+        // Resolve the active workspace id from, in order: an explicit header the
+        // caller passed, the APSO_WORKSPACE_ID env override, or the linked project.
+        if (!requestHeaders["X-Workspace-Id"]) {
+            const activeWorkspaceId = process.env.APSO_WORKSPACE_ID || ((_a = config_1.projectLink.read()) === null || _a === void 0 ? void 0 : _a.workspaceId);
+            if (activeWorkspaceId) {
+                requestHeaders["X-Workspace-Id"] = String(activeWorkspaceId);
+            }
+        }
     }
     // Make request with retries
     let lastError = null;
@@ -235,7 +290,11 @@ async function apiRequest(path, options = {}) {
                 continue;
             }
             // Client errors - don't retry
-            throw new ApiClientError(errorData.message || "Request failed", response.status, errorData.details);
+            const limit = extractLimitInfo(errorData);
+            const clientError = new ApiClientError(limit.message || errorData.message || "Request failed", response.status, errorData.details);
+            clientError.code = limit.code;
+            clientError.upgradeUrl = limit.upgradeUrl;
+            throw clientError;
         }
         catch (error) {
             if (error instanceof ApiClientError) {