@hasna/sandboxes 0.1.29 → 0.1.30

package/README.md

@@ -65,19 +65,19 @@ MCP_HTTP=1 sandboxes-mcp
 sandboxes-serve
 ```
 
-## Cloud Sync
+## Storage Sync
 
-Cloud sync is optional. By default sandboxes use local SQLite at `~/.hasna/sandboxes/`.
+Remote storage sync is optional. By default sandboxes use local SQLite at `~/.hasna/sandboxes/`.
 
 ```bash
-sandboxes cloud status
-sandboxes cloud push
-sandboxes cloud pull
-sandboxes cloud sync
+sandboxes storage status
+sandboxes storage push
+sandboxes storage pull
+sandboxes storage sync
 ```
 
-Set `HASNA_SANDBOXES_CLOUD_DATABASE_URL` or configure
-`~/.hasna/sandboxes/cloud/config.json` to run in hybrid/cloud mode with
+Set `HASNA_SANDBOXES_DATABASE_URL` or configure
+`~/.hasna/sandboxes/storage/config.json` to run in hybrid/remote mode with
 PostgreSQL.
 
 ## Data Directory

package/dist/cli/index.js

@@ -993,7 +993,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          } else {}
+          }
         };
       }
       return this;
@@ -2157,18 +2157,19 @@ function now() {
   return new Date().toISOString().replace("T", " ").replace("Z", "");
 }
 function resolvePartialId(table, partialId) {
+  if (!PARTIAL_ID_TABLES.has(table)) {
+    throw new Error(`Invalid partial-id table: ${table}`);
+  }
   const database = getDatabase();
-  const rows = database.query(`SELECT id FROM ${table} WHERE id LIKE ? || '%'`).all(partialId);
-  if (rows.length === 1)
-    return rows[0].id;
-  if (rows.length === 0)
-    return null;
-  const exact = rows.find((r) => r.id === partialId);
+  const exact = database.query(`SELECT id FROM ${table} WHERE id = ?`).get(partialId);
   if (exact)
     return exact.id;
+  const rows = database.query(`SELECT id FROM ${table} WHERE id LIKE ? ORDER BY id LIMIT 2`).all(`${partialId}%`);
+  if (rows.length === 1)
+    return rows[0].id;
   return null;
 }
-var MIGRATIONS, db = null;
+var MIGRATIONS, db = null, PARTIAL_ID_TABLES;
 var init_database = __esm(() => {
   MIGRATIONS = [
     `
@@ -2315,8 +2316,28 @@ INSERT OR IGNORE INTO _migrations (id) VALUES (6);
     `
 ALTER TABLE agents ADD COLUMN active_project_id TEXT REFERENCES projects(id) ON DELETE SET NULL;
 INSERT OR IGNORE INTO _migrations (id) VALUES (7);
+  `,
+    `
+CREATE INDEX IF NOT EXISTS idx_sandboxes_status_created ON sandboxes(status, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_sandboxes_provider_created ON sandboxes(provider, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_sandboxes_project_created ON sandboxes(project_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_sessions_sandbox_started ON sandbox_sessions(sandbox_id, started_at DESC);
+CREATE INDEX IF NOT EXISTS idx_sessions_status_started ON sandbox_sessions(status, started_at DESC);
+CREATE INDEX IF NOT EXISTS idx_sessions_sandbox_status_started ON sandbox_sessions(sandbox_id, status, started_at DESC);
+CREATE INDEX IF NOT EXISTS idx_events_sandbox_created ON sandbox_events(sandbox_id, created_at ASC);
+CREATE INDEX IF NOT EXISTS idx_events_session_created ON sandbox_events(session_id, created_at ASC);
+INSERT OR IGNORE INTO _migrations (id) VALUES (8);
   `
   ];
+  PARTIAL_ID_TABLES = new Set([
+    "agents",
+    "projects",
+    "sandbox_sessions",
+    "sandboxes",
+    "snapshots",
+    "templates",
+    "webhooks"
+  ]);
 });
 
 // node_modules/postgres-array/index.js
