patchline 1.0.1

package/README.md

@@ -0,0 +1,60 @@
+# Patchline
+
+Streamline OpenCode plugin updates by inspecting config and cache state, pinning versions, and invalidating stale cache entries.
+
+Patchline does not install plugins or run OpenCode. After running Patchline, launch OpenCode to reinstall or refresh plugins.
+
+## Install
+
+### Homebrew
+
+```
+brew install AksharP5/tap/patchline
+```
+
+### From source
+
+```
+go install github.com/AksharP5/Patchline/cmd/patchline@latest
+```
+
+### npm
+
+```
+npm i -g patchline
+```
+
+## Usage
+
+```
+patchline list
+patchline outdated
+patchline sync
+patchline upgrade <plugin> --to 1.2.3
+patchline upgrade <plugin> --major|--minor|--patch
+patchline upgrade --all --minor
+patchline snapshot <plugin>
+patchline rollback <plugin>
+patchline version
+```
+
+## Common flags
+
+- `--project <dir>`: project root to scan for `opencode.json`.
+- `--global-config <file>`: override the global config path.
+- `--cache-dir <dir>`: override the OpenCode plugin cache directory.
+- `--snapshot-dir <dir>`: override where snapshots are stored.
+- `--local-dir <dir>`: add an extra local plugin directory (repeatable).
+- `--offline`: skip npm registry calls.
+
+## Status meanings
+
+- `missing`: declared in config, but no cache entry was found.
+- `mismatch`: cache entry exists but does not match the pinned version.
+- `outdated`: installed version is behind the npm registry latest.
+- `local/unmanaged`: plugin is a local file and not managed by npm.
+
+## Troubleshooting
+
+- If plugins show as `missing`, run OpenCode to install them.
+- If Patchline cannot find your config or cache, pass `--global-config` or `--cache-dir`.

