@supacloud/cli 0.76.0 → 0.78.0

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 {};

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

@@ -0,0 +1,36 @@
+/**
+ * Migration Risk Analysis Engine
+ *
+ * Statically analyzes SQL migrations for Expand-Contract violations, destructive DDL,
+ * and lock-heavy operations (e.g. non-concurrent index creation, non-null additions without default).
+ */
+export type MigrationRiskLevel = "HIGH" | "MEDIUM" | "LOW";
+export interface MigrationRiskItem {
+    level: MigrationRiskLevel;
+    type: string;
+    description: string;
+    recommendation: string;
+    statementSnippet?: string;
+    blocksTransactionalPush?: true;
+}
+export interface MigrationFileRisk {
+    file: string;
+    overallRisk: MigrationRiskLevel;
+    risks: MigrationRiskItem[];
+}
+export interface MigrationRiskAnalysis {
+    overallRisk: MigrationRiskLevel;
+    highRiskCount: number;
+    mediumRiskCount: number;
+    lowRiskCount: number;
+    transactionalPushBlockerCount: number;
+    files: MigrationFileRisk[];
+}
+export declare function maskSqlNoise(sql: string): string;
+export declare function splitSqlStatements(sql: string): string[];
+export declare function analyzeMigrationSql(sql: string): MigrationRiskItem[];
+export declare function analyzeMigrationFiles(files: Array<{
+    file: string;
+    sql: string;
+}>): MigrationRiskAnalysis;
+export declare function formatMigrationRiskReport(analysis: MigrationRiskAnalysis): string;

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

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

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

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

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

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

package/dist/shared/tools/oauth-client-tools.d.ts

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

package/dist/shared/tools/oauth-client-tools.test.d.ts

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

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

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

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

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

package/dist/shared/tools/project-endpoint-read.d.ts

@@ -0,0 +1,10 @@
+import type { HttpResult } from "../transports/http";
+export declare const PROJECT_ENDPOINT_RESPONSE_MAX_BYTES: number;
+export declare const PROJECT_ENDPOINT_LIST_RESPONSE_MAX_BYTES: number;
+export type ProjectEndpointReadResult = {
+    text: string;
+    isError: boolean;
+};
+export declare function projectEndpointRead(response: HttpResult<unknown>, expectedRef: string): ProjectEndpointReadResult;
+export declare function projectApiOrigins(response: HttpResult<unknown>, expectedRef: string): string[] | null;
+export declare function projectEndpointListRead(response: HttpResult<unknown>): ProjectEndpointReadResult;

package/dist/shared/tools/project-endpoint-tools.test.d.ts

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

package/dist/shared/tools/project-read-projection.d.ts

@@ -0,0 +1,8 @@
+import type { HttpResult } from "../transports/http";
+export declare const PROJECT_READ_RESPONSE_MAX_BYTES = 1048576;
+export type ProjectReadResult = {
+    text: string;
+    isError: boolean;
+};
+export declare function projectListRead(response: HttpResult<unknown>): ProjectReadResult;
+export declare function projectGetRead(response: HttpResult<unknown>, expectedRef: string): ProjectReadResult;

