@daomar/agentfleet 2.0.0

package/dist/services/onedrive-detector.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneDriveDetector = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const provider_selection_1 = require("./provider-selection");
+const i18n_1 = require("./i18n");
+class OneDriveDetector {
+    constructor(options = {}) {
+        this.platform = options.platform ?? process.platform;
+        this.getHomedir = options.homedir ?? os.homedir;
+        this.execSyncImpl = options.execSyncImpl ?? child_process_1.execSync;
+        this.existsSync = options.existsSync ?? fs.existsSync;
+        this.readdirSyncImpl = options.readdirSyncImpl ?? fs.readdirSync;
+        this.statSyncImpl = options.statSyncImpl ?? fs.statSync;
+    }
+    /**
+     * Detect all OneDrive sync folders on this machine.
+     * Returns the first usable folder path for compatibility with older call sites.
+     */
+    detect() {
+        const accounts = this.detectAccounts();
+        if (accounts.length === 0) {
+            throw new Error((0, i18n_1.t)('bootstrap.no_onedrive'));
+        }
+        if (accounts.length > 1) {
+            console.warn((0, i18n_1.t)('detector.multiple_accounts') + '\n' +
+                accounts.map((account, index) => `  ${index + 1}. ${(0, provider_selection_1.formatOneDriveSelection)(account)}`).join('\n'));
+        }
+        const selected = accounts[0];
+        console.log(`✓ ${(0, i18n_1.t)('detector.detected', { path: selected.path })}`);
+        return selected.path;
+    }
+    detectAccounts() {
+        const accounts = [
+            ...this.findFromRegistry(),
+            ...this.findFromMacCloudStorage(),
+            ...this.findFromWellKnownPaths(),
+        ];
+        const dedupedAccounts = new Map();
+        for (const account of accounts) {
+            if (!this.existsSync(account.path)) {
+                continue;
+            }
+            const accountKey = account.path.toLowerCase();
+            if (!dedupedAccounts.has(accountKey)) {
+                dedupedAccounts.set(accountKey, account);
+            }
+        }
+        return Array.from(dedupedAccounts.values());
+    }
+    findFromRegistry() {
+        const accounts = [];
+        if (this.platform !== 'win32') {
+            return accounts;
+        }
+        try {
+            const regOutput = this.execSyncImpl('reg query "HKCU\\Software\\Microsoft\\OneDrive\\Accounts" /s', { encoding: 'utf-8', timeout: 5000 });
+            let currentKey = '';
+            for (const line of regOutput.split(/\r?\n/)) {
+                const keyMatch = line.match(/^HKEY_CURRENT_USER\\Software\\Microsoft\\OneDrive\\Accounts\\(.+)/i);
+                if (keyMatch) {
+                    currentKey = keyMatch[1];
+                    continue;
+                }
+                const valueMatch = line.match(/^\s+UserFolder\s+REG_SZ\s+(.+)/i);
+                if (valueMatch && currentKey) {
+                    const folderPath = valueMatch[1].trim();
+                    accounts.push(this.createAccount(folderPath, {
+                        accountKey: currentKey,
+                        accountName: currentKey.toLowerCase() === 'personal' ? 'Personal' : undefined,
+                    }));
+                }
+            }
+        }
+        catch {
+            return [];
+        }
+        return accounts;
+    }
+    findFromMacCloudStorage() {
+        if (this.platform !== 'darwin') {
+            return [];
+        }
+        return this.scanForOneDrive(this.joinPath(this.getHomedir(), 'Library', 'CloudStorage'));
+    }
+    findFromWellKnownPaths() {
+        return this.scanForOneDrive(this.getHomedir());
+    }
+    createAccount(folderPath, overrides = {}) {
+        const account = (0, provider_selection_1.createOneDriveSelection)(folderPath, overrides);
+        return {
+            ...account,
+            isBusiness: account.accountType === 'business',
+        };
+    }
+    scanForOneDrive(baseDir) {
+        const accounts = [];
+        try {
+            for (const entry of this.readdirSyncImpl(baseDir)) {
+                if (!entry.startsWith('OneDrive')) {
+                    continue;
+                }
+                const fullPath = this.joinPath(baseDir, entry);
+                if (!this.statSyncImpl(fullPath).isDirectory()) {
+                    continue;
+                }
+                accounts.push(this.createAccount(fullPath));
+            }
+        }
+        catch {
+            return [];
+        }
+        return accounts;
+    }
+    joinPath(...segments) {
+        return this.platform === 'win32'
+            ? path.win32.join(...segments)
+            : path.posix.join(...segments);
+    }
+}
+exports.OneDriveDetector = OneDriveDetector;
+//# sourceMappingURL=onedrive-detector.js.map

