@merchantduo/code 0.3.0-beta.0 → 0.3.0-beta.1

package/README.md

@@ -58,7 +58,7 @@ Host shop-stage
   IdentityFile ~/.ssh/id_ed25519
 ```
 
-Use that alias as `host: shop-stage`. `merchantduo init` offers local first and Warden when its project `.env` is detected; it prints an SSH example instead of writing an unused remote environment.
+Use that alias as `host: shop-stage`. Every `merchantduo init` asks “Choose what fits you most” and saves the selected role under the current user's `~/.merchantduo/operator-profile.yaml`: store admin, backend developer, frontend developer, or full-stack developer. It then offers local first and Warden when its project `.env` is detected; it prints an SSH example instead of writing an unused remote environment. The role is optional to load and gives the agent context for explanations and recommendations only; it does not change tools or permissions. Project configuration contains no user identity and is safe to share in a repository.
 
 ## Provisioning
 
@@ -66,10 +66,10 @@ Provision a local or Warden developer store from an empty directory or an existi
 
 ```sh
 merchantduo provision
-merchantduo provision --env warden --source https://git.example.test/store.git --database ./backup.sql.gz --yes
+merchantduo provision --env warden
 ```
 
-The interactive flow discovers available source, database, and service evidence, shows an ordered plan, and asks once before mutations. `--yes` requires all decisions to be explicit or unambiguous.
+This opens plain Pi in the host shell, even when the project defaults to Warden. It shares MerchantDuo’s configured Pi authentication, models, and user settings, but does not load the MerchantDuo package or initialize Magento context. The agent first inspects the real project, Warden/local runtime, Composer platform requirements, Magento state, and source/database evidence. It does not run a fixed Composer, database, Magento, lifecycle, or web-server sequence. Before a material mutation, it explains the evidence and intended effect and waits for confirmation. In particular, lock-file PHP incompatibility is diagnosed rather than bypassed with `composer update`. Unlike normal MerchantDuo sessions, provisioning may inspect and configure Magento deployment configuration such as `app/etc/env.php` and `app/etc/config.php` when needed; it must not reveal credentials or tokens in chat, commands, logs, or generated files.
 
 ## Install and start
 
@@ -86,7 +86,7 @@ Review the generated `.merchantduo.yaml` before the first session. MerchantDuo r
 
 ## Safety and optional services
 
-MerchantDuo does not load `app/etc/env.php`, credentials, or tokens into agent context. It does not run background tests, cache commands, deployment actions, browser operations, or PHP code. Explicit operations use the confirmation rules described in the [tool reference](docs/tools.md).
+Normal MerchantDuo sessions do not load `app/etc/env.php`, credentials, or tokens into agent context. The separate provisioning session may configure Magento deployment files, but never reveals their secret values. MerchantDuo does not run background tests, cache commands, deployment actions, browser operations, or PHP code. Explicit operations use the confirmation rules described in the [tool reference](docs/tools.md).
 
 Set `MERCHANTDUO_MCP_TOKEN` to enable the built-in read-only knowledge tool. Set `MERCHANTDUO_LLM_TOKEN` to enable the built-in MerchantDuo provider. Neither endpoint is project configuration.
 

package/dist/app/system-prompt.d.ts

@@ -1,2 +1,3 @@
+import type { OperatorRole } from "#config/index";
 export declare function mage2genRoot(): string;
-export declare function merchantDuoSystemPrompt(mage2genPath?: string): string;
+export declare function merchantDuoSystemPrompt(operatorRole: OperatorRole | undefined, mage2genPath?: string): string;

package/dist/app/system-prompt.js

@@ -2,10 +2,12 @@ import { packagePath } from "#shared/package-paths";
 export function mage2genRoot() {
     return packagePath("vendor/mage2gen");
 }
-export function merchantDuoSystemPrompt(mage2genPath = mage2genRoot()) {
+export function merchantDuoSystemPrompt(operatorRole, mage2genPath = mage2genRoot()) {
     return `You are MerchantDuo, a senior Magento 2.4 architect and implementation partner. Work directly in the selected MerchantDuo environment and theme scope. Before changing code, inspect the relevant module, theme inheritance chain, configuration, and established local conventions. Make focused, production-quality changes; do not preserve obsolete compatibility paths or add speculative abstractions.
 
-Ground every design and implementation decision in existing source before introducing a pattern. Find the closest applicable example and read its surrounding call sites, configuration, and tests. Search Magento core under vendor/magento first; if it has no suitable example, search other installed vendor modules or project app/code modules. Adapt the applicable pattern rather than copying blindly, and explain any material intentional difference. Only when no relevant precedent exists may you introduce a new pattern, and state that finding before doing so.
+${operatorRole ? `The operator is a ${operatorRole.replace(/-/g, " ")}. Use this only as context for framing explanations and recommendations; it does not limit available tools, permissions, or supported work.
+
+` : ""}Ground every design and implementation decision in existing source before introducing a pattern. Find the closest applicable example and read its surrounding call sites, configuration, and tests. Search Magento core under vendor/magento first; if it has no suitable example, search other installed vendor modules or project app/code modules. Adapt the applicable pattern rather than copying blindly, and explain any material intentional difference. Only when no relevant precedent exists may you introduce a new pattern, and state that finding before doing so.
 
 Use Magento service contracts, dependency injection, declarative schema/data patches, layout XML, and theme fallback mechanisms when they are the correct native extension points. Respect the active theme scope: all means cover every detected theme, any means identify the relevant theme from the request and code before theme-specific edits, and a concrete theme limits work to that theme and its inheritance chain. Do not use Luma RequireJS/Knockout conventions for Hyva work.
 

package/dist/cli/arguments.d.ts

@@ -2,9 +2,6 @@ export type CliArguments = {
     command?: "init" | "doctor" | "provision";
     environment?: string;
     configPath?: string;
-    source?: string;
-    database?: string;
-    yes: boolean;
     yolo: boolean;
     piArguments: string[];
 };

package/dist/cli/arguments.js

