@loopress/cli 0.13.0 → 0.15.0

package/dist/commands/project/pull.js

@@ -0,0 +1,69 @@
+import { Command } from '@oclif/core';
+import { Listr } from 'listr2';
+import { authManager } from '../../config/auth.manager.js';
+import { configManager } from '../../config/project-config.manager.js';
+import { ApiClient } from '../../lib/api-client.js';
+export default class Pull extends Command {
+    static description = 'Pull projects and environments from your Loopress account that are not configured locally yet';
+    static examples = ['$ lps project pull'];
+    async run() {
+        await this.parse(Pull);
+        const token = authManager.getAuth()?.token;
+        if (!token) {
+            this.error('Not logged in. Run `lps login` first.');
+        }
+        const api = new ApiClient(token);
+        const apiProjects = await this.fetchApiProjects(api);
+        const linkedApiProjectIds = new Set(configManager
+            .listProjects()
+            .map((project) => project.apiProjectId)
+            .filter((id) => id !== undefined));
+        const newApiProjects = apiProjects.filter((apiProject) => !linkedApiProjectIds.has(apiProject.id));
+        let projectCount = 0;
+        let environmentCount = 0;
+        if (newApiProjects.length > 0) {
+            await new Listr(newApiProjects.map((apiProject) => ({
+                task: (_ctx, task) => {
+                    this.pullProject(apiProject, task);
+                    projectCount++;
+                    environmentCount += apiProject.environments.length;
+                },
+                title: `Pull project "${apiProject.name}" from the API`,
+            })), { concurrent: false, exitOnError: false }).run();
+        }
+        this.log(`\n✓ Pulled ${projectCount} project${projectCount === 1 ? '' : 's'}, ${environmentCount} environment${environmentCount === 1 ? '' : 's'} from your Loopress account`);
+    }
+    async fetchApiProjects(api) {
+        try {
+            return await api.get('projects');
+        }
+        catch (error) {
+            this.error(`Could not fetch projects from the API: ${error.message}`);
+        }
+    }
+    // Reuse a local project already linked to this API project instead of always minting a new
+    // one: otherwise every pull that can't "claim" an existing link (e.g. after the local config
+    // was reset or desynced from the API) creates yet another duplicate entry.
+    pullProject(apiProject, task) {
+        const existing = configManager.findProjectByApiId(apiProject.id);
+        const environments = { ...existing?.environments };
+        for (const env of apiProject.environments) {
+            environments[env.name] = {
+                ...environments[env.name],
+                addedAt: environments[env.name]?.addedAt ?? env.createdAt,
+                apiEnvironmentId: env.id,
+                name: env.name,
+                url: env.url,
+            };
+        }
+        configManager.setProject(existing?.id ?? configManager.createProjectId(apiProject.name), {
+            addedAt: existing?.addedAt ?? apiProject.createdAt,
+            apiProjectId: apiProject.id,
+            environments,
+            name: apiProject.name,
+        });
+        const envCount = apiProject.environments.length;
+        if (task)
+            task.output = `Pulled with ${envCount} environment${envCount === 1 ? '' : 's'}`;
+    }
+}

