@colony2/c2j 0.0.41 → 0.0.51

package/README.md

@@ -1,6 +1,6 @@
 # c2j
 
-`c2j` is the local job-oriented CLI for submitting and running recipe jobs through an SWF runtime.
+`c2j` is the local job-oriented CLI for submitting and running recipe jobs through JobDB.
 
 Use it when you want to:
 
@@ -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
@@ -91,7 +99,7 @@ That does all of the following:
 
 - loads the local YAML file
 - embeds that recipe into the submitted job
-- starts an embedded SWF runtime
+- starts an embedded JobDB runtime
 - submits the job
 - immediately executes it
 
@@ -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
 
@@ -333,7 +360,7 @@ Useful flags:
 - `--case <id>` filters suite mode to selected cases
 - `--parallelism <n>` controls local case concurrency
 - `--out-dir <dir>` defaults to `.c2j/test-results/<timestamp>/`
-- passthrough cases use a disposable embedded runtime root automatically; use `--runtime-root` and `--keep-runtime` only for debugging
+- passthrough cases use a disposable embedded runtime automatically
 
 ## Running Jobs
 
@@ -403,21 +430,20 @@ the job becomes runnable or the wait timeout is reached.
 ## Worker Modes
 
 `c2j run loop` runs a long-lived worker for one tenant. It leases available jobs
-from an external SWF runtime and executes up to the configured local concurrency.
+from a remote JobDB runtime and executes up to the configured local concurrency.
 
 Basic usage:
 
 ```bash
-c2j run loop --tenant-id <tenant-id> --swf-url http://localhost:9047 --concurrency 4
+c2j run loop --jobdb http://localhost:9047/<tenant-id> --concurrency 4
 ```
 
 Important behavior:
 
 - `--concurrency <n>` controls how many jobs this process can run at once
-- `--tenant-id` defaults the same way as `submit`, `run`, and `list`
-- `--swf-url` must be an external `http://` or `https://` runtime
+- `--jobdb` must be a remote `http://host/tenant` or `https://host/tenant` URI
 - `--embed` is not available for `run loop`
-- `--swf-url embed:///` is rejected for `run loop`
+- `--jobdb embed:///` is rejected for `run loop`
 - `run loop` is non-interactive; use `run` or an ops surface for jobs that need input
 
 ### Loose scheduling with `ready` and `run any`
@@ -425,7 +451,7 @@ Important behavior:
 `c2j ready` prints the number of currently ready recipe jobs for one tenant:
 
 ```bash
-c2j ready --tenant-id <tenant-id> --swf-url http://localhost:9047
+c2j ready --jobdb http://localhost:9047/<tenant-id>
 ```
 
 `c2j run any` atomically polls for one available item of recipe work, leases it,
@@ -433,23 +459,23 @@ runs it, and exits. If no lease is available, it exits successfully after
 printing `no jobs found`.
 
 ```bash
-c2j run any --tenant-id <tenant-id> --swf-url http://localhost:9047
+c2j run any --jobdb http://localhost:9047/<tenant-id>
 ```
 
 These can be composed by an external scheduler:
 
 ```bash
-count=$(c2j ready --tenant-id <tenant-id> --swf-url http://localhost:9047)
+count=$(c2j ready --jobdb http://localhost:9047/<tenant-id>)
 if [ "$count" -gt 0 ]; then
   for _ in $(seq 1 "$count"); do
-    c2j run any --tenant-id <tenant-id> --swf-url http://localhost:9047 &
+    c2j run any --jobdb http://localhost:9047/<tenant-id> &
   done
   wait
 fi
 ```
 
 `ready` is only a non-mutating snapshot and can become stale under competing
-workers. `run any` uses SWF polling so finding available work and acquiring the
+workers. `run any` uses JobDB polling so finding available work and acquiring the
 lease happen in one runtime operation.
 
 ## Listing Jobs
@@ -490,20 +516,35 @@ 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:
 
 ```bash
---swf-url embed:///
+--jobdb embed:///
 ```
 
-Use it when you want a local self-contained runtime instead of an external SWF server.
+Use it when you want a local self-contained runtime instead of a remote JobDB server.
 
 Behavior:
 
 - starts embedded Postgres and Strata as needed
 - uses a persistent runtime root on disk
+- always uses tenant `0`
 - works well for local recipe authoring and debugging
 
 Defaults:
@@ -511,41 +552,39 @@ Defaults:
 - runtime URL: `embed:///`
 - runtime root: `~/.c2j/embed/default`
 
-You can override the root with:
-
-```bash
-export C2J_EMBED_ROOT=/absolute/path/to/embed-root
-```
-
 Notes:
 
