@usearete/a4 0.1.0

package/README.md

@@ -0,0 +1,47 @@
+# Arete CLI
+
+Programmable data feeds for Solana. Arete CLI lets you deploy feeds for any Solana data to our cloud.
+
+## Quick Start
+
+```bash
+npx @usearete/a4 create my-app
+cd my-app
+npm run dev
+```
+
+## Installation
+
+### npm (recommended for JS/TS developers)
+
+```bash
+npm install -g @usearete/a4
+```
+
+### Cargo (for Rust developers)
+
+```bash
+cargo install a4-cli
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `a4 create [name]` | Scaffold a new app from a template |
+| `a4 init` | Initialize a stack project |
+| `a4 up` | Deploy your stack |
+| `a4 status` | Show project overview |
+| `a4 auth login` | Authenticate with Arete |
+
+The npm package `@usearete/a4` and the Cargo crate `a4-cli` both install the same `a4` command.
+
+## Documentation
+
+- [Getting Started](https://docs.arete.run)
+- [CLI Reference](https://docs.arete.run/cli/commands/)
+- [Stack Development](https://docs.arete.run/building-stacks/workflow/)
+
+## License
+
+Apache-2.0

package/bin/a4.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const binName = process.platform === "win32" ? "a4.exe" : "a4";
+const localBinPath = path.join(__dirname, binName);
+
+// Try local binary first, then fall back to PATH
+function getBinaryPath() {
+  // 1. Check for bundled binary (npm postinstall)
+  if (fs.existsSync(localBinPath)) {
+    return localBinPath;
+  }
+
+  // 2. Check system PATH (cargo install, manual install)
+  const whichCmd = process.platform === "win32" ? "where" : "which";
+  const result = spawnSync(whichCmd, ["a4"], { encoding: "utf8" });
+  if (result.status === 0 && result.stdout) {
+    const systemBin = result.stdout.trim().split("\n")[0];
+    if (fs.existsSync(systemBin)) {
+      return systemBin;
+    }
+  }
+
+  return null;
+}
+
+const binPath = getBinaryPath();
+
+if (!binPath) {
+  console.error(
+    "Arete CLI binary not found. This usually means the postinstall script failed.\n" +
+    "Try reinstalling: npm install @usearete/a4\n" +
+    "\n" +
+    "If the problem persists, you can install the CLI via Cargo:\n" +
+    "  cargo install a4-cli"
+  );
+  process.exit(1);
+}
+
+const result = spawnSync(binPath, process.argv.slice(2), {
+  stdio: "inherit",
+  env: process.env,
+});
+
+if (result.error) {
+  if (result.error.code === "EACCES") {
+    console.error(
+      "Permission denied. Try running:\n" +
+      `  chmod +x "${binPath}"`
+    );
+  } else {
+    console.error("Failed to run Arete CLI:", result.error.message);
+  }
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@usearete/a4",
+  "version": "0.1.0",
+  "description": "Arete CLI (a4) - Real-time Solana streaming pipelines",
+  "bin": {
+    "a4": "./bin/a4.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AreteA4/arete.git",
+    "directory": "packages/arete"
+  },
+  "homepage": "https://arete.run",
+  "bugs": {
+    "url": "https://github.com/AreteA4/arete/issues"
+  },
+  "keywords": [
+    "arete",
+    "solana",
+    "streaming",
+    "cli",
+    "blockchain",
+    "web3",
+    "a4"
+  ],
+  "author": "Arete Team",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "README.md"
+  ]
+}

package/scripts/postinstall.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+const pkg = require("../package.json");
+const version = pkg.version;
+
+const PLATFORMS = {
+  "darwin-arm64": "a4-darwin-arm64",
+  "darwin-x64": "a4-darwin-x64",
+  "linux-x64": "a4-linux-x64",
+  "linux-arm64": "a4-linux-arm64",
+  "win32-x64": "a4-win32-x64.exe",
+};
+
+const platform = process.platform;
+const arch = process.arch;
+const key = `${platform}-${arch}`;
+
+const binaryName = PLATFORMS[key];
+if (!binaryName) {
+  console.warn(
+    `Arete CLI does not have a prebuilt binary for ${key}.\n` +
+    "You can build from source: cargo install a4-cli"
+  );
+  process.exit(0);
+}
+
+const binDir = path.join(__dirname, "..", "bin");
+const binPath = path.join(binDir, platform === "win32" ? "a4.exe" : "a4");
+
+if (fs.existsSync(binPath)) {
+  process.exit(0);
+}
+
+const releaseUrl = `https://github.com/AreteA4/arete/releases/download/a4-cli-v${version}`;
+const url = `${releaseUrl}/${binaryName}`;
+const checksumUrl = `${releaseUrl}/checksums.txt`;
+const MAX_REDIRECTS = 5;
+
+console.log(`Downloading Arete CLI v${version} for ${key}...`);
+
+function removeIfExists(filePath) {
+  try {
+    fs.unlinkSync(filePath);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+}
+
+function getResponse(url, depth = 0) {
+  if (depth > MAX_REDIRECTS) {
+    return Promise.reject(new Error("Too many redirects"));
+  }
+
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, (response) => {
+        if (response.statusCode === 302 || response.statusCode === 301) {
+          if (!response.headers.location) {
+            response.resume();
+            reject(new Error("Redirect missing location header"));
+            return;
+          }
+
+          response.resume();
+          resolve(
+            getResponse(
+              new URL(response.headers.location, url).toString(),
+              depth + 1
+            )
+          );
+          return;
+        }
+
+        resolve(response);
+      })
+      .on("error", reject);
+  });
+}
+
+async function download(url, dest) {
+  const response = await getResponse(url);
+
+  if (response.statusCode !== 200) {
+    response.resume();
+    removeIfExists(dest);
+    throw new Error(`Download failed: HTTP ${response.statusCode}`);
+  }
+
+  const total = parseInt(response.headers["content-length"], 10);
+  let downloaded = 0;
+
+  await new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest, { mode: 0o755 });
+
+    response.on("data", (chunk) => {
+      downloaded += chunk.length;
+      if (total && process.stdout.isTTY) {
+        const pct = Math.round((downloaded / total) * 100);
+        process.stdout.write(`\rDownloading... ${pct}%`);
+      }
+    });
+
+    response.on("error", (err) => {
+      file.destroy();
+      removeIfExists(dest);
+      reject(err);
+    });
+
+    file.on("error", (err) => {
+      response.destroy();
+      removeIfExists(dest);
+      reject(err);
+    });
+
+    file.on("finish", () => {
+      file.close(() => {
+        if (process.stdout.isTTY) {
+          process.stdout.write("\n");
+        }
+        resolve();
+      });
+    });
+
+    response.pipe(file);
+  });
+}
+
+async function fetchText(url) {
+  const response = await getResponse(url);
+
+  if (response.statusCode !== 200) {
+    response.resume();
+    throw new Error(`Checksum download failed: HTTP ${response.statusCode}`);
+  }
+
+  return new Promise((resolve, reject) => {
+    let body = "";
+    response.setEncoding("utf8");
+    response.on("data", (chunk) => {
+      body += chunk;
+    });
+    response.on("end", () => resolve(body));
+    response.on("error", reject);
+  });
+}
+
+function sha256File(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+
+async function verifyChecksum(checksumUrl, fileName, filePath) {
+  const checksums = await fetchText(checksumUrl);
+  const expected = checksums
+    .split(/\r?\n/)
+    .map((line) => line.match(/^([a-fA-F0-9]{64})\s+\*?(.+)$/))
+    .find((match) => match && match[2] === fileName);
+
+  if (!expected) {
+    throw new Error(`Missing checksum for ${fileName}`);
+  }
+
+  const actual = await sha256File(filePath);
+  if (actual !== expected[1].toLowerCase()) {
+    throw new Error(`Checksum mismatch for ${fileName}`);
+  }
+}
+
+async function main() {
+  try {
+    if (!fs.existsSync(binDir)) {
+      fs.mkdirSync(binDir, { recursive: true });
+    }
+    
+    await download(url, binPath);
+
+    try {
+      await verifyChecksum(checksumUrl, binaryName, binPath);
+    } catch (err) {
+      removeIfExists(binPath);
+      throw err;
+    }
+
+    if (platform !== "win32") {
+      fs.chmodSync(binPath, 0o755);
+    }
+
+    console.log("Arete CLI installed successfully.");
+  } catch (err) {
+    console.error(`\nFailed to download Arete CLI: ${err.message}`);
+    console.error(
+      "\nYou can install manually via Cargo:\n" +
+      "  cargo install a4-cli\n" +
+      "\nOr download directly from:\n" +
+      `  ${url}`
+    );
+    process.exit(0);
+  }
+}
+
+main();