@vendoai/vendo 0.4.0

package/dist/catalog.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentCatalog, ComponentRegistry, NormalizedCatalog, VendoTheme } from "@vendoai/core";
+/**
+ * Strictly parses catalog@1. Disk entries carry their JSON Schema for
+ * prompting AND validation: the same document drives both (04 §1).
+ */
+export declare function runtimeCatalogFromJson(raw: string | undefined, file?: string): NormalizedCatalog;
+/**
+ * 01 §14 (amended 2026-07-18): normalize a `createVendo({ catalog })` value —
+ * array form or name-keyed registry form — into the internal catalog. Registry
+ * entries: key → `name`, `props` → `propsSchema`, `component` dropped (the
+ * server never touches or executes it). Derivation happens here, once.
+ */
+export declare function normalizeCatalogConfig(config: ComponentCatalog | ComponentRegistry | undefined): NormalizedCatalog;
+/** AGENT-1 — 03 §3 item (4): the model-facing summary of the host components a
+ * generated view may use and how the host's brand should feel. One succinct
+ * block; the agent injects it only for venues that render trees. */
+export declare function catalogThemeSummary(catalog: NormalizedCatalog, theme?: VendoTheme): string | undefined;
+/** Explicit createVendo registrations win by name over disk registrations. */
+export declare function mergeRuntimeCatalog(disk: NormalizedCatalog, explicit?: NormalizedCatalog): NormalizedCatalog;

package/dist/catalog.js

