@webpresso/agent-kit 0.21.5 → 0.24.0

package/dist/esm/cli/commands/init/scaffolders/agent-kit-global/index.js

@@ -0,0 +1,64 @@
+/**
+ * `agent-kit-global` self-update scaffolder.
+ *
+ * Keeps the ONE globally-distributed `@webpresso/agent-kit` binary fresh on
+ * every `wp setup`, mirroring how omx / omc / codex / claude self-update their
+ * own global installs. The PATH `wp`, the Claude plugin MCP, and the agent
+ * hooks all resolve to this single global binary, so refreshing it here means
+ * the next invocation everywhere runs the latest published release.
+ *
+ * Uses the exact same command the auto-update installer infers
+ * (`buildVpGlobalInstallCommand` — single source of truth), so there is no
+ * second place that can drift on the install incantation.
+ *
+ * Skipped (no-op, non-fatal) when:
+ *   - `--dry-run` (no writes anywhere),
+ *   - `WP_SKIP_AUTO_INSTALL=1` (the documented opt-out, surfaced in the update
+ *     banner),
+ *   - the running binary resolves into a webpresso source/git clone — a global
+ *     install would clobber the developer's working clone with a published
+ *     tarball (`detectGitInstall`),
+ *   - `vp` is not on PATH (nothing to install with).
+ *
+ * A failed refresh is reported but NEVER fails consumer setup: keeping the
+ * global tool current is ancillary to scaffolding the consumer repo (same
+ * warn-only contract as the codex-cli scaffolder).
+ */
+import { spawnSync } from 'node:child_process';
+import { makeNoopSpinnerFactory } from '#cli/commands/init/scaffolders/spinner';
+import { buildVpGlobalInstallCommand, detectGitInstall, PUBLIC_PACKAGE_NAME, } from '#cli/auto-update/detect-pm.js';
+const NO_VP_HINT = 'vp (vite-plus) is not on PATH; cannot refresh the global ' +
+    `${PUBLIC_PACKAGE_NAME}. Install vite-plus, then re-run \`wp setup\`.`;
+/**
+ * Refresh the single global `@webpresso/agent-kit` install via `vp install -g`.
+ */
+export function ensureAgentKitGlobal(input) {
+    if (input.options.dryRun)
+        return { kind: 'agent-kit-global-skipped-dry-run' };
+    const env = input.env ?? process.env;
+    if (env.WP_SKIP_AUTO_INSTALL === '1') {
+        return { kind: 'agent-kit-global-skipped-opt-out' };
+    }
+    const argv1 = input.argv1 ?? process.argv[1] ?? '';
+    const detectGit = input.detectGit ?? detectGitInstall;
+    const sourceCloneRoot = argv1.length > 0 ? detectGit(argv1) : null;
+    if (sourceCloneRoot !== null) {
+        return { kind: 'agent-kit-global-skipped-source-clone', repoRoot: sourceCloneRoot };
+    }
+    const spawn = input.spawn ?? spawnSync;
+    const spinner = (input.spinnerFactory ?? makeNoopSpinnerFactory())('agent-kit-global');
+    const probe = spawn('vp', ['--version'], { encoding: 'utf8' });
+    if (probe.error || (probe.status !== null && probe.status !== 0)) {
+        return { kind: 'agent-kit-global-skipped-no-vp', hint: NO_VP_HINT };
+    }
+    const command = buildVpGlobalInstallCommand();
+    spinner.start();
+    const install = spawn(command[0], command.slice(1), { stdio: 'inherit' });
+    if (install.status !== 0) {
+        spinner.fail('agent-kit global refresh failed');
+        return { kind: 'agent-kit-global-failed', exitCode: install.status ?? -1, command };
+    }
+    spinner.succeed('agent-kit global up to date');
+    return { kind: 'agent-kit-global-updated', command };
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/cli/commands/package-manager.d.ts

@@ -0,0 +1,15 @@
+import type { CAC } from 'cac';
+import type { SpawnSyncReturns } from 'node:child_process';
+export declare const PACKAGE_MANAGER_VERBS: readonly ["install", "add", "remove", "update", "exec", "run"];
+export type PackageManagerVerb = (typeof PACKAGE_MANAGER_VERBS)[number];
+export interface PackageManagerCommandConfig {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+export interface PackageManagerCommandDeps {
+    readonly run?: (command: string, args: readonly string[]) => SpawnSyncReturns<string>;
+}
+export declare function registerPackageManagerCommand(cli: CAC, verb: PackageManagerVerb): void;
+export declare function buildPackageManagerCommand(verb: PackageManagerVerb, argv?: readonly string[]): PackageManagerCommandConfig;
+export declare function runPackageManagerCommand(verb: PackageManagerVerb, deps?: PackageManagerCommandDeps): number;
+//# sourceMappingURL=package-manager.d.ts.map

package/dist/esm/cli/commands/package-manager.js

@@ -0,0 +1,42 @@
+import { spawnSync } from 'node:child_process';
+import { getManagedRunner } from '#tool-runtime';
+export const PACKAGE_MANAGER_VERBS = ['install', 'add', 'remove', 'update', 'exec', 'run'];
+const HELP_BY_VERB = {
+    install: 'Install dependencies through the managed vp facade.',
+    add: 'Add dependencies through the managed vp facade.',
+    remove: 'Remove dependencies through the managed vp facade.',
+    update: 'Update dependencies through the managed vp facade.',
+    exec: 'Run a binary through the managed vp facade.',
+    run: 'Run a package script through the managed vp facade.',
+};
+export function registerPackageManagerCommand(cli, verb) {
+    cli
+        .command(`${verb} [...args]`, HELP_BY_VERB[verb])
+        .allowUnknownOptions()
+        .action(() => runPackageManagerCommand(verb));
+}
+export function buildPackageManagerCommand(verb, argv = process.argv) {
+    const resolution = getManagedRunner('vp', { outputPolicy: 'structured' });
+    return {
+        command: resolution.command,
+        args: [...resolution.args, verb, ...extractVerbArgs(verb, argv)],
+    };
+}
+export function runPackageManagerCommand(verb, deps = {}) {
+    const command = buildPackageManagerCommand(verb);
+    const result = (deps.run ?? defaultRun)(command.command, command.args);
+    return typeof result.status === 'number' ? result.status : 1;
+}
+function extractVerbArgs(verb, argv) {
+    const verbIndex = argv.findIndex((arg, index) => index >= 2 && arg === verb);
+    return verbIndex === -1 ? [] : argv.slice(verbIndex + 1);
+}
+function defaultRun(command, args) {
+    return spawnSync(command, [...args], {
+        encoding: 'utf8',
+        env: process.env,
+        stdio: 'inherit',
+        windowsHide: true,
+    });
+}
+//# sourceMappingURL=package-manager.js.map

package/dist/esm/cli/commands/test.d.ts

@@ -2,6 +2,7 @@ import type { CommandConfig, TestCommandOptions } from '#test';
 import type { CAC } from 'cac';
 export declare const TEST_COMMAND_HELP: string;
 export interface AkTestCommandInput extends TestCommandOptions {
+    cwd?: string;
     package?: readonly string[] | string;
     file?: readonly string[] | string;
     targets?: readonly string[] | string;

package/dist/esm/cli/commands/test.js

@@ -14,7 +14,7 @@ export function createAkTestCommandConfig(input) {
         file: toArray(input.file),
         positional: toArray(input.targets),
     });
-    return buildTestCommand(target, input);
+    return buildTestCommand(target, { ...input, cwd: input.cwd });
 }
 export function registerTestCommand(cli) {
     cli
@@ -35,6 +35,7 @@ export function registerTestCommand(cli) {
         .action((targets, flags) => {
         const rawArgv = process.argv.slice(2);
         const command = createAkTestCommandConfig({
+            cwd: process.cwd(),
             package: flags.package,
             file: flags.file,
             targets: targets ?? [],

package/dist/esm/cli/commands/typecheck.js

@@ -1,7 +1,6 @@
 import { getManagedRunner } from '#tool-runtime';
+import { getPackageScript, isRecursiveWpScript } from '#cli/package-scripts.js';
 import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
 export const TYPECHECK_COMMAND_HELP = [
     'Typecheck the current workspace through the portable wp surface.',
     '',
@@ -17,17 +16,15 @@ export function registerTypecheckCommand(cli) {
 }
 export function buildTypecheckCommand(options = {}) {
     const cwd = options.cwd ?? process.cwd();
-    if (hasCheckTypesScript(cwd)) {
-        const resolution = getManagedRunner('vp');
+    const checkTypesScript = getPackageScript(cwd, 'check-types');
+    if (checkTypesScript && !isRecursiveWpScript(checkTypesScript, 'typecheck')) {
+        const resolution = getManagedRunner('vp', { outputPolicy: 'structured' });
         return {
             command: resolution.command,
             args: [...resolution.args, 'run', 'check-types'],
         };
     }
-    const resolution = getManagedRunner('tsc', {
-        fallbackCommand: 'tsc',
-        fallbackArgs: [],
-    });
+    const resolution = getManagedRunner('tsc', { outputPolicy: 'structured' });
     return {
         command: resolution.command,
         args: [...resolution.args, '--noEmit', ...(options.pretty ? [] : ['--pretty', 'false'])],
@@ -48,16 +45,4 @@ function defaultRun(command, args) {
         windowsHide: true,
     });
 }
-function hasCheckTypesScript(cwd) {
-    const packageJsonPath = join(cwd, 'package.json');
-    if (!existsSync(packageJsonPath))
-        return false;
-    try {
-        const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-        return typeof parsed.scripts?.['check-types'] === 'string';
-    }
-    catch {
-        return false;
-    }
-}
 //# sourceMappingURL=typecheck.js.map

package/dist/esm/cli/package-scripts.d.ts

@@ -0,0 +1,12 @@
+export interface PackageJsonLike {
+    readonly scripts?: Record<string, unknown>;
+    readonly dependencies?: Record<string, unknown>;
+    readonly devDependencies?: Record<string, unknown>;
+    readonly optionalDependencies?: Record<string, unknown>;
+}
+export declare function readPackageJson(cwd: string): PackageJsonLike | undefined;
+export declare function getPackageScript(cwd: string, name: string): string | undefined;
+export declare function packageHasDependency(cwd: string, dependencyName: string): boolean;
+export declare function packageUsesVitest(cwd: string): boolean;
+export declare function isRecursiveWpScript(script: string, verb: string): boolean;
+//# sourceMappingURL=package-scripts.d.ts.map

package/dist/esm/cli/package-scripts.js

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function readPackageJson(cwd) {
+    const packageJsonPath = join(cwd, 'package.json');
+    if (!existsSync(packageJsonPath))
+        return;
+    try {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return;
+        return parsed;
+    }
+    catch {
+        return;
+    }
+}
+export function getPackageScript(cwd, name) {
+    const parsed = readPackageJson(cwd);
+    const candidate = parsed?.scripts?.[name];
+    return typeof candidate === 'string' ? candidate : undefined;
+}
+export function packageHasDependency(cwd, dependencyName) {
+    const parsed = readPackageJson(cwd);
+    if (!parsed)
+        return false;
+    return ['dependencies', 'devDependencies', 'optionalDependencies'].some((section) => {
+        const dependencies = parsed[section];
+        return Boolean(dependencies &&
+            typeof dependencies === 'object' &&
+            !Array.isArray(dependencies) &&
+            dependencyName in dependencies);
+    });
+}
+export function packageUsesVitest(cwd) {
+    return packageHasDependency(cwd, 'vitest');
+}
+export function isRecursiveWpScript(script, verb) {
+    const normalized = stripLeadingEnvAssignments(script.trim());
+    if (!normalized)
+        return false;
+    const patterns = [
+        new RegExp(`^(?:vp\\s+exec\\s+)?wp\\s+${escapeRegExp(verb)}(?:\\s|$)`),
+        new RegExp(`^(?:bunx?|npx)\\s+(?:--yes\\s+)?(?:@webpresso/agent-kit\\s+)?wp\\s+${escapeRegExp(verb)}(?:\\s|$)`),
+    ];
+    return patterns.some((pattern) => pattern.test(normalized));
+}
+function stripLeadingEnvAssignments(input) {
+    let remaining = input.replace(/^env\s+/u, '');
+    while (true) {
+        const next = remaining.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S+)\s+)/u, '');
+        if (next === remaining)
+            return remaining.trim();
+        remaining = next;
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}
+//# sourceMappingURL=package-scripts.js.map

package/dist/esm/cli/utils.js

@@ -5,8 +5,9 @@
  * unknown-command formatting) and webpresso/packages/cli/cli-utils
  * (getProjectRoot) so this package has no @webpresso/* runtime dependencies.
  */
-import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { readOwnedPackageVersion } from '#runtime/package-version.js';
 // ---------------------------------------------------------------------------
 // Project root resolution
 // ---------------------------------------------------------------------------
@@ -131,26 +132,6 @@ export function formatUnknownCommandError(input, commands, binName = 'wp') {
  * having to know how many `..` segments to append.
  */
 export function readPackageVersion(metaUrl) {
-    const url = new URL(metaUrl);
-    let dir = path.dirname(url.pathname);
-    for (let i = 0; i < 6; i++) {
-        const candidate = path.join(dir, 'package.json');
-        if (existsSync(candidate)) {
-            try {
-                const parsed = JSON.parse(readFileSync(candidate, 'utf-8'));
-                if (parsed.name === 'webpresso') {
-                    return parsed.version ?? '0.0.0';
-                }
-            }
-            catch {
-                // keep walking
-            }
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return '0.0.0';
+    return readOwnedPackageVersion(metaUrl);
 }
 //# sourceMappingURL=utils.js.map

package/dist/esm/cli/wp-extensions.d.ts

@@ -0,0 +1,14 @@
+import type { CAC } from 'cac';
+import { type LoadWpExtensionsOptions, type WpExtensionAliasV1 } from '#wp-extension';
+export interface RegisterWpExtensionsOptions extends LoadWpExtensionsOptions {
+    readonly cli: CAC;
+    readonly baseCommands: readonly string[];
+}
+export interface RegisteredWpExtensions {
+    readonly aliasMap: ReadonlyMap<string, WpExtensionAliasV1>;
+    readonly warnings: readonly string[];
+    readonly commandNames: readonly string[];
+}
+export declare function registerWpExtensions(options: RegisterWpExtensionsOptions): Promise<RegisteredWpExtensions>;
+export declare function resolveWpCommandAlias(command: string | undefined, aliasMap: ReadonlyMap<string, WpExtensionAliasV1>): string | undefined;
+//# sourceMappingURL=wp-extensions.d.ts.map

package/dist/esm/cli/wp-extensions.js

@@ -0,0 +1,34 @@
+import { loadWpExtensions, resolveAcceptedExtensionAliases, } from '#wp-extension';
+export async function registerWpExtensions(options) {
+    const loaded = await loadWpExtensions(options);
+    const warnings = loaded.flatMap((entry) => entry.warnings);
+    const commandNames = [];
+    const blockedCommandNames = new Set(options.baseCommands);
+    const registeredCommandNames = new Set();
+    for (const extension of loaded) {
+        if (!extension.extension || !extension.compatible || !extension.detected)
+            continue;
+        for (const command of extension.extension.commands) {
+            if (blockedCommandNames.has(command.name)) {
+                warnings.push(`${extension.packageName}: skipped command "${command.name}" because it collides with an existing command`);
+                continue;
+            }
+            command.register(options.cli);
+            commandNames.push(command.name);
+            blockedCommandNames.add(command.name);
+            registeredCommandNames.add(command.name);
+        }
+    }
+    const aliasResolution = resolveAcceptedExtensionAliases(loaded, options.baseCommands, registeredCommandNames);
+    return {
+        aliasMap: aliasResolution.aliases,
+        warnings: [...warnings, ...aliasResolution.warnings],
+        commandNames,
+    };
+}
+export function resolveWpCommandAlias(command, aliasMap) {
+    if (!command)
+        return command;
+    return aliasMap.get(command)?.commandName ?? command;
+}
+//# sourceMappingURL=wp-extensions.js.map

package/dist/esm/config/docs-lint/schemas/common.d.ts

@@ -46,8 +46,8 @@ export declare const implementationStatus: z.ZodEnum<{
     completed: "completed";
     draft: "draft";
     planned: "planned";
-    "in-progress": "in-progress";
     parked: "parked";
+    "in-progress": "in-progress";
     archived: "archived";
     current: "current";
     complete: "complete";

package/dist/esm/config/docs-lint/schemas/implementation-plan.d.ts

@@ -15,8 +15,8 @@ export declare const implementationPlanFrontmatter: z.ZodObject<{
         completed: "completed";
         draft: "draft";
         planned: "planned";
-        "in-progress": "in-progress";
         parked: "parked";
+        "in-progress": "in-progress";
         archived: "archived";
         current: "current";
         complete: "complete";
@@ -40,8 +40,8 @@ export declare const implementationPlanFrontmatter: z.ZodObject<{
             completed: "completed";
             draft: "draft";
             planned: "planned";
-            "in-progress": "in-progress";
             parked: "parked";
+            "in-progress": "in-progress";
             archived: "archived";
             current: "current";
             complete: "complete";

package/dist/esm/config/docs-lint/schemas/parent-roadmap.d.ts

@@ -14,8 +14,8 @@ export declare const parentRoadmapFrontmatter: z.ZodObject<{
         completed: "completed";
         draft: "draft";
         planned: "planned";
-        "in-progress": "in-progress";
         parked: "parked";
+        "in-progress": "in-progress";
         archived: "archived";
         current: "current";
         complete: "complete";

package/dist/esm/config/stryker/index.d.ts

@@ -40,5 +40,90 @@ export declare const baseConfig: {
     incremental: boolean;
     incrementalFile: string;
 };
+/**
+ * Extends baseConfig with TypeScript checker defaults.
+ * Use this in any TypeScript package instead of baseConfig directly.
+ *
+ * @example
+ * import { typescriptBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptBaseConfig }
+ * // or, for packages with a CF-pool vitest config:
+ * export default { ...typescriptBaseConfig, vitest: { configFile: 'vitest.stryker.config.ts' } }
+ */
+export declare const typescriptBaseConfig: {
+    checkers: string[];
+    tsconfigFile: string;
+    packageManager: string;
+    testRunner: string;
+    plugins: string[];
+    ignorePatterns: string[];
+    mutate: string[];
+    concurrency: number;
+    timeoutMS: number;
+    dryRunTimeoutMinutes: number;
+    ignoreStatic: boolean;
+    thresholds: {
+        high: number;
+        low: number;
+        break: number;
+    };
+    mutator: {
+        excludedMutations: string[];
+    };
+    reporters: string[];
+    htmlReporter: {
+        fileName: string;
+    };
+    jsonReporter: {
+        fileName: string;
+    };
+    incremental: boolean;
+    incrementalFile: string;
+};
+/**
+ * Extends typescriptBaseConfig for Cloudflare Workers packages whose vitest config
+ * uses @cloudflare/vitest-pool-workers (incompatible with Stryker's pool injection).
+ * Points to a per-package vitest.stryker.config.ts that uses the standard forks pool
+ * and excludes any tests that require CF runtime globals (cloudflare:test).
+ *
+ * @example
+ * import { typescriptWorkersBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptWorkersBaseConfig }
+ */
+export declare const typescriptWorkersBaseConfig: {
+    vitest: {
+        configFile: string;
+    };
+    checkers: string[];
+    tsconfigFile: string;
+    packageManager: string;
+    testRunner: string;
+    plugins: string[];
+    ignorePatterns: string[];
+    mutate: string[];
+    concurrency: number;
+    timeoutMS: number;
+    dryRunTimeoutMinutes: number;
+    ignoreStatic: boolean;
+    thresholds: {
+        high: number;
+        low: number;
+        break: number;
+    };
+    mutator: {
+        excludedMutations: string[];
+    };
+    reporters: string[];
+    htmlReporter: {
+        fileName: string;
+    };
+    jsonReporter: {
+        fileName: string;
+    };
+    incremental: boolean;
+    incrementalFile: string;
+};
 export default baseConfig;
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/config/stryker/index.js

@@ -75,5 +75,36 @@ export const baseConfig = {
     incremental: true,
     incrementalFile: 'reports/stryker-incremental.json',
 };
+/**
+ * Extends baseConfig with TypeScript checker defaults.
+ * Use this in any TypeScript package instead of baseConfig directly.
+ *
+ * @example
+ * import { typescriptBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptBaseConfig }
+ * // or, for packages with a CF-pool vitest config:
+ * export default { ...typescriptBaseConfig, vitest: { configFile: 'vitest.stryker.config.ts' } }
+ */
+export const typescriptBaseConfig = {
+    ...baseConfig,
+    checkers: ['typescript'],
+    tsconfigFile: 'tsconfig.json',
+};
+/**
+ * Extends typescriptBaseConfig for Cloudflare Workers packages whose vitest config
+ * uses @cloudflare/vitest-pool-workers (incompatible with Stryker's pool injection).
+ * Points to a per-package vitest.stryker.config.ts that uses the standard forks pool
+ * and excludes any tests that require CF runtime globals (cloudflare:test).
+ *
+ * @example
+ * import { typescriptWorkersBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptWorkersBaseConfig }
+ */
+export const typescriptWorkersBaseConfig = {
+    ...typescriptBaseConfig,
+    vitest: { configFile: 'vitest.stryker.config.ts' },
+};
 export default baseConfig;
 //# sourceMappingURL=index.js.map

package/dist/esm/e2e/command-builder.js

@@ -16,7 +16,9 @@ function buildPlaywrightCommand(options) {
         throw new Error(`Step ${step.logName} uses runner "playwright" but does not define configPath.`);
     }
     const { baseDir, configArg, files } = resolveRunnerPaths(step.configPath, options.files ?? []);
-    const resolution = withBaseDir(getManagedRunner('playwright', { filterOutput: options.filterOutput }), baseDir);
+    const resolution = withBaseDir(getManagedRunner('playwright', {
+        outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
+    }), baseDir);
     const args = [...resolution.args, 'test', '--config', configArg];
     appendPlaywrightFlags(args, options);
     args.push(...(step.fixedArgs ?? []), ...files, ...(options.passthrough ?? []));
@@ -28,7 +30,9 @@ function buildVitestE2eCommand(options) {
         throw new Error(`Step ${step.logName} uses runner "vitest" but does not define configPath.`);
     }
     const { baseDir, configArg, files } = resolveRunnerPaths(step.configPath, options.files ?? []);
-    const resolution = withBaseDir(getManagedRunner('vitest', { filterOutput: options.filterOutput }), baseDir);
+    const resolution = withBaseDir(getManagedRunner('vitest', {
+        outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
+    }), baseDir);
     const args = [...resolution.args, 'run', '--config', configArg];
     if (options.workers !== undefined) {
         args.push('--poolOptions.threads.maxThreads', String(options.workers));
@@ -114,4 +118,9 @@ function withBaseDir(resolution, baseDir) {
     }
     return { command: resolution.command, args: [...resolution.args] };
 }
+function resolveOutputPolicy(outputPolicy, filterOutput) {
+    if (outputPolicy)
+        return outputPolicy;
+    return filterOutput === false ? 'structured' : 'rtk-filtered';
+}
 //# sourceMappingURL=command-builder.js.map

package/dist/esm/e2e/config.d.ts

@@ -1,11 +1,76 @@
 import { z } from 'zod';
 export declare const WEBPRESSO_CONFIG_FILE_NAME = "webpresso.config.ts";
 export declare const WEBPRESSO_CONFIG_EXPORT_NAME = "webpressoConfig";
+export declare const AGENT_KIT_CONFIG_FILE_NAME = "agent-kit.config.ts";
+export declare const AGENT_KIT_CONFIG_EXPORT_NAME = "agentKitConfig";
+export declare const WEBPRESSO_CONFIG_CANDIDATES: readonly [{
+    readonly fileName: "agent-kit.config.ts";
+    readonly exportName: "agentKitConfig";
+}, {
+    readonly fileName: "webpresso.config.ts";
+    readonly exportName: "webpressoConfig";
+}];
 declare const webpressoConfigSchema: z.ZodObject<{
     e2e: z.ZodOptional<z.ZodObject<{
         hostAdapterModule: z.ZodString;
         hostAdapterExport: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    deploy: z.ZodOptional<z.ZodObject<{
+        cloudflare: z.ZodOptional<z.ZodObject<{
+            lanes: z.ZodObject<{
+                dev: z.ZodObject<{
+                    wranglerEnvName: z.ZodString;
+                }, z.core.$strict>;
+                preview_main: z.ZodObject<{
+                    wranglerEnvName: z.ZodString;
+                }, z.core.$strict>;
+                preview_pr: z.ZodObject<{
+                    wranglerEnvNamePattern: z.ZodString;
+                }, z.core.$strict>;
+                prd: z.ZodObject<{
+                    wranglerEnvName: z.ZodString & z.ZodType<"production", string, z.core.$ZodTypeInternals<"production", string>>;
+                    deployedWorkerNameMode: z.ZodLiteral<"top_level_name">;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            production: z.ZodObject<{
+                metadataPath: z.ZodLiteral<"infra/release-metadata.production.json">;
+            }, z.core.$strict>;
+            targets: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    single_worker: "single_worker";
+                    worker_plus_assets: "worker_plus_assets";
+                    monorepo_multi_target: "monorepo_multi_target";
+                }>;
+                topLevelWorkerName: z.ZodString;
+                previewTransport: z.ZodEnum<{
+                    custom_domain_env: "custom_domain_env";
+                    workers_dev_env: "workers_dev_env";
+                }>;
+                routeSpec: z.ZodOptional<z.ZodObject<{
+                    pattern: z.ZodString;
+                }, z.core.$strict>>;
+                durableObjectBindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    className: z.ZodString;
+                    scriptName: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                vars: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                requiredSecrets: z.ZodArray<z.ZodString>;
+                storageMode: z.ZodEnum<{
+                    isolated: "isolated";
+                    shared_via_script_name: "shared_via_script_name";
+                }>;
+                destroyMode: z.ZodLiteral<"wrangler_delete_env">;
+                repoCleanupHook: z.ZodOptional<z.ZodString>;
+                blastRadiusDoc: z.ZodOptional<z.ZodString>;
+                productionStrategyDefault: z.ZodEnum<{
+                    direct: "direct";
+                    gradual: "gradual";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type WebpressoConfig = z.infer<typeof webpressoConfigSchema>;
 export type WebpressoE2eConfig = NonNullable<WebpressoConfig['e2e']>;