@ggui-ai/cli 0.2.0-alpha.4 → 0.3.0-rc.0

package/dist/config-push.d.ts

@@ -0,0 +1,79 @@
+import { type GadgetDescriptor, type AppTheme } from '@ggui-ai/protocol';
+/**
+ * Extract and validate `app.gadgets` from a decoded ggui.json value.
+ *
+ * Returns `[]` when the field is absent.
+ * Throws with a descriptive message when any descriptor is malformed
+ * (schema parse fails).
+ */
+export declare function readGadgetsFromGguiJson(gguiJson: unknown): GadgetDescriptor[];
+/**
+ * Extract and validate `app.publicEnv` from a decoded ggui.json value.
+ *
+ * Returns `{}` when the field is absent.
+ * Throws with a descriptive message when any key/value is invalid.
+ * Keys must match `PUBLIC_ENV_APP_KEY_RE` (`GGUI_PUBLIC_APP_<NAME>`).
+ */
+export declare function readPublicEnvFromGguiJson(gguiJson: unknown): Record<string, string>;
+/**
+ * Extract and validate `generation` from a decoded ggui.json value.
+ *
+ * Reads the RAW model string (not a resolved `LlmRoute`) — the cloud
+ * re-validates via `parseAnyLlmRoute` server-side; the CLI just forwards.
+ *
+ * Returns `{ model, keySource }` when `generation.model` is present.
+ * Returns `undefined` when the generation block is absent or has no model.
+ * Throws when the generation block is structurally invalid.
+ */
+export declare function readGenerationFromGguiJson(gguiJson: unknown): {
+    model: string;
+    keySource: 'own' | 'managed';
+} | undefined;
+/**
+ * Resolve the developer's local `ggui.json#theme` into a concrete,
+ * injection-safe {@link AppTheme} ready to PATCH to the cloud.
+ *
+ * Returns `undefined` when no `theme` field is declared (deploy leaves the
+ * app's theme untouched).
+ *
+ * When a theme IS declared we parse the FULL manifest (via `parseGguiJson`)
+ * — `loadTheme` requires the typed `GguiJsonV1` shape and resolves relative
+ * `theme.file` paths against `projectRoot`, so a partial slice will not do.
+ *
+ * Throws with a clear, local message when:
+ *   - the manifest is structurally invalid (so deploy fails before the wire);
+ *   - the theme cannot be loaded (e.g. an unregistered preset id);
+ *   - the resolved overlay fails `appThemeSchema` — the SAME validator the
+ *     backend enforces, so a deploy fails loud LOCALLY rather than with a
+ *     confusing 422.
+ */
+export declare function readThemeFromGguiJson(projectRoot: string, gguiJson: unknown): AppTheme | undefined;
+/**
+ * Assert that none of the gadget bundle references point at a loopback host.
+ *
+ * `LOOPBACK_HOST_RE` matches bare hosts (no scheme, optional `:port`):
+ *   - `localhost` / `localhost:3000`
+ *   - `127.0.0.1` / `127.0.0.1:8080`
+ *   - `0.0.0.0` / `0.0.0.0:4321`
+ *
+ * Resolution order for "bundle host":
+ *   1. `bundleHost` (bare hostname, already scheme-free)
+ *   2. `bundleUrl` parsed via `new URL()` → `.host` (includes port)
+ *   3. Neither present → gadget has no cloud bundle reference; passes.
+ *
+ * Throws an `Error` with a remediation hint when a loopback is detected.
+ */
+export declare function assertGadgetBundlesReachable(gadgets: GadgetDescriptor[]): void;
+/**
+ * Find + read `ggui.json`, validate gadgets + publicEnv, guard against
+ * loopback bundles, then PATCH the app config via the REST API.
+ *
+ * @param appId  - The ggui app ID to patch.
+ * @param startDir - Optional start directory for `findGguiJson` (defaults to
+ *                   `process.cwd()`). Primarily used for testing.
+ * @returns 0 on success, 1 on any error (malformed ggui.json, loopback bundle,
+ *          network failure). Errors are written to stderr; success summary to
+ *          stdout.
+ */
+export declare function runConfigPushStep(appId: string, startDir?: string): Promise<number>;
+//# sourceMappingURL=config-push.d.ts.map