@@ -7287,6 +7308,9 @@ var init_pg_migrations = __esm(() => {
     `CREATE INDEX IF NOT EXISTS idx_sandboxes_status ON sandboxes(status)`,
     `CREATE INDEX IF NOT EXISTS idx_sandboxes_provider ON sandboxes(provider)`,
     `CREATE INDEX IF NOT EXISTS idx_sandboxes_project ON sandboxes(project_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_sandboxes_status_created ON sandboxes(status, created_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_sandboxes_provider_created ON sandboxes(provider, created_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_sandboxes_project_created ON sandboxes(project_id, created_at DESC)`,
     `CREATE TABLE IF NOT EXISTS sandbox_sessions (
     id TEXT PRIMARY KEY,
     sandbox_id TEXT NOT NULL REFERENCES sandboxes(id) ON DELETE CASCADE,
@@ -7300,6 +7324,9 @@ var init_pg_migrations = __esm(() => {
   )`,
     `CREATE INDEX IF NOT EXISTS idx_sessions_sandbox ON sandbox_sessions(sandbox_id)`,
     `CREATE INDEX IF NOT EXISTS idx_sessions_status ON sandbox_sessions(status)`,
+    `CREATE INDEX IF NOT EXISTS idx_sessions_sandbox_started ON sandbox_sessions(sandbox_id, started_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_sessions_status_started ON sandbox_sessions(status, started_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_sessions_sandbox_status_started ON sandbox_sessions(sandbox_id, status, started_at DESC)`,
     `CREATE TABLE IF NOT EXISTS sandbox_events (
     id TEXT PRIMARY KEY,
     sandbox_id TEXT NOT NULL REFERENCES sandboxes(id) ON DELETE CASCADE,
@@ -7311,6 +7338,8 @@ var init_pg_migrations = __esm(() => {
     `CREATE INDEX IF NOT EXISTS idx_events_sandbox ON sandbox_events(sandbox_id)`,
     `CREATE INDEX IF NOT EXISTS idx_events_session ON sandbox_events(session_id)`,
     `CREATE INDEX IF NOT EXISTS idx_events_type ON sandbox_events(type)`,
+    `CREATE INDEX IF NOT EXISTS idx_events_sandbox_created ON sandbox_events(sandbox_id, created_at ASC)`,
+    `CREATE INDEX IF NOT EXISTS idx_events_session_created ON sandbox_events(session_id, created_at ASC)`,
     `CREATE TABLE IF NOT EXISTS webhooks (
     id TEXT PRIMARY KEY,
     url TEXT NOT NULL,
@@ -7652,7 +7681,7 @@ function listEvents(opts) {
   const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
   const limit = opts?.limit ?? 100;
   const offset = opts?.offset ?? 0;
-  const rows = db2.query(`SELECT * FROM sandbox_events${where} ORDER BY created_at ASC LIMIT ? OFFSET ?`).all(...[...params, limit, offset]);
+  const rows = db2.query(`SELECT * FROM sandbox_events${where} ORDER BY created_at ASC, rowid ASC LIMIT ? OFFSET ?`).all(...[...params, limit, offset]);
   return rows.map(rowToEvent);
 }
 var init_events = __esm(() => {
@@ -8977,68 +9006,93 @@ var {
 // src/cli/index.tsx
 import chalk2 from "chalk";
 
-// src/cli/cloud.ts
+// src/cli/storage.ts
 import chalk from "chalk";
 
-// src/db/cloud-config.ts
+// src/db/storage-config.ts
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-var CONFIG_PATH = join(homedir(), ".hasna", "sandboxes", "cloud", "config.json");
-function isMode(value) {
-  return value === "local" || value === "hybrid" || value === "cloud";
+var STORAGE_CONFIG_PATH = join(homedir(), ".hasna", "sandboxes", "storage", "config.json");
+var SANDBOXES_STORAGE_ENV = "HASNA_SANDBOXES_DATABASE_URL";
+var SANDBOXES_STORAGE_FALLBACK_ENV = "SANDBOXES_DATABASE_URL";
+var SANDBOXES_STORAGE_MODE_ENV = "HASNA_SANDBOXES_STORAGE_MODE";
+var SANDBOXES_STORAGE_MODE_FALLBACK_ENV = "SANDBOXES_STORAGE_MODE";
+var STORAGE_DATABASE_ENV = [SANDBOXES_STORAGE_ENV, SANDBOXES_STORAGE_FALLBACK_ENV];
+function readEnv(name) {
+  const value = process.env[name]?.trim();
+  return value || undefined;
+}
+function normalizeStorageMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "local" || normalized === "hybrid" || normalized === "remote")
+    return normalized;
+  return;
+}
+function getStorageDatabaseEnvName() {
+  for (const name of STORAGE_DATABASE_ENV) {
+    if (readEnv(name))
+      return name;
+  }
+  return null;
+}
+function getStorageDatabaseEnv() {
+  const name = getStorageDatabaseEnvName();
+  return name ? { name } : null;
 }
-function envConnectionString() {
-  return process.env["HASNA_SANDBOXES_CLOUD_DATABASE_URL"] ?? process.env["OPEN_SANDBOXES_CLOUD_DATABASE_URL"] ?? process.env["SANDBOXES_CLOUD_DATABASE_URL"];
+function getStorageDatabaseUrl() {
+  const env = getStorageDatabaseEnv();
+  return env ? readEnv(env.name) : undefined;
 }
-function getCloudConfig() {
+function getStorageConfig() {
   const config = {
     mode: "local",
     rds: {
       host: "",
       port: 5432,
       username: "",
-      password_env: "SANDBOXES_CLOUD_DATABASE_PASSWORD",
+      password_env: "SANDBOXES_DATABASE_PASSWORD",
       ssl: true
     }
   };
-  if (existsSync(CONFIG_PATH)) {
+  if (existsSync(STORAGE_CONFIG_PATH)) {
     try {
-      const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
-      config.mode = raw.mode ?? config.mode;
+      const raw = JSON.parse(readFileSync(STORAGE_CONFIG_PATH, "utf-8"));
+      config.mode = normalizeStorageMode(raw.mode) ?? config.mode;
       config.rds = { ...config.rds, ...raw.rds ?? {} };
     } catch {}
   }
-  const modeOverride = process.env["HASNA_SANDBOXES_CLOUD_MODE"] ?? process.env["OPEN_SANDBOXES_CLOUD_MODE"] ?? process.env["SANDBOXES_CLOUD_MODE"];
-  if (isMode(modeOverride)) {
-    config.mode = modeOverride;
-  } else if (envConnectionString() && config.mode === "local") {
+  const modeOverride = readEnv(SANDBOXES_STORAGE_MODE_ENV) ?? readEnv(SANDBOXES_STORAGE_MODE_FALLBACK_ENV);
+  const mode = normalizeStorageMode(modeOverride);
+  if (mode) {
+    config.mode = mode;
+  } else if (getStorageDatabaseUrl() && config.mode === "local") {
     config.mode = "hybrid";
   }
   return config;
 }
-function getConnectionString(dbName = "sandboxes") {
-  const direct = envConnectionString();
+function getStorageConnectionString(dbName = "sandboxes") {
+  const direct = getStorageDatabaseUrl();
   if (direct)
     return direct;
-  const config = getCloudConfig();
+  const config = getStorageConfig();
   const { host, port, username, password_env, ssl } = config.rds;
   if (!host || !username) {
-    throw new Error("Cloud database is not configured. Set HASNA_SANDBOXES_CLOUD_DATABASE_URL or configure ~/.hasna/sandboxes/cloud/config.json.");
+    throw new Error("Storage database is not configured. Set HASNA_SANDBOXES_DATABASE_URL or configure ~/.hasna/sandboxes/storage/config.json.");
   }
   const password = process.env[password_env];
   if (!password) {
-    throw new Error(`Cloud database password is not set. Export ${password_env}.`);
+    throw new Error(`Storage database password is not set. Export ${password_env}.`);
   }
   const sslParam = ssl ? "?sslmode=require" : "";
   return `postgres://${username}:${encodeURIComponent(password)}@${host}:${port}/${dbName}${sslParam}`;
 }
 
-// src/db/cloud-sync.ts
+// src/db/storage-sync.ts
 init_database();
 init_remote_storage();
 init_pg_migrations();
-var CLOUD_TABLES = [
+var STORAGE_TABLES = [
   "projects",
   "agents",
   "sandboxes",
@@ -9132,21 +9186,26 @@ function upsertSqlite(db2, table, rows) {
   }
   return written;
 }
-async function getCloudPg() {
-  return new PgAdapterAsync(getConnectionString("sandboxes"));
+async function getStoragePg() {
+  return new PgAdapterAsync(getStorageConnectionString("sandboxes"));
 }
-async function runCloudMigrations(remote) {
+async function runStorageMigrations(remote) {
   for (const migration of PG_MIGRATIONS) {
     await remote.exec(migration);
   }
 }
-function getCloudStatus(db2 = getDatabase()) {
-  const config = getCloudConfig();
+function getStorageStatus(db2 = getDatabase()) {
+  const config = getStorageConfig();
+  const activeEnv = getStorageDatabaseEnv();
   return {
+    configured: Boolean(activeEnv),
     mode: config.mode,
-    enabled: config.mode === "hybrid" || config.mode === "cloud",
+    enabled: config.mode === "hybrid" || config.mode === "remote",
+    env: STORAGE_DATABASE_ENV,
+    activeEnv: activeEnv?.name ?? null,
+    service: "sandboxes",
     db_path: getDbPath(),
-    tables: CLOUD_TABLES.map((table) => {
+    tables: STORAGE_TABLES.map((table) => {
       try {
         const row = db2.query(`SELECT COUNT(*) as count FROM ${quoteId(table)}`).get();
         return { table, rows: row.count };
@@ -9156,12 +9215,12 @@ function getCloudStatus(db2 = getDatabase()) {
     })
   };
 }
-async function pushCloudChanges(tables = [...CLOUD_TABLES]) {
+async function pushStorageChanges(tables = [...STORAGE_TABLES]) {
   const db2 = getDatabase();
-  const remote = await getCloudPg();
+  const remote = await getStoragePg();
   const results = [];
   try {
-    await runCloudMigrations(remote);
+    await runStorageMigrations(remote);
     for (const table of tables) {
       const result = { table, direction: "push", rowsRead: 0, rowsWritten: 0, errors: [] };
       try {
@@ -9178,12 +9237,12 @@ async function pushCloudChanges(tables = [...CLOUD_TABLES]) {
   }
   return results;
 }
-async function pullCloudChanges(tables = [...CLOUD_TABLES]) {
+async function pullStorageChanges(tables = [...STORAGE_TABLES]) {
   const db2 = getDatabase();
-  const remote = await getCloudPg();
+  const remote = await getStoragePg();
   const results = [];
   try {
-    await runCloudMigrations(remote);
+    await runStorageMigrations(remote);
     for (const table of tables) {
       const result = { table, direction: "pull", rowsRead: 0, rowsWritten: 0, errors: [] };
       try {
@@ -9200,20 +9259,26 @@ async function pullCloudChanges(tables = [...CLOUD_TABLES]) {
   }
   return results;
 }
-async function syncCloudChanges(tables = [...CLOUD_TABLES]) {
+async function syncStorageChanges(tables = [...STORAGE_TABLES]) {
   return {
-    push: await pushCloudChanges(tables),
-    pull: await pullCloudChanges(tables)
+    push: await pushStorageChanges(tables),
+    pull: await pullStorageChanges(tables)
   };
 }
-function parseCloudTables(raw) {
+function parseStorageTables(raw) {
   if (!raw)
-    return [...CLOUD_TABLES];
+    return [...STORAGE_TABLES];
   const requested = raw.split(",").map((table) => table.trim()).filter(Boolean);
-  return requested.length > 0 ? requested : [...CLOUD_TABLES];
+  if (requested.length === 0)
+    return [...STORAGE_TABLES];
+  const allowed = new Set(STORAGE_TABLES);
+  const invalid = requested.filter((table) => !allowed.has(table));
+  if (invalid.length > 0)
+    throw new Error(`Unknown sandboxes sync table(s): ${invalid.join(", ")}`);
+  return requested;
 }
 
-// src/cli/cloud.ts
+// src/cli/storage.ts
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
 }
@@ -9226,10 +9291,10 @@ function printResults(results) {
     }
   }
 }
-function registerCloudCommands(program2) {
-  const cloud = program2.command("cloud").description("Manage sandboxes local/remote cloud sync");
-  cloud.command("status").description("Show local database and cloud sync status").option("--json", "Output as JSON").action((opts) => {
-    const status = getCloudStatus();
+function registerStorageCommands(program2) {
+  const storage = program2.command("storage").description("Manage sandboxes local/remote storage sync");
+  storage.command("status").description("Show local database and storage sync status").option("--json", "Output as JSON").action((opts) => {
+    const status = getStorageStatus();
     if (opts.json) {
       printJson(status);
       return;
@@ -9241,9 +9306,9 @@ function registerCloudCommands(program2) {
       console.log(`  ${table.table}: ${table.rows}`);
     }
   });
-  cloud.command("push").description("Push local sandboxes data to PostgreSQL").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+  storage.command("push").description("Push local sandboxes data to PostgreSQL").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
     try {
-      const results = await pushCloudChanges(parseCloudTables(opts.tables));
+      const results = await pushStorageChanges(parseStorageTables(opts.tables));
       if (opts.json)
         printJson(results);
       else
@@ -9256,9 +9321,9 @@ function registerCloudCommands(program2) {
       process.exitCode = 1;
     }
   });
-  cloud.command("pull").description("Pull PostgreSQL sandboxes data into the local database").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+  storage.command("pull").description("Pull PostgreSQL sandboxes data into the local database").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
     try {
-      const results = await pullCloudChanges(parseCloudTables(opts.tables));
+      const results = await pullStorageChanges(parseStorageTables(opts.tables));
       if (opts.json)
         printJson(results);
       else
@@ -9271,9 +9336,9 @@ function registerCloudCommands(program2) {
       process.exitCode = 1;
     }
   });
-  cloud.command("sync").description("Push local changes, then pull remote changes").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+  storage.command("sync").description("Push local changes, then pull remote changes").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
     try {
-      const result = await syncCloudChanges(parseCloudTables(opts.tables));
+      const result = await syncStorageChanges(parseStorageTables(opts.tables));
       if (opts.json) {
         printJson(result);
         return;
@@ -9290,10 +9355,10 @@ function registerCloudCommands(program2) {
       process.exitCode = 1;
     }
   });
-  cloud.command("migrate").description("Apply PostgreSQL migrations").option("--connection-string <url>", "PostgreSQL connection string").option("--json", "Output as JSON").action(async (opts) => {
+  storage.command("migrate").description("Apply PostgreSQL migrations").option("--connection-string <url>", "PostgreSQL connection string").option("--json", "Output as JSON").action(async (opts) => {
     try {
       const { applyPgMigrations: applyPgMigrations2 } = await Promise.resolve().then(() => (init_pg_migrate(), exports_pg_migrate));
-      const result = await applyPgMigrations2(opts.connectionString || getConnectionString("sandboxes"));
+      const result = await applyPgMigrations2(opts.connectionString || getStorageConnectionString("sandboxes"));
       if (opts.json) {
         printJson(result);
         return;
@@ -9442,7 +9507,7 @@ function parseEnvVars(envArgs) {
   return vars;
 }
 var program2 = new Command().name("sandboxes").description("Universal cloud sandbox manager for AI coding agents").version(getPackageVersion());
-registerCloudCommands(program2);
+registerStorageCommands(program2);
 program2.command("create").description("Create a new sandbox").option("-p, --provider <provider>", "Provider (e2b, daytona, modal)").option("-i, --image <image>", "Container image").option("-t, --timeout <seconds>", "Timeout in seconds").option("-n, --name <name>", "Sandbox name").option("-e, --env <KEY=VAL...>", "Environment variables", (val, acc) => {
   acc.push(val);
   return acc;

package/dist/cli/storage.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerStorageCommands(program: Command): void;

package/dist/db/pg-migrations.d.ts

@@ -1,5 +1,5 @@
 /**
- * PostgreSQL migrations for open-sandboxes cloud sync.
+ * PostgreSQL migrations for open-sandboxes storage sync.
  *
  * Equivalent to the SQLite schema in database.ts, translated for PostgreSQL.
  */

package/dist/db/storage-config.d.ts

@@ -0,0 +1,26 @@
+export type StorageMode = "local" | "hybrid" | "remote";
+export interface StorageConfig {
+    mode: StorageMode;
+    rds: {
+        host: string;
+        port: number;
+        username: string;
+        password_env: string;
+        ssl: boolean;
+    };
+}
+export interface StorageEnv {
+    name: string;
+}
+export declare const SANDBOXES_STORAGE_ENV = "HASNA_SANDBOXES_DATABASE_URL";
+export declare const SANDBOXES_STORAGE_FALLBACK_ENV = "SANDBOXES_DATABASE_URL";
+export declare const SANDBOXES_STORAGE_MODE_ENV = "HASNA_SANDBOXES_STORAGE_MODE";
+export declare const SANDBOXES_STORAGE_MODE_FALLBACK_ENV = "SANDBOXES_STORAGE_MODE";
+export declare const STORAGE_DATABASE_ENV: readonly ["HASNA_SANDBOXES_DATABASE_URL", "SANDBOXES_DATABASE_URL"];
+export declare const STORAGE_MODE_ENV: readonly ["HASNA_SANDBOXES_STORAGE_MODE", "SANDBOXES_STORAGE_MODE"];
+export declare function getStorageDatabaseEnvName(): (typeof STORAGE_DATABASE_ENV)[number] | null;
+export declare function getStorageDatabaseEnv(): StorageEnv | null;
+export declare function getStorageDatabaseUrl(): string | undefined;
+export declare function getStorageConfig(): StorageConfig;
+export declare function getStorageConnectionString(dbName?: string): string;
+export declare const getConnectionString: typeof getStorageConnectionString;

package/dist/db/storage-sync.d.ts

@@ -0,0 +1,35 @@
+import { type Database } from "bun:sqlite";
+import { STORAGE_DATABASE_ENV, type StorageMode } from "./storage-config.js";
+import { PgAdapterAsync } from "./remote-storage.js";
+export interface SyncResult {
+    table: string;
+    direction: "push" | "pull";
+    rowsRead: number;
+    rowsWritten: number;
+    errors: string[];
+}
+export interface StorageStatus {
+    configured: boolean;
+    mode: StorageMode;
+    enabled: boolean;
+    env: typeof STORAGE_DATABASE_ENV;
+    activeEnv: string | null;
+    service: "sandboxes";
+    db_path: string;
+    tables: Array<{
+        table: string;
+        rows: number;
+    }>;
+}
+export declare const STORAGE_TABLES: readonly ["projects", "agents", "sandboxes", "sandbox_sessions", "sandbox_events", "webhooks", "templates", "snapshots", "feedback"];
+export declare const SANDBOXES_STORAGE_TABLES: readonly ["projects", "agents", "sandboxes", "sandbox_sessions", "sandbox_events", "webhooks", "templates", "snapshots", "feedback"];
+export declare function getStoragePg(): Promise<PgAdapterAsync>;
+export declare function runStorageMigrations(remote: PgAdapterAsync): Promise<void>;
+export declare function getStorageStatus(db?: Database): StorageStatus;
+export declare function pushStorageChanges(tables?: string[]): Promise<SyncResult[]>;
+export declare function pullStorageChanges(tables?: string[]): Promise<SyncResult[]>;
+export declare function syncStorageChanges(tables?: string[]): Promise<{
+    push: SyncResult[];
+    pull: SyncResult[];
+}>;
+export declare function parseStorageTables(raw?: string): string[];

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export * from "./types/index.js";
 export { getDatabase, closeDatabase, resetDatabase, uuid, shortId, now, resolvePartialId } from "./db/database.js";
-export { getCloudConfig, getConnectionString } from "./db/cloud-config.js";
+export { SANDBOXES_STORAGE_ENV, SANDBOXES_STORAGE_FALLBACK_ENV, SANDBOXES_STORAGE_MODE_ENV, SANDBOXES_STORAGE_MODE_FALLBACK_ENV, STORAGE_DATABASE_ENV, STORAGE_MODE_ENV, getConnectionString, getStorageConfig, getStorageConnectionString, getStorageDatabaseEnv, getStorageDatabaseEnvName, getStorageDatabaseUrl, type StorageConfig, type StorageEnv, type StorageMode, } from "./db/storage-config.js";
 export { PgAdapterAsync } from "./db/remote-storage.js";
 export { applyPgMigrations } from "./db/pg-migrate.js";
-export { CLOUD_TABLES, getCloudPg, getCloudStatus, parseCloudTables, pullCloudChanges, pushCloudChanges, runCloudMigrations, syncCloudChanges, } from "./db/cloud-sync.js";
-export type { CloudStatus, SyncResult } from "./db/cloud-sync.js";
+export { SANDBOXES_STORAGE_TABLES, STORAGE_TABLES, getStoragePg, getStorageStatus, parseStorageTables, pullStorageChanges, pushStorageChanges, runStorageMigrations, syncStorageChanges, } from "./db/storage-sync.js";
+export type { StorageStatus, SyncResult } from "./db/storage-sync.js";
 export { createSandbox, getSandbox, listSandboxes, updateSandbox, deleteSandbox } from "./db/sandboxes.js";
 export { createSession, getSession, listSessions, updateSession, endSession } from "./db/sessions.js";
 export { addEvent, listEvents } from "./db/events.js";