oh-my-space 0.6.0 → 0.7.1

package/README.md

@@ -49,10 +49,13 @@ Run `oms init` to scaffold a starter `oms.yaml`, or create one by hand in your p
 # yaml-language-server: $schema=https://raw.githubusercontent.com/divlook/oh-my-space/main/oms.schema.json
 repos:
   - alias: api
-    url: git@github.com:example/api.git
+    remotes:
+      origin: git@github.com:example/api.git
     branch: main
   - alias: web
-    url: git@github.com:example/web.git
+    remotes:
+      origin: git@github.com:example/web.git
+      upstream: git@github.com:upstream/web.git
 ```
 
 Sync and work:
@@ -66,6 +69,7 @@ oms sync --all                    # sync every registered source repo
 oms status                        # branch / pointer / dirty / ahead-behind per submodule
 oms checkout <alias> <branch>     # switch (or create a brand-new local 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
 ```
 
@@ -83,7 +87,7 @@ git add oms/api && git commit     # record the pointer in your project history
 For an alias `api` checked out on `main`:
 
 ```
-.gitmodules            # registers oms/api -> url, branch
+.gitmodules            # registers oms/api -> origin url, branch
 oms/
 └── api/               # git submodule (a normal working tree, on a branch)
 ```
@@ -92,7 +96,7 @@ oms/
 
 ## Managing source repositories
 
-`oms.yaml` declares each source repo with `alias`, `url`, and optional `branch` (the baseline).
+`oms.yaml` declares each source repo with `alias`, a `remotes` mapping (which must include `origin`), and optional `branch` (the baseline).
 
 | Command | Runs in | Does | Notes |
 | --- | --- | --- | --- |
@@ -101,9 +105,9 @@ oms/
 | `oms sync <alias>` / `--all` | workspace root | Registers missing repos with `git submodule add`, initializes registered-but-uninitialized ones, fetches, and attaches the baseline branch. | Reproduces the recorded pointer on a fresh clone. |
 | `oms status [alias...]` / `--all` | anywhere under root | Prints branch, pointer state (`ok`/`moved`/`uninit`), dirtiness, and ahead/behind for each submodule. | `moved` means the working commit differs from the recorded pointer — stage/commit it. |
 | `oms checkout <alias> <branch>` | workspace root | `git switch` to the branch; creates it locally if it exists nowhere yet (no remote required). | `--from <ref>` sets the start point for a new branch. |
-| `oms fetch ...` | workspace root | `git fetch origin --prune` in each submodule. | |
-| `oms pull ...` | workspace root | `git pull --ff-only` on each submodule's current branch, then stages the moved pointer. | Requires the submodule to be on a branch with upstream. |
-| `oms push <alias>...` | workspace root | `git push -u origin <branch>` (creating the remote branch on first push), then stages the moved pointer. | `--commit` also commits the pointer update in the parent. |
+| `oms fetch ...` | workspace root | `git fetch <remote> --prune` in each submodule. | `--remote <name>` (repeatable) picks the remote(s); omit to choose interactively, defaults to `origin`. |
+| `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.yaml` format
@@ -112,17 +116,20 @@ oms/
 # yaml-language-server: $schema=https://raw.githubusercontent.com/divlook/oh-my-space/main/oms.schema.json
 repos:
   - alias: service-a
-    url: git@github.com:example/service-a.git
+    remotes:
+      origin: git@github.com:example/service-a.git
     branch: main
   - alias: docs
-    url: https://github.com/example/docs.git
+    remotes:
+      origin: https://github.com/example/docs.git
+      upstream: https://github.com/upstream/docs.git
 ```
 
 Rules:
 
 - `repos` must be a non-empty array.
 - `alias` must be unique and match `/^[a-z0-9][a-z0-9-]*$/`.
-- `url` is required.
+- `remotes` is required and must include an `origin` entry; each value is a clonable git URL. `origin` becomes the submodule's primary remote, and additional remotes are configured on `oms sync`.
 - `branch` is optional; when omitted the remote's default branch is used as the baseline.
 
 JSON schema: [`oms.schema.json`](./oms.schema.json) (also reachable at `https://raw.githubusercontent.com/divlook/oh-my-space/main/oms.schema.json` for YAML LSPs).

