@colony2/c2j 0.0.50 → 0.0.51

package/README.md

@@ -14,6 +14,14 @@ Use it when you want to:
 
 Examples below assume you are running from the repo root.
 
+## JobDB upgrade compatibility
+
+The typed-route JobDB update requires fresh format-3 databases/artifact storage
+and matching server/worker versions; existing jobs are not migrated. Job and
+task types now travel separately, preserving existing task names. Read
+[the upgrade notes](JOBDB_UPGRADE_NOTES.md) before deploying it. No existing data
+is automatically reset.
+
 ## Command Summary
 
 ```bash
@@ -142,15 +150,34 @@ This is mainly useful when you want to target another cell by short name and nee
 
 ### `c2j init`
 
-Writes a commented `.c2j/config.yaml` template.
+Writes a commented `.c2j/config.yaml` template and installs bundled c2j skills for Codex-compatible agents.
 
 ```bash
 c2j init
 c2j init --stdout
 c2j init --force
+c2j init --no-skills
+c2j init --with-op-skills
+```
+
+The generated template can derive values from the Go module in the current repo when `base: go` is appropriate. `--stdout` prints only the config and does not install skills.
+
+Bundled skill install controls:
+
+```bash
+c2j init --skills-scope auto
+c2j init --skills-scope project
+c2j init --skills-scope user
+c2j init --skills-force
 ```
 
-The generated template can derive values from the Go module in the current repo when `base: go` is appropriate.
+`auto` currently installs to the project-local `.agents/skills` directory. `user` installs to `${CODEX_HOME:-$HOME/.codex}/skills`. Install metadata is recorded in `.c2j/skills-lock.yaml`.
+
+You can also install the repo skills directly with the public `skills` tool:
+
+```bash
+npx skills add colony-2/c2j
+```
 
 ## Submitting Jobs
 
@@ -489,6 +516,20 @@ Useful filters:
 - `--page-token`
 - `--all`
 
+Filter by a pending task using a JSON route:
+
+```bash
+c2j list --self --waiting-for '{"jobType":"recipe","taskType":"input:collect_user_input"}' --embed
+```
+
+Repeat `--waiting-for` for multiple routes and `--job-type` for multiple job
+types. These flags accept literal identifiers, not comma-separated lists;
+`--waiting-for JOBTYPE:TASKTYPE` is no longer supported because either type may
+contain colons. Identifiers are case-sensitive and are not trimmed or encoded.
+List JSON exposes `next_route` (`jobType`, optional `taskType`) and `task_wait`
+instead of the old `next_need` and flat `task_wait_*` fields. The human-readable
+`NEXT` column also shows the route as JSON.
+
 ## Embedded Runtime
 
 `--embed` is shorthand for:

package/bin/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const packageRoot = path.resolve(__dirname, "..");
+const packageJson = require(path.join(packageRoot, "package.json"));
+const packageName = packageJson.name.split("/").pop();
+const binaryPath = path.join(packageRoot, "vendor", packageName);
+
+if (!fs.existsSync(binaryPath)) {
+  console.error(
+    `${packageName} binary is missing. Reinstall the package or run npm rebuild ${packageJson.name}.`
+  );
+  process.exit(1);
+}
+
+const result = spawnSync(binaryPath, process.argv.slice(2), {
+  stdio: "inherit",
+});
+
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+
+process.exit(result.status === null ? 1 : result.status);

package/package.json

@@ -1,85 +1,19 @@
 {
   "name": "@colony2/c2j",
-  "type": "module",
-  "version": "0.0.50",
+  "version": "0.0.51",
   "description": "c2j job system",
-  "scripts": {
-    "postinstall": "node install.js",
-    "run": "node run-c2j.js"
-  },
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/colony-2/c2j",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/colony-2/c2j.git"
   },
-  "author": {
-    "email": "noreply@colony2.com",
-    "name": "Colony 2"
-  },
-  "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/colony-2/c2j/issues"
   },
-  "homepage": "https://github.com/colony-2/c2j",
-  "bin": {
-    "c2j": "run-c2j.js"
-  },
-  "dependencies": {
-    "jszip": "3.10.1",
-    "proxy-agent": "8.0.1",
-    "tar": "7.5.15"
-  },
-  "archives": {
-    "darwin-arm64": {
-      "name": "c2j_0.0.50_Darwin_arm64.tar.gz",
-      "url": "https://github.com/colony-2/c2j/releases/download/v0.0.50/c2j_0.0.50_Darwin_arm64.tar.gz",
-      "bins": [
-        "c2j"
-      ],
-      "format": "tar.gz",
-      "checksum": {
-        "algorithm": "sha256",
-        "digest": "b91fdeb7d21a36f2600eaf3ffc1661ce014ab442aecceae26fd4254d402656a1"
-      }
-    },
-    "darwin-x64": {
-      "name": "c2j_0.0.50_Darwin_x86_64.tar.gz",
-      "url": "https://github.com/colony-2/c2j/releases/download/v0.0.50/c2j_0.0.50_Darwin_x86_64.tar.gz",
-      "bins": [
-        "c2j"
-      ],
-      "format": "tar.gz",
-      "checksum": {
-        "algorithm": "sha256",
-        "digest": "ae12ffdda3d24b6b14f55dbd329b488f69c02907bde62589ca0c234deb7080ce"
-      }
-    },
-    "linux-arm64": {
-      "name": "c2j_0.0.50_Linux_arm64.tar.gz",
-      "url": "https://github.com/colony-2/c2j/releases/download/v0.0.50/c2j_0.0.50_Linux_arm64.tar.gz",
-      "bins": [
-        "c2j"
-      ],
-      "format": "tar.gz",
-      "checksum": {
-        "algorithm": "sha256",
-        "digest": "e198f9037bd138270aa92ac8b5caa4509b9f76056273d4191909e810d406ba72"
-      }
-    },
-    "linux-x64": {
-      "name": "c2j_0.0.50_Linux_x86_64.tar.gz",
-      "url": "https://github.com/colony-2/c2j/releases/download/v0.0.50/c2j_0.0.50_Linux_x86_64.tar.gz",
-      "bins": [
-        "c2j"
-      ],
-      "format": "tar.gz",
-      "checksum": {
-        "algorithm": "sha256",
-        "digest": "c8b720b153a9b7354887bfb9dd3f7d26ff615cd29a74dd8385fecda8f79d6e0f"
-      }
-    }
-  },
-  "engines": {
-    "node": "\u003e=14.0.0"
+  "author": {
+    "name": "Colony 2",
+    "email": "noreply@colony2.com"
   },
   "keywords": [
     "sandbox",
@@ -88,5 +22,29 @@
     "agent",
     "cli",
     "security"
+  ],
+  "bin": {
+    "c2j": "bin/cli.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "vendor/",
+    "README.md",
+    "LICENSE"
   ]
-}
+}

package/scripts/postinstall.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execFileSync } = require("child_process");
+const { get } = require("https");
+
+const packageRoot = path.resolve(__dirname, "..");
+const packageJson = require(path.join(packageRoot, "package.json"));
+const packageName = packageJson.name.split("/").pop();
+const version = packageJson.version;
+
+const platforms = {
+  "linux:x64": ["Linux", "x86_64"],
+  "linux:arm64": ["Linux", "arm64"],
+  "darwin:x64": ["Darwin", "x86_64"],
+  "darwin:arm64": ["Darwin", "arm64"],
+};
+
+const platformKey = `${process.platform}:${process.arch}`;
+const target = platforms[platformKey];
+
+if (!target) {
+  throw new Error(`Unsupported platform for ${packageJson.name}: ${platformKey}`);
+}
+
+const repo = repositoryPath(packageJson);
+const tag = `v${version}`;
+const assetName = `${packageName}_${version}_${target[0]}_${target[1]}.tar.gz`;
+const baseUrl = `https://github.com/${repo}/releases/download/${tag}`;
+const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `${packageName}-`));
+const archivePath = path.join(tempDir, assetName);
+const checksumsPath = path.join(tempDir, "checksums.txt");
+const extractDir = path.join(tempDir, "extract");
+const vendorDir = path.join(packageRoot, "vendor");
+const installedBinary = path.join(vendorDir, packageName);
+
+fs.mkdirSync(extractDir);
+fs.mkdirSync(vendorDir, { recursive: true });
+
+downloadWithRetry(`${baseUrl}/${assetName}`, archivePath)
+  .then(() => downloadWithRetry(`${baseUrl}/checksums.txt`, checksumsPath))
+  .then(() => {
+    verifyChecksum(archivePath, checksumsPath, assetName);
+    execFileSync("tar", ["-xzf", archivePath, "-C", extractDir], {
+      stdio: "inherit",
+    });
+
+    const extractedBinary = path.join(extractDir, packageName);
+    if (!fs.existsSync(extractedBinary)) {
+      throw new Error(`Release archive did not contain ${packageName}`);
+    }
+
+    fs.copyFileSync(extractedBinary, installedBinary);
+    fs.chmodSync(installedBinary, 0o755);
+  })
+  .catch((error) => {
+    console.error(error.message || error);
+    process.exitCode = 1;
+  })
+  .finally(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+function repositoryPath(pkg) {
+  const raw =
+    typeof pkg.repository === "string" ? pkg.repository : pkg.repository && pkg.repository.url;
+
+  if (!raw) {
+    throw new Error("package.json repository is required to locate release assets");
+  }
+
+  const match = raw.match(/github\.com[:/]([^/]+\/[^/.]+)(?:\.git)?/);
+  if (!match) {
+    throw new Error(`Unsupported repository URL for release assets: ${raw}`);
+  }
+
+  return match[1];
+}
+
+async function downloadWithRetry(url, destination) {
+  let lastError;
+
+  for (let attempt = 1; attempt <= 5; attempt += 1) {
+    try {
+      await download(url, destination);
+      return;
+    } catch (error) {
+      lastError = error;
+      if (attempt === 5) {
+        break;
+      }
+      await delay(attempt * 1000);
+    }
+  }
+
+  throw lastError;
+}
+
+function download(url, destination) {
+  return new Promise((resolve, reject) => {
+    const request = get(url, (response) => {
+      if (
+        response.statusCode >= 300 &&
+        response.statusCode < 400 &&
+        response.headers.location
+      ) {
+        response.resume();
+        download(response.headers.location, destination).then(resolve, reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`Failed to download ${url}: HTTP ${response.statusCode}`));
+        return;
+      }
+
+      const file = fs.createWriteStream(destination, { mode: 0o600 });
+      response.pipe(file);
+      file.on("finish", () => file.close(resolve));
+      file.on("error", reject);
+    });
+
+    request.on("error", reject);
+  });
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function verifyChecksum(archive, checksums, assetName) {
+  const expected = fs
+    .readFileSync(checksums, "utf8")
+    .split(/\r?\n/)
+    .map((line) => line.trim().split(/\s+/))
+    .find((parts) => parts[1] === assetName);
+
+  if (!expected) {
+    throw new Error(`No checksum found for ${assetName}`);
+  }
+
+  const actual = crypto.createHash("sha256").update(fs.readFileSync(archive)).digest("hex");
+  if (actual !== expected[0]) {
+    throw new Error(`Checksum mismatch for ${assetName}`);
+  }
+}

package/install.js

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-
-// This file was generated by GoReleaser. DO NOT EDIT.
-
-import { install } from "./lib.js";
-install();

package/lib.js

@@ -1,259 +0,0 @@
-// This file was generated by GoReleaser. DO NOT EDIT.
-import fs from "fs";
-import crypto from "crypto";
-import http from "http";
-import https from "https";
-import path from "path";
-import JSZip from "jszip";
-import { x as tarExtract } from "tar";
-import { ProxyAgent } from "proxy-agent";
-import { spawnSync } from "child_process";
-import { fileURLToPath } from "url";
-
-const { archives, name, version } = JSON.parse(
-	fs.readFileSync(new URL("./package.json", import.meta.url), "utf8"),
-);
-
-const agent = new ProxyAgent();
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const getArchive = () => {
-	let target = `${process.platform}-${process.arch}`;
-	const archive = archives[target];
-	if (!archive) {
-		throw new Error(`No archive available for ${target}`);
-	}
-	return archive;
-};
-
-const binDir = path.join(__dirname, "bin");
-
-async function extractTar(tarPath, binaries, dir, wrappedIn) {
-	try {
-		const filesToExtract = wrappedIn
-			? binaries.map((bin) =>
-				path.join(wrappedIn, bin).replace(/\\/g, "/"),
-			)
-			: binaries;
-
-		await tarExtract({
-			file: tarPath,
-			cwd: dir,
-			filter: (path) => filesToExtract.includes(path),
-		});
-
-		// If wrapped, move files from wrapped directory to bin directory
-		if (wrappedIn) {
-			const wrappedDir = path.join(dir, wrappedIn);
-			for (const binary of binaries) {
-				const srcPath = path.join(wrappedDir, binary);
-				const destPath = path.join(dir, binary);
-				if (fs.existsSync(srcPath)) {
-					fs.renameSync(srcPath, destPath);
-				}
-			}
-			// Clean up empty wrapped directory
-			try {
-				fs.rmSync(wrappedDir, { recursive: true, force: true });
-			} catch (err) {
-				// Ignore cleanup errors
-			}
-		}
-
-		console.log(`Successfully extracted ${binaries} to "${dir}"`);
-	} catch (err) {
-		throw new Error(`Extraction failed: ${err.message}`);
-	}
-}
-
-async function extractZip(zipPath, binaries, dir, wrappedIn) {
-	try {
-		const zipData = fs.readFileSync(zipPath);
-		const zip = await JSZip.loadAsync(zipData);
-
-		for (const binary of binaries) {
-			const binaryPath = wrappedIn
-				? path.join(wrappedIn, binary).replace(/\\/g, "/")
-				: binary;
-
-			if (!zip.files[binaryPath]) {
-				throw new Error(
-					`Error: ${binaryPath} does not exist in ${zipPath}`,
-				);
-			}
-
-			const content = await zip.files[binaryPath].async("nodebuffer");
-			if (!fs.existsSync(dir)) {
-				fs.mkdirSync(dir, { recursive: true });
-			}
-			const file = path.join(dir, binary);
-			fs.writeFileSync(file, content);
-			fs.chmodSync(file, "755");
-			console.log(`Successfully extracted "${binary}" to "${dir}"`);
-		}
-	} catch (err) {
-		throw new Error(`Extraction failed: ${err.message}`);
-	}
-}
-
-const run = async (bin) => {
-	await install();
-	if (process.platform === "win32") {
-		bin += ".exe";
-	}
-	const [, , ...args] = process.argv;
-	let result = spawnSync(path.join(binDir, bin), args, {
-		cwd: process.cwd(),
-		stdio: "inherit",
-	});
-	if (result.error) {
-		console.error(result.error);
-	}
-	return result.status;
-};
-
-const install = async () => {
-	try {
-		let archive = getArchive();
-		if (await exists(archive)) {
-			return;
-		}
-		let tmp = fs.mkdtempSync("archive-");
-		let archivePath = path.join(tmp, archive.name);
-		await download(archive.url, archivePath);
-		verify(archivePath, archive.checksum);
-
-		if (!fs.existsSync(binDir)) {
-			fs.mkdirSync(binDir);
-		}
-		switch (archive.format) {
-			case "binary":
-				const bin = path.join(binDir, archive.bins[0]);
-				fs.copyFileSync(archivePath, bin);
-				fs.chmodSync(bin, 0o755);
-				break;
-			case "zip":
-				await extractZip(
-					archivePath,
-					archive.bins,
-					binDir,
-					archive.wrappedIn,
-				);
-				break;
-			case "tar":
-			case "tar.gz":
-			case "tgz":
-				await extractTar(
-					archivePath,
-					archive.bins,
-					binDir,
-					archive.wrappedIn,
-				);
-				break;
-			case "tar.zst":
-			case "tzst":
-			case "tar.xz":
-			case "txz":
-			default:
-				throw new Error(`unsupported format: ${archive.format}`);
-		}
-		console.log(`Installed ${name} ${version} to ${binDir}`);
-	} catch (err) {
-		throw new Error(`Installation failed: ${err.message}`);
-	}
-};
-
-const verify = (filename, checksum) => {
-	if (checksum.algorithm == "" || checksum.digest == "") {
-		console.warn("Warning: No checksum provided for verification");
-		return;
-	}
-	let digest = crypto
-		.createHash(checksum.algorithm)
-		.update(fs.readFileSync(filename))
-		.digest("hex");
-	if (digest != checksum.digest) {
-		throw new Error(
-			`${filename}: ${checksum.algorithm} does not match, expected ${checksum.digest}, got ${digest}`,
-		);
-	}
-};
-
-const download = async (url, filename, maxRedirects = 10) => {
-	try {
-		console.log(`Downloading ${url} to ${filename}...`);
-		const dir = path.dirname(filename);
-		if (!fs.existsSync(dir)) {
-			fs.mkdirSync(dir, { recursive: true });
-		}
-
-		return new Promise((resolve, reject) => {
-			const parsedUrl = new URL(url);
-			const mod = parsedUrl.protocol === "https:" ? https : http;
-
-			const request = mod.get(url, { agent }, (response) => {
-				if (
-					response.statusCode >= 300 &&
-					response.statusCode < 400 &&
-					response.headers.location
-				) {
-					if (maxRedirects <= 0) {
-						reject(new Error("Too many redirects"));
-						return;
-					}
-					download(response.headers.location, filename, maxRedirects - 1)
-						.then(resolve)
-						.catch(reject);
-					return;
-				}
-
-				if (response.statusCode !== 200) {
-					reject(
-						new Error(
-							`HTTP ${response.statusCode}: ${response.statusMessage}`,
-						),
-					);
-					return;
-				}
-
-				const writer = fs.createWriteStream(filename);
-				response.pipe(writer);
-
-				writer.on("finish", () => {
-					console.log(`Download complete: ${filename}`);
-					resolve(dir);
-				});
-
-				writer.on("error", (err) => {
-					console.error(`Error writing file: ${err.message}`);
-					reject(err);
-				});
-			});
-
-			request.on("error", (err) => {
-				reject(new Error(`Request failed: ${err.message}`));
-			});
-
-			request.setTimeout(300000, () => {
-				request.destroy();
-				reject(new Error("Request timed out"));
-			});
-		});
-	} catch (err) {
-		throw new Error(`Download failed: ${err.message}`);
-	}
-};
-
-function exists(archive) {
-	if (!fs.existsSync(binDir)) {
-		return false;
-	}
-	return archive.bins.every((bin) => fs.existsSync(path.join(binDir, bin)));
-}
-
-export {
-	install,
-	run,
-	getArchive,
-	download,
-};

package/run-c2j.js

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-
-// This file was generated by GoReleaser. DO NOT EDIT.
-
-import { run } from "./lib.js";
-run("c2j").then((code) => process.exit(code));