@that-company/dat 0.1.30

package/README.md

@@ -0,0 +1,30 @@
+# D.A.T. CLI
+
+Install D.A.T. with npm:
+
+```sh
+npm i -g @that-company/dat
+```
+
+Then sign in:
+
+```sh
+dat login
+```
+
+This npm package is a thin installer. During `postinstall`, it downloads the
+matching prebuilt `dat` binary from GitHub Releases, verifies it against
+`SHA256SUMS`, and exposes it as the `dat` command.
+
+Alternative install:
+
+```sh
+curl -fsSL https://thatcompany.ai/install.sh | sh
+```
+
+## Environment Overrides
+
+- `DAT_RELEASE_REPO`: release repo, default `theSalted/dat-releases`
+- `DAT_INSTALL_BASE`: full release asset base URL
+- `DAT_CHANNEL`: release path under `/releases`, default `download/v<package version>`
+- `DAT_SKIP_INSTALL=1`: skip binary download during npm install

package/bin/dat.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawnSync } = require("node:child_process");
+const { existsSync } = require("node:fs");
+const { join } = require("node:path");
+
+const binary = join(__dirname, "..", "vendor", process.platform === "win32" ? "dat.exe" : "dat");
+
+if (!existsSync(binary)) {
+  console.error("dat binary is missing. Reinstall with: npm rebuild -g @thatcompany/dat");
+  process.exit(1);
+}
+
+const result = spawnSync(binary, process.argv.slice(2), { stdio: "inherit" });
+
+if (result.error) {
+  console.error(`failed to run dat: ${result.error.message}`);
+  process.exit(1);
+}
+
+if (result.signal) {
+  process.kill(process.pid, result.signal);
+}
+
+process.exit(result.status === null ? 1 : result.status);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@that-company/dat",
+  "version": "0.1.30",
+  "description": "Installer for the D.A.T. CLI",
+  "bin": {
+    "dat": "bin/dat.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/that-company/that.git",
+    "directory": "npm/dat"
+  },
+  "homepage": "https://thatcompany.ai",
+  "bugs": {
+    "url": "https://github.com/that-company/that/issues"
+  },
+  "keywords": [
+    "dat",
+    "agent",
+    "training",
+    "machine-learning",
+    "cli"
+  ],
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+"use strict";
+
+const { createHash } = require("node:crypto");
+const { createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, chmodSync } = require("node:fs");
+const { get } = require("node:https");
+const { tmpdir } = require("node:os");
+const { join } = require("node:path");
+const { URL } = require("node:url");
+
+const pkg = require("../package.json");
+
+const REPO = process.env.DAT_RELEASE_REPO || "theSalted/dat-releases";
+const CHANNEL = process.env.DAT_CHANNEL || `download/v${pkg.version}`;
+const RELEASE_BASE = trimTrailingSlash(
+  process.env.DAT_INSTALL_BASE || `https://github.com/${REPO}/releases/${CHANNEL}`,
+);
+const PKG_ROOT = join(__dirname, "..");
+const VENDOR_DIR = join(PKG_ROOT, "vendor");
+const BIN_PATH = join(VENDOR_DIR, process.platform === "win32" ? "dat.exe" : "dat");
+
+main().catch((error) => {
+  console.error(`dat install failed: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});
+
+async function main() {
+  if (process.env.DAT_SKIP_INSTALL === "1") {
+    console.error("DAT_SKIP_INSTALL=1; skipping dat binary download");
+    return;
+  }
+
+  const asset = releaseAssetName(process.platform, process.arch);
+  mkdirSync(VENDOR_DIR, { recursive: true });
+
+  const tempDir = join(tmpdir(), `dat-npm-${process.pid}-${Date.now()}`);
+  mkdirSync(tempDir, { recursive: true });
+  try {
+    const tempBin = join(tempDir, asset);
+    const tempSums = join(tempDir, "SHA256SUMS");
+    const assetUrl = `${RELEASE_BASE}/${asset}`;
+    const sumsUrl = `${RELEASE_BASE}/SHA256SUMS`;
+
+    console.error(`downloading ${asset} from ${RELEASE_BASE}`);
+    await download(assetUrl, tempBin);
+    await download(sumsUrl, tempSums);
+    verifyChecksum(tempBin, tempSums, asset);
+
+    renameSync(tempBin, BIN_PATH);
+    chmodSync(BIN_PATH, 0o755);
+    console.error(`installed dat ${pkg.version} -> ${BIN_PATH}`);
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+function releaseAssetName(platform, arch) {
+  let os;
+  switch (platform) {
+    case "darwin":
+      os = "darwin";
+      break;
+    case "linux":
+      os = "linux";
+      break;
+    default:
+      throw new Error(`unsupported platform ${platform}; dat npm install currently supports macOS and Linux`);
+  }
+
+  let cpu;
+  switch (arch) {
+    case "arm64":
+      cpu = "arm64";
+      break;
+    case "x64":
+      cpu = "x64";
+      break;
+    default:
+      throw new Error(`unsupported architecture ${arch}; dat npm install supports arm64 and x64`);
+  }
+
+  return `dat-${os}-${cpu}`;
+}
+
+function trimTrailingSlash(value) {
+  return value.endsWith("/") ? trimTrailingSlash(value.slice(0, -1)) : value;
+}
+
+function download(url, dest, redirects = 0) {
+  if (redirects > 5) {
+    return Promise.reject(new Error(`too many redirects while downloading ${url}`));
+  }
+
+  return new Promise((resolve, reject) => {
+    const request = get(new URL(url), (response) => {
+      const status = response.statusCode || 0;
+      const location = response.headers.location;
+      if (status >= 300 && status < 400 && location) {
+        response.resume();
+        const next = new URL(location, url).toString();
+        download(next, dest, redirects + 1).then(resolve, reject);
+        return;
+      }
+      if (status !== 200) {
+        response.resume();
+        reject(new Error(`GET ${url} -> HTTP ${status}`));
+        return;
+      }
+      const file = createWriteStream(dest, { mode: 0o600 });
+      response.pipe(file);
+      file.on("finish", () => file.close(resolve));
+      file.on("error", reject);
+    });
+    request.on("error", reject);
+    request.setTimeout(120_000, () => {
+      request.destroy(new Error(`timeout downloading ${url}`));
+    });
+  });
+}
+
+function verifyChecksum(filePath, sumsPath, asset) {
+  if (!existsSync(sumsPath)) {
+    throw new Error("SHA256SUMS was not downloaded");
+  }
+  const line = readFileSync(sumsPath, "utf8")
+    .split(/\r?\n/)
+    .find((entry) => entry.trim().endsWith(`  ${asset}`) || entry.trim().endsWith(` ${asset}`));
+  if (!line) {
+    throw new Error(`SHA256SUMS has no entry for ${asset}`);
+  }
+  const expected = line.trim().split(/\s+/)[0];
+  const actual = createHash("sha256").update(readFileSync(filePath)).digest("hex");
+  if (actual !== expected) {
+    throw new Error(`checksum mismatch for ${asset} (expected ${expected}, got ${actual})`);
+  }
+  console.error("checksum ok");
+}