@@ -0,0 +1,152 @@
+import { catalogFileSchema } from "@vendoai/actions";
+import { zodSchema } from "ai";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+const ajv = new Ajv({ allErrors: true, strict: false });
+addFormats(ajv);
+function permissivePropsSchema() {
+    return { "~standard": { validate: (value) => ({ value }) } };
+}
+function ajvIssuePath(error) {
+    const path = error.instancePath
+        .split("/")
+        .filter((segment) => segment.length > 0)
+        .map((segment) => (/^\d+$/.test(segment) ? Number(segment) : segment.replace(/~1/g, "/").replace(/~0/g, "~")));
+    const missing = error.params.missingProperty;
+    if (typeof missing === "string")
+        path.push(missing);
+    return path;
+}
+/** 04 §1 (amended 2026-07-18): a disk entry's JSON Schema is executable, not
+ * just prompt guidance — build the entry's runtime validator from it, closing
+ * the old pass-through gap. Uncompilable schemas fall back to permissive. */
+function diskPropsValidator(schema, name) {
+    try {
+        const validate = ajv.compile(schema);
+        return {
+            "~standard": {
+                validate: (value) => {
+                    if (validate(value))
+                        return { value };
+                    return {
+                        issues: (validate.errors ?? []).map((error) => ({
+                            message: error.message ?? "props did not match the catalog schema",
+                            path: ajvIssuePath(error),
+                        })),
+                    };
+                },
+            },
+        };
+    }
+    catch (error) {
+        console.warn(`[vendo] catalog entry "${name}" has a props schema ajv could not compile (${error instanceof Error ? error.message : String(error)}); validating permissively.`);
+        return permissivePropsSchema();
+    }
+}
+function parseIssue(error) {
+    if (error !== null && typeof error === "object" && "issues" in error && Array.isArray(error.issues)) {
+        return error.issues.map((issue) => {
+            if (issue === null || typeof issue !== "object")
+                return String(issue);
+            const path = "path" in issue && Array.isArray(issue.path) && issue.path.length > 0
+                ? `${issue.path.join(".")}: `
+                : "";
+            return `${path}${"message" in issue ? String(issue.message) : String(issue)}`;
+        }).join("; ");
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Strictly parses catalog@1. Disk entries carry their JSON Schema for
+ * prompting AND validation: the same document drives both (04 §1).
+ */
+export function runtimeCatalogFromJson(raw, file = ".vendo/catalog.json") {
+    if (raw === undefined)
+        return [];
+    try {
+        const parsed = catalogFileSchema.parse(JSON.parse(raw));
+        return parsed.entries.map((entry) => ({
+            name: entry.name,
+            description: entry.description,
+            propsSchema: diskPropsValidator(entry.propsSchema, entry.name),
+            propsJsonSchema: entry.propsSchema,
+            ...(entry.examples === undefined ? {} : { examples: entry.examples }),
+        }));
+    }
+    catch (error) {
+        console.error(`[vendo] Failed to load host components from ${file}: ${parseIssue(error)}. Run "vendo sync" to regenerate the file.`);
+        return [];
+    }
+}
+function isZodSchema(schema) {
+    const standard = schema["~standard"];
+    return standard.vendor === "zod";
+}
+/** Derive the model-facing JSON Schema from a zod entry (01 §14: derived
+ * internally, once, at normalization time). Non-zod standard schemas derive
+ * nothing — they still validate at runtime and prompt description-only,
+ * matching the contract's schema-less semantics. */
+function derivedJsonSchema(schema, name) {
+    if (schema === undefined || !isZodSchema(schema))
+        return undefined;
+    try {
+        const { $schema: _meta, ...derived } = zodSchema(schema).jsonSchema;
+        return derived;
+    }
+    catch (error) {
+        console.warn(`[vendo] could not derive a JSON Schema for catalog entry "${name}" (${error instanceof Error ? error.message : String(error)}); the prompt will carry its description only.`);
+        return undefined;
+    }
+}
+function normalizeEntry(entry) {
+    const derived = derivedJsonSchema(entry.propsSchema, entry.name);
+    return {
+        name: entry.name,
+        description: entry.description,
+        ...(entry.propsSchema === undefined ? {} : { propsSchema: entry.propsSchema }),
+        ...(derived === undefined ? {} : { propsJsonSchema: derived }),
+        ...(entry.examples === undefined ? {} : { examples: entry.examples }),
+        ...(entry.remixable === undefined ? {} : { remixable: entry.remixable }),
+    };
+}
+/**
+ * 01 §14 (amended 2026-07-18): normalize a `createVendo({ catalog })` value —
+ * array form or name-keyed registry form — into the internal catalog. Registry
+ * entries: key → `name`, `props` → `propsSchema`, `component` dropped (the
+ * server never touches or executes it). Derivation happens here, once.
+ */
+export function normalizeCatalogConfig(config) {
+    if (config === undefined)
+        return [];
+    if (Array.isArray(config))
+        return config.map(normalizeEntry);
+    return Object.entries(config).map(([name, entry]) => normalizeEntry({
+        name,
+        description: entry.description,
+        ...(entry.props === undefined ? {} : { propsSchema: entry.props }),
+        ...(entry.examples === undefined ? {} : { examples: entry.examples }),
+        ...(entry.remixable === undefined ? {} : { remixable: entry.remixable }),
+    }));
+}
+/** AGENT-1 — 03 §3 item (4): the model-facing summary of the host components a
+ * generated view may use and how the host's brand should feel. One succinct
+ * block; the agent injects it only for venues that render trees. */
+export function catalogThemeSummary(catalog, theme) {
+    const sections = [];
+    if (catalog.length > 0) {
+        const lines = catalog.map((entry) => `- ${entry.name}: ${entry.description.split("\n", 1)[0] ?? ""}`.trimEnd());
+        sections.push(`Host components (usable in generated views beside the built-in primitives)\n${lines.join("\n")}`);
+    }
+    if (theme !== undefined) {
+        sections.push(`Theme: ${theme.density} density, ${theme.motion} motion, ${theme.typography.fontFamily} typography.`);
+    }
+    return sections.length > 0 ? sections.join("\n\n") : undefined;
+}
+/** Explicit createVendo registrations win by name over disk registrations. */
+export function mergeRuntimeCatalog(disk, explicit = []) {
+    const explicitNames = new Set(explicit.map((entry) => entry.name));
+    return [
+        ...disk.filter((entry) => !explicitNames.has(entry.name)),
+        ...explicit,
+    ];
+}

package/dist/cli/cloud/args.d.ts

@@ -0,0 +1,3 @@
+export declare function option(args: string[], name: string): string | undefined;
+export declare function options(args: string[], name: string): string[];
+export declare function positionals(args: string[], optionNames: string[]): string[];

package/dist/cli/cloud/args.js

@@ -0,0 +1,32 @@
+export function option(args, name) {
+    const exact = args.indexOf(name);
+    if (exact >= 0)
+        return args[exact + 1];
+    return args.find((value) => value.startsWith(`${name}=`))?.slice(name.length + 1);
+}
+export function options(args, name) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === name) {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith("--"))
+                throw new Error(`${name} requires a value`);
+            values.push(next);
+            index += 1;
+        }
+        else if (value.startsWith(`${name}=`)) {
+            values.push(value.slice(name.length + 1));
+        }
+    }
+    return values;
+}
+export function positionals(args, optionNames) {
+    const values = new Set();
+    for (const name of optionNames) {
+        const index = args.indexOf(name);
+        if (index >= 0 && args[index + 1] !== undefined)
+            values.add(args[index + 1]);
+    }
+    return args.filter((value) => !value.startsWith("--") && !values.has(value));
+}

