@agentify/cli 0.1.0

package/lib/metadata.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+function readPackageMetadata(options = {}) {
+  const packageRoot = options.packageRoot || path.resolve(__dirname, "..");
+  const packageJsonPath = path.join(packageRoot, "package.json");
+  const raw = fs.readFileSync(packageJsonPath, "utf8");
+  const parsed = JSON.parse(raw);
+  return {
+    name: String(parsed.name || ""),
+    version: String(parsed.version || "")
+  };
+}
+
+function readCargoMetadata(options = {}) {
+  const packageRoot = options.packageRoot || path.resolve(__dirname, "..");
+  const cargoTomlPath = path.join(packageRoot, "Cargo.toml");
+  const raw = fs.readFileSync(cargoTomlPath, "utf8");
+
+  const packageSection = raw.match(/(?:^|\n)\[package\]\s*([\s\S]*?)(?:\n\[|$)/);
+  if (!packageSection) {
+    throw new Error("Cargo.toml is missing a [package] section");
+  }
+
+  const body = packageSection[1];
+  const nameMatch = body.match(/^\s*name\s*=\s*"([^"]+)"\s*$/m);
+  const versionMatch = body.match(/^\s*version\s*=\s*"([^"]+)"\s*$/m);
+  if (!nameMatch) {
+    throw new Error("Cargo.toml package section is missing name");
+  }
+  if (!versionMatch) {
+    throw new Error("Cargo.toml package section is missing version");
+  }
+
+  return {
+    name: nameMatch[1],
+    version: versionMatch[1]
+  };
+}
+
+function verifyVersionSync(options = {}) {
+  const pkg = readPackageMetadata(options);
+  const cargo = readCargoMetadata(options);
+
+  if (!pkg.version) {
+    throw new Error("package.json version is empty");
+  }
+  if (!cargo.version) {
+    throw new Error("Cargo.toml version is empty");
+  }
+  if (pkg.version !== cargo.version) {
+    throw new Error(
+      `Version mismatch: package.json=${pkg.version} Cargo.toml=${cargo.version}`
+    );
+  }
+
+  return {
+    packageName: pkg.name,
+    cargoName: cargo.name,
+    version: pkg.version
+  };
+}
+
+module.exports = {
+  readCargoMetadata,
+  readPackageMetadata,
+  verifyVersionSync
+};

package/lib/platform.js

@@ -0,0 +1,77 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const SUPPORTED_TARGETS = Object.freeze({
+  "darwin-arm64": { subdir: "darwin-arm64", binaryName: "agentify" },
+  "darwin-x64": { subdir: "darwin-x64", binaryName: "agentify" },
+  "linux-arm64": { subdir: "linux-arm64", binaryName: "agentify" },
+  "linux-x64": { subdir: "linux-x64", binaryName: "agentify" },
+  "win32-arm64": { subdir: "win32-arm64", binaryName: "agentify.exe" },
+  "win32-x64": { subdir: "win32-x64", binaryName: "agentify.exe" }
+});
+
+function platformKey(platform = process.platform, arch = process.arch) {
+  return `${String(platform)}-${String(arch)}`;
+}
+
+function resolveTargetInfo(platform = process.platform, arch = process.arch) {
+  const key = platformKey(platform, arch);
+  const target = SUPPORTED_TARGETS[key];
+  if (!target) {
+    const supported = Object.keys(SUPPORTED_TARGETS).sort().join(", ");
+    throw new Error(
+      `Unsupported platform/arch for @agentify/cli: ${key}. Supported targets: ${supported}`
+    );
+  }
+  return { key, ...target };
+}
+
+function validateExecutablePath(candidate, label) {
+  const trimmed = typeof candidate === "string" ? candidate.trim() : "";
+  if (!trimmed) {
+    throw new Error(`${label} is empty`);
+  }
+  const resolved = path.resolve(trimmed);
+  const stats = fs.statSync(resolved, { throwIfNoEntry: false });
+  if (!stats) {
+    throw new Error(`${label} not found: ${resolved}`);
+  }
+  if (!stats.isFile()) {
+    throw new Error(`${label} is not a file: ${resolved}`);
+  }
+  return resolved;
+}
+
+function resolveBinaryPath(options = {}) {
+  const packageRoot =
+    options.packageRoot || path.resolve(__dirname, "..");
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  const arch = options.arch || process.arch;
+
+  const override = typeof env.AGENTIFY_CLI_BIN === "string" ? env.AGENTIFY_CLI_BIN : "";
+  if (override.trim()) {
+    return validateExecutablePath(override, "AGENTIFY_CLI_BIN");
+  }
+
+  const target = resolveTargetInfo(platform, arch);
+  const candidate = path.join(packageRoot, "bin", target.subdir, target.binaryName);
+  return validateExecutablePath(candidate, `packaged ${target.key} binary`);
+}
+
+function expectedBinaryPath(options = {}) {
+  const packageRoot =
+    options.packageRoot || path.resolve(__dirname, "..");
+  const target = resolveTargetInfo(options.platform, options.arch);
+  return path.join(packageRoot, "bin", target.subdir, target.binaryName);
+}
+
+module.exports = {
+  SUPPORTED_TARGETS,
+  expectedBinaryPath,
+  platformKey,
+  resolveBinaryPath,
+  resolveTargetInfo
+};

