@byteplus-iga-pages/cli 1.1.16 → 1.2.2

package/README.md

@@ -6,6 +6,31 @@
 
 <br/>
 
+## Pages and Agent project compatibility
+
+Use `bp-iga pages` for Pages projects and `iga agents` for new Agent projects. Existing Pages projects can continue using the Agent and Blob SDKs with `bp-iga pages dev/deploy`; no migration is required.
+
+The CLI uses `.iga/project.json` to identify the associated project: `appType: "agent"` selects Agent, and a missing `appType` selects Pages. Using the other command group reports an error and points to the original project's commands. `link` changes the local association to another project; it does not migrate the remote project.
+
+A directory without `projectId` is only unlinked. After a fresh checkout, use `bp-iga pages link --project <id-or-name>` to restore an existing Pages association, including projects using Agent or Blob SDKs. Creating a new Pages project with these SDKs is blocked; use `iga agents` for new projects instead.
+
+When `pages init` selects a template tagged as `agent`, it stops before downloading and directs you to `iga agents init --list --json`. Select a template ID from that list to initialize an Agent project.
+
+## Agent AI Gateway integrations
+
+`iga agents integration list/link/unlink` manages AI Gateway bindings for an Agent project.
+Agent integrations only support `aigateway`; Supabase integration remains available under `pages`.
+
+```bash
+iga agents integration list --format=json
+iga agents integration link aigateway --resource <gateway-id>
+iga agents integration unlink aigateway --resource <gateway-id> --yes
+iga agents env pull
+```
+
+Omitting the integration name selects `aigateway`. Region, branch and prefix options are not supported.
+Binding changes apply on the next deployment; `env pull` refreshes local configuration.
+
 ## Overview
 
 BytePlus IGA Pages is a full-stack development and deployment platform powered by BytePlus IGA. It supports static sites, server-side rendering, and serverless functions, delivering projects to a global edge network with zero infrastructure management.
@@ -51,7 +76,7 @@ bp-iga login --accessKey <AK> --secretKey <SK>  # AK/SK for automation
 
 ---
 
-### `bp-iga pages init`
+### `bp-iga pages init` / `iga agents init`
 
 ```bash
 bp-iga pages init --list --json
@@ -59,7 +84,9 @@ bp-iga pages init my-agent --template <template-id>
 bp-iga pages init my-agent --template <template-id> --name my-remote-project
 ```
 
-Download a template into a new or empty directory. AI templates also create a remote project, bind an AI Gateway, and write `.env.local`. Use `--name` to override the directory-based project name. Install dependencies, then run `bp-iga pages dev`.
+Use `iga agents init my-agent --template <template-id> --sandbox` to create and link a remote Agent with Sandbox enabled, including templates without model configuration. `--sandbox` is Agent-only and cannot be combined with `--list`. Without this flag, Agent initialization follows the template’s `ProjectParam.Context.Sandbox.Enable` setting; missing configuration uses the backend default (disabled). Templates without model configuration do not create an AI Gateway.
+
+Download a template into a new or empty directory. Use `iga agents init` for Agent projects and templates that directly depend on the Agent or Blob SDK. AI templates also create a remote project, bind an AI Gateway, and write `.env.local`. Use `--name` to override the directory-based project name. Install dependencies, then run `iga agents dev` or `bp-iga pages dev` for the corresponding project type.
 
 ---
 