@@ -4,29 +4,19 @@ export function parseArguments(args) {
     const piArguments = [];
     let environment;
     let configPath;
-    let source;
-    let database;
-    let yes = false;
     let yolo = false;
     for (let index = 0; index < input.length; index += 1) {
         const value = input[index];
-        if (value === "--env" || value === "--config" || value === "--source" || value === "--database") {
+        if (value === "--env" || value === "--config") {
             const argument = input[index + 1];
             if (!argument)
                 throw new Error(`${value} requires a value`);
             if (value === "--env")
                 environment = argument;
-            else if (value === "--config")
-                configPath = argument;
-            else if (value === "--source")
-                source = argument;
             else
-                database = argument;
+                configPath = argument;
             index += 1;
         }
-        else if (value === "--yes") {
-            yes = true;
-        }
         else if (value === "--yolo") {
             yolo = true;
         }
@@ -36,5 +26,7 @@ export function parseArguments(args) {
     }
     if (command && yolo)
         throw new Error("--yolo is only available when starting an agent session");
-    return { command, environment, configPath, source, database, yes, yolo, piArguments };
+    if (command === "provision" && (configPath || piArguments.length))
+        throw new Error("merchantduo provision supports only --env local or --env warden");
+    return { command, environment, configPath, yolo, piArguments };
 }

package/dist/cli/commands/agent.d.ts

@@ -1,3 +1,10 @@
 import type { PermissionMode } from "#app/permission-mode";
+type ProvisionEnvironment = "local" | "warden";
+export declare function provisioningPrompt(environment: ProvisionEnvironment): string;
 export declare function launchAgent(piArguments: string[], selectedEnvironment: string, configPath?: string, permissionMode?: PermissionMode): Promise<number>;
+/** Launch a non-persistent provisioning session with exactly the requested environment. */
+export declare function launchProvisioningAgent(environment: ProvisionEnvironment): Promise<number>;
+/** Preserve Pi connection preferences but never load environment-bound MerchantDuo packages. */
+export declare function provisioningSettings(settings: Record<string, unknown>): Record<string, unknown>;
 export declare function agentEnvironment(base: NodeJS.ProcessEnv, piDirectory: string, selectedEnvironment: string, configPath: string | undefined, version: string, permissionMode?: PermissionMode): NodeJS.ProcessEnv;
+export {};

package/dist/cli/commands/agent.js

@@ -1,9 +1,14 @@
 import { spawn } from "node:child_process";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, symlink, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { merchantHome } from "#config/paths";
 import { packagePath } from "#shared/package-paths";
+export function provisioningPrompt(environment) {
+    return `Start an agentic Magento provisioning investigation for the selected ${environment} environment. You are running plain Pi in the host shell, not inside a MerchantDuo selected-environment shell. Use host tools to inspect Warden/local project evidence and explicitly route any environment-specific command only after identifying its correct runtime. Do not follow a predetermined command sequence. First inspect the project, its documentation and scripts, the selected environment configuration and status, Composer metadata and lock-file platform requirements, actual runtime versions, Magento state, and available database/source evidence. Search for the smallest project-specific path to a runnable store.
+
+Before any material mutation, explain the evidence, the precise intended effect, risks, and the smallest proposed action, then wait for the user's confirmation. Do not run Composer, import a database, run Magento setup commands, start or stop services, create a virtual host, or modify dependencies merely because they are customary. Never use composer update to bypass a lock-file or PHP-platform mismatch. If compatibility fails, identify the exact incompatible packages and recommend the required environment or dependency decision instead. When project evidence requires it, inspect and configure Magento deployment configuration including app/etc/env.php, app/etc/config.php, and related files. Treat their values as sensitive: never disclose, echo, log, or copy credentials or tokens into chat, commands, or persisted artifacts.`;
+}
 export async function launchAgent(piArguments, selectedEnvironment, configPath, permissionMode) {
     const state = merchantHome();
     await mkdir(state, { recursive: true, mode: 0o700 });
@@ -25,6 +30,46 @@ export async function launchAgent(piArguments, selectedEnvironment, configPath,
         child.on("exit", (code) => resolveExit(code ?? 1));
     });
 }
+/** Launch a non-persistent provisioning session with exactly the requested environment. */
+export async function launchProvisioningAgent(environment) {
+    const state = merchantHome();
+    const merchantPi = resolve(state, "pi");
+    const provisionPi = resolve(state, "provision", "pi");
+    await mkdir(provisionPi, { recursive: true, mode: 0o700 });
+    await linkConnectionFile(merchantPi, provisionPi, "auth.json");
+    await linkConnectionFile(merchantPi, provisionPi, "models.json");
+    await linkConnectionFile(merchantPi, provisionPi, "models-store.json");
+    await writeFile(resolve(provisionPi, "settings.json"), `${JSON.stringify(provisioningSettings(JSON.parse(await readFile(resolve(merchantPi, "settings.json"), "utf8"))), null, 2)}\n`, { mode: 0o600 });
+    return launchPlainPi(["--no-extensions", provisioningPrompt(environment)], provisionPi);
+}
+/** Preserve Pi connection preferences but never load environment-bound MerchantDuo packages. */
+export function provisioningSettings(settings) {
+    const { packages: _packages, ...connectionSettings } = settings;
+    return connectionSettings;
+}
+async function linkConnectionFile(sourceDirectory, targetDirectory, name) {
+    const source = resolve(sourceDirectory, name);
+    const target = resolve(targetDirectory, name);
+    try {
+        await symlink(source, target);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+}
+async function launchPlainPi(piArguments, piDirectory) {
+    const piEntry = fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"));
+    const piCli = resolve(dirname(piEntry), "cli.js");
+    return new Promise((resolveExit, reject) => {
+        const child = spawn(process.execPath, [piCli, ...piArguments], {
+            stdio: "inherit",
+            env: { ...process.env, PI_CODING_AGENT_DIR: piDirectory },
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => resolveExit(code ?? 1));
+    });
+}
 export function agentEnvironment(base, piDirectory, selectedEnvironment, configPath, version, permissionMode) {
     return { ...base, PI_CODING_AGENT_DIR: piDirectory, MERCHANTDUO_SELECTED_ENV: selectedEnvironment, MERCHANTDUO_CONFIG_PATH: configPath ?? "", MERCHANTDUO_PACKAGE_VERSION: version, ...(permissionMode ? { MERCHANTDUO_PERMISSION_MODE: permissionMode } : {}) };
 }

package/dist/cli/commands/init.d.ts

@@ -1,9 +1,22 @@
+import { type OperatorRole } from "#config/index";
+export declare const operatorRoleChoices: ReadonlyArray<{
+    value: OperatorRole;
+    label: string;
+}>;
 export interface InitInterview {
     confirm(question: string): Promise<boolean>;
+    choose(question: string, choices: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>): Promise<string>;
 }
 export declare class TerminalInitInterview implements InitInterview {
     confirm(question: string): Promise<boolean>;
+    choose(question: string, choices: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>): Promise<string>;
 }
 export declare function hasWardenEnvironment(cwd: string): Promise<boolean>;
-export declare function initProject(cwd: string, interview?: InitInterview, output?: (message: string) => void): Promise<void>;
+export declare function initProject(cwd: string, interview?: InitInterview, output?: (message: string) => void, env?: NodeJS.ProcessEnv): Promise<void>;
 export declare const remoteEnvironmentExample = "\nTo add a remote environment later, add this under environments:\n\n  stage:\n    type: ssh\n    host: shop-stage\n    root: /var/www/html\n\nSSH sessions start read-only. Use /duo-switch-permissions normal or yolo only for the current session. Configure its user, port, and identity through ~/.ssh/config:\n\n  Host shop-stage\n    HostName stage.example.com\n    User deploy\n    Port 22\n    IdentityFile ~/.ssh/id_ed25519";

package/dist/cli/commands/init.js

@@ -3,6 +3,13 @@ import { resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import { stringify } from "yaml";
+import { operatorRoles, saveOperatorRole } from "#config/index";
+export const operatorRoleChoices = [
+    { value: "store-admin", label: "I am STORE ADMIN" },
+    { value: "backend-developer", label: "I am BACKEND developer" },
+    { value: "frontend-developer", label: "I am FRONTEND developer" },
+    { value: "full-stack-developer", label: "I am FULL STACK developer" },
+];
 export class TerminalInitInterview {
     async confirm(question) {
         const terminal = createInterface({ input: stdin, output: stdout });
@@ -14,6 +21,20 @@ export class TerminalInitInterview {
             terminal.close();
         }
     }
+    async choose(question, choices) {
+        const terminal = createInterface({ input: stdin, output: stdout });
+        try {
+            stdout.write(`${question}\n${choices.map((choice, index) => `  ${index + 1}. ${choice.label}`).join("\n")}\n`);
+            const answer = (await terminal.question(`Choose [1-${choices.length}] `)).trim();
+            const selected = choices[Number(answer) - 1];
+            if (!selected)
+                throw new Error(`Choose a number from 1 to ${choices.length}`);
+            return selected.value;
+        }
+        finally {
+            terminal.close();
+        }
+    }
 }
 export async function hasWardenEnvironment(cwd) {
     try {
@@ -26,16 +47,23 @@ export async function hasWardenEnvironment(cwd) {
         throw error;
     }
 }
-export async function initProject(cwd, interview = new TerminalInitInterview(), output = console.log) {
+export async function initProject(cwd, interview = new TerminalInitInterview(), output = console.log, env = process.env) {
     const path = resolve(cwd, ".merchantduo.yaml");
+    let exists = false;
     try {
         await access(path);
-        throw new Error(`${path} already exists`);
+        exists = true;
     }
     catch (error) {
         if (error.code !== "ENOENT")
             throw error;
     }
+    // Always refresh the caller's optional identity context, even for an existing project.
+    await saveOperatorRole(await chooseOperatorRole(interview), env);
+    if (exists) {
+        output("Updated the current user's operator role");
+        return;
+    }
     const environments = {};
     if (await interview.confirm("Add the local Magento checkout environment?")) {
         environments.local = { type: "local", root: "." };
@@ -65,4 +93,10 @@ export async function initProject(cwd, interview = new TerminalInitInterview(),
     output(`Created ${path}`);
     output(remoteEnvironmentExample);
 }
+async function chooseOperatorRole(interview) {
+    const selected = await interview.choose("Choose what fits you most", operatorRoleChoices);
+    if (!operatorRoles.includes(selected))
+        throw new Error("Choose a listed operator role");
+    return selected;
+}
 export const remoteEnvironmentExample = `\nTo add a remote environment later, add this under environments:\n\n  stage:\n    type: ssh\n    host: shop-stage\n    root: /var/www/html\n\nSSH sessions start read-only. Use /duo-switch-permissions normal or yolo only for the current session. Configure its user, port, and identity through ~/.ssh/config:\n\n  Host shop-stage\n    HostName stage.example.com\n    User deploy\n    Port 22\n    IdentityFile ~/.ssh/id_ed25519`;

package/dist/cli/commands/provision.d.ts

@@ -1,6 +1,11 @@
-export declare function provision(cwd: string, options: {
+export type ProvisionEnvironment = "local" | "warden";
+export interface ProvisionEnvironmentInterview {
+    choose(): Promise<ProvisionEnvironment>;
+}
+export declare class TerminalProvisionEnvironmentInterview implements ProvisionEnvironmentInterview {
+    choose(): Promise<ProvisionEnvironment>;
+}
+/** Starts a Pi investigation session; provisioning actions remain agent- and user-directed. */
+export declare function provision(options: {
     environment?: string;
-    source?: string;
-    database?: string;
-    yes: boolean;
-}): Promise<void>;
+}, interview?: ProvisionEnvironmentInterview, launch?: (environment: ProvisionEnvironment) => Promise<number>): Promise<void>;

package/dist/cli/commands/provision.js

@@ -1,35 +1,24 @@
-import { EnvironmentBackend } from "#environments/backend";
-import { ProvisionAdvisor } from "#provision/advisor";
-import { discoverProvision } from "#provision/discovery";
-import { TerminalProvisionInterview } from "#provision/interview";
-import { createProvisionPlan } from "#provision/planner";
-import { BackendProvisionRunner, DefaultProvisionExecutor } from "#provision/runner";
-function source(value) { if (!value)
-    return undefined; if (value === "existing")
-    return value; return /^https?:\/\//.test(value) ? (value.endsWith(".git") ? `git:${value}` : `https:${value}`) : `archive:${value}`; }
-function database(value) { if (!value)
-    return undefined; if (value === "current")
-    return value; return /^https?:\/\//.test(value) ? `https:${value}` : `dump:${value}`; }
-export async function provision(cwd, options) {
-    if (options.environment && options.environment !== "local" && options.environment !== "warden")
-        throw new Error("--env must be local or warden");
-    const snapshot = await discoverProvision(cwd);
-    const initial = { environment: options.environment, source: source(options.source), database: database(options.database) };
-    const interview = new TerminalProvisionInterview();
-    const input = options.yes ? initial : await interview.resolve(snapshot, initial);
-    const advised = await new ProvisionAdvisor().advise(snapshot, createProvisionPlan(snapshot, input));
-    if (advised.diagnostic)
-        console.error(`merchantduo: ${advised.diagnostic}`);
-    if (advised.plan.blocked.length)
-        throw new Error(`Provision requires input:\n- ${advised.plan.blocked.join("\n- ")}`);
-    if (!options.yes && !(await interview.approve(advised.plan))) {
-        console.log("Provision cancelled.");
-        return;
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { launchProvisioningAgent } from "#cli/commands/agent";
+export class TerminalProvisionEnvironmentInterview {
+    async choose() {
+        const terminal = createInterface({ input: stdin, output: stdout });
+        try {
+            const answer = (await terminal.question("Environment (warden/local): ")).trim();
+            if (answer === "warden" || answer === "local")
+                return answer;
+            throw new Error("Choose environment warden or local");
+        }
+        finally {
+            terminal.close();
+        }
     }
-    const hostBackend = new EnvironmentBackend({ type: "local", root: "." }, cwd);
-    const magentoBackend = new EnvironmentBackend(input.environment === "warden" ? { type: "warden", projectRoot: ".", root: "/var/www/html", filesService: "php-fpm", targets: { default: "php-fpm" } } : { type: "local", root: "." }, cwd);
-    const executor = new DefaultProvisionExecutor(new BackendProvisionRunner(hostBackend), cwd, input.environment, new BackendProvisionRunner(magentoBackend));
-    for (const action of advised.plan.actions)
-        await executor.execute(action, input);
-    console.log("Provision completed.");
+}
+/** Starts a Pi investigation session; provisioning actions remain agent- and user-directed. */
+export async function provision(options, interview = new TerminalProvisionEnvironmentInterview(), launch = launchProvisioningAgent) {
+    const environment = options.environment ?? await interview.choose();
+    if (environment !== "local" && environment !== "warden")
+        throw new Error("--env must be local or warden");
+    process.exitCode = await launch(environment);
 }

package/dist/cli/main.js

@@ -12,7 +12,7 @@ async function main() {
     if (args.command === "init")
         return initProject(cwd);
     if (args.command === "provision")
-        return provision(cwd, args);
+        return provision(args);
     const loaded = await loadConfig(cwd, { config: args.configPath });
     const selected = selectEnvironment(loaded.config, cwd, args.environment);
     if (loaded.configPath && !(await isTrusted(loaded.configPath))) {

package/dist/config/index.d.ts

@@ -2,8 +2,9 @@ import type { Environment } from "#environments/model";
 import type { MerchantConfig } from "#config/schema";
 export { loadConfig, interpolate, type LoadedConfig } from "#config/loader";
 export { merchantHome } from "#config/paths";
+export { loadOperatorRole, saveOperatorRole } from "#config/operator-profile";
 export { setProjectTheme } from "#config/project-store";
-export { ConfigSchema, type MerchantConfig, } from "#config/schema";
+export { ConfigSchema, type MerchantConfig, operatorRoles, type OperatorRole, } from "#config/schema";
 export { configDigest, isTrusted, trustProject } from "#config/trust-store";
 export declare function selectEnvironment(config: MerchantConfig, cwd: string, requested?: string, env?: NodeJS.ProcessEnv): {
     name: string;

package/dist/config/index.js

@@ -1,7 +1,8 @@
 export { loadConfig, interpolate } from "#config/loader";
 export { merchantHome } from "#config/paths";
+export { loadOperatorRole, saveOperatorRole } from "#config/operator-profile";
 export { setProjectTheme } from "#config/project-store";
-export { ConfigSchema, } from "#config/schema";
+export { ConfigSchema, operatorRoles, } from "#config/schema";
 export { configDigest, isTrusted, trustProject } from "#config/trust-store";
 export function selectEnvironment(config, cwd, requested, env = process.env) {
     const name = requested ?? env.MERCHANTDUO_ENV ?? config.defaultEnvironment;

package/dist/config/loader.js

@@ -49,11 +49,7 @@ export async function loadConfig(cwd, options = {}) {
         },
     };
     if (!globalConfig && !projectConfig)
-        return {
-            config: ConfigSchema.parse({
-                environments: { local: { type: "local", root: "." } },
-            }),
-        };
+        throw new Error("No MerchantDuo configuration found; run merchantduo init first");
     return {
         config: ConfigSchema.parse(expand(raw, env)),
         configPath: projectConfig ? resolve(projectPath) : undefined,

package/dist/config/operator-profile.d.ts

@@ -0,0 +1,5 @@
+import { type OperatorRole } from "#config/schema";
+/** Read optional user-only agent context without involving repository configuration. */
+export declare function loadOperatorRole(env?: NodeJS.ProcessEnv): Promise<OperatorRole | undefined>;
+/** Persist the explicitly chosen role in the current user's MerchantDuo state. */
+export declare function saveOperatorRole(role: OperatorRole, env?: NodeJS.ProcessEnv): Promise<void>;

package/dist/config/operator-profile.js

@@ -0,0 +1,28 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { parse, stringify } from "yaml";
+import { merchantHome } from "#config/paths";
+import { operatorRoles } from "#config/schema";
+const profileFile = "operator-profile.yaml";
+/** Read optional user-only agent context without involving repository configuration. */
+export async function loadOperatorRole(env = process.env) {
+    const path = resolve(merchantHome(env), profileFile);
+    try {
+        const profile = parse(await readFile(path, "utf8"));
+        const role = profile?.operatorRole;
+        if (!operatorRoles.includes(role))
+            throw new Error(`Invalid operator role in ${path}`);
+        return role;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+/** Persist the explicitly chosen role in the current user's MerchantDuo state. */
+export async function saveOperatorRole(role, env = process.env) {
+    const directory = merchantHome(env);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await writeFile(resolve(directory, profileFile), stringify({ operatorRole: role }), { mode: 0o600 });
+}

package/dist/config/schema.d.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import type { Environment } from "#environments/model";
+export declare const operatorRoles: readonly ["store-admin", "backend-developer", "frontend-developer", "full-stack-developer"];
+export type OperatorRole = (typeof operatorRoles)[number];
 export declare const ConfigSchema: z.ZodObject<{
     defaultEnvironment: z.ZodOptional<z.ZodString>;
     activeTheme: z.ZodDefault<z.ZodString>;

package/dist/config/schema.js

@@ -1,4 +1,10 @@
 import { z } from "zod";
+export const operatorRoles = [
+    "store-admin",
+    "backend-developer",
+    "frontend-developer",
+    "full-stack-developer",
+];
 const testing = z
     .object({
     frontendUrl: z.string().url().optional(),

package/dist/integrations/pi/context.js

@@ -1,5 +1,6 @@
 import { refreshStatus, setInitializingStatus } from "#app/status";
 import { merchantDuoSystemPrompt } from "#app/system-prompt";
+import { loadOperatorRole } from "#config/index";
 import { discoverTesting } from "#testing/index";
 import { discoverMagerun2 } from "#features/magerun2/index";
 import { discoverHostExecutable, NodeHostProcessRunner } from "#testing/host";
@@ -58,8 +59,9 @@ export default function context(pi) {
     });
     pi.on("before_agent_start", async (event, ctx) => {
         const state = await runtime.boot(ctx.cwd);
+        const operatorRole = await loadOperatorRole();
         const testing = state.testing;
-        return { systemPrompt: `${event.systemPrompt}\n${merchantDuoSystemPrompt()}\nEnvironment: ${state.selected.name} is ${state.environmentStatus}; permission mode=${state.permissionMode}. ${state.environmentStatus === "stopped" ? "Use environment_start only after the user directly asks to start it; do not use project tools until it is running." : "Testing URLs are discovered but unverified. Frontend: " + (testing?.frontendUrl ?? "unavailable") + "; Admin: " + (testing?.adminUrl ?? "unavailable") + ". HTTP, browser, navigation, and test artifacts are host-only; never use environment bash to locate or repair their host paths. Use explicit test tools only when relevant."}` };
+        return { systemPrompt: `${event.systemPrompt}\n${merchantDuoSystemPrompt(operatorRole)}\nEnvironment: ${state.selected.name} is ${state.environmentStatus}; permission mode=${state.permissionMode}. ${state.environmentStatus === "stopped" ? "Use environment_start only after the user directly asks to start it; do not use project tools until it is running." : "Testing URLs are discovered but unverified. Frontend: " + (testing?.frontendUrl ?? "unavailable") + "; Admin: " + (testing?.adminUrl ?? "unavailable") + ". HTTP, browser, navigation, and test artifacts are host-only; never use environment bash to locate or repair their host paths. Use explicit test tools only when relevant."}` };
     });
 }
 export function statusMessage(state) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merchantduo/code",
-  "version": "0.3.0-beta.0",
+  "version": "0.3.0-beta.1",
   "private": false,
   "description": "Magento-native Pi-based Coding Agent",
   "type": "module",
@@ -12,7 +12,6 @@
     "#features/*": "./dist/features/*.js",
     "#integrations/*": "./dist/integrations/*.js",
     "#magento/*": "./dist/magento/*.js",
-    "#provision/*": "./dist/provision/*.js",
     "#shared/*": "./dist/shared/*.js",
     "#skills/*": "./dist/skills/*.js",
     "#testing/*": "./dist/testing/*.js",

package/dist/provision/advisor.d.ts

@@ -1,12 +0,0 @@
-import { type ProvisionPlan, type ProvisionSnapshot } from "#provision/model";
-export declare const PROVISION_ADVISOR_BASE_URL = "https://merchantduo.invalid/v1";
-export declare const PROVISION_ADVISOR_MODEL = "merchantduo-mock";
-export declare class ProvisionAdvisor {
-    private readonly token;
-    private readonly fetcher;
-    constructor(token?: string | undefined, fetcher?: typeof fetch);
-    advise(snapshot: ProvisionSnapshot, plan: ProvisionPlan): Promise<{
-        plan: ProvisionPlan;
-        diagnostic?: string;
-    }>;
-}

package/dist/provision/advisor.js

@@ -1,28 +0,0 @@
-import { redactProvisionSnapshot } from "#provision/model";
-export const PROVISION_ADVISOR_BASE_URL = "https://merchantduo.invalid/v1";
-export const PROVISION_ADVISOR_MODEL = "merchantduo-mock";
-export class ProvisionAdvisor {
-    token;
-    fetcher;
-    constructor(token = process.env.MERCHANTDUO_LLM_TOKEN, fetcher = fetch) {
-        this.token = token;
-        this.fetcher = fetcher;
-    }
-    async advise(snapshot, plan) {
-        if (!this.token)
-            return { plan };
-        try {
-            const response = await this.fetcher(`${PROVISION_ADVISOR_BASE_URL}/chat/completions`, { method: "POST", headers: { authorization: `Bearer ${this.token}`, "content-type": "application/json" }, body: JSON.stringify({ model: PROVISION_ADVISOR_MODEL, response_format: { type: "json_object" }, messages: [{ role: "user", content: JSON.stringify({ snapshot: redactProvisionSnapshot(snapshot), allowedActions: plan.actions }) }] }) });
-            if (!response.ok)
-                throw new Error(`advisor returned HTTP ${response.status}`);
-            const body = await response.json();
-            const selected = JSON.parse(body.choices?.[0]?.message?.content ?? "{}");
-            if (!Array.isArray(selected.actions) || !selected.actions.every((action) => plan.actions.some((allowed) => JSON.stringify(allowed) === JSON.stringify(action))))
-                throw new Error("advisor selected an action outside the approved plan");
-            return { plan: { ...plan, actions: selected.actions } };
-        }
-        catch (error) {
-            return { plan, diagnostic: `Provision advisor unavailable: ${error.message}; using deterministic plan.` };
-        }
-    }
-}

package/dist/provision/discovery.d.ts

@@ -1,12 +0,0 @@
-import type { ProvisionSnapshot } from "#provision/model";
-export type ProvisionProbe = {
-    run(argv: string[], cwd?: string): Promise<{
-        exitCode: number;
-        stdout: string;
-        stderr: string;
-    }>;
-};
-export declare class SystemProvisionProbe implements ProvisionProbe {
-    run(argv: string[], cwd?: string): Promise<import("#environments/executor").CommandResult>;
-}
-export declare function discoverProvision(root: string, probe?: ProvisionProbe): Promise<ProvisionSnapshot>;

package/dist/provision/discovery.js

@@ -1,61 +0,0 @@
-import { access, readdir, readFile } from "node:fs/promises";
-import { constants } from "node:fs";
-import { basename, join, resolve } from "node:path";
-const exists = async (path) => access(path, constants.F_OK).then(() => true).catch(() => false);
-export class SystemProvisionProbe {
-    async run(argv, cwd) {
-        const { EnvironmentBackend } = await import("#environments/backend");
-        const backend = new EnvironmentBackend({ type: "local", root: cwd ?? process.cwd() }, cwd ?? process.cwd());
-        return backend.run(argv);
-    }
-}
-async function command(probe, name, cwd) {
-    return (await probe.run(["sh", "-lc", `command -v ${name} >/dev/null`], cwd)).exitCode === 0;
-}
-async function serviceActive(probe, name, cwd) {
-    return (await probe.run(["sh", "-lc", `systemctl is-active --quiet ${name} 2>/dev/null || pgrep -x ${name} >/dev/null 2>&1`], cwd)).exitCode === 0;
-}
-function parseVhosts(text, root) {
-    const normalized = root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const rootMatch = text.match(new RegExp(`(?:root|DocumentRoot)\\s+["']?(${normalized}(?:/pub)?)["']?`, "i"));
-    if (!rootMatch)
-        return undefined;
-    const domain = text.match(/(?:server_name|ServerName)\s+([^\s;]+)/i)?.[1];
-    return domain ? { server: /server_name/i.test(text) ? "nginx" : "apache", domain, documentRoot: rootMatch[1] } : undefined;
-}
-export async function discoverProvision(root, probe = new SystemProvisionProbe()) {
-    const resolved = resolve(root);
-    const entries = await readdir(resolved).catch(() => []);
-    const composer = await exists(join(resolved, "composer.json"));
-    const binMagento = await exists(join(resolved, "bin/magento"));
-    const composerText = composer ? await readFile(join(resolved, "composer.json"), "utf8").catch(() => "") : "";
-    const detected = binMagento || /magento\/(product|project|composer)/.test(composerText);
-    const dumps = entries.filter((name) => /\.sql(?:\.gz)?$/i.test(name)).map((name) => join(resolved, name));
-    const [php, composerCommand, mysql, warden, nginx, apache, nginxActive, apacheActive, wardenRunning] = await Promise.all([
-        command(probe, "php", resolved), command(probe, "composer", resolved), command(probe, "mysql", resolved), command(probe, "warden", resolved),
-        command(probe, "nginx", resolved), command(probe, "apache2", resolved).then((v) => v || command(probe, "httpd", resolved)),
-        serviceActive(probe, "nginx", resolved), serviceActive(probe, "apache2", resolved), serviceActive(probe, "warden", resolved),
-    ]);
-    const wardenConfigured = await exists(join(resolved, ".warden", "warden-env.yml")) || await exists(join(resolved, ".env"));
-    const env = await readFile(join(resolved, ".env"), "utf8").catch(() => "");
-    const domain = env.match(/^TRAEFIK_(?:SUB)?DOMAIN=(.+)$/m)?.[1]?.trim().replace(/^['"]|['"]$/g, "");
-    const servers = [nginx && "nginx", apache && "apache"].filter(Boolean);
-    const activeServers = [nginxActive && "nginx", apacheActive && "apache"].filter(Boolean);
-    const serverConfig = await Promise.all(servers.map(async (server) => {
-        const paths = server === "nginx" ? ["/etc/nginx/sites-enabled", "/etc/nginx/conf.d"] : ["/etc/apache2/sites-enabled", "/etc/httpd/conf.d"];
-        for (const path of paths) {
-            const result = await probe.run(["sh", "-lc", `test -d ${path} && grep -R -h -E 'server_name|ServerName|root|DocumentRoot' ${path} 2>/dev/null || true`], resolved);
-            const vhost = parseVhosts(result.stdout, resolved);
-            if (vhost)
-                return { ...vhost, server };
-        }
-        return undefined;
-    }));
-    const magentoMode = detected ? await probe.run(["sh", "-lc", "test -x bin/magento && bin/magento deploy:mode:show --no-ansi || true"], resolved) : undefined;
-    return {
-        workspace: { root: resolved, empty: entries.length === 0, magentoRoot: detected }, source: { composer, binMagento },
-        database: { envConfigured: await exists(join(resolved, "app/etc/env.php")), dumps },
-        environments: { local: { available: php && composerCommand && mysql && activeServers.length > 0, php, composer: composerCommand, mysql, servers, activeServers, vhost: serverConfig.find(Boolean) }, warden: { available: warden, configured: wardenConfigured, running: wardenRunning, domain } },
-        magento: { detected, mode: magentoMode?.stdout.match(/(?:Current|Mode):\s*(\w+)/i)?.[1] }, diagnostics: detected ? [] : [`${basename(resolved)} is not a Magento root`]
-    };
-}

package/dist/provision/interview.d.ts

@@ -1,9 +0,0 @@
-import type { ProvisionInput, ProvisionPlan, ProvisionSnapshot } from "#provision/model";
-export interface ProvisionInterview {
-    resolve(snapshot: ProvisionSnapshot, initial: ProvisionInput): Promise<ProvisionInput>;
-    approve(plan: ProvisionPlan): Promise<boolean>;
-}
-export declare class TerminalProvisionInterview implements ProvisionInterview {
-    resolve(snapshot: ProvisionSnapshot, initial: ProvisionInput): Promise<ProvisionInput>;
-    approve(plan: ProvisionPlan): Promise<boolean>;
-}

package/dist/provision/interview.js

@@ -1,29 +0,0 @@
-import { createInterface } from "node:readline/promises";
-import { stdin, stdout } from "node:process";
-export class TerminalProvisionInterview {
-    async resolve(snapshot, initial) {
-        const rl = createInterface({ input: stdin, output: stdout });
-        try {
-            const environment = initial.environment ?? await rl.question(`Environment (${snapshot.environments.warden.available ? "warden" : "local"}/local): `);
-            const source = initial.source ?? (snapshot.workspace.magentoRoot ? "existing" : await rl.question("Magento source (git URL, archive path, or HTTPS URL): ").then(parseSource));
-            const database = initial.database ?? (snapshot.database.dumps.length === 1 ? `dump:${snapshot.database.dumps[0]}` : await rl.question("Database (current, dump path, or HTTPS URL): ").then(parseDatabase));
-            const localDomain = environment === "local" && !snapshot.environments.local.vhost ? await rl.question("Local domain (blank for directory.test): ") : initial.localDomain;
-            return { environment, source, database, localDomain: localDomain || undefined };
-        }
-        finally {
-            rl.close();
-        }
-    }
-    async approve(plan) {
-        stdout.write("\nProvision plan:\n" + plan.actions.map((action, index) => `${index + 1}. ${action.type}${"command" in action ? ` (${action.command})` : ""}`).join("\n") + `\nSudo required: ${plan.requiresSudo ? "yes" : "no"}\n`);
-        const rl = createInterface({ input: stdin, output: stdout });
-        try {
-            return (await rl.question("Execute this plan? [y/N] ")).trim().toLowerCase() === "y";
-        }
-        finally {
-            rl.close();
-        }
-    }
-}
-function parseSource(value) { return /^https?:\/\//.test(value) ? (value.endsWith(".git") ? `git:${value}` : `https:${value}`) : `archive:${value}`; }
-function parseDatabase(value) { return value === "current" ? "current" : /^https?:\/\//.test(value) ? `https:${value}` : `dump:${value}`; }

package/dist/provision/model.d.ts

@@ -1,82 +0,0 @@
-/** Public, redacted state used to make a provision decision. */
-export type ProvisionEnvironment = "local" | "warden";
-export type SourceInput = "existing" | `git:${string}` | `archive:${string}` | `https:${string}`;
-export type DatabaseInput = "current" | `dump:${string}` | `https:${string}`;
-export type ProvisionInput = {
-    environment?: ProvisionEnvironment;
-    source?: SourceInput;
-    database?: DatabaseInput;
-    localDomain?: string;
-};
-export type WebServer = "nginx" | "apache";
-export type ProvisionSnapshot = {
-    workspace: {
-        root: string;
-        empty: boolean;
-        magentoRoot: boolean;
-    };
-    source: {
-        composer: boolean;
-        binMagento: boolean;
-    };
-    database: {
-        envConfigured: boolean;
-        dumps: string[];
-    };
-    environments: {
-        local: {
-            available: boolean;
-            php: boolean;
-            composer: boolean;
-            mysql: boolean;
-            servers: WebServer[];
-            activeServers: WebServer[];
-            vhost?: {
-                server: WebServer;
-                domain: string;
-                documentRoot: string;
-            };
-        };
-        warden: {
-            available: boolean;
-            configured: boolean;
-            running: boolean;
-            domain?: string;
-        };
-    };
-    magento: {
-        detected: boolean;
-        mode?: string;
-    };
-    diagnostics: string[];
-};
-export type ProvisionAction = {
-    type: "acquire-source";
-    source: Exclude<SourceInput, "existing">;
-} | {
-    type: "install-dependencies";
-} | {
-    type: "start-warden";
-} | {
-    type: "import-database";
-    database: Exclude<DatabaseInput, "current">;
-} | {
-    type: "configure-database";
-} | {
-    type: "magento-setup";
-    command: "app:config:import" | "setup:upgrade" | "cache:clean" | "indexer:reindex" | "maintenance:disable";
-} | {
-    type: "configure-web-server";
-    server: WebServer;
-    domain: string;
-} | {
-    type: "verify-storefront";
-    url?: string;
-};
-export type ProvisionPlan = {
-    actions: ProvisionAction[];
-    rationale: string[];
-    blocked: string[];
-    requiresSudo: boolean;
-};
-export declare function redactProvisionSnapshot(snapshot: ProvisionSnapshot): ProvisionSnapshot;

package/dist/provision/model.js

@@ -1,5 +0,0 @@
-export function redactProvisionSnapshot(snapshot) {
-    // The contract intentionally has no credential fields. Copying also prevents callers
-    // from accidentally attaching private process data to the advisor payload.
-    return JSON.parse(JSON.stringify(snapshot));
-}

package/dist/provision/planner.d.ts

@@ -1,4 +0,0 @@
-import type { ProvisionInput, ProvisionPlan, ProvisionSnapshot } from "#provision/model";
-/** Deterministic planner. It has no process or filesystem side effects. */
-export declare function createProvisionPlan(snapshot: ProvisionSnapshot, input: ProvisionInput): ProvisionPlan;
-export declare function unresolvedInputs(snapshot: ProvisionSnapshot, input: ProvisionInput): string[];

package/dist/provision/planner.js

@@ -1,51 +0,0 @@
-const sourceMissing = (snapshot, input) => !snapshot.workspace.magentoRoot && (!input.source || input.source === "existing");
-const databaseMissing = (snapshot, input) => !input.database && snapshot.database.dumps.length !== 1;
-/** Deterministic planner. It has no process or filesystem side effects. */
-export function createProvisionPlan(snapshot, input) {
-    const blocked = [];
-    const rationale = [];
-    const actions = [];
-    const environment = input.environment;
-    if (!environment)
-        blocked.push("Select --env local or --env warden.");
-    if (sourceMissing(snapshot, input))
-        blocked.push("Provide --source existing, a Git URL, archive path, or HTTPS archive URL.");
-    if (databaseMissing(snapshot, input))
-        blocked.push("Provide --database current, a dump path, or an HTTPS dump URL.");
-    if (input.database === "current" && !snapshot.database.envConfigured)
-        blocked.push("--database current requires an existing usable Magento database configuration.");
-    if (environment === "warden" && !snapshot.environments.warden.available)
-        blocked.push("Warden is not installed or available on PATH.");
-    if (environment === "local" && (!snapshot.environments.local.php || !snapshot.environments.local.composer || !snapshot.environments.local.mysql))
-        blocked.push("Local provisioning requires PHP, Composer, and the MySQL client.");
-    if (environment === "local" && snapshot.environments.local.activeServers.length === 0)
-        blocked.push("Start nginx or Apache before local provisioning.");
-    if (environment === "local" && snapshot.environments.local.activeServers.length > 1 && !input.localDomain)
-        blocked.push("Both nginx and Apache are active; choose a local domain/server interactively.");
-    if (blocked.length)
-        return { actions, rationale, blocked, requiresSudo: false };
-    if (!snapshot.workspace.magentoRoot && input.source && input.source !== "existing")
-        actions.push({ type: "acquire-source", source: input.source });
-    actions.push({ type: "install-dependencies" });
-    if (environment === "warden" && !snapshot.environments.warden.running)
-        actions.push({ type: "start-warden" });
-    const database = input.database ?? (snapshot.database.dumps.length === 1 ? `dump:${snapshot.database.dumps[0]}` : undefined);
-    if (environment === "local" && !snapshot.database.envConfigured)
-        actions.push({ type: "configure-database" });
-    if (database && database !== "current")
-        actions.push({ type: "import-database", database });
-    actions.push({ type: "magento-setup", command: "app:config:import" }, { type: "magento-setup", command: "setup:upgrade" }, { type: "magento-setup", command: "cache:clean" }, { type: "magento-setup", command: "indexer:reindex" }, { type: "magento-setup", command: "maintenance:disable" });
-    const vhost = snapshot.environments.local.vhost;
-    if (environment === "local" && !vhost) {
-        const server = snapshot.environments.local.activeServers[0];
-        const domain = input.localDomain ?? `${snapshot.workspace.root.split("/").filter(Boolean).pop().replace(/[^a-z0-9-]/gi, "-").toLowerCase()}.test`;
-        actions.push({ type: "configure-web-server", server, domain });
-        rationale.push(`Create a minimal ${server} virtual host for ${domain}.`);
-    }
-    actions.push({ type: "verify-storefront", url: environment === "warden" ? snapshot.environments.warden.domain : vhost?.domain ?? input.localDomain });
-    rationale.push("Composer uses the lock file; Magento deployment mode is preserved.");
-    return { actions, rationale, blocked, requiresSudo: actions.some((action) => action.type === "configure-web-server") };
-}
-export function unresolvedInputs(snapshot, input) {
-    return createProvisionPlan(snapshot, input).blocked;
-}

package/dist/provision/runner.d.ts

@@ -1,35 +0,0 @@
-import type { CommandExecutor } from "#environments/executor";
-import type { ProvisionAction, ProvisionEnvironment, ProvisionInput } from "#provision/model";
-export type ProvisionRunner = {
-    run(argv: string[], options?: {
-        cwd?: string;
-        input?: string;
-    }): Promise<{
-        exitCode: number;
-        stdout: string;
-        stderr: string;
-    }>;
-};
-export declare class BackendProvisionRunner implements ProvisionRunner {
-    private readonly backend;
-    constructor(backend: CommandExecutor);
-    run(argv: string[], options?: {
-        cwd?: string;
-        input?: string;
-    }): Promise<import("#environments/executor").CommandResult>;
-}
-export declare function validateArchiveEntry(entry: string): boolean;
-export declare function vhostConfig(server: "nginx" | "apache", projectRoot: string, domain: string): string;
-export declare class DefaultProvisionExecutor {
-    private readonly runner;
-    private readonly root;
-    private readonly environment;
-    private readonly magentoRunner;
-    constructor(runner: ProvisionRunner, root: string, environment: ProvisionEnvironment, magentoRunner?: ProvisionRunner);
-    execute(action: ProvisionAction, input: ProvisionInput): Promise<void>;
-    private acquire;
-    private importDatabase;
-    private configureVhost;
-    private verify;
-    private must;
-}

package/dist/provision/runner.js

@@ -1,98 +0,0 @@
-import { mkdir, rm, stat } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
-export class BackendProvisionRunner {
-    backend;
-    constructor(backend) {
-        this.backend = backend;
-    }
-    run(argv, options = {}) { return this.backend.run(argv, { input: options.input }); }
-}
-export function validateArchiveEntry(entry) {
-    return entry.length > 0 && !entry.startsWith("/") && !entry.split(/[\\/]+/).includes("..");
-}
-export function vhostConfig(server, projectRoot, domain) {
-    if (!/^[a-z0-9-]+\.test$/i.test(domain))
-        throw new Error("Local domain must be a sanitized .test hostname");
-    const root = join(resolve(projectRoot), "pub");
-    return server === "nginx" ? `server { listen 80; server_name ${domain}; root ${root}; index index.php; location / { try_files $uri $uri/ /index.php?$args; } location ~ \\.php$ { try_files $uri =404; fastcgi_pass unix:/run/php/php-fpm.sock; include fastcgi_params; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; } }\n` : `<VirtualHost *:80>\n  ServerName ${domain}\n  DocumentRoot ${root}\n  <Directory ${root}>\n    AllowOverride All\n    Require all granted\n  </Directory>\n</VirtualHost>\n`;
-}
-export class DefaultProvisionExecutor {
-    runner;
-    root;
-    environment;
-    magentoRunner;
-    constructor(runner, root, environment, magentoRunner = runner) {
-        this.runner = runner;
-        this.root = root;
-        this.environment = environment;
-        this.magentoRunner = magentoRunner;
-    }
-    async execute(action, input) {
-        switch (action.type) {
-            case "acquire-source": return this.acquire(action.source);
-            case "install-dependencies": return this.must(["composer", "install", "--no-interaction", "--prefer-dist", "--no-progress"], this.magentoRunner);
-            case "start-warden": return this.must(["warden", "env", "config"]).then(() => this.must(["warden", "env", "start"]));
-            case "import-database": return this.importDatabase(action.database);
-            case "configure-database": throw new Error("Database configuration is required but no safe credential source was supplied. Add app/etc/env.php or use a current configured database.");
-            case "magento-setup":
-                if (action.command === "app:config:import") {
-                    const result = await this.magentoRunner.run(["bin/magento", action.command, "--no-interaction"], { cwd: this.root });
-                    if (result.exitCode !== 0 && !/does not exist|Nothing to import/i.test(result.stderr + result.stdout))
-                        throw new Error(result.stderr || result.stdout);
-                    return;
-                }
-                return this.must(["bin/magento", action.command, "--no-interaction"], this.magentoRunner);
-            case "configure-web-server": return this.configureVhost(action.server, action.domain);
-            case "verify-storefront": return this.verify(action.url);
-        }
-    }
-    async acquire(source) {
-        const entries = await stat(this.root).then(() => import("node:fs/promises").then(({ readdir }) => readdir(this.root))).catch(() => []);
-        if (entries.length)
-            throw new Error("Refusing to acquire source into a non-empty non-Magento directory.");
-        if (source.startsWith("git:"))
-            return this.must(["git", "clone", source.slice(4), "."]);
-        const location = source.replace(/^(archive|https):/, "");
-        const home = process.env.MERCHANTDUO_HOME ?? join(process.env.XDG_STATE_HOME ?? "/tmp", "merchantduo");
-        const stage = join(home, "provisions", `${Date.now()}-${basename(location).replace(/[^a-z0-9._-]/gi, "-")}`);
-        await mkdir(stage, { recursive: true });
-        try {
-            const archive = source.startsWith("https:") ? join(stage, "source.archive") : resolve(location);
-            if (source.startsWith("https:"))
-                await this.must(["curl", "--fail", "--location", "--output", archive, location]);
-            const listed = await this.runner.run(["tar", "-tzf", archive]);
-            if (listed.exitCode !== 0 || listed.stdout.split("\n").filter(Boolean).some((entry) => !validateArchiveEntry(entry)))
-                throw new Error("Archive is invalid or contains unsafe paths.");
-            await this.must(["tar", "-xzf", archive, "-C", this.root, "--strip-components=1"]);
-            const magento = await this.runner.run(["sh", "-lc", "test -f composer.json && (test -x bin/magento || grep -q 'magento/' composer.json)"], { cwd: this.root });
-            if (magento.exitCode !== 0)
-                throw new Error("Extracted archive does not contain a Magento root.");
-        }
-        finally {
-            await rm(stage, { recursive: true, force: true });
-        }
-    }
-    async importDatabase(database) {
-        const source = database.replace(/^(dump|https):/, "");
-        if (this.environment === "warden")
-            return this.must(["warden", "db", "import", source]);
-        if (database.startsWith("https:"))
-            throw new Error("Download the local database dump before local import; database credentials are never accepted as CLI arguments.");
-        return this.must(["sh", "-lc", `${source.endsWith(".gz") ? "gzip -dc --" : "cat --"} "$1" | mysql`, "merchantduo-db-import", source]);
-    }
-    async configureVhost(server, domain) {
-        const config = vhostConfig(server, this.root, domain);
-        const file = server === "nginx" ? `/etc/nginx/sites-available/${domain}` : `/etc/apache2/sites-available/${domain}.conf`;
-        const encoded = Buffer.from(config).toString("base64");
-        await this.must(["sudo", "sh", "-lc", `echo ${encoded} | base64 -d > ${file}`]);
-        if (server === "nginx")
-            await this.must(["sudo", "sh", "-lc", `ln -sfn ${file} /etc/nginx/sites-enabled/${domain} && nginx -t && systemctl reload nginx`]);
-        else
-            await this.must(["sudo", "sh", "-lc", `a2ensite ${domain}.conf && apachectl configtest && systemctl reload apache2`]);
-        await this.must(["sudo", "sh", "-lc", `grep -qE '^[[:space:]]*127\\.0\\.0\\.1[[:space:]].*\\b${domain}\\b' /etc/hosts || echo '127.0.0.1 ${domain}' >> /etc/hosts`]);
-    }
-    async verify(url) { if (url)
-        await this.must(["curl", "--fail", "--location", "--max-time", "20", `http://${url}`]); }
-    async must(argv, runner = this.runner) { const result = await runner.run(argv, { cwd: this.root }); if (result.exitCode !== 0)
-        throw new Error(`${argv.join(" ")} failed: ${result.stderr || result.stdout}`); }
-}