@capacitor/cli 9.0.0-alpha.7 → 9.0.0-beta.0

package/dist/run-context/declared.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectDeclared = void 0;
+const agent_cli_detector_1 = require("agent-cli-detector");
+const registry_1 = require("./registry");
+const strategy = new agent_cli_detector_1.EnvironmentDetectionStrategy();
+/**
+ * Identify a registered harness from the variables it sets to announce itself.
+ *
+ * Driven through the strategy rather than the package's `detectAgent()` because
+ * that reduces to a bare `{ detected, agent }` and discards which variable
+ * matched — which callers need in order to report an unrecognised harness.
+ *
+ * Only the agent id and the session variable's *name* leave this function. The
+ * evidence also carries each matched variable's live value, and some of those
+ * hold access tokens, so nothing else from it is propagated.
+ */
+function detectDeclared(env) {
+    var _a, _b;
+    // `pid` and `maxProcessDepth` are required by the context type but unread by
+    // the environment strategy. Walking the process tree needs a subprocess call
+    // with no portable Windows equivalent, so this path stays environment-only.
+    const evidence = strategy.detect({
+        env,
+        agents: registry_1.capacitorAgents,
+        pid: 0,
+        maxProcessDepth: 0,
+    });
+    if (evidence.length === 0) {
+        return undefined;
+    }
+    const matchCounts = new Map();
+    for (const { agent } of evidence) {
+        matchCounts.set(agent.id, ((_a = matchCounts.get(agent.id)) !== null && _a !== void 0 ? _a : 0) + 1);
+    }
+    // One environment can satisfy several harnesses at once — an agent CLI run
+    // from inside another vendor's terminal declares both. Most matched signals
+    // wins; Map iteration preserves registry order, so ties resolve the same way
+    // on every platform instead of depending on `Object.keys(env)`.
+    let winner = '';
+    let best = 0;
+    for (const [id, count] of matchCounts) {
+        if (count > best) {
+            winner = id;
+            best = count;
+        }
+    }
+    const definition = registry_1.capacitorAgents.find((agent) => agent.id === winner);
+    return {
+        id: winner,
+        sessionVar: (_b = definition === null || definition === void 0 ? void 0 : definition.sessionEnv) === null || _b === void 0 ? void 0 : _b.find((name) => env[name]),
+    };
+}
+exports.detectDeclared = detectDeclared;

