primitive-admin 1.1.0-alpha.9 → 1.2.0-alpha.0

package/dist/src/lib/generated-workflow-model-fields.js

@@ -0,0 +1,53 @@
+/**
+ * GENERATED FILE — DO NOT EDIT BY HAND.
+ *
+ * Source of truth: the `WorkflowDefinition` model in the repo-root
+ * `models.yaml` — the one statically-parseable server anchor for the
+ * `[workflow]`-level config surface (issue #2326, Phase 1 of #1976).
+ *
+ * Regenerate with:
+ *   node cli/scripts/gen-workflow-fields.mjs   (runs automatically at CLI prebuild)
+ *
+ * A CI freshness guard (`cli/scripts/gen-workflow-fields.mjs --check`, also
+ * asserted by `cli/tests/unit/workflow-field-descriptor-drift-guard.test.ts`)
+ * fails if this committed artifact does not match a fresh parse of
+ * `models.yaml`. The same test asserts every field below is classified in
+ * `cli/src/lib/workflow-field-descriptor.ts` as synced, structural, or
+ * internal — so a new server-side workflow field cannot be silently ignored by
+ * the CLI.
+ */
+/** Every `WorkflowDefinition` field, in `models.yaml` declaration order (#2326). */
+export const GENERATED_WORKFLOW_MODEL_FIELDS = [
+    "workflowId",
+    "appId",
+    "workflowKey",
+    "name",
+    "status",
+    "latestRevision",
+    "description",
+    "stepsR2Key",
+    "draftStepsR2Key",
+    "draftInputSchema",
+    "draftOutputSchema",
+    "draftModifiedAt",
+    "activeConfigId",
+    "inputSchema",
+    "outputSchema",
+    "perUserMaxRunning",
+    "perUserMaxQueued",
+    "perAppMaxRunning",
+    "perAppMaxQueued",
+    "queueTtlSeconds",
+    "dequeueOrder",
+    "requiresClientApply",
+    "syncCallable",
+    "accessRule",
+    "metadataManifest",
+    "runAs",
+    "lock",
+    "capabilities",
+    "createdBy",
+    "createdAt",
+    "modifiedAt",
+];
+//# sourceMappingURL=generated-workflow-model-fields.js.map

package/dist/src/lib/generated-workflow-model-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated-workflow-model-fields.js","sourceRoot":"","sources":["../../../src/lib/generated-workflow-model-fields.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,oFAAoF;AACpF,MAAM,CAAC,MAAM,+BAA+B,GAAsB;IAChE,YAAY;IACZ,OAAO;IACP,aAAa;IACb,MAAM;IACN,QAAQ;IACR,gBAAgB;IAChB,aAAa;IACb,YAAY;IACZ,iBAAiB;IACjB,kBAAkB;IAClB,mBAAmB;IACnB,iBAAiB;IACjB,gBAAgB;IAChB,aAAa;IACb,cAAc;IACd,mBAAmB;IACnB,kBAAkB;IAClB,kBAAkB;IAClB,iBAAiB;IACjB,iBAAiB;IACjB,cAAc;IACd,qBAAqB;IACrB,cAAc;IACd,YAAY;IACZ,kBAAkB;IAClB,OAAO;IACP,MAAM;IACN,cAAc;IACd,WAAW;IACX,WAAW;IACX,YAAY;CACb,CAAC"}

