nativescript 9.1.0-alpha.1 → 9.1.0-alpha.11

package/lib/services/bundler/bundler-compiler-service.js

@@ -8,6 +8,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BundlerCompilerService = void 0;
 const path = require("path");
+const net = require("net");
 const semver = require("semver");
 const _ = require("lodash");
 const events_1 = require("events");
@@ -34,8 +35,15 @@ class BundlerCompilerService extends events_1.EventEmitter {
         this.$packageInstallationManager = $packageInstallationManager;
         this.$projectConfigService = $projectConfigService;
         this.bundlerProcesses = {};
+        // Vite-only: the long-lived `vite serve` dev server the device fetches
+        // modules and HMR updates from. Keyed by platform, managed by this CLI
+        // so users no longer need a separate `concurrently`/`wait-on` process.
+        this.viteServeProcesses = {};
         this.expectedHashes = {};
     }
+    getViteDistOutputPath(projectDir) {
+        return path.join(projectDir, process.env.NS_VITE_DIST_DIR || constants_1.VITE_DIST_FOLDER_NAME);
+    }
     async compileWithWatch(platformData, projectData, prepareData) {
         return new Promise(async (resolve, reject) => {
             if (this.bundlerProcesses[platformData.platformNameLowerCase]) {
@@ -44,6 +52,14 @@ class BundlerCompilerService extends events_1.EventEmitter {
             }
             let isFirstBundlerWatchCompilation = true;
             prepareData.watch = true;
+            // Bring up the Vite HMR dev server the device fetches modules /
+            // HMR updates from. No-op unless bundler is vite + hmr + watch.
+            // Fired in parallel with the build watcher; both child processes
+            // inherit the adb-reverse env the run-controller set before
+            // prepare, so neither one spawns adb on its own. Intentionally not
+            // awaited — the device only connects to it at app launch, well
+            // after the first build.
+            this.startViteDevServer(platformData, projectData, prepareData);
             try {
                 const childProcess = await this.startBundleProcess(platformData, projectData, prepareData);
                 // Handle Vite differently from webpack
@@ -67,7 +83,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
                             console.log("Received Vite IPC message:", message);
                         }
                         // Copy Vite output files directly to platform destination
-                        const distOutput = path.join(projectData.projectDir, constants_1.VITE_DIST_FOLDER_NAME);
+                        const distOutput = this.getViteDistOutputPath(projectData.projectDir);
                         const destDir = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
                         if (debugLog) {
                             console.log(`Copying from ${distOutput} to ${destDir}.`);
@@ -232,7 +248,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
                         // launch with `Check failed: has_pending_exception()`.
                         if (isVite) {
                             try {
-                                const distOutput = path.join(projectData.projectDir, constants_1.VITE_DIST_FOLDER_NAME);
+                                const distOutput = this.getViteDistOutputPath(projectData.projectDir);
                                 const destDir = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
                                 this.copyViteBundleToNative(distOutput, destDir);
                             }
@@ -343,6 +359,141 @@ class BundlerCompilerService extends events_1.EventEmitter {
         await this.$cleanupService.addKillProcess(childProcess.pid.toString());
         return childProcess;
     }
+    getViteHmrPort() {
+        const fromEnv = Number(process.env.NS_HMR_PORT);
+        return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 5173;
+    }
+    /**
+     * Spawn and manage the Vite dev server (`vite serve`) for HMR.
+     *
+     * Why the CLI owns this. With Vite, HMR needs a long-lived dev server
+     * (HTTP + the `/ns-hmr` websocket on port 5173) that the device fetches
+     * modules and hot updates from — it is SEPARATE from the
+     * `vite build --watch` process that emits the `bundle.mjs` bootstrap
+     * baked into the app. Historically users wired this up themselves with
+     * `concurrently`/`wait-on`, which left two uncoordinated processes both
+     * touching adb during cold start (the source of the Android
+     * "Searching for devices…" freeze). By spawning it here as a child of
+     * the CLI, the dev server inherits the CLI's environment — crucially
+     * `NS_ADB_REVERSE_READY`/`NS_DEVICE_SERIAL`/`NS_ADB_PATH` set by the
+     * run-controller — so the CLI is the single adb owner and the dev
+     * server never spawns adb itself.
+     *
+     * No-op unless bundler is vite, HMR is on, watch mode, and not release.
+     * Best-effort: failures are logged, never thrown — a dev-server hiccup
+     * must not fail the run.
+     */
+    async startViteDevServer(platformData, projectData, prepareData) {
+        try {
+            if (this.getBundler() !== "vite") {
+                return;
+            }
+            if (!prepareData.watch || !prepareData.hmr || prepareData.release) {
+                return;
+            }
+            const key = platformData.platformNameLowerCase;
+            if (this.viteServeProcesses[key]) {
+                return;
+            }
+            const port = this.getViteHmrPort();
+            // One dev server per port. Simultaneous multi-platform HMR in a
+            // single CLI invocation would collide on 5173 — that case still
+            // needs a distinct NS_HMR_PORT per platform, so skip + warn rather
+            // than fail to bind.
+            const collidingPlatform = Object.keys(this.viteServeProcesses)[0];
+            if (collidingPlatform) {
+                this.$logger.warn(`Vite dev server already running for '${collidingPlatform}' on port ${port}; skipping a second server for '${key}'. For simultaneous multi-platform HMR, set a distinct NS_HMR_PORT per platform.`);
+                return;
+            }
+            const envData = this.buildEnvData(platformData.platformNameLowerCase, projectData, prepareData);
+            const cliArgs = await this.buildEnvCommandLineParams(envData, platformData, projectData, prepareData);
+            const additionalNodeArgs = semver.major(process.version) <= 8 ? ["--harmony"] : [];
+            if (await this.shouldUsePreserveSymlinksOption()) {
+                additionalNodeArgs.push("--preserve-symlinks");
+            }
+            // `vite serve` (not `build`): runs the dev server and watches on
+            // its own — no `--watch`. Env flags (`--env.android --env.hmr …`)
+            // go after `--` so vite's CLI doesn't choke on unknown options.
+            const args = [
+                ...additionalNodeArgs,
+                this.getBundlerExecutablePath(projectData),
+                "serve",
+                `--config=${projectData.bundlerConfigPath}`,
+                `--mode=development`,
+                "--",
+                ...cliArgs,
+            ].filter(Boolean);
+            const options = {
+                cwd: projectData.projectDir,
+                // Inherit so the dev server's URLs/logs stream to the user as
+                // before. No IPC needed here — the build watcher provides the
+                // bundle-complete IPC; the dev server is fetched over HTTP/ws.
+                stdio: "inherit",
+                env: {
+                    ...process.env,
+                    NATIVESCRIPT_BUNDLER_ENV: JSON.stringify(envData),
+                },
+            };
+            if (this.$hostInfo.isWindows) {
+                Object.assign(options.env, { APPDATA: process.env.appData });
+            }
+            this.$logger.info(`Starting Vite dev server (HMR) for ${key} on port ${port}…`);
+            const childProcess = this.$childProcess.spawn(process.execPath, args, options);
+            this.viteServeProcesses[key] = childProcess;
+            await this.$cleanupService.addKillProcess(childProcess.pid.toString());
+            childProcess.once("exit", (code) => {
+                delete this.viteServeProcesses[key];
+                if (code) {
+                    this.$logger.warn(`Vite dev server for ${key} exited with code ${code}.`);
+                }
+            });
+            // Bounded readiness probe so we can surface a clear log once the
+            // device can actually reach modules.
+            const ready = await this.waitForPort(port, 30000);
+            if (ready) {
+                this.$logger.info(`Vite dev server ready on port ${port} (HMR for ${key}).`);
+            }
+            else {
+                this.$logger.trace(`Vite dev server port ${port} not observed open within the readiness probe window; continuing (it may bind shortly).`);
+            }
+        }
+        catch (err) {
+            this.$logger.warn(`Failed to start the Vite dev server: ${err}. HMR may be unavailable.`);
+        }
+    }
+    /**
+     * Resolve true once `127.0.0.1:<port>` accepts a TCP connection, or
+     * false after `timeoutMs`. Used to detect the Vite dev server is up.
+     */
+    waitForPort(port, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        return new Promise((resolve) => {
+            const attempt = () => {
+                const socket = net.connect({ port, host: "127.0.0.1" });
+                let settled = false;
+                const done = (ok) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    socket.destroy();
+                    if (ok) {
+                        resolve(true);
+                    }
+                    else if (Date.now() >= deadline) {
+                        resolve(false);
+                    }
+                    else {
+                        setTimeout(attempt, 250);
+                    }
+                };
+                socket.once("connect", () => done(true));
+                socket.once("error", () => done(false));
+                socket.setTimeout(1000, () => done(false));
+            };
+            attempt();
+        });
+    }
     buildEnvData(platform, projectData, prepareData) {
         var _a, _b, _c;
         const { env } = prepareData;
@@ -474,6 +625,13 @@ class BundlerCompilerService extends events_1.EventEmitter {
             bundlerProcess.kill("SIGINT");
             delete this.bundlerProcesses[platform];
         }
+        // Tear down the Vite dev server we manage alongside the build watcher.
+        const viteServeProcess = this.viteServeProcesses[platform];
+        if (viteServeProcess) {
+            await this.$cleanupService.removeKillProcess(viteServeProcess.pid.toString());
+            viteServeProcess.kill("SIGINT");
+            delete this.viteServeProcesses[platform];
+        }
     }
     handleHMRMessage(message, platformData, projectData, prepareData) {
         // handle new bundler hmr packets

package/lib/services/ios/spm-service.js

@@ -3,11 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SPMService = void 0;
 const yok_1 = require("../../common/yok");
 const trapezedev_project_1 = require("@nstudio/trapezedev-project");
+const color_1 = require("../../color");
 const path = require("path");
 class SPMService {
-    constructor($logger, $projectConfigService, $xcodebuildCommandService, $xcodebuildArgsService) {
+    constructor($logger, $fs, $projectConfigService, $terminalSpinnerService, $xcodebuildCommandService, $xcodebuildArgsService) {
         this.$logger = $logger;
+        this.$fs = $fs;
         this.$projectConfigService = $projectConfigService;
+        this.$terminalSpinnerService = $terminalSpinnerService;
         this.$xcodebuildCommandService = $xcodebuildCommandService;
         this.$xcodebuildArgsService = $xcodebuildArgsService;
     }
@@ -24,7 +27,7 @@ class SPMService {
     mergePluginSPMPackages(appPackages, pluginPackages) {
         // include swift packages from plugin configs
         // but allow app packages to override plugin packages with the same name
-        const appPackageNames = new Set(appPackages.map(pkg => pkg.name));
+        const appPackageNames = new Set(appPackages.map((pkg) => pkg.name));
         for (const pluginPkg of pluginPackages) {
             if (appPackageNames.has(pluginPkg.name)) {
                 this.$logger.trace(`SPM: app package overrides plugin package: ${pluginPkg.name}`);
@@ -39,7 +42,7 @@ class SPMService {
     // 	return this.getSPMPackages(projectData).length > 0;
     // }
     async applySPMPackages(platformData, projectData, pluginSpmPackages) {
-        var _a;
+        var _a, _b;
         try {
             const spmPackages = this.getSPMPackages(projectData, platformData.platformNameLowerCase);
             if (pluginSpmPackages === null || pluginSpmPackages === void 0 ? void 0 : pluginSpmPackages.length) {
@@ -79,23 +82,180 @@ class SPMService {
             }
             await project.commit();
             // finally resolve the dependencies
-            await this.resolveSPMDependencies(platformData, projectData);
+            await this.resolveSPMDependencies(platformData, projectData, {
+                showProgress: true,
+            });
         }
         catch (err) {
+            // best-effort, but don't bury the failure below trace level — a red
+            // resolve spinner with no visible reason is confusing. Warn with the
+            // message, keep the full error at trace.
+            this.$logger.warn(`Failed to apply Swift Package dependencies: ${(_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}`);
             this.$logger.trace("SPM: error applying SPM packages: ", err);
         }
     }
-    async resolveSPMDependencies(platformData, projectData) {
-        await this.$xcodebuildCommandService.executeCommand(this.$xcodebuildArgsService
+    /**
+     * Resolves (downloads + pins) the Swift Package dependencies referenced by
+     * the Xcode project. On a first build this is where the NativeScript runtime
+     * (now distributed as a remote Swift package) and any other SPM packages are
+     * actually downloaded — which can take a while. Pass `showProgress` to render
+     * a live spinner so the CLI doesn't look stalled while that happens.
+     *
+     * In verbose mode (`--log trace`) the condensed spinner is bypassed and
+     * xcodebuild's raw resolution log is streamed straight through instead.
+     */
+    async resolveSPMDependencies(platformData, projectData, options) {
+        const args = this.$xcodebuildArgsService
             .getXcodeProjectArgs(platformData, projectData)
             .concat([
             "-destination",
             "generic/platform=iOS",
             "-resolvePackageDependencies",
-        ]), {
-            cwd: projectData.projectDir,
-            message: "Resolving SPM dependencies...",
-        });
+        ]);
+        // Without progress, or when verbose: let xcodebuild's own resolution log
+        // stream straight to the terminal (inherited stdio). Verbose users want
+        // the raw log, not a condensed spinner that hides it.
+        if (!(options === null || options === void 0 ? void 0 : options.showProgress) || this.$logger.isVerbose()) {
+            await this.$xcodebuildCommandService.executeCommand(args, {
+                cwd: projectData.projectDir,
+                message: "Resolving Swift Package dependencies...",
+            });
+            return;
+        }
+        const spinner = this.$terminalSpinnerService.createSpinner();
+        const startedAt = Date.now();
+        let activity = "Resolving Swift Package dependencies";
+        let lineBuffer = "";
+        const render = () => {
+            const elapsed = Math.round((Date.now() - startedAt) / 1000);
+            spinner.text = `${activity}… ${color_1.color.dim(`(${elapsed}s)`)}`;
+        };
+        // keep the elapsed timer ticking even when xcodebuild is silent (e.g.
+        // while a binary artifact downloads) so the user can see it's alive.
+        const ticker = setInterval(render, 1000);
+        const onProgress = (chunk) => {
+            lineBuffer += chunk.data;
+            const lines = lineBuffer.split("\n");
+            // keep the last (possibly partial) line in the buffer
+            lineBuffer = lines.pop();
+            for (const line of lines) {
+                const described = this.describeSPMActivity(line);
+                if (described) {
+                    activity = described;
+                    render();
+                }
+            }
+        };
+        render();
+        spinner.start();
+        try {
+            await this.$xcodebuildCommandService.executeCommand(args, {
+                cwd: projectData.projectDir,
+                onProgress,
+            });
+            spinner.succeed(color_1.color.green("Swift Package dependencies resolved"));
+        }
+        catch (err) {
+            spinner.fail(color_1.color.red("Failed to resolve Swift Package dependencies"));
+            throw err;
+        }
+        finally {
+            clearInterval(ticker);
+        }
+    }
+    /**
+     * Best-effort pre-resolve before a build so the (potentially slow) first-time
+     * Swift package download happens under a clear progress indicator instead of
+     * silently inside the subsequent "Xcode build..." step. No-op when the
+     * project has no SPM references or they're already resolved.
+     */
+    async ensureSPMDependenciesResolved(platformData, projectData) {
+        if (!this.hasSPMReferences(platformData, projectData)) {
+            this.$logger.trace("SPM: project has no Swift Package references.");
+            return;
+        }
+        if (this.arePackagesResolved(platformData, projectData)) {
+            this.$logger.trace("SPM: Swift Package dependencies already resolved; skipping pre-resolve.");
+            return;
+        }
+        try {
+            await this.resolveSPMDependencies(platformData, projectData, {
+                showProgress: true,
+            });
+        }
+        catch (err) {
+            // non-fatal: the build itself will resolve packages and surface the
+            // authoritative error if something is genuinely wrong.
+            this.$logger.trace("SPM: pre-resolve failed (continuing): ", err);
+        }
+    }
+    /**
+     * Maps a raw xcodebuild/SwiftPM resolution log line to a concise,
+     * user-facing activity description (or null for lines we don't surface).
+     */
+    describeSPMActivity(line) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return null;
+        }
+        // the big, otherwise-silent wait on a first build: a binary artifact
+        // (the NativeScript runtime xcframework) downloading.
+        if (/Downloading binary artifact/i.test(trimmed)) {
+            if (/ios-spm|nativescript/i.test(trimmed)) {
+                return "Downloading the NativeScript runtime (first build only)";
+            }
+            return "Downloading Swift Package binaries (first build only)";
+        }
+        if (/^Fetching\b/i.test(trimmed)) {
+            return `Fetching ${this.shortenPackageRef(trimmed)}`;
+        }
+        if (/^Cloning\b/i.test(trimmed)) {
+            return `Cloning ${this.shortenPackageRef(trimmed)}`;
+        }
+        if (/Computing version for/i.test(trimmed)) {
+            return "Computing package versions";
+        }
+        if (/Resolve Package Graph/i.test(trimmed)) {
+            return "Resolving Swift Package graph";
+        }
+        if (/Resolved source packages/i.test(trimmed)) {
+            return "Finalizing Swift Package dependencies";
+        }
+        return null;
+    }
+    /** Extracts a short, readable name from a SwiftPM repo URL/log line. */
+    shortenPackageRef(line) {
+        const match = line.match(/https?:\/\/\S+/);
+        if (!match) {
+            return "Swift Packages";
+        }
+        return path
+            .basename(match[0])
+            .replace(/\.git$/, "")
+            .replace(/[)\s].*$/, "");
+    }
+    /** True when the Xcode project references any Swift packages. */
+    hasSPMReferences(platformData, projectData) {
+        const pbxprojPath = path.join(platformData.projectRoot, `${projectData.projectName}.xcodeproj`, "project.pbxproj");
+        if (!this.$fs.exists(pbxprojPath)) {
+            return false;
+        }
+        const contents = this.$fs.readText(pbxprojPath);
+        return (contents.includes("XCRemoteSwiftPackageReference") ||
+            contents.includes("XCLocalSwiftPackageReference") ||
+            contents.includes("packageReferences"));
+    }
+    /**
+     * True when a Package.resolved already exists for the project — i.e. packages
+     * have been resolved at least once, so the build's own resolve step will be a
+     * fast no-op rather than a slow, silent first-time download.
+     */
+    arePackagesResolved(platformData, projectData) {
+        const candidates = [
+            path.join(platformData.projectRoot, `${projectData.projectName}.xcworkspace`, "xcshareddata", "swiftpm", "Package.resolved"),
+            path.join(platformData.projectRoot, `${projectData.projectName}.xcodeproj`, "project.xcworkspace", "xcshareddata", "swiftpm", "Package.resolved"),
+        ];
+        return candidates.some((p) => this.$fs.exists(p));
     }
 }
 exports.SPMService = SPMService;

package/lib/services/ios/xcodebuild-args-service.js

@@ -100,10 +100,17 @@ class XcodebuildArgsService {
         // Introduced in Xcode 14+
         // ref: https://forums.swift.org/t/telling-xcode-14-beta-4-to-trust-build-tool-plugins-programatically/59305/5
         const skipPackageValidation = "-skipPackagePluginValidation";
+        // Introduced in Xcode 15+ to trust Swift macros (compiler plugins)
+        // non-interactively. Required for SPM packages that ship macros
+        // (e.g. apple/RealityKitScripting), otherwise the build fails with:
+        // "Macro '...' from package '...' must be enabled before it can be used"
+        // ref: https://developer.apple.com/documentation/xcode/writing-swift-macros
+        const skipMacroValidation = "-skipMacroValidation";
         const extraArgs = [
             "-scheme",
             projectData.projectName,
             skipPackageValidation,
+            skipMacroValidation,
         ];
         const BUILD_SETTINGS_FILE_PATH = path.join(projectData.appResourcesDirectoryPath, platformData.normalizedPlatformName, constants.BUILD_XCCONFIG_FILE_NAME);
         // Only include explicit properties from build.xcconfig
@@ -112,6 +119,17 @@ class XcodebuildArgsService {
         // like cocoapods issues related to ASSETCATALOG_COMPILER_APPICON_NAME
         // references: https://medium.com/@iostechset/why-cocoapods-eats-app-icons-79fe729808d4
         // https://github.com/CocoaPods/CocoaPods/issues/7003
+        // Xcode 26 makes Swift "explicitly built modules" the default. A
+        // regression there prevents macro/compiler-plugin SPM targets from
+        // resolving their swift-syntax module dependencies, failing with:
+        // "Unable to resolve module dependency: 'SwiftSyntax'" (and SwiftParser,
+        // SwiftSyntaxMacros, SwiftCompilerPlugin, SwiftDiagnostics).
+        // Passed as a command-line build setting so it overrides ALL targets,
+        // including the package targets we don't control.
+        // ref: https://forums.swift.org/t/xcode-26-unable-to-find-module-dependency/80516
+        const explicitModulesProperty = "SWIFT_ENABLE_EXPLICIT_MODULES";
+        const explicitModulesValue = this.$xcconfigService.readPropertyValue(BUILD_SETTINGS_FILE_PATH, explicitModulesProperty) || "NO";
+        extraArgs.push(`${explicitModulesProperty}=${explicitModulesValue}`);
         const deployTargetProperty = "IPHONEOS_DEPLOYMENT_TARGET";
         const deployTargetVersion = this.$xcconfigService.readPropertyValue(BUILD_SETTINGS_FILE_PATH, deployTargetProperty);
         if (deployTargetVersion) {
@@ -122,6 +140,14 @@ class XcodebuildArgsService {
         if (swiftUIBootValue) {
             extraArgs.push(`${swiftUIBootProperty}=${swiftUIBootValue}`);
         }
+        // Swift macro/compiler-plugin SPM targets must be code-signed with a
+        // development team when building for a device. Pass DEVELOPMENT_TEAM as a
+        // command-line build setting so it applies to SPM package targets too.
+        const developmentTeamProperty = "DEVELOPMENT_TEAM";
+        const developmentTeamValue = this.$xcconfigService.readPropertyValue(BUILD_SETTINGS_FILE_PATH, developmentTeamProperty);
+        if (developmentTeamValue) {
+            extraArgs.push(`${developmentTeamProperty}=${developmentTeamValue}`);
+        }
         if (this.$fs.exists(xcworkspacePath)) {
             return ["-workspace", xcworkspacePath, ...extraArgs];
         }

package/lib/services/ios/xcodebuild-command-service.js

@@ -10,9 +10,22 @@ class XcodebuildCommandService {
         this.$logger = $logger;
     }
     async executeCommand(args, options) {
-        const { message, cwd, stdio, spawnOptions } = options;
-        this.$logger.info(message || "Xcode build...");
-        const childProcessOptions = { cwd, stdio: stdio || "inherit" };
+        const { message, cwd, stdio, spawnOptions, onProgress } = options;
+        // A caller rendering its own progress UI owns stdout, so skip the
+        // default "Xcode build..." line that would otherwise clobber it.
+        if (!onProgress) {
+            this.$logger.info(message || "Xcode build...");
+        }
+        const childProcessOptions = {
+            cwd,
+            stdio: onProgress ? "pipe" : stdio || "inherit",
+        };
+        let detachProgress;
+        if (onProgress) {
+            const handler = (chunk) => onProgress(chunk);
+            this.$childProcess.on(constants.BUILD_OUTPUT_EVENT_NAME, handler);
+            detachProgress = () => this.$childProcess.removeListener(constants.BUILD_OUTPUT_EVENT_NAME, handler);
+        }
         try {
             const commandResult = await this.$childProcess.spawnFromEvent("xcodebuild", args, "exit", childProcessOptions, spawnOptions || {
                 emitOptions: { eventName: constants.BUILD_OUTPUT_EVENT_NAME },
@@ -23,6 +36,9 @@ class XcodebuildCommandService {
         catch (err) {
             this.$errors.fail(err.message);
         }
+        finally {
+            detachProgress === null || detachProgress === void 0 ? void 0 : detachProgress();
+        }
     }
 }
 exports.XcodebuildCommandService = XcodebuildCommandService;