@outerlayer/cli 0.7.0 → 0.8.1

package/dist/chunk-I2UOAV7X.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/runner/update/version-order.ts
+function parse(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+  if (match === null) return void 0;
+  return { core: [Number(match[1]), Number(match[2]), Number(match[3])], pre: match[4] };
+}
+function comparePre(a, b) {
+  const left = a.split(".");
+  const right = b.split(".");
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const x = left[i];
+    const y = right[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    const xNum = /^\d+$/.test(x);
+    const yNum = /^\d+$/.test(y);
+    if (xNum && yNum) {
+      const difference = Number(x) - Number(y);
+      if (difference !== 0) return Math.sign(difference);
+    } else if (xNum !== yNum) {
+      return xNum ? -1 : 1;
+    } else if (x < y) {
+      return -1;
+    } else if (x > y) {
+      return 1;
+    }
+  }
+  return 0;
+}
+function compareVersions(a, b) {
+  const left = parse(a);
+  const right = parse(b);
+  if (left === void 0 || right === void 0) return void 0;
+  for (let i = 0; i < 3; i++) {
+    const difference = left.core[i] - right.core[i];
+    if (difference !== 0) return Math.sign(difference);
+  }
+  if (left.pre === right.pre) return 0;
+  if (left.pre === void 0) return 1;
+  if (right.pre === void 0) return -1;
+  return comparePre(left.pre, right.pre);
+}
+function compareCores(a, b) {
+  for (let i = 0; i < 3; i++) {
+    const difference = a[i] - b[i];
+    if (difference !== 0) return Math.sign(difference);
+  }
+  return 0;
+}
+function parsePartial(text) {
+  if (text === "" || text === "*" || text === "x" || text === "X") return [];
+  const match = /^v?(\d+|[xX*])(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?$/.exec(text);
+  if (match === null) return void 0;
+  const numbers = [];
+  for (const part of [match[1], match[2], match[3]]) {
+    if (part === void 0 || !/^\d+$/.test(part)) break;
+    numbers.push(Number(part));
+  }
+  return numbers;
+}
+function bumpLast(numbers) {
+  const core = [numbers[0] ?? 0, numbers[1] ?? 0, numbers[2] ?? 0];
+  const last = numbers.length - 1;
+  core[last] = core[last] + 1;
+  for (let i = last + 1; i < 3; i++) core[i] = 0;
+  return core;
+}
+function fill(numbers) {
+  return [numbers[0] ?? 0, numbers[1] ?? 0, numbers[2] ?? 0];
+}
+function meets(version, comparator) {
+  const match = /^(>=|<=|>|<|=|\^|~)?(.*)$/.exec(comparator);
+  const op = match[1] ?? "";
+  const numbers = parsePartial(match[2]);
+  if (numbers === void 0) return void 0;
+  if (numbers.length === 0) return op === "" || op === "=" || op === ">=" || op === "<=" ? true : void 0;
+  const low = fill(numbers);
+  const whole = numbers.length === 3;
+  switch (op) {
+    case ">=":
+      return compareCores(version, low) >= 0;
+    case ">":
+      return whole ? compareCores(version, low) > 0 : compareCores(version, bumpLast(numbers)) >= 0;
+    case "<":
+      return compareCores(version, low) < 0;
+    case "<=":
+      return whole ? compareCores(version, low) <= 0 : compareCores(version, bumpLast(numbers)) < 0;
+    case "~":
+      return compareCores(version, low) >= 0 && compareCores(version, bumpLast(numbers.slice(0, Math.min(numbers.length, 2)))) < 0;
+    case "^": {
+      let pivot = numbers.findIndex((n) => n !== 0);
+      if (pivot === -1) pivot = numbers.length - 1;
+      return compareCores(version, low) >= 0 && compareCores(version, bumpLast(numbers.slice(0, pivot + 1))) < 0;
+    }
+    default:
+      return compareCores(version, low) >= 0 && (whole ? compareCores(version, low) <= 0 : compareCores(version, bumpLast(numbers)) < 0);
+  }
+}
+function satisfiesRange(version, range) {
+  const parsed = parse(version.trim().replace(/^v/, ""));
+  if (parsed === void 0 || parsed.pre !== void 0) return void 0;
+  let anyUnreadable = false;
+  for (const alternative of range.split("||")) {
+    if (/\s-\s/.test(alternative)) {
+      anyUnreadable = true;
+      continue;
+    }
+    const comparators = alternative.trim().replace(/(>=|<=|>|<|=|\^|~)\s+/g, "$1").split(/\s+/).filter((c) => c !== "");
+    if (comparators.length === 0) comparators.push("*");
+    let all = true;
+    for (const comparator of comparators) {
+      const met = meets(parsed.core, comparator);
+      if (met === void 0) {
+        anyUnreadable = true;
+        all = false;
+        break;
+      }
+      if (!met) {
+        all = false;
+        break;
+      }
+    }
+    if (all) return true;
+  }
+  return anyUnreadable ? void 0 : false;
+}
+
+export { compareVersions, satisfiesRange };

package/dist/chunk-I7CJIRMM.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { compareVersions } from './chunk-I2UOAV7X.js';
+import { launcherPath, writeLauncher, LauncherWriteError, pathNotes } from './chunk-PTW6W5NR.js';
+import { currentVersion, currentLink, isInLayout, packageRootIn, versionDir, switchCurrent, execStartLine } from './chunk-TI7B7UEO.js';
+import { RUNNER_DIR_MODE } from './chunk-ZM2IMMYN.js';
+import { realpathSync, readFileSync, mkdirSync, rmSync, cpSync, existsSync } from 'fs';
+import { dirname, sep, join } from 'path';
+
+createRequire(import.meta.url);
+var RunnerInstallError = class extends Error {
+};
+var RunnerDowngradeError = class extends RunnerInstallError {
+};
+function runRunnerInstall(args) {
+  const { configPath, nodePath } = args;
+  let entry;
+  try {
+    entry = realpathSync(args.entryPath);
+  } catch {
+    throw new RunnerInstallError(`cannot read the running CLI at ${args.entryPath}`);
+  }
+  const packageRoot = dirname(dirname(entry));
+  if (!packageRoot.split(sep).includes("node_modules")) {
+    throw new RunnerInstallError(
+      `${packageRoot} is not an installed package: run \`outerlayer runner install\` from a CLI installed with npm, not from a source checkout`
+    );
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(`${packageRoot}/package.json`, "utf8"));
+  } catch {
+    manifest = {};
+  }
+  if (manifest.name !== "@outerlayer/cli") throw new RunnerInstallError(`${packageRoot} is not the @outerlayer/cli package`);
+  const version = manifest.version;
+  if (typeof version !== "string" || version === "") throw new RunnerInstallError(`${packageRoot}/package.json has no version`);
+  const installed = currentVersion(configPath);
+  if (args.allowDowngrade !== true && installed !== void 0 && (compareVersions(version, installed) ?? 0) < 0) {
+    const command = args.command ?? "runner install";
+    throw new RunnerDowngradeError(
+      `this CLI is ${version}, older than ${installed}, the version the runner runs from ${currentLink(configPath)}. Installing it would move the runner back to ${version}. Run \`${launcherPath(args.home)} ${command}\` instead, which runs ${installed}. To install ${version} anyway, run \`outerlayer ${command} --allow-downgrade\``
+    );
+  }
+  if (!isInLayout(configPath, entry) && !sameBuildInstalled(packageRoot, packageRootIn(versionDir(configPath, version)))) {
+    const target = packageRootIn(versionDir(configPath, version));
+    mkdirSync(dirname(target), { recursive: true, mode: RUNNER_DIR_MODE });
+    rmSync(target, { recursive: true, force: true });
+    cpSync(packageRoot, target, { recursive: true });
+    carryHoistedDevcontainerCli(packageRoot, target);
+  }
+  switchCurrent(configPath, version);
+  let written;
+  try {
+    written = writeLauncher({ home: args.home, configPath, nodePath, replace: args.replace });
+  } catch (error) {
+    if (error instanceof LauncherWriteError) throw new RunnerInstallError(error.message);
+    throw error;
+  }
+  return {
+    version,
+    execStart: execStartLine(configPath, nodePath),
+    launcher: {
+      path: launcherPath(args.home),
+      state: written.state,
+      follows: currentLink(configPath),
+      notes: pathNotes({ home: args.home, PATH: args.PATH, state: written.state, launcher: written.path })
+    }
+  };
+}
+function sameBuildInstalled(source, target) {
+  try {
+    const wanted = readFileSync(join(source, "dist", "build-info.json"), "utf8");
+    return wanted !== "" && wanted === readFileSync(join(target, "dist", "build-info.json"), "utf8");
+  } catch {
+    return false;
+  }
+}
+function carryHoistedDevcontainerCli(packageRoot, target) {
+  const dependency = join("@devcontainers", "cli");
+  if (existsSync(join(packageRoot, "node_modules", dependency))) return;
+  const hoisted = join(dirname(dirname(packageRoot)), dependency);
+  if (!existsSync(hoisted)) return;
+  const carried = join(dirname(dirname(target)), dependency);
+  mkdirSync(dirname(carried), { recursive: true, mode: RUNNER_DIR_MODE });
+  cpSync(hoisted, carried, { recursive: true });
+}
+function launcherSummary(launcher) {
+  if (launcher.state === "foreign") return void 0;
+  return `${launcher.state === "unchanged" ? "outerlayer command already at" : "wrote the outerlayer command at"} ${launcher.path}, which runs the CLI that ${launcher.follows} names`;
+}
+
+export { RunnerDowngradeError, RunnerInstallError, launcherSummary, runRunnerInstall };