package/dist/cli/cloud/auth.d.ts

@@ -0,0 +1,17 @@
+import { type CloudFetchOptions } from "./client.js";
+import { type CloudSession } from "./session.js";
+import { type Output } from "../shared.js";
+type CloudFetcher = (path: string, options?: CloudFetchOptions) => Promise<unknown>;
+export interface CloudAuthOptions {
+    output?: Output;
+    fetcher?: CloudFetcher;
+    writeSession?: (session: CloudSession) => Promise<void>;
+    deleteSession?: () => Promise<void>;
+    promptOtp?: (prompt: string) => Promise<string>;
+    home?: string;
+    env?: Record<string, string | undefined>;
+}
+export declare function runLogin(args: string[], options?: CloudAuthOptions): Promise<number>;
+export declare function runLogout(_args: string[], options?: CloudAuthOptions): Promise<number>;
+export declare function runWhoami(args: string[], options?: CloudAuthOptions): Promise<number>;
+export {};

package/dist/cli/cloud/auth.js

@@ -0,0 +1,123 @@
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { option, positionals } from "./args.js";
+import { cloudFetch } from "./client.js";
+import { deleteCloudSession, writeCloudSession, } from "./session.js";
+import { errorMessage, printJson } from "./output.js";
+import { consoleOutput } from "../shared.js";
+function syntheticSession(token) {
+    try {
+        const payload = token.split(".")[1];
+        if (!payload)
+            return { access_token: token };
+        const normalized = payload.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(payload.length / 4) * 4, "=");
+        const value = JSON.parse(atob(normalized));
+        return typeof value.exp === "number"
+            ? { access_token: token, expires_at: value.exp }
+            : { access_token: token };
+    }
+    catch {
+        return { access_token: token };
+    }
+}
+function verifiedSession(value) {
+    const candidate = typeof value === "object" && value !== null && "session" in value
+        ? value.session
+        : value;
+    if (typeof candidate !== "object" || candidate === null
+        || typeof candidate.access_token !== "string"
+        || typeof candidate.refresh_token !== "string"
+        || typeof candidate.expires_at !== "number") {
+        throw new Error("Vendo Cloud returned an invalid session");
+    }
+    const session = candidate;
+    return {
+        access_token: session.access_token,
+        refresh_token: session.refresh_token,
+        expires_at: session.expires_at,
+    };
+}
+async function interactiveOtp(prompt) {
+    const readline = createInterface({ input: stdin, output: stdout });
+    try {
+        return await readline.question(`${prompt}: `);
+    }
+    finally {
+        readline.close();
+    }
+}
+export async function runLogin(args, options = {}) {
+    const output = options.output ?? consoleOutput;
+    const token = option(args, "--token");
+    const writeSession = options.writeSession ?? ((session) => writeCloudSession(session, { home: options.home }));
+    if (token) {
+        try {
+            await writeSession(syntheticSession(token));
+            printJson(output, { loggedIn: true, mode: "token" });
+            return 0;
+        }
+        catch (error) {
+            output.error(errorMessage(error));
+            return 1;
+        }
+    }
+    const email = positionals(args, ["--token", "--api-url"])[0];
+    if (!email) {
+        output.error("Cloud login requires an email or --token <jwt>");
+        return 1;
+    }
+    const fetcher = options.fetcher ?? cloudFetch;
+    const common = {
+        apiUrl: option(args, "--api-url"),
+        env: options.env ?? process.env,
+    };
+    try {
+        await fetcher("/api/v1/auth/otp/start", { ...common, method: "POST", body: { email } });
+        const otp = (await (options.promptOtp ?? interactiveOtp)(`Enter the code sent to ${email}`)).trim();
+        if (!/^\d{6,10}$/.test(otp))
+            throw new Error("Email OTP must be a 6-10 digit code");
+        const result = await fetcher("/api/v1/auth/otp/verify", {
+            ...common,
+            method: "POST",
+            body: { email, token: otp },
+        });
+        await writeSession(verifiedSession(result));
+        printJson(output, { loggedIn: true, mode: "email", email });
+        return 0;
+    }
+    catch (error) {
+        output.error(errorMessage(error));
+        return 1;
+    }
+}
+export async function runLogout(_args, options = {}) {
+    const output = options.output ?? consoleOutput;
+    try {
+        await (options.deleteSession ?? (() => deleteCloudSession({ home: options.home })))();
+        printJson(output, { loggedOut: true });
+        return 0;
+    }
+    catch (error) {
+        output.error(errorMessage(error));
+        return 1;
+    }
+}
+export async function runWhoami(args, options = {}) {
+    const output = options.output ?? consoleOutput;
+    const fetcher = options.fetcher ?? cloudFetch;
+    try {
+        const orgs = await fetcher("/api/v1/orgs", {
+            auth: "user",
+            apiUrl: option(args, "--api-url"),
+            accessToken: option(args, "--token"),
+            home: options.home,
+            env: options.env ?? process.env,
+        });
+        printJson(output, orgs);
+        return 0;
+    }
+    catch (error) {
+        output.error(errorMessage(error));
+        return 1;
+    }
+}

