@quonfig/cli 0.0.2 → 0.0.5

package/dist/commands/set-default.js

@@ -14,12 +14,29 @@ import nameArg from '../util/name-arg.js';
 import secretFlags, { parsedSecretFlags } from '../util/secret-flags.js';
 export default class SetDefault extends APICommand {
     static args = { ...nameArg };
-    static description = 'Set/update the default value for an environment (other rules still apply)';
+    static description = `Set the unconditional fallback value for a flag or config in a specific environment.
+
+This updates the catch-all rule — the value users receive when NO targeting rule matches.
+Any targeting rules or percentage rollouts you have configured are NOT affected; they
+continue to fire before this fallback is evaluated.
+
+"Other rules still apply" means: if you have rules targeting specific users, segments,
+or properties, those rules still take priority. This command only changes what everyone
+else sees.
+
+To set a percentage rollout (gradual rollout / A/B test / canary deploy) instead:
+  qfg set-rollout my.flag --environment production --true-percent 20
+
+To see all current values and rules for a flag:
+  qfg info my.flag`;
     static examples = [
-        '<%= config.bin %> <%= command.id %> my.flag.name # will prompt for value and env',
+        '<%= config.bin %> <%= command.id %> my.flag.name                                          # prompts for value and env',
         '<%= config.bin %> <%= command.id %> my.flag.name --value=true --environment=staging',
+        '<%= config.bin %> <%= command.id %> my.flag.name --value=false --environment=production   # kill-switch: turn off for everyone',
         '<%= config.bin %> <%= command.id %> my.flag.name --value=true --secret',
         '<%= config.bin %> <%= command.id %> my.config.name --env-var=MY_ENV_VAR_NAME --environment=production',
+        '# For a percentage rollout, use set-rollout instead:',
+        '<%= config.bin %> set-rollout my.flag.name --environment production --true-percent 20',
     ];
     static flags = {
         confidential: Flags.boolean({ default: false, description: 'mark the value as confidential' }),
@@ -123,7 +140,6 @@ export default class SetDefault extends APICommand {
                 config,
                 envVar: flags['env-var'],
                 environment,
-                environmentId: environment.id,
                 key,
                 secret,
             });
@@ -147,13 +163,12 @@ export default class SetDefault extends APICommand {
             confidential,
             config,
             environment,
-            environmentId: environment.id,
             key,
             secret,
             value,
         });
     }