package/dist/run-context/index.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAgentDriven = exports.isCI = exports.detectRunContext = exports.CONVENTION_PATTERN = exports.CONVENTION_DENYLIST = void 0;
+const utils_terminal_1 = require("@ionic/utils-terminal");
+const net_1 = require("net");
+const declared_1 = require("./declared");
+const signals_1 = require("./signals");
+const unknown_1 = require("./unknown");
+const version_1 = require("./version");
+var unknown_2 = require("./unknown");
+Object.defineProperty(exports, "CONVENTION_DENYLIST", { enumerable: true, get: function () { return unknown_2.CONVENTION_DENYLIST; } });
+Object.defineProperty(exports, "CONVENTION_PATTERN", { enumerable: true, get: function () { return unknown_2.CONVENTION_PATTERN; } });
+/**
+ * Any single signal happens legitimately — a `cat` pager, a missing TTY, a
+ * local proxy. Three together, with no terminal anywhere, is what separates a
+ * machine-driven run from a developer with an unusual setup.
+ */
+const HEURISTIC_THRESHOLD = 3;
+/**
+ * Classify this invocation as human, CI, or agent-driven from the environment
+ * alone — no process spawn, no filesystem read.
+ *
+ * Every input is injectable and nothing is captured at module load, so tests
+ * can drive the whole thing. This is also why `@ionic/utils-terminal`'s
+ * `TERMINAL_INFO` isn't used: it snapshots the real process when the module is
+ * first imported and freezes it.
+ */
+function detectRunContext(options = {}) {
+    var _a, _b, _c, _d;
+    const env = (_a = options.env) !== null && _a !== void 0 ? _a : process.env;
+    const streams = (_b = options.streams) !== null && _b !== void 0 ? _b : readStreamStates();
+    const cwd = (_c = options.cwd) !== null && _c !== void 0 ? _c : process.cwd();
+    const execPath = (_d = options.execPath) !== null && _d !== void 0 ? _d : process.execPath;
+    const scan = (0, signals_1.scanSignals)(env, streams, cwd, execPath);
+    const surface = (0, signals_1.deriveSurface)(env, scan);
+    // CI is classified but never delivered, so nothing below needs to run.
+    if (isCI(env)) {
+        return { report: false, surface, confidence: 'none' };
+    }
+    const declared = (0, declared_1.detectDeclared)(env);
+    if (declared) {
+        return {
+            report: true,
+            agentId: declared.id,
+            agentVersion: (0, version_1.detectAgentVersion)(env, declared.id),
+            surface,
+            confidence: 'declared',
+            sessionVar: declared.sessionVar,
+        };
+    }
+    // Neither path below may report a run with a terminal attached, which makes
+    // "someone at a terminal is never reported as an agent" a guarantee rather
+    // than a likelihood. The convention rule needs the gate most: it matches on
+    // the shape of a variable name alone, which desktop sessions and shells also
+    // produce, yet returns the stronger `declared` confidence.
+    const headless = scan.headless.includes(signals_1.NO_TTY_SIGNAL);
+    const detectedBy = headless ? (0, unknown_1.detectUnknownHarness)(env) : undefined;
+    if (detectedBy) {
+        return {
+            report: true,
+            agentId: 'unknown',
+            agentDetectedBy: detectedBy,
+            surface,
+            confidence: 'declared',
+        };
+    }
+    // This path exists for harnesses that strip their environment before
+    // invoking the CLI.
+    const weight = headless ? scan.headless.length + scan.sandbox.length : 0;
+    if (weight >= HEURISTIC_THRESHOLD) {
+        return {
+            report: true,
+            agentId: 'unknown',
+            surface,
+            confidence: 'heuristic',
+        };
+    }
+    return { report: true, surface, confidence: 'none' };
+}
+exports.detectRunContext = detectRunContext;
+/**
+ * Whether this is a build server. Reuses the CLI's existing variable list
+ * rather than a copy of it, so the gate can't drift from `isInteractive()`.
+ */
+function isCI(env) {
+    return utils_terminal_1.CI_ENVIRONMENT_VARIABLES.some((name) => Boolean(env[name]));
+}
+exports.isCI = isCI;
+/**
+ * Whether something other than a person invoked the CLI. True for an
+ * unrecognised harness as well as a named one — both mean there is nobody
+ * waiting on the terminal.
+ */
+function isAgentDriven(runContext) {
+    return Boolean(runContext.agentId);
+}
+exports.isAgentDriven = isAgentDriven;
+function readStreamStates() {
+    const { stdin, stdout, stderr } = process;
+    return {
+        tty: [Boolean(stdin.isTTY), Boolean(stdout.isTTY), Boolean(stderr.isTTY)],
+        socket: [isPipe(stdin), isPipe(stdout), isPipe(stderr)],
+    };
+}
+/**
+ * `tty.ReadStream` extends `net.Socket`, so a real terminal has to be excluded
+ * rather than just testing the prototype.
+ */
+function isPipe(stream) {
+    return stream instanceof net_1.Socket && !stream.isTTY;
+}

package/dist/run-context/registry.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capacitorAgents = exports.overrideFor = exports.AGENT_OVERRIDES = void 0;
+const agent_cli_detector_1 = require("agent-cli-detector");
+/**
+ * Capacitor's additions to the published registry, keyed by the upstream agent
+ * id. `agent-cli-detector@0.1.7` matches Codex only through its sandbox
+ * markers, knows none of Claude Code's entrypoint or hosted-sandbox variables,
+ * and carries no version information for anyone.
+ *
+ * Keying against the package's own id union means a rename or removal upstream
+ * fails to compile instead of silently dropping the entry. It also means this
+ * map can only extend a harness the package already lists; a vendor it has
+ * never heard of needs an upstream addition first.
+ *
+ * Re-verify the version variables before every release — vendors rename them
+ * between versions.
+ *
+ * Claude Code's `CLAUDE_CODE_HOST_*_PROXY_PORT` variables are deliberately
+ * absent: a wildcard can't be expressed as an `EnvSignal.name`, and they are
+ * loopback proxy markers, so `signals.ts` matches them instead.
+ */
+exports.AGENT_OVERRIDES = {
+    antigravity: { versionVariable: 'ANTIGRAVITY_LS_VERSION' },
+    'claude-code': { env: [{ name: 'CLAUDE_CODE_ENTRYPOINT' }, { name: 'CLAUDE_TMPDIR' }] },
+    codex: {
+        env: [{ name: 'CODEX_VERSION' }, { name: 'CODEX_SANDBOX' }],
+        versionVariable: 'CODEX_VERSION',
+    },
+    kilocode: { versionVariable: 'KILOCODE_VERSION' },
+    muse: { versionVariable: 'MUSE_RELEASE_INFO', versionIsJson: true },
+};
+function overrideFor(agentId) {
+    return exports.AGENT_OVERRIDES[agentId];
+}
+exports.overrideFor = overrideFor;
+/**
+ * The published registry with Capacitor's additions layered on. Extending a
+ * listed harness means editing `AGENT_OVERRIDES` and nothing else.
+ */
+exports.capacitorAgents = agent_cli_detector_1.defaultAgents.map((agent) => {
+    var _a, _b;
+    const extra = (_a = overrideFor(agent.id)) === null || _a === void 0 ? void 0 : _a.env;
+    return extra ? { ...agent, env: [...((_b = agent.env) !== null && _b !== void 0 ? _b : []), ...extra] } : agent;
+});

