@quonfig/cli 0.0.45 → 0.0.46

package/dist/util/git-ops.d.ts

@@ -42,6 +42,15 @@ export declare const spawnGit: (args: string[], options?: SpawnGitOptions) => Pr
 export declare const gitClone: (repoUrl: string, dir: string) => Promise<void>;
 export declare const isGitRepo: (dir: string) => Promise<boolean>;
 export declare const getRemoteUrl: (dir: string) => Promise<string | null>;
+/**
+ * Return every configured remote URL (one per remote name). Walks the
+ * output of `git remote` and resolves each name's URL via `remote get-url`.
+ *
+ * Returns an empty array when the dir isn't a git repo or has no remotes.
+ * Multi-remote support (qfg-glrd.3): the identity check accepts as long as
+ * any configured remote points at the backend's repo URL.
+ */
+export declare const getAllRemoteUrls: (dir: string) => Promise<string[]>;
 export declare const isWorkingTreeClean: (dir: string) => Promise<boolean>;
 /**
  * Returns true if `file` (relative to `dir`) has any working-tree or

package/dist/util/git-ops.js

@@ -81,6 +81,44 @@ export const getRemoteUrl = async (dir) => {
         return null;
     }
 };
+/**
+ * Return every configured remote URL (one per remote name). Walks the
+ * output of `git remote` and resolves each name's URL via `remote get-url`.
+ *
+ * Returns an empty array when the dir isn't a git repo or has no remotes.
+ * Multi-remote support (qfg-glrd.3): the identity check accepts as long as
+ * any configured remote points at the backend's repo URL.
+ */
+export const getAllRemoteUrls = async (dir) => {
+    let names;
+    try {
+        const { stdout } = await runGit(['-C', dir, 'remote']);
+        names = stdout
+            .split('\n')
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+    const urls = [];
+    for (const name of names) {
+        try {
+            // Sequential by design: each `git remote get-url` spawns its own git
+            // process against the same repo; running them serially keeps git's
+            // index/lock access predictable and the remote count is tiny.
+            // eslint-disable-next-line no-await-in-loop
+            const { stdout } = await runGit(['-C', dir, 'remote', 'get-url', name]);
+            const url = stdout.trim();
+            if (url.length > 0)
+                urls.push(url);
+        }
+        catch {
+            /* skip remotes whose URL we can't read */
+        }
+    }
+    return urls;
+};
 export const isWorkingTreeClean = async (dir) => {
     const { stdout } = await runGit(['-C', dir, 'status', '--porcelain']);
     return stdout.trim() === '';

package/dist/util/resolve-workspace-dir.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Resolve the workspace directory for `qfg push` / `qfg pull`.
+ *
+ * Resolution order:
+ *   1. `--dir <path>` flag (explicit, wins everything)
+ *   2. `QUONFIG_DIR` env var
+ *   3. Walk up from cwd looking for `quonfig.json`. Stop at the first hit,
+ *      the user's home dir, or the filesystem root.
+ *   4. Error: `No Quonfig workspace dir found. ...`
+ *
+ * Pure — the caller wires `process.cwd()` and `process.env.QUONFIG_DIR` in.
+ * Tests drive the function with explicit values so the cwd walk can be
+ * exercised inside a tmp dir without `process.chdir`.
+ *
+ * Empty-string flag / env values are treated as "absent" because shells
+ * routinely emit `EXPORT_FOO=` when a var is declared but has no value;
+ * silently picking the empty string would resolve to cwd and produce a
+ * confusing wrong-target failure downstream.
+ */
+export declare const NO_WORKSPACE_DIR_ERROR = "No Quonfig workspace dir found. Run from inside a workspace, or pass --dir, or set QUONFIG_DIR.";
+export interface ResolveWorkspaceDirInput {
+    /** Current working directory — the search root for the walk. */
+    cwd: string;
+    /** Value of `QUONFIG_DIR` env var (or undefined). */
+    envDir: string | undefined;
+    /** Value of `--dir` flag (or undefined). */
+    flagDir: string | undefined;
+    /**
+     * The user's home directory. The cwd walk stops here (without checking
+     * it) so we never pick up a stray `quonfig.json` parked in `~`. Defaults
+     * to `os.homedir()` when omitted; tests pass an explicit value so they
+     * can pretend a tmp dir is "home".
+     */
+    homeDir?: string;
+}
+export type ResolveWorkspaceDirResult = {
+    kind: 'ok';
+    dir: string;
+    source: 'flag' | 'env' | 'cwd-walk';
+} | {
+    kind: 'error';
+    message: string;
+};
+export declare const resolveWorkspaceDir: (input: ResolveWorkspaceDirInput) => ResolveWorkspaceDirResult;

package/dist/util/resolve-workspace-dir.js

@@ -0,0 +1,61 @@
+/**
+ * Resolve the workspace directory for `qfg push` / `qfg pull`.
+ *
+ * Resolution order:
+ *   1. `--dir <path>` flag (explicit, wins everything)
+ *   2. `QUONFIG_DIR` env var
+ *   3. Walk up from cwd looking for `quonfig.json`. Stop at the first hit,
+ *      the user's home dir, or the filesystem root.
+ *   4. Error: `No Quonfig workspace dir found. ...`
+ *
+ * Pure — the caller wires `process.cwd()` and `process.env.QUONFIG_DIR` in.
+ * Tests drive the function with explicit values so the cwd walk can be
+ * exercised inside a tmp dir without `process.chdir`.
+ *
+ * Empty-string flag / env values are treated as "absent" because shells
+ * routinely emit `EXPORT_FOO=` when a var is declared but has no value;
+ * silently picking the empty string would resolve to cwd and produce a
+ * confusing wrong-target failure downstream.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+const QUONFIG_JSON = 'quonfig.json';
+export const NO_WORKSPACE_DIR_ERROR = 'No Quonfig workspace dir found. Run from inside a workspace, or pass --dir, or set QUONFIG_DIR.';
+const blank = (s) => s === undefined || s === '';
+export const resolveWorkspaceDir = (input) => {
+    if (!blank(input.flagDir)) {
+        return { kind: 'ok', dir: path.resolve(input.cwd, input.flagDir), source: 'flag' };
+    }
+    if (!blank(input.envDir)) {
+        return { kind: 'ok', dir: path.resolve(input.cwd, input.envDir), source: 'env' };
+    }
+    const homeDir = input.homeDir ?? os.homedir();
+    const found = walkUpForWorkspace(input.cwd, homeDir);
+    if (found !== undefined) {
+        return { kind: 'ok', dir: found, source: 'cwd-walk' };
+    }
+    return { kind: 'error', message: NO_WORKSPACE_DIR_ERROR };
+};
+/**
+ * Walk from `start` toward the filesystem root, returning the first ancestor
+ * dir that contains a `quonfig.json`. Stops without checking when the walk
+ * reaches `homeDir` or the filesystem root — `~` is not a workspace.
+ */
+const walkUpForWorkspace = (start, homeDir) => {
+    let current = path.resolve(start);
+    // Normalize homeDir the same way so the equality check survives a
+    // trailing slash or symlink-resolved path on the caller's side.
+    const stop = path.resolve(homeDir);
+    // Walk up until the filesystem root: path.dirname() of the root is the
+    // root itself, so `parent === current` is the terminal condition.
+    for (let parent = path.dirname(current);; current = parent, parent = path.dirname(current)) {
+        if (current === stop)
+            return undefined;
+        if (fs.existsSync(path.join(current, QUONFIG_JSON))) {
+            return current;
+        }
+        if (parent === current)
+            return undefined;
+    }
+};

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "0.0.45";
+declare const _default: "0.0.46";
 export default _default;

package/dist/version.js

@@ -1,2 +1,2 @@
 // AUTO-GENERATED from package.json by scripts/generate-version.mjs — do not edit.
-export default '0.0.45';
+export default '0.0.46';