package/dist/{chunk-SSU747O6.js → chunk-ILEA3YHM.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { sanitizeTerminal } from './chunk-ZYHKJKSU.js';
-import { remoteLookupFailed } from './chunk-D6FXM5OW.js';
+import { remoteLookupFailed } from './chunk-GAYWY4GI.js';
 import { DEFAULT_DASHBOARD } from './chunk-USO2DKBD.js';
 import { resolveGatewayCredentials } from './chunk-BOLTI6LR.js';
 import { readCloudConfig } from './chunk-EABW6AJQ.js';

package/dist/{chunk-OUUINEYB.js → chunk-JKIWMRFH.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { parseSize } from './chunk-F6GFZXZ3.js';
+import { parseSize } from './chunk-7RQ73DLO.js';
 
 createRequire(import.meta.url);
 

package/dist/{chunk-JPR2WHHF.js → chunk-KSLNQOOS.js}

@@ -628,7 +628,7 @@ async function runHookFast(event, home = homeFromEnv(), read = readStdin, env =
       recordHookErrorsSeen(home, hookErrorsBytes);
       if (contextPossiblyGoverned(sessionCwd, home)) {
         try {
-          const { materializeContext: materialize } = await import('./context-materialize-QL33HDJN.js');
+          const { materializeContext: materialize } = await import('./context-materialize-4PMTDS6K.js');
           const sessionId = typeof payload.session_id === "string" ? payload.session_id : "unknown";
           const result = await materialize({ cwd: sessionCwd, sessionId, home });
           materializeMessage = result.message;

package/dist/{chunk-DGAIVMMN.js → chunk-KV47VQJZ.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { autoConnect } from './chunk-PUN7LMNS.js';
+import { autoConnect } from './chunk-4ACZCY4I.js';
 import { detectActiveSession } from './chunk-BFESLKPP.js';
 import { sanitizeTerminal } from './chunk-ZYHKJKSU.js';
-import { resolveRepoIdentity } from './chunk-D6FXM5OW.js';
+import { resolveRepoIdentity } from './chunk-GAYWY4GI.js';
 import { parseTrackerNumber, trackerNumberError } from './chunk-WZBHBH3J.js';
-import { defaultFetch } from './chunk-BCLJSQCV.js';
+import { defaultFetch } from './chunk-YO4PSLVB.js';
 import { resolveGatewayCredentials, unauthorizedMessage } from './chunk-BOLTI6LR.js';
-import { signRunnerRequest } from './chunk-M5POMKKW.js';
+import { signRunnerRequest } from './chunk-V7NIVOFD.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 
 createRequire(import.meta.url);
@@ -347,7 +347,7 @@ async function runWorkLinkSession(opts) {
     return await linkSession(opts);
   } catch (err) {
     if (opts.logFailures) {
-      const { logHookError } = await import('./hook-fast-XBOZ3N6L.js');
+      const { logHookError } = await import('./hook-fast-5H5QBJKT.js');
       const reason = err instanceof Error ? err.message : String(err);
       logHookError(opts.home ?? homeFromEnv(opts.env ?? process.env), new Error(`work link-session #${opts.number} failed: ${reason}`));
     }