litescope 0.6.0

package/README.md

@@ -0,0 +1,33 @@
+# litescope
+
+Operations tooling for **SQLite**, **Cloudflare D1**, and **Turso** — an MCP
+server for AI agents, plus schema diff, migrations, lint, point-in-time backups,
+and a self-driving optimizer. This package is a thin installer that fetches the
+prebuilt [Litescope](https://github.com/croc100/Litescope) binary for your
+platform, so JavaScript and `wrangler` users can run it without a separate
+install.
+
+```bash
+# Run the latest without installing
+npx litescope doctor app.db
+
+# Diff your dev schema against live D1
+npx litescope diff local.db d1://DB_ID
+
+# Run it as an MCP server for Claude / Cursor
+npx litescope mcp --allow-writes
+```
+
+Install globally if you prefer:
+
+```bash
+npm install -g litescope
+litescope --version
+```
+
+The binary is downloaded from the matching GitHub release on install (or on
+first run) into the package's `vendor/` directory — macOS, Linux, and Windows
+(amd64/arm64). No data leaves your machine.
+
+Full documentation: **https://litescope-site.pages.dev/docs** ·
+Source & license (AGPL-3.0): **https://github.com/croc100/Litescope**

package/bin/litescope.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// Launcher for the litescope binary. Ensures the platform binary is present
+// (downloading it on first run if the postinstall step was skipped), then
+// forwards all arguments and exit codes transparently.
+"use strict";
+
+const { spawn } = require("child_process");
+const { ensureBinary } = require("../scripts/lib");
+
+(async () => {
+  let bin;
+  try {
+    bin = await ensureBinary();
+  } catch (err) {
+    console.error(`litescope: could not obtain the binary: ${err.message}`);
+    console.error("Install manually from https://github.com/croc100/Litescope/releases");
+    process.exit(1);
+  }
+
+  const child = spawn(bin, process.argv.slice(2), { stdio: "inherit" });
+  child.on("error", (err) => {
+    console.error(`litescope: failed to start: ${err.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code, signal) => {
+    if (signal) process.kill(process.pid, signal);
+    else process.exit(code === null ? 1 : code);
+  });
+})();

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "litescope",
+  "version": "0.6.0",
+  "description": "SQLite & Cloudflare D1 operations: MCP server, schema diff, migrations, lint, backups, autopilot. Run with `npx litescope`.",
+  "keywords": [
+    "sqlite",
+    "cloudflare",
+    "d1",
+    "turso",
+    "mcp",
+    "migration",
+    "schema-diff",
+    "wrangler"
+  ],
+  "homepage": "https://litescope-site.pages.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/croc100/Litescope.git"
+  },
+  "license": "AGPL-3.0",
+  "bin": {
+    "litescope": "bin/litescope.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/install.js"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,16 @@
+// postinstall: fetch the platform binary up front. If it fails (offline,
+// air-gapped CI, --ignore-scripts), we don't fail the install — the launcher
+// downloads it lazily on first run instead.
+"use strict";
+
+const { ensureBinary } = require("./lib");
+
+ensureBinary()
+  .then((p) => {
+    console.log(`litescope: binary ready (${p})`);
+  })
+  .catch((err) => {
+    console.error(`litescope: postinstall download skipped: ${err.message}`);
+    console.error("litescope: the binary will be fetched on first run.");
+    // Exit 0 — never break `npm install` over this.
+  });

package/scripts/lib.js

@@ -0,0 +1,114 @@
+// Shared install logic: resolve the platform's release asset, download it from
+// GitHub Releases, and extract the binary. Zero runtime dependencies — archive
+// extraction shells out to tar / unzip / Expand-Archive, which exist on every
+// supported platform.
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const { execFileSync } = require("child_process");
+const { version } = require("../package.json");
+
+const REPO = "croc100/Litescope";
+
+// platformAsset maps the current Node platform/arch to a release asset name.
+function platformAsset() {
+  const goarch = { x64: "amd64", arm64: "arm64" }[process.arch];
+  if (!goarch) throw new Error(`unsupported CPU architecture: ${process.arch}`);
+
+  let goos, ext, binName;
+  switch (process.platform) {
+    case "darwin":
+      goos = "darwin"; ext = "tar.gz"; binName = "litescope"; break;
+    case "linux":
+      goos = "linux"; ext = "tar.gz"; binName = "litescope"; break;
+    case "win32":
+      goos = "windows"; ext = "zip"; binName = "litescope.exe";
+      if (goarch !== "amd64") throw new Error("Windows is only supported on amd64");
+      break;
+    default:
+      throw new Error(`unsupported platform: ${process.platform}`);
+  }
+  const asset = `litescope_${version}_${goos}_${goarch}.${ext}`;
+  return { asset, ext, binName };
+}
+
+function vendorDir() {
+  return path.join(__dirname, "..", "vendor");
+}
+
+// binaryPath returns where the binary lives (it may not exist yet).
+function binaryPath() {
+  const { binName } = platformAsset();
+  return path.join(vendorDir(), binName);
+}
+
+// ensureBinary returns the path to the litescope binary, downloading and
+// extracting it on first use.
+async function ensureBinary() {
+  const { asset, ext, binName } = platformAsset();
+  const dir = vendorDir();
+  const binPath = path.join(dir, binName);
+  if (fs.existsSync(binPath)) return binPath;
+
+  fs.mkdirSync(dir, { recursive: true });
+  const url = `https://github.com/${REPO}/releases/download/v${version}/${asset}`;
+  const archivePath = path.join(dir, asset);
+
+  await download(url, archivePath);
+  extract(archivePath, dir, ext);
+  fs.unlinkSync(archivePath);
+  if (process.platform !== "win32") fs.chmodSync(binPath, 0o755);
+  if (!fs.existsSync(binPath)) {
+    throw new Error(`archive did not contain ${binName}`);
+  }
+  return binPath;
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const get = (u, redirects) => {
+      if (redirects > 6) return reject(new Error("too many redirects"));
+      https
+        .get(u, { headers: { "User-Agent": "litescope-npm" } }, (res) => {
+          if (
+            res.statusCode >= 300 &&
+            res.statusCode < 400 &&
+            res.headers.location
+          ) {
+            res.resume();
+            return get(res.headers.location, redirects + 1);
+          }
+          if (res.statusCode !== 200) {
+            res.resume();
+            return reject(new Error(`download failed (HTTP ${res.statusCode}) for ${u}`));
+          }
+          const file = fs.createWriteStream(dest);
+          res.pipe(file);
+          file.on("finish", () => file.close(() => resolve()));
+          file.on("error", reject);
+        })
+        .on("error", reject);
+    };
+    get(url, 0);
+  });
+}
+
+function extract(archive, dir, ext) {
+  if (ext === "zip") {
+    if (process.platform === "win32") {
+      execFileSync(
+        "powershell",
+        ["-NoProfile", "-Command", `Expand-Archive -Force -Path "${archive}" -DestinationPath "${dir}"`],
+        { stdio: "ignore" }
+      );
+    } else {
+      execFileSync("unzip", ["-o", archive, "-d", dir], { stdio: "ignore" });
+    }
+  } else {
+    execFileSync("tar", ["-xzf", archive, "-C", dir], { stdio: "ignore" });
+  }
+}
+
+module.exports = { ensureBinary, binaryPath, platformAsset, version };