package/dist/shared/tools/project-read-projection.test.d.ts

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+import type { HttpResult } from "../transports/http";
+export declare const RELEASE_CONTROL_RESPONSE_SCHEMA = "supacloud.cli.release-control.v1";
+export interface ReleaseControlToolResponse {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export declare function releaseControlSuccess(operation: string, payload: Record<string, unknown>): ReleaseControlToolResponse;
+export declare function releaseControlFailure(operation: string, code: "HTTP_ERROR" | "INVALID_RESPONSE" | "MUTATION_NOT_SUCCEEDED" | "OUTCOME_UNKNOWN" | "PARTIAL_SUCCESS", httpStatus: number | null, safeState?: Record<string, unknown>): ReleaseControlToolResponse;
+export declare function releaseControlMutationFailure(operation: string, response: HttpResult<unknown>, safeState?: Record<string, unknown>): ReleaseControlToolResponse;

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

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

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

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

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

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

package/dist/shared/tools/remote-dev-tools.d.ts

@@ -0,0 +1,41 @@
+import { Type } from "typebox";
+import { type ToolServer } from "../tool-server";
+type CommandResult = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+type CommandExecutor = (command: string, args: string[], cwd: string) => Promise<CommandResult>;
+type DatabaseCallback = (args: Record<string, unknown>) => Promise<unknown>;
+export interface RemoteDevToolOptions {
+    cwd?: string;
+    host?: string;
+    sshUser?: string;
+    sshPort?: number;
+    sshKey?: string;
+    projectRef?: string;
+    environment?: string;
+    execute?: CommandExecutor;
+    runDatabase?: DatabaseCallback;
+}
+export declare const remoteDevToolSchema: {
+    action: Type.TEnum<("status" | "migrate" | "watch" | "sync")[]>;
+    target: Type.TOptional<Type.TEnum<("project" | "frontend" | "db" | "functions")[]>>;
+    project_dir: Type.TOptional<Type.TString>;
+    remote_root: Type.TOptional<Type.TString>;
+    remote_host: Type.TOptional<Type.TString>;
+    remote_user: Type.TOptional<Type.TString>;
+    remote_port: Type.TOptional<Type.TNumber>;
+    remote_key: Type.TOptional<Type.TString>;
+    function: Type.TOptional<Type.TString>;
+    delete: Type.TOptional<Type.TBoolean>;
+    reload: Type.TOptional<Type.TBoolean>;
+    interval_ms: Type.TOptional<Type.TNumber>;
+    json: Type.TOptional<Type.TBoolean>;
+    apply: Type.TOptional<Type.TBoolean>;
+    drizzle_config: Type.TOptional<Type.TString>;
+    migrations_dir: Type.TOptional<Type.TString>;
+    drizzle_bin: Type.TOptional<Type.TString>;
+};
+export declare function registerRemoteDevTools(server: ToolServer, options?: RemoteDevToolOptions): void;
+export {};

package/dist/shared/tools/remote-dev-tools.test.d.ts

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

package/dist/shared/tools/scheduled-function-tools.d.ts

@@ -0,0 +1,7 @@
+import type { HttpTransport } from "../transports/http";
+import { type ToolServer } from "../tool-server";
+interface ScheduledFunctionToolsOptions {
+    readOnly?: boolean;
+}
+export declare function registerScheduledFunctionTools(server: ToolServer, http: HttpTransport, environment?: NodeJS.ProcessEnv, options?: ScheduledFunctionToolsOptions): void;
+export {};

package/dist/shared/tools/scheduled-function-tools.test.d.ts

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

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

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

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

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

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

@@ -0,0 +1,49 @@
+import { type ToolInvocation, type ToolServer } from "../tool-server";
+export type SupabaseCliAction = "version" | "init" | "migration_new" | "db_diff" | "db_reset" | "db_pull" | "db_schema_declarative_sync" | "db_schema_declarative_generate" | "db_dump" | "config_pull" | "stack_start" | "stack_prepare" | "stack_status" | "stack_stop" | "stack_destroy" | "migration_list" | "gen_types" | "push";
+export interface SupabaseCliArgs {
+    action: SupabaseCliAction;
+    workdir?: string;
+    ref?: string;
+    name?: string;
+    schema?: string;
+    db_url?: string;
+    file?: string;
+    dir?: string;
+    dry_run?: boolean;
+    declarative?: boolean;
+    apply?: boolean;
+    experimental?: boolean;
+    strict_coverage?: boolean;
+    overwrite?: boolean;
+    runtime?: "docker" | "podman" | "native";
+    eager?: boolean;
+    preparation?: "background" | "on-demand";
+    force?: boolean;
+    yes?: boolean;
+    confirm_destroy?: boolean;
+    no_seed?: boolean;
+    diff_engine?: "migra" | "pg-delta" | "pgadmin" | "pg-schema";
+    dump_mode?: "schema" | "data" | "roles";
+    language?: "typescript" | "go" | "swift" | "python";
+}
+export interface OfficialCliExecutionResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+type MigrationPushCallback = ToolInvocation;
+type OfficialCliExecutor = (request: SupabaseCliArgs) => Promise<OfficialCliExecutionResult>;
+export interface SupabaseCliToolOptions {
+    getPushMigrations?: () => MigrationPushCallback | undefined;
+    executeOfficialCli?: OfficialCliExecutor;
+    environment?: NodeJS.ProcessEnv;
+    currentWorkingDirectory?: string;
+    projectRef?: string;
+    readOnly?: boolean;
+}
+export declare function buildOfficialSupabaseArgs(request: SupabaseCliArgs): string[];
+export declare function createOfficialSupabaseEnvironment(environment: NodeJS.ProcessEnv): Record<string, string>;
+export declare function redactOfficialSupabaseOutput(commandOutput: string, secrets?: string[]): string;
+export declare function resolveOfficialSupabaseCommand(workdir: string, environment?: NodeJS.ProcessEnv): string[];
+export declare function registerSupabaseCliTools(server: ToolServer, options?: SupabaseCliToolOptions): void;
+export {};

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

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

package/dist/shared/transports/http.d.ts

@@ -0,0 +1,68 @@
+/**
+ * SupaCloud CLI HTTP transport layer.
+ *
+ * After SupaCloud is installed, manage projects via Management API (HTTP).
+ * Includes request timeout, retry with exponential backoff, and proper error handling.
+ */
+export interface HttpConfig {
+    baseUrl: string;
+    token: string;
+    apiKey?: string;
+    insecureTls?: boolean;
+}
+export interface HttpResult<T = unknown> {
+    ok: boolean;
+    status: number;
+    data: T;
+    transportError?: boolean;
+    responseReadError?: true;
+}
+export interface HttpGetOptions {
+    timeoutMs?: number;
+    retry?: boolean;
+    /** Complete header/body budget for a bounded JSON GET with retries disabled. */
+    totalTimeoutMs?: number;
+    maxResponseBytes?: number;
+    maxJsonBytes?: number;
+    responseTimeoutMs?: number;
+}
+export interface HttpPostOptions {
+    timeoutMs?: number;
+    maxJsonBytes?: number;
+    responseTimeoutMs?: number;
+}
+export interface HttpReleaseMutationOptions {
+    timeoutMs?: number;
+}
+export interface HttpBinaryPostOptions {
+    contentType: string;
+    contentLength: number;
+    contentSha256: string;
+    maxJsonBytes: number;
+    timeoutMs?: number;
+    responseTimeoutMs?: number;
+}
+export interface HttpBinaryBody {
+    stream: ReadableStream<Uint8Array>;
+    byteLength: number;
+}
+export declare class HttpTransport {
+    private baseUrl;
+    private token;
+    private apiKey;
+    private insecureTls;
+    constructor(config: HttpConfig);
+    private headers;
+    private mutationWithResponseReader;
+    get<T = unknown>(path: string, options?: HttpGetOptions): Promise<HttpResult<T>>;
+    post<T = unknown>(path: string, body?: unknown, options?: HttpPostOptions): Promise<HttpResult<T>>;
+    postReleaseMutation<T = unknown>(path: string, body?: unknown, options?: HttpReleaseMutationOptions): Promise<HttpResult<T>>;
+    postBinary<T = unknown>(path: string, body: HttpBinaryBody, options: HttpBinaryPostOptions): Promise<HttpResult<T>>;
+    patchReleaseMutation<T = unknown>(path: string, body?: unknown): Promise<HttpResult<T>>;
+    deleteReleaseMutation<T = unknown>(path: string, body?: unknown): Promise<HttpResult<T>>;
+    postMultipart<T = unknown>(path: string, formData: FormData, options?: HttpPostOptions): Promise<HttpResult<T>>;
+    patch<T = unknown>(path: string, body?: unknown): Promise<HttpResult<T>>;
+    put<T = unknown>(path: string, body?: unknown, options?: HttpPostOptions): Promise<HttpResult<T>>;
+    delete<T = unknown>(path: string, body?: unknown): Promise<HttpResult<T>>;
+    ping(): Promise<boolean>;
+}

package/dist/shared/transports/http.test.d.ts

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

package/dist/supabase-cli.integration.test.d.ts

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

package/dist/test-helpers.d.ts

@@ -0,0 +1 @@
+export declare function requireValue<T>(value: T | null | undefined): T;

package/dist/tool-runtime.d.ts

@@ -0,0 +1,2 @@
+export { decodedSchema, optional, parseToolArguments, schemaDescription, schemaEnumValues, schemaProperties, stringEnum, validateToolArguments, withDescription, type ToolArguments, type ToolSchema, } from "./shared/schema.js";
+export { registerTool, type ToolCallback, type ToolInvocation, type ToolResult, type ToolServer, type ToolTextContent, } from "./shared/tool-server.js";

package/dist/tool-runtime.js

@@ -0,0 +1,154 @@
+// src/shared/schema.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var DECODE_ID = "~supacloudDecodeId";
+
+class OutputDecodeError extends Error {
+  decodeId;
+  issues;
+  constructor(decodeId, issues) {
+    super(issues.map((issue) => `- ${issue.path}: ${issue.message}`).join(`
+`));
+    this.decodeId = decodeId;
+    this.issues = issues;
+  }
+}
+function decodeIdOf(schema) {
+  const value = Object.getOwnPropertyDescriptor(schema, DECODE_ID)?.value;
+  return typeof value === "symbol" ? value : undefined;
+}
+function schemaErrorPath(path) {
+  return path.replace(/^\//, "").replaceAll("/", ".") || "args";
+}
+function schemaErrorLines(schema, input) {
+  return [...Value.Errors(schema, input)].map((issue) => `- ${schemaErrorPath(issue.instancePath)}: ${issue.message}`);
+}
+function transformErrorLine(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const path = typeof error === "object" && error !== null && "instancePath" in error && typeof error.instancePath === "string" ? schemaErrorPath(error.instancePath) : "args";
+  return `- ${path}: ${message}`;
+}
+function validateToolArguments(schema, input) {
+  const issues = schemaErrorLines(Type.Object(schema, { additionalProperties: false }), input);
+  if (issues.length > 0)
+    throw new Error(`Invalid arguments:
+${issues.join(`
+`)}`);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseToolArguments(schema, input) {
+  const objectSchema = Type.Object(schema, { additionalProperties: false });
+  validateToolArguments(schema, input);
+  let decoded;
+  try {
+    decoded = Value.Decode(objectSchema, input);
+  } catch (error) {
+    if (error instanceof OutputDecodeError) {
+      const entry = Object.entries(schema).find(([, property]) => decodeIdOf(property) === error.decodeId);
+      const path = entry?.[0] ?? "args";
+      const issues = error.issues.map((issue) => `- ${issue.path === "args" ? path : `${path}.${issue.path}`}: ${issue.message}`);
+      throw new Error(`Invalid arguments:
+${issues.join(`
+`)}`);
+    }
+    throw new Error(`Invalid arguments:
+${transformErrorLine(error)}`);
+  }
+  const decodedFields = decoded;
+  if (!isRecord(decodedFields)) {
+    throw new Error("Invalid arguments: decoded value must be an object");
+  }
+  return decoded;
+}
+function stringEnum(values, options) {
+  return Type.Enum([...values], options);
+}
+function mergeSchemaOptions(schema, options) {
+  const result = { ...schema };
+  Object.setPrototypeOf(result, Object.getPrototypeOf(schema));
+  Object.defineProperties(result, Object.getOwnPropertyDescriptors(schema));
+  for (const [key, value] of Object.entries(options)) {
+    Object.defineProperty(result, key, { value, enumerable: true, writable: true, configurable: true });
+  }
+  return result;
+}
+function withDescription(schema, description) {
+  return mergeSchemaOptions(schema, { description });
+}
+function optional(schema, description) {
+  return Type.Optional(description ? withDescription(schema, description) : schema);
+}
+function decodedSchema(inputSchema, outputSchema, decode, options) {
+  const decodeId = Symbol("decodedSchema");
+  const transform = Type.Decode(inputSchema, (input) => {
+    const value = decode(input);
+    const issues = [...Value.Errors(outputSchema, value)].map((issue) => ({
+      path: schemaErrorPath(issue.instancePath),
+      message: issue.message
+    }));
+    if (issues.length > 0)
+      throw new OutputDecodeError(decodeId, issues);
+    return Value.Decode(outputSchema, value);
+  });
+  const result = options ? mergeSchemaOptions(transform, options) : transform;
+  Object.defineProperty(result, DECODE_ID, { value: decodeId, enumerable: false, configurable: true });
+  return result;
+}
+function schemaEnumValues(schema) {
+  const view = schema;
+  if (Array.isArray(view.enum)) {
+    return view.enum.filter((value) => typeof value === "string" || typeof value === "number").map((value) => String(value));
+  }
+  if (typeof view.const === "string" || typeof view.const === "number") {
+    return [String(view.const)];
+  }
+  if (!Array.isArray(view.anyOf))
+    return [];
+  return view.anyOf.flatMap((branch) => {
+    if (typeof branch !== "object" || branch === null || !("const" in branch))
+      return [];
+    const enumValue = branch.const;
+    return typeof enumValue === "string" || typeof enumValue === "number" ? [String(enumValue)] : [];
+  });
+}
+function schemaDescription(schema) {
+  const description = schema.description;
+  return typeof description === "string" ? description : "";
+}
+function schemaProperties(schema) {
+  const properties = schema && typeof schema === "object" ? schema.properties : undefined;
+  if (typeof properties === "object" && properties !== null) {
+    return properties;
+  }
+  return schema;
+}
+// src/shared/tool-server.ts
+import { Type as Type2 } from "typebox";
+import { Value as Value2 } from "typebox/value";
+var resultSchema = Type2.Object({
+  content: Type2.Array(Type2.Object({ type: Type2.Literal("text"), text: Type2.String() })),
+  isError: Type2.Optional(Type2.Boolean())
+});
+function registerTool(server, name, description, schema, callback) {
+  server.tool(name, description, schema, async (input) => {
+    const args = parseToolArguments(schema, input);
+    const result = await callback(args);
+    if (!Value2.Check(resultSchema, result))
+      throw new Error(`Invalid result from tool '${name}'`);
+    return result;
+  });
+}
+export {
+  decodedSchema,
+  optional,
+  parseToolArguments,
+  registerTool,
+  schemaDescription,
+  schemaEnumValues,
+  schemaProperties,
+  stringEnum,
+  validateToolArguments,
+  withDescription
+};

package/dist/tool-runtime.test.d.ts

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

package/package.json

@@ -1,9 +1,22 @@
 {
   "name": "@supacloud/cli",
-  "version": "0.76.0",
+  "version": "0.78.0",
   "description": "Project-scoped CLI for SupaCloud users",
   "type": "module",
   "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./tool-runtime": {
+      "types": "./dist/tool-runtime.d.ts",
+      "import": "./dist/tool-runtime.js",
+      "default": "./dist/tool-runtime.js"
+    }
+  },
   "bin": {
     "supacloud-cli": "dist/index.js"
   },
@@ -18,7 +31,9 @@
     "dev": "bun run --watch src/index.ts",
     "prepare:db": "bun install --cwd ../contracts --frozen-lockfile && bun run --cwd ../contracts build && bun install --cwd ../db --force --frozen-lockfile && bun run --cwd ../db build && bun install --force --frozen-lockfile",
     "prebuild": "bun run prepare:db",
-    "build": "bun build src/index.ts --outdir dist --target node --conditions=supacloud-source",
+    "build": "bun build src/index.ts --outdir dist --target node --conditions=supacloud-source --external @supacloud/compiler && bun run build:tool-runtime && bun run build:types",
+    "build:tool-runtime": "bun build src/tool-runtime.ts --outdir dist --target node --external typebox && tsc -p tsconfig.tool-runtime.json --emitDeclarationOnly",
+    "build:types": "tsc --emitDeclarationOnly",
     "pretypecheck": "bun install --cwd ../delivery --frozen-lockfile && bun install --cwd ../compiler --frozen-lockfile && bun run --cwd ../compiler build && bun run prepare:db",
     "prepublishOnly": "bun run build",
     "typecheck": "tsc --noEmit"
@@ -36,9 +51,9 @@
     "directory": "packages/cli"
   },
   "dependencies": {
-    "@supacloud/compiler": "^0.42.1",
+    "@supacloud/compiler": "^0.43.0",
     "@supacloud/delivery": "0.8.0",
-    "@supacloud/db": "0.15.0",
+    "@supacloud/db": "0.16.0",
     "fflate": "^0.8.3",
     "typebox": "1.3.34"
   },