moondesk 0.1.1 → 0.1.4

package/README.md

@@ -88,6 +88,8 @@ I tried this with GPT-5.2 before, and the results were poor. However, **GPT-5.4
    npm install -g moondesk
    ```
 
+   MoonDesk does not rely on npm lifecycle/install scripts. On the first `moondesk` run, the small npm wrapper downloads the matching native binary from the GitHub Release, verifies it against that release's `SHA256SUMS`, and stores it in a versioned user cache under `~/.moondesk/npm-bin/`. This works with npm 12's default-deny install-script policy and also keeps the running native executable outside npm's `node_modules`, which makes Windows package upgrades less likely to hit locked-file errors.
+
 2. Run MoonDesk from any terminal directory.
 
    ```bash

package/npm/install-binary.js

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const packageRoot = path.resolve(__dirname, "..");
+const packageJson = require(path.join(packageRoot, "package.json"));
+const version = packageJson.version;
+const releaseTag = `v${version}`;
+const defaultReleaseBaseUrl = `https://github.com/Shattermoon/moondesk/releases/download/${releaseTag}`;
+
+const MAX_BINARY_BYTES = 128 * 1024 * 1024;
+const MAX_CHECKSUM_BYTES = 1024 * 1024;
+const METADATA_TIMEOUT_MS = 60_000;
+const BINARY_TIMEOUT_MS = 10 * 60_000;
+const LOCK_STALE_MS = 15 * 60_000;
+const LOCK_WAIT_MS = 15 * 60_000;
+const LOCK_POLL_MS = 100;
+
+const supportedTargets = new Set([
+  "linux-x64",
+  "linux-arm64",
+  "darwin-x64",
+  "darwin-arm64",
+  "win32-x64",
+]);
+
+function resolveTarget(platform = process.platform, arch = process.arch) {
+  const target = `${platform}-${arch}`;
+  if (!supportedTargets.has(target)) {
+    throw new Error(
+      `MoonDesk does not provide a prebuilt binary for ${target}. Supported targets: ${Array.from(supportedTargets).join(", ")}`,
+    );
+  }
+
+  return {
+    platform,
+    arch,
+    target,
+    assetName: platform === "win32" ? `moondesk-${target}.exe` : `moondesk-${target}`,
+    executableName: platform === "win32" ? "moondesk.exe" : "moondesk",
+  };
+}
+
+function defaultInstallDir(target) {
+  if (process.env.MOONDESK_BINARY_CACHE_DIR) {
+    return path.resolve(process.env.MOONDESK_BINARY_CACHE_DIR);
+  }
+
+  return path.join(os.homedir(), ".moondesk", "npm-bin", releaseTag, target);
+}
+
+async function fetchRequired(fetchImpl, url, maxBytes, timeoutMs = METADATA_TIMEOUT_MS) {
+  const response = await fetchImpl(url, {
+    headers: {
+      "User-Agent": `moondesk-npm/${version}`,
+    },
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+
+  if (!response.ok) {
+    throw new Error(`${url} returned HTTP ${response.status}`);
+  }
+
+  const contentLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+    throw new Error(`${url} is unexpectedly large (${contentLength} bytes)`);
+  }
+
+  const buffer = Buffer.from(await response.arrayBuffer());
+  if (buffer.length > maxBytes) {
+    throw new Error(`${url} exceeded the ${maxBytes}-byte download limit`);
+  }
+
+  return buffer;
+}
+
+function expectedSha256(checksums, name) {
+  for (const line of checksums.split(/\r?\n/)) {
+    const match = line.trim().match(/^([a-fA-F0-9]{64})\s+\*?(.+)$/);
+    if (match && path.basename(match[2]) === name) {
+      return match[1].toLowerCase();
+    }
+  }
+
+  throw new Error(`SHA256SUMS does not contain ${name}`);
+}
+
+function sha256Buffer(buffer) {
+  return crypto.createHash("sha256").update(buffer).digest("hex");
+}
+
+function sha256File(filePath) {
+  return sha256Buffer(fs.readFileSync(filePath));
+}
+
+function cacheMetadata(stat, expected) {
+  return {
+    version: 1,
+    sha256: expected,
+    size: stat.size,
+    mtimeMs: stat.mtimeMs,
+    ctimeMs: stat.ctimeMs,
+  };
+}
+
+function writeCacheMetadata(metadataPath, binaryPath, expected) {
+  const stat = fs.statSync(binaryPath);
+  fs.writeFileSync(metadataPath, `${JSON.stringify(cacheMetadata(stat, expected))}\n`, {
+    mode: 0o600,
+  });
+}
+
+function validCachedBinary(binaryPath, checksumPath, metadataPath, platform) {
+  if (!fs.existsSync(binaryPath) || !fs.existsSync(checksumPath)) {
+    return false;
+  }
+
+  let stat = fs.statSync(binaryPath);
+  if (!stat.isFile() || stat.size === 0 || stat.size > MAX_BINARY_BYTES) {
+    return false;
+  }
+
+  const expected = fs.readFileSync(checksumPath, "utf8").trim().toLowerCase();
+  if (!/^[a-f0-9]{64}$/.test(expected)) {
+    return false;
+  }
+
+  let metadata;
+  try {
+    metadata = JSON.parse(fs.readFileSync(metadataPath, "utf8"));
+  } catch {
+    metadata = null;
+  }
+
+  const fastPathMatches =
+    metadata?.version === 1 &&
+    metadata.sha256 === expected &&
+    metadata.size === stat.size &&
+    metadata.mtimeMs === stat.mtimeMs &&
+    metadata.ctimeMs === stat.ctimeMs;
+
+  if (fastPathMatches) {
+    return true;
+  }
+
+  if (sha256File(binaryPath) !== expected) {
+    return false;
+  }
+
+  if (platform !== "win32" && (stat.mode & 0o111) === 0) {
+    fs.chmodSync(binaryPath, 0o755);
+    stat = fs.statSync(binaryPath);
+  }
+
+  fs.writeFileSync(metadataPath, `${JSON.stringify(cacheMetadata(stat, expected))}\n`, {
+    mode: 0o600,
+  });
+  return true;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function lockOwnerIsAlive(lockPath) {
+  try {
+    const [pidText] = fs.readFileSync(lockPath, "utf8").split(/\r?\n/);
+    const pid = Number(pidText);
+    if (!Number.isSafeInteger(pid) || pid <= 0) {
+      return false;
+    }
+
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      if (error.code === "ESRCH") {
+        return false;
+      }
+      if (error.code === "EPERM") {
+        return true;
+      }
+      throw error;
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+async function acquireInstallLock(
+  lockPath,
+  binaryPath,
+  checksumPath,
+  metadataPath,
+  platform,
+) {
+  const deadline = Date.now() + LOCK_WAIT_MS;
+
+  while (Date.now() < deadline) {
+    if (validCachedBinary(binaryPath, checksumPath, metadataPath, platform)) {
+      return null;
+    }
+
+    try {
+      const fd = fs.openSync(lockPath, "wx", 0o600);
+      fs.writeFileSync(fd, `${process.pid}\n${Date.now()}\n`);
+      return fd;
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+
+      try {
+        const age = Date.now() - fs.statSync(lockPath).mtimeMs;
+        if (!lockOwnerIsAlive(lockPath) || age > LOCK_STALE_MS) {
+          fs.rmSync(lockPath, { force: true });
+          continue;
+        }
+      } catch (statError) {
+        if (statError.code !== "ENOENT") {
+          throw statError;
+        }
+      }
+
+      await sleep(LOCK_POLL_MS);
+    }
+  }
+
+  if (validCachedBinary(binaryPath, checksumPath, metadataPath, platform)) {
+    return null;
+  }
+
+  throw new Error("Timed out waiting for another MoonDesk process to finish installing the native binary");
+}
+
+async function ensureBinary(options = {}) {
+  const targetInfo = resolveTarget(options.platform, options.arch);
+  const installDir = options.installDir ?? defaultInstallDir(targetInfo.target);
+  const releaseBaseUrl = options.releaseBaseUrl ?? defaultReleaseBaseUrl;
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+
+  if (typeof fetchImpl !== "function") {
+    throw new Error("MoonDesk requires Node.js 18 or newer so the native binary can be downloaded securely");
+  }
+
+  const binaryPath = path.join(installDir, targetInfo.executableName);
+  const checksumPath = `${binaryPath}.sha256`;
+  const metadataPath = `${binaryPath}.metadata.json`;
+  const lockPath = path.join(installDir, ".install.lock");
+
+  fs.mkdirSync(installDir, { recursive: true, mode: 0o700 });
+
+  if (validCachedBinary(binaryPath, checksumPath, metadataPath, targetInfo.platform)) {
+    return binaryPath;
+  }
+
+  const lockFd = await acquireInstallLock(
+    lockPath,
+    binaryPath,
+    checksumPath,
+    metadataPath,
+    targetInfo.platform,
+  );
+
+  if (lockFd === null) {
+    return binaryPath;
+  }
+
+  const nonce = `${process.pid}-${crypto.randomBytes(8).toString("hex")}`;
+  const tempBinary = `${binaryPath}.tmp-${nonce}`;
+  const tempChecksum = `${checksumPath}.tmp-${nonce}`;
+
+  try {
+    if (validCachedBinary(binaryPath, checksumPath, metadataPath, targetInfo.platform)) {
+      return binaryPath;
+    }
+
+    const checksumsBuffer = await fetchRequired(
+      fetchImpl,
+      `${releaseBaseUrl}/SHA256SUMS`,
+      MAX_CHECKSUM_BYTES,
+    );
+    const expected = expectedSha256(checksumsBuffer.toString("utf8"), targetInfo.assetName);
+    const binary = await fetchRequired(
+      fetchImpl,
+      `${releaseBaseUrl}/${targetInfo.assetName}`,
+      MAX_BINARY_BYTES,
+      BINARY_TIMEOUT_MS,
+    );
+    const actual = sha256Buffer(binary);
+
+    if (actual !== expected) {
+      throw new Error(
+        `Checksum mismatch for ${targetInfo.assetName}: expected ${expected}, got ${actual}`,
+      );
+    }
+
+    fs.writeFileSync(tempBinary, binary, { mode: 0o755 });
+    if (targetInfo.platform !== "win32") {
+      fs.chmodSync(tempBinary, 0o755);
+    }
+    fs.writeFileSync(tempChecksum, `${expected}\n`, { mode: 0o600 });
+
+    fs.rmSync(binaryPath, { force: true });
+    fs.rmSync(checksumPath, { force: true });
+    fs.rmSync(metadataPath, { force: true });
+    fs.renameSync(tempBinary, binaryPath);
+    fs.renameSync(tempChecksum, checksumPath);
+    writeCacheMetadata(metadataPath, binaryPath, expected);
+
+    if (!validCachedBinary(binaryPath, checksumPath, metadataPath, targetInfo.platform)) {
+      throw new Error(`Installed ${targetInfo.assetName} failed its local checksum verification`);
+    }
+
+    return binaryPath;
+  } finally {
+    fs.rmSync(tempBinary, { force: true });
+    fs.rmSync(tempChecksum, { force: true });
+    try {
+      fs.closeSync(lockFd);
+    } finally {
+      fs.rmSync(lockPath, { force: true });
+    }
+  }
+}
+
+module.exports = {
+  ensureBinary,
+  expectedSha256,
+  resolveTarget,
+  sha256Buffer,
+};
+
+if (require.main === module) {
+  ensureBinary()
+    .then((binaryPath) => {
+      console.log(`MoonDesk native binary ready at ${binaryPath}`);
+    })
+    .catch((error) => {
+      console.error(`MoonDesk binary install failed: ${error.message}`);
+      process.exit(1);
+    });
+}

package/npm/moondesk.js

@@ -1,27 +1,40 @@
 #!/usr/bin/env node
 
 const { spawn } = require("node:child_process");
-const path = require("node:path");
+const { ensureBinary } = require("./install-binary");
 
-const executableName = process.platform === "win32" ? "moondesk.exe" : "moondesk";
-const binaryPath = path.join(__dirname, "bin", executableName);
+async function main() {
+  let binaryPath;
+  try {
+    binaryPath = await ensureBinary();
+  } catch (error) {
+    console.error(`MoonDesk could not prepare its native binary: ${error.message}`);
+    console.error("Check your network connection and the matching GitHub Release, then run MoonDesk again.");
+    process.exit(1);
+    return;
+  }
 
-const child = spawn(binaryPath, process.argv.slice(2), {
-  cwd: process.cwd(),
-  env: process.env,
-  stdio: "inherit",
-});
+  const child = spawn(binaryPath, process.argv.slice(2), {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: "inherit",
+  });
+
+  child.on("error", (error) => {
+    console.error(`MoonDesk failed to start: ${error.message}`);
+    process.exit(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 1);
+  });
+}
 
-child.on("error", (error) => {
+main().catch((error) => {
   console.error(`MoonDesk failed to start: ${error.message}`);
-  console.error("Reinstall MoonDesk after the matching GitHub Release binary is available.");
   process.exit(1);
 });
-
-child.on("exit", (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
-    return;
-  }
-  process.exit(code ?? 1);
-});

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "moondesk",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "MoonDesk — use ChatGPT Chat as a local coding agent, by Shattermoon.",
   "author": "Shattermoon",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Shattermoon/moondesk"
+    "url": "git+https://github.com/Shattermoon/moondesk.git"
   },
   "homepage": "https://github.com/Shattermoon/moondesk#readme",
   "bugs": {
@@ -15,12 +15,9 @@
   "bin": {
     "moondesk": "npm/moondesk.js"
   },
-  "scripts": {
-    "postinstall": "node npm/postinstall.js"
-  },
   "files": [
     "npm/moondesk.js",
-    "npm/postinstall.js",
+    "npm/install-binary.js",
     "LICENSE",
     "README.md"
   ],

package/npm/postinstall.js

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-
-const crypto = require("node:crypto");
-const fs = require("node:fs");
-const path = require("node:path");
-
-const packageRoot = path.resolve(__dirname, "..");
-const packageJson = require(path.join(packageRoot, "package.json"));
-const version = packageJson.version;
-const releaseTag = `v${version}`;
-const releaseBaseUrl = `https://github.com/Shattermoon/moondesk/releases/download/${releaseTag}`;
-
-const supportedTargets = new Set([
-  "linux-x64",
-  "linux-arm64",
-  "darwin-x64",
-  "darwin-arm64",
-  "win32-x64",
-]);
-
-const platform = process.platform;
-const arch = process.arch;
-const target = `${platform}-${arch}`;
-
-if (!supportedTargets.has(target)) {
-  console.error(`MoonDesk does not provide a prebuilt binary for ${target}.`);
-  console.error(`Supported targets: ${Array.from(supportedTargets).join(", ")}`);
-  process.exit(1);
-}
-
-const assetName = platform === "win32" ? `moondesk-${target}.exe` : `moondesk-${target}`;
-const executableName = platform === "win32" ? "moondesk.exe" : "moondesk";
-const binDir = path.join(__dirname, "bin");
-const installedBinary = path.join(binDir, executableName);
-
-async function fetchRequired(url) {
-  const response = await fetch(url, {
-    headers: {
-      "User-Agent": `moondesk-npm-install/${version}`,
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`${url} returned HTTP ${response.status}`);
-  }
-
-  return response;
-}
-
-async function downloadBuffer(url) {
-  const response = await fetchRequired(url);
-  return Buffer.from(await response.arrayBuffer());
-}
-
-async function downloadText(url) {
-  const response = await fetchRequired(url);
-  return response.text();
-}
-
-function expectedSha256(checksums, name) {
-  for (const line of checksums.split(/\r?\n/)) {
-    const match = line.trim().match(/^([a-fA-F0-9]{64})\s+\*?(.+)$/);
-    if (match && path.basename(match[2]) === name) {
-      return match[1].toLowerCase();
-    }
-  }
-
-  throw new Error(`SHA256SUMS does not contain ${name}`);
-}
-
-function sha256(buffer) {
-  return crypto.createHash("sha256").update(buffer).digest("hex");
-}
-
-async function main() {
-  const checksums = await downloadText(`${releaseBaseUrl}/SHA256SUMS`);
-  const expected = expectedSha256(checksums, assetName);
-  const binary = await downloadBuffer(`${releaseBaseUrl}/${assetName}`);
-  const actual = sha256(binary);
-
-  if (actual !== expected) {
-    throw new Error(`Checksum mismatch for ${assetName}: expected ${expected}, got ${actual}`);
-  }
-
-  fs.mkdirSync(binDir, { recursive: true });
-  fs.writeFileSync(installedBinary, binary);
-
-  if (platform !== "win32") {
-    fs.chmodSync(installedBinary, 0o755);
-  }
-}
-
-main().catch((error) => {
-  console.error(`MoonDesk install failed: ${error.message}`);
-  process.exit(1);
-});