lua-cli 3.15.1 → 3.15.3

package/node_modules/@lua/shared-source-sync/dist/index.js

@@ -0,0 +1,536 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ARCHIVE_SCHEMA_VERSION: () => ARCHIVE_SCHEMA_VERSION,
+  BackupHttpClient: () => BackupHttpClient,
+  BackupHttpError: () => BackupHttpError,
+  DEFAULT_MAX_FILE_BYTES: () => DEFAULT_MAX_FILE_BYTES,
+  FILE_HASH_LENGTH: () => FILE_HASH_LENGTH,
+  SKILL_SOURCE_EDITORS: () => SKILL_SOURCE_EDITORS,
+  classifyFile: () => classifyFile,
+  combineFileHashes: () => combineFileHashes,
+  decodeWorkspaceArchive: () => decodeWorkspaceArchive,
+  downloadBlobs: () => downloadBlobs,
+  encodeWorkspaceArchive: () => encodeWorkspaceArchive,
+  hashContentTruncated: () => hashContentTruncated,
+  pullAgentBackup: () => pullAgentBackup,
+  pushAgentBackup: () => pushAgentBackup,
+  resolveBackupFileTarget: () => resolveBackupFileTarget,
+  restoreFromBlobs: () => restoreFromBlobs,
+  sha256Hex: () => sha256Hex,
+  shouldSkipDirectory: () => shouldSkipDirectory,
+  shouldSkipFile: () => shouldSkipFile,
+  uploadBlobs: () => uploadBlobs,
+  walkWorkspace: () => walkWorkspace,
+  writeArchiveToWorkspace: () => writeArchiveToWorkspace
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/hash.ts
+var import_crypto = require("crypto");
+var FILE_HASH_LENGTH = 16;
+function hashContentTruncated(content) {
+  return (0, import_crypto.createHash)("sha256").update(content).digest("hex").slice(0, FILE_HASH_LENGTH);
+}
+__name(hashContentTruncated, "hashContentTruncated");
+function sha256Hex(content) {
+  return (0, import_crypto.createHash)("sha256").update(content).digest("hex");
+}
+__name(sha256Hex, "sha256Hex");
+function combineFileHashes(files) {
+  const sorted = [
+    ...files
+  ].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return sha256Hex(sorted.map((f) => f.hash).join("|"));
+}
+__name(combineFileHashes, "combineFileHashes");
+
+// src/filter.ts
+var import_path = require("path");
+var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "dist-v2",
+  ".git",
+  ".lua",
+  ".temp",
+  "coverage",
+  ".next",
+  ".turbo"
+]);
+var ARCHIVE_ONLY_SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
+  "build"
+]);
+var DEFAULT_MAX_FILE_BYTES = 256 * 1024;
+function shouldSkipDirectory(name) {
+  return SKIP_DIRECTORIES.has(name);
+}
+__name(shouldSkipDirectory, "shouldSkipDirectory");
+function shouldSkipFile(filePathOrName) {
+  return filePathOrName.includes("node_modules") || filePathOrName.includes(".test.") || filePathOrName.includes(".spec.") || filePathOrName.includes("__tests__") || filePathOrName.endsWith(".d.ts") || filePathOrName.endsWith(".map") || filePathOrName.startsWith(".") || filePathOrName === "package-lock.json" || filePathOrName === "yarn.lock" || filePathOrName === "pnpm-lock.yaml";
+}
+__name(shouldSkipFile, "shouldSkipFile");
+var KIND_BY_EXT = {
+  ".ts": "source",
+  ".tsx": "source",
+  ".js": "source",
+  ".jsx": "source",
+  ".yaml": "config",
+  ".yml": "config",
+  ".json": "config",
+  ".toml": "config"
+};
+function classifyFile(relPath) {
+  return KIND_BY_EXT[(0, import_path.extname)(relPath)] ?? "other";
+}
+__name(classifyFile, "classifyFile");
+
+// src/walk.ts
+var import_fs = require("fs");
+var import_path2 = require("path");
+function walkWorkspace(rootDir, opts = {}) {
+  const maxBytes = opts.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+  const refs = [];
+  const contentByHash = /* @__PURE__ */ new Map();
+  let totalSize = 0;
+  const visit = /* @__PURE__ */ __name((relPrefix) => {
+    const absDir = relPrefix ? (0, import_path2.join)(rootDir, relPrefix) : rootDir;
+    let entries;
+    try {
+      entries = (0, import_fs.readdirSync)(absDir, {
+        withFileTypes: true
+      });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (shouldSkipDirectory(entry.name)) continue;
+        if (shouldSkipFile(entry.name)) continue;
+        visit(relPrefix ? `${relPrefix}${import_path2.sep}${entry.name}` : entry.name);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (shouldSkipFile(entry.name)) continue;
+      const rel = (relPrefix ? `${relPrefix}${import_path2.sep}${entry.name}` : entry.name).split(import_path2.sep).join("/");
+      const abs = (0, import_path2.join)(rootDir, rel);
+      let stats;
+      try {
+        stats = (0, import_fs.statSync)(abs);
+      } catch {
+        continue;
+      }
+      if (stats.size > maxBytes) continue;
+      let content;
+      try {
+        content = (0, import_fs.readFileSync)(abs);
+      } catch {
+        continue;
+      }
+      const hash = hashContentTruncated(content.toString("utf-8"));
+      refs.push({
+        relativePath: rel,
+        hash,
+        size: stats.size,
+        type: classifyFile(rel)
+      });
+      if (!contentByHash.has(hash)) contentByHash.set(hash, content);
+      totalSize += stats.size;
+    }
+  }, "visit");
+  visit("");
+  refs.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  const projectHash = combineFileHashes(refs);
+  return {
+    files: refs,
+    projectHash,
+    totalSize,
+    contentByHash
+  };
+}
+__name(walkWorkspace, "walkWorkspace");
+
+// src/http.ts
+var BackupHttpError = class extends Error {
+  static {
+    __name(this, "BackupHttpError");
+  }
+  status;
+  endpoint;
+  body;
+  constructor(message, status, endpoint, body) {
+    super(message), this.status = status, this.endpoint = endpoint, this.body = body;
+    this.name = "BackupHttpError";
+  }
+};
+var BackupHttpClient = class {
+  static {
+    __name(this, "BackupHttpClient");
+  }
+  options;
+  fetchFn;
+  constructor(options) {
+    this.options = options;
+    this.fetchFn = options.fetch ?? fetch;
+  }
+  url(path) {
+    const base = this.options.baseUrl.replace(/\/$/, "");
+    return `${base}/developer/agents/${encodeURIComponent(this.options.agentId)}${path}`;
+  }
+  async json(method, path, body) {
+    const endpoint = this.url(path);
+    const res = await this.fetchFn(endpoint, {
+      method,
+      headers: {
+        Authorization: this.options.authHeader,
+        ...body !== void 0 ? {
+          "Content-Type": "application/json"
+        } : {},
+        Accept: "application/json"
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      let text2;
+      try {
+        text2 = await res.text();
+      } catch {
+        text2 = void 0;
+      }
+      throw new BackupHttpError(`Backup request failed: ${method} ${path} \u2192 ${res.status} ${res.statusText}`, res.status, endpoint, text2);
+    }
+    const text = await res.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  /** `POST /backup/check-blobs` — returns existing vs missing partition. */
+  checkBlobsExist(hashes) {
+    return this.json("POST", "/backup/check-blobs", {
+      hashes
+    });
+  }
+  /** `POST /backup/blob-upload-urls` — presigned S3 PUT URLs. */
+  getBlobUploadUrls(hashes) {
+    return this.json("POST", "/backup/blob-upload-urls", {
+      hashes
+    });
+  }
+  /** `POST /backup/blob-urls` — presigned S3 GET URLs (for restore). */
+  getBlobUrls(hashes) {
+    return this.json("POST", "/backup/blob-urls", {
+      hashes
+    });
+  }
+  /** `POST /backup/manifest` — final step in a push; returns server metadata. */
+  saveManifest(data) {
+    return this.json("POST", "/backup/manifest", data);
+  }
+  /** `GET /backup` — metadata only, no file list. */
+  getMetadata() {
+    return this.json("GET", "/backup");
+  }
+  /** `GET /backup/manifest` — metadata + file list. */
+  getManifest() {
+    return this.json("GET", "/backup/manifest");
+  }
+  /** `GET /backup/check/:hash` — fast freshness probe. */
+  checkBackupExists(hash) {
+    return this.json("GET", `/backup/check/${encodeURIComponent(hash)}`);
+  }
+};
+
+// src/transfer.ts
+var import_zlib = require("zlib");
+var DEFAULT_CONCURRENCY = 10;
+async function uploadBlobs(opts) {
+  const fetchFn = opts.fetch ?? fetch;
+  const concurrency = opts.concurrency ?? DEFAULT_CONCURRENCY;
+  const hashes = Object.keys(opts.uploadUrls);
+  for (let i = 0; i < hashes.length; i += concurrency) {
+    const batch = hashes.slice(i, i + concurrency);
+    await Promise.all(batch.map(async (hash) => {
+      const buf = opts.contentByHash.get(hash);
+      if (!buf) {
+        throw new Error(`uploadBlobs: no content for hash ${hash.slice(0, 12)}\u2026`);
+      }
+      const compressed = (0, import_zlib.gzipSync)(buf);
+      const res = await fetchFn(opts.uploadUrls[hash], {
+        method: "PUT",
+        body: compressed,
+        headers: {
+          "Content-Type": "application/octet-stream"
+        }
+      });
+      if (!res.ok) {
+        throw new Error(`S3 upload failed for ${hash.slice(0, 12)}\u2026: ${res.status} ${res.statusText}`);
+      }
+    }));
+  }
+  return hashes.length;
+}
+__name(uploadBlobs, "uploadBlobs");
+async function downloadBlobs(opts) {
+  const fetchFn = opts.fetch ?? fetch;
+  const concurrency = opts.concurrency ?? DEFAULT_CONCURRENCY;
+  const out = /* @__PURE__ */ new Map();
+  const entries = Object.entries(opts.urls);
+  for (let i = 0; i < entries.length; i += concurrency) {
+    const batch = entries.slice(i, i + concurrency);
+    const downloaded = await Promise.all(batch.map(async ([hash, url]) => {
+      const res = await fetchFn(url);
+      if (!res.ok) {
+        throw new Error(`S3 download failed for ${hash.slice(0, 12)}\u2026: ${res.status} ${res.statusText}`);
+      }
+      const ab = await res.arrayBuffer();
+      const buf = Buffer.from(ab);
+      if (buf.length >= 2 && buf[0] === 31 && buf[1] === 139) {
+        try {
+          return [
+            hash,
+            (0, import_zlib.gunzipSync)(buf)
+          ];
+        } catch {
+          return [
+            hash,
+            buf
+          ];
+        }
+      }
+      return [
+        hash,
+        buf
+      ];
+    }));
+    for (const [hash, buf] of downloaded) out.set(hash, buf);
+  }
+  return out;
+}
+__name(downloadBlobs, "downloadBlobs");
+
+// src/restore.ts
+var import_fs2 = require("fs");
+var import_path3 = require("path");
+function resolveBackupFileTarget(file, targetDir) {
+  const base = (0, import_path3.resolve)(targetDir);
+  const sandboxed = file.external ? (0, import_path3.join)(base, ".lua", "external", file.relativePath) : (0, import_path3.join)(base, file.relativePath);
+  const resolved = (0, import_path3.resolve)(sandboxed);
+  if (resolved !== base && !resolved.startsWith(base + import_path3.sep)) {
+    throw new Error(`Backup entry escapes target directory: ${file.relativePath}`);
+  }
+  return resolved;
+}
+__name(resolveBackupFileTarget, "resolveBackupFileTarget");
+function restoreFromBlobs(manifest, blobs, targetDir, opts = {}) {
+  let filesWritten = 0;
+  let filesUnchanged = 0;
+  let filesSkipped = 0;
+  for (const file of manifest.files) {
+    const content = blobs.get(file.hash);
+    if (!content) {
+      throw new Error(`Blob not found for hash: ${file.hash} (${file.relativePath})`);
+    }
+    const targetPath = resolveBackupFileTarget(file, targetDir);
+    if ((0, import_fs2.existsSync)(targetPath)) {
+      const sameSize = (0, import_fs2.statSync)(targetPath).size === content.length;
+      if (sameSize && (0, import_fs2.readFileSync)(targetPath).equals(content)) {
+        filesUnchanged++;
+        continue;
+      }
+      if (!opts.overwrite) {
+        filesSkipped++;
+        continue;
+      }
+    }
+    (0, import_fs2.mkdirSync)((0, import_path3.dirname)(targetPath), {
+      recursive: true
+    });
+    (0, import_fs2.writeFileSync)(targetPath, content);
+    filesWritten++;
+  }
+  return {
+    filesWritten,
+    filesUnchanged,
+    filesSkipped
+  };
+}
+__name(restoreFromBlobs, "restoreFromBlobs");
+
+// src/push.ts
+async function pushAgentBackup(opts) {
+  const snapshot = walkWorkspace(opts.workspaceDir, opts.walkOptions);
+  const client = new BackupHttpClient(opts.http);
+  const uniqueHashes = [
+    ...new Set(snapshot.files.map((f) => f.hash))
+  ];
+  let filesUploaded = 0;
+  if (uniqueHashes.length > 0) {
+    const checked = await client.checkBlobsExist(uniqueHashes);
+    if (checked.missing.length > 0) {
+      const urls = await client.getBlobUploadUrls(checked.missing);
+      filesUploaded = await uploadBlobs({
+        uploadUrls: urls.urls,
+        contentByHash: snapshot.contentByHash,
+        fetch: opts.http.fetch,
+        concurrency: opts.concurrency
+      });
+    }
+  }
+  const metadata = await client.saveManifest({
+    projectHash: snapshot.projectHash,
+    files: snapshot.files,
+    version: opts.version,
+    orgId: opts.orgId,
+    createdBy: opts.createdBy ?? "cli",
+    triggeredBy: opts.triggeredBy
+  });
+  return {
+    projectHash: snapshot.projectHash,
+    fileCount: snapshot.files.length,
+    filesUploaded,
+    activeVersion: metadata.activeVersion,
+    metadata,
+    files: snapshot.files
+  };
+}
+__name(pushAgentBackup, "pushAgentBackup");
+
+// src/pull.ts
+async function pullAgentBackup(opts) {
+  const client = new BackupHttpClient(opts.http);
+  const manifest = await client.getManifest();
+  const uniqueHashes = [
+    ...new Set(manifest.files.map((f) => f.hash))
+  ];
+  const blobs = uniqueHashes.length ? await (async () => {
+    const urls = await client.getBlobUrls(uniqueHashes);
+    return downloadBlobs({
+      urls: urls.urls,
+      fetch: opts.http.fetch,
+      concurrency: opts.concurrency
+    });
+  })() : /* @__PURE__ */ new Map();
+  const result = restoreFromBlobs(manifest, blobs, opts.targetDir, opts.restore);
+  return {
+    ...result,
+    manifest
+  };
+}
+__name(pullAgentBackup, "pullAgentBackup");
+
+// src/archive.ts
+var import_fs3 = require("fs");
+var import_path4 = require("path");
+var import_zlib2 = require("zlib");
+var ARCHIVE_SCHEMA_VERSION = 1;
+function encodeWorkspaceArchive(workspaceDir) {
+  const files = {};
+  try {
+    walk(workspaceDir, "", files);
+  } catch {
+    return null;
+  }
+  if (Object.keys(files).length === 0) return null;
+  const gz = (0, import_zlib2.gzipSync)(Buffer.from(JSON.stringify(files), "utf8"));
+  return gz.toString("base64");
+}
+__name(encodeWorkspaceArchive, "encodeWorkspaceArchive");
+function decodeWorkspaceArchive(archive, schemaVersion) {
+  if (schemaVersion !== void 0 && schemaVersion !== ARCHIVE_SCHEMA_VERSION) {
+    throw new Error(`Unsupported archive schema version: ${schemaVersion} (expected ${ARCHIVE_SCHEMA_VERSION})`);
+  }
+  const raw = (0, import_zlib2.gunzipSync)(Buffer.from(archive, "base64")).toString("utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Decoded archive is not a JSON object map");
+  }
+  return parsed;
+}
+__name(decodeWorkspaceArchive, "decodeWorkspaceArchive");
+function writeArchiveToWorkspace(workspaceDir, files) {
+  for (const [relPath, content] of Object.entries(files)) {
+    if (relPath.includes("..")) {
+      throw new Error(`Refusing to write archived path containing '..': ${relPath}`);
+    }
+    const abs = (0, import_path4.join)(workspaceDir, relPath);
+    (0, import_fs3.mkdirSync)((0, import_path4.dirname)(abs), {
+      recursive: true
+    });
+    (0, import_fs3.writeFileSync)(abs, content, "utf8");
+  }
+}
+__name(writeArchiveToWorkspace, "writeArchiveToWorkspace");
+function walk(root, prefix, out) {
+  const dir = prefix ? (0, import_path4.join)(root, prefix) : root;
+  const entries = (0, import_fs3.readdirSync)(dir, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (shouldSkipDirectory(entry.name) || ARCHIVE_ONLY_SKIP_DIRECTORIES.has(entry.name) || shouldSkipFile(entry.name)) continue;
+      walk(root, prefix ? `${prefix}${import_path4.sep}${entry.name}` : entry.name, out);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (shouldSkipFile(entry.name)) continue;
+    const relPath = (prefix ? `${prefix}${import_path4.sep}${entry.name}` : entry.name).split(import_path4.sep).join("/");
+    const abs = (0, import_path4.join)(dir, entry.name);
+    if ((0, import_fs3.statSync)(abs).size > DEFAULT_MAX_FILE_BYTES) continue;
+    try {
+      out[relPath] = (0, import_fs3.readFileSync)(abs, "utf8");
+    } catch {
+    }
+  }
+}
+__name(walk, "walk");
+
+// src/skill-source.ts
+var SKILL_SOURCE_EDITORS = [
+  "builder",
+  "cli",
+  "engineer",
+  "system"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARCHIVE_SCHEMA_VERSION,
+  BackupHttpClient,
+  BackupHttpError,
+  DEFAULT_MAX_FILE_BYTES,
+  FILE_HASH_LENGTH,
+  SKILL_SOURCE_EDITORS,
+  classifyFile,
+  combineFileHashes,
+  decodeWorkspaceArchive,
+  downloadBlobs,
+  encodeWorkspaceArchive,
+  hashContentTruncated,
+  pullAgentBackup,
+  pushAgentBackup,
+  resolveBackupFileTarget,
+  restoreFromBlobs,
+  sha256Hex,
+  shouldSkipDirectory,
+  shouldSkipFile,
+  uploadBlobs,
+  walkWorkspace,
+  writeArchiveToWorkspace
+});