@merchantduo/code 0.1.0-beta.0 → 0.2.0-beta.1

package/dist/environments/adapters/warden.js

@@ -0,0 +1,24 @@
+import { resolve } from "node:path";
+export class WardenAdapter {
+    environment;
+    cwd;
+    constructor(environment, cwd) {
+        this.environment = environment;
+        this.cwd = cwd;
+    }
+    path(path) {
+        return path.startsWith("/") ? path : `${this.environment.root}/${path}`;
+    }
+    command(argv, target) {
+        const service = target
+            ? this.environment.targets[target]
+            : this.environment.filesService;
+        if (!service)
+            throw new Error(`Unknown Warden target: ${target}`);
+        return {
+            file: "warden",
+            args: ["env", "exec", "-T", service, ...argv],
+            cwd: resolve(this.cwd, this.environment.projectRoot),
+        };
+    }
+}

package/dist/environments/backend.d.ts

@@ -0,0 +1,13 @@
+import type { Environment } from "#environments/model";
+import type { CommandExecutor, CommandResult, CommandSpec, RunOptions } from "#environments/executor";
+export { contain } from "#environments/path-policy";
+/** Concrete local/Warden/SSH command adapter selected once for a session. */
+export declare class EnvironmentBackend implements CommandExecutor {
+    #private;
+    readonly environment: Environment;
+    readonly localRoot: string;
+    constructor(environment: Environment, localRoot: string);
+    path(path: string): string;
+    command(argv: string[], target?: string): CommandSpec;
+    run(argv: string[], options?: RunOptions): Promise<CommandResult>;
+}

package/dist/environments/backend.js

@@ -0,0 +1,73 @@
+import { spawn } from "node:child_process";
+import { createEnvironmentAdapter } from "#environments/factory";
+export { contain } from "#environments/path-policy";
+const MAX_OUTPUT = 64 * 1024;
+/** Concrete local/Warden/SSH command adapter selected once for a session. */
+export class EnvironmentBackend {
+    environment;
+    localRoot;
+    #adapter;
+    constructor(environment, localRoot) {
+        this.environment = environment;
+        this.localRoot = localRoot;
+        this.#adapter = createEnvironmentAdapter(environment, localRoot);
+    }
+    path(path) {
+        return this.#adapter.path(path);
+    }
+    command(argv, target) {
+        if (!argv[0])
+            throw new Error("Cannot execute an empty command");
+        return this.#adapter.command(argv, target);
+    }
+    async run(argv, options = {}) {
+        const spec = this.command(argv, options.target);
+        return new Promise((resolveResult) => {
+            const child = spawn(spec.file, spec.args, {
+                cwd: spec.cwd,
+                signal: options.signal,
+                detached: process.platform !== "win32",
+            });
+            let out = "";
+            let err = "";
+            let truncated = false;
+            let settled = false;
+            const finish = (result) => {
+                if (!settled) {
+                    settled = true;
+                    resolveResult(result);
+                }
+            };
+            const add = (old, buffer) => {
+                const next = old + buffer.toString();
+                if (next.length > MAX_OUTPUT) {
+                    truncated = true;
+                    return next.slice(0, MAX_OUTPUT);
+                }
+                return next;
+            };
+            child.stdout.on("data", (buffer) => (out = add(out, buffer)));
+            child.stderr.on("data", (buffer) => (err = add(err, buffer)));
+            if (options.input !== undefined)
+                child.stdin.end(options.input);
+            const timer = options.timeoutMs
+                ? setTimeout(() => child.kill("SIGTERM"), options.timeoutMs)
+                : undefined;
+            child.on("error", (error) => {
+                if (timer)
+                    clearTimeout(timer);
+                finish({
+                    stdout: out,
+                    stderr: error.message,
+                    exitCode: 127,
+                    truncated,
+                });
+            });
+            child.on("close", (code) => {
+                if (timer)
+                    clearTimeout(timer);
+                finish({ stdout: out, stderr: err, exitCode: code ?? 1, truncated });
+            });
+        });
+    }
+}

package/dist/environments/executor.d.ts

@@ -0,0 +1,23 @@
+export type CommandResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    truncated: boolean;
+};
+export type CommandSpec = {
+    file: string;
+    args: string[];
+    cwd?: string;
+};
+export type RunOptions = {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    target?: string;
+    input?: string | Buffer;
+};
+/** Port used by Magento inspection and workflows, independent of environment type. */
+export interface CommandExecutor {
+    path(path: string): string;
+    command(argv: string[], target?: string): CommandSpec;
+    run(argv: string[], options?: RunOptions): Promise<CommandResult>;
+}