package/dist/src/lib/google-client-secret-status.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The operator-facing warning for an app whose stored `googleClientSecret` is
+ * not a `{{secrets.KEY}}` reference (#2256, #2307).
+ *
+ * The server never sends such a value back: `GET /settings` omits the key and
+ * reports `googleClientSecretStatus` in its place, so the only way an operator
+ * learns the field is still unmigrated is a command that reads the status and
+ * says so. Two do — `apps get` and `config pull` — and
+ * each has two statuses to describe, so the wording lives here once and the
+ * call sites supply only what genuinely differs: how the field is named in that
+ * context, where the value is missing from, and what the un-migrated value
+ * blocks.
+ *
+ * Modelled on `signingSecretStatusWarning` (the same problem for
+ * `webhook.signingSecret`), deliberately kept as a separate function: the
+ * remediation names a different TOML key, and a `legacy-literal` blocks
+ * different things on the two fields.
+ *
+ * Returns `null` for a status that needs no warning (`reference`, `unset`, or
+ * anything a newer server adds), so a call site is one `if` rather than two.
+ */
+export declare function googleClientSecretStatusWarning(status: string | null | undefined, context: {
+    /** How to name the field, e.g. `"googleClientSecret"`. Starts the sentence. */
+    subject: string;
+    /** Where the value is missing from, e.g. `"this output"`. */
+    withheldFrom: string;
+    /**
+     * What an un-migrated value blocks, e.g. `"the next settings write will be
+     * rejected"`. Every settings write on such an app fails unless it carries a
+     * `googleClientSecret` that migrates the field
+     * (`validateGoogleClientSecretMigration`), and a pulled `app.toml` never
+     * carries one — so for the pull paths this is the concrete consequence.
+     */
+    blocks: string;
+}): string | null;

package/dist/src/lib/google-client-secret-status.js

@@ -0,0 +1,56 @@
+/**
+ * The operator-facing warning for an app whose stored `googleClientSecret` is
+ * not a `{{secrets.KEY}}` reference (#2256, #2307).
+ *
+ * The server never sends such a value back: `GET /settings` omits the key and
+ * reports `googleClientSecretStatus` in its place, so the only way an operator
+ * learns the field is still unmigrated is a command that reads the status and
+ * says so. Two do — `apps get` and `config pull` — and
+ * each has two statuses to describe, so the wording lives here once and the
+ * call sites supply only what genuinely differs: how the field is named in that
+ * context, where the value is missing from, and what the un-migrated value
+ * blocks.
+ *
+ * Modelled on `signingSecretStatusWarning` (the same problem for
+ * `webhook.signingSecret`), deliberately kept as a separate function: the
+ * remediation names a different TOML key, and a `legacy-literal` blocks
+ * different things on the two fields.
+ *
+ * Returns `null` for a status that needs no warning (`reference`, `unset`, or
+ * anything a newer server adds), so a call site is one `if` rather than two.
+ */
+export function googleClientSecretStatusWarning(status, context) {
+    const remediation = "Store the value with `primitive secrets set KEY --value <value>` and set " +
+        'googleClientSecret = "{{secrets.KEY}}".';
+    if (status === "legacy-literal") {
+        return (`${context.subject} still holds a raw value rather than a {{secrets.KEY}} reference, ` +
+            `so it is withheld from ${context.withheldFrom}. Google sign-in keeps working, but the ` +
+            `value is deprecated and ${context.blocks} until it is migrated. ${remediation}`);
+    }
+    // Not a working legacy literal: the stored value carries reference syntax
+    // that resolves to nothing, so Google sign-in is already failing (#2332).
+    //
+    // Two deliberate differences from the branch above, both to keep the
+    // rendered settings output byte-identical to what PR #2293 shipped:
+    //
+    //   - `context.blocks` is unused. A push of the pulled file is rejected for
+    //     this status too (`validateGoogleClientSecretMigration` gates on
+    //     `isWithheldSecretStatus`, which covers both), but the sign-in outage is
+    //     the louder problem and the remediation below already fixes both. The
+    //     sibling `signingSecretStatusWarning` drops `blocks` in its malformed
+    //     branch the same way.
+    //   - The remediation sentence is written out rather than interpolating the
+    //     `remediation` constant above: this one says "the real client secret",
+    //     which the shared sentence does not.
+    //
+    // Both are worth revisiting together if `apps get`'s wording is ever
+    // allowed to change.
+    if (status === "malformed-reference") {
+        return (`${context.subject} is neither a {{secrets.KEY}} reference nor a plain stored value — it ` +
+            `carries reference syntax that does not resolve, so it is withheld from ${context.withheldFrom} ` +
+            "and Google sign-in is already FAILING. Store the real client secret with " +
+            '`primitive secrets set KEY --value <value>` and set googleClientSecret = "{{secrets.KEY}}".');
+    }
+    return null;
+}
+//# sourceMappingURL=google-client-secret-status.js.map

package/dist/src/lib/google-client-secret-status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-client-secret-status.js","sourceRoot":"","sources":["../../../src/lib/google-client-secret-status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,+BAA+B,CAC7C,MAAiC,EACjC,OAaC;IAED,MAAM,WAAW,GACf,2EAA2E;QAC3E,yCAAyC,CAAC;IAC5C,IAAI,MAAM,KAAK,gBAAgB,EAAE,CAAC;QAChC,OAAO,CACL,GAAG,OAAO,CAAC,OAAO,oEAAoE;YACtF,0BAA0B,OAAO,CAAC,YAAY,0CAA0C;YACxF,2BAA2B,OAAO,CAAC,MAAM,0BAA0B,WAAW,EAAE,CACjF,CAAC;IACJ,CAAC;IACD,0EAA0E;IAC1E,0EAA0E;IAC1E,EAAE;IACF,qEAAqE;IACrE,oEAAoE;IACpE,EAAE;IACF,4EAA4E;IAC5E,sEAAsE;IACtE,8EAA8E;IAC9E,2EAA2E;IAC3E,2EAA2E;IAC3E,2BAA2B;IAC3B,4EAA4E;IAC5E,4EAA4E;IAC5E,0CAA0C;IAC1C,EAAE;IACF,qEAAqE;IACrE,qBAAqB;IACrB,IAAI,MAAM,KAAK,qBAAqB,EAAE,CAAC;QACrC,OAAO,CACL,GAAG,OAAO,CAAC,OAAO,wEAAwE;YAC1F,0EAA0E,OAAO,CAAC,YAAY,GAAG;YACjG,2EAA2E;YAC3E,6FAA6F,CAC9F,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

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

@@ -0,0 +1,16 @@
+import { type ProjectConfig, type ProjectEnvironment } from "./project-config.js";
+export interface AdoptedEnvironment {
+    name: string;
+    config: ProjectEnvironment;
+    projectConfig: ProjectConfig;
+    projectConfigPath: string;
+}
+/**
+ * Resolves the environment `init` adopts from the project rooted at `root`.
+ * Throws whatever the loader or the selector throws — a broken or ambiguous
+ * project config must stop the run, not be guessed around.
+ */
+export declare function resolveAdoptedEnvironment(root: string, options?: {
+    explicitEnvName?: string | null;
+    envVarName?: string | null;
+}): AdoptedEnvironment;

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

@@ -0,0 +1,34 @@
+/**
+ * Reading the app identity out of the project a run is adopting (#2890).
+ *
+ * `getCurrentEnvironment()` resolves from the process's working directory,
+ * which is not necessarily inside the project being adopted — `primitive init
+ * ../ios` resolves against the TARGET, not the cwd. This resolves the same
+ * precedence order (`--env` -> `PRIMITIVE_ENV` -> this machine's selection ->
+ * the committed default -> the sole environment) against an explicit root.
+ */
+import { join } from "path";
+import { readLocalSelection, selectEnvironmentName } from "./env-resolver-core.js";
+import { PROJECT_TREE_DIR, PROJECT_CONFIG_FILENAME, loadProjectConfigFromPath, } from "./project-config.js";
+/**
+ * Resolves the environment `init` adopts from the project rooted at `root`.
+ * Throws whatever the loader or the selector throws — a broken or ambiguous
+ * project config must stop the run, not be guessed around.
+ */
+export function resolveAdoptedEnvironment(root, options = {}) {
+    const projectConfigPath = join(root, PROJECT_TREE_DIR, PROJECT_CONFIG_FILENAME);
+    const projectConfig = loadProjectConfigFromPath(projectConfigPath);
+    const { name } = selectEnvironmentName(projectConfig, {
+        explicitEnvName: options.explicitEnvName ?? null,
+        envVarName: options.envVarName ?? null,
+        localSelection: readLocalSelection(projectConfigPath),
+        configPath: projectConfigPath,
+    });
+    return {
+        name,
+        config: projectConfig.environments[name],
+        projectConfig,
+        projectConfigPath,
+    };
+}
+//# sourceMappingURL=init-adopt.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"init-adopt.js","sourceRoot":"","sources":["../../../src/lib/init-adopt.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AACnF,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,yBAAyB,GAG1B,MAAM,qBAAqB,CAAC;AAS7B;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CACvC,IAAY,EACZ,UAA2E,EAAE;IAE7E,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,EAAE,gBAAgB,EAAE,uBAAuB,CAAC,CAAC;IAChF,MAAM,aAAa,GAAG,yBAAyB,CAAC,iBAAiB,CAAC,CAAC;IACnE,MAAM,EAAE,IAAI,EAAE,GAAG,qBAAqB,CAAC,aAAoB,EAAE;QAC3D,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,IAAI;QAChD,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,IAAI;QACtC,cAAc,EAAE,kBAAkB,CAAC,iBAAiB,CAAC;QACrD,UAAU,EAAE,iBAAiB;KAC9B,CAAC,CAAC;IACH,OAAO;QACL,IAAI;QACJ,MAAM,EAAE,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC;QACxC,aAAa;QACb,iBAAiB;KAClB,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,39 @@
+/**
+ * The files `primitive init` writes at the ROOT of a repository that holds
+ * several clients of one Primitive app (#2890).
+ *
+ * These are app-wide, not client-wide: each client's own `AGENTS.md`,
+ * `package.json`, runtime config and dependencies ship with its template. What
+ * belongs here is only what the clients share — which is exactly the part a
+ * team otherwise has to reverse-engineer.
+ */
+import type { Platform } from "./resolve-platform.js";
+/** Human label for a platform, used in generated prose and summaries. */
+export declare function platformLabel(platform: Platform): string;
+/**
+ * The header prepended to the canonical `models/models.toml`.
+ *
+ * The schema is not client state: its TOML keys are the wire field names, so a
+ * second copy that drifts orphans the first one's records. Saying so in the
+ * file is the cheapest place for a reader to find that rule.
+ */
+export declare const CANONICAL_SCHEMA_HEADER = "# The model schema for this app \u2014 ONE copy, shared by every client.\n#\n# The TOML keys here are the wire field names, so a second copy that drifts\n# orphans the other one's records. Every client reads THIS file:\n#   - the web client's codegen input points at it, and its generated barrel\n#     imports it directly\n#   - the Swift client names it in `bao-codegen.json` beside its sources\n# Add or change a model here, then re-run each client's codegen.\n";
+/**
+ * A starter schema for the rare composition that has no template starter to
+ * adopt. The scaffolded clients normally supply their own, which is what a
+ * composed repo promotes to the root.
+ */
+export declare const FALLBACK_STARTER_SCHEMA = "[models.user_prefs.fields.id]\ntype = \"id\"\nauto_assign = true\nindexed = true\nrequired = true\n\n[models.user_prefs.fields.key]\ntype = \"string\"\nindexed = true\nunique = true\n\n[models.user_prefs.fields.value]\ntype = \"string\"\n";
+/**
+ * The app-wide `AGENTS.md` for a repository with several clients.
+ *
+ * Written only when there is no `AGENTS.md` at the root already — a client's
+ * own file is never replaced by init.
+ */
+export declare function rootAgentsMarkdown(input: {
+    appName: string;
+    clients: Array<{
+        platform: Platform;
+        dir: string;
+    }>;
+}): string;

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

@@ -0,0 +1,97 @@
+/** Human label for a platform, used in generated prose and summaries. */
+export function platformLabel(platform) {
+    return platform === "ios" ? "iOS (SwiftUI)" : "Web (Vue)";
+}
+/**
+ * The header prepended to the canonical `models/models.toml`.
+ *
+ * The schema is not client state: its TOML keys are the wire field names, so a
+ * second copy that drifts orphans the first one's records. Saying so in the
+ * file is the cheapest place for a reader to find that rule.
+ */
+export const CANONICAL_SCHEMA_HEADER = `# The model schema for this app — ONE copy, shared by every client.
+#
+# The TOML keys here are the wire field names, so a second copy that drifts
+# orphans the other one's records. Every client reads THIS file:
+#   - the web client's codegen input points at it, and its generated barrel
+#     imports it directly
+#   - the Swift client names it in \`bao-codegen.json\` beside its sources
+# Add or change a model here, then re-run each client's codegen.
+`;
+/**
+ * A starter schema for the rare composition that has no template starter to
+ * adopt. The scaffolded clients normally supply their own, which is what a
+ * composed repo promotes to the root.
+ */
+export const FALLBACK_STARTER_SCHEMA = `[models.user_prefs.fields.id]
+type = "id"
+auto_assign = true
+indexed = true
+required = true
+
+[models.user_prefs.fields.key]
+type = "string"
+indexed = true
+unique = true
+
+[models.user_prefs.fields.value]
+type = "string"
+`;
+/**
+ * The app-wide `AGENTS.md` for a repository with several clients.
+ *
+ * Written only when there is no `AGENTS.md` at the root already — a client's
+ * own file is never replaced by init.
+ */
+export function rootAgentsMarkdown(input) {
+    const rows = input.clients
+        .map((client) => `- \`${client.dir}/\` — ${platformLabel(client.platform)} client`)
+        .join("\n");
+    return `# ${input.appName}
+
+One Primitive app, several clients. The app is the shared thing: one app ID,
+one set of environments, one exported server config, one model schema. Each
+client is an independent project in its own directory — there is no workspace
+file and no root \`package.json\`.
+
+## Layout
+
+- \`primitive/config.json\` — the Primitive environments (backend URL + app ID
+  per environment). The single source of truth, for every client.
+- \`primitive/<env>/\` — the exported server config (workflows,
+  database type configs, app settings) that \`primitive config diff\` and
+  \`primitive config push\` read and write.
+- \`models/models.toml\` — the model schema. ONE copy: its keys are the wire
+  field names, so a second copy that drifts orphans the other's records. Each
+  client's codegen reads this file in place; never copy it into a client.
+${rows}
+
+## Per app vs per client
+
+| Per app (here, at the root) | Per client (in its directory) |
+| --- | --- |
+| Environments and app ID | Generated code |
+| Exported server config | Dependencies and build config |
+| Model schema | Runtime connection settings |
+| Secrets | Deploy configuration |
+| — | Its own \`AGENTS.md\` |
+
+## Running commands
+
+Every \`primitive\` command walks up to this directory's \`primitive/config.json\`,
+so it resolves the same app from any client directory and needs no path flag.
+\`primitive env use <name>\` selects the environment every command in this
+repository targets — it is an app-wide selection, not a per-client one.
+
+## Adding another client
+
+\`\`\`sh
+primitive init <dir> --platform <web|ios>
+\`\`\`
+
+Run from inside this repository, that adds a client to THIS app: it reuses this
+config, wires the new client to \`models/models.toml\`, and creates no second
+\`.primitive/\` and no second git repository.
+`;
+}
+//# sourceMappingURL=init-assets.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"init-assets.js","sourceRoot":"","sources":["../../../src/lib/init-assets.ts"],"names":[],"mappings":"AAWA,yEAAyE;AACzE,MAAM,UAAU,aAAa,CAAC,QAAkB;IAC9C,OAAO,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC;AAC5D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;;;CAQtC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;;;;;;;;CAatC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAGlC;IACC,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO;SACvB,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,OAAO,MAAM,CAAC,GAAG,SAAS,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;SAClF,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,OAAO,KAAK,KAAK,CAAC,OAAO;;;;;;;;;;;;;;;;;EAiBzB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BL,CAAC;AACF,CAAC"}

package/dist/src/lib/init-client-platforms.d.ts

@@ -0,0 +1,14 @@
+import type { Platform } from "./resolve-platform.js";
+/**
+ * The platform of the client in `dir`, or null when `dir` is not a client.
+ * The ONE definition of the template signals — the AGENTS.md client listing
+ * and the both-platforms predicate read it, so they cannot drift.
+ */
+export declare function detectClientPlatform(dir: string): Platform | null;
+/**
+ * Every platform already present under `projectRoot`, counting a client that
+ * IS the root. Deduplicated, in canonical order.
+ */
+export declare function discoverClientPlatforms(projectRoot: string): Platform[];
+/** Whether the app ends up with an iOS client AND a web client. */
+export declare function appHasBothPlatforms(planned: Platform[], discovered: Platform[]): boolean;

package/dist/src/lib/init-client-platforms.js

@@ -0,0 +1,71 @@
+/**
+ * Which client platforms an app HAS — the ones this run scaffolds plus the
+ * ones already in the repository (#2982).
+ *
+ * An app with both an iOS and a web client gets the universal-link wiring: the
+ * emailed sign-in link becomes the web deployment's https callback, which
+ * opens the installed app and still signs in from any browser. So "does this
+ * app have both?" decides whether init seeds a `webUrl` and prints the
+ * activation checklist.
+ *
+ * The existing clients are found by the signals the templates ship — a Swift
+ * package or Xcode project, a Vite project — so a `functions/` directory with
+ * a `package.json` is not mistaken for a client. They are looked for in child
+ * directories AND at the project root: `primitive init` still produces the
+ * flat single-client layout where the client IS the repository root, and
+ * adding the second platform to such a repository is exactly the case this
+ * feature exists for (DSO-2982-013).
+ */
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+/**
+ * The platform of the client in `dir`, or null when `dir` is not a client.
+ * The ONE definition of the template signals — the AGENTS.md client listing
+ * and the both-platforms predicate read it, so they cannot drift.
+ */
+export function detectClientPlatform(dir) {
+    let hasXcodeProject = false;
+    try {
+        hasXcodeProject = readdirSync(dir).some((name) => name.endsWith(".xcodeproj"));
+    }
+    catch {
+        return null;
+    }
+    if (existsSync(join(dir, "Package.swift")) || hasXcodeProject)
+        return "ios";
+    if (existsSync(join(dir, "package.json")) && existsSync(join(dir, "vite.config.ts"))) {
+        return "web";
+    }
+    return null;
+}
+/**
+ * Every platform already present under `projectRoot`, counting a client that
+ * IS the root. Deduplicated, in canonical order.
+ */
+export function discoverClientPlatforms(projectRoot) {
+    const found = new Set();
+    const atRoot = detectClientPlatform(projectRoot);
+    if (atRoot)
+        found.add(atRoot);
+    let entries;
+    try {
+        entries = readdirSync(projectRoot, { withFileTypes: true });
+    }
+    catch {
+        entries = [];
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith("."))
+            continue;
+        const platform = detectClientPlatform(join(projectRoot, entry.name));
+        if (platform)
+            found.add(platform);
+    }
+    return ["web", "ios"].filter((platform) => found.has(platform));
+}
+/** Whether the app ends up with an iOS client AND a web client. */
+export function appHasBothPlatforms(planned, discovered) {
+    const platforms = new Set([...planned, ...discovered]);
+    return platforms.has("ios") && platforms.has("web");
+}
+//# sourceMappingURL=init-client-platforms.js.map