package/dist/services/provider-selection.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferOneDriveAccountType = inferOneDriveAccountType;
+exports.inferOneDriveAccountName = inferOneDriveAccountName;
+exports.inferOneDriveAccountKey = inferOneDriveAccountKey;
+exports.createOneDriveSelection = createOneDriveSelection;
+exports.normalizeConfig = normalizeConfig;
+exports.selectionFromConfig = selectionFromConfig;
+exports.selectionsEqual = selectionsEqual;
+exports.formatOneDriveSelection = formatOneDriveSelection;
+exports.chooseOneDriveAccount = chooseOneDriveAccount;
+const path = __importStar(require("path"));
+const types_1 = require("../types");
+const i18n_1 = require("./i18n");
+function getPathBasename(onedrivePath) {
+    return onedrivePath.includes('\\')
+        ? path.win32.basename(onedrivePath)
+        : path.posix.basename(onedrivePath);
+}
+function inferOneDriveAccountType(onedrivePath) {
+    const baseName = getPathBasename(onedrivePath);
+    return /^OneDrive([ -]?Personal)?$/i.test(baseName) ? 'personal' : 'business';
+}
+function inferOneDriveAccountName(onedrivePath, accountType = inferOneDriveAccountType(onedrivePath)) {
+    if (accountType === 'personal') {
+        return 'Personal';
+    }
+    const baseName = getPathBasename(onedrivePath);
+    if (baseName.startsWith('OneDrive - ')) {
+        return baseName.substring('OneDrive - '.length);
+    }
+    if (baseName.startsWith('OneDrive-')) {
+        return baseName.substring('OneDrive-'.length);
+    }
+    if (baseName.startsWith('OneDrive ')) {
+        return baseName.substring('OneDrive '.length);
+    }
+    return baseName;
+}
+function inferOneDriveAccountKey(onedrivePath, accountType = inferOneDriveAccountType(onedrivePath), accountName = inferOneDriveAccountName(onedrivePath, accountType)) {
+    return accountType === 'personal' ? 'Personal' : accountName;
+}
+function createOneDriveSelection(onedrivePath, overrides = {}) {
+    const accountType = overrides.accountType ?? inferOneDriveAccountType(onedrivePath);
+    const accountName = overrides.accountName ?? inferOneDriveAccountName(onedrivePath, accountType);
+    return {
+        provider: overrides.provider ?? 'onedrive',
+        accountKey: overrides.accountKey ?? inferOneDriveAccountKey(onedrivePath, accountType, accountName),
+        accountName,
+        accountType,
+        path: overrides.path ?? onedrivePath,
+    };
+}
+function normalizeConfig(config) {
+    const provider = 'onedrive';
+    const selection = createOneDriveSelection(config.onedrivePath, {
+        provider,
+        accountKey: config.onedriveAccountKey,
+        accountName: config.onedriveAccountName,
+        accountType: config.onedriveAccountType,
+    });
+    return {
+        ...types_1.DEFAULT_CONFIG,
+        ...config,
+        provider,
+        onedrivePath: config.onedrivePath,
+        onedriveAccountKey: selection.accountKey,
+        onedriveAccountName: selection.accountName,
+        onedriveAccountType: selection.accountType,
+        hostname: config.hostname,
+    };
+}
+function selectionFromConfig(config) {
+    return createOneDriveSelection(config.onedrivePath, {
+        provider: config.provider,
+        accountKey: config.onedriveAccountKey,
+        accountName: config.onedriveAccountName,
+        accountType: config.onedriveAccountType,
+    });
+}
+function selectionsEqual(left, right) {
+    return left.provider === right.provider
+        && left.path === right.path
+        && left.accountKey === right.accountKey
+        && left.accountName === right.accountName
+        && left.accountType === right.accountType;
+}
+function formatOneDriveSelection(selection) {
+    return `${selection.accountName} (${selection.accountType}) → ${selection.path}`;
+}
+async function chooseOneDriveAccount(accounts) {
+    if (accounts.length === 0) {
+        throw new Error((0, i18n_1.t)('bootstrap.no_onedrive'));
+    }
+    const selected = accounts[0];
+    console.log(`✓ ${(0, i18n_1.t)('bootstrap.selected', { selection: formatOneDriveSelection(selected) })}`);
+    return selected;
+}
+//# sourceMappingURL=provider-selection.js.map

