@aegisagentics/agent 0.1.0

package/npm/lib/release-download.js

@@ -0,0 +1,275 @@
+import { spawnSync } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const DEFAULT_RELEASE_BASE_URL = "https://aegisagentics.com/releases/aegis-agent";
+const MANIFEST_FILE = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "release-manifest.json"
+);
+const PACKAGE_FILE = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+  "package.json"
+);
+const MAX_ARCHIVE_BYTES = 100 * 1024 * 1024;
+
+export function releasePlatformKey({
+  platform = process.platform,
+  arch = process.arch
+} = {}) {
+  const key = `${platform}-${arch}`;
+  switch (key) {
+    case "darwin-arm64":
+    case "darwin-x64":
+    case "linux-arm64":
+    case "linux-x64":
+      return key;
+    default:
+      throw new Error(
+        `Unsupported Aegis Agent platform: ${platform}/${arch}. Supported: darwin-arm64, darwin-x64, linux-arm64, linux-x64.`
+      );
+  }
+}
+
+export async function ensureNativeBinary({
+  binaryPath,
+  fetchImpl = globalThis.fetch,
+  force = process.env.AEGIS_AGENT_FORCE_BINARY_DOWNLOAD === "1",
+  platform = process.platform,
+  arch = process.arch,
+  releaseBaseUrl = process.env.AEGIS_AGENT_RELEASE_BASE_URL ?? DEFAULT_RELEASE_BASE_URL,
+  releaseVersion = process.env.AEGIS_AGENT_RELEASE_VERSION
+} = {}) {
+  if (!binaryPath) {
+    throw new Error("binaryPath is required to install Aegis Agent runtime");
+  }
+  if (!force && (await exists(binaryPath))) {
+    return {
+      binaryPath,
+      downloaded: false
+    };
+  }
+
+  const version = releaseVersion ?? (await packageVersion());
+  const manifest = await loadReleaseManifest({
+    fetchImpl,
+    releaseBaseUrl,
+    version
+  });
+  const platformKey = releasePlatformKey({ platform, arch });
+  const artifact = resolveReleaseArtifact({
+    manifest,
+    platformKey,
+    releaseBaseUrl
+  });
+  await installReleaseArtifact({
+    artifact,
+    binaryPath,
+    fetchImpl
+  });
+  return {
+    artifact,
+    binaryPath,
+    downloaded: true
+  };
+}
+
+export async function loadReleaseManifest({
+  fetchImpl = globalThis.fetch,
+  releaseBaseUrl = DEFAULT_RELEASE_BASE_URL,
+  version
+} = {}) {
+  const bundled = await loadBundledManifest();
+  if (bundled && hasArtifacts(bundled)) {
+    return bundled;
+  }
+  if (!version) {
+    throw new Error("release version is required when bundled manifest has no artifacts");
+  }
+  if (typeof fetchImpl !== "function") {
+    throw new Error("global fetch is unavailable; Node 18 or newer is required");
+  }
+  const manifestUrl = `${trimTrailingSlash(releaseBaseUrl)}/versions/${encodeURIComponent(
+    version
+  )}/manifest.json`;
+  const response = await fetchImpl(manifestUrl, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Aegis Agent release manifest download failed: HTTP ${response.status}`);
+  }
+  return validateManifest(await response.json());
+}
+
+export function resolveReleaseArtifact({
+  manifest,
+  platformKey,
+  releaseBaseUrl = DEFAULT_RELEASE_BASE_URL
+}) {
+  const validManifest = validateManifest(manifest);
+  const artifact = validManifest.artifacts[platformKey];
+  if (!artifact) {
+    throw new Error(
+      `Aegis Agent release ${validManifest.version} does not include ${platformKey}`
+    );
+  }
+  const sha256 = String(artifact.sha256 ?? "").toLowerCase();
+  if (!/^[a-f0-9]{64}$/.test(sha256)) {
+    throw new Error(`Aegis Agent release artifact ${platformKey} has invalid sha256`);
+  }
+
+  const url = artifact.url
+    ? new URL(String(artifact.url))
+    : new URL(String(artifact.path ?? ""), `${trimTrailingSlash(releaseBaseUrl)}/`);
+  assertReleaseUrl(url, releaseBaseUrl);
+
+  const sizeBytes = Number(artifact.sizeBytes ?? 0);
+  if (!Number.isSafeInteger(sizeBytes) || sizeBytes <= 0 || sizeBytes > MAX_ARCHIVE_BYTES) {
+    throw new Error(`Aegis Agent release artifact ${platformKey} has invalid sizeBytes`);
+  }
+
+  return {
+    platformKey,
+    sha256,
+    sizeBytes,
+    url: url.toString()
+  };
+}
+
+export async function installReleaseArtifact({
+  artifact,
+  binaryPath,
+  fetchImpl = globalThis.fetch
+}) {
+  if (typeof fetchImpl !== "function") {
+    throw new Error("global fetch is unavailable; Node 18 or newer is required");
+  }
+  const parentDir = path.dirname(binaryPath);
+  await fs.mkdir(parentDir, { recursive: true });
+  const tempDir = await fs.mkdtemp(path.join(parentDir, ".aegis-agent-download-"));
+  const archivePath = path.join(tempDir, "aegis-agent.tar.gz");
+  try {
+    const response = await fetchImpl(artifact.url);
+    if (!response.ok) {
+      throw new Error(`Aegis Agent binary download failed: HTTP ${response.status}`);
+    }
+    const archive = Buffer.from(await response.arrayBuffer());
+    if (archive.length !== artifact.sizeBytes) {
+      throw new Error(
+        `Aegis Agent binary size mismatch: expected ${artifact.sizeBytes}, got ${archive.length}`
+      );
+    }
+    const actualSha256 = crypto.createHash("sha256").update(archive).digest("hex");
+    if (actualSha256 !== artifact.sha256) {
+      throw new Error(
+        `Aegis Agent binary checksum mismatch: expected ${artifact.sha256}, got ${actualSha256}`
+      );
+    }
+    await fs.writeFile(archivePath, archive, { mode: 0o600 });
+    const extractedBinary = await extractVerifiedArchive({
+      archivePath,
+      tempDir
+    });
+    await fs.chmod(extractedBinary, 0o755);
+    const tempBinary = path.join(parentDir, `.aegis-agent.${process.pid}.tmp`);
+    await fs.copyFile(extractedBinary, tempBinary);
+    await fs.chmod(tempBinary, 0o755);
+    await fs.rename(tempBinary, binaryPath);
+  } finally {
+    await fs.rm(tempDir, { force: true, recursive: true });
+  }
+}
+
+async function extractVerifiedArchive({ archivePath, tempDir }) {
+  const list = spawnSync("tar", ["-tzf", archivePath], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (list.status !== 0) {
+    throw new Error(`Aegis Agent archive listing failed: ${list.stderr.trim()}`);
+  }
+  const entries = list.stdout
+    .split("\n")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  for (const entry of entries) {
+    if (entry.startsWith("/") || entry.split("/").includes("..")) {
+      throw new Error(`Aegis Agent archive contains unsafe path: ${entry}`);
+    }
+  }
+  if (!entries.includes("aegis-agent")) {
+    throw new Error("Aegis Agent archive must contain aegis-agent at archive root");
+  }
+
+  const extract = spawnSync("tar", ["-xzf", archivePath, "-C", tempDir, "aegis-agent"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (extract.status !== 0) {
+    throw new Error(`Aegis Agent archive extraction failed: ${extract.stderr.trim()}`);
+  }
+  return path.join(tempDir, "aegis-agent");
+}
+
+async function loadBundledManifest() {
+  try {
+    return validateManifest(JSON.parse(await fs.readFile(MANIFEST_FILE, "utf8")));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function packageVersion() {
+  const packageJson = JSON.parse(await fs.readFile(PACKAGE_FILE, "utf8"));
+  return packageJson.version;
+}
+
+function validateManifest(manifest) {
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+    throw new Error("Aegis Agent release manifest must be an object");
+  }
+  if (typeof manifest.version !== "string" || manifest.version.trim() === "") {
+    throw new Error("Aegis Agent release manifest requires version");
+  }
+  if (!manifest.artifacts || typeof manifest.artifacts !== "object") {
+    throw new Error("Aegis Agent release manifest requires artifacts");
+  }
+  return manifest;
+}
+
+function hasArtifacts(manifest) {
+  return Object.keys(manifest.artifacts ?? {}).length > 0;
+}
+
+function assertReleaseUrl(url, releaseBaseUrl) {
+  const base = new URL(`${trimTrailingSlash(releaseBaseUrl)}/`);
+  if (url.protocol !== "https:" && base.hostname !== "localhost") {
+    throw new Error("Aegis Agent release artifacts must use HTTPS");
+  }
+  if (url.origin !== base.origin || !url.pathname.startsWith(base.pathname)) {
+    throw new Error(`Aegis Agent release artifact URL is outside the release prefix: ${url}`);
+  }
+}
+
+function trimTrailingSlash(value) {
+  return String(value).replace(/\/+$/, "");
+}
+
+async function exists(file) {
+  try {
+    await fs.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/npm/release-manifest.json

@@ -0,0 +1,23 @@
+{
+  "schemaVersion": "aegis.agent_release_manifest.v1",
+  "version": "0.1.0",
+  "releaseBaseUrl": "https://aegisagentics.com/releases/aegis-agent",
+  "createdAt": "2026-06-22T18:55:17.615Z",
+  "artifacts": {
+    "darwin-arm64": {
+      "path": "versions/0.1.0/darwin-arm64/aegis-agent.tar.gz",
+      "sha256": "c11ceb6011c01e9ea2090494b36bf59d98a51058324e338295f68fcf60664fd0",
+      "sizeBytes": 2155326
+    },
+    "darwin-x64": {
+      "path": "versions/0.1.0/darwin-x64/aegis-agent.tar.gz",
+      "sha256": "0d1e1c8f8584dcbe23b47d12712371daf5faf488b614e8699b22d80a7cd3ef35",
+      "sizeBytes": 2248676
+    },
+    "linux-x64": {
+      "path": "versions/0.1.0/linux-x64/aegis-agent.tar.gz",
+      "sha256": "82dffedef43a7fefeb431739536ae6d3f26bd82f20ea826a528ffcd2cdb69517",
+      "sizeBytes": 2356443
+    }
+  }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@aegisagentics/agent",
+  "version": "0.1.0",
+  "description": "Aegis Agent local installer and hook runtime for Codex, Claude, Cursor, and Goose.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AegisAgentics/aegis-plugin.git"
+  },
+  "homepage": "https://github.com/AegisAgentics/aegis-plugin#readme",
+  "bugs": {
+    "url": "https://github.com/AegisAgentics/aegis-plugin/issues"
+  },
+  "bin": {
+    "aegis-agent": "./npm/install.js",
+    "aegis-agent-install": "./npm/install.js"
+  },
+  "files": [
+    "npm/install.js",
+    "npm/lib",
+    "npm/release-manifest.json",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test npm/test/*.test.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  }
+}