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

package/dist/cli/commands/init.js

@@ -0,0 +1,68 @@
+import { access, readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { stringify } from "yaml";
+export class TerminalInitInterview {
+    async confirm(question) {
+        const terminal = createInterface({ input: stdin, output: stdout });
+        try {
+            const answer = (await terminal.question(`${question} [Y/n] `)).trim().toLowerCase();
+            return answer === "" || answer === "y" || answer === "yes";
+        }
+        finally {
+            terminal.close();
+        }
+    }
+}
+export async function hasWardenEnvironment(cwd) {
+    try {
+        const source = await readFile(resolve(cwd, ".env"), "utf8");
+        return /^\s*(?:WARDEN_ENV_NAME|TRAEFIK_DOMAIN|TRAEFIK_SUBDOMAIN)\s*=/m.test(source);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+export async function initProject(cwd, interview = new TerminalInitInterview(), output = console.log) {
+    const path = resolve(cwd, ".merchantduo.yaml");
+    try {
+        await access(path);
+        throw new Error(`${path} already exists`);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const environments = {};
+    if (await interview.confirm("Add the local Magento checkout environment?")) {
+        environments.local = { type: "local", root: "." };
+    }
+    const wardenDetected = await hasWardenEnvironment(cwd);
+    if (wardenDetected &&
+        (await interview.confirm("Warden project .env detected. Add the Warden environment?"))) {
+        environments.warden = {
+            type: "warden",
+            projectRoot: ".",
+            root: "/var/www/html",
+            filesService: "php-fpm",
+            targets: { default: "php-fpm", debug: "php-debug" },
+        };
+    }
+    const selected = Object.keys(environments);
+    if (!selected.length) {
+        throw new Error("No environment selected; .merchantduo.yaml was not created");
+    }
+    const config = {
+        defaultEnvironment: selected[0],
+        activeTheme: "all",
+        testing: { allowInsecureTls: true },
+        environments,
+    };
+    await writeFile(path, stringify(config), { mode: 0o600 });
+    output(`Created ${path}`);
+    output(remoteEnvironmentExample);
+}
+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    writable: false\n\nConfigure 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

@@ -0,0 +1,6 @@
+export declare function provision(cwd: string, options: {
+    environment?: string;
+    source?: string;
+    database?: string;
+    yes: boolean;
+}): Promise<void>;

package/dist/cli/commands/provision.js

@@ -0,0 +1,35 @@
+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;
+    }
+    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.");
+}

package/dist/cli/main.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { loadConfig, selectEnvironment } from "#config/index";
+import { isTrusted, trustProject } from "#config/trust-store";
+import { parseArguments } from "#cli/arguments";
+import { launchAgent } from "#cli/commands/agent";
+import { doctor } from "#cli/commands/doctor";
+import { initProject } from "#cli/commands/init";
+import { provision } from "#cli/commands/provision";
+async function main() {
+    const cwd = process.cwd();
+    const args = parseArguments(process.argv.slice(2));
+    if (args.command === "init")
+        return initProject(cwd);
+    if (args.command === "provision")
+        return provision(cwd, args);
+    const loaded = await loadConfig(cwd, { config: args.configPath });
+    const selected = selectEnvironment(loaded.config, cwd, args.environment);
+    if (loaded.configPath && !(await isTrusted(loaded.configPath))) {
+        if (process.env.MERCHANTDUO_TRUST_CONFIG === "1")
+            await trustProject(loaded.configPath);
+        else
+            throw new Error(`Untrusted MerchantDuo configuration: ${loaded.configPath}. Review it and run with MERCHANTDUO_TRUST_CONFIG=1 once.`);
+    }
+    if (args.command === "doctor")
+        return doctor(cwd, selected.name, selected.environment, loaded.config);
+    process.exitCode = await launchAgent(args.piArguments, selected.name, loaded.configPath);
+}
+main().catch((error) => {
+    console.error(`merchantduo: ${error.message}`);
+    process.exitCode = 1;
+});

package/dist/config/index.d.ts

@@ -0,0 +1,11 @@
+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 { setProjectTheme } from "#config/project-store";
+export { ConfigSchema, type MerchantConfig, } 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;
+    environment: Environment;
+};

package/dist/config/index.js

@@ -0,0 +1,15 @@
+export { loadConfig, interpolate } from "#config/loader";
+export { merchantHome } from "#config/paths";
+export { setProjectTheme } from "#config/project-store";
+export { ConfigSchema, } 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;
+    if (name) {
+        const environment = config.environments[name];
+        if (!environment)
+            throw new Error(`Unknown MerchantDuo environment: ${name}`);
+        return { name, environment };
+    }
+    return { name: "local", environment: { type: "local", root: cwd } };
+}

