resourcexjs 1.7.0 → 2.0.0

package/dist/index.js

@@ -2502,9 +2502,16 @@ import { join } from "node:path";
 import { readFile, writeFile, mkdir, rm, stat, readdir } from "node:fs/promises";
 import { gzip as gzip22, gunzip as gunzip22 } from "node:zlib";
 import { promisify as promisify22 } from "node:util";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+import { readFile as readFile2, stat as stat2, readdir as readdir2, mkdir as mkdir2 } from "node:fs/promises";
+import { execSync } from "node:child_process";
 function isRemoteConfig(config) {
   return config !== undefined && "endpoint" in config;
 }
+function isGitConfig(config) {
+  return config !== undefined && "type" in config && config.type === "git";
+}
 
 class ResourceXError3 extends Error {
   constructor(message, options) {
@@ -3974,23 +3981,63 @@ class LocalRegistry {
   supportType(type) {
     this.typeHandler.register(type);
   }
-  buildPath(locator) {
+  buildPath(locator, area) {
     const rxl = typeof locator === "string" ? parseRXL3(locator) : locator;
-    const domain = rxl.domain ?? "localhost";
+    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
     const version = rxl.version ?? "latest";
-    let path = join(this.basePath, domain);
-    if (rxl.path) {
-      path = join(path, rxl.path);
+    if (area === "local") {
+      return join(this.basePath, "local", resourceName, version);
+    } else {
+      const domain = rxl.domain ?? "localhost";
+      let path = join(this.basePath, "cache", domain);
+      if (rxl.path) {
+        path = join(path, rxl.path);
+      }
+      return join(path, resourceName, version);
     }
-    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    return join(path, resourceName, version);
   }
-  async publish(_resource) {
-    throw new RegistryError("Remote publish not implemented yet");
+  isLocalOnlyLocator(locator) {
+    const rxl = typeof locator === "string" ? parseRXL3(locator) : locator;
+    return !rxl.domain || rxl.domain === "localhost";
+  }
+  async existsAt(resourcePath) {
+    const manifestPath = join(resourcePath, "manifest.json");
+    try {
+      await stat(manifestPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async findArea(locator) {
+    const localPath = this.buildPath(locator, "local");
+    if (await this.existsAt(localPath)) {
+      return "local";
+    }
+    const cachePath = this.buildPath(locator, "cache");
+    if (await this.existsAt(cachePath)) {
+      return "cache";
+    }
+    return null;
+  }
+  async loadFrom(resourcePath) {
+    const manifestPath = join(resourcePath, "manifest.json");
+    const manifestContent = await readFile(manifestPath, "utf-8");
+    const manifestData = JSON.parse(manifestContent);
+    const manifest = createRXM2(manifestData);
+    const contentPath = join(resourcePath, "content.tar.gz");
+    const data = await readFile(contentPath);
+    return this.typeHandler.deserialize(data, manifest);
+  }
+  async pull(_locator, _options) {
+    throw new RegistryError("Pull not implemented yet - see issue #018");
+  }
+  async publish(_resource, _options) {
+    throw new RegistryError("Publish not implemented yet - see issue #018");
   }
   async link(resource) {
     const locator = resource.manifest.toLocator();
-    const resourcePath = this.buildPath(locator);
+    const resourcePath = this.buildPath(locator, "local");
     await mkdir(resourcePath, { recursive: true });
     const manifestPath = join(resourcePath, "manifest.json");
     await writeFile(manifestPath, JSON.stringify(resource.manifest.toJSON(), null, 2), "utf-8");
@@ -3999,58 +4046,62 @@ class LocalRegistry {
     await writeFile(contentPath, serialized);
   }
   async get(locator) {
-    if (!await this.exists(locator)) {
+    const area = await this.findArea(locator);
+    if (!area) {
       throw new RegistryError(`Resource not found: ${locator}`);
     }
-    const resourcePath = this.buildPath(locator);
-    const manifestPath = join(resourcePath, "manifest.json");
-    const manifestContent = await readFile(manifestPath, "utf-8");
-    const manifestData = JSON.parse(manifestContent);
-    const manifest = createRXM2(manifestData);
-    const contentPath = join(resourcePath, "content.tar.gz");
-    const data = await readFile(contentPath);
-    return this.typeHandler.deserialize(data, manifest);
+    const resourcePath = this.buildPath(locator, area);
+    return this.loadFrom(resourcePath);
   }
   async resolve(locator) {
     const rxr = await this.get(locator);
     return this.typeHandler.resolve(rxr);
   }
   async exists(locator) {
-    const resourcePath = this.buildPath(locator);
-    const manifestPath = join(resourcePath, "manifest.json");
-    try {
-      await stat(manifestPath);
-      return true;
-    } catch {
-      return false;
-    }
+    const area = await this.findArea(locator);
+    return area !== null;
   }
   async delete(locator) {
-    if (!await this.exists(locator)) {
-      return;
+    const isLocal = this.isLocalOnlyLocator(locator);
+    if (isLocal) {
+      const localPath = this.buildPath(locator, "local");
+      if (await this.existsAt(localPath)) {
+        await rm(localPath, { recursive: true, force: true });
+      }
+    } else {
+      const cachePath = this.buildPath(locator, "cache");
+      if (await this.existsAt(cachePath)) {
+        await rm(cachePath, { recursive: true, force: true });
+      }
     }
-    const resourcePath = this.buildPath(locator);
-    await rm(resourcePath, { recursive: true, force: true });
   }
   async search(options) {
     const { query, limit, offset = 0 } = options ?? {};
-    let entries;
-    try {
-      entries = await this.listRecursive(this.basePath);
-    } catch {
-      return [];
-    }
     const locators = [];
-    for (const entry of entries) {
-      if (!entry.endsWith("manifest.json")) {
-        continue;
+    const localDir = join(this.basePath, "local");
+    try {
+      const localEntries = await this.listRecursive(localDir);
+      for (const entry of localEntries) {
+        if (!entry.endsWith("manifest.json"))
+          continue;
+        const relativePath = entry.slice(localDir.length + 1);
+        const rxl = this.parseLocalEntry(relativePath);
+        if (rxl)
+          locators.push(rxl);
       }
-      const relativePath = entry.slice(this.basePath.length + 1);
-      const rxl = this.parseEntryToRXL(relativePath);
-      if (rxl) {
-        locators.push(rxl);
+    } catch {}
+    const cacheDir = join(this.basePath, "cache");
+    try {
+      const cacheEntries = await this.listRecursive(cacheDir);
+      for (const entry of cacheEntries) {
+        if (!entry.endsWith("manifest.json"))
+          continue;
+        const relativePath = entry.slice(cacheDir.length + 1);
+        const rxl = this.parseCacheEntry(relativePath);
+        if (rxl)
+          locators.push(rxl);
       }
-    }
+    } catch {}
     let filtered = locators;
     if (query) {
       const lowerQuery = query.toLowerCase();
@@ -4081,7 +4132,27 @@ class LocalRegistry {
     } catch {}
     return results;
   }
-  parseEntryToRXL(entry) {
+  parseLocalEntry(entry) {
+    const dirPath = entry.replace(/[/\\]manifest\.json$/, "");
+    const parts = dirPath.split(/[/\\]/);
+    if (parts.length < 2) {
+      return null;
+    }
+    const version = parts.pop();
+    const nameTypePart = parts.shift();
+    const { name, type } = this.parseNameType(nameTypePart);
+    let locatorStr = name;
+    if (type) {
+      locatorStr += `.${type}`;
+    }
+    locatorStr += `@${version}`;
+    try {
+      return parseRXL3(locatorStr);
+    } catch {
+      return null;
+    }
+  }
+  parseCacheEntry(entry) {
     const dirPath = entry.replace(/[/\\]manifest\.json$/, "");
     const parts = dirPath.split(/[/\\]/);
     if (parts.length < 3) {
@@ -4091,16 +4162,7 @@ class LocalRegistry {
     const nameTypePart = parts.pop();
     const domain = parts.shift();
     const path = parts.length > 0 ? parts.join("/") : undefined;
-    const dotIndex = nameTypePart.lastIndexOf(".");
-    let name;
-    let type;
-    if (dotIndex !== -1) {
-      name = nameTypePart.substring(0, dotIndex);
-      type = nameTypePart.substring(dotIndex + 1);
-    } else {
-      name = nameTypePart;
-      type = undefined;
-    }
+    const { name, type } = this.parseNameType(nameTypePart);
     let locatorStr = domain;
     if (path) {
       locatorStr += `/${path}`;
@@ -4116,6 +4178,17 @@ class LocalRegistry {
       return null;
     }
   }
+  parseNameType(nameTypePart) {
+    const dotIndex = nameTypePart.lastIndexOf(".");
+    if (dotIndex !== -1) {
+      return {
+        name: nameTypePart.substring(0, dotIndex),
+        type: nameTypePart.substring(dotIndex + 1)
+      };
+    } else {
+      return { name: nameTypePart, type: undefined };
+    }
+  }
 }
 
 class RemoteRegistry {
@@ -4128,7 +4201,10 @@ class RemoteRegistry {
   supportType(type) {
     this.typeHandler.register(type);
   }
-  async publish(_resource) {
+  async pull(_locator, _options) {
+    throw new RegistryError("Cannot pull to remote registry - use local registry for pulling");
+  }
+  async publish(_resource, _options) {
     throw new RegistryError("Remote registry publish not implemented yet");
   }
   async link(_resource) {
@@ -4186,15 +4262,215 @@ class RemoteRegistry {
     return (data.results || []).map((locator) => parseRXL3(locator));
   }
 }
+var DEFAULT_GIT_CACHE = `${homedir2()}/.resourcex/.git-cache`;
+
+class GitRegistry {
+  url;
+  ref;
+  basePath;
+  cacheDir;
+  typeHandler;
+  trustedDomain;
+  constructor(config) {
+    this.url = config.url;
+    this.ref = config.ref ?? "main";
+    this.basePath = config.basePath ?? ".resourcex";
+    this.typeHandler = TypeHandlerChain2.create();
+    this.trustedDomain = config.domain;
+    if (this.isRemoteUrl(config.url) && !config.domain) {
+      throw new RegistryError(`Remote git registry requires a trusted domain.
+
+` + `Either:
+` + `1. Use discoverRegistry("your-domain.com") to auto-bind domain
+` + `2. Explicitly set domain: createRegistry({ type: "git", url: "...", domain: "your-domain.com" })
+
+` + `This ensures resources from untrusted sources cannot impersonate your domain.`);
+    }
+    this.cacheDir = this.buildCacheDir(config.url);
+  }
+  isRemoteUrl(url) {
+    return url.startsWith("git@") || url.startsWith("https://") || url.startsWith("http://");
+  }
+  buildCacheDir(url) {
+    let normalized = url;
+    if (url.startsWith("git@")) {
+      normalized = url.slice(4).replace(":", "/");
+    }
+    if (normalized.endsWith(".git")) {
+      normalized = normalized.slice(0, -4);
+    }
+    const dirName = normalized.replace(/\//g, "-");
+    return join2(DEFAULT_GIT_CACHE, dirName);
+  }
+  supportType(type) {
+    this.typeHandler.register(type);
+  }
+  async ensureCloned() {
+    const gitDir = join2(this.cacheDir, ".git");
+    try {
+      await stat2(gitDir);
+      this.gitExec(`fetch origin ${this.ref}`);
+      this.gitExec(`checkout FETCH_HEAD`);
+    } catch {
+      await mkdir2(DEFAULT_GIT_CACHE, { recursive: true });
+      execSync(`git clone --depth 1 --branch ${this.ref} ${this.url} ${this.cacheDir}`, {
+        stdio: "pipe"
+      });
+    }
+  }
+  gitExec(command) {
+    execSync(`git -C ${this.cacheDir} ${command}`, { stdio: "pipe" });
+  }
+  buildResourcePath(locator) {
+    const rxl = parseRXL3(locator);
+    const domain = rxl.domain ?? "localhost";
+    const version = rxl.version ?? "latest";
+    let path = join2(this.cacheDir, this.basePath, domain);
+    if (rxl.path) {
+      path = join2(path, rxl.path);
+    }
+    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
+    return join2(path, resourceName, version);
+  }
+  async get(locator) {
+    await this.ensureCloned();
+    const resourcePath = this.buildResourcePath(locator);
+    const manifestPath = join2(resourcePath, "manifest.json");
+    try {
+      await stat2(manifestPath);
+    } catch {
+      throw new RegistryError(`Resource not found: ${locator}`);
+    }
+    const manifestContent = await readFile2(manifestPath, "utf-8");
+    const manifestData = JSON.parse(manifestContent);
+    const manifest = createRXM2(manifestData);
+    if (this.trustedDomain && manifest.domain !== this.trustedDomain) {
+      throw new RegistryError(`Untrusted domain: resource claims "${manifest.domain}" but registry only trusts "${this.trustedDomain}"`);
+    }
+    const contentPath = join2(resourcePath, "content.tar.gz");
+    const data = await readFile2(contentPath);
+    return this.typeHandler.deserialize(data, manifest);
+  }
+  async resolve(locator) {
+    const rxr = await this.get(locator);
+    return this.typeHandler.resolve(rxr);
+  }
+  async exists(locator) {
+    try {
+      await this.ensureCloned();
+      const resourcePath = this.buildResourcePath(locator);
+      const manifestPath = join2(resourcePath, "manifest.json");
+      await stat2(manifestPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async search(options) {
+    await this.ensureCloned();
+    const { query, limit, offset = 0 } = options ?? {};
+    const locators = [];
+    const baseDir = join2(this.cacheDir, this.basePath);
+    try {
+      const entries = await this.listRecursive(baseDir);
+      for (const entry of entries) {
+        if (!entry.endsWith("manifest.json"))
+          continue;
+        const relativePath = entry.slice(baseDir.length + 1);
+        const rxl = this.parseEntryToRXL(relativePath);
+        if (rxl)
+          locators.push(rxl);
+      }
+    } catch {
+      return [];
+    }
+    let filtered = locators;
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      filtered = locators.filter((rxl) => {
+        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
+        return searchText.includes(lowerQuery);
+      });
+    }
+    let result = filtered.slice(offset);
+    if (limit !== undefined) {
+      result = result.slice(0, limit);
+    }
+    return result;
+  }
+  async listRecursive(dir) {
+    const results = [];
+    try {
+      const entries = await readdir2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join2(dir, entry.name);
+        if (entry.isDirectory()) {
+          const subEntries = await this.listRecursive(fullPath);
+          results.push(...subEntries);
+        } else {
+          results.push(fullPath);
+        }
+      }
+    } catch {}
+    return results;
+  }
+  parseEntryToRXL(entry) {
+    const dirPath = entry.replace(/[/\\]manifest\.json$/, "");
+    const parts = dirPath.split(/[/\\]/);
+    if (parts.length < 3)
+      return null;
+    const version = parts.pop();
+    const nameTypePart = parts.pop();
+    const domain = parts.shift();
+    const path = parts.length > 0 ? parts.join("/") : undefined;
+    const dotIndex = nameTypePart.lastIndexOf(".");
+    let name;
+    let type;
+    if (dotIndex !== -1) {
+      name = nameTypePart.substring(0, dotIndex);
+      type = nameTypePart.substring(dotIndex + 1);
+    } else {
+      name = nameTypePart;
+      type = undefined;
+    }
+    let locatorStr = domain;
+    if (path)
+      locatorStr += `/${path}`;
+    locatorStr += `/${name}`;
+    if (type)
+      locatorStr += `.${type}`;
+    locatorStr += `@${version}`;
+    try {
+      return parseRXL3(locatorStr);
+    } catch {
+      return null;
+    }
+  }
+  async pull(_locator, _options) {
+    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.pull()");
+  }
+  async publish(_resource, _options) {
+    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.publish()");
+  }
+  async link(_resource) {
+    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.link()");
+  }
+  async delete(_locator) {
+    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.delete()");
+  }
+}
 function createRegistry(config) {
   if (isRemoteConfig(config)) {
     return new RemoteRegistry(config);
   }
+  if (isGitConfig(config)) {
+    return new GitRegistry(config);
+  }
   return new LocalRegistry(config);
 }
 // ../loader/dist/index.js
-import { join as join2, relative } from "node:path";
-import { stat as stat2, readFile as readFile2, readdir as readdir2 } from "node:fs/promises";
+import { join as join3, relative } from "node:path";
+import { stat as stat3, readFile as readFile3, readdir as readdir3 } from "node:fs/promises";
 import { gzip as gzip4, gunzip as gunzip4 } from "node:zlib";
 import { promisify as promisify4 } from "node:util";
 
@@ -5386,22 +5662,22 @@ async function createRXC4(input) {
 class FolderLoader {
   async canLoad(source) {
     try {
-      const stats = await stat2(source);
+      const stats = await stat3(source);
       if (!stats.isDirectory()) {
         return false;
       }
-      const manifestPath = join2(source, "resource.json");
-      const manifestStats = await stat2(manifestPath);
+      const manifestPath = join3(source, "resource.json");
+      const manifestStats = await stat3(manifestPath);
       return manifestStats.isFile();
     } catch {
       return false;
     }
   }
   async load(folderPath) {
-    const manifestPath = join2(folderPath, "resource.json");
+    const manifestPath = join3(folderPath, "resource.json");
     let manifestJson;
     try {
-      manifestJson = await readFile2(manifestPath, "utf-8");
+      manifestJson = await readFile3(manifestPath, "utf-8");
     } catch (error) {
       throw new ResourceXError4(`Failed to read resource.json: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -5441,15 +5717,15 @@ class FolderLoader {
   }
   async readFolderFiles(folderPath, basePath = folderPath) {
     const files = {};
-    const entries = await readdir2(folderPath, { withFileTypes: true });
+    const entries = await readdir3(folderPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join2(folderPath, entry.name);
+      const fullPath = join3(folderPath, entry.name);
       const relativePath = relative(basePath, fullPath);
       if (relativePath === "resource.json") {
         continue;
       }
       if (entry.isFile()) {
-        files[relativePath] = await readFile2(fullPath);
+        files[relativePath] = await readFile3(fullPath);
       } else if (entry.isDirectory()) {
         const subFiles = await this.readFolderFiles(fullPath, basePath);
         Object.assign(files, subFiles);
@@ -5468,7 +5744,7 @@ async function loadResource(source, config) {
 }
 
 // src/index.ts
-var VERSION = "1.7.0";
+var VERSION = "2.0.0";
 export {
   textType,
   parseRXL,
@@ -5491,4 +5767,4 @@ export {
   ContentError
 };
 
-//# debugId=D41A861C6C8E364564756E2164756E21
+//# debugId=3C36FF6A5291529664756E2164756E21