@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/chunk-BKFM6EJV.js

@@ -0,0 +1,462 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  currentToolPlatform,
+  ensureToolchainRoot,
+  findPinnedTool,
+  toolchainRoot
+} from "./chunk-QDC3K2U3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/toolchain/install.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, renameSync, rmSync as rmSync2, writeFileSync } from "node:fs";
+import { basename, join as join2 } from "node:path";
+
+// src/domains/toolchain/archive.ts
+init_esm_shims();
+import { gunzipSync, inflateRawSync } from "node:zlib";
+var MAX_TOTAL_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;
+var ZIP_EOCD_SIGNATURE = 101010256;
+var ZIP_CENTRAL_SIGNATURE = 33639248;
+var ZIP_LOCAL_SIGNATURE = 67324752;
+var ZIP_STORED = 0;
+var ZIP_DEFLATED = 8;
+function readZipEntries(buffer) {
+  const eocd = findEndOfCentralDirectory(buffer);
+  if (eocd < 0) throw new Error("not a zip archive: end-of-central-directory record not found");
+  const entryCount = buffer.readUInt16LE(eocd + 10);
+  let cursor = buffer.readUInt32LE(eocd + 16);
+  const entries = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (let i = 0; i < entryCount; i += 1) {
+    if (cursor + 46 > buffer.length || buffer.readUInt32LE(cursor) !== ZIP_CENTRAL_SIGNATURE) {
+      throw new Error(`zip central directory is malformed at entry ${i}`);
+    }
+    const method = buffer.readUInt16LE(cursor + 10);
+    const compressedSize = buffer.readUInt32LE(cursor + 20);
+    const uncompressedSize = buffer.readUInt32LE(cursor + 24);
+    const nameLength = buffer.readUInt16LE(cursor + 28);
+    const extraLength = buffer.readUInt16LE(cursor + 30);
+    const commentLength = buffer.readUInt16LE(cursor + 32);
+    const externalAttributes = buffer.readUInt32LE(cursor + 38);
+    const localOffset = buffer.readUInt32LE(cursor + 42);
+    const name = buffer.toString("utf8", cursor + 46, cursor + 46 + nameLength);
+    cursor += 46 + nameLength + extraLength + commentLength;
+    if (name.endsWith("/")) continue;
+    assertSafeMember(name);
+    total += uncompressedSize;
+    if (total > MAX_TOTAL_UNCOMPRESSED_BYTES) throw new Error("zip archive expands beyond the size cap");
+    if (localOffset + 30 > buffer.length || buffer.readUInt32LE(localOffset) !== ZIP_LOCAL_SIGNATURE) {
+      throw new Error(`zip local header is malformed for ${name}`);
+    }
+    const localNameLength = buffer.readUInt16LE(localOffset + 26);
+    const localExtraLength = buffer.readUInt16LE(localOffset + 28);
+    const dataStart = localOffset + 30 + localNameLength + localExtraLength;
+    const raw = buffer.subarray(dataStart, dataStart + compressedSize);
+    const data = method === ZIP_STORED ? Buffer.from(raw) : method === ZIP_DEFLATED ? inflateRawSync(raw) : (() => {
+      throw new Error(`unsupported zip compression method ${method} for ${name}`);
+    })();
+    const unixMode = externalAttributes >>> 16 & 4095;
+    entries.set(name, { path: name, data, mode: unixMode === 0 ? null : unixMode });
+  }
+  return entries;
+}
+function readTarGzEntries(buffer) {
+  const tar = gunzipSync(buffer);
+  const entries = /* @__PURE__ */ new Map();
+  let offset = 0;
+  let total = 0;
+  let pendingLongName = null;
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+    const rawName = readTarString(header, 0, 100);
+    const prefix = readTarString(header, 345, 155);
+    const size = readTarOctal(header, 124, 12);
+    const mode = readTarOctal(header, 100, 8);
+    const typeFlag = String.fromCharCode(header[156] ?? 0);
+    const dataStart = offset + 512;
+    const padded = Math.ceil(size / 512) * 512;
+    offset = dataStart + padded;
+    if (typeFlag === "L") {
+      pendingLongName = tar.toString("utf8", dataStart, dataStart + size).replace(/\0+$/, "");
+      continue;
+    }
+    if (typeFlag === "x" || typeFlag === "g" || typeFlag === "5") {
+      pendingLongName = null;
+      continue;
+    }
+    if (typeFlag !== "0" && typeFlag !== "\0") {
+      pendingLongName = null;
+      continue;
+    }
+    const name = pendingLongName ?? (prefix.length > 0 ? `${prefix}/${rawName}` : rawName);
+    pendingLongName = null;
+    if (name.length === 0 || name.endsWith("/")) continue;
+    assertSafeMember(name);
+    total += size;
+    if (total > MAX_TOTAL_UNCOMPRESSED_BYTES) throw new Error("tar archive expands beyond the size cap");
+    entries.set(name, {
+      path: name,
+      data: Buffer.from(tar.subarray(dataStart, dataStart + size)),
+      mode: mode === 0 ? null : mode & 4095
+    });
+  }
+  return entries;
+}
+function findEndOfCentralDirectory(buffer) {
+  const start = Math.max(0, buffer.length - (22 + 65535));
+  for (let i = buffer.length - 22; i >= start; i -= 1) {
+    if (buffer.readUInt32LE(i) === ZIP_EOCD_SIGNATURE) return i;
+  }
+  return -1;
+}
+function readTarString(header, offset, length) {
+  const slice = header.subarray(offset, offset + length);
+  const end = slice.indexOf(0);
+  return slice.toString("utf8", 0, end === -1 ? slice.length : end);
+}
+function readTarOctal(header, offset, length) {
+  const text = readTarString(header, offset, length).trim();
+  if (text.length === 0) return 0;
+  const value = Number.parseInt(text, 8);
+  return Number.isNaN(value) ? 0 : value;
+}
+function assertSafeMember(name) {
+  if (name.startsWith("/") || name.startsWith("\\") || /^[A-Za-z]:/.test(name)) {
+    throw new Error(`archive member has an absolute path: ${name}`);
+  }
+  if (name.split(/[/\\]/).includes("..")) {
+    throw new Error(`archive member escapes the archive root: ${name}`);
+  }
+}
+
+// src/domains/toolchain/remove.ts
+init_esm_shims();
+import { readdirSync, rmdirSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+var STALE_STAGING_MS = 36e5;
+function installedToolVersions(id, options = {}) {
+  const dir = join(options.root ?? toolchainRoot(), id);
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.filter((name) => !name.startsWith(".") && isDirectory(join(dir, name))).sort((a, b) => a.localeCompare(b));
+}
+function removeTool(id, options = {}) {
+  if (findPinnedTool(id) === null) {
+    const dir = join(options.root ?? toolchainRoot(), id);
+    return { ok: false, id, dir, removed: [], failed: [], staleStaging: [], message: `unknown tool: ${id}` };
+  }
+  return removeVersions(id, null, options);
+}
+function pruneSupersededVersions(id, keep, options = {}) {
+  return removeVersions(id, keep, options);
+}
+function removeVersions(id, keep, options) {
+  const root = options.root ?? toolchainRoot();
+  const dir = join(root, id);
+  const versions = installedToolVersions(id, { root }).filter((version) => version !== keep);
+  const removed = [];
+  const failed = [];
+  for (const version of versions) {
+    try {
+      rmSync(join(dir, version), { recursive: true, force: true });
+      removed.push(version);
+    } catch (error) {
+      failed.push({ version, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  const staleStaging = sweepStaleStaging(dir, options.staleStagingMs ?? STALE_STAGING_MS);
+  if (keep === null && failed.length === 0) {
+    try {
+      rmdirSync(dir);
+    } catch {
+    }
+  }
+  return {
+    ok: failed.length === 0,
+    id,
+    dir,
+    removed,
+    failed,
+    staleStaging,
+    message: describeRemoval(id, dir, keep, removed, failed, staleStaging)
+  };
+}
+function sweepStaleStaging(dir, staleMs) {
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const cutoff = Date.now() - staleMs;
+  const swept = [];
+  for (const name of names.sort((a, b) => a.localeCompare(b))) {
+    if (!STAGING_NAME.test(name)) continue;
+    const stat = statSync(join(dir, name), { throwIfNoEntry: false });
+    if (stat === void 0 || !stat.isDirectory() || stat.mtimeMs > cutoff) continue;
+    try {
+      rmSync(join(dir, name), { recursive: true, force: true });
+      swept.push(name);
+    } catch {
+    }
+  }
+  return swept;
+}
+var STAGING_NAME = /^\.[^/]+\.(?:incomplete|replaced)-\d+-[a-z0-9]+$/;
+function describeRemoval(id, dir, keep, removed, failed, staleStaging) {
+  const swept = staleStaging.length === 0 ? "" : `; swept ${staleStaging.length} abandoned install ${staleStaging.length === 1 ? "directory" : "directories"}`;
+  const trouble = failed.map((entry) => `${entry.version} (${entry.error})`).join(", ");
+  if (failed.length > 0) {
+    const done = removed.length > 0 ? `removed ${removed.join(", ")}; ` : "";
+    return `${done}could not remove ${id} ${trouble} under ${dir}${swept}`;
+  }
+  if (removed.length === 0) {
+    return keep === null ? `${id} is not installed under ${dir}; nothing to remove${swept}` : `${id} has no superseded versions under ${dir}${swept}`;
+  }
+  const what = `${id} ${removed.join(", ")}`;
+  const headline = keep === null ? `removed ${what} from ${dir}` : `pruned ${what} from ${dir}, keeping ${keep}`;
+  return `${headline}${swept}`;
+}
+function isDirectory(path) {
+  return statSync(path, { throwIfNoEntry: false })?.isDirectory() === true;
+}
+
+// src/domains/toolchain/install.ts
+var DOWNLOAD_TIMEOUT_MS = 3e5;
+async function installTool(id, options = {}) {
+  const entry = findPinnedTool(id);
+  if (entry === null) {
+    return failure(id, "unknown", "", `unknown tool: ${id}`);
+  }
+  return installPinnedTool(entry, options);
+}
+async function installPinnedTool(entry, options = {}) {
+  const root = options.root ?? ensureToolchainRoot();
+  const dir = join2(root, entry.id, entry.version);
+  const platform = options.platform ?? currentToolPlatform();
+  const progress = options.onProgress ?? (() => void 0);
+  if (platform === null) {
+    return failure(entry.id, entry.version, dir, `no pinned asset for ${process.platform}-${process.arch}`);
+  }
+  const download = entry.downloads[platform];
+  if (download === void 0) {
+    return failure(entry.id, entry.version, dir, `no pinned asset for ${platform}`);
+  }
+  const installedBinaries = Object.keys(download.binaryMembers).map((name) => join2(dir, executableName(name, platform)));
+  if (!options.force && installedBinaries.every((path) => existsSync(path))) {
+    const swept2 = prune(root, entry);
+    return {
+      ok: true,
+      id: entry.id,
+      version: entry.version,
+      dir,
+      binaries: installedBinaries,
+      documents: [],
+      skipped: true,
+      pruned: swept2.pruned,
+      message: `${entry.id} ${entry.version} is already installed at ${dir}${swept2.note}`
+    };
+  }
+  const fetcher = options.fetch ?? fetchAsset;
+  let assetBytes;
+  try {
+    progress(`downloading ${download.url}`);
+    assetBytes = await fetcher(download.url);
+  } catch (error) {
+    return failure(entry.id, entry.version, dir, `download failed: ${messageOf(error)}`);
+  }
+  const actual = sha256(assetBytes);
+  if (actual !== download.sha256) {
+    return failure(
+      entry.id,
+      entry.version,
+      dir,
+      `checksum mismatch for ${download.url}: expected ${download.sha256}, got ${actual}. Nothing was written.`
+    );
+  }
+  progress(`checksum verified (${actual})`);
+  const documentBytes = /* @__PURE__ */ new Map();
+  for (const doc of entry.documents) {
+    let bytes;
+    try {
+      progress(`downloading ${doc.url}`);
+      bytes = await fetcher(doc.url);
+    } catch (error) {
+      return failure(entry.id, entry.version, dir, `download failed for ${doc.name}: ${messageOf(error)}`);
+    }
+    const docHash = sha256(bytes);
+    if (docHash !== doc.sha256) {
+      return failure(
+        entry.id,
+        entry.version,
+        dir,
+        `checksum mismatch for ${doc.url}: expected ${doc.sha256}, got ${docHash}. Nothing was written.`
+      );
+    }
+    documentBytes.set(doc.name, bytes);
+  }
+  let members;
+  try {
+    members = unpack(assetBytes, download);
+  } catch (error) {
+    return failure(entry.id, entry.version, dir, `could not unpack the asset: ${messageOf(error)}`);
+  }
+  for (const memberPath of Object.values(download.binaryMembers)) {
+    if (!members.has(memberPath)) {
+      return failure(entry.id, entry.version, dir, `the asset does not contain ${memberPath || entry.primaryBinary}`);
+    }
+  }
+  for (const memberPath of download.documentMembers) {
+    if (!members.has(memberPath)) {
+      return failure(entry.id, entry.version, dir, `the asset does not contain ${memberPath}`);
+    }
+  }
+  const staging = join2(root, entry.id, `.${entry.version}.incomplete-${process.pid}-${Date.now().toString(36)}`);
+  const retired = join2(root, entry.id, `.${entry.version}.replaced-${process.pid}-${Date.now().toString(36)}`);
+  let retiredOld = false;
+  const binaries = [];
+  const documents = [];
+  try {
+    mkdirSync(staging, { recursive: true });
+    for (const [name, memberPath] of Object.entries(download.binaryMembers)) {
+      const member = members.get(memberPath);
+      if (member === void 0) continue;
+      const target = join2(staging, executableName(name, platform));
+      writeFileSync(target, member.data);
+      chmodSync(target, 493);
+      binaries.push(join2(dir, executableName(name, platform)));
+    }
+    for (const memberPath of download.documentMembers) {
+      const member = members.get(memberPath);
+      if (member === void 0) continue;
+      const target = join2(staging, basename(memberPath));
+      writeFileSync(target, member.data, { mode: 420 });
+      documents.push(join2(dir, basename(memberPath)));
+    }
+    for (const [name, bytes] of documentBytes) {
+      writeFileSync(join2(staging, name), bytes, { mode: 420 });
+      documents.push(join2(dir, name));
+    }
+    writeFileSync(
+      join2(staging, "clio-install.json"),
+      `${JSON.stringify(
+        {
+          id: entry.id,
+          version: entry.version,
+          platform,
+          license: entry.license,
+          homepage: entry.homepage,
+          url: download.url,
+          sha256: download.sha256,
+          installedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        null,
+        2
+      )}
+`,
+      { mode: 420 }
+    );
+    if (options.force && existsSync(dir)) {
+      renameSync(dir, retired);
+      retiredOld = true;
+    }
+    renameSync(staging, dir);
+    if (retiredOld) {
+      rmSync2(retired, { recursive: true, force: true });
+      retiredOld = false;
+    }
+  } catch (error) {
+    rmSync2(staging, { recursive: true, force: true });
+    if (retiredOld && !existsSync(dir)) {
+      try {
+        renameSync(retired, dir);
+        retiredOld = false;
+      } catch {
+      }
+    }
+    if (!options.force && existsSync(dir)) {
+      const swept2 = prune(root, entry);
+      return {
+        ok: true,
+        id: entry.id,
+        version: entry.version,
+        dir,
+        binaries: installedBinaries,
+        documents: [],
+        skipped: true,
+        pruned: swept2.pruned,
+        message: `${entry.id} ${entry.version} was installed concurrently at ${dir}${swept2.note}`
+      };
+    }
+    return failure(entry.id, entry.version, dir, `install failed: ${messageOf(error)}`);
+  }
+  const swept = prune(root, entry);
+  return {
+    ok: true,
+    id: entry.id,
+    version: entry.version,
+    dir,
+    binaries,
+    documents,
+    skipped: false,
+    pruned: swept.pruned,
+    message: `installed ${entry.id} ${entry.version} (${entry.license}) at ${dir}${swept.note}`
+  };
+}
+function prune(root, entry) {
+  const outcome = pruneSupersededVersions(entry.id, entry.version, { root });
+  const parts = [];
+  if (outcome.removed.length > 0) parts.push(`pruned ${outcome.removed.join(", ")}`);
+  if (outcome.staleStaging.length > 0) {
+    const count = outcome.staleStaging.length;
+    parts.push(`swept ${count} abandoned install ${count === 1 ? "directory" : "directories"}`);
+  }
+  if (outcome.failed.length > 0) {
+    parts.push(`could not prune ${outcome.failed.map((item) => `${item.version} (${item.error})`).join(", ")}`);
+  }
+  return { pruned: outcome.removed, note: parts.length === 0 ? "" : `; ${parts.join("; ")}` };
+}
+function unpack(bytes, download) {
+  if (download.archive === "raw") {
+    return /* @__PURE__ */ new Map([["", { path: "", data: bytes, mode: 493 }]]);
+  }
+  if (download.archive === "zip") return readZipEntries(bytes);
+  return readTarGzEntries(bytes);
+}
+async function fetchAsset(url) {
+  const response = await fetch(url, {
+    redirect: "follow",
+    signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
+  });
+  if (!response.ok) throw new Error(`HTTP ${response.status} ${response.statusText}`);
+  return Buffer.from(await response.arrayBuffer());
+}
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function executableName(name, platform) {
+  return platform.startsWith("win32") ? `${name}.exe` : name;
+}
+function failure(id, version, dir, message) {
+  return { ok: false, id, version, dir, binaries: [], documents: [], skipped: false, pruned: [], message };
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export {
+  installedToolVersions,
+  removeTool,
+  installTool,
+  installPinnedTool
+};
+//# sourceMappingURL=chunk-BKFM6EJV.js.map

package/dist/chunk-BMS5RKQY.js

@@ -0,0 +1,27 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  findExecutableOnPath,
+  resolveToolBinary
+} from "./chunk-QSNYB6ZV.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/executables.ts
+init_esm_shims();
+function resolveFdBinary() {
+  return findExecutableOnPath("fd") ?? findExecutableOnPath("fdfind");
+}
+function resolveRgBinary() {
+  return findExecutableOnPath("rg");
+}
+function resolveBinary(name) {
+  return resolveToolBinary(name).binaryPath;
+}
+
+export {
+  resolveFdBinary,
+  resolveRgBinary,
+  resolveBinary
+};
+//# sourceMappingURL=chunk-BMS5RKQY.js.map

package/dist/{chunk-ZNLWCMVZ.js → chunk-BPKCPIL7.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-W6GROXXM.js";
 import {
   ceilChars
-} from "./chunk-RWSI4YD7.js";
+} from "./chunk-UM7N4G5A.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -119,4 +119,4 @@ export {
   recallableRefListing,
   recallErrorMessage
 };
-//# sourceMappingURL=chunk-ZNLWCMVZ.js.map
+//# sourceMappingURL=chunk-BPKCPIL7.js.map