@supacloud/cli 0.75.1 → 0.77.0

package/dist/shared/tools/app-tools.d.ts

@@ -0,0 +1,93 @@
+import { type ToolServer } from "../tool-server";
+import { type AppManifest } from "./app-tool-export";
+declare const REMOTE_APP_ACTIONS: {
+    readonly upload: "upload_release";
+    readonly configure: "put_configuration";
+    readonly deploy: "activate_release";
+    readonly status: "get_runtime";
+    readonly rollback: "activate_release";
+    readonly reconcile: "reconcile_activation";
+    readonly retire: "retire_activation";
+    readonly logs: "logs";
+};
+export interface AppToolOptions {
+    getApplications?: () => ((args: Record<string, unknown>) => Promise<ToolResult>) | undefined;
+    projectRef?: string;
+    /** Abort signal for long-running local actions (`app dev` watch), used for cancellation and tests. */
+    signal?: AbortSignal;
+    /** Watch progress only. The caller owns its transport; the final result is returned separately. */
+    onDevProgress?: (result: ToolResult) => void;
+}
+export interface AppToolArguments {
+    action: "init" | "generate" | "dev" | "watch" | "verify-plan" | "compile" | "check" | "graph" | "explain" | "export-tools" | "context" | "doctor" | "fix" | "plan" | "build" | keyof typeof REMOTE_APP_ACTIONS;
+    ref?: string;
+    id?: string;
+    environment_id?: string;
+    configuration_id?: string;
+    activation_id?: string;
+    expected_activation_id?: string | null;
+    configuration_path?: string;
+    manifest_path?: string;
+    release_id?: string;
+    kind?: "module" | "command" | "query" | "controller" | "job" | "contract" | "resource";
+    template?: "minimal" | "http" | "command" | "edge";
+    name?: string;
+    module?: string;
+    dir?: string;
+    force?: boolean;
+    dry_run?: boolean;
+    register_in?: string;
+    "dry-run"?: boolean;
+    "register-in"?: string;
+    root?: string;
+    include?: string;
+    out_dir?: string;
+    strict?: boolean;
+    format?: "text" | "json";
+    target?: string;
+    fix?: string;
+    write?: boolean;
+    /** `app dev` local profile. `fast` is local/ephemeral; `integration` requires an explicit database URL. */
+    profile?: "fast" | "integration";
+    /** `app dev`: validate and report once without watching. */
+    once?: boolean;
+    /** `app dev`: watch for changes (default true; `--once` disables). */
+    watch?: boolean;
+    /** Integration dev verifies an explicit loopback database before running dev:integration. */
+    database_url?: string;
+    "database-url"?: string;
+    offset?: number;
+    service?: string;
+    search?: string;
+    start?: string;
+    end?: string;
+}
+export interface ToolResult {
+    isError?: boolean;
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}
+/** kebab/snake/space-separated name -> PascalCase (class name for generate). */
+declare function pascalName(name: string): string;
+/** kebab-case -> camelCase (semantic name suffix for command/query). */
+declare function camelName(name: string): string;
+declare function formatGraphText(manifest: AppManifest): string;
+/** token -> dependent provider/controller module and name (reverse index). */
+declare function reverseDependencies(manifest: AppManifest, token: string): string[];
+export declare function runAppTool(request: AppToolArguments, options?: AppToolOptions): Promise<ToolResult>;
+export declare function registerAppTools(server: ToolServer, options?: AppToolOptions): void;
+/**
+ * Promotes the single-entry development verbs to top-level commands so an AI or
+ * developer does not need to remember the `app` namespace. The `app` tool and
+ * these aliases share one implementation and one execution-policy classification.
+ */
+export declare function registerAppAliases(server: ToolServer): void;
+export declare const __internal: {
+    pascalName: typeof pascalName;
+    camelName: typeof camelName;
+    formatGraphText: typeof formatGraphText;
+    reverseDependencies: typeof reverseDependencies;
+};
+export {};

package/dist/shared/tools/app-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/app-verification-plan.d.ts

@@ -0,0 +1,14 @@
+import type { ApplicationGraph } from "@supacloud/compiler";
+/** Read only the selected owner's immediate source directories, never the whole repository. */
+export declare function createVerificationPlan(root: string, graph: ApplicationGraph, target: string, sourceRoot?: string): Promise<{
+    version: number;
+    source: string;
+    target: string;
+    ready: boolean;
+    files: string[];
+    tests: string[];
+    commands: string[][];
+    manual: string[];
+    releaseOnly: string[];
+    executed: boolean;
+}>;

