primitive-admin 1.0.61 → 1.0.62

package/dist/src/lib/init-plan.d.ts

@@ -0,0 +1,80 @@
+import type { Platform } from "./resolve-platform.js";
+export type InitMode = "standalone" | "multi-client" | "add-client";
+export interface ClientPlan {
+    platform: Platform;
+    /** Absolute directory this client's template is installed into. */
+    dir: string;
+}
+export interface InitPlan {
+    mode: InitMode;
+    /** Every client this run scaffolds, in processing order (web first). */
+    clients: ClientPlan[];
+    /** The directory holding the ONE `.primitive/` for this app. */
+    projectRoot: string;
+    /**
+     * Whether this run writes `.primitive/config.json` and seeds the
+     * environment's credential slot. False when adopting: the config is already
+     * there and is not this run's to rewrite.
+     */
+    writesProjectConfig: boolean;
+    /**
+     * Whether this run may create the app and point the CLI's global "current
+     * app" at it. False when adopting — the app already exists and belongs to the
+     * project config.
+     */
+    ownsApp: boolean;
+    /**
+     * Whether this run creates the git repository and its initial commit. False
+     * when adopting: the surrounding repository owns the history, and the new
+     * files are left for the user to review and commit.
+     */
+    initsGit: boolean;
+    /**
+     * The one schema both clients read, or `null` in standalone mode where the
+     * client keeps the template's own copy (spec decision 1: single-client output
+     * is unchanged).
+     */
+    canonicalSchemaPath: string | null;
+    /**
+     * Whether this run may write an app-wide `AGENTS.md` at the project root.
+     * Never over an existing file — client `AGENTS.md` files ship with their
+     * templates and an adopted repo's root file is the user's.
+     */
+    writesRootAgents: boolean;
+}
+export interface PlanInitInput {
+    /** The resolved platforms, in canonical order. */
+    platforms: Platform[];
+    /** Absolute directory the command was pointed at. */
+    targetDir: string;
+    /**
+     * The nearest ancestor project root, passed ONLY when it differs from
+     * `targetDir` — `primitive init .` at an existing project root keeps its
+     * merge behavior rather than adopting itself.
+     */
+    ancestorProjectRoot?: string | null;
+}
+/** Resolve the layout for this run. */
+export declare function planInit(input: PlanInitInput): InitPlan;
+export interface InitGuardInput {
+    /** The init config's `action`, when a non-interactive config is in effect. */
+    action?: "create" | "use-existing" | "add-client";
+    /** Whether an init config is in effect at all. */
+    hasConfig: boolean;
+    /** The nearest ancestor project root, or null/undefined outside a project. */
+    ancestorProjectRoot?: string | null;
+    /** `app_id` from a `use-existing` init config. */
+    configAppId?: string;
+    /** `--use-existing-app-id`. */
+    flagAppId?: string;
+    /** The adopted environment's `appId`, when adopting. */
+    environmentAppId?: string;
+    /** The adopted environment's name, for the error messages. */
+    environmentName?: string;
+}
+/**
+ * Everything a run must be refused for, checked before any download, any API
+ * call and any write. Returns the user-facing message, or `null` when the run
+ * may proceed.
+ */
+export declare function checkInitGuards(input: InitGuardInput): string | null;

package/dist/src/lib/init-plan.js

