@remodlai/lexiqfs 0.1.0

package/dist/fuse.d.ts

@@ -0,0 +1,11 @@
+import Fuse from 'fuse-native';
+
+type MountFuseParams = {
+    mountPoint: string;
+    libsqlUrl: string;
+    authToken?: string;
+    namespaces: Record<string, string>;
+};
+declare function mountFuse(params: MountFuseParams): Promise<Fuse>;
+
+export { type MountFuseParams, mountFuse };

package/dist/fuse.js

@@ -0,0 +1,459 @@
+// src/fuse/daemon.ts
+import Fuse from "fuse-native";
+import { configure, fs } from "@zenfs/core";
+
+// src/backends/libsql/backend.ts
+import { createClient } from "@libsql/client";
+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 fs2 = new LibSQLFS(client, options);
+    return fs2;
+  },
+  async isAvailable() {
+    try {
+      const { createClient: _c } = await import("@libsql/client");
+      return typeof _c === "function";
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/fuse/daemon.ts
+var _nextFd = 42;
+function allocFd() {
+  return _nextFd++;
+}
+async function mountFuse(params) {
+  const firstEntry = Object.entries(params.namespaces)[0];
+  if (!firstEntry) throw new Error("mountFuse: at least one namespace required");
+  const [, namespace] = firstEntry;
+  await configure({
+    mounts: {
+      "/": {
+        backend: LibSQLBackend,
+        url: `https://${namespace}.${params.libsqlUrl}`,
+        authToken: params.authToken,
+        organizationId: namespace,
+        disableAsyncCache: true
+      }
+    }
+  });
+  console.log(`[fuse] backend ready: ${params.mountPoint}`);
+  const fuse = new Fuse(params.mountPoint, {
+    readdir(path, cb) {
+      (async () => {
+        try {
+          const entries = await fs.promises.readdir(path);
+          cb(0, entries);
+        } catch {
+          cb(Fuse.ENOENT);
+        }
+      })();
+    },
+    getattr(path, cb) {
+      (async () => {
+        try {
+          const stat = await fs.promises.stat(path);
+          cb(0, stat);
+        } catch {
+          cb(Fuse.ENOENT);
+        }
+      })();
+    },
+    open(_path, _flags, cb) {
+      cb(0, allocFd());
+    },
+    fgetattr(path, _fd, cb) {
+      (async () => {
+        try {
+          const stat = await fs.promises.stat(path);
+          cb(0, stat);
+        } catch {
+          cb(Fuse.ENOENT);
+        }
+      })();
+    },
+    release(_path, _fd, cb) {
+      cb(0);
+    },
+    lstat(path, cb) {
+      (async () => {
+        try {
+          const stat = await fs.promises.stat(path);
+          cb(0, stat);
+        } catch {
+          cb(Fuse.ENOENT);
+        }
+      })();
+    },
+    readlink(_path, cb) {
+      cb(-22);
+    },
+    access(path, _mode, cb) {
+      (async () => {
+        try {
+          await fs.promises.stat(path);
+          cb(0);
+        } catch {
+          cb(Fuse.ENOENT);
+        }
+      })();
+    },
+    read(path, _fd, buf, len, pos, cb) {
+      (async () => {
+        try {
+          const data = Buffer.from(await fs.promises.readFile(path));
+          const slice = data.slice(pos, pos + len);
+          slice.copy(buf);
+          cb(slice.length);
+        } catch {
+          cb(-Fuse.EIO);
+        }
+      })();
+    },
+    write(path, _fd, buf, len, pos, cb) {
+      (async () => {
+        try {
+          let existing;
+          try {
+            existing = Buffer.from(await fs.promises.readFile(path));
+          } catch {
+            existing = Buffer.alloc(0);
+          }
+          const data = Buffer.from(buf).slice(0, len);
+          let final;
+          if (pos === 0 && existing.length <= len) {
+            final = data;
+          } else {
+            const newBuf = Buffer.alloc(Math.max(existing.length, pos + len));
+            existing.copy(newBuf);
+            data.copy(newBuf, pos);
+            final = newBuf;
+          }
+          await fs.promises.writeFile(path, final);
+          cb(len);
+        } catch (err) {
+          console.error(`[fuse] write error: ${path}`, err);
+          cb(-Fuse.EIO);
+        }
+      })();
+    },
+    mkdir(path, _mode, cb) {
+      (async () => {
+        try {
+          await fs.promises.mkdir(path);
+          cb(0);
+        } catch (e) {
+          if (e?.code === "EEXIST") {
+            cb(0);
+          } else {
+            cb(Fuse.ENOENT);
+          }
+        }
+      })();
+    },
+    create(path, _mode, cb) {
+      (async () => {
+        try {
+          await fs.promises.writeFile(path, Buffer.alloc(0));
+          cb(0, allocFd());
+        } catch (err) {
+          console.error(`[fuse] create error: ${path}`, err);
+          cb(Fuse.EACCES, -1);
+        }
+      })();
+    },
+    unlink(path, cb) {
+      (async () => {
+        try {
+          await fs.promises.unlink(path);
+          cb(0);
+        } catch {
+          cb(Fuse.ENOENT);
+        }
+      })();
+    },
+    rmdir(path, cb) {
+      (async () => {
+        try {
+          await fs.promises.rmdir(path);
+          cb(0);
+        } catch {
+          cb(Fuse.ENOENT);
+        }
+      })();
+    },
+    rename(src, dst, cb) {
+      (async () => {
+        try {
+          const content = await fs.promises.readFile(src);
+          await fs.promises.writeFile(dst, content);
+          await fs.promises.unlink(src);
+          cb(0);
+        } catch {
+          cb(Fuse.ENOENT);
+        }
+      })();
+    }
+  }, { debug: false, force: true, allowOther: true });
+  await new Promise((resolve, reject) => {
+    fuse.mount((err) => err ? reject(err) : resolve());
+  });
+  console.log(`[fuse] mounted ZenFS at ${params.mountPoint}`);
+  let shuttingDown = false;
+  const gracefulShutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log("[fuse] shutting down...");
+    fuse.unmount(() => {
+      console.log("[fuse] unmounted");
+      process.exit(0);
+    });
+  };
+  process.on("SIGINT", gracefulShutdown);
+  process.on("SIGTERM", gracefulShutdown);
+  return fuse;
+}
+export {
+  mountFuse
+};