package/dist/shared/tools/app-verification-plan.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/application-schemas.d.ts

@@ -0,0 +1,75 @@
+export declare const ApplicationIdSchema: import("typebox").TString;
+export declare const ApplicationReleaseIdSchema: import("typebox").TString;
+export declare const ApplicationReleaseRecordSchema: import("typebox").TObject<{
+    schema: import("typebox").TLiteral<"supacloud.application-release.v1">;
+    project_ref: import("typebox").TString;
+    application_id: import("typebox").TString;
+    release_id: import("typebox").TString;
+    manifest_sha256: import("typebox").TString;
+    created_at: import("typebox").TString;
+    targets: import("typebox").TArray<import("typebox").TObject<{
+        name: import("typebox").TString;
+        object_id: import("typebox").TString;
+        kind: import("typebox").TUnion<[import("typebox").TLiteral<"http">, import("typebox").TLiteral<"worker">]>;
+        entrypoint: import("typebox").TLiteral<"bundle/index.js">;
+        execution: import("typebox").TOptional<import("typebox").TObject<{
+            name: import("typebox").TString;
+            target: import("typebox").TString;
+            workloadClass: import("typebox").TUnion<[import("typebox").TLiteral<"interactive">, import("typebox").TLiteral<"batch">]>;
+            executor: import("typebox").TLiteral<"pgflow-queue">;
+            runtime: import("typebox").TLiteral<"bun">;
+            queue: import("typebox").TString;
+            taskKey: import("typebox").TString;
+            definitionVersion: import("typebox").TString;
+            replicas: import("typebox").TInteger;
+            maxReplicas: import("typebox").TInteger;
+            concurrencyPerReplica: import("typebox").TInteger;
+            resources: import("typebox").TObject<{
+                cpuLimit: import("typebox").TNumber;
+                memoryLimitMiB: import("typebox").TInteger;
+            }>;
+            database: import("typebox").TObject<{
+                engineConnectionsPerReplica: import("typebox").TInteger;
+                handlerConnectionsPerReplica: import("typebox").TInteger;
+            }>;
+            lifecycle: import("typebox").TObject<{
+                executionTimeoutSeconds: import("typebox").TInteger;
+                visibilityTimeoutSeconds: import("typebox").TInteger;
+                shutdownGraceSeconds: import("typebox").TInteger;
+            }>;
+            retry: import("typebox").TObject<{
+                maxAttempts: import("typebox").TInteger;
+            }>;
+            admission: import("typebox").TObject<{
+                maxOutstandingOperations: import("typebox").TInteger;
+            }>;
+        }>>;
+        compute: import("typebox").TOptional<import("typebox").TObject<{
+            cpuLimit: import("typebox").TNumber;
+            memoryLimitMiB: import("typebox").TInteger;
+        }>>;
+    }>>;
+}>;
+export declare const ApplicationConfigurationIdSchema: import("typebox").TString;
+export declare const ApplicationActivationIdSchema: import("typebox").TString;
+export declare const ApplicationActivationWriteSchema: import("typebox").TObject<{
+    activation_id: import("typebox").TString;
+    release_id: import("typebox").TString;
+    configuration_id: import("typebox").TString;
+    expected_activation_id: import("typebox").TUnion<[import("typebox").TString, import("typebox").TNull]>;
+}>;
+export declare const ApplicationActivationResultSchema: import("typebox").TObject<{
+    project_ref: import("typebox").TString;
+    application_id: import("typebox").TString;
+    environment_id: import("typebox").TString;
+    release_id: import("typebox").TString;
+    activation_id: import("typebox").TString;
+    replayed: import("typebox").TBoolean;
+}>;
+export declare const ApplicationActivationRetirementResultSchema: import("typebox").TObject<{
+    project_ref: import("typebox").TString;
+    application_id: import("typebox").TString;
+    environment_id: import("typebox").TString;
+    activation_id: import("typebox").TString;
+    retired_at: import("typebox").TString;
+}>;

package/dist/shared/tools/application-tools.d.ts