package/dist/config/loader.d.ts

@@ -0,0 +1,10 @@
+import { type MerchantConfig } from "#config/schema";
+export type LoadedConfig = {
+    config: MerchantConfig;
+    configPath?: string;
+};
+export declare function interpolate(value: string, env?: NodeJS.ProcessEnv): string;
+export declare function loadConfig(cwd: string, options?: {
+    config?: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<LoadedConfig>;

package/dist/config/loader.js

@@ -0,0 +1,61 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { parse } from "yaml";
+import { ConfigSchema } from "#config/schema";
+import { merchantHome } from "#config/paths";
+export function interpolate(value, env = process.env) {
+    return value.replace(/\$\{([A-Z][A-Z0-9_]*)\}/g, (_, name) => {
+        if (!env[name])
+            throw new Error(`Missing required environment variable: ${name}`);
+        return env[name];
+    });
+}
+function expand(value, env) {
+    if (typeof value === "string")
+        return interpolate(value, env);
+    if (Array.isArray(value))
+        return value.map((item) => expand(item, env));
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, expand(item, env)]));
+    return value;
+}
+async function readYaml(path) {
+    try {
+        const value = parse(await readFile(path, "utf8"));
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("expected a YAML object");
+        return value;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw new Error(`Cannot load ${path}: ${error.message}`);
+    }
+}
+export async function loadConfig(cwd, options = {}) {
+    const env = options.env ?? process.env;
+    const globalPath = resolve(merchantHome(env), "config.yaml");
+    const projectPath = options.config ??
+        env.MERCHANTDUO_CONFIG ??
+        resolve(cwd, ".merchantduo.yaml");
+    const globalConfig = await readYaml(globalPath);
+    const projectConfig = await readYaml(projectPath);
+    const raw = {
+        ...(globalConfig ?? {}),
+        ...(projectConfig ?? {}),
+        environments: {
+            ...(globalConfig?.environments ?? {}),
+            ...(projectConfig?.environments ?? {}),
+        },
+    };
+    if (!globalConfig && !projectConfig)
+        return {
+            config: ConfigSchema.parse({
+                environments: { local: { type: "local", root: "." } },
+            }),
+        };
+    return {
+        config: ConfigSchema.parse(expand(raw, env)),
+        configPath: projectConfig ? resolve(projectPath) : undefined,
+    };
+}

package/dist/config/paths.d.ts

@@ -0,0 +1 @@
+export declare function merchantHome(env?: NodeJS.ProcessEnv): string;

package/dist/config/paths.js

@@ -0,0 +1,7 @@
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+export function merchantHome(env = process.env) {
+    return env.MERCHANTDUO_HOME
+        ? resolve(env.MERCHANTDUO_HOME)
+        : resolve(homedir(), ".merchantduo");
+}

package/dist/config/project-store.d.ts

@@ -0,0 +1,2 @@
+/** Patch project-owned values without rewriting merged global configuration. */
+export declare function setProjectTheme(configPath: string, activeTheme: string): Promise<void>;

package/dist/config/project-store.js