-    async submitChange({ confidential, config, envVar, environment, environmentId, key, secret, value, }) {
+    async submitChange({ confidential, config, envVar, environment, key, secret, value, }) {
         /* eslint-disable camelcase */
         const typeMapping = {
             bool: 'bool',
@@ -174,7 +189,7 @@ export default class SetDefault extends APICommand {
             successMessage = `Successfully changed default to \`${value}\``;
             if (secret.selected) {
                 // Handle encrypted values using shared utility
-                const encryptedValueResult = await makeConfidentialValue(this, value, secret, environmentId);
+                const encryptedValueResult = await makeConfidentialValue(this, value, secret, environment.id);
                 if (!encryptedValueResult.ok) {
                     return this.err(encryptedValueResult.message || 'Failed to encrypt value');
                 }
@@ -244,19 +259,67 @@ export default class SetDefault extends APICommand {
             configValue.confidential = true;
             successMessage += ' (confidential)';
         }
-        const payload = {
-            configKey: key,
-            currentVersionId: config.version,
-            environmentId: environmentId ? Number.parseInt(environmentId, 10) : 0,
-            value: configValue,
-        };
-        this.verboseLog('Payload:', payload);
-        const request = await this.apiClient.post('/internal/ops/v1/set-default', payload);
+        // Fetch the current full config to get the existing environments array and commitSha.
+        const detailRequest = await this.apiClient.post('/api/v1/metadata/getByKey', {
+            workspaceId: this.workspaceId,
+            key,
+        });
+        if (!detailRequest.ok) {
+            return this.err(`Failed to fetch config details: ${detailRequest.status}`);
+        }
+        const currentConfig = detailRequest.json;
+        // Build a single catch-all rule (empty criteria = matches everything).
+        const newRule = { criteria: [], value: configValue };
+        // For [Default] (environment.id === ''), update default.rules.
+        // For a specific environment, update the environments array.
+        let updateFields;
+        if (environment.id === '') {
+            // [Default] — no environment-specific block, update the catch-all default rules.
+            updateFields = { default: { rules: [newRule] } };
+        }
+        else {
+            // environment.name is the slug stored in git files (e.g. "production").
+            // environment.id is the DB UUID — never written to git files.
+            const envKey = environment.name;
+            const existingEnvs = currentConfig.environments ?? [];
+            const hasEnv = existingEnvs.some((e) => e.id === envKey);
+            const updatedEnvironments = hasEnv
+                ? existingEnvs.map((e) => (e.id === envKey ? { ...e, rules: [newRule] } : e))
+                : [...existingEnvs, { id: envKey, rules: [newRule] }];
+            updateFields = { environments: updatedEnvironments };
+        }
+        this.verboseLog('Update fields:', JSON.stringify(updateFields, null, 2));
+        // Route to the correct update endpoint based on config type.
+        let request;
+        if (config.type === 'feature_flag') {
+            request = await this.apiClient.post('/api/v1/flags/update', {
+                workspaceId: this.workspaceId,
+                flagKey: key,
+                flag: updateFields,
+                expectedCommitSha: currentConfig.commitSha,
+            });
+        }
+        else if (config.type === 'log_level') {
+            request = await this.apiClient.post('/api/v1/logLevels/update', {
+                workspaceId: this.workspaceId,
+                logLevelKey: key,
+                logLevel: updateFields,
+                expectedCommitSha: currentConfig.commitSha,
+            });
+        }
+        else {
+            request = await this.apiClient.post('/api/v1/configs/update', {
+                workspaceId: this.workspaceId,
+                configKey: key,
+                config: updateFields,
+                expectedCommitSha: currentConfig.commitSha,
+            });
+        }
         if (request.ok) {
             this.log(`${checkmark} ${successMessage}`);
             return {
                 environment: {
-                    id: environmentId,
+                    id: environment.id,
                     name: environment.name,
                 },
                 key,

package/dist/commands/set-rollout.d.ts

@@ -0,0 +1,19 @@
+import { APICommand } from '../index.js';
+import { JsonObj } from '../result.js';
+export default class SetRollout extends APICommand {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        environment: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'hash-by': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'true-percent': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        weights: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        confirm: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<JsonObj | void>;
+    private parseWeights;
+    private coerceValue;
+}

package/dist/commands/set-rollout.js

@@ -0,0 +1,260 @@
+import { Flags } from '@oclif/core';
+import { APICommand } from '../index.js';
+import getConfirmation from '../ui/get-confirmation.js';
+import getEnvironment from '../ui/get-environment.js';
+import { checkmark } from '../util/color.js';
+import isInteractive from '../util/is-interactive.js';
+import nameArg from '../util/name-arg.js';
+const WEIGHT_TOTAL = 100_000;
+export default class SetRollout extends APICommand {
+    static args = { ...nameArg };
+    static description = `Configure a percentage rollout (gradual rollout / A/B test / canary deploy) for a flag.
+
+The flag must already exist. Create it first if needed:
+  qfg create my.flag --type boolean-flag
+
+Weights are specified as whole-number percentages (0–100). They must sum to 100.
+
+For a boolean flag, use --true-percent to set the percentage of users that receive
+true (the remainder automatically receive false):
+  qfg set-rollout my.flag --environment production --true-percent 20
+  → 20% of users get true, 80% get false
+
+For multi-value flags or custom splits, use --weights with a comma-separated list:
+  qfg set-rollout my.flag --environment production --weights "red:33,green:33,blue:34"
+
+Hashing: users are bucketed by the value of hashByPropertyName (default: "user.key").
+Use --hash-by to change which property drives the bucket assignment:
+  qfg set-rollout my.flag --environment production --true-percent 10 --hash-by user.id
+
+For scripted / agent use, add --confirm to skip the interactive confirmation prompt.
+
+To combine a rollout with segment targeting (e.g. beta ON, holdout OFF, everyone else 50/50),
+you need to edit the JSON config file directly:
+  qfg config-schema           # operator reference + worked multi-rule example
+  qfg pull --dir ./config     # clone workspace to edit
+
+To revert to a single value for everyone, use:
+  qfg set-default my.flag --environment production --value false
+
+To inspect the current rollout:
+  qfg info my.flag`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my.feature.flag --environment production --true-percent 20',
+        '<%= config.bin %> <%= command.id %> my.feature.flag --environment staging --true-percent 50',
+        '<%= config.bin %> <%= command.id %> my.feature.flag --environment production --true-percent 100  # full rollout',
+        '<%= config.bin %> <%= command.id %> my.feature.flag --environment production --true-percent 0    # kill switch (all false)',
+        '<%= config.bin %> <%= command.id %> my.variant.flag --environment production --weights "control:50,treatment:50"',
+        '<%= config.bin %> <%= command.id %> my.variant.flag --environment production --weights "a:33,b:33,c:34" --hash-by user.id',
+    ];
+    static flags = {
+        environment: Flags.string({ description: 'environment to update (e.g. production, staging)' }),
+        'hash-by': Flags.string({
+            default: 'user.key',
+            description: 'user property used to assign buckets (default: user.key)',
+        }),
+        'true-percent': Flags.integer({
+            description: 'percentage of users that receive true (0–100). Remaining users receive false. Boolean flags only.',
+            max: 100,
+            min: 0,
+        }),
+        weights: Flags.string({
+            description: 'comma-separated "value:percent" pairs that must sum to 100 (e.g. "true:20,false:80" or "red:33,green:33,blue:34")',
+        }),
+        confirm: Flags.boolean({ description: 'skip the interactive confirmation prompt (useful for scripts and agents)' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SetRollout);
+        // Validate flag exclusivity
+        if (flags['true-percent'] !== undefined && flags.weights) {
+            return this.err('Use either --true-percent or --weights, not both.');
+        }
+        if (flags['true-percent'] === undefined && !flags.weights) {
+            return this.err('Either --true-percent or --weights is required.');
+        }
+        // Validate required args for non-interactive mode
+        if (!args.name && !isInteractive(flags)) {
+            return this.err("'name' argument is required when interactive mode isn't available.");
+        }
+        if (!flags.environment && !isInteractive(flags)) {
+            return this.err("'environment' is required when interactive mode isn't available.");
+        }
+        // Fetch config metadata to validate the key exists
+        const metadataRequest = await this.apiClient.post('/api/v1/metadata/list', { workspaceId: this.workspaceId });
+        if (!metadataRequest.ok) {
+            const errorMsg = metadataRequest.error?.error || `Failed to fetch configs: ${metadataRequest.status}`;
+            return this.err(errorMsg, { serverError: metadataRequest.error });
+        }
+        const metadataResponse = metadataRequest.json;
+        const configs = metadataResponse.configs;
+        let key = args.name;
+        if (!key && isInteractive(flags)) {
+            const { default: autocomplete } = await import('../util/autocomplete.js');
+            const selected = await autocomplete({
+                message: 'Which flag would you like to configure a rollout for?',
+                source: configs.map((c) => c.key),
+            });
+            if (selected)
+                key = selected;
+        }
+        if (!key) {
+            return this.err("'name' argument is required when interactive mode isn't available.");
+        }
+        const config = configs.find((c) => c.key === key);
+        if (!config) {
+            return this.err(`Could not find config named ${key}`);
+        }
+        // Get environment
+        const environment = await getEnvironment({
+            command: this,
+            flags,
+            message: 'Which environment would you like to configure the rollout for?',
+            providedEnvironment: flags.environment,
+        });
+        if (!environment)
+            return;
+        // Build weighted values
+        let weightedValues;
+        if (flags['true-percent'] !== undefined) {
+            const truePercent = flags['true-percent'];
+            const falsePercent = 100 - truePercent;
+            weightedValues = [
+                { value: { type: 'bool', value: true }, weight: truePercent * (WEIGHT_TOTAL / 100) },
+                { value: { type: 'bool', value: false }, weight: falsePercent * (WEIGHT_TOTAL / 100) },
+            ];
+        }
+        else {
+            // Parse --weights "value1:N,value2:M,..."
+            const parsed = this.parseWeights(flags.weights, config.valueType);
+            if (!parsed.ok) {
+                return this.err(parsed.error);
+            }
+            weightedValues = parsed.weights;
+        }
+        const totalWeight = weightedValues.reduce((sum, wv) => sum + wv.weight, 0);
+        if (totalWeight !== WEIGHT_TOTAL) {
+            return this.err(`Weights must sum to 100. Got: ${weightedValues.map((wv) => `${wv.weight / 1000}%`).join(' + ')} = ${totalWeight / 1000}%`);
+        }
+        const rolloutValue = {
+            type: 'weighted_values',
+            value: {
+                hashByPropertyName: flags['hash-by'],
+                weightedValues,
+            },
+        };
+        const rolloutDescription = weightedValues
+            .map((wv) => `${wv.weight / 1000}% → ${JSON.stringify(wv.value.value)}`)
+            .join(', ');
+        const message = `Confirm: set rollout for ${key} in ${environment.name} to [${rolloutDescription}]? yes/no`;
+        if (!(await getConfirmation({ flags, message }))) {
+            return;
+        }
+        // Fetch the current full config to get commitSha and existing environments
+        const detailRequest = await this.apiClient.post('/api/v1/metadata/getByKey', {
+            workspaceId: this.workspaceId,
+            key,
+        });
+        if (!detailRequest.ok) {
+            return this.err(`Failed to fetch config details: ${detailRequest.status}`);
+        }
+        const currentConfig = detailRequest.json;
+        const newRule = { criteria: [], value: rolloutValue };
+        const envKey = environment.name;
+        const existingEnvs = currentConfig.environments ?? [];
+        const hasEnv = existingEnvs.some((e) => e.id === envKey);
+        const updatedEnvironments = hasEnv
+            ? existingEnvs.map((e) => (e.id === envKey ? { ...e, rules: [newRule] } : e))
+            : [...existingEnvs, { id: envKey, rules: [newRule] }];
+        const updateFields = { environments: updatedEnvironments };
+        this.verboseLog('Update fields:', JSON.stringify(updateFields, null, 2));
+        let request;
+        if (config.type === 'feature_flag') {
+            request = await this.apiClient.post('/api/v1/flags/update', {
+                expectedCommitSha: currentConfig.commitSha,
+                flag: updateFields,
+                flagKey: key,
+                workspaceId: this.workspaceId,
+            });
+        }
+        else {
+            request = await this.apiClient.post('/api/v1/configs/update', {
+                config: updateFields,
+                configKey: key,
+                expectedCommitSha: currentConfig.commitSha,
+                workspaceId: this.workspaceId,
+            });
+        }
+        if (request.ok) {
+            this.log(`${checkmark} Rollout set: ${key} in ${environment.name} → [${rolloutDescription}]`);
+            return {
+                environment: { id: environment.id, name: environment.name },
+                hashByPropertyName: flags['hash-by'],
+                key,
+                rollout: rolloutDescription,
+                success: true,
+                weightedValues,
+            };
+        }
+        this.verboseLog(request.error);
+        return this.err(`Failed to set rollout: ${request.status} | ${JSON.stringify(request.error)}`, { key, serverError: request.error });
+    }
+    parseWeights(weightsStr, valueType) {
+        const pairs = weightsStr.split(',').map((s) => s.trim());
+        const weights = [];
+        let totalPercent = 0;
+        for (const pair of pairs) {
+            const colonIdx = pair.lastIndexOf(':');
+            if (colonIdx === -1) {
+                return {
+                    error: `Invalid weight entry "${pair}". Expected format "value:percent" (e.g. "true:20").`,
+                    ok: false,
+                };
+            }
+            const rawValue = pair.slice(0, colonIdx).trim();
+            const percentStr = pair.slice(colonIdx + 1).trim();
+            const percent = Number(percentStr);
+            if (Number.isNaN(percent) || percent < 0 || percent > 100) {
+                return { error: `Invalid percent "${percentStr}" in "${pair}". Must be 0–100.`, ok: false };
+            }
+            const typedValue = this.coerceValue(rawValue, valueType);
+            if (!typedValue.ok) {
+                return { error: typedValue.error, ok: false };
+            }
+            weights.push({ value: typedValue.typed, weight: percent * (WEIGHT_TOTAL / 100) });
+            totalPercent += percent;
+        }
+        if (Math.round(totalPercent) !== 100) {
+            return { error: `Weights must sum to 100. Got: ${totalPercent}%.`, ok: false };
+        }
+        return { ok: true, weights };
+    }
+    coerceValue(raw, valueType) {
+        const type = valueType.toLowerCase();
+        switch (type) {
+            case 'bool': {
+                if (raw !== 'true' && raw !== 'false') {
+                    return { error: `Invalid boolean value "${raw}". Must be "true" or "false".`, ok: false };
+                }
+                return { ok: true, typed: { type: 'bool', value: raw === 'true' } };
+            }
+            case 'int': {
+                const n = Number.parseInt(raw, 10);
+                if (Number.isNaN(n)) {
+                    return { error: `Invalid int value "${raw}".`, ok: false };
+                }
+                return { ok: true, typed: { type: 'int', value: n } };
+            }
+            case 'double': {
+                const n = Number.parseFloat(raw);
+                if (Number.isNaN(n)) {
+                    return { error: `Invalid double value "${raw}".`, ok: false };
+                }
+                return { ok: true, typed: { type: 'double', value: n } };
+            }
+            default: {
+                // string, json, etc — pass as-is
+                return { ok: true, typed: { type, value: raw } };
+            }
+        }
+    }
+}

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;
+}