package/dist/run-context/signals.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSurface = exports.scanSignals = exports.NO_TTY_SIGNAL = void 0;
+/**
+ * No standard stream is attached to a terminal. The strongest of the headless
+ * signals, and the one the heuristic verdict is gated on.
+ */
+exports.NO_TTY_SIGNAL = 'no-tty';
+/**
+ * Variables whose value is a proxy target. The `_PORT` spelling is how hosted
+ * Claude Code sandboxes expose theirs.
+ */
+const PROXY_VARIABLE_PATTERN = /_PROXY$|_PROXY_PORT$|^(?:HTTP|HTTPS|ALL)_PROXY$/;
+const LOOPBACK_PATTERN = /(?:^|\/\/|@)(?:127\.0\.0\.1|localhost|\[::1\]|0\.0\.0\.0)(?::\d+)?(?:$|[/?])/i;
+/**
+ * Some hosted sandboxes mint an adjective-adjective-surname username per
+ * session. Inferred from observed sandboxes, not documented by any vendor —
+ * which is why it only ever contributes to a heuristic verdict.
+ */
+const GENERATED_USERNAME_PATTERN = /^[a-z]+[-_][a-z]+[-_][a-z]+$/;
+/** A session-scoped mount carries a generated id in its path. Also inferred. */
+const SESSION_MOUNT_PATTERN = /[/\\](?:sessions?|workspaces?)[/\\][0-9a-f][0-9a-f-]{7,}/i;
+const JAVA_AGENT_PATTERN = /-javaagent/i;
+const JETBRAINS_TERMINAL_PATTERN = /jetbrains/i;
+function scanSignals(env, streams, cwd, execPath) {
+    return {
+        headless: scanHeadless(env, streams),
+        sandbox: scanSandbox(env, cwd, execPath),
+    };
+}
+exports.scanSignals = scanSignals;
+/**
+ * Derive the execution environment, most specific match first. Independent of
+ * the agent verdict by design, so a terminal agent and an IDE agent are
+ * distinguishable downstream.
+ */
+function deriveSurface(env, scan) {
+    if (scan.sandbox.length > 0) {
+        return 'cloud-sandbox';
+    }
+    if (isDesktopShell(env)) {
+        return 'desktop-app';
+    }
+    if (isIde(env)) {
+        return 'ide';
+    }
+    return 'terminal';
+}
+exports.deriveSurface = deriveSurface;
+function scanHeadless(env, streams) {
+    const signals = [];
+    if (!streams.tty.some(Boolean)) {
+        signals.push(exports.NO_TTY_SIGNAL);
+    }
+    if (streams.socket.some(Boolean)) {
+        signals.push('stream-socket');
+    }
+    // A human wouldn't set contradictory color rules; a wrapper assembling an
+    // environment from defaults does.
+    if (env.NO_COLOR && env.CLICOLOR_FORCE) {
+        signals.push('contradictory-color');
+    }
+    if (env.PAGER === 'cat' || env.GIT_PAGER === 'cat' || env.GIT_EDITOR === 'true') {
+        signals.push('pager-disabled');
+    }
+    if (isDesktopShell(env)) {
+        signals.push('gui-bundle-no-term');
+    }
+    return signals;
+}
+function scanSandbox(env, cwd, execPath) {
+    var _a, _b;
+    const signals = [];
+    if (countLoopbackProxies(env) >= 3) {
+        signals.push('loopback-proxies');
+    }
+    if (env.SANDBOX_RUNTIME) {
+        signals.push('sandbox-runtime');
+    }
+    if (env.JAVA_TOOL_OPTIONS && JAVA_AGENT_PATTERN.test(env.JAVA_TOOL_OPTIONS)) {
+        signals.push('java-tool-options-agent');
+    }
+    if (GENERATED_USERNAME_PATTERN.test((_b = (_a = env.USER) !== null && _a !== void 0 ? _a : env.USERNAME) !== null && _b !== void 0 ? _b : '')) {
+        signals.push('generated-username');
+    }
+    if (SESSION_MOUNT_PATTERN.test(cwd) || SESSION_MOUNT_PATTERN.test(execPath)) {
+        signals.push('session-mount');
+    }
+    return signals;
+}
+function countLoopbackProxies(env) {
+    return Object.entries(env).filter(([name, value]) => {
+        const normalized = name.toUpperCase();
+        if (!value || !PROXY_VARIABLE_PATTERN.test(normalized)) {
+            return false;
+        }
+        // A bare port is only ever a local one, so `*_PROXY_PORT` needs no host.
+        return normalized.endsWith('_PORT') ? /^\d+$/.test(value) : LOOPBACK_PATTERN.test(value);
+    }).length;
+}
+/**
+ * A GUI application spawned a bare shell. Shared by the headless scan and the
+ * surface derivation so the two can't drift apart.
+ */
+function isDesktopShell(env) {
+    return Boolean(env.__CFBundleIdentifier || env.ELECTRON_RUN_AS_NODE) && !env.TERM;
+}
+function isIde(env) {
+    var _a;
+    return Boolean(env.VSCODE_PID ||
+        env.VSCODE_GIT_ASKPASS_NODE ||
+        env.JETBRAINS_IDE ||
+        env.TERM_PROGRAM === 'vscode' ||
+        JETBRAINS_TERMINAL_PATTERN.test((_a = env.TERMINAL_EMULATOR) !== null && _a !== void 0 ? _a : ''));
+}