package/dist/environments/factory.d.ts

@@ -0,0 +1,3 @@
+import type { EnvironmentAdapter } from "#environments/adapter";
+import type { Environment } from "#environments/model";
+export declare function createEnvironmentAdapter(environment: Environment, cwd: string): EnvironmentAdapter;

package/dist/environments/factory.js

@@ -0,0 +1,13 @@
+import { LocalAdapter } from "#environments/adapters/local";
+import { SshAdapter } from "#environments/adapters/ssh";
+import { WardenAdapter } from "#environments/adapters/warden";
+export function createEnvironmentAdapter(environment, cwd) {
+    switch (environment.type) {
+        case "local":
+            return new LocalAdapter(environment, cwd);
+        case "warden":
+            return new WardenAdapter(environment, cwd);
+        case "ssh":
+            return new SshAdapter(environment);
+    }
+}

package/dist/environments/model.d.ts

@@ -0,0 +1,28 @@
+type EnvironmentTesting = {
+    frontendUrl?: string;
+    adminUrl?: string;
+    allowInsecureTls?: boolean;
+};
+export type LocalEnvironment = {
+    type: "local";
+    root: string;
+    testing?: EnvironmentTesting;
+};
+export type WardenEnvironment = {
+    type: "warden";
+    projectRoot: string;
+    root: string;
+    filesService: string;
+    targets: Record<string, string>;
+    testing?: EnvironmentTesting;
+};
+export type SshEnvironment = {
+    type: "ssh";
+    host: string;
+    root: string;
+    writable: boolean;
+    testing?: EnvironmentTesting;
+};
+export type Environment = LocalEnvironment | WardenEnvironment | SshEnvironment;
+export declare function environmentWritable(environment: Environment): boolean;
+export {};

package/dist/environments/model.js

@@ -0,0 +1,3 @@
+export function environmentWritable(environment) {
+    return environment.type !== "ssh" || environment.writable;
+}

package/dist/environments/path-policy.d.ts

@@ -0,0 +1 @@
+export declare function contain(root: string, candidate: string): string;

package/dist/environments/path-policy.js

@@ -0,0 +1,8 @@
+import { relative, resolve, sep } from "node:path";
+export function contain(root, candidate) {
+    const full = resolve(root, candidate);
+    const relation = relative(resolve(root), full);
+    if (relation === ".." || relation.startsWith(`..${sep}`))
+        throw new Error(`Path escapes configured root: ${candidate}`);
+    return full;
+}

package/dist/{mage2gen.d.ts → features/mage2gen/service.d.ts}

@@ -12,5 +12,4 @@ export type Mage2GenRequest = {
 };
 export declare function mage2genDestination(projectRoot: string, vendor: string, module: string): string;
 export declare function mage2genModuleExists(request: Mage2GenRequest): Promise<boolean>;
-/** Execute the vendored Mage2Gen library on the host workspace mounted by local/Warden Magento. */
 export declare function generateMage2GenModule(request: Mage2GenRequest): Promise<string>;

package/dist/{mage2gen.js → features/mage2gen/service.js}

@@ -1,8 +1,12 @@
 import { spawn } from "node:child_process";
 import { access } from "node:fs/promises";
 import { resolve } from "node:path";