package/lib/release.js

@@ -0,0 +1,223 @@
+"use strict";
+
+const childProcess = require("node:child_process");
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const { SUPPORTED_TARGETS, expectedBinaryPath } = require("./platform");
+
+function parseReleaseArgs(argv) {
+  const args = Array.isArray(argv) ? [...argv] : [];
+  const result = {
+    out: "",
+    requireAll: false,
+    help: false
+  };
+
+  while (args.length > 0) {
+    const token = args.shift();
+    if (token === "--help" || token === "-h") {
+      result.help = true;
+      continue;
+    }
+    if (token === "--require-all") {
+      result.requireAll = true;
+      continue;
+    }
+    if (token === "--out") {
+      const value = args.shift();
+      if (!value || value.startsWith("--")) {
+        throw new Error("--out requires a file path");
+      }
+      result.out = value;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${token}`);
+  }
+
+  return result;
+}
+
+function sha256File(filePath) {
+  const hash = crypto.createHash("sha256");
+  const data = fs.readFileSync(filePath);
+  hash.update(data);
+  return hash.digest("hex");
+}
+
+function validateBinLayout(packageRoot) {
+  const binRoot = path.join(packageRoot, "bin");
+  const entries = fs.readdirSync(binRoot, { withFileTypes: true });
+  const supported = new Set(Object.values(SUPPORTED_TARGETS).map((target) => target.subdir));
+
+  for (const entry of entries) {
+    if (entry.name === "agentify.js" && entry.isFile()) {
+      continue;
+    }
+    if (entry.isDirectory() && supported.has(entry.name)) {
+      continue;
+    }
+    throw new Error(
+      `Unexpected entry under bin/: ${entry.name}. Only agentify.js and supported platform directories are allowed`
+    );
+  }
+}
+
+function collectStagedBinaries(options = {}) {
+  const packageRoot = options.packageRoot || path.resolve(__dirname, "..");
+  const requireAll = Boolean(options.requireAll);
+
+  validateBinLayout(packageRoot);
+
+  const staged = [];
+  const missing = [];
+
+  for (const key of Object.keys(SUPPORTED_TARGETS).sort()) {
+    const target = SUPPORTED_TARGETS[key];
+    const binaryPath = expectedBinaryPath({
+      packageRoot,
+      platform: key.split("-")[0],
+      arch: key.slice(key.indexOf("-") + 1)
+    });
+    const stats = fs.statSync(binaryPath, { throwIfNoEntry: false });
+    if (!stats) {
+      missing.push(key);
+      continue;
+    }
+    if (!stats.isFile()) {
+      throw new Error(`Staged binary is not a file for ${key}: ${binaryPath}`);
+    }
+    if (stats.size <= 0) {
+      throw new Error(`Staged binary is empty for ${key}: ${binaryPath}`);
+    }
+    staged.push({
+      target: key,
+      binaryName: target.binaryName,
+      relativePath: path.relative(packageRoot, binaryPath),
+      size: stats.size,
+      sha256: sha256File(binaryPath)
+    });
+  }
+
+  if (requireAll && missing.length > 0) {
+    throw new Error(
+      `Missing staged binaries for required targets: ${missing.join(", ")}`
+    );
+  }
+
+  return { staged, missing };
+}
+
+function buildReleaseManifest(options = {}) {
+  const packageRoot = options.packageRoot || path.resolve(__dirname, "..");
+  const packageJsonPath = path.join(packageRoot, "package.json");
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  const { staged, missing } = collectStagedBinaries({
+    packageRoot,
+    requireAll: options.requireAll
+  });
+
+  return {
+    schemaVersion: "agentify.sh/release-manifest-v0.1",
+    package: {
+      name: String(packageJson.name || ""),
+      version: String(packageJson.version || "")
+    },
+    generatedAt: new Date().toISOString(),
+    stagedTargets: staged,
+    missingTargets: missing
+  };
+}
+
+function parsePackDryRun(stdout) {
+  const parsed = JSON.parse(stdout);
+  if (!Array.isArray(parsed) || parsed.length !== 1 || typeof parsed[0] !== "object" || !parsed[0]) {
+    throw new Error("npm pack --dry-run --json returned an unexpected payload shape");
+  }
+  const pack = parsed[0];
+  if (!Array.isArray(pack.files)) {
+    throw new Error("npm pack --dry-run --json payload is missing files[]");
+  }
+  return pack;
+}
+
+function verifyPackContents(manifest, pack) {
+  const files = new Map(
+    pack.files.map((entry) => [String(entry.path || ""), entry])
+  );
+
+  if (!files.has("bin/agentify.js")) {
+    throw new Error("pack archive is missing bin/agentify.js");
+  }
+
+  for (const target of manifest.stagedTargets || []) {
+    const entry = files.get(target.relativePath);
+    if (!entry) {
+      throw new Error(`pack archive is missing staged binary: ${target.relativePath}`);
+    }
+    if (Number(entry.size) !== Number(target.size)) {
+      throw new Error(
+        `pack archive size mismatch for ${target.relativePath}: expected ${target.size}, got ${entry.size}`
+      );
+    }
+  }
+
+  return {
+    packedFileCount: pack.files.length,
+    verifiedTargets: (manifest.stagedTargets || []).map((target) => target.target)
+  };
+}
+
+function runPackDryRun(options = {}) {
+  const packageRoot = options.packageRoot || path.resolve(__dirname, "..");
+  const stdout = childProcess.execFileSync("npm", ["pack", "--dry-run", "--json"], {
+    cwd: packageRoot,
+    encoding: "utf8"
+  });
+  return parsePackDryRun(stdout);
+}
+
+function writeManifest(manifest, outPath) {
+  const trimmed = typeof outPath === "string" ? outPath.trim() : "";
+  if (!trimmed) {
+    throw new Error("manifest output path is empty");
+  }
+  const resolved = path.resolve(trimmed);
+  const existing = fs.statSync(resolved, { throwIfNoEntry: false });
+  if (existing && existing.isDirectory()) {
+    throw new Error(`manifest output path is a directory: ${resolved}`);
+  }
+  fs.mkdirSync(path.dirname(resolved), { recursive: true });
+  fs.writeFileSync(resolved, `${JSON.stringify(manifest, null, 2)}\n`);
+  return resolved;
+}
+
+function helpText() {
+  return [
+    "Build a local release manifest for staged @agentify/cli binaries.",
+    "",
+    "Usage:",
+    "  node ./scripts/build-release-manifest.js [--out ./release-manifest.json] [--require-all]",
+    "",
+    "Defaults:",
+    "  Prints the manifest JSON to stdout when --out is omitted",
+    "  Allows partial staged target sets unless --require-all is passed",
+    "",
+    "Examples:",
+    "  npm run release:manifest",
+    "  npm run release:manifest -- --out ./release-manifest.json",
+    "  npm run release:manifest -- --require-all"
+  ].join("\n");
+}
+
+module.exports = {
+  buildReleaseManifest,
+  collectStagedBinaries,
+  helpText,
+  parseReleaseArgs,
+  parsePackDryRun,
+  runPackDryRun,
+  verifyPackContents,
+  writeManifest
+};

package/lib/stage.js

@@ -0,0 +1,156 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const { expectedBinaryPath, resolveTargetInfo } = require("./platform");
+
+function defaultSourcePath(options = {}) {
+  const packageRoot = options.packageRoot || path.resolve(__dirname, "..");
+  const platform = options.platform || process.platform;
+  const arch = options.arch || process.arch;
+  const target = resolveTargetInfo(platform, arch);
+  return path.join(packageRoot, "target", "release", target.binaryName);
+}
+
+function parseStageArgs(argv) {
+  const args = Array.isArray(argv) ? [...argv] : [];
+  const result = {
+    source: "",
+    platform: process.platform,
+    arch: process.arch,
+    force: false,
+    help: false
+  };
+
+  while (args.length > 0) {
+    const token = args.shift();
+    if (token === "--help" || token === "-h") {
+      result.help = true;
+      continue;
+    }
+    if (token === "--force") {
+      result.force = true;
+      continue;
+    }
+    if (token === "--source") {
+      const value = args.shift();
+      if (!value || value.startsWith("--")) {
+        throw new Error("--source requires a file path");
+      }
+      result.source = value;
+      continue;
+    }
+    if (token === "--platform") {
+      const value = args.shift();
+      if (!value || value.startsWith("--")) {
+        throw new Error("--platform requires a value");
+      }
+      result.platform = value;
+      continue;
+    }
+    if (token === "--arch") {
+      const value = args.shift();
+      if (!value || value.startsWith("--")) {
+        throw new Error("--arch requires a value");
+      }
+      result.arch = value;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${token}`);
+  }
+
+  return result;
+}
+
+function validateSourcePath(candidate) {
+  const trimmed = typeof candidate === "string" ? candidate.trim() : "";
+  if (!trimmed) {
+    throw new Error("stage source path is empty");
+  }
+  const resolved = path.resolve(trimmed);
+  const stats = fs.statSync(resolved, { throwIfNoEntry: false });
+  if (!stats) {
+    throw new Error(`stage source binary not found: ${resolved}`);
+  }
+  if (!stats.isFile()) {
+    throw new Error(`stage source is not a file: ${resolved}`);
+  }
+  return resolved;
+}
+
+function stageBinary(options = {}) {
+  const packageRoot = options.packageRoot || path.resolve(__dirname, "..");
+  const platform = options.platform || process.platform;
+  const arch = options.arch || process.arch;
+  const target = resolveTargetInfo(platform, arch);
+  const destination = expectedBinaryPath({ packageRoot, platform, arch });
+  const source = validateSourcePath(
+    options.source || defaultSourcePath({ packageRoot, platform, arch })
+  );
+
+  const packageRootResolved = path.resolve(packageRoot);
+  const destinationResolved = path.resolve(destination);
+  const destinationRelative = path.relative(packageRootResolved, destinationResolved);
+  if (
+    !destinationRelative ||
+    destinationRelative.startsWith("..") ||
+    path.isAbsolute(destinationRelative)
+  ) {
+    throw new Error(`refusing to stage binary outside package root: ${destinationResolved}`);
+  }
+
+  const destinationStats = fs.statSync(destinationResolved, { throwIfNoEntry: false });
+  if (destinationStats && destinationStats.isDirectory()) {
+    throw new Error(`stage destination is a directory: ${destinationResolved}`);
+  }
+  if (destinationStats && !options.force) {
+    const sourceReal = fs.realpathSync(source);
+    const destinationReal = fs.realpathSync(destinationResolved);
+    if (sourceReal !== destinationReal) {
+      throw new Error(
+        `staged binary already exists for ${target.key}: ${destinationResolved} (use --force to overwrite)`
+      );
+    }
+  }
+
+  fs.mkdirSync(path.dirname(destinationResolved), { recursive: true });
+  fs.copyFileSync(source, destinationResolved);
+  if (platform !== "win32") {
+    fs.chmodSync(destinationResolved, 0o755);
+  }
+
+  return {
+    target: target.key,
+    source,
+    destination: destinationResolved,
+    overwritten: Boolean(destinationStats),
+    binaryName: target.binaryName
+  };
+}
+
+function helpText() {
+  return [
+    "Stage a built Rust agentify binary into the npm package layout.",
+    "",
+    "Usage:",
+    "  node ./scripts/stage-binary.js [--source /abs/path/to/agentify] [--platform darwin] [--arch arm64] [--force]",
+    "",
+    "Defaults:",
+    "  --source defaults to ./target/release/<binary-name> for the selected platform/arch",
+    "  --platform defaults to the current platform",
+    "  --arch defaults to the current architecture",
+    "",
+    "Examples:",
+    "  npm run stage:bin",
+    "  npm run stage:bin -- --force",
+    "  npm run stage:bin -- --platform linux --arch x64 --source /tmp/agentify"
+  ].join("\n");
+}
+
+module.exports = {
+  defaultSourcePath,
+  helpText,
+  parseStageArgs,
+  stageBinary
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@agentify/cli",
+  "version": "0.1.0",
+  "description": "Agentify CLI for Ask, Replay, workflows, and local agent session tooling",
+  "license": "MIT",
+  "homepage": "https://agentify.sh",
+  "type": "commonjs",
+  "bin": {
+    "agentify": "bin/agentify.js"
+  },
+  "files": [
+    "README.md",
+    "bin/",
+    "lib/",
+    "scripts/",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "check:versions": "node ./scripts/check-version-sync.js",
+    "postinstall": "node ./scripts/postinstall.js",
+    "prepublishOnly": "npm run release:check",
+    "release:check": "node ./scripts/release-check.js",
+    "release:manifest": "node ./scripts/build-release-manifest.js",
+    "stage:bin": "node ./scripts/stage-binary.js",
+    "test:npm": "node --test ./test/npm/*.test.js",
+    "verify:package": "node ./scripts/verify-package.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "agentify",
+    "cli",
+    "agentic",
+    "replay",
+    "workflows"
+  ]
+}

