oh-my-space 0.9.0 → 0.9.1

package/README.md

@@ -72,6 +72,7 @@ oms checkout <alias> <branch>     # fetch origin, then check out a remote branch
 oms push <alias>...               # push the branch (lazy remote) + stage the pointer
 oms push <alias> --remote upstream  # target a specific remote (repeatable; defaults to origin)
 oms unsync <alias>...             # deinitialize and remove a submodule
+oms update --check                # check whether a newer oms CLI is available
 ```
 
 For `oms switch` and `oms checkout`, omitting the alias and/or branch prompts you to pick one interactively (synced submodules, and local or `origin/*` branches respectively).
@@ -113,6 +114,29 @@ oms/
 | `oms pull ...` | workspace root | `git pull --ff-only <remote>` on each submodule's current branch, then stages the moved pointer. | Requires the submodule to be on a branch. `--remote <name>` selects a single remote (defaults to `origin`). |
 | `oms push <alias>...` | workspace root | `git push <remote> <branch>` (creating the remote branch on first push), then stages the moved pointer. | `--remote <name>` (repeatable) picks the remote(s), defaults to `origin`; upstream is set only for `origin`. `--commit` also commits the pointer update in the parent. |
 | `oms unsync <alias>` / `--all` | workspace root | `git submodule deinit` + `git rm` for the alias; drops an empty `.gitmodules`. | Keeps the `oms.yaml` entry. Use `--force` to discard uncommitted changes. |
+| `oms update` | anywhere | Checks the npm registry and safely updates the installed `oms` CLI only when it detects a confident global install. | Use `--check` for a non-mutating check. Use `--yes` to skip the confirmation prompt for confident global updates. Project-local, temporary runner, development, and unknown installs print guidance only. |
+
+## Updating the CLI
+
+Check whether the installed CLI is current:
+
+```bash
+oms update --check
+```
+
+Run an update when `oms` can confidently identify a global npm, pnpm, Yarn classic, or Bun installation:
+
+```bash
+oms update
+```
+
+For automation, `--yes` skips the confirmation prompt after `oms` has printed the detected context and selected command:
+
+```bash
+oms update --yes
+```
+
+`oms update` does not edit project manifests or temporary runner caches. If the install is project-local, temporary, development, or unknown, it prints safe manual guidance instead of mutating the environment.
 
 ## `oms.yaml` format
 

package/dist/build-info.json

@@ -1 +1 @@
-{"commit":"b2c2b0bb4e51a35fc36da6d65f40229c896f1d70"}
+{"commit":"3c598f24e0cfc453bc81728553b0c40fb1b34591"}

package/dist/oms.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync, readdirSync, rmSync, rmdirSync, writeFileSync, } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, rmdirSync, writeFileSync, } from "node:fs";
+import { delimiter, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 import { cancel, isCancel, log, multiselect, select, text } from "@clack/prompts";
+import semver from "semver";
 import { parse as parseYaml } from "yaml";
 const ALIAS_PATTERN = /^[a-z0-9][a-z0-9_@-]*$/;
 const REMOTE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
@@ -23,9 +24,364 @@ const REMOTES_MIGRATION_DOC = "docs/migrations/0.6.x-to-0.7.0.md";
 const DOCS_REPO_BLOB_BASE = "https://github.com/divlook/oh-my-space/blob";
 const MIN_GIT_MAJOR = 2;
 const MIN_GIT_MINOR = 40;
+const PACKAGE_NAME = "oh-my-space";
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}`;
+const REGISTRY_TIMEOUT_MS = 10_000;
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const useColor = process.stdout.isTTY;
 const dim = (s) => (useColor ? `\x1b[2m${s}\x1b[0m` : s);
+function isTestMode() {
+    return process.env.OMS_TEST_MODE === "1";
+}
+function testEnv(name) {
+    return isTestMode() ? process.env[name] : undefined;
+}
+function formatCommand(command) {
+    return [command.executable, ...command.args].join(" ");
+}
+function globalUpdateCommand(manager) {
+    if (manager === "npm")
+        return { executable: "npm", args: ["install", "-g", `${PACKAGE_NAME}@latest`] };
+    if (manager === "pnpm")
+        return { executable: "pnpm", args: ["add", "-g", `${PACKAGE_NAME}@latest`] };
+    if (manager === "yarn")
+        return { executable: "yarn", args: ["global", "add", `${PACKAGE_NAME}@latest`] };
+    return { executable: "bun", args: ["add", "-g", `${PACKAGE_NAME}@latest`] };
+}
+async function fetchLatestPackageVersion() {
+    const mocked = testEnv("OMS_TEST_REGISTRY_RESPONSE");
+    if (mocked !== undefined)
+        return latestFromRegistryJson(JSON.parse(mocked));
+    const failure = testEnv("OMS_TEST_REGISTRY_FAILURE");
+    if (failure)
+        throw new Error(failure);
+    let response;
+    try {
+        response = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS) });
+    }
+    catch (e) {
+        throw new Error(`Could not reach npm registry: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (!response.ok) {
+        throw new Error(`npm registry request failed with HTTP ${response.status}`);
+    }
+    try {
+        return latestFromRegistryJson(await response.json());
+    }
+    catch (e) {
+        if (e instanceof Error)
+            throw e;
+        throw new Error(`Could not parse npm registry response: ${String(e)}`);
+    }
+}
+function latestFromRegistryJson(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+        throw new Error("npm registry response was not a JSON object");
+    }
+    const distTags = data["dist-tags"];
+    if (!distTags || typeof distTags !== "object" || Array.isArray(distTags)) {
+        throw new Error("npm registry response is missing dist-tags.latest");
+    }
+    const latest = distTags.latest;
+    if (typeof latest !== "string" || latest.length === 0) {
+        throw new Error("npm registry response is missing dist-tags.latest");
+    }
+    return latest;
+}
+function compareVersions(currentVersion, latestVersion) {
+    const current = semver.valid(currentVersion);
+    if (!current)
+        throw new Error(`Installed version is not valid semver: ${currentVersion}`);
+    const latest = semver.valid(latestVersion);
+    if (!latest)
+        throw new Error(`Registry latest version is not valid semver: ${latestVersion}`);
+    return semver.compare(current, latest);
+}
+function safeRealpath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}
+function runtimePlatform() {
+    const mocked = testEnv("OMS_TEST_PLATFORM");
+    return mocked === "win32" ? "win32" : process.platform;
+}
+function binaryPathNames(name) {
+    if (runtimePlatform() !== "win32")
+        return [name];
+    const extensions = new Set([...(process.env.PATHEXT ?? "").split(";"), ".cmd", ".ps1", ".exe", ".bat"]);
+    const names = [name];
+    for (const ext of extensions) {
+        if (!ext)
+            continue;
+        const normalizedExt = ext.startsWith(".") ? ext : `.${ext}`;
+        names.push(`${name}${normalizedExt.toLowerCase()}`, `${name}${normalizedExt}`);
+    }
+    return [...new Set(names)];
+}
+function resolvePathBinary(name) {
+    const mocked = testEnv("OMS_TEST_PATH_BIN");
+    if (mocked !== undefined)
+        return mocked.length > 0 ? mocked : null;
+    for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const candidateName of binaryPathNames(name)) {
+            const candidate = join(dir, candidateName);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+function findPackageRoot(start) {
+    let current = resolve(start);
+    while (true) {
+        const pkgPath = join(current, "package.json");
+        if (existsSync(pkgPath))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function readPackageName(root) {
+    try {
+        return readJson(join(root, "package.json"))?.name ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function collectRuntimeEvidence() {
+    const mocked = testEnv("OMS_TEST_RUNTIME_EVIDENCE");
+    if (mocked !== undefined)
+        return JSON.parse(mocked);
+    const modulePath = testEnv("OMS_TEST_MODULE_PATH") ?? fileURLToPath(import.meta.url);
+    const detectedPackageRoot = findPackageRoot(dirname(modulePath)) ?? packageRoot;
+    const mockedArgv1 = testEnv("OMS_TEST_ARGV1");
+    const runningBin = mockedArgv1 !== undefined
+        ? resolve(mockedArgv1)
+        : process.argv[1]
+            ? resolve(process.argv[1])
+            : modulePath;
+    const pathBin = resolvePathBinary("oms");
+    return {
+        packageRoot: detectedPackageRoot,
+        realPackageRoot: safeRealpath(detectedPackageRoot),
+        runningBin,
+        realRunningBin: safeRealpath(runningBin),
+        pathBin,
+        realPathBin: pathBin ? safeRealpath(pathBin) : null,
+        packageName: readPackageName(detectedPackageRoot),
+    };
+}
+function commandForProject(manager, dev) {
+    if (manager === "npm")
+        return `npm install ${dev ? "--save-dev " : ""}${PACKAGE_NAME}@latest`;
+    if (manager === "pnpm")
+        return `pnpm add ${dev ? "-D " : ""}${PACKAGE_NAME}@latest`;
+    if (manager === "yarn")
+        return `yarn add ${dev ? "--dev " : ""}${PACKAGE_NAME}@latest`;
+    return `bun add ${dev ? "-d " : ""}${PACKAGE_NAME}@latest`;
+}
+function nearestProjectRoot(start) {
+    let current = resolve(start);
+    while (true) {
+        if (existsSync(join(current, "package.json")))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function inferProjectManager(projectRoot, pkg) {
+    const declared = pkg.packageManager?.split("@")[0];
+    if (declared === "pnpm" || declared === "yarn" || declared === "bun" || declared === "npm")
+        return declared;
+    if (existsSync(join(projectRoot, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (existsSync(join(projectRoot, "yarn.lock")))
+        return "yarn";
+    if (existsSync(join(projectRoot, "bun.lockb")) || existsSync(join(projectRoot, "bun.lock")))
+        return "bun";
+    return "npm";
+}
+function projectGuidance(packageRootPath) {
+    const projectRoot = nearestProjectRoot(dirname(packageRootPath));
+    if (!projectRoot)
+        return [`npm install --save-dev ${PACKAGE_NAME}@latest`];
+    const pkg = readJson(join(projectRoot, "package.json"));
+    if (!pkg)
+        return [`npm install --save-dev ${PACKAGE_NAME}@latest`];
+    const manager = inferProjectManager(projectRoot, pkg);
+    const dev = !(pkg.dependencies && PACKAGE_NAME in pkg.dependencies);
+    return [commandForProject(manager, dev)];
+}
+function pathParts(path) {
+    return normalizePath(safeRealpath(path)).split("/").filter(Boolean);
+}
+function normalizePath(path) {
+    return path.replace(/\\/g, "/");
+}
+function isPackageRootNamed(packageRootPath) {
+    return pathParts(packageRootPath).at(-1) === PACKAGE_NAME;
+}
+function hasBinPath(binPaths, expectedPaths) {
+    const normalizeForComparison = (path) => {
+        const normalized = normalizePath(path);
+        return runtimePlatform() === "win32" ? normalized.toLowerCase() : normalized;
+    };
+    const actual = binPaths.map(normalizeForComparison);
+    return expectedPaths.some((expected) => actual.includes(normalizeForComparison(expected)));
+}
+function commandShimPaths(prefix, name) {
+    return [`${prefix}/${name}`, `${prefix}/${name}.cmd`, `${prefix}/${name}.ps1`];
+}
+function isNpmGlobalLayout(packageRootPath, binPaths) {
+    const root = normalizePath(packageRootPath);
+    if (root.endsWith(`/lib/node_modules/${PACKAGE_NAME}`)) {
+        const prefix = root.slice(0, -`/lib/node_modules/${PACKAGE_NAME}`.length);
+        return hasBinPath(binPaths, commandShimPaths(`${prefix}/bin`, "oms"));
+    }
+    if (root.endsWith(`/node_modules/${PACKAGE_NAME}`)) {
+        const prefix = root.slice(0, -`/node_modules/${PACKAGE_NAME}`.length);
+        return hasBinPath(binPaths, commandShimPaths(prefix, "oms"));
+    }
+    return false;
+}
+function isPnpmGlobalLayout(packageRootPath, binPaths) {
+    const root = normalizePath(packageRootPath);
+    const suffix = `/node_modules/${PACKAGE_NAME}`;
+    const marker = "/global/";
+    const markerIndex = root.lastIndexOf(marker);
+    if (markerIndex === -1 || !root.endsWith(suffix))
+        return false;
+    const storeVersion = root.slice(markerIndex + marker.length, -suffix.length);
+    if (!/^\d+$/.test(storeVersion))
+        return false;
+    const prefix = root.slice(0, markerIndex);
+    return hasBinPath(binPaths, [...commandShimPaths(prefix, "oms"), ...commandShimPaths(`${prefix}/bin`, "oms")]);
+}
+function isYarnGlobalLayout(packageRootPath, binPaths) {
+    const root = normalizePath(packageRootPath);
+    const suffix = `/.config/yarn/global/node_modules/${PACKAGE_NAME}`;
+    if (!root.endsWith(suffix))
+        return false;
+    const home = root.slice(0, -suffix.length);
+    return hasBinPath(binPaths, commandShimPaths(`${home}/.yarn/bin`, "oms"));
+}
+function isBunGlobalLayout(packageRootPath, binPaths) {
+    const root = normalizePath(packageRootPath);
+    const suffix = `/.bun/install/global/node_modules/${PACKAGE_NAME}`;
+    if (!root.endsWith(suffix))
+        return false;
+    const home = root.slice(0, -suffix.length);
+    return hasBinPath(binPaths, commandShimPaths(`${home}/.bun/bin`, "oms"));
+}
+function isProjectLocalLayout(evidence) {
+    const projectRoot = nearestProjectRoot(dirname(evidence.realPackageRoot));
+    if (!projectRoot)
+        return false;
+    const root = normalizePath(evidence.realPackageRoot);
+    const project = normalizePath(projectRoot);
+    if (!root.startsWith(`${project}/`))
+        return false;
+    const binPaths = [evidence.pathBin, evidence.runningBin, evidence.realPathBin, evidence.realRunningBin]
+        .filter((path) => Boolean(path))
+        .map(normalizePath);
+    return hasBinPath(binPaths, commandShimPaths(`${project}/node_modules/.bin`, "oms"));
+}
+function globalManagerFromPaths(evidence) {
+    const root = normalizePath(evidence.realPackageRoot);
+    const binPaths = [evidence.pathBin, evidence.runningBin, evidence.realPathBin, evidence.realRunningBin]
+        .filter((path) => Boolean(path))
+        .map(normalizePath);
+    const managers = new Set();
+    if (isNpmGlobalLayout(root, binPaths))
+        managers.add("npm");
+    if (isPnpmGlobalLayout(root, binPaths))
+        managers.add("pnpm");
+    if (isYarnGlobalLayout(root, binPaths))
+        managers.add("yarn");
+    if (isBunGlobalLayout(root, binPaths))
+        managers.add("bun");
+    return managers.size === 1 ? [...managers][0] : null;
+}
+function detectInstallContext() {
+    const mocked = testEnv("OMS_TEST_INSTALL_CONTEXT");
+    if (mocked !== undefined)
+        return JSON.parse(mocked);
+    const evidence = collectRuntimeEvidence();
+    const warnings = [];
+    if (evidence.packageName !== PACKAGE_NAME) {
+        return {
+            kind: "unknown",
+            label: `unknown install (package root is not ${PACKAGE_NAME})`,
+            guidance: [`npm install -g ${PACKAGE_NAME}@latest`, `pnpm add -g ${PACKAGE_NAME}@latest`],
+            warnings,
+        };
+    }
+    if (evidence.realPathBin && evidence.realPathBin !== evidence.realRunningBin) {
+        warnings.push(`PATH-resolved oms differs from the running executable: ${evidence.pathBin}`);
+    }
+    const rootParts = pathParts(evidence.realPackageRoot);
+    if (rootParts.includes("_npx") || rootParts.includes("dlx") || rootParts.includes("bunx")) {
+        return {
+            kind: "ephemeral",
+            label: "temporary runner install",
+            guidance: [`Run ${PACKAGE_NAME} with @latest, or install it globally with npm install -g ${PACKAGE_NAME}@latest.`],
+            warnings,
+        };
+    }
+    if (existsSync(join(evidence.packageRoot, "scripts", "oms.ts")) || existsSync(join(evidence.packageRoot, "tsconfig.json"))) {
+        return {
+            kind: "development",
+            label: "development checkout",
+            guidance: ["Update the source checkout with git, then rebuild."],
+            warnings,
+        };
+    }
+    if (normalizePath(evidence.realPackageRoot).includes(`/node_modules/${PACKAGE_NAME}`)) {
+        const manager = globalManagerFromPaths(evidence);
+        if (manager && isPackageRootNamed(evidence.realPackageRoot)) {
+            const updateCommand = globalUpdateCommand(manager);
+            return {
+                kind: "global",
+                label: `global ${manager} install`,
+                manager,
+                updateCommand,
+                guidance: [formatCommand(updateCommand)],
+                warnings,
+            };
+        }
+        if (!isProjectLocalLayout(evidence)) {
+            return {
+                kind: "unknown",
+                label: "unknown install context",
+                guidance: [`npm install -g ${PACKAGE_NAME}@latest`, `pnpm add -g ${PACKAGE_NAME}@latest`],
+                warnings,
+            };
+        }
+        return {
+            kind: "project",
+            label: "project-local install",
+            guidance: projectGuidance(evidence.realPackageRoot),
+            warnings,
+        };
+    }
+    return {
+        kind: "unknown",
+        label: "unknown install context",
+        guidance: [`npm install -g ${PACKAGE_NAME}@latest`, `pnpm add -g ${PACKAGE_NAME}@latest`],
+        warnings,
+    };
+}
 function validateSources(data) {
     if (!data || typeof data !== "object" || Array.isArray(data)) {
         throw new Error(`${MANIFEST_FILENAME}: root must be a mapping`);
@@ -1140,6 +1496,134 @@ function readPackageVersion() {
     const pkg = readJson(join(packageRoot, "package.json"));
     return pkg?.version ?? "0.0.0";
 }
+function printUpdateHeader(currentVersion, latestVersion) {
+    log.info(`Current version: ${currentVersion}`);
+    log.info(`Latest version: ${latestVersion}`);
+}
+function printInstallContext(context) {
+    log.info(`Detected context: ${context.label}`);
+    for (const warning of context.warnings)
+        log.warn(warning);
+    if (context.updateCommand)
+        log.info(`Selected command: ${formatCommand(context.updateCommand)}`);
+}
+function printGuidance(context) {
+    if (context.guidance.length === 0)
+        return;
+    log.info("Manual update guidance:");
+    for (const command of context.guidance)
+        log.message(`  ${command}`);
+}
+function commandAvailability(command) {
+    const mocked = testEnv("OMS_TEST_MANAGER_AVAILABLE");
+    if (mocked !== undefined)
+        return mocked === "1" || mocked === "true";
+    const result = spawnSync(command.executable, ["--version"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: runtimePlatform() === "win32",
+    });
+    return result.status === 0;
+}
+function runUpdateCommand(command) {
+    const mocked = testEnv("OMS_TEST_UPDATE_EXIT");
+    if (mocked !== undefined) {
+        log.step(formatCommand(command));
+        return Number.parseInt(mocked, 10);
+    }
+    log.step(formatCommand(command));
+    const result = spawnSync(command.executable, command.args, { stdio: "inherit", shell: runtimePlatform() === "win32" });
+    if (result.status !== null)
+        return result.status;
+    log.error(`Package manager exited from signal ${result.signal ?? "unknown"}.`);
+    return 1;
+}
+function verifyPostUpdate(latestVersion) {
+    const mocked = testEnv("OMS_TEST_VERIFY_VERSION");
+    const result = mocked !== undefined
+        ? { status: 0, stdout: mocked, stderr: "" }
+        : spawnSync("oms", ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], shell: false });
+    if (result.status !== 0) {
+        log.warn("Post-update verification could not run oms --version from PATH.");
+        return;
+    }
+    const observed = result.stdout.trim().replace(/^oms\s+/, "");
+    if (observed !== latestVersion) {
+        log.warn(`Post-update verification saw ${observed || "empty output"}, expected ${latestVersion}.`);
+    }
+}
+async function confirmUpdate(command) {
+    const choice = await select({
+        message: `Run ${formatCommand(command)}?`,
+        options: [
+            { value: "yes", label: "Yes, update oms" },
+            { value: "no", label: "No, do not update" },
+        ],
+    });
+    if (isCancel(choice)) {
+        cancel("Cancelled.");
+        return null;
+    }
+    return choice === "yes";
+}
+async function runUpdate(options) {
+    let latestVersion;
+    const currentVersion = readPackageVersion();
+    try {
+        latestVersion = await fetchLatestPackageVersion();
+        const comparison = compareVersions(currentVersion, latestVersion);
+        printUpdateHeader(currentVersion, latestVersion);
+        if (comparison === 0) {
+            log.success("oms is up to date.");
+            return 0;
+        }
+        if (comparison > 0) {
+            log.info("Installed version is newer than the npm registry latest; no downgrade will be performed.");
+            return 0;
+        }
+    }
+    catch (e) {
+        log.error(e instanceof Error ? e.message : String(e));
+        return 1;
+    }
+    log.warn("Update available.");
+    const context = detectInstallContext();
+    printInstallContext(context);
+    if (options.check) {
+        if (!context.updateCommand)
+            printGuidance(context);
+        return 0;
+    }
+    if (context.kind !== "global" || !context.updateCommand) {
+        log.info("Automatic update is only supported for confident global installs.");
+        printGuidance(context);
+        return 0;
+    }
+    const command = context.updateCommand;
+    if (!options.yes) {
+        if (!process.stdin.isTTY) {
+            log.info(`Non-interactive shell detected. Re-run with --yes to execute: ${formatCommand(command)}`);
+            return 0;
+        }
+        const confirmed = await confirmUpdate(command);
+        if (!confirmed) {
+            log.info("Update cancelled; no changes made.");
+            return 0;
+        }
+    }
+    if (!commandAvailability(command)) {
+        log.error(`${command.executable} is not executable from PATH. Would have run: ${formatCommand(command)}`);
+        return 1;
+    }
+    const updateExit = runUpdateCommand(command);
+    if (updateExit !== 0) {
+        log.error(`Package manager update failed (exit ${updateExit}).`);
+        return 1;
+    }
+    verifyPostUpdate(latestVersion);
+    log.success("Update command completed.");
+    return 0;
+}
 /** The commit baked in at build time, or null when unavailable (dev/no-git build). */
 function readBuildCommit() {
     const info = readJson(join(dirname(fileURLToPath(import.meta.url)), "build-info.json"));
@@ -1171,6 +1655,7 @@ const commandNames = new Set([
     "pull",
     "push",
     "unsync",
+    "update",
     "help",
 ]);
 const program = new Command();
@@ -1273,6 +1758,15 @@ program
     .action(async (aliases, options) => {
     await exitWith(runUnsync(aliases, options));
 });
+program
+    .command("update")
+    .description("Check for and safely update the oms CLI. Only confident global installs are updated automatically.")
+    .option("--check", "check for an available update without mutating the installation")
+    .option("--yes", "run a confirmed global update without prompting")
+    .addHelpText("after", exitHelp)
+    .action(async (options) => {
+    await exitWith(runUpdate(options));
+});
 const requestedCommand = process.argv[2];
 if (requestedCommand && !requestedCommand.startsWith("-") && !commandNames.has(requestedCommand)) {
     console.error(`error: unknown command '${requestedCommand}'`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-space",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "CLI for managing external source repositories declared in oms.yaml.",
   "license": "MIT",
   "homepage": "https://github.com/divlook/oh-my-space",
@@ -46,11 +46,13 @@
     "@changesets/changelog-github": "^0.7.0",
     "@changesets/cli": "^2.29.7",
     "@types/node": "^20.19.0",
+    "@types/semver": "^7.7.1",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "@clack/prompts": "^1.4.0",
     "commander": "^14.0.3",
+    "semver": "^7.8.4",
     "yaml": "^2.8.1"
   }
 }