package/dist/commands/project/{sync.d.ts → push.d.ts}

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class Sync extends Command {
+export default class Push extends Command {
     static description: string;
     static examples: string[];
     run(): Promise<void>;
@@ -8,6 +8,5 @@ export default class Sync extends Command {
     private fetchApiProjects;
     private planEnvironment;
     private planProject;
-    private pullProject;
     private pushCredentials;
 }

package/dist/commands/project/{sync.js → push.js}

@@ -5,11 +5,11 @@ 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';
-export default class Sync extends Command {
-    static description = 'Sync locally configured projects and environments with your Loopress account';
-    static examples = ['$ lps project sync'];
+export default class Push extends Command {
+    static description = 'Push locally configured projects, environments and credentials to your Loopress account';
+    static examples = ['$ lps project push'];
     async run() {
-        await this.parse(Sync);
+        await this.parse(Push);
         const token = authManager.getAuth()?.token;
         if (!token) {
             this.error('Not logged in. Run `lps login` first.');
@@ -77,22 +77,11 @@ export default class Sync extends Command {
                     await this.pushCredentials(api, plan.apiProjectId, envPlan.apiEnvironmentId, envPlan.env);
                 }
                 catch (error) {
-                    this.warn(`Failed to sync "${plan.project.name}/${envPlan.env.name}": ${error.message}`);
+                    this.warn(`Failed to push "${plan.project.name}/${envPlan.env.name}": ${error.message}`);
                 }
             }
         }
-        const newApiProjects = apiProjects.filter((candidate) => !claimedProjectIds.has(candidate.id));
-        if (newApiProjects.length > 0) {
-            await new Listr(newApiProjects.map((apiProject) => ({
-                task: async (_ctx, task) => {
-                    this.pullProject(apiProject, task);
-                    projectCount++;
-                    environmentCount += apiProject.environments.length;
-                },
-                title: `Pull project "${apiProject.name}" from the API`,
-            })), { concurrent: false, exitOnError: false }).run();
-        }
-        this.log(`\n✓ Synced ${projectCount} project${projectCount === 1 ? '' : 's'}, ${environmentCount} environment${environmentCount === 1 ? '' : 's'} with your Loopress account`);
+        this.log(`\n✓ Pushed ${projectCount} project${projectCount === 1 ? '' : 's'}, ${environmentCount} environment${environmentCount === 1 ? '' : 's'} to your Loopress account`);
     }
     async applyEnvironment(api, apiProjectId, envPlan, task) {
         try {
@@ -111,7 +100,7 @@ export default class Sync extends Command {
                 task.output = envPlan.action === 'create' ? 'Created on the API' : 'Linked to the API';
         }
         catch (error) {
-            const message = `Failed to sync "${envPlan.env.name}": ${error.message}`;
+            const message = `Failed to push "${envPlan.env.name}": ${error.message}`;
             if (task)
                 task.output = message;
             throw error;
@@ -131,7 +120,7 @@ export default class Sync extends Command {
                 task.output = plan.action === 'create' ? 'Created on the API' : 'Linked to the API';
         }
         catch (error) {
-            const message = `Failed to sync project "${plan.project.name}": ${error.message}`;
+            const message = `Failed to push project "${plan.project.name}": ${error.message}`;
             if (task)
                 task.output = message;
             throw error;
@@ -183,31 +172,6 @@ export default class Sync extends Command {
         }
         return { action: 'create', project };
     }
-    pullProject(apiProject, task) {
-        // Reuse a local project already linked to this API project instead of always minting a
-        // new one: otherwise every sync run that can't "claim" an existing link (e.g. after the
-        // local config was reset or desynced from the API) creates yet another duplicate entry.
-        const existing = configManager.findProjectByApiId(apiProject.id);
-        const environments = { ...existing?.environments };
-        for (const env of apiProject.environments) {
-            environments[env.name] = {
-                ...environments[env.name],
-                addedAt: environments[env.name]?.addedAt ?? env.createdAt,
-                apiEnvironmentId: env.id,
-                name: env.name,
-                url: env.url,
-            };
-        }
-        configManager.setProject(existing?.id ?? configManager.createProjectId(apiProject.name), {
-            addedAt: existing?.addedAt ?? apiProject.createdAt,
-            apiProjectId: apiProject.id,
-            environments,
-            name: apiProject.name,
-        });
-        const envCount = apiProject.environments.length;
-        if (task)
-            task.output = `Pulled with ${envCount} environment${envCount === 1 ? '' : 's'}`;
-    }
     async pushCredentials(api, apiProjectId, apiEnvironmentId, env) {
         if (!env.token)
             return;

package/dist/commands/snippet/publish.js

@@ -32,7 +32,7 @@ export default class Publish extends Command {
             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.`);
+            this.error(`Project "${project.name}" is not linked to your Loopress account yet. Run \`lps project push\` first.`);
         }
         const path = args.path ?? join(localConfig.rootDir ?? '.', localConfig.snippetsDir ?? 'snippets');
         this.log(`Publishing snippets from ${path}`);

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,15 +19,15 @@ export class ProjectConfigManager {
         return id;
     }
     ensureConfigDir() {
-        const dir = join(this.homeDir, '.loopress');
+        const dir = this.requireConfigDir();
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
         }
     }
-    // Looks up a local project already linked to a given API project, regardless of whether
-    // it was "claimed" in the current sync run. Used by `project sync` to avoid minting a new
-    // local project every time it pulls an API project whose local link was lost (e.g. after
-    // a reset or partial config corruption), which otherwise accumulates duplicate entries.
+    // Looks up a local project already linked to a given API project. Used by `project pull` to
+    // avoid minting a new local project every time it pulls an API project whose local link was
+    // lost (e.g. after a reset or partial config corruption), which otherwise accumulates
+    // duplicate entries.
     findProjectByApiId(apiProjectId) {
         const config = this.readConfig();
         for (const [id, project] of Object.entries(config.projects)) {
@@ -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();

package/dist/hooks/finally.js

@@ -1,15 +1,29 @@
-import * as Sentry from '@sentry/node';
-import { isTelemetryDisabled, runtimeContext } from '../lib/sentry.js';
+import { isTelemetryDisabled, redactArgv, resolveEnvironment, runtimeContext, SENTRY_DSN, } from '../lib/sentry.js';
 // oclif has no `command_error` hook (checked @oclif/core@4.11.11's hooks.d.ts). `finally`
 // is the closest equivalent: it always runs at the end of the CLI lifecycle and carries
 // the error, if any, so it's where we report crashes before the process exits.
+//
+// @sentry/node is imported dynamically here, only when there's actually an error to report.
+// It's a heavy module (@opentelemetry deps, import-in-the-middle instrumentation), so loading
+// it eagerly on every command would tax the common case where commands succeed.
 const hook = async function (options) {
     if (!options.error || isTelemetryDisabled())
         return;
     try {
+        const Sentry = await import('@sentry/node');
+        Sentry.init({
+            dsn: SENTRY_DSN,
+            environment: resolveEnvironment(),
+            release: this.config.version,
+            // Node defaults `server_name` to os.hostname(), which is often the user's real name
+            // (e.g. "jane-doe-macbook-pro"). sendDefaultPii covers IP addresses and similar, off by
+            // default but set explicitly since this reports from users' own machines.
+            sendDefaultPii: false,
+            serverName: 'loopress',
+        });
         Sentry.captureException(options.error, {
             contexts: { runtime: runtimeContext() },
-            extra: { argv: options.argv },
+            extra: { argv: redactArgv(options.argv) },
             tags: { command: options.id },
         });
         await Sentry.flush(2000);

package/dist/hooks/init.js

@@ -1,18 +1,10 @@
-import * as Sentry from '@sentry/node';
-import { consumeErrorReportingFlag, isTelemetryDisabled, resolveEnvironment, SENTRY_DSN } from '../lib/sentry.js';
-const hook = async function (options) {
-    consumeErrorReportingFlag(options.argv);
-    if (isTelemetryDisabled())
-        return;
-    try {
-        Sentry.init({
-            dsn: SENTRY_DSN,
-            environment: resolveEnvironment(),
-            release: this.config.version,
-        });
-    }
-    catch (error) {
-        this.debug('Failed to initialize Sentry: %O', error);
-    }
+import { authManager } from '../config/auth.manager.js';
+import { configManager } from '../config/project-config.manager.js';
+// configManager/authManager start unconfigured and throw if used before a directory is set.
+// This hook runs before any command and points them at oclif's native, per-platform config/data
+// directories as soon as the real CLI Config is available.
+const hook = async function ({ config }) {
+    configManager.setConfigDir(config.configDir);
+    authManager.setDataDir(config.dataDir);
 };
 export default hook;

package/dist/lib/local-callback-server.d.ts

@@ -1,12 +1,12 @@
 export type CallbackHelpers<T> = {
+    body: Record<string, string>;
     rejectWithPage: (page: string, error: Error) => void;
     resolveWithPage: (page: string, value: T) => void;
     respondBadRequest: (message: string) => void;
 };
 /**
- * Both `login` and `authorizeWithBrowser` send the user to a URL in their browser and need to
- * catch the resulting redirect on a short-lived local server; this factors out the server setup,
- * timeout, and browser-opening boilerplate they'd otherwise duplicate.
+ * Sends the user to a URL in their browser and catches the resulting redirect on a short-lived
+ * local server; this factors out the server setup, timeout, and browser-opening boilerplate.
  */
 export declare function waitForLocalCallback<T>(options: {
     buildUrl: (callbackBaseUrl: string) => string;

package/dist/lib/local-callback-server.js

@@ -1,9 +1,17 @@
 import { createServer } from 'node:http';
 import { openBrowser } from './open-browser.js';
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString('utf8');
+}
+function parseFormData(body) {
+    return Object.fromEntries(new URLSearchParams(body));
+}
 /**
- * Both `login` and `authorizeWithBrowser` send the user to a URL in their browser and need to
- * catch the resulting redirect on a short-lived local server; this factors out the server setup,
- * timeout, and browser-opening boilerplate they'd otherwise duplicate.
+ * Sends the user to a URL in their browser and catches the resulting redirect on a short-lived
+ * local server; this factors out the server setup, timeout, and browser-opening boilerplate.
  */
 export function waitForLocalCallback(options) {
     const timeoutMs = options.timeoutMs ?? 5 * 60 * 1000;
@@ -15,9 +23,10 @@ export function waitForLocalCallback(options) {
             server.close();
             settle();
         }
-        const server = createServer((req, res) => {
+        const server = createServer(async (req, res) => {
             try {
                 const url = new URL(req.url ?? '/', 'http://localhost');
+                const body = req.method === 'POST' ? parseFormData(await readBody(req)) : {};
                 options.handleRequest(url, {
                     rejectWithPage: (page, error) => finish(res, page, () => reject(error)),
                     resolveWithPage: (page, value) => finish(res, page, () => resolve(value)),
@@ -25,6 +34,7 @@ export function waitForLocalCallback(options) {
                         res.writeHead(400, { 'Content-Type': 'text/plain' });
                         res.end(message);
                     },
+                    body,
                 });
             }
             catch (error) {

package/dist/lib/open-browser.d.ts

@@ -1,2 +1,2 @@
-/** Opens `url` in the user's default browser, best-effort (no-op on unknown platforms). */
+/** Opens `url` in the user's default browser, best-effort. */
 export declare function openBrowser(url: string): void;

package/dist/lib/open-browser.js

@@ -1,12 +1,5 @@
-import { execFile } from 'node:child_process';
-/** Opens `url` in the user's default browser, best-effort (no-op on unknown platforms). */
+import open from 'open';
+/** Opens `url` in the user's default browser, best-effort. */
 export function openBrowser(url) {
-    const commands = {
-        darwin: ['open', [url]],
-        linux: ['xdg-open', [url]],
-        win32: ['cmd', ['/c', 'start', '', url]],
-    };
-    const command = commands[process.platform];
-    if (command)
-        execFile(...command);
+    open(url).catch(() => { });
 }

package/dist/lib/sentry.d.ts

@@ -1,8 +1,8 @@
 export declare const SENTRY_DSN = "https://a08dd56bfffc2a45d5b8f665e4cb8b7d@o4511586904309760.ingest.de.sentry.io/4511673275973712";
-export declare function consumeErrorReportingFlag(argv: string[]): void;
 export declare function isTelemetryDisabled(): boolean;
 export declare function resolveEnvironment(): string;
 export declare function runtimeContext(): {
     node: string;
     os: string;
 };
+export declare function redactArgv(argv: string[]): string[];

package/dist/lib/sentry.js

@@ -1,15 +1,13 @@
 import { platform, release } from 'node:os';
+import { configManager } from '../config/project-config.manager.js';
 // DSNs are write-only and safe to embed in a distributed CLI, see https://docs.sentry.io/product/security/#can-i-make-my-sentry-dsn-private
 export const SENTRY_DSN = 'https://a08dd56bfffc2a45d5b8f665e4cb8b7d@o4511586904309760.ingest.de.sentry.io/4511673275973712';
-export function consumeErrorReportingFlag(argv) {
-    const index = argv.indexOf('--no-error-reporting');
-    if (index === -1)
-        return;
-    argv.splice(index, 1);
-    process.env.LOOPRESS_TELEMETRY_DISABLED = '1';
-}
+// The env var takes priority so CI/ephemeral environments can opt out for a single run
+// without touching the persistent preference in the global config.json.
 export function isTelemetryDisabled() {
-    return process.env.LOOPRESS_TELEMETRY_DISABLED === '1';
+    if (process.env.LOOPRESS_TELEMETRY_DISABLED === '1')
+        return true;
+    return configManager.isTelemetryDisabled();
 }
 export function resolveEnvironment() {
     if (process.env.SENTRY_ENVIRONMENT)
@@ -22,3 +20,14 @@ export function runtimeContext() {
         os: `${platform()} ${release()}`,
     };
 }
+// Positional args and flag values can carry WordPress URLs, usernames, application passwords,
+// or tokens (e.g. `lps login --token xxx`, `lps project config <url>`). Only flag names are
+// safe to report, they help tell which code path crashed without leaking what was passed to it.
+export function redactArgv(argv) {
+    return argv.map((arg) => {
+        if (!arg.startsWith('-'))
+            return '[REDACTED]';
+        const eqIndex = arg.indexOf('=');
+        return eqIndex === -1 ? arg : arg.slice(0, eqIndex);
+    });
+}