moondust 0.0.2 → 0.2.0

package/README.md

@@ -1,27 +1 @@
-<p>
-  <img width="100%" src="https://assets.solidjs.com/banner?type=Moondust&background=tiles&project=%20" alt="Moondust">
-</p>
-
-# Moondust
-
-[![pnpm](https://img.shields.io/badge/maintained%20with-pnpm-cc00ff.svg?style=for-the-badge&logo=pnpm)](https://pnpm.io/)
-
-Moondust is a component library designed with many themes in mind and customizable props.
-
-## Quick start
-
-Install it:
-
-```bash
-npm i moondust
-# or
-yarn add moondust
-# or
-pnpm add moondust
-```
-
-Use it:
-
-```tsx
-import moondust from "moondust";
-```
+Moondust is a local, open-source app for managing multiple repositories and the coding agents you use across them.

package/bin/moondust.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+/**
+ * Interactive version pick, then ensure cached release binary exists and exec.
+ * Releases: https://github.com/zackarysantana/moondust — assets moondust_<semver>_<os>_<arch>.{tar.gz,zip}.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, copyFileSync, unlinkSync, rmSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+
+import { getTargetTriple, assetBasename } from "../lib/platform.js";
+import {
+  getLatestReleaseTag,
+  listRecentReleases,
+  releaseTagExists,
+  getReleaseAssetUrl,
+} from "../lib/github.js";
+import {
+  downloadToFile,
+  extractArchive,
+  findBinaryInDir,
+  tempDownloadPath,
+  ensureExecutable,
+} from "../lib/download.js";
+
+/** GitHub owner/repo for releases (API + assets). */
+const GITHUB_REPO = "zackarysantana/moondust";
+
+function semverFromTag(tag) {
+  return tag.replace(/^v/i, "").trim();
+}
+
+/** User input like "0.1.0" or "v0.1.0" → "v0.1.0" */
+function tagFromUserVersion(raw) {
+  const t = raw.trim();
+  if (!t) return null;
+  return t.startsWith("v") ? t : `v${t}`;
+}
+
+function cacheDir(version) {
+  return path.join(os.homedir(), ".cache", "moondust", version);
+}
+
+function binaryName(ext) {
+  return `moondust${ext}`;
+}
+
+async function ensureBinary(version, triple) {
+  const base = assetBasename(version, triple);
+  const isZip = triple.os === "windows";
+  const archiveName = isZip ? `${base}.zip` : `${base}.tar.gz`;
+  const tag = version.startsWith("v") ? version : `v${version}`;
+  const destDir = cacheDir(version);
+  const cached = path.join(destDir, binaryName(triple.ext));
+
+  if (existsSync(cached)) {
+    return cached;
+  }
+
+  const url = await getReleaseAssetUrl(GITHUB_REPO, tag, archiveName);
+  const tmpArchive = tempDownloadPath("moondust") + (isZip ? ".zip" : ".tar.gz");
+  const extractRoot = tempDownloadPath("moondust-extract");
+
+  try {
+    await downloadToFile(url, tmpArchive);
+    await extractArchive(tmpArchive, extractRoot, isZip);
+    const found = await findBinaryInDir(extractRoot, "moondust", triple.ext);
+    mkdirSync(destDir, { recursive: true });
+    copyFileSync(found, cached);
+    await ensureExecutable(cached);
+  } finally {
+    try {
+      unlinkSync(tmpArchive);
+    } catch {
+      /* ignore */
+    }
+    try {
+      rmSync(extractRoot, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  }
+
+  return cached;
+}
+
+async function chooseVersionInteractive() {
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const line = await rl.question("Use latest version? [Y/n] ");
+    const useLatest = line.trim() === "" || /^y(es)?$/i.test(line.trim());
+
+    if (useLatest) {
+      const tag = await getLatestReleaseTag(GITHUB_REPO);
+      return semverFromTag(tag);
+    }
+
+    const releases = await listRecentReleases(GITHUB_REPO, 5);
+    if (releases.length === 0) {
+      throw new Error(`No releases found for ${GITHUB_REPO}.`);
+    }
+
+    console.log("\nRecent releases:");
+    for (let i = 0; i < releases.length; i++) {
+      const r = releases[i];
+      const title = r.name || r.tag_name;
+      const when = r.published_at
+        ? new Date(r.published_at).toISOString().slice(0, 10)
+        : "";
+      console.log(
+        `  ${i + 1}. ${r.tag_name} — ${title}${when ? ` — ${when}` : ""}`,
+      );
+    }
+    console.log("  … (Older releases may exist on GitHub.)\n");
+
+    for (;;) {
+      const raw = await rl.question(
+        "Enter version to install (e.g. 0.1.0): ",
+      );
+      const tag = tagFromUserVersion(raw);
+      if (!tag) {
+        console.error("Please enter a version.");
+        continue;
+      }
+      const exists = await releaseTagExists(GITHUB_REPO, tag);
+      if (!exists) {
+        console.error(
+          `No release found for ${tag}. Check the tag and try again.`,
+        );
+        continue;
+      }
+      return semverFromTag(tag);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+async function resolveVersion() {
+  if (!stdin.isTTY) {
+    const tag = await getLatestReleaseTag(GITHUB_REPO);
+    return semverFromTag(tag);
+  }
+  return chooseVersionInteractive();
+}
+
+async function main() {
+  const version = await resolveVersion();
+  const triple = getTargetTriple();
+  const binPath = await ensureBinary(version, triple);
+
+  const child = spawn(binPath, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env,
+    windowsHide: false,
+  });
+  child.on("exit", (code, signal) => {
+    if (signal) process.kill(process.pid, signal);
+    else process.exit(code ?? 1);
+  });
+}
+
+main().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});

package/lib/download.js

@@ -0,0 +1,67 @@
+import { createWriteStream } from "node:fs";
+import { mkdir, chmod, stat } from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+import extractZip from "extract-zip";
+import { x as extractTar } from "tar";
+
+export async function downloadToFile(url, destPath) {
+  const res = await fetch(url, {
+    headers: { "User-Agent": "moondust-npm-cli" },
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Download failed ${res.status}: ${text.slice(0, 300)}`);
+  }
+  await mkdir(path.dirname(destPath), { recursive: true });
+  const tmp = `${destPath}.${randomBytes(8).toString("hex")}.part`;
+  await pipeline(res.body, createWriteStream(tmp));
+  const { rename } = await import("node:fs/promises");
+  await rename(tmp, destPath);
+}
+
+export async function extractArchive(archivePath, outDir, isZip) {
+  await mkdir(outDir, { recursive: true });
+  if (isZip) {
+    await extractZip(archivePath, { dir: outDir });
+  } else {
+    await extractTar({ file: archivePath, cwd: outDir });
+  }
+}
+
+export async function findBinaryInDir(dir, baseName, ext) {
+  const expected = `${baseName}${ext}`;
+  const direct = path.join(dir, expected);
+  try {
+    await stat(direct);
+    return direct;
+  } catch {
+    // walk one level
+  }
+  const { readdir } = await import("node:fs/promises");
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      const p = path.join(dir, e.name, expected);
+      try {
+        await stat(p);
+        return p;
+      } catch {
+        /* continue */
+      }
+    }
+  }
+  throw new Error(`Could not find ${expected} inside extracted archive (looked in ${dir})`);
+}
+
+export function tempDownloadPath(prefix) {
+  return path.join(tmpdir(), `${prefix}-${randomBytes(8).toString("hex")}`);
+}
+
+export async function ensureExecutable(filePath) {
+  if (process.platform === "win32") return;
+  const s = await stat(filePath);
+  await chmod(filePath, s.mode | 0o111);
+}

package/lib/github.js

@@ -0,0 +1,82 @@
+const HEADERS = {
+  Accept: "application/vnd.github+json",
+  "X-GitHub-Api-Version": "2022-11-28",
+  "User-Agent": "moondust-npm-cli",
+};
+
+async function githubJson(url) {
+  const res = await fetch(url, { headers: HEADERS });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`GitHub API ${res.status}: ${text.slice(0, 500)}`);
+  }
+  return text ? JSON.parse(text) : null;
+}
+
+/**
+ * Latest non-prerelease release tag, or newest tag if /latest is missing.
+ */
+export async function getLatestReleaseTag(repo) {
+  const latestUrl = `https://api.github.com/repos/${repo}/releases/latest`;
+  const res = await fetch(latestUrl, { headers: HEADERS });
+  if (res.ok) {
+    const data = await res.json();
+    return data.tag_name;
+  }
+  if (res.status === 404) {
+    const arr = await githubJson(
+      `https://api.github.com/repos/${repo}/releases?per_page=1`,
+    );
+    if (!Array.isArray(arr) || arr.length === 0) {
+      throw new Error(`No releases found for ${repo}.`);
+    }
+    return arr[0].tag_name;
+  }
+  const text = await res.text();
+  throw new Error(`GitHub API ${res.status}: ${text.slice(0, 500)}`);
+}
+
+/** Most recent releases (newest first), up to `limit`. */
+export async function listRecentReleases(repo, limit) {
+  const data = await githubJson(
+    `https://api.github.com/repos/${repo}/releases?per_page=${limit}`,
+  );
+  return Array.isArray(data) ? data : [];
+}
+
+/**
+ * True if a release exists for this tag (e.g. v0.1.0).
+ */
+export async function releaseTagExists(repo, tag) {
+  const url = `https://api.github.com/repos/${repo}/releases/tags/${encodeURIComponent(tag)}`;
+  const res = await fetch(url, { headers: HEADERS });
+  return res.ok;
+}
+
+/**
+ * Resolve download URL for a release asset from GitHub's API (public repos).
+ */
+export async function getReleaseAssetUrl(repo, tag, assetName) {
+  const url = `https://api.github.com/repos/${repo}/releases/tags/${encodeURIComponent(tag)}`;
+  const res = await fetch(url, { headers: HEADERS });
+  if (res.status === 404) {
+    throw new Error(
+      `Release ${tag} not found for ${repo}. Publish a GitHub Release with that tag and matching assets.`,
+    );
+  }
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`GitHub API ${res.status}: ${text.slice(0, 500)}`);
+  }
+
+  const data = await res.json();
+  const assets = data.assets ?? [];
+  const match = assets.find((a) => a.name === assetName);
+  if (!match) {
+    const names = assets.map((a) => a.name).join(", ");
+    throw new Error(
+      `No asset named "${assetName}" on ${tag}. Available: ${names || "(none)"}`,
+    );
+  }
+  return match.browser_download_url;
+}

package/lib/platform.js

@@ -0,0 +1,29 @@
+/**
+ * Maps Node's platform/arch to release asset names (see docs in repo root RELEASE_ASSETS.md).
+ */
+export function getTargetTriple() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === "win32") {
+    if (arch === "x64" || arch === "ia32") return { os: "windows", arch: "amd64", ext: ".exe" };
+    if (arch === "arm64") return { os: "windows", arch: "arm64", ext: ".exe" };
+  }
+  if (platform === "darwin") {
+    if (arch === "arm64") return { os: "darwin", arch: "arm64", ext: "" };
+    if (arch === "x64") return { os: "darwin", arch: "amd64", ext: "" };
+  }
+  if (platform === "linux") {
+    if (arch === "x64") return { os: "linux", arch: "amd64", ext: "" };
+    if (arch === "arm64") return { os: "linux", arch: "arm64", ext: "" };
+  }
+
+  throw new Error(
+    `Unsupported platform: ${platform} ${arch}. Build or download a binary for this OS manually.`,
+  );
+}
+
+export function assetBasename(version, triple) {
+  const v = version.replace(/^v/, "");
+  return `moondust_${v}_${triple.os}_${triple.arch}`;
+}

package/package.json

@@ -1,91 +1,33 @@
 {
-    "name": "moondust",
-    "version": "0.0.2",
-    "description": "Moondust is a component library designed with many themes in mind and customizable props.",
-    "license": "MIT",
-    "author": "Zackary Santana",
-    "contributors": [],
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/zackarysantana/moondust.git"
-    },
-    "homepage": "https://github.com/zackarysantana/moondust#readme",
-    "bugs": {
-        "url": "https://github.com/zackarysantana/moondust/issues"
-    },
-    "files": [
-        "dist"
-    ],
-    "private": false,
-    "sideEffects": false,
-    "type": "module",
-    "main": "./dist/index.js",
-    "module": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "browser": {},
-    "exports": {
-        "solid": {
-            "development": "./dist/dev.jsx",
-            "import": "./dist/index.jsx"
-        },
-        "development": {
-            "import": {
-                "types": "./dist/index.d.ts",
-                "default": "./dist/dev.js"
-            }
-        },
-        "import": {
-            "types": "./dist/index.d.ts",
-            "default": "./dist/index.js"
-        }
-    },
-    "typesVersions": {},
-    "scripts": {
-        "dev": "vite serve dev",
-        "build": "tsup",
-        "test": "concurrently pnpm:test:*",
-        "test:client": "vitest",
-        "test:ssr": "pnpm run test:client --mode ssr",
-        "prepublishOnly": "pnpm build",
-        "format": "prettier --ignore-path .gitignore -w \"src/**/*.{js,ts,json,css,tsx,jsx}\" \"dev/**/*.{js,ts,json,css,tsx,jsx}\"",
-        "lint": "concurrently pnpm:lint:*",
-        "lint:code": "eslint --ignore-path .gitignore --max-warnings 0 src/**/*.{js,ts,tsx,jsx}",
-        "lint:types": "tsc --noEmit",
-        "update-deps": "pnpm up -Li"
-    },
-    "peerDependencies": {
-        "solid-js": "^1.6.0"
-    },
-    "devDependencies": {
-        "@types/node": "^20.12.12",
-        "@typescript-eslint/eslint-plugin": "^7.9.0",
-        "@typescript-eslint/parser": "^7.9.0",
-        "class-variance-authority": "^0.7.0",
-        "clsx": "^2.1.1",
-        "concurrently": "^8.2.2",
-        "esbuild": "^0.23.0",
-        "esbuild-plugin-solid": "^0.6.0",
-        "eslint": "^8.56.0",
-        "eslint-plugin-eslint-comments": "^3.2.0",
-        "eslint-plugin-no-only-tests": "^3.1.0",
-        "jsdom": "^24.0.0",
-        "prettier": "^3.3.3",
-        "prettier-plugin-tailwindcss": "^0.6.5",
-        "solid-js": "^1.8.17",
-        "tailwind-merge": "^2.4.0",
-        "tsup": "^8.0.2",
-        "tsup-preset-solid": "^2.2.0",
-        "typescript": "^5.4.5",
-        "vite": "^5.2.11",
-        "vite-plugin-solid": "^2.10.2",
-        "vitest": "^2.0.2"
-    },
-    "keywords": [
-        "solid"
-    ],
-    "packageManager": "pnpm@9.1.1",
-    "engines": {
-        "node": ">=18",
-        "pnpm": ">=9.0.0"
-    }
-}
+  "name": "moondust",
+  "version": "0.2.0",
+  "description": "Download and run the Moondust desktop app from GitHub Releases",
+  "type": "module",
+  "bin": {
+    "moondust": "bin/moondust.js"
+  },
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zackarysantana/moondust.git"
+  },
+  "keywords": [
+    "moondust",
+    "desktop",
+    "launcher"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.10.0"
+  },
+  "dependencies": {
+    "extract-zip": "^2.0.1",
+    "tar": "^7.4.3"
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 {{me}}
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.