@apso/cli 0.19.0 → 0.21.0

package/dist/lib/base-command.d.ts

@@ -1,5 +1,13 @@
 import { Command } from "@oclif/core";
 export default abstract class BaseCommand extends Command {
+    /**
+     * Report failures to Sentry + PostHog before oclif exits. The postrun hook
+     * does not fire on error, so the flush has to happen here.
+     */
+    catch(err: Error & {
+        exitCode?: number;
+        code?: string;
+    }): Promise<any>;
     runCommand(command: string, args: string[], silent?: boolean): Promise<void>;
     runNpmCommand(args: string[], silent?: boolean): Promise<void>;
 }

package/dist/lib/base-command.js

@@ -4,7 +4,28 @@ const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const child_process_1 = require("child_process");
 const os_1 = tslib_1.__importDefault(require("os"));
+const telemetry_1 = require("./telemetry/telemetry");
 class BaseCommand extends core_1.Command {
+    /**
+     * Report failures to Sentry + PostHog before oclif exits. The postrun hook
+     * does not fire on error, so the flush has to happen here.
+     */
+    async catch(err) {
+        try {
+            (0, telemetry_1.captureException)(err, { command: this.id });
+            (0, telemetry_1.track)("cli_command_failed", {
+                command: this.id,
+                duration_ms: (0, telemetry_1.elapsedMs)(),
+                error: err === null || err === void 0 ? void 0 : err.message,
+                error_code: err === null || err === void 0 ? void 0 : err.code,
+            });
+            await (0, telemetry_1.shutdownTelemetry)();
+        }
+        catch {
+            // never mask the original error with a telemetry failure
+        }
+        return super.catch(err);
+    }
     async runCommand(command, args, silent = false) {
         return new Promise((resolve, reject) => {
             const isWindows = os_1.default.platform() === "win32";

package/dist/lib/biome/biome.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100
+  },
+  "javascript": {
+    "parser": {
+      "unsafeParameterDecoratorsEnabled": true
+    },
+    "formatter": {
+      "quoteStyle": "double",
+      "semicolons": "always"
+    }
+  },
+  "linter": {
+    "enabled": false
+  }
+}

package/dist/lib/config/types.js

@@ -11,7 +11,10 @@ exports.CONFIG_ENV_VARS = exports.DEFAULT_GLOBAL_CONFIG = void 0;
  * Default values for global configuration
  */
 exports.DEFAULT_GLOBAL_CONFIG = {
-    apiUrl: "https://api.apso.dev",
+    // The CLI talks to the BFF (the app's /api/* routes), not the internal
+    // backend on api.apso.dev. Override for staging with
+    // APSO_API_URL=https://app.staging.apso.cloud.
+    apiUrl: "https://app.apso.cloud",
     webUrl: "https://app.apso.cloud",
     verbose: false,
     noColor: false,

package/dist/lib/git.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Local git helpers for the deploy flow.
+ *
+ * The CLI pushes generated code to GitHub with the user's own local git (their
+ * credentials / credential helper) — not through apso.ai. The platform only
+ * needs the repo *connected* to the service so the provisioner can clone it at
+ * deploy time.
+ */
+export declare function gitAvailable(): boolean;
+export declare function isGitRepo(cwd: string): boolean;
+export declare function initRepo(cwd: string): void;
+export declare function getOriginUrl(cwd: string): string | null;
+/** Parse `owner/repo` from an https or ssh GitHub remote URL. */
+export declare function parseRepoFullName(url: string | null): string | null;
+/** The repo the local project is already wired to, if any (owner/repo). */
+export declare function localRepoFullName(cwd: string): string | null;
+export declare function setOrigin(cwd: string, repoUrl: string): void;
+export declare function hasUncommittedChanges(cwd: string): boolean;
+/** Stage everything and commit, unless there is nothing to commit. */
+export declare function commitAll(cwd: string, message: string): boolean;
+/** Attribution trailer appended to every commit the CLI creates. */
+export declare const APSO_COMMIT_TRAILER = "Generated with Apso (https://apso.ai)";
+/** Push the current HEAD to origin/<branch>, setting upstream. */
+export declare function pushHead(cwd: string, branch: string): void;
+export declare function httpsUrlFor(repoFullName: string): string;

package/dist/lib/git.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Local git helpers for the deploy flow.
+ *
+ * The CLI pushes generated code to GitHub with the user's own local git (their
+ * credentials / credential helper) — not through apso.ai. The platform only
+ * needs the repo *connected* to the service so the provisioner can clone it at
+ * deploy time.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpsUrlFor = exports.pushHead = exports.APSO_COMMIT_TRAILER = exports.commitAll = exports.hasUncommittedChanges = exports.setOrigin = exports.localRepoFullName = exports.parseRepoFullName = exports.getOriginUrl = exports.initRepo = exports.isGitRepo = exports.gitAvailable = void 0;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+function run(cmd, cwd) {
+    return (0, child_process_1.execSync)(cmd, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+    })
+        .toString()
+        .trim();
+}
+function gitAvailable() {
+    try {
+        (0, child_process_1.execSync)("git --version", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports.gitAvailable = gitAvailable;
+function isGitRepo(cwd) {
+    return fs.existsSync(path.join(cwd, ".git"));
+}
+exports.isGitRepo = isGitRepo;
+function initRepo(cwd) {
+    if (!isGitRepo(cwd)) {
+        run("git init", cwd);
+    }
+}
+exports.initRepo = initRepo;
+function getOriginUrl(cwd) {
+    try {
+        return run("git remote get-url origin", cwd);
+    }
+    catch {
+        return null;
+    }
+}
+exports.getOriginUrl = getOriginUrl;
+/** Parse `owner/repo` from an https or ssh GitHub remote URL. */
+function parseRepoFullName(url) {
+    if (!url)
+        return null;
+    const m = url.match(/github\.com[:/]([^/]+)\/(.+?)(?:\.git)?\/?$/i);
+    return m ? `${m[1]}/${m[2]}` : null;
+}
+exports.parseRepoFullName = parseRepoFullName;
+/** The repo the local project is already wired to, if any (owner/repo). */
+function localRepoFullName(cwd) {
+    return parseRepoFullName(getOriginUrl(cwd));
+}
+exports.localRepoFullName = localRepoFullName;
+function setOrigin(cwd, repoUrl) {
+    if (getOriginUrl(cwd)) {
+        run(`git remote set-url origin ${repoUrl}`, cwd);
+    }
+    else {
+        run(`git remote add origin ${repoUrl}`, cwd);
+    }
+}
+exports.setOrigin = setOrigin;
+function hasUncommittedChanges(cwd) {
+    return run("git status --porcelain", cwd).length > 0;
+}
+exports.hasUncommittedChanges = hasUncommittedChanges;
+/** Stage everything and commit, unless there is nothing to commit. */
+function commitAll(cwd, message) {
+    run("git add -A", cwd);
+    if (!hasUncommittedChanges(cwd)) {
+        // Something may still be staged with no worktree diff; check the index.
+        const staged = (() => {
+            try {
+                return run("git diff --cached --name-only", cwd).length > 0;
+            }
+            catch {
+                return false;
+            }
+        })();
+        if (!staged)
+            return false;
+    }
+    // Second -m adds a trailer paragraph attributing the code to Apso. Mirrors
+    // the "Co-Authored-By" convention: a machine-visible footprint on every
+    // commit the CLI makes.
+    run(`git commit -m ${JSON.stringify(message)} -m ${JSON.stringify(exports.APSO_COMMIT_TRAILER)}`, cwd);
+    return true;
+}
+exports.commitAll = commitAll;
+/** Attribution trailer appended to every commit the CLI creates. */
+exports.APSO_COMMIT_TRAILER = "Generated with Apso (https://apso.ai)";
+/** Push the current HEAD to origin/<branch>, setting upstream. */
+function pushHead(cwd, branch) {
+    run(`git push -u origin HEAD:${branch}`, cwd);
+}
+exports.pushHead = pushHead;
+function httpsUrlFor(repoFullName) {
+    return `https://github.com/${repoFullName}.git`;
+}
+exports.httpsUrlFor = httpsUrlFor;

package/dist/lib/telemetry/telemetry.d.ts

@@ -0,0 +1,21 @@
+declare function isDisabled(telemetryDisabled: boolean): boolean;
+/** Stable, non-PII fallback id for logged-out users (no username, no MAC). */
+declare function anonMachineId(): string;
+/**
+ * Initialize telemetry. Call once at process start (init hook). Safe to call
+ * when disabled — it just no-ops everything downstream.
+ */
+export declare function initTelemetry(): void;
+/** Emit a PostHog event. No-op when disabled. */
+export declare function track(event: string, properties?: Record<string, unknown>): void;
+/** Report an exception to Sentry. No-op when disabled. */
+export declare function captureException(err: unknown, context?: Record<string, unknown>): void;
+/** Milliseconds since the process (CLI invocation) started. */
+export declare function elapsedMs(): number;
+/** Flush + close both clients. Call before the process exits. */
+export declare function shutdownTelemetry(): Promise<void>;
+export declare const __testing: {
+    isDisabled: typeof isDisabled;
+    anonMachineId: typeof anonMachineId;
+};
+export {};

package/dist/lib/telemetry/telemetry.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing = exports.shutdownTelemetry = exports.elapsedMs = exports.captureException = exports.track = exports.initTelemetry = void 0;
+const tslib_1 = require("tslib");
+/**
+ * CLI telemetry — usage analytics (PostHog) + error reporting (Sentry).
+ *
+ * Wired to the same Apso systems the web app and build engine use so CLI usage
+ * shows up in the same funnels. Fully opt-out:
+ *   - `apso config set telemetryDisabled true`
+ *   - env DO_NOT_TRACK=1  (honors the console.dev standard)
+ *   - env APSO_TELEMETRY_DISABLED=1
+ *
+ * Everything here is best-effort and MUST NOT throw or block a command. All
+ * public functions swallow their own errors. The PostHog project keys and the
+ * Sentry DSN are public client ingestion keys (the same class of token shipped
+ * to browsers), safe to bundle.
+ */
+const posthog_node_1 = require("posthog-node");
+const Sentry = tslib_1.__importStar(require("@sentry/node"));
+const crypto_1 = require("crypto");
+const os_1 = tslib_1.__importDefault(require("os"));
+const config_1 = require("../config");
+// Public ingestion keys (same tokens the browser/build-engine ship, per env).
+const POSTHOG_KEY_PROD = "phc_Es9UUMw8pOs7Bs21b5PhfC5Qdo94GpYVv8MfdrG12LC";
+const POSTHOG_KEY_STAGING = "phc_bkc33v3wo5LRvgPF6IdjsgDEDOwgJMz95MR2YIlvELk";
+const POSTHOG_HOST = "https://us.i.posthog.com";
+// Dedicated apsoai/apso-cli Sentry project DSN (public client key).
+const SENTRY_DSN_DEFAULT = "https://754ae10322af78af3edbb87b93383ebb@o4509208616435714.ingest.us.sentry.io/4511796852162560";
+let cliVersion = "0.0.0";
+try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    cliVersion = require("../../../package.json").version || cliVersion;
+}
+catch {
+    // ignore
+}
+let posthog = null;
+let enabled = false;
+let sentryOn = false;
+let distinctId = "cli-anonymous";
+let environment = "production";
+let startedAt = Date.now();
+function isDisabled(telemetryDisabled) {
+    if (process.env.DO_NOT_TRACK === "1" || process.env.DO_NOT_TRACK === "true")
+        return true;
+    if (process.env.APSO_TELEMETRY_DISABLED === "1")
+        return true;
+    return !!telemetryDisabled;
+}
+/** Stable, non-PII fallback id for logged-out users (no username, no MAC). */
+function anonMachineId() {
+    const seed = `${os_1.default.hostname()}|${os_1.default.platform()}|${os_1.default.arch()}`;
+    return "cli_" + (0, crypto_1.createHash)("sha256").update(seed).digest("hex").slice(0, 20);
+}
+/**
+ * Initialize telemetry. Call once at process start (init hook). Safe to call
+ * when disabled — it just no-ops everything downstream.
+ */
+function initTelemetry() {
+    var _a, _b, _c;
+    try {
+        startedAt = Date.now();
+        const cfg = config_1.globalConfig.read();
+        if (isDisabled(cfg.telemetryDisabled)) {
+            enabled = false;
+            return;
+        }
+        enabled = true;
+        environment = (cfg.apiUrl || "").includes("staging")
+            ? "staging"
+            : "production";
+        const creds = config_1.credentials.read();
+        distinctId = ((_a = creds === null || creds === void 0 ? void 0 : creds.user) === null || _a === void 0 ? void 0 : _a.id) || anonMachineId();
+        posthog = new posthog_node_1.PostHog(environment === "staging" ? POSTHOG_KEY_STAGING : POSTHOG_KEY_PROD, { host: POSTHOG_HOST, flushAt: 1, flushInterval: 0 });
+        if ((_b = creds === null || creds === void 0 ? void 0 : creds.user) === null || _b === void 0 ? void 0 : _b.email) {
+            // Attach identity so CLI events attribute to the same person as the app.
+            posthog.identify({
+                distinctId,
+                properties: { email: creds.user.email, name: creds.user.name },
+            });
+        }
+        const dsn = process.env.APSO_CLI_SENTRY_DSN || SENTRY_DSN_DEFAULT;
+        if (dsn) {
+            Sentry.init({
+                dsn,
+                environment,
+                release: `apso-cli@${cliVersion}`,
+                tracesSampleRate: 0,
+            });
+            Sentry.setUser({ id: distinctId, email: (_c = creds === null || creds === void 0 ? void 0 : creds.user) === null || _c === void 0 ? void 0 : _c.email });
+            Sentry.setTag("cli_version", cliVersion);
+            sentryOn = true;
+        }
+    }
+    catch {
+        enabled = false;
+    }
+}
+exports.initTelemetry = initTelemetry;
+function commonProps() {
+    return {
+        cli_version: cliVersion,
+        environment,
+        os: os_1.default.platform(),
+        arch: os_1.default.arch(),
+        node_version: process.version,
+        authenticated: distinctId !== anonMachineId() && !distinctId.startsWith("cli_"),
+    };
+}
+/** Emit a PostHog event. No-op when disabled. */
+function track(event, properties = {}) {
+    try {
+        if (!enabled || !posthog)
+            return;
+        posthog.capture({
+            distinctId,
+            event,
+            properties: { ...commonProps(), ...properties },
+        });
+    }
+    catch {
+        // never break a command over telemetry
+    }
+}
+exports.track = track;
+/** Report an exception to Sentry. No-op when disabled. */
+function captureException(err, context = {}) {
+    try {
+        if (!enabled || !sentryOn)
+            return;
+        Sentry.captureException(err, { extra: context });
+    }
+    catch {
+        // ignore
+    }
+}
+exports.captureException = captureException;
+/** Milliseconds since the process (CLI invocation) started. */
+function elapsedMs() {
+    return Date.now() - startedAt;
+}
+exports.elapsedMs = elapsedMs;
+/** Flush + close both clients. Call before the process exits. */
+async function shutdownTelemetry() {
+    try {
+        if (posthog)
+            await posthog.shutdown();
+    }
+    catch {
+        // ignore
+    }
+    try {
+        if (sentryOn)
+            await Sentry.close(2000);
+    }
+    catch {
+        // ignore
+    }
+}
+exports.shutdownTelemetry = shutdownTelemetry;
+exports.__testing = { isDisabled, anonMachineId };

package/dist/lib/templates/go/header.eta

@@ -1,3 +1,4 @@
-// Code generated by APSO CLI. DO NOT EDIT.
-// This file is auto-generated - any changes will be overwritten.
-// Generated at: <%= new Date().toISOString() %>
+// Code generated by Apso CLI. DO NOT EDIT.
+// Generated with Apso (https://apso.ai)
+//
+// This file is auto-generated; changes will be overwritten on the next scaffold.

package/dist/lib/templates/guards/guards.module.eta

@@ -37,9 +37,11 @@ import { <%= it.authConfig.accountUserEntity %> } from '../<%= it.authConfig.acc
  *
  * Usage:
  * 1. Import GuardsModule in your AppModule
- * 2. Guards are NOT enabled globally by default (for backward compatibility)
- * 3. To enable guards globally, uncomment the APP_GUARD providers below
- * 4. Or apply guards selectively using @UseGuards(AuthGuard, ScopeGuard) on controllers
+ * 2. Guards are ENABLED GLOBALLY BY DEFAULT (secure by default) because this
+ *    schema declares an auth model / scoped entities. Requests are authenticated
+ *    and tenant-scoped unless a route opts out with @Public().
+ * 3. Services with no auth model generate no guards and rely on the API Gateway
+ *    API key at the edge.
  *
 <% if (it.authConfig) { %>
  * AuthGuard:
@@ -88,18 +90,22 @@ import { <%= it.authConfig.accountUserEntity %> } from '../<%= it.authConfig.acc
 <% if (it.scopedEntities && it.scopedEntities.length > 0) { %>
     ScopeGuard,
 <% } %>
-    // UNCOMMENT BELOW TO ENABLE GLOBAL GUARDS
+    // Global guards are ENABLED BY DEFAULT (secure by default) whenever the
+    // schema declares an auth model / scoped entities. Services with NO auth
+    // config generate no guards at all and are protected at the edge by the
+    // API Gateway API key — so this does not conflict with that setup. Use the
+    // @Public() decorator to opt an individual route out of authentication.
 <% if (it.authConfig) { %>
-    // {
-    //   provide: APP_GUARD,
-    //   useClass: AuthGuard,
-    // },
+    {
+      provide: APP_GUARD,
+      useClass: AuthGuard,
+    },
 <% } %>
 <% if (it.scopedEntities && it.scopedEntities.length > 0) { %>
-    // {
-    //   provide: APP_GUARD,
-    //   useClass: ScopeGuard,
-    // },
+    {
+      provide: APP_GUARD,
+      useClass: ScopeGuard,
+    },
 <% } %>
   ],
   exports: [

package/dist/lib/templates/header.eta

@@ -1,8 +1,6 @@
-<% /*
- * This file is generated by Apso.
+/**
+ * Generated with Apso (https://apso.ai)
  *
- * Generated at: <%= it.generatedAt %>
- * Generated by: <%= it.generatedBy %>
- *
- * Do not edit this file directly.
-*/ %>
+ * This file is auto-generated by the Apso CLI. Do not edit it directly;
+ * changes will be overwritten on the next scaffold.
+ */

package/dist/lib/templates/python/header.eta

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
-# Generated: <%= it.generatedAt %>
-
-# Auto-generated by Apso CLI
-# DO NOT EDIT - This file is managed by Apso and will be overwritten on scaffold
+# Generated with Apso (https://apso.ai)
+#
+# This file is auto-generated by the Apso CLI. Do not edit it directly;
+# changes will be overwritten on the next scaffold.
 

package/dist/lib/upgrade.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Upgrade-on-limit flow.
+ *
+ * When the platform rejects an action because the workspace hit a plan limit
+ * (e.g. the free-tier service cap), we surface a friendly prompt that opens the
+ * upgrade page in the browser and retries once the user is done — mirroring the
+ * "you've hit a limit, upgrade?" flow developers expect from modern CLIs.
+ */
+import { ApiClientError } from "./api/client";
+/**
+ * Prompt the user to upgrade after a limit error, open the upgrade page, and
+ * wait for them to finish. Returns true if the caller should retry the action.
+ */
+export declare function promptUpgrade(error: ApiClientError): Promise<boolean>;
+/**
+ * Run an action; if it fails with an upgradeable plan-limit error, offer to
+ * upgrade and retry once.
+ */
+export declare function withUpgradeRetry<T>(action: () => Promise<T>): Promise<T>;

package/dist/lib/upgrade.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Upgrade-on-limit flow.
+ *
+ * When the platform rejects an action because the workspace hit a plan limit
+ * (e.g. the free-tier service cap), we surface a friendly prompt that opens the
+ * upgrade page in the browser and retries once the user is done — mirroring the
+ * "you've hit a limit, upgrade?" flow developers expect from modern CLIs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withUpgradeRetry = exports.promptUpgrade = void 0;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const client_1 = require("./api/client");
+const config_1 = require("./config");
+/**
+ * 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());
+    });
+}
+/**
+ * Prompt the user to upgrade after a limit error, open the upgrade page, and
+ * wait for them to finish. Returns true if the caller should retry the action.
+ */
+async function promptUpgrade(error) {
+    const config = config_1.globalConfig.read();
+    const upgradeUrl = `${config.webUrl}${error.upgradeUrl || "/billing/upgrade"}`;
+    console.log("");
+    console.log(`  ⚠  ${error.message || "You've reached a plan limit."}`);
+    console.log("");
+    const { proceed } = await inquirer_1.default.prompt([
+        {
+            type: "confirm",
+            name: "proceed",
+            message: "Open the upgrade page in your browser?",
+            default: true,
+        },
+    ]);
+    if (!proceed) {
+        console.log(`  You can upgrade any time at: ${upgradeUrl}`);
+        return false;
+    }
+    console.log("");
+    console.log(`  Opening ${upgradeUrl}`);
+    console.log("  If the browser doesn't open, visit the URL above.");
+    await openBrowser(upgradeUrl);
+    const { done } = await inquirer_1.default.prompt([
+        {
+            type: "confirm",
+            name: "done",
+            message: "Press enter once your upgrade is complete to retry",
+            default: true,
+        },
+    ]);
+    return done;
+}
+exports.promptUpgrade = promptUpgrade;
+/**
+ * Run an action; if it fails with an upgradeable plan-limit error, offer to
+ * upgrade and retry once.
+ */
+async function withUpgradeRetry(action) {
+    try {
+        return await action();
+    }
+    catch (error) {
+        if (error instanceof client_1.ApiClientError && error.isLimitError()) {
+            const retry = await promptUpgrade(error);
+            if (retry) {
+                return action();
+            }
+        }
+        throw error;
+    }
+}
+exports.withUpgradeRetry = withUpgradeRetry;