package/scripts/build-release-manifest.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+
+const {
+  buildReleaseManifest,
+  helpText,
+  parseReleaseArgs,
+  writeManifest
+} = require("../lib/release");
+
+function main() {
+  let args;
+  try {
+    args = parseReleaseArgs(process.argv.slice(2));
+  } catch (error) {
+    console.error(error.message);
+    console.error("");
+    console.error(helpText());
+    process.exit(1);
+  }
+
+  if (args.help) {
+    console.log(helpText());
+    return;
+  }
+
+  try {
+    const manifest = buildReleaseManifest({ requireAll: args.requireAll });
+    if (args.out) {
+      const resolved = writeManifest(manifest, args.out);
+      console.log(`Wrote release manifest to ${resolved}`);
+      return;
+    }
+    console.log(JSON.stringify(manifest, null, 2));
+  } catch (error) {
+    console.error(`Failed to build release manifest: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/check-version-sync.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+"use strict";
+
+const { verifyVersionSync } = require("../lib/metadata");
+
+function main() {
+  try {
+    const result = verifyVersionSync();
+    console.log(
+      JSON.stringify(
+        {
+          schemaVersion: "agentify.sh/version-sync-v0.1",
+          ok: true,
+          packageName: result.packageName,
+          cargoName: result.cargoName,
+          version: result.version
+        },
+        null,
+        2
+      )
+    );
+  } catch (error) {
+    console.error(`Version check failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/postinstall.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+"use strict";
+
+const { expectedBinaryPath, resolveBinaryPath, resolveTargetInfo } = require("../lib/platform");
+
+function main() {
+  if (String(process.env.AGENTIFY_SKIP_POSTINSTALL || "").trim().toLowerCase() === "true") {
+    return;
+  }
+
+  try {
+    resolveBinaryPath();
+  } catch (error) {
+    const target = resolveTargetInfo();
+    const expected = expectedBinaryPath();
+    console.warn(
+      [
+        `@agentify/cli postinstall warning: packaged binary not found for ${target.key}.`,
+        `Expected: ${expected}`,
+        `This is normal in local development before release assets are staged.`,
+        `You can set AGENTIFY_CLI_BIN to a local Rust build to use the npm wrapper now.`
+      ].join("\n")
+    );
+  }
+}
+
+main();