package/dist/run-context/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/run-context/unknown.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectUnknownHarness = exports.CONVENTION_DENYLIST = exports.CONVENTION_PATTERN = void 0;
+/**
+ * Agent harnesses name their declaring variables consistently, so one missing
+ * from the registry can still be noticed by shape alone. A name that shows up
+ * across many projects is the signal to register the vendor properly.
+ */
+exports.CONVENTION_PATTERN = /^[A-Z0-9_]+_(AGENT|TOOL_USE_ID|SESSION_ID|THREAD_ID|CONVERSATION_ID|TRAJECTORY_ID)$/;
+/**
+ * Non-agent tools that follow the same convention. Terminals, SSH and GPG all
+ * mint session identifiers of their own. Tested one entry at a time.
+ *
+ * The caller only consults this rule for a run with no terminal attached, so a
+ * name missing here can only affect a headless run.
+ */
+exports.CONVENTION_DENYLIST = [
+    'TERM_SESSION_ID',
+    'ITERM_SESSION_ID',
+    'SSH_SESSION_ID',
+    'XDG_SESSION_ID',
+    'USER_AGENT',
+    'HTTP_USER_AGENT',
+    'GPG_AGENT',
+    'SSH_AGENT',
+];
+/**
+ * Return the name of the first variable that looks like an unregistered
+ * harness, or undefined. Names are sorted so the result doesn't depend on
+ * environment insertion order.
+ */
+function detectUnknownHarness(env) {
+    for (const name of Object.keys(env).sort()) {
+        // Windows environment variables are case-insensitive, so normalize before
+        // both tests — otherwise a denylisted name in mixed case slips through.
+        const normalized = name.toUpperCase();
+        if (exports.CONVENTION_DENYLIST.includes(normalized)) {
+            continue;
+        }
+        if (exports.CONVENTION_PATTERN.test(normalized)) {
+            return name;
+        }
+    }
+    return undefined;
+}
+exports.detectUnknownHarness = detectUnknownHarness;