package/dist/services/result-writer.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultWriter = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const i18n_1 = require("./i18n");
+class ResultWriter {
+    constructor(outputDir) {
+        this.outputDir = outputDir;
+        this.hostname = os.hostname();
+    }
+    /**
+     * Write execution results to the output directory.
+     * Creates output/<task-id>/<HOSTNAME>-result.json, <HOSTNAME>-stdout.log, and <HOSTNAME>-stderr.log.
+     */
+    write(result) {
+        const taskOutputDir = path.join(this.outputDir, result.taskId);
+        // Create task output directory if it doesn't exist
+        if (!fs.existsSync(taskOutputDir)) {
+            fs.mkdirSync(taskOutputDir, { recursive: true });
+        }
+        // Write result metadata
+        const resultFile = {
+            taskId: result.taskId,
+            hostname: this.hostname,
+            startedAt: result.startedAt,
+            completedAt: result.completedAt,
+            exitCode: result.exitCode,
+            status: result.status,
+            agentCommand: result.agentCommand,
+            error: result.error,
+        };
+        const resultPath = path.join(taskOutputDir, `${this.hostname}-result.json`);
+        fs.writeFileSync(resultPath, JSON.stringify(resultFile, null, 2));
+        // Write stdout log if non-empty
+        if (result.stdout) {
+            const stdoutPath = path.join(taskOutputDir, `${this.hostname}-stdout.log`);
+            fs.writeFileSync(stdoutPath, result.stdout);
+        }
+        // Write stderr log if non-empty
+        if (result.stderr) {
+            const stderrPath = path.join(taskOutputDir, `${this.hostname}-stderr.log`);
+            fs.writeFileSync(stderrPath, result.stderr);
+        }
+        const statusIcon = result.status === 'completed' ? '✅' : result.status === 'timeout' ? '⏰' : '❌';
+        console.log(`${statusIcon} ${(0, i18n_1.t)('result.written', { path: taskOutputDir })}`);
+        return taskOutputDir;
+    }
+}
+exports.ResultWriter = ResultWriter;
+//# sourceMappingURL=result-writer.js.map

package/dist/services/setup.js

