@tetsuo-ai/agenc 0.2.0 → 0.2.1

package/bin/agenc

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from "../src/launcher.mjs";
+
+process.exitCode = await main();

package/generated/.gitkeep

@@ -1 +0,0 @@
-

package/generated/agenc-runtime-manifest.json

@@ -1,24 +1,62 @@
 {
   "manifestVersion": 1,
-  "wrapperVersion": "0.2.0",
-  "keyId": "agenc-v0.2.0",
-  "generatedAt": "2026-04-12T08:17:12.539Z",
-  "releaseChannel": "github-releases",
-  "releaseRepository": "tetsuo-ai/agenc-core",
+  "runtimeVersion": "0.2.0",
+  "releaseRepository": "tetsuo-ai/agenc-releases",
   "releaseTag": "agenc-v0.2.0",
   "artifacts": [
+    {
+      "platform": "darwin",
+      "arch": "arm64",
+      "runtimeVersion": "0.2.0",
+      "url": "https://github.com/tetsuo-ai/agenc-releases/releases/download/agenc-v0.2.0/agenc-runtime-0.2.0-darwin-arm64.tar.gz",
+      "sha256": "ad777d177b249cc1a0655c9c0a88cd41b749859103d08185f2d303364bfcbb5e",
+      "bytes": 81090457,
+      "bins": {
+        "agenc": "node_modules/@tetsuo-ai/runtime/bin/agenc"
+      }
+    },
+    {
+      "platform": "darwin",
+      "arch": "x64",
+      "runtimeVersion": "0.2.0",
+      "url": "https://github.com/tetsuo-ai/agenc-releases/releases/download/agenc-v0.2.0/agenc-runtime-0.2.0-darwin-x64.tar.gz",
+      "sha256": "1f7fc36fd46152265eae8e4d678092fef826fbd784fa2bb2fa89ee0535e09235",
+      "bytes": 81890941,
+      "bins": {
+        "agenc": "node_modules/@tetsuo-ai/runtime/bin/agenc"
+      }
+    },
     {
       "platform": "linux",
+      "arch": "arm64",
+      "runtimeVersion": "0.2.0",
+      "url": "https://github.com/tetsuo-ai/agenc-releases/releases/download/agenc-v0.2.0/agenc-runtime-0.2.0-linux-arm64.tar.gz",
+      "sha256": "2fc204dc5c8ed0484c5be3cb96344069d8db497226e13a164d557882b2f457af",
+      "bytes": 81489030,
+      "bins": {
+        "agenc": "node_modules/@tetsuo-ai/runtime/bin/agenc"
+      }
+    },
+    {
+      "platform": "linux",
+      "arch": "x64",
+      "runtimeVersion": "0.2.0",
+      "url": "https://github.com/tetsuo-ai/agenc-releases/releases/download/agenc-v0.2.0/agenc-runtime-0.2.0-linux-x64.tar.gz",
+      "sha256": "84f9f908f6a51d32b28eec9ac479677b7c73c6812ab79ee4ac80b65d0ca82855",
+      "bytes": 81500626,
+      "bins": {
+        "agenc": "node_modules/@tetsuo-ai/runtime/bin/agenc"
+      }
+    },
+    {
+      "platform": "win",
       "arch": "x64",
-      "nodeRange": ">=18.0.0",
       "runtimeVersion": "0.2.0",
-      "url": "https://github.com/tetsuo-ai/agenc-core/releases/download/agenc-v0.2.0/agenc-runtime-0.2.0-linux-x64.tar.gz",
-      "sha256": "67de5ba2c5bced79893414e226547016325d423dd630a25ff579b8cc6abbb76d",
+      "url": "https://github.com/tetsuo-ai/agenc-releases/releases/download/agenc-v0.2.0/agenc-runtime-0.2.0-win-x64.tar.gz",
+      "sha256": "5b93930e876a73534d9e0b718953bdcc1ae2854e3c8ad53f20b9cbced7bdc539",
+      "bytes": 80859755,
       "bins": {
-        "agenc": "node_modules/@tetsuo-ai/runtime/dist/bin/agenc.js",
-        "agenc-runtime": "node_modules/@tetsuo-ai/runtime/dist/bin/agenc-runtime.js",
-        "daemon": "node_modules/@tetsuo-ai/runtime/dist/bin/daemon.js",
-        "agenc-watch": "node_modules/@tetsuo-ai/runtime/dist/bin/agenc-watch.js"
+        "agenc": "node_modules/@tetsuo-ai/runtime/bin/agenc"
       }
     }
   ]

package/lib/runtime-manager.mjs

@@ -0,0 +1,169 @@
+// Install-side runtime resolver for the published launcher.
+//
+// The npm launcher is tiny; the real runtime is a per-platform tarball on
+// GitHub Releases (see scripts/build-runtime-tarball.mjs). This module:
+//   1. resolves the already-extracted runtime under <agenc-home>/runtime/<ver>/,
+//   2. or, if absent, reads the bundled manifest, downloads the artifact for the
+//      current platform, verifies its sha256, and extracts it there.
+//
+// It is intentionally dependency-free (Node built-ins only) so it can run from
+// `postinstall` before anything else is available.
+
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  createReadStream,
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MANIFEST_PATH = resolve(
+  __dirname,
+  "..",
+  "generated",
+  "agenc-runtime-manifest.json",
+);
+
+export function resolveAgenCHome(env = process.env, userHome = homedir()) {
+  const configured = env.AGENC_HOME?.trim();
+  return configured && configured.length > 0
+    ? configured
+    : join(userHome, ".agenc");
+}
+
+export function platformSlug(platform = process.platform, arch = process.arch) {
+  const os = platform === "win32" ? "win" : platform;
+  return { os, arch };
+}
+
+export function readManifest(manifestPath = MANIFEST_PATH) {
+  if (!existsSync(manifestPath)) {
+    throw new Error(
+      `agenc: runtime manifest missing (${manifestPath}); this launcher build is incomplete`,
+    );
+  }
+  return JSON.parse(readFileSync(manifestPath, "utf8"));
+}
+
+export function selectArtifact(manifest, slug = platformSlug()) {
+  const match = manifest.artifacts?.find(
+    (a) => a.platform === slug.os && a.arch === slug.arch,
+  );
+  if (!match) {
+    const have = (manifest.artifacts ?? [])
+      .map((a) => `${a.platform}-${a.arch}`)
+      .join(", ");
+    throw new Error(
+      `agenc: no runtime build for ${slug.os}-${slug.arch} (available: ${have || "none"})`,
+    );
+  }
+  return match;
+}
+
+// Directory the artifact extracts to, and the runtime bin inside it.
+export function runtimeInstallDir(home, version) {
+  return join(home, "runtime", version);
+}
+export function runtimeBinPath(home, version, artifact) {
+  const rel = artifact?.bins?.agenc ?? "node_modules/@tetsuo-ai/runtime/bin/agenc";
+  return join(runtimeInstallDir(home, version), rel);
+}
+
+function markerPath(installDir) {
+  return join(installDir, ".agenc-runtime-ok");
+}
+
+// A runtime install is "good" only if the success marker exists AND records the
+// expected sha256 — guards against a half-extracted or stale tree.
+export function isInstalled(installDir, expectedSha) {
+  const marker = markerPath(installDir);
+  if (!existsSync(marker)) return false;
+  try {
+    return readFileSync(marker, "utf8").trim() === expectedSha;
+  } catch {
+    return false;
+  }
+}
+
+async function sha256File(file) {
+  const hash = createHash("sha256");
+  await pipeline(createReadStream(file), hash);
+  return hash.digest("hex");
+}
+
+async function download(url, dest, fetchImpl = globalThis.fetch) {
+  // Local file:// support keeps the whole flow testable without a real release.
+  if (url.startsWith("file://")) {
+    await pipeline(createReadStream(fileURLToPath(url)), createWriteStream(dest));
+    return;
+  }
+  const res = await fetchImpl(url, { redirect: "follow" });
+  if (!res.ok) {
+    throw new Error(`agenc: download failed ${res.status} ${res.statusText}: ${url}`);
+  }
+  await pipeline(Readable.fromWeb(res.body), createWriteStream(dest));
+}
+
+function extractTarGz(archive, destDir) {
+  mkdirSync(destDir, { recursive: true });
+  const res = spawnSync("tar", ["-xzf", archive, "-C", destDir], {
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  if (res.status !== 0) {
+    throw new Error(`agenc: tar extraction failed (status ${res.status ?? res.signal})`);
+  }
+}
+
+// Ensure the runtime for `manifest.runtimeVersion` is present; returns the bin
+// path. Idempotent: a verified existing install short-circuits the download.
+export async function ensureRuntime({
+  env = process.env,
+  userHome = homedir(),
+  manifest = readManifest(),
+  slug = platformSlug(),
+  fetchImpl = globalThis.fetch,
+  log = (m) => process.stderr.write(m + "\n"),
+} = {}) {
+  const home = resolveAgenCHome(env, userHome);
+  const version = manifest.runtimeVersion;
+  const artifact = selectArtifact(manifest, slug);
+  const installDir = runtimeInstallDir(home, version);
+
+  if (isInstalled(installDir, artifact.sha256)) {
+    return runtimeBinPath(home, version, artifact);
+  }
+
+  log(`agenc: fetching runtime ${version} (${slug.os}-${slug.arch})...`);
+  const tmp = join(tmpdir(), `agenc-runtime-${version}-${process.pid}.tar.gz`);
+  try {
+    await download(artifact.url, tmp, fetchImpl);
+    const actual = await sha256File(tmp);
+    if (actual !== artifact.sha256) {
+      throw new Error(
+        `agenc: runtime checksum mismatch (expected ${artifact.sha256}, got ${actual})`,
+      );
+    }
+    // Replace any partial/old tree atomically-ish: clean then extract.
+    rmSync(installDir, { recursive: true, force: true });
+    extractTarGz(tmp, installDir);
+    const bin = runtimeBinPath(home, version, artifact);
+    if (!existsSync(bin)) {
+      throw new Error(`agenc: runtime extracted but entry missing: ${bin}`);
+    }
+    writeFileSync(markerPath(installDir), artifact.sha256);
+    log(`agenc: runtime ${version} ready`);
+    return bin;
+  } finally {
+    rmSync(tmp, { force: true });
+  }
+}

package/package.json

@@ -1,40 +1,32 @@
 {
   "name": "@tetsuo-ai/agenc",
-  "version": "0.2.0",
-  "description": "Public CLI and launcher for the AgenC framework",
+  "version": "0.2.1",
+  "description": "Public AgenC CLI launcher package",
+  "license": "MIT",
   "type": "module",
   "bin": {
-    "agenc": "./bin/agenc.js",
-    "agenc-runtime": "./bin/agenc-runtime.js"
+    "agenc": "bin/agenc"
   },
   "files": [
     "bin",
-    "generated",
+    "src",
     "lib",
     "scripts",
-    "README.md"
+    "generated"
   ],
   "scripts": {
-    "postinstall": "node ./scripts/postinstall.js",
-    "test": "node --test tests/*.test.mjs"
+    "postinstall": "node ./scripts/postinstall.mjs",
+    "build:runtime-tarball": "node ./scripts/build-runtime-tarball.mjs",
+    "gen:manifest": "node ./scripts/gen-manifest.mjs",
+    "test": "node --test test/*.test.mjs"
   },
-  "keywords": [
-    "agents",
-    "cli",
-    "runtime",
-    "marketplace"
-  ],
-  "author": "Tetsuo AI",
-  "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/tetsuo-ai/agenc-core",
-    "directory": "packages/agenc"
+  "devDependencies": {
+    "@tetsuo-ai/runtime": "file:../../runtime"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=25.0.0"
   }
 }

package/scripts/build-runtime-tarball.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+// Build a self-contained, per-platform runtime artifact for GitHub Releases.
+//
+// The runtime (@tetsuo-ai/runtime) is NOT published to npm — it ships as a
+// platform-specific tarball because it pulls native deps (better-sqlite3,
+// node-pty) that must be compiled for the host OS/arch. This script produces
+// one such artifact for the CURRENT platform; the release CI matrix runs it on
+// each target runner.
+//
+// Output layout (what the install-side runtime-manager extracts verbatim into
+// ~/.agenc/runtime/<version>/):
+//
+//   node_modules/@tetsuo-ai/runtime/{bin,dist,package.json,README.md}
+//   node_modules/<every production dep, natively built for this platform>/...
+//
+// So the runtime entry after extraction is:
+//   <root>/node_modules/@tetsuo-ai/runtime/bin/agenc
+//
+// Steps: build runtime → `npm pack` it (respects its `files`) → `npm install`
+// that tarball with --omit=dev into a staging dir (resolves the prod dep tree
+// and compiles native modules for THIS platform) → tar the resulting
+// node_modules → emit sha256. Pure npm; no hand-rolled dependency resolution.
+
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdtempSync, readFileSync, rmSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { createReadStream } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const launcherDir = resolve(__dirname, "..");
+const repoRoot = resolve(launcherDir, "..", "..");
+const runtimeDir = join(repoRoot, "runtime");
+
+// On Windows, npm/tar-style launchers are .cmd shims that spawnSync cannot
+// exec directly (ENOENT surfaces as a null status — exactly the CI matrix
+// failure mode). `shell: true` resolves them through cmd.exe; argv here is
+// always static, never user input.
+const IS_WINDOWS = process.platform === "win32";
+
+function run(cmd, args, opts = {}) {
+  const res = spawnSync(cmd, args, {
+    stdio: "inherit",
+    shell: IS_WINDOWS,
+    ...opts,
+  });
+  if (res.status !== 0) {
+    throw new Error(
+      `command failed (${res.status ?? res.signal}): ${cmd} ${args.join(" ")}`,
+    );
+  }
+  return res;
+}
+
+function capture(cmd, args, opts = {}) {
+  const res = spawnSync(cmd, args, {
+    encoding: "utf8",
+    shell: IS_WINDOWS,
+    ...opts,
+  });
+  if (res.status !== 0) {
+    throw new Error(
+      `command failed (${res.status ?? res.signal}): ${cmd} ${args.join(" ")}\n${res.stderr ?? ""}`,
+    );
+  }
+  return res.stdout.trim();
+}
+
+// node platform/arch → the artifact slug used in filenames + the manifest.
+function platformSlug() {
+  const os = process.platform === "win32" ? "win" : process.platform; // linux | darwin | win
+  const arch = process.arch; // x64 | arm64
+  return { os, arch, slug: `${os}-${arch}` };
+}
+
+function sha256(file) {
+  return new Promise((resolveHash, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(file);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolveHash(hash.digest("hex")));
+  });
+}
+
+async function main() {
+  const runtimePkg = JSON.parse(
+    readFileSync(join(runtimeDir, "package.json"), "utf8"),
+  );
+  const version = runtimePkg.version;
+  const { os, arch, slug } = platformSlug();
+
+  const outDir = resolve(
+    process.env.AGENC_RELEASE_OUT_DIR ?? join(launcherDir, "release-artifacts"),
+  );
+  mkdirSync(outDir, { recursive: true });
+
+  const stage = mkdtempSync(join(tmpdir(), "agenc-runtime-build-"));
+  try {
+    // 1. Build the runtime (produces dist/).
+    console.error(`[build] runtime ${version} (${slug})`);
+    run("npm", ["run", "build"], { cwd: runtimeDir });
+
+    // 2. Pack the runtime package into a tgz (honors runtime's `files`).
+    const packed = capture(
+      "npm",
+      ["pack", "--silent", "--pack-destination", stage],
+      { cwd: runtimeDir },
+    )
+      .split("\n")
+      .map((l) => l.trim())
+      .filter(Boolean)
+      .pop();
+    const runtimeTgz = join(stage, packed);
+
+    // 3. Install the packed runtime + its PROD deps into the staging dir,
+    //    compiling native modules for THIS platform.
+    const installRoot = join(stage, "install");
+    mkdirSync(installRoot, { recursive: true });
+    // A bare package.json so npm installs into install/node_modules.
+    // (Written in-process: a `node -e` child with embedded quotes breaks
+    // under the Windows shell resolution above.)
+    writeFileSync(
+      join(installRoot, "package.json"),
+      JSON.stringify({
+        name: "agenc-runtime-bundle",
+        private: true,
+        version: "0.0.0",
+      }),
+    );
+    run(
+      "npm",
+      [
+        "install",
+        runtimeTgz,
+        "--omit=dev",
+        "--no-audit",
+        "--no-fund",
+        "--install-strategy=hoisted",
+      ],
+      { cwd: installRoot },
+    );
+
+    const nodeModules = join(installRoot, "node_modules");
+    const runtimeEntry = join(
+      nodeModules,
+      "@tetsuo-ai",
+      "runtime",
+      "bin",
+      "agenc",
+    );
+    statSync(runtimeEntry); // hard-fail if the layout isn't what we promise
+
+    // 4. Tar node_modules into the release artifact.
+    const artifactName = `agenc-runtime-${version}-${slug}.tar.gz`;
+    const artifactPath = join(outDir, artifactName);
+    // Windows: bash-on-PATH resolves `tar` to GNU tar, which parses drive
+    // letters (D:\...) as remote hosts ("Cannot connect to D:"). The system
+    // bsdtar handles Windows paths natively — use it explicitly.
+    const tarBin =
+      IS_WINDOWS && existsSync("C:\\Windows\\System32\\tar.exe")
+        ? "C:\\Windows\\System32\\tar.exe"
+        : "tar";
+    run(tarBin, ["-czf", artifactPath, "-C", installRoot, "node_modules"]);
+
+    // 5. Hash + report.
+    const digest = await sha256(artifactPath);
+    const size = statSync(artifactPath).size;
+    const meta = {
+      platform: os,
+      arch,
+      runtimeVersion: version,
+      artifact: artifactName,
+      sha256: digest,
+      bytes: size,
+      bins: {
+        agenc: "node_modules/@tetsuo-ai/runtime/bin/agenc",
+      },
+    };
+    // Sidecar meta so gen-manifest.mjs can assemble the manifest by globbing
+    // release-artifacts/ across the CI matrix's downloaded artifacts.
+    writeFileSync(
+      join(outDir, `${artifactName}.meta.json`),
+      JSON.stringify(meta, null, 2),
+    );
+    // Machine-readable line for CI; human summary on stderr.
+    process.stdout.write(JSON.stringify(meta) + "\n");
+    console.error(
+      `[build] wrote ${artifactPath} (${(size / 1e6).toFixed(1)} MB)\n[build] sha256 ${digest}`,
+    );
+  } finally {
+    rmSync(stage, { recursive: true, force: true });
+  }
+}
+
+main().catch((err) => {
+  console.error(`[build] FAILED: ${err?.stack ?? err}`);
+  process.exitCode = 1;
+});

package/scripts/gen-manifest.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// Assemble generated/agenc-runtime-manifest.json from the per-platform sidecar
+// meta files (release-artifacts/*.meta.json) produced by build-runtime-tarball.
+//
+// In CI the matrix builds each platform on its own runner, uploads the tarball +
+// .meta.json as workflow artifacts; this step runs after they're all collected,
+// then the manifest is committed into the npm launcher before publish.
+//
+// Usage:
+//   node scripts/gen-manifest.mjs --repo tetsuo-ai/agenc-releases --tag agenc-v0.2.0
+//   [--artifacts <dir>]   (default: packages/agenc/release-artifacts)
+//   [--base-url <url>]    (override; default: GitHub Releases download URL)
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const launcherDir = resolve(__dirname, "..");
+
+function arg(name, fallback) {
+  const i = process.argv.indexOf(`--${name}`);
+  return i !== -1 && i + 1 < process.argv.length ? process.argv[i + 1] : fallback;
+}
+
+const repo = arg("repo", "tetsuo-ai/agenc-releases");
+const tag = arg("tag");
+const artifactsDir = resolve(
+  arg("artifacts", join(launcherDir, "release-artifacts")),
+);
+const baseUrl =
+  arg("base-url") ??
+  (tag ? `https://github.com/${repo}/releases/download/${tag}` : undefined);
+
+if (!tag) {
+  console.error("gen-manifest: --tag is required (e.g. agenc-v0.2.0)");
+  process.exit(1);
+}
+if (!existsSync(artifactsDir)) {
+  console.error(`gen-manifest: artifacts dir not found: ${artifactsDir}`);
+  process.exit(1);
+}
+
+const metas = readdirSync(artifactsDir)
+  .filter((f) => f.endsWith(".meta.json"))
+  .map((f) => JSON.parse(readFileSync(join(artifactsDir, f), "utf8")));
+
+if (metas.length === 0) {
+  console.error(`gen-manifest: no *.meta.json in ${artifactsDir}`);
+  process.exit(1);
+}
+
+const versions = [...new Set(metas.map((m) => m.runtimeVersion))];
+if (versions.length !== 1) {
+  console.error(`gen-manifest: mixed runtime versions: ${versions.join(", ")}`);
+  process.exit(1);
+}
+
+const manifest = {
+  manifestVersion: 1,
+  runtimeVersion: versions[0],
+  releaseRepository: repo,
+  releaseTag: tag,
+  artifacts: metas
+    .map((m) => ({
+      platform: m.platform,
+      arch: m.arch,
+      runtimeVersion: m.runtimeVersion,
+      url: `${baseUrl}/${m.artifact}`,
+      sha256: m.sha256,
+      bytes: m.bytes,
+      bins: m.bins,
+    }))
+    .sort((a, b) => `${a.platform}-${a.arch}`.localeCompare(`${b.platform}-${b.arch}`)),
+};
+
+const outDir = join(launcherDir, "generated");
+mkdirSync(outDir, { recursive: true });
+const outPath = join(outDir, "agenc-runtime-manifest.json");
+writeFileSync(outPath, JSON.stringify(manifest, null, 2) + "\n");
+console.error(
+  `gen-manifest: wrote ${outPath} (${manifest.artifacts.length} platform(s): ${manifest.artifacts
+    .map((a) => `${a.platform}-${a.arch}`)
+    .join(", ")})`,
+);

package/scripts/postinstall.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// Runs on `npm install @tetsuo-ai/agenc`. Pre-fetches the platform runtime so
+// the first `agenc` invocation is fast. Best-effort: a failure here (offline
+// install, CI, etc.) is NOT fatal — the launcher fetches lazily on first run.
+
+// Skip in obviously non-interactive / packaging contexts.
+if (process.env.AGENC_SKIP_POSTINSTALL === "1" || process.env.CI === "true") {
+  process.exit(0);
+}
+
+try {
+  const { ensureRuntime } = await import("../lib/runtime-manager.mjs");
+  await ensureRuntime();
+} catch (err) {
+  process.stderr.write(
+    `agenc: runtime pre-fetch skipped (${err?.message ?? err}); it will be fetched on first run.\n`,
+  );
+  // Non-fatal by design.
+}