@@ -0,0 +1,95 @@
+/**
+ * What shape does this `primitive init` run produce? (#2890)
+ *
+ * One Primitive app can have several clients — a web client and a native
+ * client — and they are one app: one appId, one project config, one exported
+ * server-config tree, one model schema. `init` therefore composes one of three
+ * layouts, and the choice decides everything downstream:
+ *
+ *   standalone   — one client, no surrounding project. Today's flat scaffold,
+ *                  unchanged: the client IS the project root.
+ *   multi-client — several clients, no surrounding project. Each client gets a
+ *                  platform-named subdirectory; the project config, the git
+ *                  repository and the canonical schema live at the root.
+ *   add-client   — an ancestor `.primitive/config.json` already exists. The run
+ *                  ADOPTS it: no nested project config, no nested git
+ *                  repository, no app creation, no commit. This is the path the
+ *                  issue opens with — running init in a subdirectory used to
+ *                  scaffold a second project that had to be partly undone.
+ *
+ * Pure on purpose: the layout and the guards are the part that is expensive to
+ * get wrong and impossible to assert from a half-written scaffold.
+ */
+import { join } from "path";
+import { PROJECT_CONFIG_DISPLAY_NAME } from "./project-config.js";
+/** Resolve the layout for this run. */
+export function planInit(input) {
+    const adopting = Boolean(input.ancestorProjectRoot);
+    const projectRoot = adopting ? input.ancestorProjectRoot : input.targetDir;
+    const composed = adopting || input.platforms.length > 1;
+    // One client in an adopt run lands exactly where the user pointed the
+    // command; anything else gets a platform-named subdirectory, which is what
+    // makes `web/` and `ios/` siblings under one root.
+    const useSubdirectories = input.platforms.length > 1;
+    const clients = input.platforms.map((platform) => ({
+        platform,
+        dir: useSubdirectories ? join(input.targetDir, platform) : input.targetDir,
+    }));
+    const mode = adopting
+        ? "add-client"
+        : input.platforms.length > 1
+            ? "multi-client"
+            : "standalone";
+    return {
+        mode,
+        clients,
+        projectRoot,
+        writesProjectConfig: !adopting,
+        ownsApp: !adopting,
+        initsGit: !adopting,
+        canonicalSchemaPath: composed
+            ? join(projectRoot, "models", "models.toml")
+            : null,
+        writesRootAgents: composed,
+    };
+}
+/**
+ * Everything a run must be refused for, checked before any download, any API
+ * call and any write. Returns the user-facing message, or `null` when the run
+ * may proceed.
+ */
+export function checkInitGuards(input) {
+    const root = input.ancestorProjectRoot;
+    if (!root) {
+        // `add-client` describes adopting a project that is not there.
+        if (input.action === "add-client") {
+            return (`action = "add-client" adds a client to an existing Primitive app, but there is no ` +
+                `${PROJECT_CONFIG_DISPLAY_NAME} in this directory or any parent. ` +
+                `Run init from inside the app's repository, or use action = "create" to start a new app.`);
+        }
+        return null;
+    }
+    const envName = input.environmentName ?? "the selected environment";
+    // Creating a SECOND app inside a repository that already has one is the
+    // nesting this change removes.
+    if (input.action === "create") {
+        return (`action = "create" would create a second Primitive app inside the existing project at ${root}. ` +
+            `Use action = "add-client" to add this client to the app that project already targets.`);
+    }
+    if (!input.environmentAppId) {
+        return (`The "${envName}" environment in ${root}/${PROJECT_CONFIG_DISPLAY_NAME} has no appId, so there is no app to add this client to. ` +
+            `Set one with \`primitive env add <name> --api-url <url> --app-id <appId>\`, or select an environment that has one with \`primitive env use <name>\`.`);
+    }
+    // Naming an app explicitly is allowed only when it is the SAME app: a
+    // different one would wire this client to a backend the rest of the repo does
+    // not target.
+    const named = input.flagAppId ?? (input.action === "use-existing" ? input.configAppId : undefined);
+    if (named && named !== input.environmentAppId) {
+        const source = input.flagAppId ? "--use-existing-app-id" : '`app_id` (action = "use-existing")';
+        return (`${source} names app ${named}, but the "${envName}" environment of the project at ${root} targets app ${input.environmentAppId}. ` +
+            `A client added to this repository belongs to that app — drop the app id and use action = "add-client", ` +
+            `or run init outside this project to scaffold a separate app.`);
+    }
+    return null;
+}
+//# sourceMappingURL=init-plan.js.map