package/dist/src/lib/init-client-platforms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-client-platforms.js","sourceRoot":"","sources":["../../../src/lib/init-client-platforms.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,IAAI,CAAC;AAE7C,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAG5B;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAW;IAC9C,IAAI,eAAe,GAAG,KAAK,CAAC;IAC5B,IAAI,CAAC;QACH,eAAe,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC;IACjF,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC,IAAI,eAAe;QAAE,OAAO,KAAK,CAAC;IAC5E,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC;QACrF,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,WAAmB;IACzD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAY,CAAC;IAElC,MAAM,MAAM,GAAG,oBAAoB,CAAC,WAAW,CAAC,CAAC;IACjD,IAAI,MAAM;QAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAE9B,IAAI,OAAiB,CAAC;IACtB,IAAI,CAAC;QACH,OAAO,GAAG,WAAW,CAAC,WAAW,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;IAC9D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,GAAG,EAAE,CAAC;IACf,CAAC;IACD,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;YAAE,SAAS;QACjE,MAAM,QAAQ,GAAG,oBAAoB,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;QACrE,IAAI,QAAQ;YAAE,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACpC,CAAC;IAED,OAAQ,CAAC,KAAK,EAAE,KAAK,CAAW,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,mBAAmB,CACjC,OAAmB,EACnB,UAAsB;IAEtB,MAAM,SAAS,GAAG,IAAI,GAAG,CAAW,CAAC,GAAG,OAAO,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC;IACjE,OAAO,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACtD,CAAC"}

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