package/dist/config-push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-push.d.ts","sourceRoot":"","sources":["../src/config-push.ts"],"names":[],"mappings":"AAUA,OAAO,EAKL,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EACd,MAAM,mBAAmB,CAAC;AAU3B;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,OAAO,GAAG,gBAAgB,EAAE,CAqB7E;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAmBnF;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,OAAO,GAChB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,KAAK,GAAG,SAAS,CAAA;CAAE,GAAG,SAAS,CAkB7D;AA4BD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,OAAO,GAChB,QAAQ,GAAG,SAAS,CA4CtB;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAiB9E;AAMD;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,MAAM,EACb,QAAQ,GAAE,MAAsB,GAC/B,OAAO,CAAC,MAAM,CAAC,CA8FjB"}

package/dist/config-push.js

@@ -0,0 +1,301 @@
+/**
+ * `config-push` — read `ggui.json#app.{gadgets,publicEnv}` and
+ * `ggui.json#generation`, guard against loopback bundle URLs, and PATCH the
+ * cloud app config via the REST API.
+ *
+ * Consumed by `ggui deploy` (M3.3) — wiring into that command is a separate
+ * task. This module is the pure logic layer: readers + guard + network call.
+ */
+import process from 'node:process';
+import { dirname } from 'node:path';
+import { strictGadgetDescriptorSchema, appPublicEnvSchema, appThemeSchema, LOOPBACK_HOST_RE, } from '@ggui-ai/protocol';
+import { loadTheme, parseGguiJson } from '@ggui-ai/project-config/node';
+import { z } from 'zod';
+import { patchAppConfig } from './api-client.js';
+import { findGguiJson, readGguiJson } from './internal/ggui-json.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// Readers
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Extract and validate `app.gadgets` from a decoded ggui.json value.
+ *
+ * Returns `[]` when the field is absent.
+ * Throws with a descriptive message when any descriptor is malformed
+ * (schema parse fails).
+ */
+export function readGadgetsFromGguiJson(gguiJson) {
+    // Navigate to `app.gadgets` via a nested schema rather than casting +
+    // index access. `z.object` is non-strict by default, so ggui.json's other
+    // fields (schema / protocol / generation / app.publicEnv / …) ride through
+    // as allowed-and-stripped extras — only `app.gadgets` is validated here.
+    const schema = z.object({
+        app: z
+            .object({
+            gadgets: z.array(strictGadgetDescriptorSchema).optional(),
+        })
+            .optional(),
+    });
+    const result = schema.safeParse(gguiJson);
+    if (!result.success) {
+        throw new Error(`ggui.json: app.gadgets is invalid — ${result.error.issues[0]?.message ?? 'malformed descriptor'}`);
+    }
+    // result.data.app?.gadgets is GadgetDescriptor[] — strictGadgetDescriptorSchema
+    // parses to the same shape as GadgetDescriptor. Spread to a fresh mutable array.
+    return [...(result.data.app?.gadgets ?? [])];
+}
+/**
+ * Extract and validate `app.publicEnv` from a decoded ggui.json value.
+ *
+ * Returns `{}` when the field is absent.
+ * Throws with a descriptive message when any key/value is invalid.
+ * Keys must match `PUBLIC_ENV_APP_KEY_RE` (`GGUI_PUBLIC_APP_<NAME>`).
+ */
+export function readPublicEnvFromGguiJson(gguiJson) {
+    // Navigate to `app.publicEnv` via a nested schema (same posture as
+    // readGadgetsFromGguiJson) — other ggui.json fields ride through as
+    // allowed-and-stripped extras; only `app.publicEnv` is validated here.
+    const schema = z.object({
+        app: z
+            .object({
+            publicEnv: appPublicEnvSchema.optional(),
+        })
+            .optional(),
+    });
+    const result = schema.safeParse(gguiJson);
+    if (!result.success) {
+        throw new Error(`ggui.json: app.publicEnv is invalid — keys must match GGUI_PUBLIC_APP_<NAME>: ${result.error.issues[0]?.message ?? 'invalid entry'}`);
+    }
+    // appPublicEnvSchema returns a readonly record; spread to a fresh mutable one.
+    return { ...(result.data.app?.publicEnv ?? {}) };
+}
+/**
+ * Extract and validate `generation` from a decoded ggui.json value.
+ *
+ * Reads the RAW model string (not a resolved `LlmRoute`) — the cloud
+ * re-validates via `parseAnyLlmRoute` server-side; the CLI just forwards.
+ *
+ * Returns `{ model, keySource }` when `generation.model` is present.
+ * Returns `undefined` when the generation block is absent or has no model.
+ * Throws when the generation block is structurally invalid.
+ */
+export function readGenerationFromGguiJson(gguiJson) {
+    const schema = z.object({
+        generation: z
+            .object({
+            model: z.string().min(1).optional(),
+            keySource: z.enum(['own', 'managed']).optional(),
+        })
+            .optional(),
+    });
+    const result = schema.safeParse(gguiJson);
+    if (!result.success) {
+        throw new Error(`ggui.json: generation is invalid — ${result.error.issues[0]?.message ?? 'malformed generation block'}`);
+    }
+    const model = result.data.generation?.model;
+    if (!model)
+        return undefined;
+    return { model, keySource: result.data.generation?.keySource ?? 'managed' };
+}
+/**
+ * Parse a generated `:root { --ggui-x: val; … }` block into a flat
+ * `{ '--ggui-x': 'val' }` map.
+ *
+ * The block is machine-generated by `@ggui-ai/design`'s theme parser
+ * (one `--ggui-*: value;` declaration per line, wrapped in a `:root {…}`
+ * selector), so a line-based parse is deterministic:
+ *   - split on newlines;
+ *   - on each line, split at the FIRST `:` (custom-property names never
+ *     contain `:`, so the key is unambiguous even when the value does);
+ *   - keep only `--ggui-*`-prefixed keys with a non-empty value. The
+ *     `:root {` and `}` wrapper lines have no such key and drop out.
+ */
+function parseCssVarBlock(css) {
+    const out = {};
+    for (const line of css.split('\n')) {
+        const i = line.indexOf(':');
+        if (i === -1)
+            continue;
+        const key = line.slice(0, i).trim();
+        let val = line.slice(i + 1).trim();
+        if (val.endsWith(';'))
+            val = val.slice(0, -1).trim();
+        if (key.startsWith('--ggui-') && val.length > 0)
+            out[key] = val;
+    }
+    return out;
+}
+/**
+ * Resolve the developer's local `ggui.json#theme` into a concrete,
+ * injection-safe {@link AppTheme} ready to PATCH to the cloud.
+ *
+ * Returns `undefined` when no `theme` field is declared (deploy leaves the
+ * app's theme untouched).
+ *
+ * When a theme IS declared we parse the FULL manifest (via `parseGguiJson`)
+ * — `loadTheme` requires the typed `GguiJsonV1` shape and resolves relative
+ * `theme.file` paths against `projectRoot`, so a partial slice will not do.
+ *
+ * Throws with a clear, local message when:
+ *   - the manifest is structurally invalid (so deploy fails before the wire);
+ *   - the theme cannot be loaded (e.g. an unregistered preset id);
+ *   - the resolved overlay fails `appThemeSchema` — the SAME validator the
+ *     backend enforces, so a deploy fails loud LOCALLY rather than with a
+ *     confusing 422.
+ */
+export function readThemeFromGguiJson(projectRoot, gguiJson) {
+    // Cheap pre-check on the raw value: no `theme` field → nothing to push,
+    // and we avoid forcing a full-manifest parse on theme-less deploys.
+    const presence = z
+        .object({ theme: z.unknown().optional() })
+        .safeParse(gguiJson);
+    if (!presence.success || presence.data.theme === undefined)
+        return undefined;
+    // A theme is declared — `loadTheme` needs the fully-typed manifest.
+    let manifest;
+    try {
+        manifest = parseGguiJson(gguiJson);
+    }
+    catch (err) {
+        throw new Error(`ggui.json: cannot resolve theme — manifest is invalid: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const result = loadTheme({ projectRoot, manifest });
+    if (!result.ok) {
+        throw new Error(`ggui.json: ${result.issue.message}`);
+    }
+    const loaded = result.theme;
+    const theme = {
+        mode: loaded.mode,
+        cssVariables: parseCssVarBlock(loaded.cssVariables),
+        ...(loaded.source === 'preset' ? { name: loaded.preset } : {}),
+    };
+    // Defense + clear local error: the resolved overlay must satisfy the same
+    // schema the backend enforces, so a deploy fails loud LOCALLY (not with a
+    // confusing 422) if a token ever produces an unsafe value.
+    const parsed = appThemeSchema.safeParse(theme);
+    if (!parsed.success) {
+        throw new Error(`ggui.json: resolved theme is invalid — ${parsed.error.issues[0]?.message ?? 'unexpected css value'}`);
+    }
+    return parsed.data;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Loopback guard
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Assert that none of the gadget bundle references point at a loopback host.
+ *
+ * `LOOPBACK_HOST_RE` matches bare hosts (no scheme, optional `:port`):
+ *   - `localhost` / `localhost:3000`
+ *   - `127.0.0.1` / `127.0.0.1:8080`
+ *   - `0.0.0.0` / `0.0.0.0:4321`
+ *
+ * Resolution order for "bundle host":
+ *   1. `bundleHost` (bare hostname, already scheme-free)
+ *   2. `bundleUrl` parsed via `new URL()` → `.host` (includes port)
+ *   3. Neither present → gadget has no cloud bundle reference; passes.
+ *
+ * Throws an `Error` with a remediation hint when a loopback is detected.
+ */
+export function assertGadgetBundlesReachable(gadgets) {
+    for (const g of gadgets) {
+        let host;
+        if (g.bundleHost !== undefined) {
+            host = g.bundleHost;
+        }
+        else if (g.bundleUrl !== undefined) {
+            host = new URL(g.bundleUrl).host;
+        }
+        if (host !== undefined && LOOPBACK_HOST_RE.test(host)) {
+            throw new Error(`gadget ${g.package}'s bundle is local-only (${host}) — publish it to a ` +
+                `cloud-reachable registry (run \`ggui gadget publish\`) before deploy.`);
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Orchestrator
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Find + read `ggui.json`, validate gadgets + publicEnv, guard against
+ * loopback bundles, then PATCH the app config via the REST API.
+ *
+ * @param appId  - The ggui app ID to patch.
+ * @param startDir - Optional start directory for `findGguiJson` (defaults to
+ *                   `process.cwd()`). Primarily used for testing.
+ * @returns 0 on success, 1 on any error (malformed ggui.json, loopback bundle,
+ *          network failure). Errors are written to stderr; success summary to
+ *          stdout.
+ */
+export async function runConfigPushStep(appId, startDir = process.cwd()) {
+    const gguiJsonPath = findGguiJson(startDir);
+    if (!gguiJsonPath) {
+        process.stderr.write('ggui deploy: could not find ggui.json (looked up to 8 parent directories).\n');
+        return 1;
+    }
+    const readResult = readGguiJson(gguiJsonPath);
+    if ('error' in readResult) {
+        process.stderr.write(`ggui deploy: ${readResult.error}\n`);
+        return 1;
+    }
+    let gadgets;
+    let publicEnv;
+    let generation;
+    let theme;
+    try {
+        gadgets = readGadgetsFromGguiJson(readResult.value);
+    }
+    catch (err) {
+        process.stderr.write(`ggui deploy: ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    try {
+        publicEnv = readPublicEnvFromGguiJson(readResult.value);
+    }
+    catch (err) {
+        process.stderr.write(`ggui deploy: ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    try {
+        generation = readGenerationFromGguiJson(readResult.value);
+    }
+    catch (err) {
+        process.stderr.write(`ggui deploy: ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    try {
+        // `loadTheme` resolves relative `theme.file` paths against the directory
+        // containing ggui.json — the same root convention `storage.*.path` uses.
+        theme = readThemeFromGguiJson(dirname(gguiJsonPath), readResult.value);
+    }
+    catch (err) {
+        process.stderr.write(`ggui deploy: ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    try {
+        assertGadgetBundlesReachable(gadgets);
+    }
+    catch (err) {
+        process.stderr.write(`ggui deploy: ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    try {
+        await patchAppConfig(appId, {
+            gadgets,
+            ...(Object.keys(publicEnv).length > 0 ? { publicEnv } : {}),
+            ...(generation !== undefined ? { generation } : {}),
+            ...(theme !== undefined ? { theme } : {}),
+        });
+    }
+    catch (err) {
+        process.stderr.write(`ggui deploy: config push failed — ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    const gadgetLine = gadgets.length > 0
+        ? `pushed ${gadgets.length} gadget extension(s)`
+        : 'no gadget extensions — cleared (stdlib still available)';
+    const envLine = Object.keys(publicEnv).length > 0
+        ? ` + ${Object.keys(publicEnv).length} publicEnv key(s)`
+        : '';
+    const generationLine = generation !== undefined ? ` + model ${generation.model}` : '';
+    const themeLine = theme !== undefined ? ` + theme ${theme.name ?? theme.mode}` : '';
+    process.stdout.write(`  ${gadgetLine}${envLine}${generationLine}${themeLine}\n`);
+    return 0;
+}

package/dist/create-app-command.d.ts

@@ -0,0 +1,17 @@
+export interface CreateAppFlags {
+    name?: string;
+    error?: string;
+}
+/**
+ * Parse the args that follow `ggui create`. The first element must be
+ * the literal string `'app'`; anything else is an error. Remaining
+ * elements are flag pairs (`--name <value>`).
+ */
+export declare function parseCreateAppFlags(args: readonly string[]): CreateAppFlags;
+/**
+ * Run `ggui create app [--name <displayName>]`.
+ *
+ * Returns 0 on success, 1 on API / I/O error, 2 on usage error.
+ */
+export declare function runCreateCommand(args: readonly string[]): Promise<number>;
+//# sourceMappingURL=create-app-command.d.ts.map

package/dist/create-app-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-app-command.d.ts","sourceRoot":"","sources":["../src/create-app-command.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,cAAc,CAc3E;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,OAAO,CAAC,MAAM,CAAC,CAuBjB"}

package/dist/create-app-command.js

@@ -0,0 +1,58 @@
+/**
+ * `ggui create app` — create a new app in the ggui.ai cloud and write
+ * the returned appId back into the local ggui.json (if one is found).
+ *
+ * Calls `POST /v1/apps` with an optional display name and prints the
+ * created app's id, connect URL, and default flag. When a ggui.json is
+ * found in the working-directory ancestor chain, the command updates
+ * (or adds) the `appId` field so subsequent `ggui deploy` invocations
+ * can pick it up automatically.
+ */
+import { createApp } from './api-client.js';
+import { findGguiJson, readGguiJson, writeGguiJson, } from './internal/ggui-json.js';
+/**
+ * Parse the args that follow `ggui create`. The first element must be
+ * the literal string `'app'`; anything else is an error. Remaining
+ * elements are flag pairs (`--name <value>`).
+ */
+export function parseCreateAppFlags(args) {
+    if (args[0] !== 'app') {
+        return {
+            error: `unknown create target: ${args[0] ?? '(none)'} (expected 'app')`,
+        };
+    }
+    const rest = args.slice(1);
+    const flags = {};
+    for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === '--name') {
+            flags.name = rest[++i];
+        }
+    }
+    return flags;
+}
+/**
+ * Run `ggui create app [--name <displayName>]`.
+ *
+ * Returns 0 on success, 1 on API / I/O error, 2 on usage error.
+ */
+export async function runCreateCommand(args) {
+    const flags = parseCreateAppFlags(args);
+    if (flags.error) {
+        process.stderr.write(`ggui create: ${flags.error}\n`);
+        return 2;
+    }
+    const app = await createApp({ displayName: flags.name });
+    // Persist the returned appId into the local ggui.json when one exists.
+    const path = findGguiJson(process.cwd());
+    if (path) {
+        const read = readGguiJson(path);
+        if ('value' in read) {
+            writeGguiJson(path, { ...read.value, appId: app.appId });
+        }
+    }
+    process.stdout.write(`App created.\n`);
+    process.stdout.write(`  appId:      ${app.appId}\n`);
+    process.stdout.write(`  connectUrl: ${app.connectUrl}\n`);
+    process.stdout.write(`  default:    ${app.isDefault}\n`);
+    return 0;
+}

package/dist/deploy-command.d.ts

@@ -0,0 +1,67 @@
+/** Current deployment state, read from disk at the start of the command. */
+export interface DeployState {
+    /** True if a valid auth session exists in ~/.ggui/auth.json. */
+    readonly authed: boolean;
+    /** appId from ggui.json, if already set. */
+    readonly appId?: string;
+    /** True if GGUI_MCP_BEARER is already present in .env.local. */
+    readonly hasKey: boolean;
+}
+export type DeployStepKind = 'login' | 'create-app' | 'mint-key' | 'push' | 'push-config' | 'push-keys' | 'wire-env';
+export interface DeployStep {
+    readonly kind: DeployStepKind;
+}
+/** Input to the planner — pure data, no I/O. */
+export interface DeployInput {
+    readonly state: DeployState;
+    /** When true, insert a `push-keys` step after `push-config` and before `wire-env`. */
+    readonly pushKeys?: boolean;
+}
+/**
+ * Derive the ordered list of steps to execute given the current state.
+ * Pure function — no I/O.
+ *
+ * Step order:
+ *   login? → create-app? → mint-key? → push → push-config → push-keys? → wire-env
+ */
+export declare function planDeploySteps(input: DeployInput): DeployStep[];
+/**
+ * Resolve the `GGUI_MCP_URL` value `ggui deploy` wires into `.env.local`.
+ *
+ * The per-app cloud pod serves the MCP transport at the BARE per-app endpoint
+ * `<base>/apps/<appId>` (the `connectUrl` the backend advertises) — NOT a
+ * `/mcp` sub-path. The `/mcp` suffix is the LOCAL `ggui serve` convention;
+ * appending it here produced a URL the per-app pod 404s, so the agent (which
+ * reads GGUI_MCP_URL verbatim) could never connect to a deployed app.
+ *
+ *   - `connectUrl` present (a create-app ran this session) → use it VERBATIM —
+ *     the deployment-correct base (prod `mcp.ggui.ai`, sandbox
+ *     `<env>.mcp.sandbox.ggui.ai`, derived from whichever backend `GGUI_API_URL`
+ *     pointed at).
+ *   - absent → the PRODUCTION default `https://mcp.ggui.ai/apps/<appId>`.
+ *
+ * The caller leaves any pre-existing `GGUI_MCP_URL` untouched (env override).
+ */
+export declare function resolveDeployMcpUrl(connectUrl: string | undefined, appId: string): string;
+/**
+ * Read-modify-write `.env.local` at `envLocalPath`, upserting `key=value`.
+ *
+ * - If the file doesn't exist, creates it with only this line.
+ * - If the key already exists, replaces its value in-place.
+ * - Other keys/comments are preserved unchanged.
+ * - No trailing newline is added beyond the final `\n`.
+ */
+export declare function upsertEnvLocal(envLocalPath: string, key: string, value: string): void;
+/**
+ * Read the non-empty value of `key` from `.env.local`, or `undefined` if
+ * the file doesn't exist, the key is absent, or its value is empty.
+ * Strips surrounding quotes + `export ` prefix the same way `upsertEnvLocal`
+ * recognises them.
+ */
+export declare function readEnvLocalValue(envLocalPath: string, key: string): string | undefined;
+export declare const DEPLOY_HELP = "ggui deploy \u2014 provision + wire a ggui.ai cloud app for this project\n\nIdempotent: run it again after a partial failure to resume.\n\nSteps (ggui-side only):\n  1. login        Sign in (skipped if already authed)\n  2. create-app   Create a cloud app + write appId into ggui.json\n  3. mint-key     Create a connector key + write GGUI_MCP_BEARER into .env.local\n  4. push         Export + upload blueprints to the app\n  5. push-config  Push declared gadgets + publicEnv to the app\n  6. push-keys    Push provider API key from env to the app (only with --push-keys)\n  7. wire-env     Write GGUI_MCP_URL into .env.local\n\nAgent / MCP HOSTING (guuey.com) is handled separately.\n\nUsage:\n  ggui deploy [--push-keys]\n\nOptions:\n  --push-keys  Read the provider API key from the appropriate env var\n               (e.g. ANTHROPIC_API_KEY) and push it to the cloud app so\n               keySource=own renders work. Derives the provider from\n               ggui.json#generation.model (or pass --provider to\n               `ggui provider-key set` directly).\n";
+/**
+ * Orchestrate a full ggui-side deploy. Returns a process exit code.
+ */
+export declare function runDeployCommand(_args: readonly string[]): Promise<number>;
+//# sourceMappingURL=deploy-command.d.ts.map

package/dist/deploy-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy-command.d.ts","sourceRoot":"","sources":["../src/deploy-command.ts"],"names":[],"mappings":"AAkCA,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,YAAY,GAAG,UAAU,GAAG,MAAM,GAAG,aAAa,GAAG,WAAW,GAAG,UAAU,CAAC;AAErH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;CAC/B;AAED,gDAAgD;AAChD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,EAAE,CAUhE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzF;AAMD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CA+BrF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,MAAM,GACV,MAAM,GAAG,SAAS,CAiBpB;AAgDD,eAAO,MAAM,WAAW,ijCAwBvB,CAAC;AAEF;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAuNhF"}