@@ -0,0 +1,12 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { parse, stringify } from "yaml";
+/** Patch project-owned values without rewriting merged global configuration. */
+export async function setProjectTheme(configPath, activeTheme) {
+    const source = await readFile(configPath, "utf8");
+    const value = parse(source);
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`Cannot update ${configPath}: expected a YAML object`);
+    await writeFile(configPath, stringify({ ...value, activeTheme }), {
+        mode: 0o600,
+    });
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,210 @@
+import { z } from "zod";
+import type { Environment } from "#environments/model";
+export declare const ConfigSchema: z.ZodObject<{
+    defaultEnvironment: z.ZodOptional<z.ZodString>;
+    activeTheme: z.ZodDefault<z.ZodString>;
+    testing: z.ZodDefault<z.ZodObject<{
+        frontendUrl: z.ZodOptional<z.ZodString>;
+        adminUrl: z.ZodOptional<z.ZodString>;
+        allowInsecureTls: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        allowInsecureTls: boolean;
+        frontendUrl?: string | undefined;
+        adminUrl?: string | undefined;
+    }, {
+        frontendUrl?: string | undefined;
+        adminUrl?: string | undefined;
+        allowInsecureTls?: boolean | undefined;
+    }>>;
+    environments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"local">;
+        root: z.ZodString;
+        testing: z.ZodOptional<z.ZodObject<{
+            frontendUrl: z.ZodOptional<z.ZodString>;
+            adminUrl: z.ZodOptional<z.ZodString>;
+            allowInsecureTls: z.ZodDefault<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            allowInsecureTls: boolean;
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+        }, {
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+            allowInsecureTls?: boolean | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "local";
+        root: string;
+        testing?: {
+            allowInsecureTls: boolean;
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+        } | undefined;
+    }, {
+        type: "local";
+        root: string;
+        testing?: {
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+            allowInsecureTls?: boolean | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"warden">;
+        projectRoot: z.ZodString;
+        root: z.ZodString;
+        filesService: z.ZodDefault<z.ZodString>;
+        targets: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        testing: z.ZodOptional<z.ZodObject<{
+            frontendUrl: z.ZodOptional<z.ZodString>;
+            adminUrl: z.ZodOptional<z.ZodString>;
+            allowInsecureTls: z.ZodDefault<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            allowInsecureTls: boolean;
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+        }, {
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+            allowInsecureTls?: boolean | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "warden";
+        root: string;
+        projectRoot: string;
+        filesService: string;
+        targets: Record<string, string>;
+        testing?: {
+            allowInsecureTls: boolean;
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+        } | undefined;
+    }, {
+        type: "warden";
+        root: string;
+        projectRoot: string;
+        testing?: {
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+            allowInsecureTls?: boolean | undefined;
+        } | undefined;
+        filesService?: string | undefined;
+        targets?: Record<string, string> | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"ssh">;
+        host: z.ZodString;
+        root: z.ZodString;
+        writable: z.ZodDefault<z.ZodBoolean>;
+        testing: z.ZodOptional<z.ZodObject<{
+            frontendUrl: z.ZodOptional<z.ZodString>;
+            adminUrl: z.ZodOptional<z.ZodString>;
+            allowInsecureTls: z.ZodDefault<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            allowInsecureTls: boolean;
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+        }, {
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+            allowInsecureTls?: boolean | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "ssh";
+        root: string;
+        host: string;
+        writable: boolean;
+        testing?: {
+            allowInsecureTls: boolean;
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+        } | undefined;
+    }, {
+        type: "ssh";
+        root: string;
+        host: string;
+        testing?: {
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+            allowInsecureTls?: boolean | undefined;
+        } | undefined;
+        writable?: boolean | undefined;
+    }>]>>>;
+}, "strict", z.ZodTypeAny, {
+    testing: {
+        allowInsecureTls: boolean;
+        frontendUrl?: string | undefined;
+        adminUrl?: string | undefined;
+    };
+    activeTheme: string;
+    environments: Record<string, {
+        type: "local";
+        root: string;
+        testing?: {
+            allowInsecureTls: boolean;
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+        } | undefined;
+    } | {
+        type: "warden";
+        root: string;
+        projectRoot: string;
+        filesService: string;
+        targets: Record<string, string>;
+        testing?: {
+            allowInsecureTls: boolean;
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+        } | undefined;
+    } | {
+        type: "ssh";
+        root: string;
+        host: string;
+        writable: boolean;
+        testing?: {
+            allowInsecureTls: boolean;
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+        } | undefined;
+    }>;
+    defaultEnvironment?: string | undefined;
+}, {
+    testing?: {
+        frontendUrl?: string | undefined;
+        adminUrl?: string | undefined;
+        allowInsecureTls?: boolean | undefined;
+    } | undefined;
+    defaultEnvironment?: string | undefined;
+    activeTheme?: string | undefined;
+    environments?: Record<string, {
+        type: "local";
+        root: string;
+        testing?: {
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+            allowInsecureTls?: boolean | undefined;
+        } | undefined;
+    } | {
+        type: "warden";
+        root: string;
+        projectRoot: string;
+        testing?: {
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+            allowInsecureTls?: boolean | undefined;
+        } | undefined;
+        filesService?: string | undefined;
+        targets?: Record<string, string> | undefined;
+    } | {
+        type: "ssh";
+        root: string;
+        host: string;
+        testing?: {
+            frontendUrl?: string | undefined;
+            adminUrl?: string | undefined;
+            allowInsecureTls?: boolean | undefined;
+        } | undefined;
+        writable?: boolean | undefined;
+    }> | undefined;
+}>;
+export type MerchantConfig = Omit<z.infer<typeof ConfigSchema>, "environments"> & {
+    environments: Record<string, Environment>;
+};

package/dist/config/schema.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+const testing = z
+    .object({
+    frontendUrl: z.string().url().optional(),
+    adminUrl: z.string().url().optional(),
+    allowInsecureTls: z.boolean().default(true),
+})
+    .strict();
+const local = z.object({ type: z.literal("local"), root: z.string(), testing: testing.optional() }).strict();
+const warden = z
+    .object({
+    type: z.literal("warden"),
+    projectRoot: z.string(),
+    root: z.string(),
+    filesService: z.string().default("php-fpm"),
+    targets: z.record(z.string()).default({ default: "php-fpm" }),
+    testing: testing.optional(),
+})
+    .strict();
+const ssh = z
+    .object({
+    type: z.literal("ssh"),
+    host: z.string().min(1),
+    root: z.string(),
+    writable: z.boolean().default(false),
+    testing: testing.optional(),
+})
+    .strict();
+export const ConfigSchema = z
+    .object({
+    defaultEnvironment: z.string().optional(),
+    activeTheme: z.string().default("all"),
+    testing: testing.default({ allowInsecureTls: true }),
+    environments: z.record(z.union([local, warden, ssh])).default({}),
+})
+    .strict();

package/dist/config/trust-store.d.ts

@@ -0,0 +1,3 @@
+export declare function configDigest(content: string): string;
+export declare function trustProject(configPath: string, env?: NodeJS.ProcessEnv): Promise<void>;
+export declare function isTrusted(configPath: string, env?: NodeJS.ProcessEnv): Promise<boolean>;

package/dist/config/trust-store.js

@@ -0,0 +1,29 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { merchantHome } from "#config/paths";
+export function configDigest(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+export async function trustProject(configPath, env = process.env) {
+    const digest = configDigest(await readFile(configPath, "utf8"));
+    const path = resolve(merchantHome(env), "trust.json");
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    let trust = {};
+    try {
+        trust = JSON.parse(await readFile(path, "utf8"));
+    }
+    catch { }
+    trust[resolve(configPath)] = digest;
+    await writeFile(path, JSON.stringify(trust, null, 2), { mode: 0o600 });
+}
+export async function isTrusted(configPath, env = process.env) {
+    try {
+        const trust = JSON.parse(await readFile(resolve(merchantHome(env), "trust.json"), "utf8"));
+        return (trust[resolve(configPath)] ===
+            configDigest(await readFile(configPath, "utf8")));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/environments/adapter.d.ts

@@ -0,0 +1,5 @@
+import type { CommandSpec } from "#environments/executor";
+export interface EnvironmentAdapter {
+    path(path: string): string;
+    command(argv: string[], target?: string): CommandSpec;
+}

package/dist/environments/adapters/local.d.ts

@@ -0,0 +1,12 @@
+import type { EnvironmentAdapter } from "#environments/adapter";
+import type { LocalEnvironment } from "#environments/model";
+export declare class LocalAdapter implements EnvironmentAdapter {
+    #private;
+    constructor(environment: LocalEnvironment, cwd: string);
+    path(path: string): string;
+    command(argv: string[]): {
+        file: string;
+        args: string[];
+        cwd: string;
+    };
+}

package/dist/environments/adapters/local.js

@@ -0,0 +1,14 @@
+import { resolve } from "node:path";
+import { contain } from "#environments/path-policy";
+export class LocalAdapter {
+    #root;
+    constructor(environment, cwd) {
+        this.#root = resolve(cwd, environment.root);
+    }
+    path(path) {
+        return contain(this.#root, path);
+    }
+    command(argv) {
+        return { file: argv[0], args: argv.slice(1), cwd: this.#root };
+    }
+}

package/dist/environments/adapters/ssh.d.ts

@@ -0,0 +1,11 @@
+import type { EnvironmentAdapter } from "#environments/adapter";
+import type { SshEnvironment } from "#environments/model";
+export declare class SshAdapter implements EnvironmentAdapter {
+    readonly environment: SshEnvironment;
+    constructor(environment: SshEnvironment);
+    path(path: string): string;
+    command(argv: string[]): {
+        file: string;
+        args: string[];
+    };
+}

package/dist/environments/adapters/ssh.js

@@ -0,0 +1,24 @@
+import { contain } from "#environments/path-policy";
+export class SshAdapter {
+    environment;
+    constructor(environment) {
+        this.environment = environment;
+    }
+    path(path) {
+        return path.startsWith("/")
+            ? contain(this.environment.root, path)
+            : `${this.environment.root}/${path}`;
+    }
+    command(argv) {
+        return {
+            file: "ssh",
+            args: [
+                this.environment.host,
+                `cd ${shell(this.environment.root)} && ${argv.map(shell).join(" ")}`,
+            ],
+        };
+    }
+}
+function shell(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}

package/dist/environments/adapters/warden.d.ts

@@ -0,0 +1,13 @@
+import type { EnvironmentAdapter } from "#environments/adapter";
+import type { WardenEnvironment } from "#environments/model";
+export declare class WardenAdapter implements EnvironmentAdapter {
+    readonly environment: WardenEnvironment;
+    readonly cwd: string;
+    constructor(environment: WardenEnvironment, cwd: string);
+    path(path: string): string;
+    command(argv: string[], target?: string): {
+        file: string;
+        args: string[];
+        cwd: string;
+    };
+}