package/dist/build-info.json

@@ -0,0 +1 @@
+{"commit":"b3b6890088ebe3eb5dd965d2fdd730a60b5a0a01"}

package/dist/oms.js

@@ -4,11 +4,12 @@ import { existsSync, readFileSync, readdirSync, rmSync, rmdirSync, writeFileSync
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
-import { cancel, isCancel, log, multiselect } from "@clack/prompts";
+import { cancel, isCancel, log, multiselect, select } from "@clack/prompts";
 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._/-]*$/;
 const ALLOWED_TOP_KEYS = new Set(["repos"]);
-const ALLOWED_ITEM_KEYS = new Set(["alias", "url", "branch"]);
+const ALLOWED_ITEM_KEYS = new Set(["alias", "remotes", "branch"]);
 const MANIFEST_FILENAME = "oms.yaml";
 const DATA_DIRNAME = "oms";
 const GITIGNORE_ENTRY = `${DATA_DIRNAME}/`;
@@ -17,6 +18,9 @@ const LEGACY_MANIFEST = "sources.yaml";
 const LEGACY_DATA_DIRNAME = "sources";
 const RENAME_MIGRATION_DOC = "docs/migrations/0.3.x-to-0.4.0.md";
 const WORKTREE_MIGRATION_DOC = "docs/migrations/0.5.x-to-0.6.0.md";
+const REMOTES_MIGRATION_DOC = "docs/migrations/0.6.x-to-0.7.0.md";
+/** GitHub blob base for the clickable doc permalinks shown in CLI messages. */
+const DOCS_REPO_BLOB_BASE = "https://github.com/divlook/oh-my-space/blob";
 const MIN_GIT_MAJOR = 2;
 const MIN_GIT_MINOR = 40;
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
@@ -47,6 +51,10 @@ function validateSources(data) {
             throw new Error(`${MANIFEST_FILENAME}: ${where} must be a mapping`);
         }
         const r = item;
+        // Friendlier than "unknown key url": the 0.7.0 manifest replaced url with a remotes mapping.
+        if ("url" in r && !("remotes" in r)) {
+            throw new Error(`${MANIFEST_FILENAME}: ${where}.url is no longer supported; use a "remotes" mapping with an "origin" entry. See ${docUrl(REMOTES_MIGRATION_DOC)}`);
+        }
         for (const key of Object.keys(r)) {
             if (!ALLOWED_ITEM_KEYS.has(key)) {
                 throw new Error(`${MANIFEST_FILENAME}: ${where} has unknown key "${key}"`);
@@ -62,8 +70,25 @@ function validateSources(data) {
             throw new Error(`${MANIFEST_FILENAME}: duplicate alias "${r.alias}"`);
         }
         seen.add(r.alias);
-        if (typeof r.url !== "string" || r.url.length === 0) {
-            throw new Error(`${MANIFEST_FILENAME}: ${where} missing required "url"`);
+        if (!r.remotes || typeof r.remotes !== "object" || Array.isArray(r.remotes)) {
+            throw new Error(`${MANIFEST_FILENAME}: ${where} missing required "remotes" mapping`);
+        }
+        const remoteEntries = Object.entries(r.remotes);
+        if (remoteEntries.length === 0) {
+            throw new Error(`${MANIFEST_FILENAME}: ${where}.remotes must have at least one remote`);
+        }
+        const remotes = {};
+        for (const [name, url] of remoteEntries) {
+            if (!REMOTE_NAME_PATTERN.test(name)) {
+                throw new Error(`${MANIFEST_FILENAME}: ${where}.remotes name "${name}" must match ${REMOTE_NAME_PATTERN}`);
+            }
+            if (typeof url !== "string" || url.length === 0) {
+                throw new Error(`${MANIFEST_FILENAME}: ${where}.remotes.${name} must be a non-empty string URL`);
+            }
+            remotes[name] = url;
+        }
+        if (!remotes.origin) {
+            throw new Error(`${MANIFEST_FILENAME}: ${where}.remotes must include an "origin" entry`);
         }
         let branch;
         if (r.branch !== undefined) {
@@ -72,19 +97,27 @@ function validateSources(data) {
             }
             branch = r.branch;
         }
-        validated.push({ alias: r.alias, url: r.url, branch });
+        validated.push({ alias: r.alias, remotes, branch });
     });
     return validated;
 }
 function pad(s, width) {
     return s + " ".repeat(Math.max(0, width - s.length));
 }