+import { contain } from "#environments/path-policy";
 export function mage2genDestination(projectRoot, vendor, module) {
-    return resolve(projectRoot, "app/code", vendor, module);
+    if (!/^[A-Z][A-Za-z0-9]*$/.test(vendor) ||
+        !/^[A-Z][A-Za-z0-9]*$/.test(module))
+        throw new Error("Mage2Gen requires PascalCase vendor and module names");
+    return contain(resolve(projectRoot, "app/code"), `${vendor}/${module}`);
 }
 export async function mage2genModuleExists(request) {
     try {
@@ -13,7 +17,6 @@ export async function mage2genModuleExists(request) {
         return false;
     }
 }
-/** Execute the vendored Mage2Gen library on the host workspace mounted by local/Warden Magento. */
 export async function generateMage2GenModule(request) {
     const program = `
 import json, sys
@@ -41,6 +44,8 @@ print(data['destination'])
         child.stdout.on("data", (chunk) => (output += chunk));
         child.stderr.on("data", (chunk) => (error += chunk));
         child.on("error", reject);
-        child.on("close", (code) => code === 0 ? resolveResult(output.trim()) : reject(new Error(error || `Mage2Gen exited with ${code}`)));
+        child.on("close", (code) => code === 0
+            ? resolveResult(output.trim())
+            : reject(new Error(error || `Mage2Gen exited with ${code}`)));
     });
 }

package/dist/integrations/pi/context.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function context(pi: ExtensionAPI): void;

package/dist/integrations/pi/context.js

@@ -0,0 +1,46 @@
+import { refreshStatus } from "#app/status";
+import { merchantDuoSystemPrompt } from "#app/system-prompt";
+import { discoverTesting, discoverMagerun } from "#testing/index";
+import { discoverHostExecutable } from "#testing/host";
+import { runtime, sessionEvents } from "#integrations/pi/session";
+export default function context(pi) {
+    pi.on("session_start", async (_event, ctx) => {
+        runtime.resetInjection();
+        const state = await runtime.boot(ctx.cwd);
+        const magerun = await discoverMagerun(state.selected.environment, state.backend, ctx.cwd);
+        // HTTP and Chromium deliberately run on the host against Warden's routed URL.
+        // Do not use EnvironmentBackend here: its Warden adapter would probe php-fpm.
+        // Prefer non-Snap Chrome: Snap Chromium cannot write MerchantDuo artifacts
+        // and its private /tmp makes generated output unavailable to the host.
+        const [http, browser] = await Promise.all([
+            discoverHostExecutable(["curl"]),
+            discoverHostExecutable(["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]),
+        ]);
+        runtime.setTesting(await discoverTesting(state.selected.environment, state.backend, ctx.cwd, { ...state.config.testing, ...state.selected.environment.testing, allowInsecureTls: state.selected.environment.testing?.allowInsecureTls ?? state.config.testing.allowInsecureTls }, { http, browser, magerun: magerun.executable }));
+        if (magerun.diagnostic)
+            state.testing?.diagnostics.push(magerun.diagnostic);
+        refreshStatus(ctx, state);
+        sessionEvents.emit("merchantduo.context", state);
+        pi.appendEntry("merchantduo.context", { environment: state.selected.name, testing: state.testing });
+    });
+    pi.on("session_compact", () => runtime.resetInjection());
+    pi.on("session_shutdown", () => sessionEvents.clear());
+    pi.on("tool_call", (event) => {
+        if (event.toolName !== "write" && event.toolName !== "edit")
+            return;
+        const path = event.input.path;
+        if (typeof path === "string")
+            runtime.changes.begin(event.toolCallId, path);
+    });
+    pi.on("tool_result", (event, ctx) => {
+        runtime.changes.finish(event.toolCallId, !event.isError);
+        const files = runtime.changes.files();
+        if (files.length)
+            ctx.ui.setStatus("merchantduo-actions", `Pending validation and cache recommendations for ${files.length} edit(s)`);
+    });
+    pi.on("before_agent_start", async (event, ctx) => {
+        const state = await runtime.boot(ctx.cwd);
+        const testing = state.testing;
+        return { systemPrompt: `${event.systemPrompt}\n${merchantDuoSystemPrompt()}\nTesting 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.` };
+    });
+}

package/dist/integrations/pi/mage2gen.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function mage2gen(pi: ExtensionAPI): void;

package/dist/integrations/pi/mage2gen.js

@@ -0,0 +1,19 @@
+import { resolve } from "node:path";
+import { Type } from "typebox";
+import { mage2genRoot } from "#app/system-prompt";
+import { generateMage2GenModule, mage2genDestination, mage2genModuleExists } from "#features/mage2gen/service";
+import { runtime, text } from "#integrations/pi/session";
+export default function mage2gen(pi) { pi.registerTool({ name: "mage2gen_generate_module", label: "Generate Magento module", description: "Preview or explicitly generate a Magento module through vendored Mage2Gen.", parameters: Type.Object({ vendor: Type.String(), module: Type.String(), description: Type.Optional(Type.String()), execute: Type.Optional(Type.Boolean()) }), async execute(_id, params, _signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); if (state.selected.environment.type === "ssh")
+        return text("Mage2Gen is unavailable for SSH."); const root = state.selected.environment.type === "warden" ? resolve(ctx.cwd, state.selected.environment.projectRoot) : resolve(ctx.cwd, state.selected.environment.root); let destination; try {
+        destination = mage2genDestination(root, params.vendor, params.module);
+    }
+    catch (error) {
+        return text(error.message);
+    } const request = { mage2genRoot: mage2genRoot(), projectRoot: root, vendor: params.vendor, module: params.module, description: params.description }; if (await mage2genModuleExists(request))
+        return text(`Refused: module destination already exists: ${destination}`); if (!params.execute)
+        return text(`Preview: Mage2Gen will create ${destination}. Set execute=true after the user's direct request.`); try {
+        return text(`Mage2Gen created ${params.vendor}_${params.module} at ${await generateMage2GenModule(request)}.`);
+    }
+    catch (error) {
+        return text(`Mage2Gen failed: ${error.message}`);
+    } } }); }