package/dist/src/lib/init-plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-plan.js","sourceRoot":"","sources":["../../../src/lib/init-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AA8DlE,uCAAuC;AACvC,MAAM,UAAU,QAAQ,CAAC,KAAoB;IAC3C,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACpD,MAAM,WAAW,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,mBAAoB,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC;IAC5E,MAAM,QAAQ,GAAG,QAAQ,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;IAExD,sEAAsE;IACtE,2EAA2E;IAC3E,mDAAmD;IACnD,MAAM,iBAAiB,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;IACrD,MAAM,OAAO,GAAiB,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAC/D,QAAQ;QACR,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS;KAC3E,CAAC,CAAC,CAAC;IAEJ,MAAM,IAAI,GAAa,QAAQ;QAC7B,CAAC,CAAC,YAAY;QACd,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC;YAC1B,CAAC,CAAC,cAAc;YAChB,CAAC,CAAC,YAAY,CAAC;IAEnB,OAAO;QACL,IAAI;QACJ,OAAO;QACP,WAAW;QACX,mBAAmB,EAAE,CAAC,QAAQ;QAC9B,OAAO,EAAE,CAAC,QAAQ;QAClB,QAAQ,EAAE,CAAC,QAAQ;QACnB,mBAAmB,EAAE,QAAQ;YAC3B,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,aAAa,CAAC;YAC5C,CAAC,CAAC,IAAI;QACR,gBAAgB,EAAE,QAAQ;KAC3B,CAAC;AACJ,CAAC;AAmBD;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,KAAqB;IACnD,MAAM,IAAI,GAAG,KAAK,CAAC,mBAAmB,CAAC;IAEvC,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,+DAA+D;QAC/D,IAAI,KAAK,CAAC,MAAM,KAAK,YAAY,EAAE,CAAC;YAClC,OAAO,CACL,oFAAoF;gBACpF,GAAG,2BAA2B,oCAAoC;gBAClE,yFAAyF,CAC1F,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,OAAO,GAAG,KAAK,CAAC,eAAe,IAAI,0BAA0B,CAAC;IAEpE,wEAAwE;IACxE,+BAA+B;IAC/B,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,CACL,wFAAwF,IAAI,IAAI;YAChG,uFAAuF,CACxF,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC;QAC5B,OAAO,CACL,QAAQ,OAAO,oBAAoB,IAAI,IAAI,2BAA2B,2DAA2D;YACjI,sJAAsJ,CACvJ,CAAC;IACJ,CAAC;IAED,sEAAsE;IACtE,8EAA8E;IAC9E,cAAc;IACd,MAAM,KAAK,GAAG,KAAK,CAAC,SAAS,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IACnG,IAAI,KAAK,IAAI,KAAK,KAAK,KAAK,CAAC,gBAAgB,EAAE,CAAC;QAC9C,MAAM,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC,oCAAoC,CAAC;QAChG,OAAO,CACL,GAAG,MAAM,cAAc,KAAK,cAAc,OAAO,mCAAmC,IAAI,gBAAgB,KAAK,CAAC,gBAAgB,IAAI;YAClI,yGAAyG;YACzG,8DAA8D,CAC/D,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/src/lib/init-production-env.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Which backend a scaffolded client's PRODUCTION build talks to (#2890).
+ *
+ * `init` used to write the hosted production URL into `.env.production`
+ * unconditionally, alongside the app ID of the app it had just created. On the
+ * hosted server those agree. On any other one — a self-hosted server, a staging
+ * server, an alpha channel — they do not: the production build points at a
+ * backend the app ID does not exist on, and the mismatch only shows up after a
+ * deploy.
+ *
+ * So a composed run derives the pair from the project's own environments
+ * instead, and only falls back to the old behavior where it was right anyway:
+ *
+ *   1. a `prod` environment, then a `production` one — the team already said
+ *      which backend/app pair production means
+ *   2. otherwise, when this run targets the hosted production server, the
+ *      hosted production URL with this app (today's output)
+ *   3. otherwise the selected environment's own server and app — one backend,
+ *      one app, consistently
+ *
+ * Standalone runs keep calling the old path verbatim, so a single-client
+ * scaffold's output is unchanged (spec decision 1).
+ */
+export interface ProductionRuntime {
+    serverUrl: string;
+    appId: string;
+    appName?: string;
+    /** Which rule chose it, for the message init prints. */
+    source: "environment" | "hosted-production" | "selected";
+    /** The environment name, when one was used. */
+    environmentName?: string;
+}
+export interface ResolveProductionRuntimeInput {
+    /** The project's environments, keyed by name. */
+    environments?: Record<string, {
+        apiUrl?: string;
+        appId?: string;
+        appName?: string;
+    } | undefined>;
+    /** The server this run targets. */
+    selectedServerUrl: string;
+    /** The app this run scaffolds against. */
+    selectedAppId: string;
+    selectedAppName?: string;
+    /** The hosted production server URL. */
+    productionServerUrl: string;
+}
+export declare function resolveProductionRuntime(input: ResolveProductionRuntimeInput): ProductionRuntime;

package/dist/src/lib/init-production-env.js

@@ -0,0 +1,59 @@
+/**
+ * Which backend a scaffolded client's PRODUCTION build talks to (#2890).
+ *
+ * `init` used to write the hosted production URL into `.env.production`
+ * unconditionally, alongside the app ID of the app it had just created. On the
+ * hosted server those agree. On any other one — a self-hosted server, a staging
+ * server, an alpha channel — they do not: the production build points at a
+ * backend the app ID does not exist on, and the mismatch only shows up after a
+ * deploy.
+ *
+ * So a composed run derives the pair from the project's own environments
+ * instead, and only falls back to the old behavior where it was right anyway:
+ *
+ *   1. a `prod` environment, then a `production` one — the team already said
+ *      which backend/app pair production means
+ *   2. otherwise, when this run targets the hosted production server, the
+ *      hosted production URL with this app (today's output)
+ *   3. otherwise the selected environment's own server and app — one backend,
+ *      one app, consistently
+ *
+ * Standalone runs keep calling the old path verbatim, so a single-client
+ * scaffold's output is unchanged (spec decision 1).
+ */
+/** Trailing-slash-insensitive comparison, as elsewhere in init. */
+function sameServer(a, b) {
+    return a.replace(/\/+$/, "") === b.replace(/\/+$/, "");
+}
+export function resolveProductionRuntime(input) {
+    const environments = input.environments ?? {};
+    // `prod` first, deliberately: a repo with both names has one of them as the
+    // real one, and `prod` is what `primitive init` and the templates use.
+    for (const name of ["prod", "production"]) {
+        const env = environments[name];
+        if (env?.apiUrl && env?.appId) {
+            return {
+                serverUrl: env.apiUrl,
+                appId: env.appId,
+                appName: env.appName ?? input.selectedAppName,
+                source: "environment",
+                environmentName: name,
+            };
+        }
+    }
+    if (sameServer(input.selectedServerUrl, input.productionServerUrl)) {
+        return {
+            serverUrl: input.productionServerUrl,
+            appId: input.selectedAppId,
+            appName: input.selectedAppName,
+            source: "hosted-production",
+        };
+    }
+    return {
+        serverUrl: input.selectedServerUrl,
+        appId: input.selectedAppId,
+        appName: input.selectedAppName,
+        source: "selected",
+    };
+}
+//# sourceMappingURL=init-production-env.js.map

package/dist/src/lib/init-production-env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-production-env.js","sourceRoot":"","sources":["../../../src/lib/init-production-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AA2BH,mEAAmE;AACnE,SAAS,UAAU,CAAC,CAAS,EAAE,CAAS;IACtC,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,wBAAwB,CACtC,KAAoC;IAEpC,MAAM,YAAY,GAAG,KAAK,CAAC,YAAY,IAAI,EAAE,CAAC;IAC9C,4EAA4E;IAC5E,uEAAuE;IACvE,KAAK,MAAM,IAAI,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC;QAC1C,MAAM,GAAG,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,CAAC;YAC9B,OAAO;gBACL,SAAS,EAAE,GAAG,CAAC,MAAM;gBACrB,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,OAAO,EAAE,GAAG,CAAC,OAAO,IAAI,KAAK,CAAC,eAAe;gBAC7C,MAAM,EAAE,aAAa;gBACrB,eAAe,EAAE,IAAI;aACtB,CAAC;QACJ,CAAC;IACH,CAAC;IAED,IAAI,UAAU,CAAC,KAAK,CAAC,iBAAiB,EAAE,KAAK,CAAC,mBAAmB,CAAC,EAAE,CAAC;QACnE,OAAO;YACL,SAAS,EAAE,KAAK,CAAC,mBAAmB;YACpC,KAAK,EAAE,KAAK,CAAC,aAAa;YAC1B,OAAO,EAAE,KAAK,CAAC,eAAe;YAC9B,MAAM,EAAE,mBAAmB;SAC5B,CAAC;IACJ,CAAC;IAED,OAAO;QACL,SAAS,EAAE,KAAK,CAAC,iBAAiB;QAClC,KAAK,EAAE,KAAK,CAAC,aAAa;QAC1B,OAAO,EAAE,KAAK,CAAC,eAAe;QAC9B,MAAM,EAAE,UAAU;KACnB,CAAC;AACJ,CAAC"}

package/dist/src/lib/init-schema.d.ts

@@ -0,0 +1,74 @@
+import type { Platform } from "./resolve-platform.js";
+/** The canonical schema's path, relative to the project root. */
+export declare const CANONICAL_SCHEMA_RELATIVE: string;
+/**
+ * A POSIX-style relative specifier from `fromDir` to `toFile`, always prefixed
+ * with `./` or `../` — what both an import specifier and a `-i` argument need.
+ */
+export declare function relativeSchemaPath(fromDir: string, toFile: string): string;
+/**
+ * The schema a freshly installed client template ships, or null when it has
+ * none (the Swift starter is comment-only but the file is still there).
+ */
+export declare function findClientSchema(clientDir: string, platform: Platform): string | null;
+/** The Swift target's source directory (`Sources/<AppName>`), if there is one. */
+export declare function findSwiftTargetDir(clientDir: string): string | null;
+/**
+ * The models a schema declares, in the order it declares them.
+ *
+ * `[models.<name>]`, `[models.<name>.fields.<field>]` and the array form all
+ * name the same model; the loader treats the first path segment after `models`
+ * as the model name, and so does this.
+ */
+export declare function declaredModelNames(toml: string): string[];
+/**
+ * The app's one schema has to declare every model its clients read.
+ *
+ * A client's template ships both a starter schema and code generated from it —
+ * the web template's store reads `UserPref`, and the model generator refuses a
+ * schema with no models at all. So composing the shared schema is not "pick a
+ * starter": it is the base schema (an existing client's, when one is being
+ * promoted) PLUS every model a client being added declares and the base does
+ * not. Nothing is ever overwritten — a model the base already declares is the
+ * app's definition of it, and stays exactly as it is.
+ */
+export declare function composeSchemaContent(input: {
+    /** The schema the app already has, or the one being promoted to the root. */
+    base: string;
+    /** The starter schemas of the clients this run is adding. */
+    starters: string[];
+}): {
+    content: string;
+    added: string[];
+};
+/** What `wireClientToSchema` actually rewrote, for the caller to report. */
+export interface SchemaWiringResult {
+    /** Files rewritten or created so this client reads the shared schema. */
+    rewired: string[];
+    /** The client-local schema copy that was removed, if any. */
+    removed?: string;
+    /** Set when the client's shape was not recognized and nothing was rewired. */
+    error?: string;
+}
+/**
+ * Points one client at the shared schema and drops its own copy.
+ *
+ * Writes the new wiring BEFORE removing the client-local schema, so a failure
+ * leaves a client that still has a schema rather than one with neither.
+ */
+export declare function wireClientToSchema(clientDir: string, platform: Platform, schemaPath: string): SchemaWiringResult;
+/**
+ * Why this client cannot be pointed at the shared schema, or null when it can.
+ *
+ * Separate from the wiring itself because the answer decides whether the run
+ * happens at all: a client that keeps its own schema while the app has another
+ * is the two-copies layout the shared schema exists to prevent, so a caller
+ * asks this BEFORE it writes the shared file — before the download, when the
+ * client already exists.
+ */
+export declare function checkClientWiring(clientDir: string, platform: Platform, schemaPath: string): string | null;
+/**
+ * Writes the canonical schema, creating `models/` if needed. Never overwrites:
+ * an existing shared schema is the app's, not this run's.
+ */
+export declare function writeCanonicalSchema(schemaPath: string, content: string): boolean;