@@ -0,0 +1,23 @@
+import { Type } from "typebox";
+import type { HttpTransport } from "../transports/http";
+import { type ToolServer } from "../tool-server";
+export declare const APPLICATION_TOOL_SCHEMA: {
+    action: Type.TEnum<("list_releases" | "get_release" | "upload_release" | "activate_release" | "logs" | "get_runtime" | "get_deployment_evidence" | "get_configuration" | "put_configuration" | "reconcile_activation" | "retire_activation")[]>;
+    ref: Type.TString;
+    id: Type.TString;
+    environment_id: Type.TOptional<Type.TString>;
+    configuration_id: Type.TOptional<Type.TString>;
+    activation_id: Type.TOptional<Type.TString>;
+    expected_activation_id: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull, Type.TLiteral<"absent">]>>;
+    configuration_path: Type.TOptional<Type.TString>;
+    manifest_path: Type.TOptional<Type.TString>;
+    release_id: Type.TOptional<Type.TString>;
+    cursor: Type.TOptional<Type.TString>;
+    limit: Type.TOptional<Type.TInteger>;
+    offset: Type.TOptional<Type.TInteger>;
+    service: Type.TOptional<Type.TString>;
+    search: Type.TOptional<Type.TString>;
+    start: Type.TOptional<Type.TString>;
+    end: Type.TOptional<Type.TString>;
+};
+export declare function registerApplicationTools(server: ToolServer, http: HttpTransport): void;

package/dist/shared/tools/application-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/auth-tools.d.ts

@@ -0,0 +1,3 @@
+import type { HttpTransport } from "../transports/http";
+import { type ToolServer } from "../tool-server";
+export declare function registerAuthTools(server: ToolServer, http: HttpTransport): void;

package/dist/shared/tools/auth-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/branch-tools.d.ts

@@ -0,0 +1,6 @@
+import type { HttpTransport } from "../transports/http";
+import { type ToolServer } from "../tool-server";
+export declare function registerBranchTools(server: ToolServer, http: HttpTransport, options?: {
+    projectRef?: string;
+    readOnly?: boolean;
+}): void;

package/dist/shared/tools/branch-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/database-tools.d.ts

@@ -0,0 +1,13 @@
+import type { HttpTransport } from "../transports/http";
+import { type ToolServer } from "../tool-server";
+export interface DatabaseToolsConfig {
+    localOnly?: boolean;
+    readOnly?: boolean;
+    projectRef?: string;
+}
+export declare function migrationVersionFromFilename(file: string): string;
+export declare function vectorWarningsForPendingMigrations(migrations: Array<{
+    file: string;
+    sql: string;
+}>, vectorEnabled: boolean | null): string[];
+export declare function registerDatabaseTools(server: ToolServer, http: HttpTransport | undefined, config?: DatabaseToolsConfig): void;

package/dist/shared/tools/database-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/db-governance-tools.d.ts

@@ -0,0 +1,80 @@
+import { type DatabaseModule, type QueryExecutor, type ReconcileReport } from "@supacloud/db";
+import { type DbWorkflowAction } from "./db-workflow";
+import { type ToolServer, type ToolResult } from "../tool-server";
+export interface DbToolArguments {
+    action: "context" | "lint" | "explain" | "module_check" | DbWorkflowAction;
+    module?: string;
+    root?: string;
+    module_file?: string;
+    target?: string;
+    database_url?: string;
+    schema?: string;
+    lite?: boolean;
+    project_dir?: string;
+    schema_dir?: string;
+    db_major_version?: number;
+    out?: string;
+    dir?: string;
+    ref?: string;
+    approved_digest?: string;
+    application_role?: string;
+    migration_role?: string;
+    database?: string;
+}
+export interface DatabaseAiContextObject {
+    kind: "table" | "policy" | "function" | "trigger" | "grant";
+    name: string;
+    module: string;
+    table?: string;
+    source: string | null;
+    tests: string[];
+    security?: string;
+    permission?: string;
+    transaction?: string;
+    audit?: string;
+    idempotency?: string;
+}
+export interface DatabaseAiContext {
+    version: 1;
+    scope: "database-ai-context";
+    root: string;
+    selectedModules: string[];
+    target: string | null;
+    objects: DatabaseAiContextObject[];
+    maintenance: {
+        structureSource: "drizzle" | "declarative-sql";
+        behaviorSource: "sql";
+        generatedPaths: string[];
+        protectedPaths: string[];
+        forwardMigrationPath: string;
+        rules: string[];
+    };
+    verification: string[];
+}
+export interface DbGovernanceToolOptions {
+    environment?: NodeJS.ProcessEnv;
+    currentWorkingDirectory?: string;
+    liteSpawn?: LiteSpawn;
+    /** Overrides the supacloud-lite binary lookup; null simulates a missing binary (tests). */
+    liteBinary?: string | null;
+    projectRef?: string;
+    apiUrl?: string;
+    runDatabase?: () => ((args: Record<string, unknown>) => Promise<ToolResult>) | undefined;
+}
+/**
+ * Load database governance module declarations:
+ * --module_file points to a file exporting `default defineDatabaseModule(...)` (or an array);
+ * defaults to <root>/db/modules.ts (default or named "modules" export, single or array).
+ */
+export declare function loadDatabaseModules(root: string, moduleFile?: string): Promise<DatabaseModule[]>;
+export declare function buildDatabaseAiContext(modules: readonly DatabaseModule[], root: string, moduleName?: string, target?: string): DatabaseAiContext;
+/** Testable orchestration point: inject executor, read catalog, and reconcile against declared modules. */
+export declare function runModuleCheck(module: DatabaseModule, executor: QueryExecutor, schemas?: string[]): Promise<ReconcileReport>;
+interface LiteSubprocessResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+type LiteSpawn = (command: string[], cwd: string) => Promise<LiteSubprocessResult>;
+export declare function registerDbGovernanceTools(server: ToolServer, options?: DbGovernanceToolOptions): void;
+export {};

