@dinglebear/labby 1.8.6

package/scripts/install.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+"use strict";
+
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const http = require("node:http");
+const https = require("node:https");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const {
+  binaryPath,
+  downloadUrl,
+  installRoot,
+  releaseVersion,
+  targetFor,
+} = require("../lib/platform");
+
+function log(message) {
+  process.stderr.write(`labby: ${message}\n`);
+}
+
+function download(url, destination) {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith("http:") ? http : https;
+    const request = client.get(url, (response) => {
+      if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
+        response.resume();
+        download(response.headers.location, destination).then(resolve, reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`download failed (${response.statusCode}) from ${url}`));
+        return;
+      }
+
+      const file = fs.createWriteStream(destination, { mode: 0o600 });
+      response.pipe(file);
+      file.on("finish", () => file.close(resolve));
+      file.on("error", reject);
+    });
+
+    request.on("error", reject);
+  });
+}
+
+function sha256(file) {
+  const hash = crypto.createHash("sha256");
+  hash.update(fs.readFileSync(file));
+  return hash.digest("hex");
+}
+
+function checksumFromText(text, asset) {
+  const lines = text.trim().split(/\r?\n/).filter(Boolean);
+  for (const line of lines) {
+    const parts = line.trim().split(/\s+/);
+    const hash = parts[0] && parts[0].toLowerCase();
+    const name = parts.slice(1).join(" ").replace(/^\*/, "");
+    if (/^[a-f0-9]{64}$/.test(hash) && (!asset || !name || path.basename(name) === asset)) {
+      return hash;
+    }
+  }
+  throw new Error("checksum file does not contain a SHA-256 entry for " + asset);
+}
+
+async function verifyChecksum(url, archive) {
+  const asset = path.basename(archive);
+  const sidecarFile = archive + ".sha256";
+  let expected;
+
+  try {
+    await download(url + ".sha256", sidecarFile);
+    expected = checksumFromText(fs.readFileSync(sidecarFile, "utf8"), asset);
+  } catch (sidecarError) {
+    const manifestUrl = url.replace(/\/[^/]+$/, "/SHA256SUMS");
+    const manifestFile = archive + ".SHA256SUMS";
+    await download(manifestUrl, manifestFile);
+    expected = checksumFromText(fs.readFileSync(manifestFile, "utf8"), asset);
+  }
+
+  const actual = sha256(archive);
+  if (actual !== expected) {
+    throw new Error("checksum mismatch for " + asset + ": expected " + expected + ", got " + actual);
+  }
+
+  log("verified checksum for " + asset);
+}
+
+function run(command, args, failureMessage) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  if (result.status !== 0) {
+    throw new Error((result.stderr || result.stdout || failureMessage).trim());
+  }
+}
+
+function extractTarGz(archive, destination) {
+  run("tar", ["-xzf", archive, "-C", destination], "tar extraction failed");
+}
+
+function powershellLiteral(value) {
+  return `'${String(value).replaceAll("'", "''")}'`;
+}
+
+function powershellExpandArchiveCommand(archive, destination) {
+  return `Expand-Archive -LiteralPath ${powershellLiteral(archive)} -DestinationPath ${powershellLiteral(destination)} -Force`;
+}
+
+function extractZip(archive, destination) {
+  if (process.platform === "win32") {
+    run(
+      "powershell.exe",
+      [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        powershellExpandArchiveCommand(archive, destination),
+      ],
+      "zip extraction failed",
+    );
+    return;
+  }
+
+  run("unzip", ["-q", archive, "-d", destination], "zip extraction failed");
+}
+
+function extract(archive, destination, archiveType) {
+  fs.rmSync(destination, { recursive: true, force: true });
+  fs.mkdirSync(destination, { recursive: true });
+
+  if (archiveType === "tar.gz") {
+    extractTarGz(archive, destination);
+    return;
+  }
+
+  if (archiveType === "zip") {
+    extractZip(archive, destination);
+    return;
+  }
+
+  throw new Error(`unsupported archive type: ${archiveType}`);
+}
+
+async function main() {
+  if (process.env.LABBY_SKIP_DOWNLOAD === "1") {
+    log("skipping binary download because LABBY_SKIP_DOWNLOAD=1");
+    return;
+  }
+
+  const target = targetFor();
+  const destination = binaryPath();
+
+  if (fs.existsSync(destination)) {
+    log(`${path.basename(destination)} already installed for ${releaseVersion()}`);
+    return;
+  }
+
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "labby-mcp-install-"));
+  const archive = path.join(tempDir, target.asset);
+
+  try {
+    const url = downloadUrl(target);
+    log(`downloading ${url}`);
+    await download(url, archive);
+    await verifyChecksum(url, archive);
+    extract(archive, installRoot(), target.archiveType);
+    fs.chmodSync(destination, 0o755);
+    log(`installed ${destination}`);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    log(error.message);
+    process.exitCode = 1;
+  });
+}
+
+module.exports = {
+  powershellExpandArchiveCommand,
+  powershellLiteral,
+};

package/scripts/sync-readme.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const packageReadme = path.resolve(__dirname, "..", "README.md");
+const repoReadme = path.resolve(__dirname, "..", "..", "..", "README.md");
+const packageRoot = path.resolve(__dirname, "..");
+const repoRoot = path.resolve(__dirname, "..", "..", "..");
+
+if (fs.existsSync(packageReadme) && fs.lstatSync(packageReadme).isSymbolicLink()) {
+  fs.unlinkSync(packageReadme);
+}
+
+fs.copyFileSync(repoReadme, packageReadme);
+
+for (const entry of fs.readdirSync(repoRoot)) {
+  const source = path.join(repoRoot, entry);
+  if (/^licen[cs]e/i.test(entry) && fs.statSync(source).isFile()) {
+    const destination = path.join(packageRoot, entry);
+    if (fs.existsSync(destination) && fs.lstatSync(destination).isSymbolicLink()) {
+      fs.unlinkSync(destination);
+    }
+    fs.copyFileSync(source, destination);
+  }
+}