@axiom-lattice/core 2.1.73 → 2.1.74

package/dist/index.js

@@ -79,6 +79,7 @@ __export(index_exports, {
   MicrosandboxRemoteProvider: () => MicrosandboxRemoteProvider,
   MicrosandboxServiceClient: () => MicrosandboxServiceClient,
   ModelLatticeManager: () => ModelLatticeManager,
+  MysqlDatabase: () => MysqlDatabase,
   PinoLoggerClient: () => PinoLoggerClient,
   PostgresDatabase: () => PostgresDatabase,
   PrometheusClient: () => PrometheusClient,
@@ -143,6 +144,7 @@ __export(index_exports, {
   ensureBuiltinAgentsForTenant: () => ensureBuiltinAgentsForTenant,
   eventBus: () => eventBus,
   eventBusDefault: () => event_bus_default,
+  extractFetcherError: () => extractFetcherError,
   fileDataToString: () => fileDataToString,
   formatContentWithLineNumbers: () => formatContentWithLineNumbers,
   formatGrepMatches: () => formatGrepMatches,
@@ -3284,6 +3286,168 @@ var PostgresDatabase = class {
     }
   }
 };
+var MysqlDatabase = class {
+  constructor(config) {
+    // mysql2.Pool
+    this.connected = false;
+    this.config = config;
+  }
+  async connect() {
+    if (this.connected && this.pool) return;
+    try {
+      const mysql = await import("mysql2/promise");
+      const poolConfig = this.config.connectionString ? { uri: this.config.connectionString } : {
+        host: this.config.host || "localhost",
+        port: this.config.port || 3306,
+        database: this.config.database,
+        user: this.config.user,
+        password: this.config.password,
+        ssl: this.config.ssl ? { rejectUnauthorized: false } : void 0
+      };
+      this.pool = mysql.createPool({
+        ...poolConfig,
+        waitForConnections: true,
+        connectionLimit: 10,
+        maxIdle: 10,
+        idleTimeout: 6e4,
+        queueLimit: 0,
+        enableKeepAlive: true,
+        keepAliveInitialDelay: 0
+      });
+      const connection = await this.pool.getConnection();
+      try {
+        await connection.query("SELECT 1");
+      } finally {
+        connection.release();
+      }
+      this.connected = true;
+    } catch (error) {
+      this.connected = false;
+      throw new Error(`Failed to connect to MySQL: ${error}`);
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      try {
+        await this.pool.end();
+      } catch (error) {
+        console.warn("Warning: Error closing MySQL pool:", error);
+      } finally {
+        this.pool = null;
+        this.connected = false;
+      }
+    }
+  }
+  async listTables() {
+    await this.ensureConnected();
+    const query = `
+      SELECT TABLE_NAME, TABLE_SCHEMA
+      FROM information_schema.TABLES
+      WHERE TABLE_SCHEMA NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')
+        AND TABLE_SCHEMA = DATABASE()
+        AND TABLE_TYPE = 'BASE TABLE'
+      ORDER BY TABLE_SCHEMA, TABLE_NAME
+    `;
+    const [rows] = await this.pool.query(query);
+    return rows.map((row) => ({
+      name: row.TABLE_NAME,
+      schema: row.TABLE_SCHEMA
+    }));
+  }
+  async getTableInfo(tables) {
+    await this.ensureConnected();
+    const schemas = [];
+    for (const tableName of tables) {
+      const rawName = tableName.includes(".") ? tableName.split(".").pop() : tableName;
+      const columnQuery = `
+        SELECT
+          c.COLUMN_NAME,
+          c.DATA_TYPE,
+          c.IS_NULLABLE,
+          c.COLUMN_DEFAULT
+        FROM information_schema.COLUMNS c
+        WHERE c.TABLE_NAME = ?
+          AND c.TABLE_SCHEMA = DATABASE()
+        ORDER BY c.ORDINAL_POSITION
+      `;
+      const pkQuery = `
+        SELECT k.COLUMN_NAME
+        FROM information_schema.TABLE_CONSTRAINTS t
+        JOIN information_schema.KEY_COLUMN_USAGE k
+          ON t.CONSTRAINT_NAME = k.CONSTRAINT_NAME
+          AND t.TABLE_SCHEMA = k.TABLE_SCHEMA
+          AND t.TABLE_NAME = k.TABLE_NAME
+        WHERE t.CONSTRAINT_TYPE = 'PRIMARY KEY'
+          AND t.TABLE_NAME = ?
+          AND t.TABLE_SCHEMA = DATABASE()
+      `;
+      const fkQuery = `
+        SELECT
+          k.COLUMN_NAME,
+          k.REFERENCED_TABLE_NAME,
+          k.REFERENCED_COLUMN_NAME
+        FROM information_schema.KEY_COLUMN_USAGE k
+        WHERE k.TABLE_NAME = ?
+          AND k.TABLE_SCHEMA = DATABASE()
+          AND k.REFERENCED_TABLE_NAME IS NOT NULL
+      `;
+      const [columnRows] = await this.pool.query(columnQuery, [rawName]);
+      const [pkRows] = await this.pool.query(pkQuery, [rawName]);
+      const [fkRows] = await this.pool.query(fkQuery, [rawName]);
+      const pkColumns = new Set(pkRows.map((r) => r.COLUMN_NAME));
+      const fkMap = /* @__PURE__ */ new Map();
+      for (const row of fkRows) {
+        fkMap.set(row.COLUMN_NAME, {
+          foreignTable: row.REFERENCED_TABLE_NAME,
+          foreignColumn: row.REFERENCED_COLUMN_NAME
+        });
+      }
+      const columns = columnRows.map((row) => {
+        const fkRef = fkMap.get(row.COLUMN_NAME);
+        return {
+          name: row.COLUMN_NAME,
+          type: row.DATA_TYPE,
+          nullable: row.IS_NULLABLE === "YES",
+          default: row.COLUMN_DEFAULT,
+          isPrimaryKey: pkColumns.has(row.COLUMN_NAME),
+          isForeignKey: fkRef !== void 0,
+          foreignKeyRef: fkRef ? `${fkRef.foreignTable}.${fkRef.foreignColumn}` : void 0
+        };
+      });
+      let sampleRows = [];
+      try {
+        const sampleQuery = `SELECT * FROM \`${rawName}\` LIMIT 3`;
+        const [sampleResult] = await this.pool.query(sampleQuery);
+        sampleRows = sampleResult;
+      } catch {
+      }
+      schemas.push({
+        tableName,
+        columns,
+        sampleRows
+      });
+    }
+    return schemas;
+  }
+  async executeQuery(query) {
+    await this.ensureConnected();
+    const [rows, fields] = await this.pool.query(query);
+    const isSelectResult = Array.isArray(rows);
+    return {
+      rows: isSelectResult ? rows : [],
+      rowCount: isSelectResult ? rows.length : rows.affectedRows || 0,
+      fields: fields?.map((f) => f.name)
+    };
+  }
+  getDatabaseType() {
+    return "mysql";
+  }
+  async ensureConnected() {
+    if (!this.connected) {
+      await this.connect();
+    }
+  }
+};
 var SqlDatabaseManager = class _SqlDatabaseManager {
   constructor() {
     this.databases = /* @__PURE__ */ new Map();
@@ -3323,7 +3487,8 @@ var SqlDatabaseManager = class _SqlDatabaseManager {
         database = new PostgresDatabase(config);
         break;
       case "mysql":
-        throw new Error("MySQL support not yet implemented");
+        database = new MysqlDatabase(config);
+        break;
       case "sqlite":
         throw new Error("SQLite support not yet implemented");
       default:
@@ -5858,7 +6023,7 @@ var SandboxLatticeManager = class _SandboxLatticeManager extends BaseLatticeMana
     const tenantId = config.tenantId ?? "default";
     const mapping = this._resolveVolumeForPath(config, tenantId, filePath);
     if (!mapping) return null;
-    const client = provider.createVolumeFsClient(mapping.volumeName);
+    const client = provider.createVolumeFsClient(mapping.volumeName, mapping.pathPrefix);
     return new VolumeFilesystem(stripPrefixClient(client, mapping.pathPrefix), mapping.pathPrefix);
   }
   _resolveVolumeForPath(config, tenantId, filePath) {
@@ -21471,7 +21636,7 @@ var MicrosandboxRemoteProvider = class {
     this.instances.delete(name);
     await this.client.deleteSandbox(name);
   }
-  createVolumeFsClient(volumeName) {
+  createVolumeFsClient(volumeName, _pathPrefix) {
     return {
       read: (path3) => this.client.volumeFsRead(volumeName, path3),
       write: (path3, content) => this.client.volumeFsWrite(volumeName, path3, content),
@@ -21528,50 +21693,84 @@ var MicrosandboxRemoteProvider = class {
 var import_sandbox23 = require("@agent-infra/sandbox");
 
 // src/sandbox_lattice/RemoteSandboxInstance.ts
+function extractFetcherError(error) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error && typeof error === "object") {
+    const e = error;
+    if (typeof e.reason === "string") {
+      switch (e.reason) {
+        case "status-code":
+          return `HTTP ${e.statusCode}: ${JSON.stringify(e.body)}`;
+        case "non-json":
+          return `HTTP ${e.statusCode}: ${e.rawBody}`;
+        case "timeout":
+          return "Request timed out";
+        case "unknown":
+          return typeof e.errorMessage === "string" ? e.errorMessage : "Unknown error";
+      }
+    }
+    if (typeof e.message === "string") {
+      return e.message;
+    }
+    if (typeof e.error === "string") {
+      return e.error;
+    }
+    return JSON.stringify(error);
+  }
+  return String(error);
+}
 var RemoteSandboxInstance = class {
-  constructor(name, client) {
+  constructor(name, client, workspace) {
     this.client = client;
+    this.workspace = workspace;
     this.file = {
       readFile: async (file) => {
-        const result = await this.client.file.readFile({ file });
+        const resolved = this.resolvePath(file);
+        const result = await this.client.file.readFile({ file: resolved });
         if (!result.ok) {
-          throw new Error(String(result.error));
+          throw new Error(`readFile failed: ${extractFetcherError(result.error)}`);
         }
         return { content: result.body.data?.content ?? "" };
       },
       writeFile: async (file, content) => {
-        const result = await this.client.file.writeFile({ file, content });
+        const resolved = this.resolvePath(file);
+        const result = await this.client.file.writeFile({ file: resolved, content });
         if (!result.ok) {
-          throw new Error(String(result.error));
+          throw new Error(`writeFile failed: ${extractFetcherError(result.error)}`);
         }
       },
       listPath: async (path3, options) => {
+        const resolved = this.resolvePath(path3);
         const result = await this.client.file.listPath({
-          path: path3,
+          path: resolved,
           recursive: options?.recursive ?? false
         });
         if (!result.ok) {
-          throw new Error(String(result.error));
+          throw new Error(`listPath failed: ${extractFetcherError(result.error)}`);
         }
         const files = (result.body.data?.files || []).map((f) => ({
           path: f.path,
-          is_dir: f.is_dir ?? false,
-          size: f.size,
+          is_dir: f.is_dir === true || f.size === null,
+          size: f.size ?? void 0,
           modified_at: f.modified_at
         }));
         return { files };
       },
       findFiles: async (path3, glob) => {
-        const result = await this.client.file.findFiles({ path: path3, glob });
+        const resolved = this.resolvePath(path3);
+        const result = await this.client.file.findFiles({ path: resolved, glob });
         if (!result.ok) {
-          throw new Error(String(result.error));
+          throw new Error(`findFiles failed: ${extractFetcherError(result.error)}`);
         }
         return { files: result.body.data?.files || [] };
       },
       searchInFile: async (file, regex) => {
-        const result = await this.client.file.searchInFile({ file, regex });
+        const resolved = this.resolvePath(file);
+        const result = await this.client.file.searchInFile({ file: resolved, regex });
         if (!result.ok) {
-          throw new Error(String(result.error));
+          throw new Error(`searchInFile failed: ${extractFetcherError(result.error)}`);
         }
         return {
           matches: result.body.data?.matches || [],
@@ -21579,30 +21778,33 @@ var RemoteSandboxInstance = class {
         };
       },
       strReplaceEditor: async (params) => {
+        const resolved = this.resolvePath(params.path);
         const result = await this.client.file.strReplaceEditor({
           command: params.command,
-          path: params.path,
+          path: resolved,
           old_str: params.old_str,
           new_str: params.new_str,
           replace_mode: params.replace_mode
         });
         if (!result.ok) {
-          throw new Error(String(result.error));
+          throw new Error(`strReplaceEditor failed: ${extractFetcherError(result.error)}`);
         }
       },
       uploadFile: async (params) => {
+        const resolved = this.resolvePath(params.file);
         const result = await this.client.file.uploadFile({
           file: params.data,
-          path: params.file
+          path: resolved
         });
         if (!result.ok) {
-          throw new Error(String(result.error));
+          throw new Error(`uploadFile failed: ${extractFetcherError(result.error)}`);
         }
       },
       downloadFile: async (params) => {
-        const result = await this.client.file.downloadFile({ path: params.file });
+        const resolved = this.resolvePath(params.file);
+        const result = await this.client.file.downloadFile({ path: resolved });
         if (!result.ok) {
-          throw new Error(String(result.error));
+          throw new Error(`downloadFile failed: ${extractFetcherError(result.error)}`);
         }
         const buffer2 = await result.body.arrayBuffer();
         return Buffer.from(buffer2);
@@ -21612,11 +21814,11 @@ var RemoteSandboxInstance = class {
       execCommand: async (params) => {
         const result = await this.client.shell.execCommand({
           command: params.command,
-          exec_dir: params.exec_dir,
+          exec_dir: params.exec_dir ? this.resolvePath(params.exec_dir) : void 0,
           timeout: params.timeout
         });
         if (!result.ok) {
-          throw new Error(String(result.error));
+          throw new Error(`execCommand failed: ${extractFetcherError(result.error)}`);
         }
         return {
           output: result.body.data?.output ?? "",
@@ -21626,6 +21828,15 @@ var RemoteSandboxInstance = class {
     };
     this.name = name;
   }
+  resolvePath(file) {
+    if (file.startsWith(this.workspace)) {
+      return file;
+    }
+    if (!file.startsWith("/")) {
+      return `${this.workspace}/${file}`;
+    }
+    return `${this.workspace}${file}`;
+  }
   async start() {
   }
   async stop() {
@@ -21646,23 +21857,58 @@ var RemoteSandboxInstance = class {
 };
 
 // src/sandbox_lattice/providers/RemoteSandboxProvider.ts
+var DEFAULT_WORKSPACE = "/home/gem";
 var RemoteSandboxProvider = class {
   constructor(config) {
     this.config = config;
     this.instances = /* @__PURE__ */ new Map();
+    this.creating = /* @__PURE__ */ new Map();
+    this.workspace = DEFAULT_WORKSPACE;
+    this.workspaceResolved = false;
     this.client = new import_sandbox23.SandboxClient({
       baseUrl: config.baseURL,
       environment: ""
     });
   }
+  async resolveWorkspace() {
+    if (this.workspaceResolved) {
+      return this.workspace;
+    }
+    try {
+      const result = await this.client.sandbox.getContext();
+      if (result.ok && result.body.home_dir) {
+        this.workspace = result.body.home_dir;
+      }
+    } catch {
+    }
+    this.workspaceResolved = true;
+    return this.workspace;
+  }
   async createSandbox(name, _config) {
     const existing = this.instances.get(name);
     if (existing) {
       return existing;
     }
-    const instance = new RemoteSandboxInstance(name, this.client);
-    this.instances.set(name, instance);
-    return instance;
+    const inFlight = this.creating.get(name);
+    if (inFlight) {
+      return inFlight;
+    }
+    const creation = (async () => {
+      const workspace = await this.resolveWorkspace();
+      const instance = new RemoteSandboxInstance(name, this.client, workspace);
+      this.instances.set(name, instance);
+      return instance;
+    })();
+    this.creating.set(name, creation);
+    creation.then(
+      () => {
+        this.creating.delete(name);
+      },
+      () => {
+        this.creating.delete(name);
+      }
+    );
+    return creation;
   }
   async getSandbox(name) {
     const instance = this.instances.get(name);
@@ -21672,9 +21918,7 @@ var RemoteSandboxProvider = class {
     return instance;
   }
   async stopSandbox(name) {
-    const instance = this.instances.get(name);
-    if (instance) {
-    }
+    this.instances.delete(name);
   }
   async deleteSandbox(name) {
     this.instances.delete(name);
@@ -21682,6 +21926,82 @@ var RemoteSandboxProvider = class {
   async listSandboxes() {
     return Array.from(this.instances.values());
   }
+  createVolumeFsClient(_volumeName, pathPrefix) {
+    const workspace = this.workspace;
+    const resolve3 = (p) => {
+      if (!p || p === "/") {
+        if (pathPrefix) {
+          return `${workspace}${pathPrefix}`;
+        }
+        return workspace;
+      }
+      if (p.startsWith(workspace)) {
+        return p;
+      }
+      if (p.startsWith("/")) {
+        return `${workspace}${p}`;
+      }
+      if (pathPrefix) {
+        const mountDir = pathPrefix.replace(/^\//, "");
+        return `${workspace}/${mountDir}/${p}`;
+      }
+      return `${workspace}/${p}`;
+    };
+    return {
+      read: async (path3) => {
+        const resolved = resolve3(path3);
+        const result = await this.client.file.readFile({ file: resolved });
+        if (!result.ok) {
+          throw new Error(`Volume read failed: ${extractFetcherError(result.error)}`);
+        }
+        return result.body.data?.content ?? "";
+      },
+      write: async (path3, content) => {
+        const resolved = resolve3(path3);
+        const result = await this.client.file.writeFile({ file: resolved, content });
+        if (!result.ok) {
+          throw new Error(`Volume write failed: ${extractFetcherError(result.error)}`);
+        }
+      },
+      list: async (path3) => {
+        const resolved = resolve3(path3);
+        const result = await this.client.file.listPath({
+          path: resolved,
+          recursive: false
+        });
+        if (!result.ok) {
+          throw new Error(`Volume list failed: ${extractFetcherError(result.error)}`);
+        }
+        const entries = (result.body.data?.files || []).map((f) => ({
+          path: f.path.startsWith(workspace) ? f.path.slice(workspace.length) : f.path,
+          kind: f.is_dir === true || f.size === null ? "directory" : "file",
+          size: f.size ?? 0,
+          mode: 0,
+          modified: f.modified_at ?? null
+        }));
+        return entries;
+      },
+      readRaw: async (path3) => {
+        const resolved = resolve3(path3);
+        const result = await this.client.file.downloadFile({ path: resolved });
+        if (!result.ok) {
+          throw new Error(`Volume download failed: ${extractFetcherError(result.error)}`);
+        }
+        const buffer2 = await result.body.arrayBuffer();
+        return Buffer.from(buffer2);
+      },
+      writeRaw: async (path3, data) => {
+        const resolved = resolve3(path3);
+        const result = await this.client.file.uploadFile({
+          file: data,
+          path: resolved
+        });
+        if (!result.ok) {
+          throw new Error(`Volume upload failed: ${extractFetcherError(result.error)}`);
+        }
+      }
+    };
+  }
 };
 
 // src/sandbox_lattice/providers/E2BProvider.ts
@@ -22323,6 +22643,7 @@ function clearEncryptionKeyCache() {
   MicrosandboxRemoteProvider,
   MicrosandboxServiceClient,
   ModelLatticeManager,
+  MysqlDatabase,
   PinoLoggerClient,
   PostgresDatabase,
   PrometheusClient,
@@ -22387,6 +22708,7 @@ function clearEncryptionKeyCache() {
   ensureBuiltinAgentsForTenant,
   eventBus,
   eventBusDefault,
+  extractFetcherError,
   fileDataToString,
   formatContentWithLineNumbers,
   formatGrepMatches,