@@ -0,0 +1,98 @@
+export declare const INIT_CONFIG_FILENAME = ".primitive-init.toml";
+export interface InitConfig {
+    /**
+     * What this run does with the app:
+     *   - `create`       — make a new app (needs `app_name`)
+     *   - `use-existing` — scaffold against an app that already exists (needs `app_id`)
+     *   - `add-client`   — add another client to the Primitive app the surrounding
+     *     project already targets (#2890). The app comes from the selected
+     *     environment of the nearest ancestor `primitive/config.json`, so this
+     *     action names no app of its own.
+     */
+    action: "create" | "use-existing" | "add-client";
+    /** App name (required for action = "create") */
+    app_name?: string;
+    /** Existing app ID (required for action = "use-existing") */
+    app_id?: string;
+    /** Project directory name */
+    dir?: string;
+    /** Access mode for the app */
+    access_mode?: "public" | "domain" | "invite-only";
+    /** Port for local dev server */
+    dev_port?: number;
+    /** Whether to skip npm install */
+    skip_install?: boolean;
+    /**
+     * Custom server URL. Behaves like the `-s/--server` flag: the app is created
+     * on this server and the scaffolded project config records it. The flag wins
+     * when both are given. (#2376)
+     */
+    server?: string;
+    /** Email addresses to invite (for invite-only mode) */
+    invite_emails?: string[];
+    /** Allowed email domains (for domain mode) */
+    allowed_domains?: string[];
+    /** Whether to overwrite a non-empty target directory (default: false) */
+    overwrite?: boolean;
+    /**
+     * Target platform(s) for the scaffolded client(s): `"web"`, `"ios"`, a
+     * comma-separated string, or a TOML array (`platform = ["web", "ios"]`).
+     */
+    platform?: string | string[];
+    /**
+     * Non-interactive consent to move an existing single-client repo's model
+     * schema to `<project root>/models/models.toml` so both clients read one copy
+     * (#2890). Valid only with `action = "add-client"`.
+     */
+    promote_schema?: boolean;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Resolves the "use an existing app" app id from the two places it can be
+ * specified: the `--use-existing-app-id` CLI flag (highest precedence) or an
+ * init-config TOML with `action = "use-existing"` + `app_id`.
+ *
+ * Before this existed, `init` only read the flag, so a `use-existing` TOML fell
+ * through to the create-app branch and interactively prompted for an app name —
+ * hanging non-interactive (`--config`) runs. (See js-bao-wss #1217.)
+ *
+ * Returns `undefined` when neither source selects an existing app (i.e. the run
+ * should create a new app).
+ */
+export declare function resolveUseExistingAppId(flag: string | undefined, initConfig: InitConfig | null): string | undefined;
+/** Where the resolved "skip dependency install" decision came from. */
+export type SkipInstallSource = "flag" | "config" | "default";
+export interface ResolvedSkipInstall {
+    skipInstall: boolean;
+    source: SkipInstallSource;
+}
+/**
+ * Resolves whether `primitive init` skips the dependency install, from the two
+ * places it can be requested: the `--skip-install` flag (highest precedence)
+ * or `skip_install = true` in the init-config TOML.
+ *
+ * `init` used to read only the flag, so a config's `skip_install` was silently
+ * ignored and CI runs installed anyway (#2720). Precedence matches #2376's
+ * `server` fix: the flag wins. Because `--skip-install` is a boolean flag it
+ * can only ever request a skip, so an explicit `skip_install = false` in the
+ * config cannot un-skip a run that passed the flag.
+ */
+export declare function resolveSkipInstall(flag: boolean | undefined, initConfig: InitConfig | null): ResolvedSkipInstall;
+/**
+ * Parses a TOML string into an InitConfig object.
+ * Throws if the string contains invalid TOML.
+ */
+export declare function parseInitConfigToml(content: string): InitConfig;
+/**
+ * Loads and parses a .primitive-init.toml file from the given directory.
+ * Returns null if the file does not exist.
+ * Throws if the file exists but contains invalid TOML.
+ */
+export declare function loadInitConfig(dir: string): InitConfig | null;
+/**
+ * Validates an InitConfig object. Returns a ValidationResult with any errors.
+ */
+export declare function validateInitConfig(config: InitConfig): ValidationResult;