@@ -0,0 +1,219 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetupService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const provider_selection_1 = require("./provider-selection");
+const i18n_1 = require("./i18n");
+const AGENTFLEET_DIR = '.agentfleet';
+const ONEDRIVE_SUBDIR = 'AgentFleet';
+const SYMLINK_TARGETS = ['tasks', 'output'];
+class SetupService {
+    constructor(homeDir = os.homedir()) {
+        this.homeDir = homeDir;
+        this.agentfleetDir = path.join(this.homeDir, AGENTFLEET_DIR);
+    }
+    getAgentFleetDir() {
+        return this.agentfleetDir;
+    }
+    getTasksDir() {
+        return path.join(this.agentfleetDir, 'tasks');
+    }
+    getOutputDir() {
+        return path.join(this.agentfleetDir, 'output');
+    }
+    getConfigPath() {
+        return path.join(this.agentfleetDir, 'config.json');
+    }
+    getProcessedPath() {
+        return path.join(this.agentfleetDir, 'processed.json');
+    }
+    /**
+     * Run full setup: create directories, symlinks, and config.
+     * Returns the loaded or created config.
+     */
+    setup(selection) {
+        const onedrivePath = selection.path;
+        // 1. Create ~/.agentfleet if it doesn't exist
+        if (!fs.existsSync(this.agentfleetDir)) {
+            fs.mkdirSync(this.agentfleetDir, { recursive: true });
+            console.log(`✓ ${(0, i18n_1.t)('setup.created_dir', { path: this.agentfleetDir })}`);
+        }
+        // 2. Create OneDrive subdirectories
+        const onedriveBase = path.join(onedrivePath, ONEDRIVE_SUBDIR);
+        for (const subdir of SYMLINK_TARGETS) {
+            const targetDir = path.join(onedriveBase, subdir);
+            if (!fs.existsSync(targetDir)) {
+                fs.mkdirSync(targetDir, { recursive: true });
+                console.log(`✓ ${(0, i18n_1.t)('setup.created_onedrive_dir', { path: targetDir })}`);
+            }
+        }
+        // 3. Create or validate symlinks
+        for (const subdir of SYMLINK_TARGETS) {
+            const linkPath = path.join(this.agentfleetDir, subdir);
+            const targetPath = path.join(onedriveBase, subdir);
+            this.ensureSymlink(linkPath, targetPath);
+        }
+        // 4. Create or load config
+        const config = this.ensureConfig(selection);
+        // 5. Ensure processed.json exists
+        if (!fs.existsSync(this.getProcessedPath())) {
+            fs.writeFileSync(this.getProcessedPath(), JSON.stringify({ processedIds: [] }, null, 2));
+        }
+        return config;
+    }
+    ensureSymlink(linkPath, targetPath) {
+        if (this.pathEntryExists(linkPath)) {
+            // Check if it's a symlink/junction pointing to the right place
+            try {
+                const stats = fs.lstatSync(linkPath);
+                if (stats.isSymbolicLink()) {
+                    const currentTarget = fs.readlinkSync(linkPath);
+                    if (path.resolve(currentTarget) === path.resolve(targetPath)) {
+                        console.log(`✓ ${(0, i18n_1.t)('setup.symlink_valid', { link: linkPath, target: targetPath })}`);
+                        return;
+                    }
+                    // Stale symlink — remove and recreate
+                    console.log(`⟳ ${(0, i18n_1.t)('setup.symlink_stale', { link: linkPath })}`);
+                    this.removePathEntry(linkPath);
+                }
+                else {
+                    // It's a real directory, not a symlink — skip
+                    console.warn(`⚠ ${(0, i18n_1.t)('setup.symlink_exists_as_dir', { path: linkPath })}`);
+                    return;
+                }
+            }
+            catch {
+                // If we can't read the symlink, remove and recreate
+                try {
+                    this.removePathEntry(linkPath);
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+        // Create symlink (or junction as fallback on Windows)
+        try {
+            fs.symlinkSync(targetPath, linkPath, 'junction');
+            console.log(`✓ ${(0, i18n_1.t)('setup.created_junction', { link: linkPath, target: targetPath })}`);
+        }
+        catch (symlinkErr) {
+            try {
+                // Fallback: try directory symlink (requires Developer Mode)
+                fs.symlinkSync(targetPath, linkPath, 'dir');
+                console.log(`✓ ${(0, i18n_1.t)('setup.created_symlink', { link: linkPath, target: targetPath })}`);
+            }
+            catch {
+                throw new Error((0, i18n_1.t)('setup.symlink_failed', { path: linkPath, error: symlinkErr.message }));
+            }
+        }
+    }
+    pathEntryExists(targetPath) {
+        try {
+            fs.lstatSync(targetPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    removePathEntry(targetPath) {
+        const stats = fs.lstatSync(targetPath);
+        if (stats.isSymbolicLink()) {
+            fs.unlinkSync(targetPath);
+            return;
+        }
+        fs.rmSync(targetPath, { recursive: true, force: true });
+    }
+    loadConfig() {
+        const configPath = this.getConfigPath();
+        if (!fs.existsSync(configPath)) {
+            return null;
+        }
+        try {
+            const existing = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (typeof existing.onedrivePath !== 'string' || existing.onedrivePath.length === 0) {
+                console.warn(`⚠ ${(0, i18n_1.t)('setup.config_missing_path')}`);
+                return null;
+            }
+            return (0, provider_selection_1.normalizeConfig)({
+                ...existing,
+                onedrivePath: existing.onedrivePath,
+                hostname: existing.hostname ?? os.hostname(),
+            });
+        }
+        catch {
+            console.warn(`⚠ ${(0, i18n_1.t)('setup.config_corrupt')}`);
+            return null;
+        }
+    }
+    ensureConfig(selection) {
+        const configPath = this.getConfigPath();
+        const existing = this.loadConfig();
+        if (existing) {
+            const nextConfig = (0, provider_selection_1.normalizeConfig)({
+                ...existing,
+                provider: selection.provider,
+                onedrivePath: selection.path,
+                onedriveAccountKey: selection.accountKey,
+                onedriveAccountName: selection.accountName,
+                onedriveAccountType: selection.accountType,
+                hostname: os.hostname(),
+            });
+            if (!(0, provider_selection_1.selectionsEqual)((0, provider_selection_1.selectionFromConfig)(existing), selection)) {
+                console.log(`⟳ ${(0, i18n_1.t)('setup.onedrive_changed')}`);
+            }
+            fs.writeFileSync(configPath, JSON.stringify(nextConfig, null, 2));
+            console.log(`✓ ${(0, i18n_1.t)('setup.config_loaded', { path: configPath })}`);
+            return nextConfig;
+        }
+        const config = (0, provider_selection_1.normalizeConfig)({
+            provider: selection.provider,
+            onedrivePath: selection.path,
+            onedriveAccountKey: selection.accountKey,
+            onedriveAccountName: selection.accountName,
+            onedriveAccountType: selection.accountType,
+            hostname: os.hostname(),
+        });
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log(`✓ ${(0, i18n_1.t)('setup.config_created', { path: configPath })}`);
+        return config;
+    }
+}
+exports.SetupService = SetupService;
+//# sourceMappingURL=setup.js.map