package/dist/cli/cloud/client.d.ts

@@ -0,0 +1,28 @@
+import { type CloudSession } from "./session.js";
+export declare function isVendoKey(key: string): boolean;
+export declare class CloudError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, message: string, status: number);
+}
+export interface CloudUrlOptions {
+    apiUrl?: string;
+    env?: Record<string, string | undefined>;
+}
+export declare function resolveCloudBaseUrl(options?: CloudUrlOptions): string;
+export interface SessionStore {
+    read(): Promise<CloudSession | null>;
+    write(session: CloudSession): Promise<void>;
+}
+export interface CloudFetchOptions extends CloudUrlOptions {
+    method?: string;
+    body?: unknown;
+    auth?: "user" | "key";
+    apiKey?: string;
+    accessToken?: string;
+    fetchImpl?: typeof fetch;
+    home?: string;
+    sessionStore?: SessionStore;
+    signal?: AbortSignal;
+}
+export declare function cloudFetch<T = unknown>(path: string, options?: CloudFetchOptions): Promise<T>;

package/dist/cli/cloud/client.js

@@ -0,0 +1,133 @@
+import { isSessionExpired, readCloudSession, writeCloudSession, } from "./session.js";
+import { deploymentIdentityHeaders } from "../../deployment-identity.js";
+import { CLI_VERSION } from "../shared.js";
+const DEFAULT_CLOUD_URL = "https://console.vendo.run";
+export function isVendoKey(key) {
+    return /^vnd_[0-9a-f]{40}$/.test(key);
+}
+export class CloudError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.name = "CloudError";
+        this.code = code;
+        this.status = status;
+    }
+}
+export function resolveCloudBaseUrl(options = {}) {
+    const value = options.apiUrl ?? (options.env ?? process.env).VENDO_CLOUD_URL ?? DEFAULT_CLOUD_URL;
+    return value.replace(/\/+$/, "");
+}
+function requestUrl(path, options) {
+    const base = resolveCloudBaseUrl(options);
+    const suffix = base.endsWith("/api/v1") && path.startsWith("/api/v1/")
+        ? path.slice("/api/v1".length)
+        : path;
+    return `${base}${suffix.startsWith("/") ? suffix : `/${suffix}`}`;
+}
+async function responseBody(response) {
+    const text = await response.text();
+    if (text.length === 0)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function errorFrom(response, body) {
+    const envelope = body;
+    const code = typeof envelope?.error?.code === "string" ? envelope.error.code : `http-${response.status}`;
+    const message = typeof envelope?.error?.message === "string"
+        ? envelope.error.message
+        : `Vendo Cloud request failed (${response.status})`;
+    return new CloudError(code, message, response.status);
+}
+function defaultSessionStore(home) {
+    return {
+        read: () => readCloudSession({ home }),
+        write: (session) => writeCloudSession(session, { home }),
+    };
+}
+function sessionFrom(value) {
+    if (typeof value !== "object" || value === null || typeof value.access_token !== "string") {
+        throw new CloudError("invalid-session", "Vendo Cloud returned an invalid session", 500);
+    }
+    return value;
+}
+async function refreshUserSession(session, options, store) {
+    if (!session.refresh_token) {
+        throw new CloudError("session-expired", "Vendo Cloud session expired; run `vendo cloud login` again", 401);
+    }
+    const response = await (options.fetchImpl ?? fetch)(requestUrl("/api/v1/auth/refresh", options), {
+        method: "POST",
+        headers: {
+            accept: "application/json",
+            "content-type": "application/json",
+            "user-agent": `vendo-cli/${CLI_VERSION}`,
+        },
+        body: JSON.stringify({ refresh_token: session.refresh_token }),
+    });
+    const body = await responseBody(response);
+    if (!response.ok)
+        throw errorFrom(response, body);
+    const refreshed = sessionFrom(body);
+    await store.write(refreshed);
+    return refreshed;
+}
+async function send(path, options, token) {
+    const headers = {
+        accept: "application/json",
+        "user-agent": `vendo-cli/${CLI_VERSION}`,
+    };
+    if (options.body !== undefined)
+        headers["content-type"] = "application/json";
+    if (token !== undefined)
+        headers.authorization = `Bearer ${token}`;
+    // The console's shared auth middleware upserts deployment inventory and
+    // meters usage from these headers on real service calls — there is no
+    // heartbeat (shared with the runtime Cloud adapters; deployment-identity.ts).
+    if (options.auth === "key") {
+        Object.assign(headers, await deploymentIdentityHeaders());
+    }
+    const response = await (options.fetchImpl ?? fetch)(requestUrl(path, options), {
+        method: options.method ?? (options.body === undefined ? "GET" : "POST"),
+        headers,
+        body: options.body === undefined ? undefined : JSON.stringify(options.body),
+        signal: options.signal,
+    });
+    return { response, body: await responseBody(response) };
+}
+export async function cloudFetch(path, options = {}) {
+    let token;
+    let session = null;
+    const store = options.sessionStore ?? defaultSessionStore(options.home);
+    if (options.auth === "key") {
+        token = options.apiKey ?? (options.env ?? process.env).VENDO_API_KEY;
+        if (!token)
+            throw new CloudError("missing-api-key", "Pass --key or set VENDO_API_KEY", 0);
+    }
+    else if (options.auth === "user") {
+        if (options.accessToken) {
+            token = options.accessToken;
+        }
+        else {
+            session = await store.read();
+            if (!session)
+                throw new CloudError("not-logged-in", "Run `vendo cloud login` first", 401);
+            if (isSessionExpired(session))
+                session = await refreshUserSession(session, options, store);
+            token = session.access_token;
+        }
+    }
+    let result = await send(path, options, token);
+    if (options.auth === "user" && !options.accessToken && result.response.status === 401 && session) {
+        session = await refreshUserSession(session, options, store);
+        result = await send(path, options, session.access_token);
+    }
+    if (!result.response.ok)
+        throw errorFrom(result.response, result.body);
+    return result.body;
+}

package/dist/cli/cloud/command.d.ts

@@ -0,0 +1,22 @@
+import { type CloudFetchOptions } from "./client.js";
+import { type Output } from "../shared.js";
+export type CloudFetcher = (path: string, options?: CloudFetchOptions) => Promise<unknown>;
+export interface CloudCommandOptions {
+    output?: Output;
+    fetcher?: CloudFetcher;
+    home?: string;
+    env?: Record<string, string | undefined>;
+    now?: number | (() => number);
+}
+export interface CloudCommandContext {
+    output: Output;
+    fetcher: CloudFetcher;
+    home?: string;
+    env: Record<string, string | undefined>;
+    now?: number | (() => number);
+}
+export declare function commandContext(options: CloudCommandOptions): CloudCommandContext;
+export declare function userOptions(args: string[], context: CloudCommandContext): CloudFetchOptions;
+export declare function resolveOrgId(args: string[], context: CloudCommandContext): Promise<string>;
+export declare function resolveProjectId(args: string[], context: CloudCommandContext): Promise<string>;
+export declare function runCommand(options: CloudCommandOptions, operation: (context: CloudCommandContext) => Promise<unknown>): Promise<number>;

package/dist/cli/cloud/command.js

@@ -0,0 +1,73 @@
+import { option } from "./args.js";
+import { cloudFetch } from "./client.js";
+import { errorMessage, printJson } from "./output.js";
+import { consoleOutput } from "../shared.js";
+export function commandContext(options) {
+    return {
+        output: options.output ?? consoleOutput,
+        fetcher: options.fetcher ?? cloudFetch,
+        home: options.home,
+        env: options.env ?? process.env,
+        now: options.now,
+    };
+}
+export function userOptions(args, context) {
+    return {
+        auth: "user",
+        apiUrl: option(args, "--api-url"),
+        accessToken: option(args, "--token"),
+        home: context.home,
+        env: context.env,
+    };
+}
+function orgRecords(value) {
+    if (Array.isArray(value))
+        return value;
+    if (typeof value === "object" && value !== null && Array.isArray(value.orgs)) {
+        return value.orgs;
+    }
+    return [];
+}
+export async function resolveOrgId(args, context) {
+    const explicit = option(args, "--org");
+    if (explicit)
+        return explicit;
+    const value = await context.fetcher("/api/v1/orgs", userOptions(args, context));
+    const orgs = orgRecords(value);
+    if (orgs.length === 1 && typeof orgs[0]?.id === "string")
+        return orgs[0].id;
+    throw new Error("Pass --org <id> (it can only be omitted when your account has exactly one organization)");
+}
+function projectRecords(value) {
+    if (Array.isArray(value))
+        return value;
+    if (typeof value === "object" && value !== null && Array.isArray(value.projects)) {
+        return value.projects;
+    }
+    return [];
+}
+// Keys and usage live under the project since the spine v2 realignment; a
+// bare command walks org -> only project the same way resolveOrgId walks
+// account -> only org.
+export async function resolveProjectId(args, context) {
+    const explicit = option(args, "--project");
+    if (explicit)
+        return explicit;
+    const orgId = await resolveOrgId(args, context);
+    const value = await context.fetcher(`/api/v1/orgs/${encodeURIComponent(orgId)}/projects`, userOptions(args, context));
+    const projects = projectRecords(value);
+    if (projects.length === 1 && typeof projects[0]?.id === "string")
+        return projects[0].id;
+    throw new Error("Pass --project <id> (it can only be omitted when the organization has exactly one project)");
+}
+export async function runCommand(options, operation) {
+    const context = commandContext(options);
+    try {
+        printJson(context.output, await operation(context));
+        return 0;
+    }
+    catch (error) {
+        context.output.error(errorMessage(error));
+        return 1;
+    }
+}

package/dist/cli/cloud/deploy.d.ts

@@ -0,0 +1,26 @@
+import type { AppDocument, PermissionGrant } from "@vendoai/core";
+import { type VendoStore } from "@vendoai/store";
+import { type CloudCommandOptions } from "./command.js";
+export interface LocalDeployApp {
+    doc: AppDocument;
+    enabled: boolean;
+}
+export interface LocalDeployProject {
+    subject: string;
+    apps: LocalDeployApp[];
+    grants: PermissionGrant[];
+}
+export interface LocalProjectReadOptions {
+    subject?: string;
+    cwd?: string;
+}
+export interface ReadLocalProjectOptions extends LocalProjectReadOptions {
+    storeFactory?: () => VendoStore;
+}
+export type LocalProjectReader = (options: LocalProjectReadOptions) => Promise<LocalDeployProject>;
+export interface CloudDeployOptions extends CloudCommandOptions {
+    cwd?: string;
+    localProjectReader?: LocalProjectReader;
+}
+export declare function readLocalProject(options?: ReadLocalProjectOptions): Promise<LocalDeployProject>;
+export declare function runDeploy(args: string[], options?: CloudDeployOptions): Promise<number>;