-- `C2J_EMBED_ROOT` must be an absolute path
 - only one `c2j` process can own a given embedded runtime root at a time
-- if you need parallel embedded runtimes, give each process a different `C2J_EMBED_ROOT`
 
-## Runtime and Tenant Defaults
+## JobDB Configuration
 
 `c2j` reads these environment variables:
 
-- `C2J_SWF_URL`
-- `C2J_TENANT_ID`
-- `C2J_EMBED_ROOT`
+- `C2J_JOBDB`
 
-Built-in defaults:
+JobDB URI forms:
 
-- `C2J_SWF_URL`: `http://localhost:9047`
-- `C2J_TENANT_ID`: `0`
+- `https://jobdb.example.com/<tenant-id>`
+- `http://localhost:9047/<tenant-id>`
+- `embed:///`
 
 Examples:
 
 ```bash
-export C2J_SWF_URL=http://localhost:9047
-export C2J_TENANT_ID=123
+export C2J_JOBDB=http://localhost:9047/my-tenant
 ```
 
-When `--embed` is present, it overrides `C2J_SWF_URL` for that command.
-`c2j run loop` is the exception: it does not support `--embed` and rejects
-`C2J_SWF_URL=embed:///`.
+`--jobdb` overrides `C2J_JOBDB` for that command. Project config may also define:
+
+```yaml
+jobdb: https://jobdb.example.com/my-tenant
+```
+
+For local embedded mode in project config:
+
+```yaml
+jobdb: embed:///
+```
 
 ## Common Workflows
 
@@ -568,7 +607,7 @@ c2j run --job-id <job-id> --embed
 ```bash
 c2j submit \
   --recipe-file ./recipes/my-recipe.yaml \
-  --swf-url http://localhost:9047 \
+  --jobdb http://localhost:9047/my-tenant \
   --run
 ```
 

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,82 +1,19 @@
 {
   "name": "@colony2/c2j",
-  "type": "module",
-  "version": "0.0.41",
+  "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.41_Darwin_arm64.tar.gz",
-      "url": "https://github.com/colony-2/c2j-release/releases/download/v0.0.41/c2j_0.0.41_Darwin_arm64.tar.gz",
-      "bins": [
-        "c2j"
-      ],
-      "format": "tar.gz",
-      "checksum": {
-        "algorithm": "sha256",
-        "digest": "13de517cad797c93023be1d7f03d191432fe2a3167fd614e67d0af37f666435b"
-      }
-    },
-    "darwin-x64": {
-      "name": "c2j_0.0.41_Darwin_x86_64.tar.gz",
-      "url": "https://github.com/colony-2/c2j-release/releases/download/v0.0.41/c2j_0.0.41_Darwin_x86_64.tar.gz",
-      "bins": [
-        "c2j"
-      ],
-      "format": "tar.gz",
-      "checksum": {
-        "algorithm": "sha256",
-        "digest": "167d6ef9e7cfd2fb03fa132cecbec52d25fcaa2b5d4fc6a46d767f10e1895362"
-      }
-    },
-    "linux-arm64": {
-      "name": "c2j_0.0.41_Linux_arm64.tar.gz",
-      "url": "https://github.com/colony-2/c2j-release/releases/download/v0.0.41/c2j_0.0.41_Linux_arm64.tar.gz",
-      "bins": [
-        "c2j"
-      ],
-      "format": "tar.gz",
-      "checksum": {
-        "algorithm": "sha256",
-        "digest": "0c9f35b66643466f5d4919e209c8b0b49feca80f87de6b9ea579ed781392dd5a"
-      }
-    },
-    "linux-x64": {
-      "name": "c2j_0.0.41_Linux_x86_64.tar.gz",
-      "url": "https://github.com/colony-2/c2j-release/releases/download/v0.0.41/c2j_0.0.41_Linux_x86_64.tar.gz",
-      "bins": [
-        "c2j"
-      ],
-      "format": "tar.gz",
-      "checksum": {
-        "algorithm": "sha256",
-        "digest": "e87a96e1bdf4c26fdd818b6a40a3b1edcc20ffe1137dec6afda4b88729c92897"
-      }
-    }
+  "author": {
+    "name": "Colony 2",
+    "email": "noreply@colony2.com"
   },
   "keywords": [
     "sandbox",
@@ -86,7 +23,28 @@
     "cli",
     "security"
   ],
+  "bin": {
+    "c2j": "bin/cli.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
   "engines": {
-    "node": "\u003e=14.0.0"
-  }
-}
+    "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));