@hasna/sandboxes 0.1.29 → 0.1.30

package/dist/mcp/index.js

@@ -9941,6 +9941,17 @@ 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);
   `
 ];
 var db = null;
@@ -9971,16 +9982,26 @@ function uuid() {
 function now() {
   return new Date().toISOString().replace("T", " ").replace("Z", "");
 }
+var PARTIAL_ID_TABLES = new Set([
+  "agents",
+  "projects",
+  "sandbox_sessions",
+  "sandboxes",
+  "snapshots",
+  "templates",
+  "webhooks"
+]);
 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;
 }
 
@@ -10189,7 +10210,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);
 }
 
@@ -10861,55 +10882,80 @@ function getPackageVersion() {
   return cachedVersion;
 }
 
-// src/db/cloud-config.ts
+// src/db/storage-config.ts
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 import { homedir } from "os";
 import { join as join4 } from "path";
-var CONFIG_PATH = join4(homedir(), ".hasna", "sandboxes", "cloud", "config.json");
-function isMode(value) {
-  return value === "local" || value === "hybrid" || value === "cloud";
+var STORAGE_CONFIG_PATH = join4(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 (existsSync4(CONFIG_PATH)) {
+  if (existsSync4(STORAGE_CONFIG_PATH)) {
     try {
-      const raw = JSON.parse(readFileSync3(CONFIG_PATH, "utf-8"));
-      config.mode = raw.mode ?? config.mode;
+      const raw = JSON.parse(readFileSync3(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}`;
@@ -11005,6 +11051,9 @@ var PG_MIGRATIONS = [
   `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,
@@ -11018,6 +11067,9 @@ var PG_MIGRATIONS = [
   )`,
   `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,
@@ -11029,6 +11081,8 @@ var PG_MIGRATIONS = [
   `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,
@@ -11079,8 +11133,8 @@ var PG_MIGRATIONS = [
   `ALTER TABLE agents ADD COLUMN IF NOT EXISTS active_project_id TEXT REFERENCES projects(id) ON DELETE SET NULL`
 ];
 
-// src/db/cloud-sync.ts
-var CLOUD_TABLES = [
+// src/db/storage-sync.ts
+var STORAGE_TABLES = [
   "projects",
   "agents",
   "sandboxes",
@@ -11174,21 +11228,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 };
@@ -11198,12 +11257,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 {
@@ -11220,12 +11279,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 {
@@ -11242,20 +11301,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/mcp/cloud-tools.ts
+// src/mcp/storage-tools.ts
 function ok(data) {
   return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
 }
@@ -11265,42 +11330,42 @@ function err(error) {
     isError: true
   };
 }
-function registerSandboxesCloudTools(server) {
-  server.tool("sandboxes_cloud_status", "Show sandboxes local database and cloud sync status", {}, async () => {
+function registerSandboxesStorageTools(server) {
+  server.tool("sandboxes_storage_status", "Show sandboxes local database and storage sync status", {}, async () => {
     try {
-      return ok(getCloudStatus());
+      return ok(getStorageStatus());
     } catch (error) {
       return err(error);
     }
   });
-  server.tool("sandboxes_cloud_push", "Push local sandboxes data to PostgreSQL", {
+  server.tool("sandboxes_storage_push", "Push local sandboxes data to PostgreSQL", {
     tables: exports_external.string().optional().describe("Comma-separated table names")
   }, async ({ tables }) => {
     try {
-      return ok(await pushCloudChanges(parseCloudTables(tables)));
+      return ok(await pushStorageChanges(parseStorageTables(tables)));
     } catch (error) {
       return err(error);
     }
   });
-  server.tool("sandboxes_cloud_pull", "Pull PostgreSQL sandboxes data into the local database", {
+  server.tool("sandboxes_storage_pull", "Pull PostgreSQL sandboxes data into the local database", {
     tables: exports_external.string().optional().describe("Comma-separated table names")
   }, async ({ tables }) => {
     try {
-      return ok(await pullCloudChanges(parseCloudTables(tables)));
+      return ok(await pullStorageChanges(parseStorageTables(tables)));
     } catch (error) {
       return err(error);
     }
   });
-  server.tool("sandboxes_cloud_sync", "Push local changes, then pull remote changes", {
+  server.tool("sandboxes_storage_sync", "Push local changes, then pull remote changes", {
     tables: exports_external.string().optional().describe("Comma-separated table names")
   }, async ({ tables }) => {
     try {
-      return ok(await syncCloudChanges(parseCloudTables(tables)));
+      return ok(await syncStorageChanges(parseStorageTables(tables)));
     } catch (error) {
       return err(error);
     }
   });
-  server.tool("sandboxes_cloud_feedback", "Save feedback for sandboxes", {
+  server.tool("sandboxes_feedback", "Save feedback for sandboxes", {
     message: exports_external.string(),
     email: exports_external.string().optional(),
     category: exports_external.enum(["bug", "feature", "general"]).optional()
@@ -12124,7 +12189,7 @@ function buildServer() {
       return err2(e);
     }
   });
-  registerSandboxesCloudTools(server);
+  registerSandboxesStorageTools(server);
   return server;
 }
 

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

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSandboxesStorageTools(server: McpServer): void;