package/bin/patchline

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const { getInstalledBinaryName, resolvePlatform } = require("../lib/installer");
+
+function run() {
+  let goos;
+  try {
+    goos = resolvePlatform(process.platform);
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+
+  const binaryPath = path.join(__dirname, getInstalledBinaryName(goos));
+  if (!fs.existsSync(binaryPath)) {
+    console.error("Patchline binary not found. Reinstall the package to download it.");
+    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 ?? 1);
+}
+
+run();

package/lib/installer.js

@@ -0,0 +1,139 @@
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const platformMap = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+};
+
+const archMap = {
+  x64: "amd64",
+  arm64: "arm64",
+};
+
+function resolvePlatform(platform) {
+  const resolved = platformMap[platform];
+  if (!resolved) {
+    throw new Error(`unsupported platform: ${platform}`);
+  }
+  return resolved;
+}
+
+function resolveArch(arch) {
+  const resolved = archMap[arch];
+  if (!resolved) {
+    throw new Error(`unsupported architecture: ${arch}`);
+  }
+  return resolved;
+}
+
+function getArchiveExtension(goos) {
+  if (goos === "windows") {
+    return "zip";
+  }
+  return "tar.gz";
+}
+
+function getArchiveName(version, goos, goarch) {
+  const ext = getArchiveExtension(goos);
+  return `patchline_${version}_${goos}_${goarch}.${ext}`;
+}
+
+function getDownloadUrl(version, goos, goarch) {
+  const archiveName = getArchiveName(version, goos, goarch);
+  return `https://github.com/AksharP5/Patchline/releases/download/v${version}/${archiveName}`;
+}
+
+function getChecksumsUrl(version) {
+  return `https://github.com/AksharP5/Patchline/releases/download/v${version}/checksums.txt`;
+}
+
+function getBinaryName(goos) {
+  if (goos === "windows") {
+    return "patchline.exe";
+  }
+  return "patchline";
+}
+
+function getInstalledBinaryName(goos) {
+  if (goos === "windows") {
+    return "patchline-bin.exe";
+  }
+  return "patchline-bin";
+}
+
+function getCandidateBinaryPaths(rootDir, version, goos, goarch) {
+  const binaryName = getBinaryName(goos);
+  return [
+    path.join(rootDir, binaryName),
+    path.join(rootDir, `patchline_${version}_${goos}_${goarch}`, binaryName),
+  ];
+}
+
+function parseChecksums(text) {
+  const result = {};
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const parts = trimmed.split(/\s+/);
+    if (parts.length < 2) {
+      continue;
+    }
+    const hash = parts[0];
+    const filename = parts[1].replace(/^\*?\.\//, "").replace(/^\*/, "");
+    result[filename] = hash;
+  }
+  return result;
+}
+
+function calculateSha256(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+
+    stream.on("data", (chunk) => {
+      hash.update(chunk);
+    });
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+
+async function verifyChecksum(checksums, filename, filePath) {
+  const expected = checksums[filename];
+  if (!expected) {
+    throw new Error(`checksum not found for ${filename}`);
+  }
+  const actual = await calculateSha256(filePath);
+  if (actual !== expected) {
+    throw new Error(`checksum mismatch for ${filename}`);
+  }
+}
+
+function shouldSkipDownload(env) {
+  const flag = env.PATCHLINE_SKIP_DOWNLOAD;
+  if (!flag) {
+    return false;
+  }
+  const normalized = flag.toLowerCase();
+  return normalized === "1" || normalized === "true";
+}
+
+module.exports = {
+  resolvePlatform,
+  resolveArch,
+  getArchiveExtension,
+  getArchiveName,
+  getDownloadUrl,
+  getChecksumsUrl,
+  getBinaryName,
+  getInstalledBinaryName,
+  getCandidateBinaryPaths,
+  parseChecksums,
+  verifyChecksum,
+  shouldSkipDownload,
+};

package/lib/npm-version.js

@@ -0,0 +1,32 @@
+const fs = require("node:fs");
+
+const semverPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+
+function normalizeTag(tag) {
+  if (!tag) {
+    throw new Error("version tag is required");
+  }
+  const trimmed = tag.trim();
+  const version = trimmed.startsWith("v") ? trimmed.slice(1) : trimmed;
+  if (!version) {
+    throw new Error("version tag is required");
+  }
+  if (!semverPattern.test(version)) {
+    throw new Error(`invalid semver: ${version}`);
+  }
+  return version;
+}
+
+function updatePackageVersion(packagePath, tag) {
+  const version = normalizeTag(tag);
+  const raw = fs.readFileSync(packagePath, "utf8");
+  const pkg = JSON.parse(raw);
+  pkg.version = version;
+  fs.writeFileSync(packagePath, `${JSON.stringify(pkg, null, 2)}\n`);
+  return version;
+}
+
+module.exports = {
+  normalizeTag,
+  updatePackageVersion,
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "patchline",
+  "version": "1.0.1",
+  "description": "Streamline OpenCode plugin updates.",
+  "license": "UNLICENSED",
+  "bin": {
+    "patchline": "bin/patchline"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js",
+    "test": "node --test test/*.test.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "lib",
+    "README.md",
+    "package.json"
+  ],
+  "dependencies": {
+    "extract-zip": "^2.0.1",
+    "tar": "^6.2.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AksharP5/Patchline.git"
+  },
+  "homepage": "https://github.com/AksharP5/Patchline"
+}

package/scripts/install.js

@@ -0,0 +1,133 @@
+const fs = require("node:fs");
+const fsPromises = require("node:fs/promises");
+const https = require("node:https");
+const os = require("node:os");
+const path = require("node:path");
+const { pipeline } = require("node:stream/promises");
+
+const extractZip = require("extract-zip");
+const tar = require("tar");
+
+const {
+  getArchiveExtension,
+  getArchiveName,
+  getBinaryName,
+  getCandidateBinaryPaths,
+  getChecksumsUrl,
+  getDownloadUrl,
+  getInstalledBinaryName,
+  parseChecksums,
+  resolveArch,
+  resolvePlatform,
+  shouldSkipDownload,
+  verifyChecksum,
+} = require("../lib/installer");
+
+const packageJson = require("../package.json");
+
+function request(url) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        res.resume();
+        resolve(request(res.headers.location));
+        return;
+      }
+
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error(`download failed: ${res.statusCode} ${res.statusMessage}`));
+        return;
+      }
+
+      resolve(res);
+    });
+
+    req.on("error", reject);
+  });
+}
+
+async function downloadFile(url, destination) {
+  const response = await request(url);
+  await pipeline(response, fs.createWriteStream(destination));
+}
+
+async function downloadText(url) {
+  const response = await request(url);
+  const chunks = [];
+  for await (const chunk of response) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+async function extractArchive(archivePath, extractDir, extension) {
+  if (extension === "zip") {
+    await extractZip(archivePath, { dir: extractDir });
+    return;
+  }
+  await tar.x({ file: archivePath, cwd: extractDir });
+}
+
+async function findExistingPath(paths) {
+  for (const candidate of paths) {
+    try {
+      await fsPromises.access(candidate);
+      return candidate;
+    } catch (error) {
+      continue;
+    }
+  }
+  return "";
+}
+
+async function install() {
+  if (shouldSkipDownload(process.env)) {
+    console.log("Skipping Patchline download because PATCHLINE_SKIP_DOWNLOAD is set.");
+    return;
+  }
+
+  const version = packageJson.version;
+  const goos = resolvePlatform(process.platform);
+  const goarch = resolveArch(process.arch);
+  const extension = getArchiveExtension(goos);
+  const archiveName = getArchiveName(version, goos, goarch);
+  const url = getDownloadUrl(version, goos, goarch);
+  const checksumsUrl = getChecksumsUrl(version);
+
+  const tempRoot = await fsPromises.mkdtemp(path.join(os.tmpdir(), "patchline-"));
+  const archivePath = path.join(tempRoot, archiveName);
+  const extractDir = path.join(tempRoot, "extract");
+
+  await fsPromises.mkdir(extractDir, { recursive: true });
+  await downloadFile(url, archivePath);
+
+  const checksumsText = await downloadText(checksumsUrl);
+  const checksums = parseChecksums(checksumsText);
+  await verifyChecksum(checksums, archiveName, archivePath);
+
+  await extractArchive(archivePath, extractDir, extension);
+
+  const binaryName = getBinaryName(goos);
+  const candidates = getCandidateBinaryPaths(extractDir, version, goos, goarch);
+  const extractedBinaryPath = await findExistingPath(candidates);
+
+  if (!extractedBinaryPath) {
+    throw new Error(`binary ${binaryName} not found in archive`);
+  }
+
+  const installedBinaryName = getInstalledBinaryName(goos);
+  const targetPath = path.join(__dirname, "..", "bin", installedBinaryName);
+
+  await fsPromises.mkdir(path.dirname(targetPath), { recursive: true });
+  await fsPromises.copyFile(extractedBinaryPath, targetPath);
+
+  if (goos !== "windows") {
+    await fsPromises.chmod(targetPath, 0o755);
+  }
+}
+
+install().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/scripts/prepare-npm-version.js

@@ -0,0 +1,17 @@
+const path = require("node:path");
+
+const { updatePackageVersion } = require("../lib/npm-version");
+
+const tag = process.env.NPM_VERSION || process.env.GITHUB_REF_NAME;
+if (!tag) {
+  console.error("NPM_VERSION or GITHUB_REF_NAME is required to set the npm version.");
+  process.exit(1);
+}
+
+try {
+  const version = updatePackageVersion(path.join(__dirname, "..", "package.json"), tag);
+  console.log(`Prepared npm package version ${version}.`);
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}