@ozyman42/ozy-cli 0.4.9-linux-x64.0 → 0.4.9

package/src/scripts/command-launcher.js.ejs

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  linkSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PLATFORM_MAP = <%- json(platformMap) %>;
+const PLATFORM_PACKAGES = <%- json(platformPackages) %>;
+const PLATFORM_BINARIES = <%- json(platformBinaries) %>;
+const COMMANDS = <%- json(commandNames) %>;
+const BIN_DIR = <%- json(binDir) %>;
+const INSTALL_SCRIPT = <%- json(installScript) %>;
+// Root install.js repairs command targets; bin launchers repair and then execute.
+const IS_INSTALL_SCRIPT = <%- json(isInstallScript) %>;
+const WINDOWS_EXECUTABLE_SUFFIX = <%- json(windowsExecutableSuffix) %>;
+const INSTALLED_JSON = "installed.json";
+
+const require = createRequire(import.meta.url);
+const launcherPath = fileURLToPath(import.meta.url);
+const launcherDir = dirname(launcherPath);
+const packageDir = IS_INSTALL_SCRIPT ? launcherDir : dirname(launcherDir);
+const commandTargetDir = join(packageDir, BIN_DIR);
+const rootInstallScriptPath = join(packageDir, INSTALL_SCRIPT);
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function currentPlatformKey() {
+  const platformKey = PLATFORM_MAP[`${process.platform}-${process.arch}`];
+  if (!platformKey) {
+    fail(`Unsupported platform: ${process.platform}-${process.arch}`);
+  }
+  return platformKey;
+}
+
+function currentPlatformPackageName() {
+  const platformKey = currentPlatformKey();
+  const packageName = PLATFORM_PACKAGES[platformKey];
+  if (!packageName) {
+    fail(`No platform package is configured for ${platformKey}`);
+  }
+  return packageName;
+}
+
+/**
+ * When a Jive library contains any number of CLIs (entrypoints or agents), then the base package
+ * will have an optional dependency for each possible architecture, with those platform-specific
+ * packages containing a platform build of the CLI.
+ * @returns the path to the platform binary and the exact version of the platform package.
+ */
+function currentPlatformPackage() {
+  const platformKey = currentPlatformKey();
+  const binaryFile = PLATFORM_BINARIES[platformKey];
+  if (!binaryFile) {
+    fail(`No platform binary is configured for ${platformKey}`);
+  }
+
+  const packageName = currentPlatformPackageName();
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    const packageDir = dirname(packageJsonPath);
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return {
+      binaryPath: join(packageDir, binaryFile),
+      version: packageJson.version,
+    };
+  } catch (error) {
+    fail(`Could not resolve optional platform package ${packageName}. Reinstall dependencies for ${process.platform}-${process.arch}.`);
+  }
+}
+
+function commandTargetPath(command) {
+  const suffix = process.platform === "win32" ? WINDOWS_EXECUTABLE_SUFFIX : "";
+  return join(commandTargetDir, `${command}${suffix}`);
+}
+
+function installedJsonPath() {
+  return join(commandTargetDir, INSTALLED_JSON);
+}
+
+function windowsTargetsAreCurrent(version) {
+  if (process.platform !== "win32") return false;
+  if (!COMMANDS.every((command) => existsSync(commandTargetPath(command)))) return false;
+
+  try {
+    const installed = JSON.parse(readFileSync(installedJsonPath(), "utf-8"));
+    return installed.version === version;
+  } catch {
+    return false;
+  }
+}
+
+function linkOrCopyFirstExecutable(sourcePath, targetPath) {
+  mkdirSync(dirname(targetPath), { recursive: true });
+  const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp${process.platform === "win32" ? WINDOWS_EXECUTABLE_SUFFIX : ""}`;
+  rmSync(tempPath, { force: true });
+
+  try {
+    try {
+      linkSync(sourcePath, tempPath);
+    } catch {
+      copyFileSync(sourcePath, tempPath);
+    }
+
+    chmodSync(tempPath, 0o755);
+    rmSync(targetPath, { force: true });
+    renameSync(tempPath, targetPath);
+  } finally {
+    rmSync(tempPath, { force: true });
+  }
+}
+
+function hardLinkCommandTarget(sourcePath, targetPath) {
+  if (sourcePath === targetPath) return;
+
+  const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp${process.platform === "win32" ? WINDOWS_EXECUTABLE_SUFFIX : ""}`;
+  rmSync(tempPath, { force: true });
+
+  try {
+    linkSync(sourcePath, tempPath);
+    chmodSync(tempPath, 0o755);
+    rmSync(targetPath, { force: true });
+    renameSync(tempPath, targetPath);
+  } finally {
+    rmSync(tempPath, { force: true });
+  }
+}
+
+function repairCommandTargets() {
+  const platformPackage = currentPlatformPackage();
+
+  if (windowsTargetsAreCurrent(platformPackage.version)) {
+    return;
+  }
+
+  const firstTargetPath = commandTargetPath(COMMANDS[0]);
+  linkOrCopyFirstExecutable(platformPackage.binaryPath, firstTargetPath);
+
+  for (const command of COMMANDS.slice(1)) {
+    hardLinkCommandTarget(firstTargetPath, commandTargetPath(command));
+  }
+
+  if (process.platform === "win32") {
+    writeFileSync(installedJsonPath(), `${JSON.stringify({ version: platformPackage.version }, null, 2)}\n`);
+  }
+}
+
+function runExecutable(executablePath) {
+  const result = spawnSync(executablePath, process.argv.slice(2), { stdio: "inherit" });
+
+  if (result.error) {
+    fail(result.error.message);
+  }
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+
+function removeInstallScript() {
+  try {
+    rmSync(rootInstallScriptPath, { force: true });
+    // TODO: should we also remove the postinstall script line from package.json?
+  } catch {
+    // Cleanup is best-effort; failing to remove install.js should not fail package installation.
+  }
+}
+
+repairCommandTargets();
+removeInstallScript();
+if (!IS_INSTALL_SCRIPT) {
+  const commandName = basename(launcherPath);
+  runExecutable(commandTargetPath(commandName));
+}

package/src/scripts/constants.ts

@@ -0,0 +1,11 @@
+export const BIN_DIR = "bin";
+export const INSTALL_SCRIPT = "install.js";
+export const LICENSE_FILE = "LICENSE";
+export const MULTI_CALL_BINARY = "multi-call-binary";
+export const NPM_PACKAGE_SPEC = "npm@^11.5.1";
+export const OUTDIR = "dist";
+export const PUBLISH_ORDER_FILE = "publish-order.json";
+export const README_FILE = "README.md";
+export const TARBALL_EXTENSION = ".tgz";
+export const WINDOWS_EXECUTABLE_SUFFIX = ".exe";
+export const WORKDIR = "build-temp";

package/src/scripts/kill-existing-agent.ts

@@ -0,0 +1,22 @@
+import path from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+
+const pidFile = path.resolve(import.meta.dir, "../../dist/ozy-signing-agent.pid");
+
+function isProcessRunning(pid: number): boolean {
+  try {
+    // signal 0 sends nothing; it only checks whether the PID exists
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+if (existsSync(pidFile)) {
+  const pid = parseInt(readFileSync(pidFile, "utf-8"));
+  if (isProcessRunning(pid)) {
+    console.log(`Killing agent on PID ${pid}`);
+    process.kill(pid, "SIGTERM");
+  }
+}

package/src/scripts/publish.ts

@@ -0,0 +1,89 @@
+import * as path from "path";
+import * as fs from "fs/promises";
+import { NPM_PACKAGE_SPEC, OUTDIR, PUBLISH_ORDER_FILE, TARBALL_EXTENSION } from "./constants";
+
+// only publish on workflow dispatch on push to default branch (config can change this later)
+const event = process.argv[2];
+if (event !== "push") {
+  console.log("Skipping publish. Only publishing to NPM on push events. Current event is", event);
+  process.exit(0);
+}
+
+const buildFolderName = OUTDIR;
+const expectedFileType = TARBALL_EXTENSION;
+const publishOrderFileName = PUBLISH_ORDER_FILE;
+const distFolder = path.resolve(__dirname, `../../${buildFolderName}`);
+const children = await fs.readdir(distFolder);
+const badChildren = new Set<string>();
+for (const child of children) {
+  if (!child.endsWith(expectedFileType) && child !== publishOrderFileName) {
+    badChildren.add(child);
+  }
+}
+if (badChildren.size > 0) {
+  console.log(`Only expected ${expectedFileType} files or ${publishOrderFileName} in ${buildFolderName} folder. Instead got following:`);
+  for (const child of children) {
+    const isBad = badChildren.has(child);
+    const prefix = isBad ? "::error::" : "";
+    console.log(`${prefix}- ${child}`);
+  }
+  process.exit(1);
+}
+const tarballs = await orderedTarballs(children);
+for (const child of tarballs) {
+  const fullPath = path.resolve(distFolder, child).toLocaleLowerCase();
+  const tarball = `./${buildFolderName}/${child}`;
+  const tag = path.basename(fullPath, expectedFileType);
+  const command = ["bunx", NPM_PACKAGE_SPEC, "publish", tarball, "--tag", tag, "--loglevel", "silly"];
+  console.log(command.join(" "));
+  const exitCode = await Bun.spawn(command, {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env: process.env
+  }).exited;
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+
+async function orderedTarballs(children: string[]): Promise<string[]> {
+  const tarballs = children.filter((child) => child.endsWith(expectedFileType));
+  if (!children.includes(publishOrderFileName)) {
+    return tarballs;
+  }
+
+  const orderPath = path.resolve(distFolder, publishOrderFileName);
+  const parsed = JSON.parse(await fs.readFile(orderPath, "utf-8"));
+  if (!Array.isArray(parsed) || !parsed.every((value) => typeof value === "string")) {
+    console.error(`${publishOrderFileName} must be a JSON array of tarball file names`);
+    process.exit(1);
+  }
+
+  const ordered = parsed as string[];
+  const expected = new Set(tarballs);
+  const seen = new Set<string>();
+  for (const child of ordered) {
+    if (!child.endsWith(expectedFileType)) {
+      console.error(`${publishOrderFileName} includes a non-${expectedFileType} entry: ${child}`);
+      process.exit(1);
+    }
+    if (!expected.has(child)) {
+      console.error(`${publishOrderFileName} includes ${child}, but it is not present in ${buildFolderName}`);
+      process.exit(1);
+    }
+    if (seen.has(child)) {
+      console.error(`${publishOrderFileName} includes ${child} more than once`);
+      process.exit(1);
+    }
+    seen.add(child);
+  }
+
+  const missing = tarballs.filter((child) => !seen.has(child));
+  if (missing.length > 0) {
+    console.error(`${publishOrderFileName} is missing tarballs: ${missing.join(", ")}`);
+    process.exit(1);
+  }
+
+  return ordered;
+}