package/dist/integrations/pi/permissions.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { Environment } from "#environments/model";
+export declare function requiresExecuteConfirmation(toolName: string, input: Record<string, unknown>): boolean;
+export declare function requiresSshConfirmation(environment: Environment, toolName: string): boolean;
+/** The sole MerchantDuo confirmation gate. Explicit test/navigation tools are intentionally excluded. */
+export default function permissions(pi: ExtensionAPI): void;

package/dist/integrations/pi/permissions.js

@@ -0,0 +1,36 @@
+import { runtime } from "#integrations/pi/session";
+export function requiresExecuteConfirmation(toolName, input) {
+    return (toolName === "mage2gen_generate_module" || toolName === "magento_workflow") && input.execute === true;
+}
+export function requiresSshConfirmation(environment, toolName) {
+    return environment.type === "ssh" && environment.writable && ["write", "edit", "bash"].includes(toolName);
+}
+/** The sole MerchantDuo confirmation gate. Explicit test/navigation tools are intentionally excluded. */
+export default function permissions(pi) {
+    pi.on("tool_call", async (event, ctx) => {
+        const state = await runtime.boot(ctx.cwd);
+        const input = event.input;
+        if (requiresExecuteConfirmation(event.toolName, input)) {
+            const ok = ctx.hasUI && await ctx.ui.confirm("Confirm Magento action", `Execute ${event.toolName}?`);
+            return ok ? undefined : { block: true, reason: "Cancelled: confirmation required." };
+        }
+        if (state.selected.environment.type === "ssh" && ["write", "edit", "bash"].includes(event.toolName)) {
+            if (!state.selected.environment.writable)
+                return { block: true, reason: "MerchantDuo: this SSH environment is read-only." };
+            const ok = !requiresSshConfirmation(state.selected.environment, event.toolName) || (ctx.hasUI && await ctx.ui.confirm("SSH workspace action", `Run ${event.toolName} on ${state.selected.environment.host}?`));
+            return ok ? undefined : { block: true, reason: "Cancelled: SSH confirmation required." };
+        }
+    });
+    pi.on("user_bash", async (event, ctx) => {
+        const state = await runtime.boot(ctx.cwd);
+        if (state.selected.environment.type !== "ssh")
+            return;
+        if (!state.selected.environment.writable)
+            return { result: { output: "MerchantDuo: this SSH environment is read-only.", exitCode: 1, cancelled: true, truncated: false } };
+        const ok = ctx.hasUI && await ctx.ui.confirm("SSH command", `Run command on ${state.selected.environment.host}?`);
+        if (!ok)
+            return { result: { output: "Cancelled: confirmation required.", exitCode: 1, cancelled: true, truncated: false } };
+        const result = await state.backend.run(["sh", "-lc", event.command]);
+        return { result: { output: `${result.stdout}${result.stderr}`, exitCode: result.exitCode, cancelled: false, truncated: result.truncated } };
+    });
+}

package/dist/integrations/pi/session.d.ts

@@ -0,0 +1,12 @@
+import { MerchantDuoRuntime } from "#app/runtime";
+/** Pi evaluates all package extensions in one module graph; this is session-scoped shared state. */
+export declare const runtime: MerchantDuoRuntime;
+/** Native Pi event bus for resolved session context consumers. */
+export declare const sessionEvents: import("@earendil-works/pi-coding-agent").EventBusController;
+export declare function text(value: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {};
+};

package/dist/integrations/pi/session.js

@@ -0,0 +1,9 @@
+import { MerchantDuoRuntime } from "#app/runtime";
+import { createEventBus } from "@earendil-works/pi-coding-agent";
+/** Pi evaluates all package extensions in one module graph; this is session-scoped shared state. */
+export const runtime = new MerchantDuoRuntime();
+/** Native Pi event bus for resolved session context consumers. */
+export const sessionEvents = createEventBus();
+export function text(value) {
+    return { content: [{ type: "text", text: value }], details: {} };
+}

package/dist/integrations/pi/testing.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function testing(pi: ExtensionAPI): void;

package/dist/integrations/pi/testing.js

