lua-cli 3.15.3 → 3.16.0

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

@@ -1,536 +0,0 @@
-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
-});