@quonfig/cli 0.0.1 → 0.0.4

package/dist/commands/pull.js

@@ -0,0 +1,176 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../index.js';
+import { getActiveProfile, loadAuthConfig } from '../util/token-storage.js';
+import { loadGiteaToken, isGiteaTokenExpired, saveGiteaToken } from '../util/gitea-token-storage.js';
+import { mintAndStoreGiteaReadToken, mintGiteaToken } from '../util/gitea-api.js';
+import { isGitRepo, getRemoteUrl, isWorkingTreeClean, gitFetch, gitSetRemote, canFastForward, hasDivergedFromRemote, gitMergeFfOnly, gitClone, displayUrl, } from '../util/git-ops.js';
+export default class Pull extends BaseCommand {
+    static description = 'Clone or update a local directory from the workspace Gitea repo';
+    static examples = [
+        '<%= config.bin %> pull --dir ./our-config',
+        '<%= config.bin %> pull  # uses QUONFIG_DIR env var',
+    ];
+    static flags = {
+        dir: Flags.string({
+            description: 'Local directory to clone/update (defaults to QUONFIG_DIR env var)',
+        }),
+        workspace: Flags.string({
+            description: 'Workspace ID (defaults to active profile)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Pull);
+        // Resolve target directory
+        const dir = flags.dir || process.env.QUONFIG_DIR;
+        if (!dir) {
+            return this.err('No directory specified. Use --dir <path> or set QUONFIG_DIR.');
+        }
+        const resolvedDir = path.resolve(dir);
+        // Resolve workspace ID
+        let workspaceId = flags.workspace;
+        if (!workspaceId) {
+            const authConfig = await loadAuthConfig();
+            if (!authConfig) {
+                return this.err('Not logged in. Please run `qfg login` first.');
+            }
+            const activeProfile = getActiveProfile();
+            const profile = authConfig.profiles[activeProfile] || authConfig.profiles[authConfig.defaultProfile || 'default'];
+            if (!profile) {
+                return this.err('No active profile found. Please run `qfg login` first.');
+            }
+            workspaceId = profile.workspace;
+        }
+        this.verboseLog('Pull', { workspaceId, dir: resolvedDir });
+        // Get or mint Gitea read token
+        const repoUrl = await this.resolveRepoUrl(workspaceId);
+        // Perform git operation
+        const isRepo = await isGitRepo(resolvedDir);
+        if (!isRepo) {
+            // Clone fresh
+            this.log(`Cloning workspace into ${resolvedDir}...`);
+            try {
+                await gitClone(repoUrl, resolvedDir);
+            }
+            catch (err) {
+                // On 401, refresh token and retry once
+                if (this.looksLike401(err)) {
+                    this.verboseLog('Pull', 'Got 401, refreshing Gitea token...');
+                    const freshUrl = await this.refreshAndGetUrl(workspaceId);
+                    await gitClone(freshUrl, resolvedDir);
+                }
+                else {
+                    throw err;
+                }
+            }
+            this.log(`Cloned successfully into ${resolvedDir}`);
+        }
+        else {
+            // Existing repo — check remote
+            const existingRemote = await getRemoteUrl(resolvedDir);
+            const expectedUrlBase = stripAuth(repoUrl);
+            if (existingRemote && stripAuth(existingRemote) !== expectedUrlBase) {
+                return this.err(`Directory has a different git remote:\n  existing: ${displayUrl(existingRemote)}\n  expected: ${expectedUrlBase}\n\nResolve manually or use a different --dir.`);
+            }
+            // Update the remote URL to use current (possibly refreshed) token
+            await gitSetRemote(resolvedDir, repoUrl);
+            // Check working tree
+            const clean = await isWorkingTreeClean(resolvedDir);
+            if (!clean) {
+                return this.err('Local changes present — commit, stash, or run `git reset --hard origin/main` to discard.');
+            }
+            // Fetch
+            this.log('Fetching from remote...');
+            try {
+                await gitFetch(resolvedDir);
+            }
+            catch (err) {
+                if (this.looksLike401(err)) {
+                    this.verboseLog('Pull', 'Got 401 on fetch, refreshing Gitea token...');
+                    const freshUrl = await this.refreshAndGetUrl(workspaceId);
+                    await gitSetRemote(resolvedDir, freshUrl);
+                    await gitFetch(resolvedDir);
+                }
+                else {
+                    throw err;
+                }
+            }
+            const ff = await canFastForward(resolvedDir);
+            const diverged = !ff && (await hasDivergedFromRemote(resolvedDir));
+            if (diverged) {
+                return this.err('Local commits diverge from remote — resolve manually.');
+            }
+            if (!ff) {
+                this.log('Already up to date.');
+                return { dir: resolvedDir, newCommits: [], workspaceId };
+            }
+            // Merge
+            const newCommits = await gitMergeFfOnly(resolvedDir);
+            if (newCommits.length > 0) {
+                this.log(`Pulled ${newCommits.length} new commit(s):`);
+                for (const msg of newCommits) {
+                    this.log(`  - ${msg}`);
+                }
+            }
+            else {
+                this.log('Updated successfully.');
+            }
+        }
+        // Write QUONFIG_DIR to ~/.quonfig/config if not set
+        await this.maybeWriteQuonfigDir(resolvedDir);
+        return { dir: resolvedDir, workspaceId };
+    }
+    async resolveRepoUrl(workspaceId) {
+        let entry = await loadGiteaToken(workspaceId);
+        if (!entry || isGiteaTokenExpired(entry)) {
+            this.verboseLog('Pull', 'Minting new Gitea read token...');
+            entry = await mintAndStoreGiteaReadToken(workspaceId);
+        }
+        return entry.repoUrl;
+    }
+    async refreshAndGetUrl(workspaceId) {
+        const data = await mintGiteaToken(workspaceId, 'read', 'pull');
+        const entry = { token: data.token, repoUrl: data.repoUrl, expiresAt: data.expiresAt };
+        await saveGiteaToken(workspaceId, entry);
+        return entry.repoUrl;
+    }
+    looksLike401(err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return msg.includes('401') || msg.toLowerCase().includes('authentication failed');
+    }
+    async maybeWriteQuonfigDir(dir) {
+        if (process.env.QUONFIG_DIR)
+            return; // already set via env
+        const os = await import('node:os');
+        const pathMod = await import('node:path');
+        const configFilePath = pathMod.join(os.homedir(), '.quonfig', 'config');
+        try {
+            const existing = await fs.promises.readFile(configFilePath, 'utf8').catch(() => '');
+            if (existing.includes('QUONFIG_DIR') || existing.includes('quonfig_dir'))
+                return;
+            const line = `\nQUONFIG_DIR = ${dir}\n`;
+            await fs.promises.appendFile(configFilePath, line, 'utf8');
+            this.verboseLog('Pull', `Wrote QUONFIG_DIR to ${configFilePath}`);
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+}
+/**
+ * Strip auth credentials from a git URL for comparison purposes.
+ * Converts `https://user:token@host/path` to `https://host/path`.
+ */
+function stripAuth(url) {
+    try {
+        const u = new URL(url);
+        u.username = '';
+        u.password = '';
+        return u.toString();
+    }
+    catch {
+        // Not a valid URL (e.g. SSH) — return as-is
+        return url;
+    }
+}

package/dist/commands/serve.js

@@ -47,7 +47,9 @@ export default class Serve extends BaseCommand {
         }
         catch (error_) {
             const error = error_;
-            if (/No projectEnvId found in config/.test(error.message) || /Unexpected end of JSON input/.test(error.message)) {
+            if (/No projectEnvId found in config/.test(error.message) ||
+                /is not iterable/.test(error.message) ||
+                /Unexpected end of JSON input/.test(error.message)) {
                 return this.error(`${error.message}\nYour download file seems invalid or corrupt. Please redownload your datafile.`);
             }
             return this.error(error);

package/dist/commands/sync.d.ts

@@ -0,0 +1,18 @@
+import type { JsonObj } from '../result.js';
+import { BaseCommand } from '../index.js';
+export default class Sync extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        dir: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        interval: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        watch: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    private workspaceId;
+    private resolvedDir;
+    run(): Promise<JsonObj | void>;
+    private runSync;
+    private ensureRemoteUrl;
+    private refreshToken;
+    private looksLike401;
+}

package/dist/commands/sync.js

@@ -0,0 +1,142 @@
+import * as path from 'node:path';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../index.js';
+import { getActiveProfile, loadAuthConfig } from '../util/token-storage.js';
+import { loadGiteaToken, isGiteaTokenExpired, saveGiteaToken } from '../util/gitea-token-storage.js';
+import { mintGiteaToken } from '../util/gitea-api.js';
+import { isGitRepo, isWorkingTreeClean, gitFetch, canFastForward, hasDivergedFromRemote, gitMergeFfOnly, gitSetRemote, } from '../util/git-ops.js';
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export default class Sync extends BaseCommand {
+    static description = 'Continuously poll for workspace config updates and apply them locally';
+    static examples = [
+        '<%= config.bin %> sync --watch',
+        '<%= config.bin %> sync --watch --interval 10',
+        '<%= config.bin %> sync --watch --dir ./our-config --interval 30',
+    ];
+    static flags = {
+        dir: Flags.string({
+            description: 'Local directory to sync (defaults to QUONFIG_DIR env var)',
+        }),
+        interval: Flags.integer({
+            default: 60,
+            description: 'Poll interval in seconds',
+        }),
+        watch: Flags.boolean({
+            description: 'Run as a continuous polling daemon (required)',
+            required: true,
+        }),
+    };
+    workspaceId;
+    resolvedDir;
+    async run() {
+        const { flags } = await this.parse(Sync);
+        // Resolve directory
+        const dir = flags.dir || process.env.QUONFIG_DIR;
+        if (!dir) {
+            return this.err('No directory specified. Use --dir <path> or set QUONFIG_DIR.');
+        }
+        this.resolvedDir = path.resolve(dir);
+        // Resolve workspace ID
+        const authConfig = await loadAuthConfig();
+        if (!authConfig) {
+            return this.err('Not logged in. Please run `qfg login` first.');
+        }
+        const activeProfile = getActiveProfile();
+        const profile = authConfig.profiles[activeProfile] || authConfig.profiles[authConfig.defaultProfile || 'default'];
+        if (!profile) {
+            return this.err('No active profile found. Please run `qfg login` first.');
+        }
+        this.workspaceId = profile.workspace;
+        // Validate the directory is a git repo
+        const isRepo = await isGitRepo(this.resolvedDir);
+        if (!isRepo) {
+            return this.err(`${this.resolvedDir} is not a git repository. Run \`qfg pull --dir ${this.resolvedDir}\` first.`);
+        }
+        const intervalSec = flags.interval;
+        this.log(`Watching ${this.resolvedDir} — polling every ${intervalSec}s. Press Ctrl+C to stop.`);
+        // Ensure remote URL is up to date before starting
+        await this.ensureRemoteUrl();
+        // Run initial sync
+        await this.runSync();
+        // Poll loop
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            await sleep(intervalSec * 1000);
+            await this.runSync();
+        }
+    }
+    async runSync() {
+        const timestamp = new Date().toISOString();
+        try {
+            // Ensure token is valid
+            await this.ensureRemoteUrl();
+            // Fetch
+            this.verboseLog('Sync', 'Fetching...');
+            await gitFetch(this.resolvedDir);
+            // Check if there's anything to do
+            const ff = await canFastForward(this.resolvedDir);
+            if (!ff) {
+                // Check if diverged
+                const diverged = await hasDivergedFromRemote(this.resolvedDir);
+                if (diverged) {
+                    this.log(`[${timestamp}] Skipped: local commits diverge from remote. Resolve manually.`);
+                    return;
+                }
+                this.log(`[${timestamp}] Already up to date.`);
+                return;
+            }
+            // Check working tree
+            const clean = await isWorkingTreeClean(this.resolvedDir);
+            if (!clean) {
+                this.log(`[${timestamp}] Skipped: local changes present. Commit or stash first.`);
+                return;
+            }
+            // Merge
+            const newCommits = await gitMergeFfOnly(this.resolvedDir);
+            if (newCommits.length > 0) {
+                this.log(`[${timestamp}] Pulled ${newCommits.length} new commit(s):`);
+                for (const msg of newCommits) {
+                    this.log(`  - ${msg}`);
+                }
+            }
+            else {
+                this.log(`[${timestamp}] Updated.`);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (this.looksLike401(err)) {
+                this.log(`[${timestamp}] Token expired, refreshing...`);
+                try {
+                    await this.refreshToken();
+                    await this.ensureRemoteUrl();
+                }
+                catch (refreshErr) {
+                    this.log(`[${timestamp}] Warning: could not refresh token: ${String(refreshErr)}`);
+                }
+            }
+            else {
+                this.log(`[${timestamp}] Warning: sync failed: ${msg}`);
+            }
+        }
+    }
+    async ensureRemoteUrl() {
+        const entry = await loadGiteaToken(this.workspaceId);
+        if (!entry || isGiteaTokenExpired(entry)) {
+            await this.refreshToken();
+            return;
+        }
+        await gitSetRemote(this.resolvedDir, entry.repoUrl);
+    }
+    async refreshToken() {
+        const data = await mintGiteaToken(this.workspaceId, 'read', 'pull');
+        const entry = { token: data.token, repoUrl: data.repoUrl, expiresAt: data.expiresAt };
+        await saveGiteaToken(this.workspaceId, entry);
+        await gitSetRemote(this.resolvedDir, entry.repoUrl);
+        this.verboseLog('Sync', 'Token refreshed.');
+    }
+    looksLike401(err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return msg.includes('401') || msg.toLowerCase().includes('authentication failed');
+    }
+}

package/dist/commands/whoami.js

@@ -38,7 +38,10 @@ export default class Whoami extends BaseCommand {
         // Display user information
         this.log(`Logged in as: ${userEmail || 'Unknown'}`);
         this.log(`Active profile: ${activeProfile}`);
-        this.log(`Active workspace: ${profile.workspaceName || profile.workspace}`);
+        const workspaceDisplay = profile.workspaceName
+            ? `${profile.workspaceName} (${profile.workspace})`
+            : profile.workspace;
+        this.log(`Active workspace: ${workspaceDisplay}`);
         return {
             email: userEmail,
             loggedIn: true,

package/dist/commands/workspace/bootstrap.d.ts

@@ -0,0 +1,13 @@
+import type { JsonObj } from '../../result.js';
+import { BaseCommand } from '../../index.js';
+export default class WorkspaceBootstrap extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        dir: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'skip-validate': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<JsonObj | void>;
+    private remoteHasCommits;
+}

package/dist/commands/workspace/bootstrap.js

@@ -0,0 +1,155 @@
+import * as path from 'node:path';
+import { confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../index.js';
+import { getActiveProfile, loadAuthConfig } from '../../util/token-storage.js';
+import { mintGiteaToken } from '../../util/gitea-api.js';
+import { isGitRepo, hasAtLeastOneCommit, gitSetRemote, gitPushForceLease, gitPushForce, getRemoteUrl, displayUrl, } from '../../util/git-ops.js';
+export default class WorkspaceBootstrap extends BaseCommand {
+    static description = 'Push a local git repo to Gitea as this workspace\'s config repository';
+    static examples = [
+        '<%= config.bin %> workspace bootstrap --dir ./our-config',
+        '<%= config.bin %> workspace bootstrap --dir ./launch-migrator/output',
+        '<%= config.bin %> workspace bootstrap --dir ./our-config --skip-validate',
+    ];
+    static flags = {
+        dir: Flags.string({
+            description: 'Local directory to push (defaults to current directory)',
+            required: false,
+        }),
+        force: Flags.boolean({
+            default: false,
+            description: 'Force push even if remote already has commits',
+        }),
+        'skip-validate': Flags.boolean({
+            default: false,
+            description: 'Skip config validation before pushing',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkspaceBootstrap);
+        // Resolve target directory
+        const dir = flags.dir || process.env.QUONFIG_DIR || process.cwd();
+        const resolvedDir = path.resolve(dir);
+        // Load auth
+        const authConfig = await loadAuthConfig();
+        if (!authConfig) {
+            return this.err('Not logged in. Run `qfg login` first.');
+        }
+        const activeProfile = getActiveProfile();
+        const profile = authConfig.profiles[activeProfile] || authConfig.profiles[authConfig.defaultProfile || 'default'];
+        if (!profile) {
+            return this.err('No active profile found. Run `qfg login` first.');
+        }
+        const workspaceId = profile.workspace;
+        const workspaceName = profile.workspaceSlug || profile.workspaceName || workspaceId;
+        this.verboseLog('WorkspaceBootstrap', { workspaceId, dir: resolvedDir });
+        // Validate: must be a git repo with at least one commit
+        const isRepo = await isGitRepo(resolvedDir);
+        if (!isRepo) {
+            return this.err(`${resolvedDir} is not a git repository.\nInitialize it with \`git init\` and commit your config files first.`);
+        }
+        const hasCommit = await hasAtLeastOneCommit(resolvedDir);
+        if (!hasCommit) {
+            return this.err(`${resolvedDir} has no commits. Commit your config files first.`);
+        }
+        // Verify config before doing anything
+        if (!flags['skip-validate']) {
+            this.log('Verifying config files...');
+            try {
+                const { validateWorkspace } = await import('../../verify/validate.js');
+                const result = validateWorkspace(resolvedDir);
+                const errors = result.issues.filter((i) => i.severity === 'error');
+                if (errors.length > 0) {
+                    this.log(`\nFound ${errors.length} validation error(s):\n`);
+                    for (const issue of errors) {
+                        this.log(`  ${issue.message}`);
+                    }
+                    this.log('\nFix the errors above or run with --skip-validate to bypass.');
+                    return this.err('Validation failed.');
+                }
+                this.log('Validation passed.\n');
+            }
+            catch (err) {
+                this.verboseLog('Validation error', String(err));
+                this.log('Warning: could not run validation. Proceeding anyway.');
+                this.log('Use --skip-validate to suppress this warning.\n');
+            }
+        }
+        // Confirmation prompt
+        const existingRemote = await getRemoteUrl(resolvedDir);
+        this.log(`Directory:  ${resolvedDir}`);
+        this.log(`Workspace:  ${workspaceName}`);
+        if (existingRemote) {
+            this.log(`Remote:     ${displayUrl(existingRemote)} (will be updated)`);
+        }
+        this.log('');
+        const confirmed = await confirm({
+            message: `Push ${path.basename(resolvedDir)} to workspace "${workspaceName}"?`,
+            default: false,
+        });
+        if (!confirmed) {
+            this.log('Aborted.');
+            return;
+        }
+        this.log('');
+        // Mint write token (backend provisions Gitea repo + bot account)
+        this.log('Connecting to Gitea...');
+        let tokenData;
+        try {
+            tokenData = await mintGiteaToken(workspaceId, 'write', 'bootstrap');
+        }
+        catch (err) {
+            return this.err(`Could not get Gitea credentials: ${String(err)}\n\nMake sure the workspace is fully provisioned in the Quonfig app before bootstrapping.`);
+        }
+        const { repoUrl } = tokenData;
+        this.verboseLog('WorkspaceBootstrap', { repoUrl: displayUrl(repoUrl) });
+        // Idempotency: check if remote already has commits
+        if (!flags.force) {
+            const remoteHasCommits = await this.remoteHasCommits(repoUrl);
+            if (remoteHasCommits) {
+                this.log(`\nThe remote repository already has commits.`);
+                this.log(`Run \`qfg pull --dir ${resolvedDir}\` to sync, then re-run bootstrap.`);
+                this.log(`Or run with --force to overwrite the remote.\n`);
+                return this.err('Remote is not empty.');
+            }
+        }
+        // Set remote
+        if (existingRemote) {
+            this.log(`Updating remote origin...`);
+        }
+        else {
+            this.log(`Setting remote origin...`);
+        }
+        await gitSetRemote(resolvedDir, repoUrl);
+        // Push
+        this.log('Pushing to Gitea...');
+        try {
+            if (flags.force) {
+                await gitPushForce(resolvedDir);
+            }
+            else {
+                await gitPushForceLease(resolvedDir);
+            }
+        }
+        catch (err) {
+            return this.err(`Push failed: ${String(err)}`);
+        }
+        this.log(`\nBootstrap complete.`);
+        this.log(`Workspace "${workspaceName}" is now connected to your local directory.`);
+        this.log(`\nTo keep it in sync locally, run:`);
+        this.log(`  qfg sync --watch --dir ${resolvedDir}`);
+        return {
+            dir: resolvedDir,
+            repoUrl: displayUrl(repoUrl),
+            workspaceId,
+        };
+    }
+    async remoteHasCommits(repoUrl) {
+        const { execFile: execFileCb } = await import('node:child_process');
+        const util = await import('node:util');
+        const execFile = util.promisify(execFileCb);
+        const { stdout } = await execFile('git', ['ls-remote', '--heads', repoUrl]);
+        return stdout.trim().length > 0;
+    }
+}

package/dist/init/init-workspace.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Core logic for `qfg init`.
+ *
+ * Uses a plan/execute pattern so --dry-run can show what *would* happen
+ * without writing anything.
+ */
+export interface InitOptions {
+    dir: string;
+    /** true = force include samples, false = force skip, undefined = auto-detect */
+    samples: boolean | undefined;
+    dryRun: boolean;
+}
+export type ActionKind = 'git-init' | 'create-dir' | 'write-file' | 'skip-file' | 'create-hook' | 'update-hook' | 'skip-hook';
+export interface InitAction {
+    kind: ActionKind;
+    path: string;
+    description: string;
+}
+export interface InitPlan {
+    actions: InitAction[];
+    isFirstTime: boolean;
+    samplesIncluded: boolean;
+}
+export declare function planInit(options: InitOptions): InitPlan;
+export declare function executeInit(plan: InitPlan, dir: string): void;