package/dist/shared/tools/db-governance-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/db-workflow.d.ts

@@ -0,0 +1,37 @@
+import { type QueryExecutor } from "@supacloud/db";
+export type DbWorkflowAction = "reverse" | "diff" | "plan" | "apply" | "role_check" | "role_sql";
+export interface DbWorkflowArguments {
+    action: DbWorkflowAction;
+    root?: string;
+    schema?: string;
+    database_url?: string;
+    schema_dir?: string;
+    db_major_version?: number;
+    out?: string;
+    dir?: string;
+    ref?: string;
+    approved_digest?: string;
+    application_role?: string;
+    migration_role?: string;
+    database?: string;
+}
+interface ToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export interface DbWorkflowOptions {
+    environment?: NodeJS.ProcessEnv;
+    projectRef?: string;
+    apiUrl?: string;
+    runDatabase?: () => ((args: Record<string, unknown>) => Promise<ToolResult>) | undefined;
+    spawn?: (args: string[], root: string, environment: NodeJS.ProcessEnv) => Promise<number>;
+    connect?: (url: string) => {
+        executor: QueryExecutor;
+        close(): Promise<void>;
+    };
+}
+export declare function runDbWorkflow(args: DbWorkflowArguments, projectRoot: string, options?: DbWorkflowOptions): Promise<ToolResult>;
+export {};

package/dist/shared/tools/db-workflow.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/deploy-tools.d.ts

