@remodlai/lexiqfs 0.1.0

package/dist/index.js

@@ -0,0 +1,914 @@
+// src/index.ts
+export * from "@zenfs/core";
+
+// src/backends/libsql/backend.ts
+import { createClient } from "@libsql/client";
+
+// src/backends/libsql/transaction.ts
+var AsyncTransactionBase = class {
+  asyncDone = Promise.resolve();
+  /**
+   * Run an async operation from sync context
+   */
+  async(promise) {
+    this.asyncDone = this.asyncDone.then(() => promise);
+  }
+};
+var LibSQLTransaction = class extends AsyncTransactionBase {
+  constructor(store, client, organizationId, agentId, onCommit) {
+    super();
+    this.store = store;
+    this.client = client;
+    this.organizationId = organizationId;
+    this.agentId = agentId;
+    this.onCommit = onCommit;
+  }
+  cache = /* @__PURE__ */ new Map();
+  pendingWrites = /* @__PURE__ */ new Map();
+  pendingDeletes = /* @__PURE__ */ new Set();
+  committed = false;
+  /**
+   * Get all keys (file paths) in the store
+   */
+  async keys() {
+    await this.asyncDone;
+    const result = await this.client.execute({
+      sql: `SELECT path FROM files
+            WHERE organization_id = ? AND (agent_id = ? OR (agent_id IS NULL AND ? IS NULL))`,
+      args: [this.organizationId, this.agentId, this.agentId]
+    });
+    return result.rows.map((row) => row.path);
+  }
+  /**
+   * Get data for a file path
+   *
+   * @param path - The file path to look up (e.g., '/src/main.ts')
+   * @param offset - Start offset in the data
+   * @param end - End offset (exclusive), or undefined for rest of data
+   */
+  async get(path, offset, end) {
+    await this.asyncDone;
+    if (this.pendingDeletes.has(path)) {
+      return void 0;
+    }
+    if (this.pendingWrites.has(path)) {
+      const data2 = this.pendingWrites.get(path);
+      return this.sliceData(data2, offset, end);
+    }
+    if (this.cache.has(path)) {
+      const cached = this.cache.get(path);
+      return cached ? this.sliceData(cached, offset, end) : void 0;
+    }
+    const result = await this.client.execute({
+      sql: `SELECT content FROM files
+            WHERE path = ? AND organization_id = ?
+            AND (agent_id = ? OR (agent_id IS NULL AND ? IS NULL))`,
+      args: [path, this.organizationId, this.agentId, this.agentId]
+    });
+    if (result.rows.length === 0) {
+      this.cache.set(path, void 0);
+      return void 0;
+    }
+    const rawData = result.rows[0].content;
+    let data;
+    if (rawData === null || rawData === void 0) {
+      data = void 0;
+    } else if (rawData instanceof Uint8Array) {
+      data = rawData;
+    } else if (rawData instanceof ArrayBuffer) {
+      data = new Uint8Array(rawData);
+    } else if (typeof rawData === "string") {
+      data = this.decodeBase64(rawData);
+    } else if (ArrayBuffer.isView(rawData)) {
+      data = new Uint8Array(rawData.buffer, rawData.byteOffset, rawData.byteLength);
+    } else {
+      console.warn("Unknown data type from libSQL:", typeof rawData);
+      data = void 0;
+    }
+    this.cache.set(path, data);
+    return data ? this.sliceData(data, offset, end) : void 0;
+  }
+  /**
+   * Synchronous get - uses cache only
+   * Throws EAGAIN if data not in cache
+   */
+  getSync(path, offset, end) {
+    if (this.pendingDeletes.has(path)) {
+      return void 0;
+    }
+    if (this.pendingWrites.has(path)) {
+      const data = this.pendingWrites.get(path);
+      return this.sliceData(data, offset, end);
+    }
+    if (this.cache.has(path)) {
+      const cached = this.cache.get(path);
+      return cached ? this.sliceData(cached, offset, end) : void 0;
+    }
+    this.async(this.get(path, offset, end));
+    const error = new Error("EAGAIN: Resource temporarily unavailable");
+    error.code = "EAGAIN";
+    throw error;
+  }
+  /**
+   * Set data for a file path
+   *
+   * @param path - The file path (e.g., '/src/main.ts')
+   * @param data - The data to store
+   * @param offset - Offset at which to write (0 for full replacement)
+   */
+  async set(path, data, offset) {
+    await this.asyncDone;
+    this.pendingDeletes.delete(path);
+    let finalData;
+    if (offset === 0) {
+      finalData = data;
+    } else {
+      const existing = await this.get(path, 0) ?? new Uint8Array(0);
+      const newSize = Math.max(existing.length, offset + data.length);
+      finalData = new Uint8Array(newSize);
+      finalData.set(existing);
+      finalData.set(data, offset);
+    }
+    this.pendingWrites.set(path, finalData);
+    this.cache.set(path, finalData);
+  }
+  /**
+   * Synchronous set - queues for async write
+   */
+  setSync(path, data, offset) {
+    this.async(this.set(path, data, offset));
+  }
+  /**
+   * Remove a file path from the store
+   */
+  async remove(path) {
+    await this.asyncDone;
+    this.pendingWrites.delete(path);
+    this.pendingDeletes.add(path);
+    this.cache.set(path, void 0);
+  }
+  /**
+   * Synchronous remove - queues for async delete
+   */
+  removeSync(path) {
+    this.async(this.remove(path));
+  }
+  /**
+   * Commit all pending changes to the database
+   */
+  async commit() {
+    if (this.committed) return;
+    await this.asyncDone;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const events = [];
+    const timestamp = Date.now();
+    for (const [path, data] of this.pendingWrites) {
+      await this.client.execute({
+        sql: `INSERT INTO files (path, organization_id, agent_id, content, mode, uid, gid, size, atime, mtime, ctime, birthtime)
+              VALUES (?, ?, ?, ?, 33188, 1000, 1000, ?, ?, ?, ?, ?)
+              ON CONFLICT (path, organization_id, agent_id) DO UPDATE SET
+                content = excluded.content,
+                size = excluded.size,
+                mtime = excluded.mtime,
+                ctime = excluded.ctime`,
+        args: [path, this.organizationId, this.agentId, data, data.length, now, now, now, now]
+      });
+      events.push({ eventType: "change", path, timestamp });
+    }
+    for (const path of this.pendingDeletes) {
+      await this.client.execute({
+        sql: `DELETE FROM files
+              WHERE path = ? AND organization_id = ?
+              AND (agent_id = ? OR (agent_id IS NULL AND ? IS NULL))`,
+        args: [path, this.organizationId, this.agentId, this.agentId]
+      });
+      events.push({ eventType: "rename", path, timestamp });
+    }
+    this.committed = true;
+    this.pendingWrites.clear();
+    this.pendingDeletes.clear();
+    if (events.length > 0 && this.onCommit) {
+      this.onCommit(events);
+    }
+  }
+  /**
+   * Abort - discard pending changes
+   */
+  abort() {
+    this.committed = true;
+    this.pendingWrites.clear();
+    this.pendingDeletes.clear();
+    this.cache.clear();
+  }
+  /**
+   * Slice data according to offset/end
+   */
+  sliceData(data, offset, end) {
+    if (offset === 0 && end === void 0) {
+      return data;
+    }
+    return data.subarray(offset, end);
+  }
+  /**
+   * Decode base64 string to Uint8Array
+   */
+  decodeBase64(str) {
+    const binary = atob(str);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  /**
+   * Symbol.asyncDispose for using/await using
+   */
+  async [Symbol.asyncDispose]() {
+    if (!this.committed) {
+      this.abort();
+    }
+  }
+  /**
+   * Symbol.dispose for using
+   */
+  [Symbol.dispose]() {
+    if (!this.committed) {
+      this.abort();
+    }
+  }
+};
+
+// src/process/base/event-emitter.ts
+var BrowserEventEmitter = class {
+  events = {};
+  maxListeners = 10;
+  setMaxListeners(n) {
+    this.maxListeners = n;
+    return this;
+  }
+  on(event, listener) {
+    if (!this.events[event]) {
+      this.events[event] = [];
+    }
+    if (this.events[event].length >= this.maxListeners) {
+      console.warn(`MaxListenersExceededWarning: Possible memory leak detected. ${this.events[event].length} listeners added.`);
+    }
+    this.events[event].push(listener);
+    return this;
+  }
+  off(event, listener) {
+    return this.removeListener(event, listener);
+  }
+  emit(event, ...args) {
+    if (!this.events[event]) return false;
+    this.events[event].forEach((listener) => listener(...args));
+    return true;
+  }
+  removeListener(event, listener) {
+    if (!this.events[event]) return this;
+    this.events[event] = this.events[event].filter((l) => l !== listener);
+    return this;
+  }
+};
+
+// src/backends/libsql/store.ts
+var LibSQLStore = class {
+  type = 1819505011;
+  // 'lsqs' in hex
+  name = "libsqlfs";
+  label;
+  uuid;
+  flags = ["partial"];
+  // We support partial reads/writes
+  client;
+  organizationId;
+  agentId;
+  maxSize;
+  initialized = false;
+  eventEmitter = new BrowserEventEmitter();
+  constructor(client, options) {
+    this.client = client;
+    this.organizationId = options.organizationId;
+    this.agentId = options.agentId ?? null;
+    this.label = options.label;
+    this.maxSize = options.maxSize ?? 4 * 1024 * 1024 * 1024;
+  }
+  /**
+   * Initialize the database schema if needed
+   */
+  async initialize() {
+    if (this.initialized) return;
+    await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS files (
+        path TEXT NOT NULL,
+        organization_id TEXT NOT NULL,
+        agent_id TEXT,
+        content BLOB,
+        mode INTEGER NOT NULL DEFAULT 33188,
+        uid INTEGER NOT NULL DEFAULT 1000,
+        gid INTEGER NOT NULL DEFAULT 1000,
+        size INTEGER NOT NULL DEFAULT 0,
+        atime TEXT NOT NULL,
+        mtime TEXT NOT NULL,
+        ctime TEXT NOT NULL,
+        birthtime TEXT NOT NULL,
+        canonical_path TEXT,
+        PRIMARY KEY (path, organization_id, agent_id)
+      )
+    `);
+    await this.client.execute(`
+      CREATE INDEX IF NOT EXISTS idx_files_org_agent
+      ON files(organization_id, agent_id)
+    `);
+    await this.client.execute(`
+      CREATE INDEX IF NOT EXISTS idx_files_path_prefix
+      ON files(path, organization_id, agent_id)
+    `);
+    await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS fs_metadata (
+        organization_id TEXT NOT NULL,
+        agent_id TEXT,
+        metadata TEXT NOT NULL,
+        PRIMARY KEY (organization_id, agent_id)
+      )
+    `);
+    this.initialized = true;
+  }
+  /**
+   * Sync the embedded replica with the remote server
+   * For libSQL embedded replicas, this triggers a sync operation
+   */
+  async sync() {
+    if ("sync" in this.client && typeof this.client.sync === "function") {
+      await this.client.sync();
+    }
+  }
+  /**
+   * Create a new transaction for atomic operations
+   *
+   * ZenFS StoreFS uses transactions for all operations:
+   * - tx.get(id, offset, end) - read data
+   * - tx.set(id, data, offset) - write data
+   * - tx.remove(id) - delete data
+   * - tx.commit() - persist changes
+   */
+  transaction() {
+    return new LibSQLTransaction(
+      this,
+      this.client,
+      this.organizationId,
+      this.agentId,
+      (events) => this.handleCommitEvents(events)
+    );
+  }
+  /**
+   * Handle events from committed transactions
+   */
+  handleCommitEvents(events) {
+    for (const event of events) {
+      this.eventEmitter.emit("change", event);
+    }
+  }
+  /**
+   * Subscribe to file change events
+   * @returns Unsubscribe function
+   */
+  onFileChange(callback) {
+    this.eventEmitter.on("change", callback);
+    return () => this.eventEmitter.off("change", callback);
+  }
+  /**
+   * Get storage usage information
+   */
+  usage() {
+    return {
+      totalSpace: this.maxSize,
+      freeSpace: this.maxSize
+      // TODO: Calculate actual usage
+    };
+  }
+  /**
+   * Get the libSQL client (for advanced operations)
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Get organization ID
+   */
+  getOrganizationId() {
+    return this.organizationId;
+  }
+  /**
+   * Get agent ID
+   */
+  getAgentId() {
+    return this.agentId;
+  }
+  /**
+   * Check if a root directory exists
+   */
+  async hasRoot() {
+    const result = await this.client.execute({
+      sql: `SELECT 1 FROM files
+            WHERE path = '/' AND organization_id = ?
+            AND (agent_id = ? OR (agent_id IS NULL AND ? IS NULL))`,
+      args: [this.organizationId, this.agentId, this.agentId]
+    });
+    return result.rows.length > 0;
+  }
+  /**
+   * Create root directory if it doesn't exist
+   * Called by StoreFS during initialization
+   */
+  async ensureRoot() {
+    const hasRoot = await this.hasRoot();
+    if (hasRoot) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.client.execute({
+      sql: `INSERT INTO files (path, organization_id, agent_id, content, mode, uid, gid, size, atime, mtime, ctime, birthtime)
+            VALUES ('/', ?, ?, NULL, 16877, 1000, 1000, 0, ?, ?, ?, ?)`,
+      args: [this.organizationId, this.agentId, now, now, now, now]
+    });
+  }
+  /**
+   * Close the store and release resources
+   */
+  async close() {
+    await this.sync();
+    if ("close" in this.client && typeof this.client.close === "function") {
+      await this.client.close();
+    }
+  }
+  /**
+   * Text search using FTS5 with fuzzy fallback
+   *
+   * Search strategy:
+   * 1. FTS5 MATCH for fast, indexed word matching
+   * 2. Fuzzy fallback (fuzzy_damlev) for typo tolerance if no results
+   *
+   * @param query - Search query string
+   * @param options - Search options
+   * @returns Array of search matches with line information
+   */
+  async textSearch(query, options = {}) {
+    const limit = options.resultLimit || 500;
+    const fuzzyThreshold = options.fuzzyThreshold ?? 2;
+    const matches = [];
+    try {
+      let folderFilter = "";
+      const folderArgs = [];
+      if (options.folders && options.folders.length > 0) {
+        const folderClauses = options.folders.map((folder, i) => {
+          folderArgs.push(folder.endsWith("/") ? `${folder}%` : `${folder}/%`);
+          return `f.path LIKE ?`;
+        });
+        folderFilter = `AND (${folderClauses.join(" OR ")})`;
+      }
+      let excludeFilter = "";
+      const excludeArgs = [];
+      if (options.excludes && options.excludes.length > 0) {
+        for (const pattern of options.excludes) {
+          const likePattern = pattern.replace(/\*\*/g, "%").replace(/\*/g, "%").replace(/\?/g, "_");
+          excludeArgs.push(likePattern);
+          excludeFilter += ` AND f.path NOT LIKE ?`;
+        }
+      }
+      const ftsQuery = options.isRegex ? query : query.replace(/['"]/g, "");
+      const ftsResult = await this.client.execute({
+        sql: `
+          SELECT f.path, f.content
+          FROM files f
+          INNER JOIN files_fts fts ON f.rowid = fts.rowid
+          WHERE fts.content MATCH ?
+          AND f.organization_id = ?
+          AND (f.agent_id = ? OR (f.agent_id IS NULL AND ? IS NULL))
+          AND f.mode & 61440 = 32768  -- Regular files only (S_IFREG)
+          ${folderFilter}
+          ${excludeFilter}
+          LIMIT ?
+        `,
+        args: [
+          ftsQuery,
+          this.organizationId,
+          this.agentId,
+          this.agentId,
+          ...folderArgs,
+          ...excludeArgs,
+          limit
+        ]
+      });
+      for (const row of ftsResult.rows) {
+        const path = row.path;
+        const content = row.content;
+        if (!content) continue;
+        const lines = content.split("\n");
+        const searchLower = options.caseSensitive ? query : query.toLowerCase();
+        for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+          const line = lines[lineNum];
+          const lineLower = options.caseSensitive ? line : line.toLowerCase();
+          let matchIndex = lineLower.indexOf(searchLower);
+          while (matchIndex !== -1) {
+            matches.push({
+              path,
+              lineNumber: lineNum + 1,
+              lineContent: line,
+              matchStart: matchIndex,
+              matchEnd: matchIndex + query.length
+            });
+            if (matches.length >= limit) break;
+            matchIndex = lineLower.indexOf(searchLower, matchIndex + 1);
+          }
+          if (matches.length >= limit) break;
+        }
+        if (matches.length >= limit) break;
+      }
+      if (matches.length === 0 && fuzzyThreshold > 0) {
+        const fuzzyResult = await this.client.execute({
+          sql: `
+            SELECT path, content
+            FROM files
+            WHERE organization_id = ?
+            AND (agent_id = ? OR (agent_id IS NULL AND ? IS NULL))
+            AND mode & 61440 = 32768
+            AND (
+              fuzzy_damlev(path, ?) <= ?
+              OR path LIKE '%' || ? || '%'
+            )
+            ${folderFilter}
+            ${excludeFilter}
+            LIMIT ?
+          `,
+          args: [
+            this.organizationId,
+            this.agentId,
+            this.agentId,
+            query,
+            fuzzyThreshold,
+            query,
+            ...folderArgs,
+            ...excludeArgs,
+            limit
+          ]
+        });
+        for (const row of fuzzyResult.rows) {
+          const path = row.path;
+          const content = row.content;
+          if (!content) continue;
+          const lines = content.split("\n");
+          const searchLower = options.caseSensitive ? query : query.toLowerCase();
+          for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+            const line = lines[lineNum];
+            const lineLower = options.caseSensitive ? line : line.toLowerCase();
+            const matchIndex = lineLower.indexOf(searchLower);
+            if (matchIndex !== -1) {
+              matches.push({
+                path,
+                lineNumber: lineNum + 1,
+                lineContent: line,
+                matchStart: matchIndex,
+                matchEnd: matchIndex + query.length
+              });
+              if (matches.length >= limit) break;
+            }
+          }
+          if (matches.length >= limit) break;
+        }
+      }
+      return {
+        matches,
+        truncated: matches.length >= limit
+      };
+    } catch (error) {
+      console.error("textSearch error:", error);
+      return { matches: [], truncated: false };
+    }
+  }
+};
+
+// src/backends/libsql/backend.ts
+import { Async, FileSystem, InMemory } from "@zenfs/core";
+function errnoError(code, path, syscall) {
+  const err = Object.assign(new Error(`${code}: ${syscall || "unknown"} '${path || ""}'`), { code, path, syscall });
+  return err;
+}
+var DEFAULT_FILE_MODE = 33188;
+var DEFAULT_DIR_MODE = 16877;
+var LibSQLFS = class extends Async(FileSystem) {
+  _sync = InMemory.create({});
+  client;
+  organizationId;
+  agentId;
+  label;
+  constructor(client, options) {
+    super(19539, "libsqlfs");
+    this.client = client;
+    this.organizationId = options.organizationId;
+    this.agentId = options.agentId ?? null;
+    this.label = options.label;
+  }
+  /**
+   * Initialize schema and seed root directory.
+   * Called before ready(), which triggers Async() crossCopy.
+   */
+  async initialize() {
+    await this.client.execute(`
+            CREATE TABLE IF NOT EXISTS files (
+                path        TEXT PRIMARY KEY,
+                content     BLOB,
+                mode        INTEGER NOT NULL DEFAULT ${DEFAULT_FILE_MODE},
+                uid         INTEGER NOT NULL DEFAULT 1000,
+                gid         INTEGER NOT NULL DEFAULT 1000,
+                size        INTEGER NOT NULL DEFAULT 0,
+                atime       TEXT NOT NULL,
+                mtime       TEXT NOT NULL,
+                ctime       TEXT NOT NULL,
+                birthtime   TEXT NOT NULL,
+                organization_id TEXT,
+                agent_id        TEXT
+            )
+        `);
+    await this.client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_files_path_prefix ON files(path)`
+    );
+    const root = await this.client.execute(`SELECT 1 FROM files WHERE path = '/'`);
+    if (!root.rows.length) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await this.client.execute({
+        sql: `INSERT INTO files (path, content, mode, uid, gid, size, atime, mtime, ctime, birthtime, organization_id, agent_id)
+                      VALUES ('/', NULL, ?, 1000, 1000, 0, ?, ?, ?, ?, ?, ?)`,
+        args: [DEFAULT_DIR_MODE, now, now, now, now, this.organizationId, this.agentId]
+      });
+    }
+  }
+  /**
+   * Override ready() to run initialize(), then let Async() crossCopy.
+   */
+  async ready() {
+    await this.initialize();
+    await super.ready();
+  }
+  // -- async methods that Async(FileSystem) requires --
+  async rename(oldPath, newPath) {
+    await this.client.execute({
+      sql: `UPDATE files SET path = ? WHERE path = ?`,
+      args: [newPath, oldPath]
+    });
+  }
+  async stat(path) {
+    const result = await this.client.execute({
+      sql: `SELECT mode, size, atime, mtime, ctime, birthtime, uid, gid FROM files WHERE path = ?`,
+      args: [path]
+    });
+    if (!result.rows.length) {
+      throw errnoError("ENOENT", path, "stat");
+    }
+    const r = result.rows[0];
+    return {
+      mode: r.mode,
+      size: r.size,
+      atimeMs: new Date(r.atime).getTime(),
+      mtimeMs: new Date(r.mtime).getTime(),
+      ctimeMs: new Date(r.ctime).getTime(),
+      birthtimeMs: new Date(r.birthtime).getTime(),
+      uid: r.uid,
+      gid: r.gid,
+      ino: 0,
+      nlink: 1
+    };
+  }
+  async touch(path, metadata) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const atime = metadata.atimeMs ? new Date(metadata.atimeMs).toISOString() : now;
+    const mtime = metadata.mtimeMs ? new Date(metadata.mtimeMs).toISOString() : now;
+    const ctime = metadata.ctimeMs ? new Date(metadata.ctimeMs).toISOString() : now;
+    await this.client.execute({
+      sql: `UPDATE files SET atime = ?, mtime = ?, ctime = ?, organization_id = ?, agent_id = ? WHERE path = ?`,
+      args: [atime, mtime, ctime, this.organizationId, this.agentId, path]
+    });
+  }
+  async createFile(path, options) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const mode = options.mode ?? DEFAULT_FILE_MODE;
+    const uid = options.uid ?? 1e3;
+    const gid = options.gid ?? 1e3;
+    await this.client.execute({
+      sql: `INSERT INTO files (path, content, mode, uid, gid, size, atime, mtime, ctime, birthtime, organization_id, agent_id)
+                  VALUES (?, NULL, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?)
+                  ON CONFLICT (path) DO UPDATE SET mode = excluded.mode, mtime = excluded.mtime, ctime = excluded.ctime`,
+      args: [path, mode, uid, gid, now, now, now, now, this.organizationId, this.agentId]
+    });
+    return {
+      mode,
+      size: 0,
+      uid,
+      gid,
+      atimeMs: Date.now(),
+      mtimeMs: Date.now(),
+      ctimeMs: Date.now(),
+      birthtimeMs: Date.now(),
+      ino: 0,
+      nlink: 1
+    };
+  }
+  async unlink(path) {
+    await this.client.execute({ sql: `DELETE FROM files WHERE path = ?`, args: [path] });
+  }
+  async rmdir(path) {
+    await this.client.execute({ sql: `DELETE FROM files WHERE path = ?`, args: [path] });
+  }
+  async mkdir(path, options) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const mode = options.mode ?? DEFAULT_DIR_MODE;
+    const uid = options.uid ?? 1e3;
+    const gid = options.gid ?? 1e3;
+    await this.client.execute({
+      sql: `INSERT INTO files (path, content, mode, uid, gid, size, atime, mtime, ctime, birthtime, organization_id, agent_id)
+                  VALUES (?, NULL, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?)
+                  ON CONFLICT (path) DO NOTHING`,
+      args: [path, mode, uid, gid, now, now, now, now, this.organizationId, this.agentId]
+    });
+    return {
+      mode,
+      size: 0,
+      uid,
+      gid,
+      atimeMs: Date.now(),
+      mtimeMs: Date.now(),
+      ctimeMs: Date.now(),
+      birthtimeMs: Date.now(),
+      ino: 0,
+      nlink: 1
+    };
+  }
+  async readdir(path) {
+    const prefix = path === "/" ? "/" : path.endsWith("/") ? path : path + "/";
+    let sql;
+    let args;
+    if (prefix === "/") {
+      sql = `SELECT path FROM files WHERE path != '/' AND path LIKE '/%' AND path NOT LIKE '/%/%'`;
+      args = [];
+    } else {
+      sql = `SELECT path FROM files WHERE path LIKE ? AND path NOT LIKE ?`;
+      args = [prefix + "%", prefix + "%/%"];
+    }
+    const result = await this.client.execute({ sql, args });
+    return result.rows.map((r) => r.path.slice(prefix.length)).filter((name) => name.length > 0);
+  }
+  async link(_target, _link) {
+    throw errnoError("ENOSYS", _target, "link");
+  }
+  async sync() {
+  }
+  async read(path, buffer, start, end) {
+    const result = await this.client.execute({
+      sql: `SELECT content FROM files WHERE path = ?`,
+      args: [path]
+    });
+    const raw = result.rows[0]?.content;
+    if (raw === null || raw === void 0) return;
+    let content;
+    if (raw instanceof Uint8Array) {
+      content = raw;
+    } else if (raw instanceof ArrayBuffer) {
+      content = new Uint8Array(raw);
+    } else if (ArrayBuffer.isView(raw)) {
+      content = new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
+    } else if (typeof raw === "string") {
+      const binary = atob(raw);
+      content = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) content[i] = binary.charCodeAt(i);
+    } else {
+      return;
+    }
+    const slice = content.subarray(start, end);
+    buffer.set(slice);
+  }
+  async write(path, buffer, offset) {
+    const result = await this.client.execute({
+      sql: `SELECT content FROM files WHERE path = ?`,
+      args: [path]
+    });
+    let existing = new Uint8Array(0);
+    const raw = result.rows[0]?.content;
+    if (raw instanceof Uint8Array) {
+      existing = new Uint8Array(raw);
+    } else if (raw instanceof ArrayBuffer) {
+      existing = new Uint8Array(raw);
+    } else if (ArrayBuffer.isView(raw)) {
+      existing = new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
+    }
+    const newSize = Math.max(existing.length, offset + buffer.length);
+    const merged = new Uint8Array(newSize);
+    merged.set(existing);
+    merged.set(buffer, offset);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.client.execute({
+      sql: `INSERT INTO files (path, content, mode, uid, gid, size, atime, mtime, ctime, birthtime, organization_id, agent_id)
+                  VALUES (?, ?, ${DEFAULT_FILE_MODE}, 1000, 1000, ?, ?, ?, ?, ?, ?, ?)
+                  ON CONFLICT (path) DO UPDATE SET
+                    content = excluded.content, size = excluded.size,
+                    mtime = excluded.mtime, ctime = excluded.ctime,
+                    organization_id = excluded.organization_id, agent_id = excluded.agent_id`,
+      args: [path, merged, merged.length, now, now, now, now, this.organizationId, this.agentId]
+    });
+  }
+};
+var LibSQLBackend = {
+  name: "LibSQL",
+  options: {
+    url: { type: "string", required: false },
+    syncUrl: { type: "string", required: false },
+    authToken: { type: "string", required: false },
+    organizationId: { type: "string", required: true },
+    agentId: { type: ["string", "undefined"], required: false },
+    label: { type: "string", required: false },
+    maxSize: { type: "number", required: false }
+  },
+  async create(options) {
+    const url = options.url || options.syncUrl || ":memory:";
+    const client = createClient({ url, authToken: options.authToken });
+    const fs = new LibSQLFS(client, options);
+    return fs;
+  },
+  async isAvailable() {
+    try {
+      const { createClient: _c } = await import("@libsql/client");
+      return typeof _c === "function";
+    } catch {
+      return false;
+    }
+  }
+};
+async function createLibSQLStore(options) {
+  const url = options.url || options.syncUrl || ":memory:";
+  const client = createClient({ url, authToken: options.authToken });
+  const store = new LibSQLStore(client, options);
+  await store.initialize();
+  await store.ensureRoot();
+  return store;
+}
+async function forkTemplate(serverUrl, templateNamespace, targetNamespace, authToken) {
+  const headers = { "Content-Type": "application/json" };
+  if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
+  try {
+    const response = await fetch(`${serverUrl}/v1/namespaces/${templateNamespace}/fork/${targetNamespace}`, { method: "POST", headers });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function namespaceExists(serverUrl, namespace, authToken) {
+  const headers = {};
+  if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
+  try {
+    const response = await fetch(`${serverUrl}/v1/namespaces`, { headers });
+    if (!response.ok) return false;
+    const data = await response.json();
+    return (data.namespaces || []).includes(namespace);
+  } catch {
+    return false;
+  }
+}
+async function createNamespace(serverUrl, namespace, authToken) {
+  const headers = { "Content-Type": "application/json" };
+  if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
+  try {
+    const response = await fetch(`${serverUrl}/v1/namespaces/${namespace}/create`, { method: "POST", headers });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/backends/libsql/types.ts
+var S_IFMT = 61440;
+var S_IFDIR = 16384;
+var S_IFREG = 32768;
+var DEFAULT_DIR_MODE2 = S_IFDIR | 493;
+var DEFAULT_FILE_MODE2 = S_IFREG | 420;
+function isDirectory(mode) {
+  return (mode & S_IFMT) === S_IFDIR;
+}
+function isFile(mode) {
+  return (mode & S_IFMT) === S_IFREG;
+}
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+export {
+  AsyncTransactionBase,
+  DEFAULT_DIR_MODE2 as DEFAULT_DIR_MODE,
+  DEFAULT_FILE_MODE2 as DEFAULT_FILE_MODE,
+  LibSQLBackend as LibSQL,
+  LibSQLBackend,
+  LibSQLStore,
+  LibSQLTransaction,
+  createLibSQLStore,
+  createNamespace,
+  forkTemplate,
+  isDirectory,
+  isFile,
+  namespaceExists,
+  nowISO
+};