@@ -106,6 +133,8 @@ bp-iga pages deploy                        # deploy current project
 bp-iga pages deploy --logs                 # stream complete build logs
 ```
 
+Agent projects support `iga agents deploy --sandbox`. For a new Agent, Sandbox is enabled during creation. For an existing Agent, the CLI enables Sandbox and waits for the configuration to become ready before deploying. Omitting `--sandbox` preserves the existing Sandbox configuration. Pages deployments do not accept this flag.
+
 By default, show deployment progress and full logs on failure. Use `--logs` to stream all build logs.
 
 ---
@@ -290,3 +319,7 @@ bp-iga whoami
 ## License
 
 MIT © BytePlus Pte. Ltd.
+
+Agent creation without deployment supports `iga agents link --name my-agent --sandbox --yes`.
+This enables Sandbox during creation for both Git and upload projects. `--sandbox` requires
+`--name`, cannot be combined with `--project`, and is not available under `pages link`.

package/dist/functions-runtime.js

@@ -2667,6 +2667,198 @@ var __webpack_modules__ = {
             ]
         };
     },
+    "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        "use strict";
+        const cp = __webpack_require__("child_process");
+        const parse = __webpack_require__("../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js");
+        const enoent = __webpack_require__("../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js");
+        function spawn(command, args, options) {
+            const parsed = parse(command, args, options);
+            const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+            enoent.hookChildProcess(spawned, parsed);
+            return spawned;
+        }
+        function spawnSync(command, args, options) {
+            const parsed = parse(command, args, options);
+            const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+            result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+            return result;
+        }
+        module.exports = spawn;
+        module.exports.spawn = spawn;
+        module.exports.sync = spawnSync;
+        module.exports._parse = parse;
+        module.exports._enoent = enoent;
+    },
+    "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js" (module) {
+        "use strict";
+        const isWin = 'win32' === process.platform;
+        function notFoundError(original, syscall) {
+            return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+                code: 'ENOENT',
+                errno: 'ENOENT',
+                syscall: `${syscall} ${original.command}`,
+                path: original.command,
+                spawnargs: original.args
+            });
+        }
+        function hookChildProcess(cp, parsed) {
+            if (!isWin) return;
+            const originalEmit = cp.emit;
+            cp.emit = function(name, arg1) {
+                if ('exit' === name) {
+                    const err = verifyENOENT(arg1, parsed);
+                    if (err) return originalEmit.call(cp, 'error', err);
+                }
+                return originalEmit.apply(cp, arguments);
+            };
+        }
+        function verifyENOENT(status, parsed) {
+            if (isWin && 1 === status && !parsed.file) return notFoundError(parsed.original, 'spawn');
+            return null;
+        }
+        function verifyENOENTSync(status, parsed) {
+            if (isWin && 1 === status && !parsed.file) return notFoundError(parsed.original, 'spawnSync');
+            return null;
+        }
+        module.exports = {
+            hookChildProcess,
+            verifyENOENT,
+            verifyENOENTSync,
+            notFoundError
+        };
+    },
+    "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
+        "use strict";
+        const path = __webpack_require__("path");
+        const resolveCommand = __webpack_require__("../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js");
+        const escape = __webpack_require__("../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js");
+        const readShebang = __webpack_require__("../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js");
+        const isWin = 'win32' === process.platform;
+        const isExecutableRegExp = /\.(?:com|exe)$/i;
+        const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+        function detectShebang(parsed) {
+            parsed.file = resolveCommand(parsed);
+            const shebang = parsed.file && readShebang(parsed.file);
+            if (shebang) {
+                parsed.args.unshift(parsed.file);
+                parsed.command = shebang;
+                return resolveCommand(parsed);
+            }
+            return parsed.file;
+        }
+        function parseNonShell(parsed) {
+            if (!isWin) return parsed;
+            const commandFile = detectShebang(parsed);
+            const needsShell = !isExecutableRegExp.test(commandFile);
+            if (parsed.options.forceShell || needsShell) {
+                const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+                parsed.command = path.normalize(parsed.command);
+                parsed.command = escape.command(parsed.command);
+                parsed.args = parsed.args.map((arg)=>escape.argument(arg, needsDoubleEscapeMetaChars));
+                const shellCommand = [
+                    parsed.command
+                ].concat(parsed.args).join(' ');
+                parsed.args = [
+                    '/d',
+                    '/s',
+                    '/c',
+                    `"${shellCommand}"`
+                ];
+                parsed.command = process.env.comspec || 'cmd.exe';
+                parsed.options.windowsVerbatimArguments = true;
+            }
+            return parsed;
+        }
+        function parse(command, args, options) {
+            if (args && !Array.isArray(args)) {
+                options = args;
+                args = null;
+            }
+            args = args ? args.slice(0) : [];
+            options = Object.assign({}, options);
+            const parsed = {
+                command,
+                args,
+                options,
+                file: void 0,
+                original: {
+                    command,
+                    args
+                }
+            };
+            return options.shell ? parsed : parseNonShell(parsed);
+        }
+        module.exports = parse;
+    },
+    "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js" (module) {
+        "use strict";
+        const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+        function escapeCommand(arg) {
+            arg = arg.replace(metaCharsRegExp, '^$1');
+            return arg;
+        }
+        function escapeArgument(arg, doubleEscapeMetaChars) {
+            arg = `${arg}`;
+            arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+            arg = arg.replace(/(?=(\\+?)?)\1$/, '$1$1');
+            arg = `"${arg}"`;
+            arg = arg.replace(metaCharsRegExp, '^$1');
+            if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, '^$1');
+            return arg;
+        }
+        module.exports.command = escapeCommand;
+        module.exports.argument = escapeArgument;
+    },
+    "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js" (module, __unused_rspack_exports, __webpack_require__) {
+        "use strict";
+        const fs = __webpack_require__("fs");
+        const shebangCommand = __webpack_require__("../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js");
+        function readShebang(command) {
+            const size = 150;
+            const buffer = Buffer.alloc(size);
+            let fd;
+            try {
+                fd = fs.openSync(command, 'r');
+                fs.readSync(fd, buffer, 0, size, 0);
+                fs.closeSync(fd);
+            } catch (e) {}
+            return shebangCommand(buffer.toString());
+        }
+        module.exports = readShebang;
+    },
+    "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js" (module, __unused_rspack_exports, __webpack_require__) {
+        "use strict";
+        const path = __webpack_require__("path");
+        const which = __webpack_require__("../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js");
+        const getPathKey = __webpack_require__("../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js");
+        function resolveCommandAttempt(parsed, withoutPathExt) {
+            const env = parsed.options.env || process.env;
+            const cwd = process.cwd();
+            const hasCustomCwd = null != parsed.options.cwd;
+            const shouldSwitchCwd = hasCustomCwd && void 0 !== process.chdir && !process.chdir.disabled;
+            if (shouldSwitchCwd) try {
+                process.chdir(parsed.options.cwd);
+            } catch (err) {}
+            let resolved;
+            try {
+                resolved = which.sync(parsed.command, {
+                    path: env[getPathKey({
+                        env
+                    })],
+                    pathExt: withoutPathExt ? path.delimiter : void 0
+                });
+            } catch (e) {} finally{
+                if (shouldSwitchCwd) process.chdir(cwd);
+            }
+            if (resolved) resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
+            return resolved;
+        }
+        function resolveCommand(parsed) {
+            return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+        }
+        module.exports = resolveCommand;
+    },
     "../../node_modules/.pnpm/defaults@1.0.4/node_modules/defaults/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         var clone = __webpack_require__("../../node_modules/.pnpm/clone@1.0.4/node_modules/clone/clone.js");
         module.exports = function(options, defaults) {
@@ -4775,6 +4967,102 @@ var __webpack_modules__ = {
             return Boolean(process.env.CI) || Boolean(process.env.WT_SESSION) || 'vscode' === process.env.TERM_PROGRAM || 'xterm-256color' === process.env.TERM || 'alacritty' === process.env.TERM;
         };
     },
+    "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        __webpack_require__("fs");
+        var core;
+        core = 'win32' === process.platform || global.TESTING_WINDOWS ? __webpack_require__("../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js") : __webpack_require__("../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js");
+        module.exports = isexe;
+        isexe.sync = sync;
+        function isexe(path, options, cb) {
+            if ('function' == typeof options) {
+                cb = options;
+                options = {};
+            }
+            if (!cb) {
+                if ('function' != typeof Promise) throw new TypeError('callback not provided');
+                return new Promise(function(resolve, reject) {
+                    isexe(path, options || {}, function(er, is) {
+                        if (er) reject(er);
+                        else resolve(is);
+                    });
+                });
+            }
+            core(path, options || {}, function(er, is) {
+                if (er) {
+                    if ('EACCES' === er.code || options && options.ignoreErrors) {
+                        er = null;
+                        is = false;
+                    }
+                }
+                cb(er, is);
+            });
+        }
+        function sync(path, options) {
+            try {
+                return core.sync(path, options || {});
+            } catch (er) {
+                if (options && options.ignoreErrors || 'EACCES' === er.code) return false;
+                throw er;
+            }
+        }
+    },
+    "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = isexe;
+        isexe.sync = sync;
+        var fs = __webpack_require__("fs");
+        function isexe(path, options, cb) {
+            fs.stat(path, function(er, stat) {
+                cb(er, er ? false : checkStat(stat, options));
+            });
+        }
+        function sync(path, options) {
+            return checkStat(fs.statSync(path), options);
+        }
+        function checkStat(stat, options) {
+            return stat.isFile() && checkMode(stat, options);
+        }
+        function checkMode(stat, options) {
+            var mod = stat.mode;
+            var uid = stat.uid;
+            var gid = stat.gid;
+            var myUid = void 0 !== options.uid ? options.uid : process.getuid && process.getuid();
+            var myGid = void 0 !== options.gid ? options.gid : process.getgid && process.getgid();
+            var u = parseInt('100', 8);
+            var g = parseInt('010', 8);
+            var o = parseInt('001', 8);
+            var ug = u | g;
+            var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && 0 === myUid;
+            return ret;
+        }
+    },
+    "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = isexe;
+        isexe.sync = sync;
+        var fs = __webpack_require__("fs");
+        function checkPathExt(path, options) {
+            var pathext = void 0 !== options.pathExt ? options.pathExt : process.env.PATHEXT;
+            if (!pathext) return true;
+            pathext = pathext.split(';');
+            if (-1 !== pathext.indexOf('')) return true;
+            for(var i = 0; i < pathext.length; i++){
+                var p = pathext[i].toLowerCase();
+                if (p && path.substr(-p.length).toLowerCase() === p) return true;
+            }
+            return false;
+        }
+        function checkStat(stat, path, options) {
+            if (!stat.isSymbolicLink() && !stat.isFile()) return false;
+            return checkPathExt(path, options);
+        }
+        function isexe(path, options, cb) {
+            fs.stat(path, function(er, stat) {
+                cb(er, er ? false : checkStat(stat, path, options));
+            });
+        }
+        function sync(path, options) {
+            return checkStat(fs.statSync(path), path, options);
+        }
+    },
     "../../node_modules/.pnpm/jsonfile@6.2.0/node_modules/jsonfile/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         let _fs;
         try {
@@ -5180,6 +5468,17 @@ var __webpack_modules__ = {
             return spinner;
         };
     },
+    "../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js" (module) {
+        "use strict";
+        const pathKey = (options = {})=>{
+            const environment = options.env || process.env;
+            const platform = options.platform || process.platform;
+            if ('win32' !== platform) return 'PATH';
+            return Object.keys(environment).reverse().find((key)=>'PATH' === key.toUpperCase()) || 'Path';
+        };
+        module.exports = pathKey;
+        module.exports["default"] = pathKey;
+    },
     "../../node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/errors.js" (module) {
         "use strict";
         const codes = {};
@@ -8707,6 +9006,22 @@ var __webpack_modules__ = {
         };
         module.exports = validRange;
     },
+    "../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        "use strict";
+        const shebangRegex = __webpack_require__("../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js");
+        module.exports = (string = '')=>{
+            const match = string.match(shebangRegex);
+            if (!match) return null;
+            const [path, argument] = match[0].replace(/#! ?/, '').split(' ');
+            const binary = path.split('/').pop();
+            if ('env' === binary) return argument;
+            return argument ? `${binary} ${argument}` : binary;
+        };
+    },
+    "../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js" (module) {
+        "use strict";
+        module.exports = /^#!(.*)/;
+    },
     "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         var process1 = global.process;
         const processOk = function(process1) {
@@ -9774,6 +10089,93 @@ var __webpack_modules__ = {
             return false;
         }
     },
+    "../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const isWindows = 'win32' === process.platform || 'cygwin' === process.env.OSTYPE || 'msys' === process.env.OSTYPE;
+        const path = __webpack_require__("path");
+        const COLON = isWindows ? ';' : ':';
+        const isexe = __webpack_require__("../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js");
+        const getNotFoundError = (cmd)=>Object.assign(new Error(`not found: ${cmd}`), {
+                code: 'ENOENT'
+            });
+        const getPathInfo = (cmd, opt)=>{
+            const colon = opt.colon || COLON;
+            const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [
+                ''
+            ] : [
+                ...isWindows ? [
+                    process.cwd()
+                ] : [],
+                ...(opt.path || process.env.PATH || '').split(colon)
+            ];
+            const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM' : '';
+            const pathExt = isWindows ? pathExtExe.split(colon) : [
+                ''
+            ];
+            if (isWindows) {
+                if (-1 !== cmd.indexOf('.') && '' !== pathExt[0]) pathExt.unshift('');
+            }
+            return {
+                pathEnv,
+                pathExt,
+                pathExtExe
+            };
+        };
+        const which = (cmd, opt, cb)=>{
+            if ('function' == typeof opt) {
+                cb = opt;
+                opt = {};
+            }
+            if (!opt) opt = {};
+            const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+            const found = [];
+            const step = (i)=>new Promise((resolve, reject)=>{
+                    if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+                    const ppRaw = pathEnv[i];
+                    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+                    const pCmd = path.join(pathPart, cmd);
+                    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+                    resolve(subStep(p, i, 0));
+                });
+            const subStep = (p, i, ii)=>new Promise((resolve, reject)=>{
+                    if (ii === pathExt.length) return resolve(step(i + 1));
+                    const ext = pathExt[ii];
+                    isexe(p + ext, {
+                        pathExt: pathExtExe
+                    }, (er, is)=>{
+                        if (!er && is) if (!opt.all) return resolve(p + ext);
+                        else found.push(p + ext);
+                        return resolve(subStep(p, i, ii + 1));
+                    });
+                });
+            return cb ? step(0).then((res)=>cb(null, res), cb) : step(0);
+        };
+        const whichSync = (cmd, opt)=>{
+            opt = opt || {};
+            const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+            const found = [];
+            for(let i = 0; i < pathEnv.length; i++){
+                const ppRaw = pathEnv[i];
+                const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+                const pCmd = path.join(pathPart, cmd);
+                const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+                for(let j = 0; j < pathExt.length; j++){
+                    const cur = p + pathExt[j];
+                    try {
+                        const is = isexe.sync(cur, {
+                            pathExt: pathExtExe
+                        });
+                        if (is) if (!opt.all) return cur;
+                        else found.push(cur);
+                    } catch (ex) {}
+                }
+            }
+            if (opt.all && found.length) return found;
+            if (opt.nothrow) return null;
+            throw getNotFoundError(cmd);
+        };
+        module.exports = which;
+        which.sync = whichSync;
+    },
     "../build-utils/dist/config.js" (__unused_rspack_module, exports1, __webpack_require__) {
         "use strict";
         function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
@@ -9908,8 +10310,8 @@ var __webpack_modules__ = {
             }
             return validatedConfig;
         }
-        function resolveRootDirectory(cwd) {
-            return _async_to_generator(function*() {
+        function resolveRootDirectory(_0) {
+            return _async_to_generator(function*(cwd, options = {}) {
                 const envConfig = readEnvConfig();
                 const rootDirectory = envConfig.rootDirectory || "";
                 if (!rootDirectory) return {
@@ -9922,12 +10324,12 @@ var __webpack_modules__ = {
                 if (!(yield fs.pathExists(resolved))) throw new Error(`Root directory "${rootDirectory}" does not exist (resolved to ${resolved})`);
                 const stat = yield fs.stat(resolved);
                 if (!stat.isDirectory()) throw new Error(`Root directory "${rootDirectory}" is not a directory`);
-                logger_1.logger.log(`  Root directory: ${rootDirectory}`);
+                if (!options.quiet) logger_1.logger.log(`  Root directory: ${rootDirectory}`);
                 return {
                     workPath: resolved,
                     rootDirectory
                 };
-            })();
+            }).apply(this, arguments);
         }
         function resolveBuildCommand(workPath, igaConfig, framework) {
             return _async_to_generator(function*() {
@@ -11349,22 +11751,102 @@ export function installFaasInstanceNameResponseHeader() {
     },
     "../build-utils/dist/spawn-command.js" (__unused_rspack_module, exports1, __webpack_require__) {
         "use strict";
+        function _define_property(obj, key, value) {
+            if (key in obj) Object.defineProperty(obj, key, {
+                value: value,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+            else obj[key] = value;
+            return obj;
+        }
+        function _object_spread(target) {
+            for(var i = 1; i < arguments.length; i++){
+                var source = null != arguments[i] ? arguments[i] : {};
+                var ownKeys = Object.keys(source);
+                if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                    return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+                }));
+                ownKeys.forEach(function(key) {
+                    _define_property(target, key, source[key]);
+                });
+            }
+            return target;
+        }
+        function ownKeys(object, enumerableOnly) {
+            var keys = Object.keys(object);
+            if (Object.getOwnPropertySymbols) {
+                var symbols = Object.getOwnPropertySymbols(object);
+                if (enumerableOnly) symbols = symbols.filter(function(sym) {
+                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+                });
+                keys.push.apply(keys, symbols);
+            }
+            return keys;
+        }
+        function _object_spread_props(target, source) {
+            source = null != source ? source : {};
+            if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+            else ownKeys(Object(source)).forEach(function(key) {
+                Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+            });
+            return target;
+        }
         Object.defineProperty(exports1, "__esModule", {
             value: true
         });
         exports1.spawnCommand = spawnCommand;
+        exports1.terminateProcessTree = terminateProcessTree;
         exports1.cloneEnv = cloneEnv;
         exports1.execCommand = execCommand;
         const child_process_1 = __webpack_require__("child_process");
-        function spawnCommand(command, opts = {}) {
+        const crossSpawn = __webpack_require__("../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js");
+        function spawnCommand(command, argsOrOptions = {}, options = {}) {
+            if (Array.isArray(argsOrOptions)) {
+                if ([
+                    command,
+                    ...argsOrOptions
+                ].some((value)=>/[\r\n]/.test(value))) throw new Error("Command and arguments must not contain newlines");
+                if (options.shell) throw new Error("Argument-array commands must not use shell");
+                return crossSpawn(command, argsOrOptions, _object_spread_props(_object_spread({}, options), {
+                    shell: false
+                }));
+            }
             if ("win32" === process.platform) return (0, child_process_1.spawn)("cmd.exe", [
-                "/C",
-                command
-            ], opts);
+                "/d",
+                "/s",
+                "/c",
+                `"${command}"`
+            ], _object_spread_props(_object_spread({}, argsOrOptions), {
+                windowsVerbatimArguments: true
+            }));
             return (0, child_process_1.spawn)("sh", [
                 "-c",
                 command
-            ], opts);
+            ], argsOrOptions);
+        }
+        function terminateProcessTree(child) {
+            if (null != child.exitCode || null != child.signalCode) return Promise.resolve();
+            if ("win32" !== process.platform) {
+                child.kill();
+                return Promise.resolve();
+            }
+            if (!Number.isSafeInteger(child.pid) || child.pid <= 0) return Promise.resolve();
+            return new Promise((resolve, reject)=>{
+                (0, child_process_1.execFile)("taskkill.exe", [
+                    "/pid",
+                    String(child.pid),
+                    "/T",
+                    "/F"
+                ], {
+                    windowsHide: true,
+                    timeout: 5000
+                }, (error)=>{
+                    if (error && null == child.exitCode && null == child.signalCode) reject(error);
+                    else resolve();
+                });
+            });
         }
         const hasProp = Object.prototype.hasOwnProperty;
         function cloneEnv(...envs) {