@@ -0,0 +1,36 @@
+import { Type } from "typebox";
+import type { HttpTransport } from "../transports/http";
+import { type ToolServer } from "../tool-server";
+interface DeployToolOptions {
+    projectRef?: string;
+    cwd?: string;
+    edgeFunctionDeploy?: (args: Record<string, unknown>) => Promise<ToolResponse>;
+}
+interface ToolResponse {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export declare const deployToolSchema: {
+    ref: Type.TOptional<Type.TString>;
+    target: Type.TOptional<Type.TString>;
+    id: Type.TOptional<Type.TString>;
+    cwd: Type.TOptional<Type.TString>;
+    build_command: Type.TOptional<Type.TString>;
+    output_dir: Type.TOptional<Type.TString>;
+    skip_build: Type.TOptional<Type.TBoolean>;
+    dry_run: Type.TOptional<Type.TBoolean>;
+    json: Type.TOptional<Type.TBoolean>;
+};
+export declare function findDeployConfigRoot(startDirectory: string): Promise<string>;
+export declare function createFrontendArchive(outputDirectory: string): Promise<{
+    archivePath: string;
+    sha256: string;
+    sourceBytes: number;
+    fileCount: number;
+    cleanup(): Promise<void>;
+}>;
+export declare function registerDeployTools(server: ToolServer, http: HttpTransport, options?: DeployToolOptions): void;
+export {};

package/dist/shared/tools/deploy-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/edge-function-response.d.ts

@@ -0,0 +1,55 @@
+declare const FUNCTION_FRAMEWORKS: readonly ["fetch", "elysia", "hono", "sveltekit-function"];
+type FunctionFramework = typeof FUNCTION_FRAMEWORKS[number];
+type FunctionCapabilities = {
+    secrets?: string[];
+    outbound_hosts?: string[];
+    bindings?: string[];
+    background?: boolean;
+};
+type FunctionLimits = {
+    timeout_ms?: number;
+    max_request_body_bytes?: number;
+    max_response_body_bytes?: number;
+    wait_until_timeout_ms?: number;
+};
+export type FunctionConfigInput = {
+    verify_jwt?: boolean;
+    background_routes?: string[];
+    framework?: FunctionFramework;
+    capabilities?: FunctionCapabilities;
+    limits?: FunctionLimits;
+};
+export type FunctionIdentityResponse = {
+    project_ref: string;
+    slug: string;
+    active_version: string;
+    activation_id: string;
+    verify_jwt: boolean;
+    background_routes: string[];
+    framework?: FunctionFramework;
+    version?: string;
+    import_map?: string;
+    entrypoint?: string;
+    capabilities?: FunctionCapabilities;
+    limits?: FunctionLimits;
+};
+export type FunctionConfigMutationExpectation = {
+    projectRef: string;
+    slug: string;
+    expectedActivationId: string;
+    config: FunctionConfigInput;
+};
+export type FunctionDeleteExpectation = {
+    projectRef: string;
+    slug: string;
+    expectedActivationId: string;
+};
+export declare function projectedFunctionCapabilities(candidate: unknown): FunctionCapabilities | null;
+export declare function projectedFunctionLimits(candidate: unknown): FunctionLimits | null;
+export declare function validObservedFunctionActivationId(candidate: unknown): candidate is string;
+export declare function validCommittedFunctionActivationId(candidate: unknown): candidate is string;
+export declare function projectedFunctionList(payload: unknown): Array<Record<string, unknown>> | null;
+export declare function projectedFunctionIdentity(payload: unknown, expectedProjectRef: string, expectedSlug: string): FunctionIdentityResponse | null;
+export declare function confirmedFunctionConfigMutation(payload: unknown, expectation: FunctionConfigMutationExpectation): Record<string, unknown> | null;
+export declare function confirmedFunctionDeletion(payload: unknown, expectation: FunctionDeleteExpectation): Record<string, unknown> | null;
+export {};

package/dist/shared/tools/edge-function-response.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/frontend-release-control.d.ts

@@ -0,0 +1,54 @@
+import type { HttpResult } from "../transports/http";
+type ToolResponse = {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+};
+export interface FrontendReleaseHttp {
+    get<T = unknown>(path: string, options?: {
+        maxJsonBytes?: number;
+    }): Promise<HttpResult<T>>;
+    post<T = unknown>(path: string, body?: unknown, options?: {
+        maxJsonBytes?: number;
+        responseTimeoutMs?: number;
+    }): Promise<HttpResult<T>>;
+    postBinary<T = unknown>(path: string, body: {
+        stream: ReadableStream<Uint8Array>;
+        byteLength: number;
+    }, options: {
+        contentType: string;
+        contentLength: number;
+        contentSha256: string;
+        maxJsonBytes: number;
+        timeoutMs?: number;
+        responseTimeoutMs?: number;
+    }): Promise<HttpResult<T>>;
+}
+export interface FrontendReleaseRecord {
+    project_ref: string;
+    deployment_id: string;
+    release_id: string;
+    sha256: string;
+    tree_sha256: string;
+    size_bytes: number;
+    file_count: number;
+    created_at: string;
+    kind: "prebuilt_static";
+}
+export declare function listFrontendReleases(http: FrontendReleaseHttp, projectRef: string, deploymentId: string, cursor?: string, limit?: number): Promise<ToolResponse>;
+export declare function getFrontendRelease(http: FrontendReleaseHttp, projectRef: string, deploymentId: string, releaseId: string): Promise<ToolResponse>;
+export declare function uploadFrontendRelease(http: FrontendReleaseHttp, projectRef: string, deploymentId: string, archivePath: string): Promise<ToolResponse>;
+export declare function getActiveFrontendRelease(http: FrontendReleaseHttp, projectRef: string, deploymentId: string): Promise<ToolResponse>;
+export declare function readFrontendReleaseAuthority(http: FrontendReleaseHttp, projectRef: string, deploymentId: string): Promise<ToolResponse>;
+export declare function rollbackFrontendRelease(http: FrontendReleaseHttp, projectRef: string, deploymentId: string, releaseId?: string): Promise<ToolResponse>;
+export declare function activateFrontendRelease(http: FrontendReleaseHttp, input: {
+    projectRef: string;
+    deploymentId: string;
+    releaseId: string;
+    expectedActiveReleaseId: string;
+    expectedActivationId: string;
+    mutationId: string;
+}): Promise<ToolResponse>;
+export {};

package/dist/shared/tools/frontend-release-control.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/frontend-tools.d.ts

@@ -0,0 +1,3 @@
+import type { HttpTransport } from "../transports/http";
+import { type ToolServer } from "../tool-server";
+export declare function registerFrontendTools(server: ToolServer, http: HttpTransport): void;

package/dist/shared/tools/gateway-tools.d.ts

@@ -0,0 +1,6 @@
+import type { HttpTransport } from "../transports/http";
+import { type ToolServer } from "../tool-server";
+export declare function registerGatewayTools(server: ToolServer, http: Pick<HttpTransport, "get" | "post" | "put" | "delete">, options?: {
+    projectRef?: string;
+    refPriority?: "argument" | "project";
+}): void;

package/dist/shared/tools/gateway-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/lite-cli-command.d.ts

@@ -0,0 +1,2 @@
+/** Resolve the installed package's declared bin, not an internal file suffix. */
+export declare function resolveLiteCommand(workdir: string, environment?: NodeJS.ProcessEnv): string[];

package/dist/shared/tools/lite-cli-tools.d.ts

@@ -0,0 +1,46 @@
+export { resolveLiteCommand } from "./lite-cli-command";
+import { type ToolServer } from "../tool-server";
+export type LiteCliAction = "version" | "start" | "migrate" | "status" | "keys" | "gen_types" | "db_reset" | "db_diff" | "db_pull" | "snapshot_create" | "snapshot_restore" | "upgrade" | "inspect" | "doctor";
+export interface LiteCliArgs {
+    action: LiteCliAction;
+    workdir?: string;
+    project_dir?: string;
+    state_dir?: string;
+    data_dir?: string;
+    storage_dir?: string;
+    storage_backend?: "fs" | "memory" | "s3";
+    s3_prefix?: string;
+    engine?: "pglite" | "native";
+    host?: string;
+    port?: number;
+    api_url?: string;
+    site_url?: string;
+    replication_profile?: "powersync";
+    replication_host?: string;
+    replication_port?: number;
+    replication_allow_cidrs?: string;
+    powersync_tables?: string;
+    replication_tls_cert?: string;
+    replication_tls_key?: string;
+    output?: string;
+    file?: string;
+    snapshot_file?: string;
+    service_role?: boolean;
+    force?: boolean;
+    memory?: boolean;
+    json?: boolean;
+    baseline?: boolean;
+}
+export interface LiteCliExecutionResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+type LiteCliExecutor = (request: LiteCliArgs) => Promise<LiteCliExecutionResult>;
+export interface LiteCliToolOptions {
+    executeLiteCli?: LiteCliExecutor;
+    environment?: NodeJS.ProcessEnv;
+    currentWorkingDirectory?: string;
+}
+export declare function buildLiteArgs(request: LiteCliArgs): string[];
+export declare function registerLiteCliTools(server: ToolServer, options?: LiteCliToolOptions): void;

package/dist/shared/tools/lite-cli-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/tools/migration-import.d.ts

@@ -0,0 +1,22 @@
+export interface MigrationImportFile {
+    file: string;
+    name: string;
+    sql: string;
+    source: "sql" | "hasura-metadata" | "hasura-application-review" | "nhost";
+}
+export interface MigrationImportPlan {
+    source: "hasura" | "nhost";
+    files: MigrationImportFile[];
+    warnings: string[];
+    compatibility: {
+        supabase_migrations: true;
+        pg_graphql: "preserved";
+        rls: "manual_review";
+    };
+}
+export declare function writeMigrationImportPlan(plan: MigrationImportPlan, outputDirectory: string): Promise<string[]>;
+export declare function createMigrationImportPlan(input: {
+    source: "hasura" | "nhost";
+    directory?: string;
+    metadata?: unknown;
+}): MigrationImportPlan;

package/dist/shared/tools/migration-import.test.d.ts

@@ -0,0 +1 @@
+export {};