@@ -0,0 +1,88 @@
+import { mkdtemp, mkdir, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { Type } from "typebox";
+import { merchantHome } from "#config/paths";
+import { joinedUrl, relativePath, sameOrigin } from "#testing/url";
+import { artifactExists, bound, browserArguments, NodeHostProcessRunner } from "#testing/host";
+import { runtime, text } from "#integrations/pi/session";
+const host = new NodeHostProcessRunner();
+export default function testing(pi) {
+    pi.registerTool({ name: "magento_http_test", label: "Magento HTTP test", description: "Explicit unauthenticated GET or HEAD test against a discovered Magento URL.", parameters: Type.Object({ target: Type.Union([Type.Literal("frontend"), Type.Literal("adminhtml")]), path: Type.Optional(Type.String()), method: Type.Optional(Type.Union([Type.Literal("GET"), Type.Literal("HEAD")])) }), async execute(_id, params, signal, _update, ctx) {
+            const state = await runtime.boot(ctx.cwd);
+            const base = params.target === "frontend" ? state.testing?.frontendUrl : state.testing?.adminUrl;
+            const url = targetUrl(base, params.path ?? "/");
+            if (!url)
+                return text("Refused: target URL is unavailable or path is not same-origin.");
+            const args = ["--silent", "--show-error", "--location", "--max-time", "20", "--connect-timeout", "8", "--dump-header", "-", "--request", params.method ?? "GET", url];
+            if (!state.testing?.http.executable)
+                return text(state.testing?.http.reason ?? "HTTP testing unavailable.");
+            if (state.selected.environment.testing?.allowInsecureTls ?? state.config.testing.allowInsecureTls)
+                args.unshift("--insecure");
+            const result = await host.run(state.testing.http.executable, args, { cwd: ctx.cwd, signal });
+            return text(bound(`URL: ${url}\n${result.output}`));
+        } });
+    pi.registerTool({ name: "magento_browser_test", label: "Magento browser test", description: "Explicit stateless Chromium screenshot or DOM capture for a discovered Magento URL.", parameters: Type.Object({ target: Type.Union([Type.Literal("frontend"), Type.Literal("adminhtml")]), action: Type.Union([Type.Literal("screenshot"), Type.Literal("dump-dom")]), path: Type.Optional(Type.String()) }), async execute(_id, params, signal, _update, ctx) {
+            const state = await runtime.boot(ctx.cwd);
+            const executable = state.testing?.browser.executable;
+            const base = params.target === "frontend" ? state.testing?.frontendUrl : state.testing?.adminUrl;
+            const url = targetUrl(base, params.path ?? "/");
+            if (!executable || !url)
+                return text("Browser test unavailable: Chromium or target URL is unavailable.");
+            const artifactDir = resolve(merchantHome(), "artifacts", projectId(ctx.cwd));
+            await mkdir(artifactDir, { recursive: true, mode: 0o700 });
+            const profile = await mkdtemp(join(tmpdir(), "merchantduo-chromium-"));
+            const artifact = join(artifactDir, `${Date.now()}-${params.action}${params.action === "screenshot" ? ".png" : ".html"}`);
+            try {
+                const allowInsecureTls = state.selected.environment.testing?.allowInsecureTls ?? state.config.testing.allowInsecureTls;
+                const args = browserArguments({ profile, artifact, url, action: params.action, allowInsecureTls });
+                const result = await host.run(executable, args, { cwd: ctx.cwd, signal });
+                if (params.action === "dump-dom") {
+                    if (result.code)
+                        return text(`Browser DOM capture failed (exit ${result.code}):\n${bound(result.output)}`);
+                    await BunOrNode.write(artifact, bound(result.output));
+                    return text(`DOM saved to ${artifact}\n${bound(result.output)}`);
+                }
+                if (result.code)
+                    return text(`Browser screenshot failed (exit ${result.code}):\n${bound(result.output)}`);
+                if (!(await artifactExists(artifact)))
+                    return text(`Browser screenshot failed: ${executable} did not create the host artifact. A sandboxed Snap Chromium cannot access MerchantDuo artifacts.\n${bound(result.output)}`);
+                const image = await readFile(artifact);
+                return { content: [{ type: "text", text: `Screenshot saved to ${artifact}\n${bound(result.output)}` }, { type: "image", data: image.toString("base64"), mimeType: "image/png" }], details: {} };
+            }
+            finally {
+                await rm(profile, { recursive: true, force: true });
+            }
+        } });
+    pi.registerTool({ name: "magento_php_repl", label: "Magento PHP console", description: "Explicit one-shot magerun2 PHP snippet execution.", parameters: Type.Object({ snippet: Type.String({ minLength: 1 }), area: Type.Optional(Type.Union([Type.Literal("adminhtml"), Type.Literal("frontend"), Type.Literal("crontab"), Type.Literal("webapi_rest"), Type.Literal("graphql")])) }), async execute(_id, params, signal, _update, ctx) {
+            const state = await runtime.boot(ctx.cwd);
+            if (state.selected.environment.type === "ssh" && !state.selected.environment.writable)
+                return text("PHP REPL is unavailable for read-only SSH.");
+            const executable = state.testing?.phpRepl.executable;
+            if (!executable)
+                return text(state.testing?.phpRepl.reason ?? "PHP REPL unavailable.");
+            const args = [executable, "dev:console"];
+            if (params.area)
+                args.push(`--area=${params.area}`);
+            if (state.selected.environment.type === "local") {
+                const result = await host.run("sh", ["-lc", `${quote(executable)} dev:console${params.area ? ` --area=${params.area}` : ""}`], { cwd: ctx.cwd, signal, input: params.snippet });
+                return text(bound(result.output));
+            }
+            const result = await state.backend.run(args, { input: params.snippet, signal });
+            return text(bound(`${result.stdout}${result.stderr}`));
+        } });
+    registerNavigate(pi, "navigate-frontend", "frontend");
+    registerNavigate(pi, "navigate-adminhtml", "adminhtml");
+}
+function registerNavigate(pi, name, target) { pi.registerCommand(name, { description: `Open the discovered Magento ${target} URL in the default browser.`, handler: async (args, ctx) => { const state = await runtime.boot(ctx.cwd); const base = target === "frontend" ? state.testing?.frontendUrl : state.testing?.adminUrl; const url = targetUrl(base, args.trim() || "/"); if (!url) {
+        ctx.ui.notify("URL unavailable or path is not same-origin.", "error");
+        return;
+    } const [file, openerArgs] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]]; const result = await host.run(file, openerArgs, { cwd: ctx.cwd }); if (result.code)
+        ctx.ui.notify(`Could not open browser: ${result.output}`, "error");
+    else
+        ctx.ui.notify(`Opened ${url}`, "info"); } }); }
+function targetUrl(base, path) { if (!relativePath(path))
+    return undefined; const url = joinedUrl(base, path); return url && sameOrigin(base, url) ? url : undefined; }
+function projectId(cwd) { return cwd.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-|-$/g, "").slice(-80) || "project"; }
+function quote(value) { return `'${value.replace(/'/g, "'\\''")}'`; }
+const BunOrNode = { async write(path, value) { const { writeFile } = await import("node:fs/promises"); await writeFile(path, value, "utf8"); } };