package/dist/run-context/version.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAgentVersion = void 0;
+const semver_1 = require("semver");
+const registry_1 = require("./registry");
+/**
+ * Several harnesses set `AI_AGENT` in a shared `<vendor>_<version>_agent`
+ * format, with the version's dots written as dashes. It's the only
+ * non-per-vendor source, so a harness adopting the convention is picked up
+ * without a registry change.
+ */
+const AI_AGENT_PATTERN = /^[A-Za-z0-9-]+_(\d[\d-]*)_agent$/;
+/**
+ * Resolve the harness version from the first source that carries one.
+ *
+ * "First source" means first *present*, not first valid: a harness that sets
+ * `AI_AGENT` to something malformed reports `unknown` rather than falling
+ * through to a variable it never set.
+ *
+ * Both sources are environment variables by design. The executable path looks
+ * like a third, but it is always the Node binary running the CLI rather than
+ * the harness's entrypoint — reading a version out of it reports the user's
+ * nvm or Homebrew Node version as the agent's.
+ */
+function detectAgentVersion(env, agentId) {
+    var _a;
+    const raw = (_a = fromAiAgent(env)) !== null && _a !== void 0 ? _a : fromVendorVariable(env, agentId);
+    return raw && (0, semver_1.valid)(raw) ? raw : 'unknown';
+}
+exports.detectAgentVersion = detectAgentVersion;
+function fromAiAgent(env) {
+    const value = env.AI_AGENT;
+    if (!value) {
+        return undefined;
+    }
+    const match = AI_AGENT_PATTERN.exec(value);
+    // An unparseable value is still a hit — it gets rejected by semver below.
+    return match ? match[1].replace(/-/g, '.') : value;
+}
+function fromVendorVariable(env, agentId) {
+    var _a;
+    const override = (0, registry_1.overrideFor)(agentId);
+    if (!(override === null || override === void 0 ? void 0 : override.versionVariable)) {
+        return undefined;
+    }
+    const value = env[override.versionVariable];
+    if (!value) {
+        return undefined;
+    }
+    return override.versionIsJson ? ((_a = fromJson(value)) !== null && _a !== void 0 ? _a : value) : value;
+}
+/**
+ * Pull a version out of a JSON-valued vendor variable. The field name isn't
+ * documented by any vendor we've seen, so the common spellings are tried and
+ * anything else falls through to semver rejection.
+ */
+function fromJson(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed !== 'object' || parsed === null) {
+            return undefined;
+        }
+        const record = parsed;
+        for (const field of ['version', 'release', 'tag']) {
+            if (typeof record[field] === 'string') {
+                return record[field];
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/tasks/copy.js

@@ -57,7 +57,9 @@ async function copy(config, platformName, inline = false) {
             usesLiveUpdates = true;
         }
         let usesSSLPinning = false;
-        if (allPlugins.filter((plugin) => plugin.id === '@ionic-enterprise/ssl-pinning' || plugin.id === '@capacitor/ssl-pinning').length > 0) {
+        if (allPlugins.filter((plugin) => plugin.id === '@ionic-enterprise/ssl-pinning' ||
+            plugin.id === '@capacitor/ssl-pinning' ||
+            plugin.id === '@capacitor-community/ssl-pinning').length > 0) {
             usesSSLPinning = true;
         }
         if (platformName === config.ios.name) {

package/dist/tasks/doctor.js

@@ -10,6 +10,7 @@ const doctor_2 = require("../ios/doctor");
 const log_1 = require("../log");
 const emoji_1 = require("../util/emoji");
 const node_1 = require("../util/node");
+const npm_1 = require("../util/npm");
 const subprocess_1 = require("../util/subprocess");
 async function doctorCommand(config, selectedPlatformName) {
     log_1.output.write(`${(0, emoji_1.emoji)('💊', '')}   ${colors_1.default.strong('Capacitor Doctor')}  ${(0, emoji_1.emoji)('💊', '')} \n\n`);
@@ -21,11 +22,12 @@ async function doctorCommand(config, selectedPlatformName) {
 }
 exports.doctorCommand = doctorCommand;
 async function doctorCore(config) {
-    const [cliVersion, coreVersion, androidVersion, iosVersion] = await Promise.all([
+    const [cliVersion, coreVersion, androidVersion, iosVersion, blockedInstallScripts] = await Promise.all([
         (0, subprocess_1.getCommandOutput)('npm', ['info', '@capacitor/cli', 'version']),
         (0, subprocess_1.getCommandOutput)('npm', ['info', '@capacitor/core', 'version']),
         (0, subprocess_1.getCommandOutput)('npm', ['info', '@capacitor/android', 'version']),
         (0, subprocess_1.getCommandOutput)('npm', ['info', '@capacitor/ios', 'version']),
+        (0, npm_1.getBlockedInstallScripts)(config.app.rootDir),
     ]);
     log_1.output.write(`${colors_1.default.strong('Latest Dependencies:')}\n\n` +
         `  @capacitor/cli: ${colors_1.default.weak(cliVersion !== null && cliVersion !== void 0 ? cliVersion : 'unknown')}\n` +
@@ -35,6 +37,7 @@ async function doctorCore(config) {
         `${colors_1.default.strong('Installed Dependencies:')}\n\n`);
     await printInstalledPackages(config);
     log_1.output.write('\n');
+    (0, npm_1.logBlockedInstallScripts)(blockedInstallScripts);
 }
 exports.doctorCore = doctorCore;
 async function printInstalledPackages(config) {

package/dist/tasks/list.js

@@ -26,7 +26,7 @@ async function listCommand(config, selectedPlatformName) {
 exports.listCommand = listCommand;
 async function list(config, platform) {
     const allPlugins = await (0, plugin_1.getPlugins)(config, platform);
-    let plugins = [];
+    let plugins;
     if (platform === config.ios.name) {
         plugins = await (0, common_3.getIOSPlugins)(allPlugins);
     }

package/dist/tasks/migrate-debug-xcconfig.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testables = exports.removeDebugXcconfig = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const log_1 = require("../log");
+const spm_1 = require("../util/spm");
+const xcode_1 = require("../util/xcode");
+const STOCK_LINE = /^CAPACITOR_DEBUG\s*=\s*true$/;
+async function removeDebugXcconfig(config) {
+    if ((await config.ios.packageManager) !== 'SPM') {
+        return;
+    }
+    const xcconfigPath = (0, path_1.join)(config.ios.platformDirAbs, 'debug.xcconfig');
+    const state = classifyDebugXcconfig(xcconfigPath);
+    if (state === 'customized') {
+        log_1.logger.warn(`${xcconfigPath} declares build settings besides CAPACITOR_DEBUG, leaving it in place. ` +
+            `Remove the CAPACITOR_DEBUG line yourself — Capacitor 9 no longer reads it.`);
+    }
+    else if (state === 'stock' && unregisterFromXcodeProject(config)) {
+        await (0, fs_extra_1.remove)(xcconfigPath);
+        log_1.logger.info(`Removed ${xcconfigPath}.`);
+    }
+    const result = (0, spm_1.removeInfoPlistDebug)(config);
+    if (result.status === 'skipped') {
+        log_1.logger.warn(`CAPACITOR_DEBUG not removed from Info.plist: ${result.reason}`);
+    }
+}
+exports.removeDebugXcconfig = removeDebugXcconfig;
+/**
+ * Deleting the file while the Debug build configuration still points at it fails the
+ * Xcode build, so the file only goes once the project has been rewritten.
+ */
+function unregisterFromXcodeProject(config) {
+    var _a;
+    const pbxprojPath = (0, path_1.join)(config.ios.nativeXcodeProjDirAbs, 'project.pbxproj');
+    try {
+        (0, xcode_1.removeBaseConfigurationFile)(pbxprojPath, 'debug.xcconfig');
+        return true;
+    }
+    catch (err) {
+        log_1.logger.warn(`Could not remove the debug.xcconfig reference from ${pbxprojPath}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}. ` +
+            `Remove debug.xcconfig from the Xcode project manually.`);
+        return false;
+    }
+}
+function classifyDebugXcconfig(path) {
+    if (!(0, fs_extra_1.existsSync)(path)) {
+        return 'absent';
+    }
+    const settings = (0, fs_extra_1.readFileSync)(path, 'utf-8')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith('//'));
+    return settings.every((line) => STOCK_LINE.test(line)) ? 'stock' : 'customized';
+}
+// Exported for tests.
+exports.__testables = {
+    classifyDebugXcconfig,
+};

package/dist/tasks/migrate-spm.js

@@ -15,7 +15,6 @@ async function migrateToSPM(config) {
     await (0, spm_1.extractSPMPackageDirectory)(config);
     await (0, spm_1.runCocoapodsDeintegrate)(config);
     await (0, spm_1.removeCocoapodsFiles)(config);
-    await (0, spm_1.addInfoPlistDebugIfNeeded)(config);
     const configWritable = config;
     configWritable.ios.packageManager = Promise.resolve('SPM');
     await (0, update_1.update)(configWritable, 'ios', false);