+/** Names of a repo's non-origin remotes, in declared order (origin is shown via its URL column). */
+function extraRemoteNames(repo) {
+    return Object.keys(repo.remotes).filter((name) => name !== "origin");
+}
 function printList(repos) {
+    const extras = (r) => {
+        const names = extraRemoteNames(r);
+        return names.length > 0 ? ` (+${names.join(",")})` : "";
+    };
     const aliasW = Math.max("ALIAS".length, ...repos.map((r) => r.alias.length));
-    const urlW = Math.max("URL".length, ...repos.map((r) => r.url.length));
-    console.log(dim(`${pad("ALIAS", aliasW)}  ${pad("URL", urlW)}  BRANCH`));
+    const urlW = Math.max("ORIGIN".length, ...repos.map((r) => (r.remotes.origin + extras(r)).length));
+    console.log(dim(`${pad("ALIAS", aliasW)}  ${pad("ORIGIN", urlW)}  BRANCH`));
     for (const r of repos) {
-        console.log(`${pad(r.alias, aliasW)}  ${pad(r.url, urlW)}  ${r.branch ?? ""}`);
+        console.log(`${pad(r.alias, aliasW)}  ${pad(r.remotes.origin + extras(r), urlW)}  ${r.branch ?? ""}`);
     }
 }
 async function selectInteractive(repos, actionLabel) {
@@ -105,6 +138,56 @@ async function selectInteractive(repos, actionLabel) {
         .map((alias) => repos.find((r) => r.alias === alias))
         .filter((r) => r !== undefined);
 }
+/**
+ * Decide which remote(s) a fetch/pull/push targets for one repo. Honors an explicit --remote list,
+ * otherwise prompts interactively on a TTY (origin preselected) and falls back to origin off-TTY.
+ * pull is restricted to a single remote since --ff-only can advance to at most one. Returns the
+ * resolved remote names, or null when the request is invalid or the prompt was cancelled.
+ */
+async function resolveRemotes(repo, requested, command) {
+    const declared = Object.keys(repo.remotes);
+    if (requested && requested.length > 0) {
+        const unique = uniqueAliases(requested);
+        const unknown = unique.filter((name) => !declared.includes(name));
+        if (unknown.length > 0) {
+            log.error(`${repo.alias}: unknown remote(s): ${unknown.join(", ")}. Declared: ${declared.join(", ")}.`);
+            return null;
+        }
+        if (command === "pull" && unique.length > 1) {
+            log.error(`${repo.alias}: pull targets a single remote (git pull --ff-only can advance only one).`);
+            return null;
+        }
+        return unique;
+    }
+    // No explicit remote: a lone origin needs no prompt, and a non-interactive shell defaults to origin.
+    if (declared.length === 1)
+        return declared;
+    if (!process.stdin.isTTY)
+        return ["origin"];
+    if (command === "pull") {
+        const choice = await select({
+            message: `${repo.alias}: select a remote to ${command}`,
+            options: declared.map((name) => ({ value: name, label: name, hint: repo.remotes[name] })),
+            initialValue: "origin",
+        });
+        if (isCancel(choice)) {
+            cancel("Cancelled.");
+            return null;
+        }
+        return [choice];
+    }
+    const choice = await multiselect({
+        message: `${repo.alias}: select remote(s) to ${command} (space to toggle, enter to confirm)`,
+        options: declared.map((name) => ({ value: name, label: name, hint: repo.remotes[name] })),
+        initialValues: ["origin"],
+        required: true,
+    });
+    if (isCancel(choice)) {
+        cancel("Cancelled.");
+        return null;
+    }
+    return choice;
+}
 function runGit(cwd, args, inheritOutput = false) {
     const result = spawnSync("git", args, {
         cwd,
@@ -155,10 +238,10 @@ function submodulePath(alias) {
 function isGitRepo(repoRoot) {
     return runGit(repoRoot, ["rev-parse", "--is-inside-work-tree"]).stdout.trim() === "true";
 }
-/** True when .gitmodules registers a submodule at the given path (sources/<alias> or oms/<alias>). */
-function isRegisteredSubmodule(repoRoot, sourcePath) {
+/** Every submodule path registered in .gitmodules (empty when the file is absent or registers none). */
+function registeredSubmodulePaths(repoRoot) {
     if (!existsSync(join(repoRoot, ".gitmodules")))
-        return false;
+        return [];
     const result = runGit(repoRoot, [
         "config",
         "--file",
@@ -167,10 +250,19 @@ function isRegisteredSubmodule(repoRoot, sourcePath) {
         "^submodule\\..*\\.path$",
     ]);
     if (!result.success)
-        return false;
+        return [];
     return result.stdout
         .split("\n")
-        .some((line) => line.trim().split(/\s+/)[1] === sourcePath);
+        .map((line) => line.trim().split(/\s+/)[1])
+        .filter((p) => Boolean(p));
+}
+/** True when .gitmodules registers a submodule at the given path (sources/<alias> or oms/<alias>). */
+function isRegisteredSubmodule(repoRoot, sourcePath) {
+    return registeredSubmodulePaths(repoRoot).includes(sourcePath);
+}
+/** True when .gitmodules still registers at least one submodule. */
+function hasRegisteredSubmodules(repoRoot) {
+    return registeredSubmodulePaths(repoRoot).length > 0;
 }
 /** A submodule is initialized when its working tree has a .git gitlink file/dir. */
 function submoduleInitialized(repoRoot, alias) {
@@ -232,6 +324,21 @@ function attachBranch(repoRoot, alias, branch) {
         runSub(repoRoot, alias, ["branch", "--set-upstream-to", `origin/${branch}`, branch]);
     }
 }
+/**
+ * Reconcile the submodule's git remotes with the declared `remotes` map: add missing remotes and
+ * update URLs that drifted. Non-destructive — remotes no longer in oms.yaml are left untouched.
+ */
+function ensureRemotes(repoRoot, alias, remotes) {
+    for (const [name, url] of Object.entries(remotes)) {
+        const existing = runSub(repoRoot, alias, ["remote", "get-url", name]);
+        if (!existing.success) {
+            runSub(repoRoot, alias, ["remote", "add", name, url]);
+        }
+        else if (existing.stdout.trim() !== url) {
+            runSub(repoRoot, alias, ["remote", "set-url", name, url]);
+        }
+    }
+}
 /** Stage the submodule gitlink in the parent so a moved pointer shows up and is ready to commit. */
 function stagePointer(repoRoot, alias) {
     runGit(repoRoot, ["add", "--", submodulePath(alias)]);
@@ -245,7 +352,7 @@ function emitLegacyRenameMessage(dir, found) {
         .join(" and ");
     log.error(`detected legacy ${artifacts} at ${dir}.\n` +
         `  oh-my-space 0.4.0 renamed the manifest to ${MANIFEST_FILENAME} and the data directory to ${DATA_DIRNAME}/.\n` +
-        `  See ${RENAME_MIGRATION_DOC} for the manual steps. Aborting to avoid destructive change.`);
+        `  See ${docUrl(RENAME_MIGRATION_DOC)} for the manual steps. Aborting to avoid destructive change.`);
 }
 /** Block when the active oms.yaml workspace still has 0.3.x rename artifacts at its root. */
 function abortOnLegacyRenameAt(repoRoot) {
@@ -283,7 +390,7 @@ function abortOnLegacyWorktree(repoRoot, repos) {
     if (!stale)
         return false;
     log.error(`detected a legacy bare clone at ${DATA_DIRNAME}/${stale.alias}/.bare. oh-my-space 0.6.0 manages sources as git submodules.\n` +
-        `  See ${WORKTREE_MIGRATION_DOC} for the manual steps. Aborting to avoid destructive change.`);
+        `  See ${docUrl(WORKTREE_MIGRATION_DOC)} for the manual steps. Aborting to avoid destructive change.`);
     return true;
 }
 /** Submodules live inside the parent's history, so oms/ must not be gitignored. Strip a managed entry. */
@@ -347,11 +454,11 @@ function syncRepo(repo, repoRoot) {
                 "ls-remote",
                 "--exit-code",
                 "--heads",
-                repo.url,
+                repo.remotes.origin,
                 repo.branch,
             ]);
             if (lsRemote.exitCode === 2) {
-                log.error(`${alias}: branch "${repo.branch}" not found on ${repo.url}. Push the branch upstream or fix the alias, then retry.`);
+                log.error(`${alias}: branch "${repo.branch}" not found on ${repo.remotes.origin}. Push the branch upstream or fix the alias, then retry.`);
                 return "failed";
             }
             if (!lsRemote.success && lsRemote.exitCode !== 2) {
@@ -364,14 +471,15 @@ function syncRepo(repo, repoRoot) {
         if (!existsSync(gitmodules) && runGit(repoRoot, ["cat-file", "-e", "HEAD:.gitmodules"]).success) {
             writeFileSync(gitmodules, "");
         }
-        log.step(`${alias}: git submodule add${repo.branch ? ` -b ${repo.branch}` : ""} ${repo.url} ${path}`);
-        const args = ["submodule", "add", ...(repo.branch ? ["-b", repo.branch] : []), "--", repo.url, path];
+        log.step(`${alias}: git submodule add${repo.branch ? ` -b ${repo.branch}` : ""} ${repo.remotes.origin} ${path}`);
+        const args = ["submodule", "add", ...(repo.branch ? ["-b", repo.branch] : []), "--", repo.remotes.origin, path];
         const add = runGit(repoRoot, args, true);
         if (!add.success) {
             log.error(`${alias}: git submodule add failed (exit ${add.exitCode})`);
             cleanupFailedAdd(repoRoot, alias);
             return "failed";
         }
+        ensureRemotes(repoRoot, alias, repo.remotes);
         const branch = repo.branch ?? currentBranch(aliasDir(repoRoot, alias));
         if (branch)
             attachBranch(repoRoot, alias, branch);
@@ -385,12 +493,14 @@ function syncRepo(repo, repoRoot) {
             log.error(`${alias}: git submodule update --init failed (exit ${upd.exitCode})`);
             return "failed";
         }
+        ensureRemotes(repoRoot, alias, repo.remotes);
         const branch = gitmodulesBranch(repoRoot, alias) ?? repo.branch;
         if (branch)
             attachBranch(repoRoot, alias, branch);
         log.success(`${alias}: initialized${branch ? ` (branch=${branch})` : ""}`);
         return "added";
     }
+    ensureRemotes(repoRoot, alias, repo.remotes);
     log.step(`${alias}: git fetch origin --prune`);
     const fetch = runSub(repoRoot, alias, ["fetch", "origin", "--prune"], true);
     if (!fetch.success) {
@@ -411,22 +521,34 @@ function unsyncRepo(repo, repoRoot, force) {
     if (!registered && !exists)
         return "nothing-to-remove";
     if (!force && submoduleInitialized(repoRoot, alias) && isDirty(aliasDir(repoRoot, alias))) {
-        log.error(`${alias}: ${path} has uncommitted changes. Commit, stash, or pass --force.`);
+        log.error(`${alias}: ${path} has uncommitted or untracked changes. Commit, stash, remove them, or pass --force.`);
         return "failed";
     }
     runGit(repoRoot, ["submodule", "deinit", ...(force ? ["-f"] : []), "--", path]);
     const rm = runGit(repoRoot, ["rm", "-f", "--", path], true);
     if (!rm.success) {
-        // Fall back to manual unregistration (e.g. the submodule was never initialized).
+        // git rm couldn't stage the removal (e.g. the submodule was never initialized).
         runGit(repoRoot, ["rm", "-f", "--cached", "--", path]);
-        runGit(repoRoot, ["config", "--file", ".gitmodules", "--remove-section", `submodule.${path}`]);
-        if (existsSync(join(repoRoot, ".gitmodules")))
-            runGit(repoRoot, ["add", ".gitmodules"]);
     }
+    // Always strip the registration explicitly: git rm's implicit .gitmodules edit is unreliable
+    // across git versions/states, and when it silently no-ops the section is orphaned for good.
+    // A missing section just makes these exit non-zero — harmless, output stays captured.
+    runGit(repoRoot, ["config", "--file", ".gitmodules", "--remove-section", `submodule.${path}`]);
+    if (existsSync(join(repoRoot, ".gitmodules")))
+        runGit(repoRoot, ["add", ".gitmodules"]);
+    // Drop the matching .git/config section too, in case deinit was skipped or failed.
+    runGit(repoRoot, ["config", "--remove-section", `submodule.${path}`]);
     try {
         rmSync(join(repoRoot, ".git", "modules", DATA_DIRNAME, alias), { recursive: true, force: true });
     }
     catch { }
+    // Drop the now-empty .git/modules/oms/ container so no stale gitdir scaffolding lingers.
+    try {
+        const modulesParent = join(repoRoot, ".git", "modules", DATA_DIRNAME);
+        if (existsSync(modulesParent) && readdirSync(modulesParent).length === 0)
+            rmdirSync(modulesParent);
+    }
+    catch { }
     if (existsSync(aliasDir(repoRoot, alias))) {
         rmSync(aliasDir(repoRoot, alias), { recursive: true, force: true });
     }
@@ -437,30 +559,32 @@ function unsyncRepo(repo, repoRoot, force) {
             rmdirSync(parent);
     }
     catch { }
-    // Drop a .gitmodules that no longer registers any submodule (git rm leaves it empty).
+    // Drop .gitmodules once it no longer registers any submodule (judged by content, not byte-emptiness).
     const gitmodules = join(repoRoot, ".gitmodules");
-    if (existsSync(gitmodules) && readFileSync(gitmodules, "utf8").trim().length === 0) {
+    if (existsSync(gitmodules) && !hasRegisteredSubmodules(repoRoot)) {
         if (!runGit(repoRoot, ["rm", "-f", "--", ".gitmodules"]).success) {
             rmSync(gitmodules, { force: true });
         }
     }
     return "removed";
 }
-function fetchRepo(repo, repoRoot) {
+function fetchRepo(repo, repoRoot, remotes) {
     if (!submoduleInitialized(repoRoot, repo.alias)) {
         log.error(`${repo.alias}: not synced. Run "oms sync ${repo.alias}" first.`);
         return "failed";
     }
-    log.step(`${repo.alias}: git fetch origin --prune`);
-    const r = runSub(repoRoot, repo.alias, ["fetch", "origin", "--prune"], true);
-    if (r.success) {
-        log.success(`${repo.alias}: fetched`);
-        return "fetched";
+    for (const remote of remotes) {
+        log.step(`${repo.alias}: git fetch ${remote} --prune`);
+        const r = runSub(repoRoot, repo.alias, ["fetch", remote, "--prune"], true);
+        if (!r.success) {
+            log.error(`${repo.alias}: fetch ${remote} failed (exit ${r.exitCode})`);
+            return "failed";
+        }
     }
-    log.error(`${repo.alias}: fetch failed (exit ${r.exitCode})`);
-    return "failed";
+    log.success(`${repo.alias}: fetched (${remotes.join(", ")})`);
+    return "fetched";
 }
-function pullRepo(repo, repoRoot) {
+function pullRepo(repo, repoRoot, remote) {
     if (!submoduleInitialized(repoRoot, repo.alias)) {
         log.error(`${repo.alias}: not synced. Run "oms sync ${repo.alias}" first.`);
         return "failed";
@@ -470,17 +594,17 @@ function pullRepo(repo, repoRoot) {
         log.error(`${repo.alias}: detached HEAD. Run "oms checkout ${repo.alias} <branch>" before pulling.`);
         return "failed";
     }
-    log.step(`${repo.alias}/${branch}: git pull --ff-only`);
-    const r = runSub(repoRoot, repo.alias, ["pull", "--ff-only"], true);
+    log.step(`${repo.alias}/${branch}: git pull --ff-only ${remote} ${branch}`);
+    const r = runSub(repoRoot, repo.alias, ["pull", "--ff-only", remote, branch], true);
     if (r.success) {
         stagePointer(repoRoot, repo.alias);
-        log.success(`${repo.alias}/${branch}: pulled`);
+        log.success(`${repo.alias}/${branch}: pulled from ${remote}`);
         return "pulled";
     }
-    log.error(`${repo.alias}/${branch}: pull failed (exit ${r.exitCode})`);
+    log.error(`${repo.alias}/${branch}: pull from ${remote} failed (exit ${r.exitCode})`);
     return "failed";
 }
-function pushRepo(repo, repoRoot, commit) {
+function pushRepo(repo, repoRoot, remotes, commit) {
     if (!submoduleInitialized(repoRoot, repo.alias)) {
         log.error(`${repo.alias}: not synced. Run "oms sync ${repo.alias}" first.`);
         return "failed";
@@ -490,18 +614,22 @@ function pushRepo(repo, repoRoot, commit) {
         log.error(`${repo.alias}: detached HEAD. Run "oms checkout ${repo.alias} <branch>" before pushing.`);
         return "failed";
     }
-    log.step(`${repo.alias}/${branch}: git push -u origin ${branch}`);
-    const r = runSub(repoRoot, repo.alias, ["push", "-u", "origin", branch], true);
-    if (!r.success) {
-        log.error(`${repo.alias}/${branch}: push failed (exit ${r.exitCode})`);
-        return "failed";
+    for (const remote of remotes) {
+        // Only origin sets upstream — repointing @{u} to a fork would skew "oms status" ahead/behind.
+        const args = remote === "origin" ? ["push", "-u", "origin", branch] : ["push", remote, branch];
+        log.step(`${repo.alias}/${branch}: git ${args.join(" ")}`);
+        const r = runSub(repoRoot, repo.alias, args, true);
+        if (!r.success) {
+            log.error(`${repo.alias}/${branch}: push to ${remote} failed (exit ${r.exitCode})`);
+            return "failed";
+        }
     }
     stagePointer(repoRoot, repo.alias);
     if (commit) {
         const sha = shortSha(aliasDir(repoRoot, repo.alias));
         runGit(repoRoot, ["commit", "-m", `oms: bump ${repo.alias} to ${sha}`, "--", submodulePath(repo.alias)]);
     }
-    log.success(`${repo.alias}/${branch}: pushed${commit ? " and recorded pointer" : ""}`);
+    log.success(`${repo.alias}/${branch}: pushed to ${remotes.join(", ")}${commit ? " and recorded pointer" : ""}`);
     return "pushed";
 }
 function printSummary(results) {
@@ -616,13 +744,20 @@ async function runManage(command, aliases, options) {
     const picked = await selectRepos(repos, aliases, options, command);
     if (!picked || picked.length === 0)
         return 1;
-    const results = picked.map((repo) => {
+    const results = [];
+    for (const repo of picked) {
+        const remotes = await resolveRemotes(repo, options.remote, command);
+        if (!remotes || remotes.length === 0) {
+            results.push("failed");
+            continue;
+        }
         if (command === "fetch")
-            return fetchRepo(repo, repoRoot);
-        if (command === "pull")
-            return pullRepo(repo, repoRoot);
-        return pushRepo(repo, repoRoot, options.commit ?? false);
-    });
+            results.push(fetchRepo(repo, repoRoot, remotes));
+        else if (command === "pull")
+            results.push(pullRepo(repo, repoRoot, remotes[0]));
+        else
+            results.push(pushRepo(repo, repoRoot, remotes, options.commit ?? false));
+    }
     if (results.length > 1 || options.all)
         printSummary(results);
     return exitFromResults(results);
@@ -650,6 +785,11 @@ async function runUnsync(aliases, options) {
     });
     if (results.length > 1 || options.all)
         printSummary(results);
+    // Name the failed aliases so a buried failure among several isn't read as "all unsynced".
+    const failed = picked.filter((_, i) => results[i] === "failed").map((r) => r.alias);
+    if (failed.length > 0) {
+        log.error(`Not unsynced: ${failed.join(", ")}. The submodule had uncommitted or untracked changes — commit/stash/remove them, or re-run with --force.`);
+    }
     return exitFromResults(results);
 }
 async function runCheckout(alias, branch, options) {
@@ -763,7 +903,9 @@ async function runStatus(aliases, options) {
 const INIT_TEMPLATE = `# yaml-language-server: $schema=https://raw.githubusercontent.com/divlook/oh-my-space/main/oms.schema.json
 repos:
   - alias: example
-    url: git@github.com:example/repo.git
+    remotes:
+      origin: git@github.com:example/repo.git
+      # upstream: git@github.com:upstream/repo.git
     branch: main
 `;
 /** 현재 디렉터리에 기본 oms.yaml 템플릿을 생성합니다. */
@@ -780,7 +922,7 @@ async function runInit(options) {
     if (!isGitRepo(process.cwd())) {
         log.info(`oms manages sources as git submodules; run "git init" here if this is not a git repo yet.`);
     }
-    log.info(`edit alias/url/branch, then run "oms sync".`);
+    log.info(`edit alias/remotes/branch, then run "oms sync".`);
     return 0;
 }
 async function runDoctor() {
@@ -857,6 +999,16 @@ function readPackageVersion() {
     const pkg = readJson(join(packageRoot, "package.json"));
     return pkg?.version ?? "0.0.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"));
+    return info?.commit ?? null;
+}
+/** Clickable GitHub permalink for a repo doc, pinned to the build commit; falls back to the version tag. */
+function docUrl(relPath) {
+    const ref = readBuildCommit() ?? `v${readPackageVersion()}`;
+    return `${DOCS_REPO_BLOB_BASE}/${ref}/${relPath}`;
+}
 async function exitWith(action) {
     try {
         process.exit(await action);
@@ -929,29 +1081,33 @@ program
     .action(async (alias, branch, options) => {
     await exitWith(runCheckout(alias, branch, options));
 });
+const collectRemote = (value, acc) => [...acc, value];
 program
     .command("fetch")
-    .description("Run git fetch origin --prune in each submodule.")
+    .description("Run git fetch <remote> --prune in each submodule (defaults to origin).")
     .argument("[aliases...]", "repo aliases to fetch (omit for interactive multi-select)")
     .option("--all", "fetch every registered source repo")
+    .option("--remote <name>", "remote to fetch (repeatable; omit to choose interactively)", collectRemote, [])
     .addHelpText("after", exitHelp)
     .action(async (aliases, options) => {
     await exitWith(runManage("fetch", aliases, options));
 });
 program
     .command("pull")
-    .description("Run git pull --ff-only on each submodule's current branch and stage the moved pointer.")
+    .description("Run git pull --ff-only <remote> on each submodule's current branch and stage the moved pointer (defaults to origin).")
     .argument("[aliases...]", "repo aliases to pull (omit for interactive multi-select)")
     .option("--all", "pull every registered source repo")
+    .option("--remote <name>", "remote to pull from (single; omit to choose interactively)", collectRemote, [])
     .addHelpText("after", exitHelp)
     .action(async (aliases, options) => {
     await exitWith(runManage("pull", aliases, options));
 });
 program
     .command("push")
-    .description("Run git push -u origin <branch> on each listed submodule (creating the remote branch on first push) and stage the moved pointer.")
+    .description("Run git push <remote> <branch> on each listed submodule (creating the remote branch on first push) and stage the moved pointer (defaults to origin).")
     .argument("<aliases...>", "repo aliases to push")
     .option("--commit", "also commit the pointer update in the parent repo")
+    .option("--remote <name>", "remote to push to (repeatable; omit to choose interactively)", collectRemote, [])
     .addHelpText("after", exitHelp)
     .action(async (aliases, options) => {
     await exitWith(runManage("push", aliases, options));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-space",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "CLI for managing external source repositories declared in oms.yaml.",
   "license": "MIT",
   "homepage": "https://github.com/divlook/oh-my-space",
@@ -35,7 +35,7 @@
     "node": ">=20.19.0"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && node -e \"require('node:fs').chmodSync('dist/oms.js', 0o755)\"",
+    "build": "tsc -p tsconfig.build.json && node -e \"require('node:fs').chmodSync('dist/oms.js', 0o755)\" && node scripts/gen-build-info.mjs",
     "test": "npm run build && node --test tests/*.test.js",
     "prepack": "npm test",
     "changeset": "changeset",