package/dist/integrations/pi/theme.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function theme(pi: ExtensionAPI): void;

package/dist/integrations/pi/theme.js

@@ -0,0 +1,6 @@
+import { refreshStatus } from "#app/status";
+import { runtime } from "#integrations/pi/session";
+export default function theme(pi) { pi.registerCommand("theme", { description: "Select all, any, or a detected Magento theme.", handler: async (args, ctx) => { const state = await runtime.boot(ctx.cwd); const value = args.trim(); const choices = ["all", "any", ...state.magento.themes.map((theme) => theme.code)]; if (!choices.includes(value)) {
+        ctx.ui.notify(`Choose one of: ${choices.join(", ")}`, "error");
+        return;
+    } const changed = await runtime.changeTheme(ctx.cwd, value); refreshStatus(ctx, changed); ctx.ui.notify(`Theme scope set to ${value}.`, "info"); } }); }

package/dist/integrations/pi/workflows.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function workflows(pi: ExtensionAPI): void;

package/dist/integrations/pi/workflows.js

@@ -0,0 +1,26 @@
+import { Type } from "typebox";
+import { builtInWorkflows } from "#workflows/builtins";
+import { runWorkflow, syntaxCheck } from "#workflows/runner";
+import { runtime, text } from "#integrations/pi/session";
+export default function workflows(pi) {
+    pi.registerTool({ name: "magento_workflow", label: "Magento workflow", description: "Preview or explicitly execute a supported Magento operational action.", parameters: Type.Object({ action: Type.String(), execute: Type.Optional(Type.Boolean()) }), async execute(_id, params, _signal, _update, ctx) {
+            const state = await runtime.boot(ctx.cwd);
+            if (params.action === "status")
+                return text(JSON.stringify({ snapshot: state.magento, testing: state.testing, pendingFiles: runtime.changes.files(), workflows: builtInWorkflows.map(({ id, description }) => ({ id, description })) }, null, 2));
+            if (params.action === "syntax-check")
+                return text((await syntaxCheck(state.backend, runtime.changes.files())).join("\n") || "No supported changed files require syntax checks.");
+            const workflow = builtInWorkflows.find(({ id }) => id === params.action);
+            if (!workflow)
+                return text(`Unknown workflow: ${params.action}`);
+            const cacheTypes = workflow.id === "cache-clean" ? runtime.changes.safeCacheTypes(state.magento) : [];
+            const command = workflow.command(cacheTypes);
+            if (!params.execute)
+                return text(`Preview: ${command.join(" ")}. Set execute=true after the user's direct request.`);
+            if (state.selected.environment.type === "ssh" && !workflow.allowRemote)
+                return text(`Refused: ${workflow.id} is not enabled for SSH environments.`);
+            const result = await runWorkflow(state.backend, workflow, cacheTypes);
+            if (result.result.exitCode === 0 && workflow.id === "cache-clean")
+                runtime.changes.clear();
+            return text(JSON.stringify(result, null, 2));
+        } });
+}

