@merchantduo/code 0.2.0-beta.4 → 0.2.0-beta.5

package/dist/app/native-operations.d.ts

@@ -0,0 +1,19 @@
+import type { CommandResult, CommandSpec } from "#environments/executor";
+export type NativeLogContext = {
+    project: string;
+    session: string;
+    environment: string;
+};
+/** Append-only, fail-soft evidence for automatic native probes only. */
+export declare class NativeProbeLog {
+    #private;
+    readonly path: string;
+    constructor(path?: string);
+    get warning(): string | undefined;
+    start(context: NativeLogContext): Promise<void>;
+    record(spec: CommandSpec, result: CommandResult): Promise<void>;
+}
+export declare function runNativeProbe(log: NativeProbeLog, executor: {
+    command(argv: string[], target?: string): CommandSpec;
+    run(argv: string[], options?: Parameters<import("#environments/executor").CommandExecutor["run"]>[1]): Promise<CommandResult>;
+}, argv: string[], options?: Parameters<import("#environments/executor").CommandExecutor["run"]>[1]): Promise<CommandResult>;

package/dist/app/native-operations.js

@@ -0,0 +1,50 @@
+import { appendFile, chmod, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const MAX_STREAM = 8_000;
+/** Append-only, fail-soft evidence for automatic native probes only. */
+export class NativeProbeLog {
+    path;
+    #started = false;
+    #warning;
+    constructor(path = join(homedir(), ".merchantduo", "native-operations.log")) {
+        this.path = path;
+    }
+    get warning() { return this.#warning; }
+    async start(context) {
+        if (this.#started)
+            return;
+        this.#started = true;
+        await this.#append(`\n=== MerchantDuo native session ${new Date().toISOString()} ===\nsession: ${redact(context.session)}\nproject: ${redact(context.project)}\nenvironment: ${redact(context.environment)}\n`);
+    }
+    async record(spec, result) {
+        const stdout = stream(result.stdout);
+        const stderr = stream(result.stderr);
+        await this.#append(`\n[${new Date().toISOString()}]\ncommand: ${redact([spec.file, ...spec.args].join(" "))}\nexit_code: ${result.exitCode}\nstdout:\n${stdout.value}${result.truncated || stdout.truncated ? "\n[stdout truncated]" : ""}\nstderr:\n${stderr.value}${result.truncated || stderr.truncated ? "\n[stderr truncated]" : ""}\n`);
+    }
+    async #append(record) {
+        try {
+            const directory = dirname(this.path);
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            await chmod(directory, 0o700);
+            await appendFile(this.path, record, { encoding: "utf8", mode: 0o600 });
+            await chmod(this.path, 0o600);
+        }
+        catch {
+            this.#warning = "Native operation logging is unavailable.";
+        }
+    }
+}
+export async function runNativeProbe(log, executor, argv, options) {
+    const spec = executor.command(argv, options?.target);
+    const result = await executor.run(argv, options);
+    await log.record(spec, result);
+    return result;
+}
+function stream(value) {
+    const redacted = redact(value);
+    return { value: redacted.slice(0, MAX_STREAM), truncated: redacted.length > MAX_STREAM };
+}
+function redact(value) {
+    return value.replace(/((?:password|passwd|secret|token|api[_-]?key)\s*(?:=|:|=>)\s*["']?)[^\s"']+/gi, "$1[redacted]");
+}

package/dist/app/runtime.d.ts

@@ -7,6 +7,7 @@ import { type MagentoInspector, type MagentoSnapshot } from "#magento/index";
 import { ChangeTracker } from "#workflows/change-tracker";
 import type { TestingSnapshot } from "#testing/model";
 import type { Magerun2Capability } from "#features/magerun2/index";
+import { NativeProbeLog } from "#app/native-operations";
 export type SessionState = {
     config: MerchantConfig;
     configPath?: string;
@@ -15,6 +16,7 @@ export type SessionState = {
         environment: Environment;
     };
     backend: EnvironmentBackend;
+    nativeLog: NativeProbeLog;
     environmentStatus: EnvironmentStatus;
     permissionMode: PermissionMode;
     magento: MagentoSnapshot;

package/dist/app/runtime.js

@@ -3,6 +3,8 @@ import { EnvironmentBackend } from "#environments/backend";
 import { resolvePermissionMode } from "#app/permission-mode";
 import { DefaultMagentoInspector, } from "#magento/index";
 import { ChangeTracker } from "#workflows/change-tracker";
+import { NativeProbeLog } from "#app/native-operations";
+import { wardenRunning } from "#environments/backend";
 export class MerchantDuoRuntime {
     inspector;
     #state;
@@ -20,14 +22,17 @@ export class MerchantDuoRuntime {
         });
         const selected = selectEnvironment(loaded.config, cwd, process.env.MERCHANTDUO_SELECTED_ENV);
         const backend = new EnvironmentBackend(selected.environment, cwd);
-        const environmentStatus = await backend.status();
+        const nativeLog = new NativeProbeLog();
+        await nativeLog.start({ project: cwd, session: `${process.pid}`, environment: selected.name });
+        const environmentStatus = await nativeStatus(backend, nativeLog);
         this.#state = {
             ...loaded,
             selected,
             backend,
+            nativeLog,
             environmentStatus,
             permissionMode: resolvePermissionMode(selected.environment, process.env.MERCHANTDUO_PERMISSION_MODE),
-            magento: environmentStatus === "running" ? await this.inspector.inspect(backend) : stoppedMagentoSnapshot(),
+            magento: environmentStatus === "running" ? await this.inspector.inspect(backend, (argv, result) => nativeLog.record(backend.command(argv), result)) : stoppedMagentoSnapshot(),
         };
         return this.#state;
     }
@@ -102,3 +107,15 @@ export class MerchantDuoRuntime {
 function stoppedMagentoSnapshot() {
     return { cacheTypes: [], warnings: ["Environment is stopped"], evidence: [], themes: [] };
 }
+async function nativeStatus(backend, log) {
+    if (backend.environment.type === "ssh")
+        return "running";
+    if (backend.environment.type === "local")
+        return "unknown";
+    const spec = backend.lifecycleCommand("status");
+    if (!spec)
+        return "stopped";
+    const result = await backend.runCommand(spec);
+    await log.record(spec, result);
+    return result.exitCode === 0 && wardenRunning(result.stdout) ? "running" : "stopped";
+}

package/dist/environments/backend.d.ts

@@ -11,8 +11,10 @@ export declare class EnvironmentBackend implements CommandExecutor {
     path(path: string): string;
     command(argv: string[], target?: string): CommandSpec;
     run(argv: string[], options?: RunOptions): Promise<CommandResult>;
+    /** Execute a pre-routed adapter command, used by automatic lifecycle probing. */
+    runCommand(spec: CommandSpec, options?: RunOptions): Promise<CommandResult>;
     lifecycleCommand(action: "status" | "start" | "stop"): CommandSpec | undefined;
-    status(): Promise<EnvironmentStatus>;
+    status(onCommand?: (spec: CommandSpec, result: CommandResult) => void): Promise<EnvironmentStatus>;
     start(): Promise<CommandResult | undefined>;
     stop(): Promise<CommandResult | undefined>;
 }

package/dist/environments/backend.js

@@ -22,12 +22,16 @@ export class EnvironmentBackend {
     }
     async run(argv, options = {}) {
         const spec = this.command(argv, options.target);
+        return this.runCommand(spec, options);
+    }
+    /** Execute a pre-routed adapter command, used by automatic lifecycle probing. */
+    runCommand(spec, options = {}) {
         return this.#runSpec(spec, options);
     }
     lifecycleCommand(action) {
         return this.#adapter.lifecycleCommand?.(action);
     }
-    async status() {
+    async status(onCommand) {
         if (this.environment.type === "ssh")
             return "running";
         if (this.environment.type === "local")
@@ -36,6 +40,7 @@ export class EnvironmentBackend {
         if (!spec)
             return "stopped";
         const output = await this.#runSpec(spec);
+        onCommand?.(spec, output);
         return output.exitCode === 0 && wardenRunning(output.stdout) ? "running" : "stopped";
     }
     async start() {

package/dist/features/magerun2/service.d.ts

@@ -1,9 +1,10 @@
 import type { EnvironmentBackend } from "#environments/backend";
+import type { CommandExecutor, CommandResult } from "#environments/executor";
 import type { Environment } from "#environments/model";
 import { type HostProcessRunner } from "#testing/host";
 import type { Magerun2Capability, Magerun2Result } from "#features/magerun2/model";
 /** Resolve magerun once for the selected Magento environment without altering the project. */
-export declare function discoverMagerun2(environment: Environment, backend: EnvironmentBackend, cwd: string): Promise<Magerun2Capability>;
+export declare function discoverMagerun2(environment: Environment, backend: CommandExecutor, cwd: string, record?: (argv: string[], result: CommandResult) => Promise<void>): Promise<Magerun2Capability>;
 /** Run a structured argument vector. Local commands are host processes; Warden and SSH use their selected backend. */
 export declare function runMagerun2(capability: Magerun2Capability, environment: Environment, backend: EnvironmentBackend, cwd: string, args: string[], stdin?: string, signal?: AbortSignal, host?: HostProcessRunner): Promise<Magerun2Result>;
 /** Stable display only: this is never passed to a shell. */

package/dist/features/magerun2/service.js

@@ -6,14 +6,16 @@ import { NodeHostProcessRunner } from "#testing/host";
 const RELEASE_URL = "https://api.github.com/repos/netz98/n98-magerun2/releases/latest";
 const MAX_OUTPUT = 64 * 1024;
 /** Resolve magerun once for the selected Magento environment without altering the project. */
-export async function discoverMagerun2(environment, backend, cwd) {
+export async function discoverMagerun2(environment, backend, cwd, record) {
     if (environment.type === "warden")
         return { available: true, executable: "/usr/local/bin/mr" };
     const candidates = environment.type === "local"
         ? ["vendor/bin/n98-magerun2", "bin/n98-magerun2", "n98-magerun2", "magerun2"]
         : ["n98-magerun2", "magerun2"];
     for (const candidate of candidates) {
-        const result = await backend.run(["sh", "-lc", `command -v -- ${candidate} 2>/dev/null || { test -x ${candidate} && printf '%s' ${candidate}; }`]);
+        const argv = ["sh", "-lc", `command -v -- ${candidate} 2>/dev/null || { test -x ${candidate} && printf '%s' ${candidate}; }`];
+        const result = await backend.run(argv);
+        await record?.(argv, result);
         const executable = result.stdout.trim();
         if (executable)
             return { available: true, executable };

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

@@ -1,2 +1,4 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runtime } from "#integrations/pi/session";
 export default function context(pi: ExtensionAPI): void;
+export declare function statusMessage(state: Awaited<ReturnType<typeof runtime.boot>>): string;

package/dist/integrations/pi/context.js

@@ -2,7 +2,7 @@ import { refreshStatus } from "#app/status";
 import { merchantDuoSystemPrompt } from "#app/system-prompt";
 import { discoverTesting } from "#testing/index";
 import { discoverMagerun2 } from "#features/magerun2/index";
-import { discoverHostExecutable } from "#testing/host";
+import { discoverHostExecutable, NodeHostProcessRunner } from "#testing/host";
 import { runtime, sessionEvents } from "#integrations/pi/session";
 export default function context(pi) {
     pi.on("session_start", async (_event, ctx) => {
@@ -14,23 +14,34 @@ export default function context(pi) {
             pi.appendEntry("merchantduo.context", { environment: state.selected.name, environmentStatus: state.environmentStatus, permissionMode: state.permissionMode });
             return;
         }
-        const magerun2 = await discoverMagerun2(state.selected.environment, state.backend, ctx.cwd);
+        const record = (argv, result) => state.nativeLog.record(state.backend.command(argv), result);
+        const magerun2 = await discoverMagerun2(state.selected.environment, state.backend, ctx.cwd, record);
         // 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 hostRunner = new NodeHostProcessRunner();
+        const nativeHost = { run: async (file, args, options) => {
+                const result = await hostRunner.run(file, args, options);
+                await state.nativeLog.record({ file, args, cwd: options.cwd }, { stdout: result.output, stderr: "", exitCode: result.code, truncated: result.truncated ?? false });
+                return result;
+            } };
         const [http, browser] = await Promise.all([
-            discoverHostExecutable(["curl"]),
-            discoverHostExecutable(["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]),
+            discoverHostExecutable(["curl"], nativeHost),
+            discoverHostExecutable(["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"], nativeHost),
         ]);
         runtime.setMagerun2(magerun2);
-        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 }));
+        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 }, record));
         refreshStatus(ctx, state);
         sessionEvents.emit("merchantduo.context", state);
         pi.appendEntry("merchantduo.context", { environment: state.selected.name, environmentStatus: state.environmentStatus, permissionMode: state.permissionMode, testing: state.testing, magerun2: state.magerun2 });
     });
     pi.on("session_compact", () => runtime.resetInjection());
     pi.on("session_shutdown", () => sessionEvents.clear());
+    pi.registerCommand("duo-status", { description: "Show the current MerchantDuo session status.", handler: async (_args, ctx) => {
+            const state = await runtime.boot(ctx.cwd);
+            pi.sendMessage({ customType: "merchantduo.status", content: statusMessage(state), display: true, details: {} });
+        } });
     pi.on("tool_call", (event) => {
         if (event.toolName !== "write" && event.toolName !== "edit")
             return;
@@ -50,3 +61,21 @@ export default function context(pi) {
         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."}` };
     });
 }
+export function statusMessage(state) {
+    const lines = [
+        `Environment: ${state.selected.name} (${state.environmentStatus})`,
+        `Permission mode: ${state.permissionMode}`,
+        `Magento: ${state.magento.edition ?? "unknown"} ${state.magento.version ?? "version unavailable"}`,
+        `PHP: ${state.magento.phpVersion ?? "unavailable"}`,
+        `Deploy mode: ${state.magento.mode ?? "unavailable"}`,
+        `Active theme: ${state.config.activeTheme}`,
+        `Frontend URL: ${state.testing?.frontendUrl ?? "unavailable"}`,
+        `Admin URL: ${state.testing?.adminUrl ?? "unavailable"}`,
+        `Capabilities: HTTP ${state.testing?.http.available ? "available" : "unavailable"}; browser ${state.testing?.browser.available ? "available" : "unavailable"}; magerun2 ${state.magerun2?.available ? "available" : "unavailable"}`,
+        ...state.magento.warnings.map((warning) => `Warning: ${warning}`),
+        ...(state.testing?.diagnostics.map((warning) => `Warning: ${warning}`) ?? []),
+        ...(state.magerun2?.diagnostic ? [`Warning: ${state.magerun2.diagnostic}`] : []),
+        ...(state.nativeLog.warning ? [`Warning: ${state.nativeLog.warning}`] : []),
+    ];
+    return lines.join("\n");
+}

package/dist/magento/inspector.d.ts

@@ -1,9 +1,9 @@
-import type { CommandExecutor } from "#environments/executor";
+import type { CommandExecutor, CommandResult } from "#environments/executor";
 import type { MagentoSnapshot } from "#magento/model";
 export interface MagentoInspector {
-    inspect(executor: CommandExecutor): Promise<MagentoSnapshot>;
+    inspect(executor: CommandExecutor, record?: (argv: string[], result: CommandResult) => Promise<void>): 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>;
+    inspect(executor: CommandExecutor, record?: (argv: string[], result: CommandResult) => Promise<void>): Promise<MagentoSnapshot>;
 }

package/dist/magento/inspector.js

@@ -2,13 +2,18 @@ import { parseDeployMode } from "#magento/deploy-mode";
 import { parseRegisteredThemes, resolveThemes } from "#magento/themes";
 /** Ordered, fail-soft Magento inspection. New probes can be extracted without changing consumers. */
 export class DefaultMagentoInspector {
-    async inspect(executor) {
+    async inspect(executor, record) {
         const warnings = [];
         const evidence = [];
-        const composer = await executor.run([
+        const run = async (argv) => {
+            const result = await executor.run(argv);
+            await record?.(argv, result);
+            return result;
+        };
+        const composer = await run([
             "sh",
             "-lc",
-            "test -f composer.lock && node -e \"const x=require('./composer.lock'); console.log(JSON.stringify(x.packages||[]))\" || true",
+            `test -f composer.lock && php -r '$x=json_decode(file_get_contents("composer.lock"), true, flags: JSON_THROW_ON_ERROR); echo json_encode($x["packages"] ?? []);'`,
         ]);
         const match = composer.stdout.match(/magento\/(product-community-edition|product-enterprise-edition).*?"version":"([^"]+)/s);
         const edition = match?.[1] === "product-enterprise-edition"
@@ -19,20 +24,21 @@ export class DefaultMagentoInspector {
         const composerVersion = match?.[2];
         if (composerVersion)
             evidence.push("composer.lock");
-        const cli = await executor.run(["bin/magento", "--version"]);
+        const cli = await run(["bin/magento", "--version"]);
         const cliVersion = cli.stdout.match(/(?:Magento|Adobe Commerce)[^0-9]*(\d+\.\d+\.\d+(?:-[^\s]+)?)/)?.[1];
         if (cliVersion)
             evidence.push("bin/magento --version");
+        if (!composerVersion && !cliVersion)
+            warnings.push("Magento version unavailable");
         if (composerVersion &&
             cliVersion &&
             !cliVersion.startsWith(composerVersion))
             warnings.push(`Composer (${composerVersion}) and CLI (${cliVersion}) disagree`);
-        const [php, mode, cache, modules, registeredThemes] = await Promise.all([
-            executor.run(["php", "-r", "echo PHP_VERSION;"]),
-            executor.run(["bin/magento", "deploy:mode:show"]),
-            executor.run(["bin/magento", "cache:status", "--no-ansi"]),
-            executor.run(["bin/magento", "module:status", "--enabled", "--no-ansi"]),
-            executor.run(["sh", "-lc", themeDiscoveryScript]),
+        const [php, mode, cache, registeredThemes] = await Promise.all([
+            run(["php", "-r", "echo PHP_VERSION;"]),
+            run(["bin/magento", "deploy:mode:show"]),
+            run(["bin/magento", "cache:status", "--no-ansi"]),
+            run(["sh", "-lc", themeDiscoveryScript]),
         ]);
         return {
             version: composerVersion ?? cliVersion,
@@ -43,7 +49,6 @@ export class DefaultMagentoInspector {
                 .split("\n")
                 .map((line) => line.match(/^([^:]+):/)?.[1])
                 .filter((value) => Boolean(value)),
-            modulesEnabled: modules.stdout.split("\n").filter(Boolean).length || undefined,
             warnings,
             evidence,
             themes: resolveThemes(parseRegisteredThemes(registeredThemes.stdout)),

package/dist/magento/model.d.ts

@@ -18,7 +18,6 @@ export type MagentoSnapshot = {
     phpVersion?: string;
     mode?: MagentoDeployMode;
     cacheTypes: string[];
-    modulesEnabled?: number;
     warnings: string[];
     evidence: string[];
     themes: MagentoTheme[];

package/dist/testing/discovery.d.ts

@@ -1,9 +1,9 @@
-import type { EnvironmentBackend } from "#environments/backend";
+import type { CommandExecutor, CommandResult } from "#environments/executor";
 import type { Environment } from "#environments/model";
 import type { TestingOptions, TestingSnapshot } from "#testing/model";
-export declare function discoverTesting(environment: Environment, backend: EnvironmentBackend, cwd: string, options: TestingOptions, tools?: {
+export declare function discoverTesting(environment: Environment, backend: CommandExecutor, cwd: string, options: TestingOptions, tools?: {
     http?: string;
     browser?: string;
-}): Promise<TestingSnapshot>;
+}, record?: (argv: string[], result: CommandResult) => Promise<void>): Promise<TestingSnapshot>;
 export declare function wardenRouting(projectRoot: string): Promise<string | undefined>;
 export declare function findExecutable(candidates: string[]): Promise<string | undefined>;

package/dist/testing/discovery.js

@@ -1,7 +1,7 @@
 import { access, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { canonicalUrl, joinedUrl } from "#testing/url";
-export async function discoverTesting(environment, backend, cwd, options, tools = {}) {
+export async function discoverTesting(environment, backend, cwd, options, tools = {}, record) {
     const diagnostics = [];
     let frontendUrl = canonicalUrl(options.frontendUrl ?? "");
     let adminUrl = canonicalUrl(options.adminUrl ?? "");
@@ -17,15 +17,21 @@ export async function discoverTesting(environment, backend, cwd, options, tools
             diagnostics.push("Warden routing was not found in .env.");
     }
     if (!frontendUrl && environment.type !== "warden") {
-        const result = await backend.run(["bin/magento", "config:show", "web/secure/base_url"]);
+        const secure = ["bin/magento", "config:show", "web/secure/base_url"];
+        const result = await backend.run(secure);
+        await record?.(secure, result);
         frontendUrl = canonicalUrl(result.stdout.trim());
         if (!frontendUrl) {
-            const fallback = await backend.run(["bin/magento", "config:show", "web/unsecure/base_url"]);
+            const unsecure = ["bin/magento", "config:show", "web/unsecure/base_url"];
+            const fallback = await backend.run(unsecure);
+            await record?.(unsecure, fallback);
             frontendUrl = canonicalUrl(fallback.stdout.trim());
         }
     }
     if (!adminUrl) {
-        const result = await backend.run(["bin/magento", "info:adminuri"]);
+        const argv = ["bin/magento", "info:adminuri"];
+        const result = await backend.run(argv);
+        await record?.(argv, result);
         const path = result.stdout.trim().split(/\s+/).pop();
         adminUrl = joinedUrl(frontendUrl, path?.startsWith("/") ? path : `/${path ?? ""}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merchantduo/code",
-  "version": "0.2.0-beta.4",
+  "version": "0.2.0-beta.5",
   "private": false,
   "description": "Magento-native Pi-based Coding Agent",
   "type": "module",