@loopress/cli 0.12.0 → 0.14.0

package/dist/commands/plugin/push.js

@@ -1,8 +1,7 @@
-import { confirm } from '@inquirer/prompts';
 import { Listr } from 'listr2';
 import { PushCommand } from '../../lib/push-command.js';
 import { getComposerManagedSlugs, readComposerJson } from '../../utils/composer.js';
-import { diffPlugins } from '../../utils/plugins.js';
+import { diffPlugins, parseInstalledPlugins } from '../../utils/plugins.js';
 export default class Push extends PushCommand {
     static description = 'Push plugins to WordPress to match loopress.json';
     static examples = ['$ lps plugin push', '$ lps plugin push --dry-run'];
@@ -25,45 +24,39 @@ export default class Push extends PushCommand {
             this.log('Run `lps composer push` to deploy them.');
         }
         this.log(`Pushing plugins to ${url}`);
-        const installed = await this.wp.get('loopress/v1/plugins');
-        const { drifted, toActivate, toInstall } = diffPlugins(filteredManifest, installed);
-        if (toInstall.length === 0 && toActivate.length === 0 && drifted.length === 0) {
+        const raw = await this.wp.get('wp/v2/plugins');
+        const installed = parseInstalledPlugins(raw);
+        const { toActivate, toInstall } = diffPlugins(filteredManifest, installed);
+        if (toInstall.length === 0 && toActivate.length === 0) {
             this.log('Everything is already in sync.');
             return;
         }
         if (toInstall.length > 0) {
             this.log(`\nTo install (${toInstall.length}):`);
             for (const a of toInstall)
-                this.log(`  + ${a.slug} @ ${a.targetVersion}`);
+                this.log(`  + ${a.slug}`);
         }
         if (toActivate.length > 0) {
             this.log(`\nTo activate (${toActivate.length}):`);
             for (const a of toActivate)
                 this.log(`  ↑ ${a.slug}`);
         }
-        if (drifted.length > 0) {
-            this.log(`\nVersion mismatch (${drifted.length}):`);
-            for (const a of drifted) {
-                this.log(`  ~ ${a.slug}: site has ${a.currentVersion}, manifest wants ${a.targetVersion}`);
-            }
-        }
         if (this.dryRun)
             return;
-        // Install missing plugins and activate them.
+        // Installing with `status: active` activates in the same call, so installs never need a
+        // separate activation step the way the old custom endpoint's two-step flow did.
         if (toInstall.length > 0) {
             await new Listr(toInstall.map((action) => ({
-                task: async (_ctx, task) => this.installAndActivate(action.slug, action.targetVersion, task),
-                title: `Install ${action.slug} @ ${action.targetVersion}`,
+                task: async (_ctx, task) => this.installPlugin(action.slug, task),
+                title: `Install ${action.slug}`,
             })), { concurrent: false, exitOnError: false }).run();
         }
-        // Activate installed-but-inactive plugins without prompting.
         if (toActivate.length > 0) {
             await new Listr(toActivate.map((action) => ({
-                task: async (_ctx, task) => this.activatePlugin(action.slug, task),
+                task: async (_ctx, task) => this.activatePlugin(action.file, action.slug, task),
                 title: `Activate ${action.slug}`,
             })), { concurrent: false, exitOnError: false }).run();
         }
-        await this.syncDrifted(drifted);
         if (this.failedCount > 0) {
             this.error(`${this.failedCount} plugin${this.failedCount === 1 ? '' : 's'} failed to install or activate.`);
         }
@@ -75,18 +68,16 @@ export default class Push extends PushCommand {
     // it falls back to plain logging. Rethrowing on failure (rather than swallowing) is what lets Listr
     // mark the task as failed (red cross) instead of completed, even though `exitOnError: false` stops
     // that failure from aborting sibling tasks in the same list.
-    async activatePlugin(slug, task) {
-        await this.performPluginAction('activate', { body: { slug }, endpoint: 'loopress/v1/plugins/activate', slug }, task);
+    async activatePlugin(file, slug, task) {
+        await this.performPluginAction('activate', slug, () => this.wp.put(`wp/v2/plugins/${file}`, { status: 'active' }), task);
     }
-    async installAndActivate(slug, version, task) {
-        await this.performPluginAction('install', { body: { slug, version }, endpoint: 'loopress/v1/plugins/install', slug }, task);
-        await this.activatePlugin(slug, task);
+    async installPlugin(slug, task) {
+        await this.performPluginAction('install', slug, () => this.wp.post('wp/v2/plugins', { slug, status: 'active' }), task);
     }
-    async performPluginAction(verb, request, task) {
-        const { body, endpoint, slug } = request;
+    async performPluginAction(verb, slug, request, task) {
         try {
-            const result = await this.wp.post(endpoint, body);
-            const message = `✓ ${result.message}`;
+            await request();
+            const message = `✓ ${slug} ${verb === 'install' ? 'installed and activated' : 'activated'}`;
             if (task)
                 task.output = message;
             else
@@ -102,27 +93,4 @@ export default class Push extends PushCommand {
             throw error;
         }
     }
-    // Prompt per drifted plugin before syncing. Prompts run sequentially on plain stdout,
-    // before the Listr renderer takes over the terminal for the confirmed subset.
-    async syncDrifted(drifted) {
-        const confirmedDrift = [];
-        for (const action of drifted) {
-            const proceed = await confirm({
-                default: false,
-                message: `${action.slug} is at ${action.currentVersion} on the site but manifest wants ${action.targetVersion}. Sync to ${action.targetVersion}?`,
-            });
-            if (proceed) {
-                confirmedDrift.push(action);
-            }
-            else {
-                this.log(`  Skipped ${action.slug}`);
-            }
-        }
-        if (confirmedDrift.length === 0)
-            return;
-        await new Listr(confirmedDrift.map((action) => ({
-            task: async (_ctx, task) => this.installAndActivate(action.slug, action.targetVersion, task),
-            title: `Sync ${action.slug} to ${action.targetVersion}`,
-        })), { concurrent: false, exitOnError: false }).run();
-    }
 }

package/dist/commands/project/config.d.ts

@@ -3,5 +3,7 @@ export default class Config extends Command {
     static description: string;
     static examples: string[];
     run(): Promise<void>;
+    private promptManualCredentials;
+    private resolveCredentials;
     private resolveProject;
 }

package/dist/commands/project/config.js

@@ -1,9 +1,13 @@
 import { confirm, input, password as passwordPrompt, select } from '@inquirer/prompts';
 import { Command } from '@oclif/core';
 import { configManager } from '../../config/project-config.manager.js';
+import { authorizeWithBrowser } from '../../lib/wp-authorize-flow.js';
+import { diagnoseWpSite } from '../../lib/wp-site-diagnostic.js';
 const NEW_PROJECT = '__new__';
+const AUTH_BROWSER = 'browser';
+const AUTH_MANUAL = 'manual';
 export default class Config extends Command {
-    static description = 'Add or update a WordPress project environment';
+    static description = 'Add or update a WordPress project environment. By default, authorizes via WordPress in your browser; manual username/Application Password entry is available as a fallback.';
     static examples = ['$ lps project config'];
     async run() {
         await this.parse(Config);
@@ -34,7 +38,7 @@ export default class Config extends Command {
                 return;
             }
         }
-        const url = await input({
+        const rawUrl = await input({
             message: 'WordPress URL',
             validate(value) {
                 try {
@@ -49,15 +53,8 @@ export default class Config extends Command {
                 }
             },
         });
-        const user = await input({
-            message: 'Username',
-            validate: (value) => (value.trim().length > 0 ? true : 'Username cannot be empty'),
-        });
-        const appPassword = await passwordPrompt({
-            mask: '*',
-            message: 'Application password',
-            validate: (value) => (value.trim().length > 0 ? true : 'Application password cannot be empty'),
-        });
+        const url = rawUrl.replace(/\/+$/, '');
+        const { appPassword, user } = await this.resolveCredentials(url);
         const token = `${user}:${appPassword}`;
         const env = {
             addedAt: new Date().toISOString(),
@@ -79,6 +76,43 @@ export default class Config extends Command {
         this.log(`✓ "${projectName}/${envName}" configured`);
         this.log('→ Run `lps project switch` to change the active project or environment');
     }
+    async promptManualCredentials() {
+        const user = await input({
+            message: 'Username',
+            validate: (value) => (value.trim().length > 0 ? true : 'Username cannot be empty'),
+        });
+        const appPassword = await passwordPrompt({
+            mask: '*',
+            message: 'Application password',
+            validate: (value) => (value.trim().length > 0 ? true : 'Application password cannot be empty'),
+        });
+        return { appPassword, user };
+    }
+    async resolveCredentials(url) {
+        const authMode = await select({
+            choices: [
+                { name: 'Authorize in my browser (recommended)', value: AUTH_BROWSER },
+                { name: 'Enter credentials manually', value: AUTH_MANUAL },
+            ],
+            message: 'How do you want to authenticate?',
+        });
+        if (authMode === AUTH_MANUAL) {
+            return this.promptManualCredentials();
+        }
+        const diagnostic = await diagnoseWpSite(url);
+        if (!diagnostic.ok) {
+            this.warn(`${diagnostic.reason}\nFalling back to manual credential entry.`);
+            return this.promptManualCredentials();
+        }
+        try {
+            const { password, userLogin } = await authorizeWithBrowser(url, (message) => this.log(message));
+            return { appPassword: password, user: userLogin };
+        }
+        catch (error) {
+            this.warn(`${error.message}\nFalling back to manual credential entry.`);
+            return this.promptManualCredentials();
+        }
+    }
     async resolveProject() {
         const projects = configManager.listProjects();
         if (projects.length > 0) {

package/dist/commands/snippet/publish.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Publish extends Command {
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private toPayload;
+}

package/dist/commands/snippet/publish.js

@@ -0,0 +1,74 @@
+import { Args, Command } from '@oclif/core';
+import { join } from 'node:path';
+import slugify from 'slugify';
+import { authManager } from '../../config/auth.manager.js';
+import { configManager } from '../../config/project-config.manager.js';
+import { ApiClient } from '../../lib/api-client.js';
+import { loadSnippets } from '../../lib/load-snippets.js';
+import { readLocalConfig } from '../../utils/loopress-config.js';
+// Publishes to the Loopress api (not a WordPress site), so this does not extend
+// `LoopressCommand`/`PushCommand`: those force an environment to be resolved, but a project
+// publishing its snippets for sharing doesn't need one, a pure "library" project 
+// may have zero environments configured at all.
+export default class Publish extends Command {
+    static args = {
+        path: Args.string({ description: 'Path to snippets directory (overrides project config)' }),
+    };
+    static description = 'Publish snippets to your Loopress account so they can be deployed to other projects. Does not touch any WordPress site.';
+    static examples = ['$ lps snippet publish', '$ lps snippet publish --path ./snippets'];
+    async run() {
+        const { args } = await this.parse(Publish);
+        const token = process.env.LOOPRESS_TOKEN ?? authManager.getAuth()?.token;
+        if (!token) {
+            this.error('Not logged in. Run `lps login` first.');
+        }
+        const localConfig = await readLocalConfig();
+        const projectId = localConfig.projectId ?? configManager.getCurrentProject()?.id;
+        if (!projectId) {
+            this.error('No project configured. Run `lps project config` first.');
+        }
+        const project = configManager.getProject(projectId);
+        if (!project) {
+            this.error(`Project "${projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
+        }
+        if (!project.apiProjectId) {
+            this.error(`Project "${project.name}" is not linked to your Loopress account yet. Run \`lps project sync\` first.`);
+        }
+        const path = args.path ?? join(localConfig.rootDir ?? '.', localConfig.snippetsDir ?? 'snippets');
+        this.log(`Publishing snippets from ${path}`);
+        let snippets;
+        try {
+            snippets = await loadSnippets(path);
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+        const api = new ApiClient(token);
+        try {
+            await api.post(`projects/${project.apiProjectId}/snippets/publish`, {
+                snippets: snippets.map((snippet) => this.toPayload(snippet)),
+            });
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+        this.log(`Published ${snippets.length} snippet${snippets.length === 1 ? '' : 's'} to your Loopress account.`);
+    }
+    toPayload(snippet) {
+        return {
+            active: snippet.active,
+            code: snippet.code,
+            insertMethod: snippet.insertMethod,
+            location: snippet.location,
+            name: snippet.name,
+            priority: snippet.priority,
+            shortcodeAttributes: snippet.shortcodeAttributes,
+            // Derived from the snippet's name rather than its on-disk filename: the same
+            // slugification `push`/`pull` already use for the canonical `<id>-<slug>` filename
+            // convention, so it stays stable even for a not-yet-pushed file with an arbitrary name.
+            slug: slugify(snippet.name, { lower: true, strict: true }),
+            tags: snippet.tags,
+            type: snippet.type,
+        };
+    }
+}

package/dist/commands/snippet/push.js

@@ -1,18 +1,12 @@
 import { Args } from '@oclif/core';
 import { Listr } from 'listr2';
-import { readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { basename, dirname, extname, join } from 'node:path';
 import slugify from 'slugify';
+import { loadSnippets as loadSnippetsFromDisk } from '../../lib/load-snippets.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
-import { defaultLocationForType, normalizeSnippet, parseInsertMethod, parseLocation, parseType, SNIPPETS_ENDPOINT, stripPhpOpeningTag, } from '../../utils/snippet-format.js';
-const TYPE_BY_EXTENSION = {
-    '.css': 'css',
-    '.html': 'html',
-    '.js': 'js',
-    '.php': 'php',
-    '.txt': 'text',
-};
+import { normalizeSnippet, SNIPPETS_ENDPOINT, stripPhpOpeningTag } from '../../utils/snippet-format.js';
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to snippets directory (overrides project config)' }),
@@ -78,71 +72,12 @@ export default class Push extends PushCommand {
         await rm(oldMetaPath, { force: true });
     }
     async loadSnippets(path) {
-        const snippets = [];
-        let files;
         try {
-            files = await readdir(path);
+            return await loadSnippetsFromDisk(path, (message) => this.warn(message));
         }
         catch (error) {
-            this.error(`Error loading snippets: ${error.message}`);
+            this.error(error.message);
         }
-        for (const file of files) {
-            const ext = extname(file);
-            if (!(ext in TYPE_BY_EXTENSION))
-                continue;
-            const filePath = join(path, file);
-            const metaPath = join(path, `${basename(file, ext)}.json`);
-            // One snippet's files are read in isolation: a corrupted or hand-broken sidecar
-            // (bad JSON, unreadable file, ...) must only skip that snippet, not abort the entire
-            // push for every other snippet in the directory.
-            try {
-                const content = await readFile(filePath, 'utf8');
-                let id;
-                let name;
-                let type;
-                let active = false;
-                let tags = [];
-                let location = null;
-                let insertMethod = null;
-                let priority = 10;
-                let shortcodeAttributes = [];
-                try {
-                    const metaContent = await readFile(metaPath, 'utf8');
-                    const meta = JSON.parse(metaContent);
-                    id = meta.id ? Number(meta.id) : undefined;
-                    name = meta.name ? String(meta.name) : undefined;
-                    type = parseType(meta.type) ?? undefined;
-                    active = Boolean(meta.active);
-                    tags = Array.isArray(meta.tags) ? meta.tags.map(String) : [];
-                    location = parseLocation(meta.location);
-                    insertMethod = parseInsertMethod(meta.insertMethod);
-                    priority = meta.priority === undefined ? 10 : Number(meta.priority);
-                    shortcodeAttributes = Array.isArray(meta.shortcodeAttributes) ? meta.shortcodeAttributes.map(String) : [];
-                }
-                catch (error) {
-                    if (error.code !== 'ENOENT')
-                        throw error;
-                }
-                const resolvedType = type ?? (ext in TYPE_BY_EXTENSION ? TYPE_BY_EXTENSION[ext] : 'php');
-                snippets.push({
-                    active,
-                    code: content,
-                    id,
-                    insertMethod: insertMethod ?? 'auto',
-                    location: location ?? defaultLocationForType(resolvedType),
-                    name: name ?? basename(file, ext),
-                    path: filePath,
-                    priority,
-                    shortcodeAttributes,
-                    tags,
-                    type: resolvedType,
-                });
-            }
-            catch (error) {
-                this.warn(`Skipping "${metaPath}": ${error.message}`);
-            }
-        }
-        return snippets;
     }
     // Throwing on failure (rather than returning a boolean) is what lets Listr mark the task as
     // failed (red cross) instead of completed; `exitOnError: false` on the task list still lets

package/dist/commands/status.js

@@ -10,9 +10,13 @@ export default class Status extends Command {
         const localConfig = await readLocalConfig();
         if (localConfig.projectId) {
             this.reportPinnedProject(localConfig.projectId);
-            return;
         }
-        this.reportActiveProject();
+        else {
+            this.reportActiveProject();
+        }
+        this.log('');
+        this.log(`Config dir: ${this.config.configDir}`);
+        this.log(`Data dir:   ${this.config.dataDir}`);
     }
     reportActiveProject() {
         const env = configManager.getCurrentEnv();

package/dist/commands/telemetry/disable.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class TelemetryDisable extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/telemetry/disable.js

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+import { configManager } from '../../config/project-config.manager.js';
+export default class TelemetryDisable extends Command {
+    static description = 'Disable error reporting to Sentry';
+    static examples = ['$ lps telemetry disable'];
+    async run() {
+        if (configManager.isTelemetryDisabled()) {
+            this.log('Error reporting is already disabled.');
+            return;
+        }
+        configManager.setTelemetryDisabled(true);
+        this.log('Error reporting disabled.');
+    }
+}

package/dist/commands/telemetry/enable.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class TelemetryEnable extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/telemetry/enable.js

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+import { configManager } from '../../config/project-config.manager.js';
+export default class TelemetryEnable extends Command {
+    static description = 'Enable error reporting to Sentry';
+    static examples = ['$ lps telemetry enable'];
+    async run() {
+        if (!configManager.isTelemetryDisabled()) {
+            this.log('Error reporting is already enabled.');
+            return;
+        }
+        configManager.setTelemetryDisabled(false);
+        this.log('Error reporting enabled.');
+    }
+}

package/dist/config/auth.manager.d.ts

@@ -4,11 +4,13 @@ export interface ConsoleAuth {
     token: string;
 }
 export declare class AuthManager {
-    private readonly homeDir;
-    constructor(homeDir?: string);
+    private dataDir?;
+    constructor(dataDir?: string | undefined);
     clearAuth(): void;
     getAuth(): ConsoleAuth | null;
     getAuthFilePath(): string;
     setAuth(auth: ConsoleAuth): void;
+    setDataDir(dataDir: string): void;
+    private requireDataDir;
 }
 export declare const authManager: AuthManager;

package/dist/config/auth.manager.js

@@ -1,11 +1,10 @@
 import { existsSync, unlinkSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { readJsonFile, writeJsonFileAtomic } from './json-file.js';
 export class AuthManager {
-    homeDir;
-    constructor(homeDir = homedir()) {
-        this.homeDir = homeDir;
+    dataDir;
+    constructor(dataDir) {
+        this.dataDir = dataDir;
     }
     clearAuth() {
         const filePath = this.getAuthFilePath();
@@ -16,10 +15,21 @@ export class AuthManager {
         return readJsonFile(this.getAuthFilePath());
     }
     getAuthFilePath() {
-        return join(this.homeDir, '.loopress', 'auth.json');
+        return join(this.requireDataDir(), 'auth.json');
     }
     setAuth(auth) {
         writeJsonFileAtomic(this.getAuthFilePath(), auth);
     }
+    // Real CLI runs get this from the `init` hook (src/hooks/init.ts) before any command runs.
+    // Throwing when it's unset (rather than falling back to a hardcoded path) surfaces tests that
+    // forgot to configure the manager instead of silently touching some default location.
+    setDataDir(dataDir) {
+        this.dataDir = dataDir;
+    }
+    requireDataDir() {
+        if (!this.dataDir)
+            throw new Error('AuthManager used before setDataDir() was called');
+        return this.dataDir;
+    }
 }
 export const authManager = new AuthManager();

package/dist/config/project-config.manager.d.ts

@@ -1,7 +1,7 @@
 import { EnvironmentConfig, LoopressConfig, ProjectConfig } from '../types/config.js';
 export declare class ProjectConfigManager {
-    private readonly homeDir;
-    constructor(homeDir?: string);
+    private configDir?;
+    constructor(configDir?: string | undefined);
     createProjectId(name: string): string;
     ensureConfigDir(): void;
     findProjectByApiId(apiProjectId: string): null | (ProjectConfig & {
@@ -14,6 +14,7 @@ export declare class ProjectConfigManager {
     });
     getEnvironment(projectId: string, envName: string): EnvironmentConfig | null;
     getProject(id: string): null | ProjectConfig;
+    isTelemetryDisabled(): boolean;
     listEnvironments(projectId: string): Array<EnvironmentConfig & {
         isCurrent: boolean;
     }>;
@@ -24,15 +25,19 @@ export declare class ProjectConfigManager {
     readConfig(): LoopressConfig;
     removeEnvironment(projectId: string, envName: string): void;
     removeProject(id: string): void;
+    setConfigDir(configDir: string): void;
     setCurrent(projectId: string, envName: string): void;
     setEnvironment(projectId: string, envName: string, env: EnvironmentConfig): void;
     setEnvironmentApiId(projectId: string, envName: string, apiEnvironmentId: string): void;
     setProject(id: string, project: ProjectConfig): void;
     setProjectApiId(id: string, apiProjectId: string): void;
+    setTelemetryDisabled(disabled: boolean): void;
     writeConfig(config: LoopressConfig): void;
     private isProjectConfig;
+    private requireConfigDir;
     private sanitizeConfig;
     private sanitizeCurrentProject;
     private sanitizeProjects;
+    private sanitizeTelemetry;
 }
 export declare const configManager: ProjectConfigManager;

package/dist/config/project-config.manager.js

@@ -1,12 +1,11 @@
 import { existsSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import slugify from 'slugify';
 import { readJsonFile, writeJsonFileAtomic } from './json-file.js';
 export class ProjectConfigManager {
-    homeDir;
-    constructor(homeDir = homedir()) {
-        this.homeDir = homeDir;
+    configDir;
+    constructor(configDir) {
+        this.configDir = configDir;
     }
     createProjectId(name) {
         const config = this.readConfig();
@@ -20,7 +19,7 @@ export class ProjectConfigManager {
         return id;
     }
     ensureConfigDir() {
-        const dir = join(this.homeDir, '.loopress');
+        const dir = this.requireConfigDir();
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
         }
@@ -38,7 +37,7 @@ export class ProjectConfigManager {
         return null;
     }
     getConfigFilePath() {
-        return join(this.homeDir, '.loopress', 'config.json');
+        return join(this.requireConfigDir(), 'config.json');
     }
     getCurrentEnv() {
         const config = this.readConfig();
@@ -68,6 +67,9 @@ export class ProjectConfigManager {
         const config = this.readConfig();
         return config.projects[id] ?? null;
     }
+    isTelemetryDisabled() {
+        return this.readConfig().telemetry?.disabled ?? false;
+    }
     listEnvironments(projectId) {
         const config = this.readConfig();
         const project = config.projects[projectId];
@@ -116,6 +118,12 @@ export class ProjectConfigManager {
         }
         this.writeConfig(config);
     }
+    // Repointed by the `init` hook to oclif's native configDir once the real CLI Config is
+    // available. The constructor default only serves contexts that bypass the oclif lifecycle
+    // (e.g. commands instantiated directly in unit tests).
+    setConfigDir(configDir) {
+        this.configDir = configDir;
+    }
     setCurrent(projectId, envName) {
         const config = this.readConfig();
         if (!config.projects[projectId])
@@ -159,6 +167,11 @@ export class ProjectConfigManager {
         project.apiProjectId = apiProjectId;
         this.writeConfig(config);
     }
+    setTelemetryDisabled(disabled) {
+        const config = this.readConfig();
+        config.telemetry = { disabled };
+        this.writeConfig(config);
+    }
     writeConfig(config) {
         writeJsonFileAtomic(this.getConfigFilePath(), config);
     }
@@ -168,13 +181,23 @@ export class ProjectConfigManager {
         const candidate = value;
         return typeof candidate.name === 'string' && typeof candidate.environments === 'object' && candidate.environments !== null;
     }
+    // Real CLI runs get this from the `init` hook (src/hooks/init.ts) before any command runs.
+    // Throwing when it's unset (rather than falling back to a hardcoded path) surfaces tests that
+    // forgot to configure the manager instead of silently touching some default location.
+    requireConfigDir() {
+        if (!this.configDir)
+            throw new Error('ProjectConfigManager used before setConfigDir() was called');
+        return this.configDir;
+    }
     sanitizeConfig(value) {
         if (typeof value !== 'object' || value === null)
             return { currentProject: null, projects: {} };
         const candidate = value;
+        const telemetry = this.sanitizeTelemetry(candidate.telemetry);
         return {
             currentProject: this.sanitizeCurrentProject(candidate.currentProject),
             projects: this.sanitizeProjects(candidate.projects),
+            ...(telemetry && { telemetry }),
         };
     }
     sanitizeCurrentProject(value) {
@@ -193,5 +216,11 @@ export class ProjectConfigManager {
         }
         return projects;
     }
+    sanitizeTelemetry(value) {
+        if (typeof value !== 'object' || value === null)
+            return undefined;
+        const candidate = value;
+        return typeof candidate.disabled === 'boolean' ? { disabled: candidate.disabled } : undefined;
+    }
 }
 export const configManager = new ProjectConfigManager();