package/dist/integrations/pi/workspace.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { EnvironmentBackend } from "#environments/backend";
+/** Replaces Pi's native workspace tools with selected-environment operations. */
+export default function workspace(pi: ExtensionAPI): void;
+export declare function workspacePath(backend: EnvironmentBackend, cwd: string, candidate: string): string;

package/dist/integrations/pi/workspace.js

@@ -0,0 +1,33 @@
+import { relative, resolve } from "node:path";
+import { Type } from "typebox";
+import { createEditToolDefinition, createReadToolDefinition, createWriteToolDefinition, } from "@earendil-works/pi-coding-agent";
+import { runtime } from "#integrations/pi/session";
+const shell = (value) => `'${value.replace(/'/g, "'\\''")}'`;
+const result = (value) => ({ content: [{ type: "text", text: value }], details: {} });
+/** Replaces Pi's native workspace tools with selected-environment operations. */
+export default function workspace(pi) {
+    registerFileTools(pi);
+    pi.registerTool({ name: "bash", label: "bash", description: "Run a shell command in the selected MerchantDuo environment.", parameters: Type.Object({ command: Type.String(), timeout: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const output = await state.backend.run(["sh", "-lc", params.command], { signal, timeoutMs: params.timeout }); return result(`${output.stdout}${output.stderr}`); } });
+    pi.registerTool({ name: "ls", label: "ls", description: "List a selected-environment directory.", parameters: Type.Object({ path: Type.Optional(Type.String()), limit: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const path = workspacePath(state.backend, ctx.cwd, params.path ?? "."); const output = await state.backend.run(["sh", "-lc", `find ${shell(path)} -mindepth 1 -maxdepth 1 -printf '%f\\n' | head -n ${Math.max(1, Math.min(params.limit ?? 200, 1000))}`], { signal }); return result(output.stdout || output.stderr); } });
+    pi.registerTool({ name: "find", label: "find", description: "Find files in the selected MerchantDuo environment.", parameters: Type.Object({ pattern: Type.String(), path: Type.Optional(Type.String()), limit: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const path = workspacePath(state.backend, ctx.cwd, params.path ?? "."); const limit = Math.max(1, Math.min(params.limit ?? 1000, 5000)); const output = await state.backend.run(["sh", "-lc", `find ${shell(path)} -path '*/node_modules/*' -prune -o -path '*/.git/*' -prune -o -name ${shell(params.pattern)} -print | head -n ${limit}`], { signal }); return result(output.stdout || output.stderr); } });
+    pi.registerTool({ name: "grep", label: "grep", description: "Search text using ripgrep in the selected MerchantDuo environment.", parameters: Type.Object({ pattern: Type.String(), path: Type.Optional(Type.String()), glob: Type.Optional(Type.String()), ignoreCase: Type.Optional(Type.Boolean()), literal: Type.Optional(Type.Boolean()), context: Type.Optional(Type.Number()), limit: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const path = workspacePath(state.backend, ctx.cwd, params.path ?? "."); const limit = Math.max(1, Math.min(params.limit ?? 100, 1000)); const flags = ["--line-number", "--color=never", `--max-count=${limit}`, params.ignoreCase ? "--ignore-case" : "", params.literal ? "--fixed-strings" : "", params.context ? `--context=${Math.min(params.context, 20)}` : "", params.glob ? `--glob ${shell(params.glob)}` : ""].filter(Boolean).join(" "); const output = await state.backend.run(["sh", "-lc", `rg ${flags} -- ${shell(params.pattern)} ${shell(path)}`], { signal }); return result(output.stdout || output.stderr); } });
+}
+function registerFileTools(pi) {
+    const localRead = createReadToolDefinition(process.cwd());
+    const localWrite = createWriteToolDefinition(process.cwd());
+    const localEdit = createEditToolDefinition(process.cwd());
+    pi.registerTool({ ...localRead, async execute(id, params, signal, update, ctx) { const state = await runtime.boot(ctx.cwd); return createReadToolDefinition(ctx.cwd, { operations: fileOps(state.backend, ctx.cwd) }).execute(id, params, signal, update, ctx); } });
+    pi.registerTool({ ...localWrite, async execute(id, params, signal, update, ctx) { const state = await runtime.boot(ctx.cwd); return createWriteToolDefinition(ctx.cwd, { operations: fileOps(state.backend, ctx.cwd) }).execute(id, params, signal, update, ctx); } });
+    pi.registerTool({ ...localEdit, async execute(id, params, signal, update, ctx) { const state = await runtime.boot(ctx.cwd); return createEditToolDefinition(ctx.cwd, { operations: fileOps(state.backend, ctx.cwd) }).execute(id, params, signal, update, ctx); } });
+}
+function fileOps(backend, cwd) {
+    const readFile = async (path) => { const target = workspacePath(backend, cwd, path); const response = await backend.run(["sh", "-lc", `base64 < ${shell(target)}`]); if (response.exitCode)
+        throw new Error(response.stderr || "Cannot read file"); return Buffer.from(response.stdout.replace(/\s/g, ""), "base64"); };
+    const writeFile = async (path, content) => { const target = workspacePath(backend, cwd, path); const response = await backend.run(["sh", "-lc", `base64 -d > ${shell(target)}`], { input: Buffer.from(content).toString("base64") }); if (response.exitCode)
+        throw new Error(response.stderr || "Cannot write file"); };
+    return { readFile, writeFile, access: async (path) => { const response = await backend.run(["sh", "-lc", `test -r ${shell(workspacePath(backend, cwd, path))}`]); if (response.exitCode)
+            throw new Error("Path is inaccessible"); }, mkdir: async (path) => { const response = await backend.run(["mkdir", "-p", workspacePath(backend, cwd, path)]); if (response.exitCode)
+            throw new Error(response.stderr || "Cannot create directory"); } };
+}
+export function workspacePath(backend, cwd, candidate) { const full = resolve(cwd, candidate); const value = relative(resolve(cwd), full); if (value === ".." || value.startsWith("../"))
+    throw new Error(`Path escapes workspace: ${candidate}`); return backend.path(value); }

package/dist/magento/deploy-mode.d.ts

@@ -0,0 +1,2 @@
+import type { MagentoDeployMode } from "#magento/model";
+export declare function parseDeployMode(output: string, exitCode: number): MagentoDeployMode | undefined;

package/dist/magento/deploy-mode.js

@@ -0,0 +1,10 @@
+export function parseDeployMode(output, exitCode) {
+    if (exitCode !== 0)
+        return undefined;
+    const mode = output
+        .match(/\b(developer|production|default)\b/i)?.[1]
+        ?.toLowerCase();
+    return mode === "developer" || mode === "production" || mode === "default"
+        ? mode
+        : undefined;
+}

package/dist/magento/index.d.ts

@@ -0,0 +1,5 @@
+export { parseDeployMode } from "#magento/deploy-mode";
+export { DefaultMagentoInspector, type MagentoInspector, } from "#magento/inspector";
+export type { MagentoDeployMode, MagentoSnapshot, MagentoTheme, RawTheme, } from "#magento/model";
+export { snapshotPrompt } from "#magento/prompt";
+export { parseRegisteredThemes, resolveThemes } from "#magento/themes";

package/dist/magento/index.js

@@ -0,0 +1,4 @@
+export { parseDeployMode } from "#magento/deploy-mode";
+export { DefaultMagentoInspector, } from "#magento/inspector";
+export { snapshotPrompt } from "#magento/prompt";
+export { parseRegisteredThemes, resolveThemes } from "#magento/themes";

package/dist/magento/inspector.d.ts

@@ -0,0 +1,9 @@
+import type { CommandExecutor } from "#environments/executor";
+import type { MagentoSnapshot } from "#magento/model";
+export interface MagentoInspector {
+    inspect(executor: CommandExecutor): Promise<MagentoSnapshot>;
+}
+/** Ordered, fail-soft Magento inspection. New probes can be extracted without changing consumers. */
+export declare class DefaultMagentoInspector implements MagentoInspector {
+    inspect(executor: CommandExecutor): Promise<MagentoSnapshot>;
+}