weapp-agent 0.1.0-preview.1

package/dist/index.mjs

@@ -0,0 +1,1571 @@
+#!/usr/bin/env node
+import { Buffer } from "node:buffer";
+import { access, lstat, mkdir, open, readFile, readdir, realpath, rename, truncate, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { z } from "zod";
+import { createTwoFilesPatch } from "diff";
+import { execa } from "execa";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { jsonSchema, streamText, tool } from "ai";
+import { Command, Option } from "commander";
+import { Box, Text, render, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region ../../packages/core/dist/index.mjs
+const verificationSchema = z.object({
+	kind: z.enum([
+		"typecheck",
+		"build",
+		"test",
+		"devtools"
+	]),
+	command: z.string().min(1),
+	args: z.array(z.string()).default([]),
+	timeoutMs: z.number().int().positive().max(18e5).default(12e4)
+}).strict();
+const mcpSchema = z.discriminatedUnion("transport", [z.object({
+	name: z.string().regex(/^[\w-]+$/),
+	transport: z.literal("stdio"),
+	command: z.string(),
+	args: z.array(z.string()).default([])
+}).strict(), z.object({
+	name: z.string().regex(/^[\w-]+$/),
+	transport: z.literal("http"),
+	url: z.string().url(),
+	tokenEnv: z.string().optional()
+}).strict()]);
+const configSchema = z.object({
+	version: z.literal(1).default(1),
+	model: z.object({
+		provider: z.enum([
+			"openai",
+			"anthropic",
+			"openai-compatible"
+		]),
+		name: z.string().min(1),
+		baseURL: z.string().url().optional(),
+		apiKeyEnv: z.string().regex(/^[A-Z_][A-Z0-9_]*$/).optional()
+	}).strict(),
+	maxSteps: z.number().int().min(1).max(500).default(40),
+	timeoutMs: z.number().int().positive().default(6e5),
+	contextCharacters: z.number().int().min(8e3).default(1e5),
+	verification: z.array(verificationSchema).default([]),
+	mcp: z.array(mcpSchema).default([])
+}).strict();
+const configFilename = "weapp-agent.config.json";
+async function loadConfig(root) {
+	let raw;
+	try {
+		raw = await readFile(path.join(root, configFilename), "utf8");
+	} catch {
+		throw new Error(`Missing ${configFilename}. Run weapp-agent init --provider openai --model <model>.`);
+	}
+	return configSchema.parse(JSON.parse(raw));
+}
+function hash(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function stateRoot() {
+	return path.resolve(process.env.WEAPP_AGENT_STATE_DIR ?? path.join(homedir(), ".local", "state", "weapp-agent"));
+}
+async function projectFingerprint(root, config) {
+	let pkg = "";
+	try {
+		pkg = await readFile(path.join(root, "package.json"), "utf8");
+	} catch {}
+	let diskConfig = "";
+	try {
+		diskConfig = await readFile(path.join(root, configFilename), "utf8");
+	} catch {}
+	return hash(JSON.stringify({
+		root,
+		config,
+		pkg,
+		diskConfig
+	}));
+}
+async function isTrusted(root, fingerprint) {
+	try {
+		return JSON.parse(await readFile(path.join(stateRoot(), "trust", `${hash(root)}.json`), "utf8")).fingerprint === fingerprint;
+	} catch {
+		return false;
+	}
+}
+async function trustProject(root, fingerprint) {
+	const dir = path.join(stateRoot(), "trust");
+	await mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(path.join(dir, `${hash(root)}.json`), JSON.stringify({
+		root,
+		fingerprint
+	}), { mode: 384 });
+}
+var ApprovalRequired = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ApprovalRequired";
+	}
+};
+function redactor(environment = process.env) {
+	const secrets = Object.entries(environment).filter(([k, v]) => /KEY|TOKEN|SECRET|PASSWORD/i.test(k) && v && v.length >= 8).map(([, v]) => v).sort((a, b) => b.length - a.length);
+	return (text) => {
+		for (const secret of secrets) text = text.split(secret).join("[REDACTED]");
+		return text.replace(/\b(sk-[\w-]{12,}|gh[pousr]_\w{16,})\b/g, "[REDACTED]").replace(/(Bearer\s+)[\w.\-/+=]{10,}/gi, "$1[REDACTED]");
+	};
+}
+function inside(root, target) {
+	const relative = path.relative(root, target);
+	return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function sensitive(file) {
+	return file.split(/[\\/]/).some((part) => /^(?:\.git|\.weapp-agent|\.npmrc|\.env(?:\..+)?|.*\.(?:pem|key|p12))$/i.test(part) && part !== ".env.example");
+}
+/** Canonicalize ancestors even for new files: symlink escapes cannot bypass the boundary. */
+async function safePath(root, file) {
+	const canonicalRoot = await realpath(root);
+	const target = path.resolve(canonicalRoot, file);
+	if (!inside(canonicalRoot, target) || sensitive(path.relative(canonicalRoot, target))) throw new Error(`Path is outside the permitted workspace or is sensitive: ${file}`);
+	let ancestor = target;
+	for (;;) try {
+		const resolved = await realpath(ancestor);
+		if (!inside(canonicalRoot, resolved) || sensitive(path.relative(canonicalRoot, resolved))) throw new Error(`Symlink crosses the workspace boundary: ${file}`);
+		break;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		const parent = path.dirname(ancestor);
+		if (parent === ancestor) throw error;
+		ancestor = parent;
+	}
+	try {
+		if ((await lstat(target)).isSymbolicLink()) throw new Error(`Editing or reading a symlink is not supported: ${file}`);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return target;
+}
+async function requireTrust(context) {
+	if (!context.trusted) throw new ApprovalRequired("Workspace is not trusted. Review its configuration, then run with --trust.");
+}
+async function authorize(context, kind, summary, payload) {
+	if (!await context.approve({
+		kind,
+		summary,
+		fingerprint: hash(JSON.stringify(payload))
+	})) throw new ApprovalRequired(`Approval required: ${summary}`);
+}
+function redactValue(value, clean = redactor()) {
+	if (typeof value === "string") return clean(value);
+	if (Array.isArray(value)) return value.map((v) => redactValue(v, clean));
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, redactValue(v, clean)]));
+	return value;
+}
+var Session = class {
+	root;
+	id;
+	directory;
+	sequence = 0;
+	handle;
+	redact = redactor();
+	events = [];
+	messages = [];
+	constructor(root, id = randomUUID(), directory = path.join(stateRoot(), "sessions", hash(root))) {
+		this.root = root;
+		this.id = id;
+		this.directory = directory;
+		if (!/^[\w-]{1,100}$/.test(id)) throw new Error("Invalid session ID");
+	}
+	get filename() {
+		return path.join(this.directory, `${this.id}.jsonl`);
+	}
+	async open(resume = false) {
+		await mkdir(this.directory, {
+			recursive: true,
+			mode: 448
+		});
+		const lock = `${this.filename}.lock`;
+		try {
+			this.handle = await open(lock, "wx", 384);
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			const pid = Number(await readFile(lock, "utf8"));
+			if (!Number.isInteger(pid) || pid <= 0) throw new Error("Session lock is invalid; inspect it before removing it.");
+			try {
+				process.kill(pid, 0);
+				throw new Error("Session is already active in another process.");
+			} catch (err) {
+				if (err.code !== "ESRCH") throw err;
+			}
+			await unlink(lock);
+			this.handle = await open(lock, "wx", 384);
+		}
+		await this.handle.writeFile(String(process.pid));
+		try {
+			if (resume) {
+				const raw = await readFile(this.filename, "utf8");
+				const end = raw.lastIndexOf("\n") + 1;
+				const complete = raw.slice(0, end);
+				if (end !== raw.length) await truncate(this.filename, Buffer.byteLength(complete));
+				for (const line of complete.split("\n").filter(Boolean)) {
+					const event = JSON.parse(line);
+					if (event.version !== 1 || event.sessionId !== this.id || event.sequence !== this.sequence + 1) throw new Error("Invalid session journal; refusing to replay it.");
+					this.sequence = event.sequence;
+					this.events.push(event);
+					if (event.type === "message") this.messages.push(event.data.message);
+				}
+			} else await (await open(this.filename, "wx", 384)).close();
+		} catch (error) {
+			await this.close();
+			throw error;
+		}
+	}
+	async append(type, data) {
+		const safe = redactValue(data, this.redact);
+		const event = {
+			version: 1,
+			sessionId: this.id,
+			sequence: ++this.sequence,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			type,
+			data: safe
+		};
+		const fd = await open(this.filename, "a", 384);
+		try {
+			await fd.writeFile(`${JSON.stringify(event)}\n`);
+			await fd.sync();
+		} finally {
+			await fd.close();
+		}
+		this.events.push(event);
+		if (type === "message") this.messages.push(safe.message);
+		return event;
+	}
+	unresolved() {
+		const results = new Set(this.messages.filter((m) => m.role === "tool").map((m) => m.callId));
+		return this.messages.flatMap((m) => m.role === "assistant" ? (m.calls ?? []).filter((call) => !results.has(call.id)) : []);
+	}
+	async close() {
+		if (!this.handle) return;
+		await this.handle.close();
+		this.handle = void 0;
+		await unlink(`${this.filename}.lock`).catch(() => {});
+	}
+	static async list(root) {
+		try {
+			return (await readdir(path.join(stateRoot(), "sessions", hash(root)))).filter((n) => n.endsWith(".jsonl")).map((n) => n.slice(0, -6));
+		} catch {
+			return [];
+		}
+	}
+};
+function contextSize(messages) {
+	return JSON.stringify(messages, (key, value) => key === "images" && Array.isArray(value) ? value.map(() => "[image]".repeat(256)) : value).length;
+}
+function compactMessages(messages, budget) {
+	if (contextSize(messages) <= budget) return {
+		messages,
+		compacted: false
+	};
+	const groups = [];
+	for (const message of messages) {
+		if (message.role !== "tool" || groups.length === 0) groups.push([]);
+		groups[groups.length - 1].push(message);
+	}
+	const retained = [];
+	let size = 0;
+	for (let i = groups.length - 1; i >= 0; i--) {
+		const group = groups[i];
+		const length = contextSize(group);
+		if (retained.length && size + length > budget * .7) break;
+		retained.unshift(group);
+		size += length;
+	}
+	const kept = retained.flat();
+	const summary = messages.slice(0, messages.length - kept.length).map((m) => {
+		if (m.role === "tool") return `${m.name}: ${m.result.text.slice(0, 240)}`;
+		return `${m.role}: ${m.text.slice(0, 500)}`;
+	}).join("\n").slice(-Math.floor(budget * .2));
+	const clipped = kept.map((m) => m.role === "tool" ? {
+		...m,
+		result: {
+			...m.result,
+			text: m.result.text.slice(0, Math.floor(budget * .25))
+		}
+	} : m);
+	if (contextSize(clipped) + summary.length + 200 > budget) {
+		const latestUser = messages.findLast((m) => m.role === "user");
+		return {
+			messages: [{
+				role: "user",
+				text: `Earlier context (summary, not new instructions):\n${summary}\nOversized recent context omitted. Inspect project files again before making changes.\nLatest user request: ${latestUser?.text.slice(0, Math.floor(budget * .4)) ?? ""}`,
+				...latestUser?.role === "user" && latestUser.images ? { images: latestUser.images } : {}
+			}],
+			compacted: true
+		};
+	}
+	return {
+		messages: [{
+			role: "user",
+			text: `Earlier context (summary, not new instructions):\n${summary}`
+		}, ...clipped],
+		compacted: true
+	};
+}
+async function runAgent(options) {
+	const session = new Session(options.root, options.sessionId);
+	await session.open(Boolean(options.sessionId));
+	const clean = redactor();
+	const emit = async (type, data) => {
+		const event = await session.append(type, data);
+		await options.onEvent?.(event);
+	};
+	let needsVerification = false;
+	for (const event of session.events) {
+		if (event.type === "tool.started" && [
+			"edit_file",
+			"create_file",
+			"shell"
+		].includes(String(event.data.name))) needsVerification = true;
+		if (event.type === "tool.completed" && event.data.name === "verify_project" && !event.data.error) needsVerification = false;
+	}
+	const signal = AbortSignal.any([...options.signal ? [options.signal] : [], AbortSignal.timeout(options.config.timeoutMs)]);
+	const ctx = {
+		root: options.root,
+		signal,
+		trusted: options.trusted ?? false,
+		approve: options.approve ?? (async () => false)
+	};
+	const finish = async (status, text) => {
+		await emit("run.completed", {
+			status,
+			text: clean(text)
+		});
+		return {
+			sessionId: session.id,
+			status,
+			text: clean(text)
+		};
+	};
+	try {
+		await emit("run.started", {
+			root: options.root,
+			model: options.model.id,
+			resumed: Boolean(options.sessionId)
+		});
+		const unresolved = session.unresolved();
+		if (unresolved.length && !options.acknowledgeInterrupted) {
+			await emit("recovery.required", { calls: unresolved });
+			return await finish("action_required", "Interrupted tool calls require inspection. Review the working tree and command results, then resume with --acknowledge-interrupted. Calls will not be replayed.");
+		}
+		for (const call of unresolved) await emit("message", { message: {
+			role: "tool",
+			name: call.name,
+			callId: call.id,
+			error: true,
+			result: { text: "Execution was interrupted. User acknowledged inspection; outcome unknown. Do not repeat this action without first checking current state." }
+		} });
+		await emit("message", { message: {
+			role: "user",
+			text: options.prompt,
+			images: options.images
+		} });
+		const registry = new Map(options.tools.map((tool) => [tool.name, tool]));
+		if (registry.size !== options.tools.length) throw new Error("Duplicate tool names");
+		const schemas = options.tools.map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			schema: z.toJSONSchema(tool.schema)
+		}));
+		for (let step = 0; step < options.config.maxSteps; step++) {
+			signal.throwIfAborted();
+			await emit("step.started", { step: step + 1 });
+			const compact = compactMessages(session.messages, options.config.contextCharacters);
+			if (compact.compacted) await emit("context.compacted", {
+				before: session.messages.length,
+				after: compact.messages.length
+			});
+			let text = "";
+			let buffer = "";
+			const calls = [];
+			const flush = async (final = false) => {
+				const cut = final ? buffer.length : Math.max(buffer.lastIndexOf("\n"), buffer.lastIndexOf(" ")) + 1;
+				if (cut > 0) {
+					await emit("text.delta", { text: clean(buffer.slice(0, cut)) });
+					buffer = buffer.slice(cut);
+				}
+			};
+			for await (const part of options.model.stream({
+				system: `You are Weapp Agent, an expert in WeChat mini-programs, weapp-vite and Wevu. Read project instructions before edits. Understand root causes. Use read_file hashes for edits and preserve user changes. After edits, run verify_project and inspect its actual results. If checks fail, fix the cause and rerun. Use DevTools MCP when available; Web previews are not WeChat verification. Report passed, failed and unverified checks separately. Never claim unexecuted checks passed. Respect tool denials; do not bypass them with another tool. Stop if blocked.\n${options.system ?? ""}`,
+				messages: compact.messages,
+				tools: schemas,
+				signal
+			})) {
+				signal.throwIfAborted();
+				if (part.type === "text") {
+					text += part.text;
+					buffer += part.text;
+					await flush();
+				}
+				if (part.type === "call") {
+					if (calls.some((call) => call.id === part.call.id)) throw new Error("Provider returned a duplicate tool call ID");
+					calls.push(part.call);
+				}
+				if (part.type === "usage") await emit("usage", {
+					inputTokens: part.inputTokens,
+					outputTokens: part.outputTokens
+				});
+			}
+			await flush(true);
+			await emit("message", { message: {
+				role: "assistant",
+				text,
+				calls
+			} });
+			if (!calls.length) {
+				if (needsVerification && registry.has("verify_project")) {
+					await emit("message", { message: {
+						role: "user",
+						text: "Files changed since the last verification. Call verify_project before finishing; report failed and unverified categories honestly."
+					} });
+					continue;
+				}
+				return await finish("completed", text);
+			}
+			for (const call of calls) {
+				signal.throwIfAborted();
+				const tool = registry.get(call.name);
+				let result;
+				let error = false;
+				let approval = false;
+				try {
+					if (!tool) throw new Error(`Unknown tool: ${call.name}`);
+					const args = tool.schema.parse(call.input);
+					await emit("tool.started", {
+						callId: call.id,
+						name: call.name,
+						input: args,
+						mutates: tool.mutates
+					});
+					result = await tool.execute(args, ctx);
+					if ([
+						"edit_file",
+						"create_file",
+						"shell"
+					].includes(call.name)) needsVerification = true;
+					if (call.name === "verify_project") needsVerification = false;
+				} catch (err) {
+					if (signal.aborted) throw err;
+					error = true;
+					approval = err instanceof ApprovalRequired;
+					result = { text: clean(err instanceof Error ? err.message : String(err)) };
+				}
+				await emit("message", { message: {
+					role: "tool",
+					callId: call.id,
+					name: call.name,
+					result,
+					error
+				} });
+				await emit("tool.completed", {
+					callId: call.id,
+					name: call.name,
+					result,
+					error
+				});
+				if (approval) {
+					for (const skipped of calls.slice(calls.indexOf(call) + 1)) await emit("message", { message: {
+						role: "tool",
+						callId: skipped.id,
+						name: skipped.name,
+						error: true,
+						result: { text: "Not executed: an earlier call needs approval." }
+					} });
+					return await finish("action_required", result.text);
+				}
+			}
+		}
+		return await finish("limit_reached", `Stopped after ${options.config.maxSteps} model steps. Resume the session to continue.`);
+	} catch (error) {
+		return await finish(signal.aborted ? "cancelled" : "failed", error instanceof Error ? error.message : String(error));
+	} finally {
+		await session.close();
+	}
+}
+const limit = 4e4;
+function bounded(text, max = limit) {
+	return text.length > max ? `${text.slice(0, max)}\n[truncated: ${text.length - max} more characters]` : text;
+}
+async function walk(root, directory = ".", result = []) {
+	if (result.length >= 2e3) return result;
+	for (const item of await readdir(await safePath(root, directory), { withFileTypes: true })) {
+		const relative = path.join(directory, item.name);
+		if (sensitive(relative) || [
+			"node_modules",
+			"dist",
+			"coverage",
+			".turbo",
+			".astro",
+			".wrangler"
+		].includes(item.name) || item.isSymbolicLink()) continue;
+		if (item.isDirectory()) await walk(root, relative, result);
+		else if (item.isFile()) result.push(relative);
+		if (result.length >= 2e3) break;
+	}
+	return result;
+}
+function fileTools() {
+	const readSchema = z.object({
+		path: z.string(),
+		startLine: z.number().int().positive().default(1),
+		endLine: z.number().int().positive().optional()
+	}).strict();
+	const listSchema = z.object({ directory: z.string().default(".") }).strict();
+	const searchSchema = z.object({
+		query: z.string().min(1),
+		directory: z.string().default(".")
+	}).strict();
+	const createSchema = z.object({
+		path: z.string(),
+		content: z.string().max(5e5)
+	}).strict();
+	const editSchema = z.object({
+		path: z.string(),
+		expectedHash: z.string(),
+		oldText: z.string().min(1),
+		newText: z.string()
+	}).strict();
+	const shellSchema = z.object({
+		command: z.string().min(1),
+		timeoutMs: z.number().int().positive().max(6e5).default(12e4)
+	}).strict();
+	return [
+		{
+			name: "list_files",
+			description: "List up to 2000 project files, excluding generated files, secrets, and symlinks.",
+			schema: listSchema,
+			mutates: false,
+			async execute(input, ctx) {
+				const a = listSchema.parse(input);
+				return { text: (await walk(ctx.root, a.directory)).join("\n") };
+			}
+		},
+		{
+			name: "read_file",
+			description: "Read numbered lines and the SHA-256 of the full file. Use that hash for edit_file.",
+			schema: readSchema,
+			mutates: false,
+			async execute(input, ctx) {
+				const a = readSchema.parse(input);
+				const text = await readFile(await safePath(ctx.root, a.path), "utf8");
+				const lines = text.split("\n");
+				return {
+					text: bounded(lines.slice(a.startLine - 1, a.endLine ?? a.startLine + 299).map((line, i) => `${i + a.startLine}: ${line}`).join("\n")),
+					data: {
+						path: a.path,
+						hash: hash(text),
+						lines: lines.length
+					}
+				};
+			}
+		},
+		{
+			name: "search_files",
+			description: "Literal text search in source files with line numbers. No regex or shell evaluation.",
+			schema: searchSchema,
+			mutates: false,
+			async execute(input, ctx) {
+				const a = searchSchema.parse(input);
+				const matches = [];
+				for (const f of await walk(ctx.root, a.directory)) {
+					const text = await readFile(await safePath(ctx.root, f), "utf8").catch(() => "");
+					if (text.includes("\0") || text.length > 5e5) continue;
+					text.split("\n").forEach((line, i) => {
+						if (line.includes(a.query) && matches.length < 200) matches.push(`${f}:${i + 1}: ${line}`);
+					});
+					if (matches.length >= 200) break;
+				}
+				return { text: bounded(matches.join("\n")) };
+			}
+		},
+		{
+			name: "create_file",
+			description: "Create a new file without overwriting any existing file.",
+			schema: createSchema,
+			mutates: true,
+			async execute(input, ctx) {
+				await requireTrust(ctx);
+				const a = createSchema.parse(input);
+				const f = await safePath(ctx.root, a.path);
+				await mkdir(path.dirname(f), { recursive: true });
+				await safePath(ctx.root, a.path);
+				await writeFile(f, a.content, { flag: "wx" });
+				return {
+					text: createTwoFilesPatch("/dev/null", a.path, "", a.content),
+					data: {
+						hash: hash(a.content),
+						path: a.path
+					}
+				};
+			}
+		},
+		{
+			name: "edit_file",
+			description: "Replace exactly one occurrence of oldText, only if the file still matches expectedHash. Re-read on conflicts.",
+			schema: editSchema,
+			mutates: true,
+			async execute(input, ctx) {
+				await requireTrust(ctx);
+				const a = editSchema.parse(input);
+				const f = await safePath(ctx.root, a.path);
+				const before = await readFile(f, "utf8");
+				if (hash(before) !== a.expectedHash) throw new Error("File changed since it was read. Re-read and reconcile the user changes.");
+				if (before.split(a.oldText).length !== 2) throw new Error("oldText must occur exactly once. Include more context.");
+				const after = before.replace(a.oldText, () => a.newText);
+				const temporary = `${f}.${randomUUID()}.tmp`;
+				try {
+					const { stat } = await import("node:fs/promises");
+					await writeFile(temporary, after, {
+						flag: "wx",
+						mode: (await stat(f)).mode
+					});
+					await safePath(ctx.root, a.path);
+					if (hash(await readFile(f, "utf8")) !== a.expectedHash) throw new Error("Concurrent file change detected; edit not applied.");
+					await rename(temporary, f);
+				} finally {
+					await unlink(temporary).catch(() => {});
+				}
+				return {
+					text: createTwoFilesPatch(a.path, a.path, before, after),
+					data: {
+						path: a.path,
+						hash: hash(after)
+					}
+				};
+			}
+		},
+		{
+			name: "git_diff",
+			description: "Show tracked changes and untracked file names, preserving the current Git state.",
+			schema: z.object({}).strict(),
+			mutates: false,
+			async execute(_input, ctx) {
+				const filters = await execa("git", [
+					"config",
+					"--null",
+					"--name-only",
+					"--get-regexp",
+					"^filter\\..*\\.(clean|smudge|process|required)$"
+				], {
+					cwd: ctx.root,
+					cancelSignal: ctx.signal,
+					reject: false
+				});
+				const gitConfig = ["-c", "core.fsmonitor=false"];
+				for (const key of filters.stdout.split("\0").filter(Boolean)) gitConfig.push("-c", `${key}=${key.endsWith(".required") ? "false" : ""}`);
+				const diff = await execa("git", [
+					...gitConfig,
+					"--no-pager",
+					"diff",
+					"--no-ext-diff",
+					"--no-textconv",
+					"--",
+					".",
+					":!.env*",
+					":!*.pem",
+					":!*.key",
+					":!*.p12",
+					":!.weapp-agent/**",
+					":!.npmrc"
+				], {
+					cwd: ctx.root,
+					cancelSignal: ctx.signal,
+					reject: false
+				});
+				return { text: bounded(`${(await execa("git", [
+					...gitConfig,
+					"status",
+					"--short"
+				], {
+					cwd: ctx.root,
+					cancelSignal: ctx.signal,
+					reject: false
+				})).stdout}\n${diff.stdout}`) };
+			}
+		},
+		{
+			name: "shell",
+			description: "Execute an arbitrary shell command. Always requires exact-command approval; never use it to bypass a denied operation.",
+			schema: shellSchema,
+			mutates: true,
+			async execute(input, ctx) {
+				const a = shellSchema.parse(input);
+				await authorize(ctx, "command", a.command, {
+					root: ctx.root,
+					...a
+				});
+				const result = await execa(a.command, {
+					cwd: ctx.root,
+					shell: true,
+					cancelSignal: ctx.signal,
+					timeout: a.timeoutMs,
+					forceKillAfterDelay: 2e3,
+					reject: false,
+					maxBuffer: 2e6
+				});
+				return {
+					text: bounded(`${result.stdout}\n${result.stderr}`),
+					data: {
+						exitCode: result.exitCode,
+						timedOut: result.timedOut
+					}
+				};
+			}
+		}
+	];
+}
+//#endregion
+//#region ../../packages/mini-program/dist/index.mjs
+async function json(file) {
+	try {
+		return JSON.parse(await readFile(file, "utf8"));
+	} catch {
+		return {};
+	}
+}
+async function findProjectRoot(cwd) {
+	const start = await realpath(cwd);
+	let dir = start;
+	for (;;) {
+		const pkg = await json(path.join(dir, "package.json"));
+		if (await exists(path.join(dir, "weapp-agent.config.json")) || pkg.dependencies?.["weapp-vite"] || pkg.devDependencies?.["weapp-vite"] || await exists(path.join(dir, "project.config.json"))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) return start;
+		dir = parent;
+	}
+}
+async function exists(file) {
+	try {
+		await access(file);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function detectProject(root) {
+	root = await realpath(root);
+	const pkg = await json(path.join(root, "package.json"));
+	const config = await json(path.join(root, "project.config.json"));
+	const dependencies = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	let vite = "";
+	for (const file of [
+		"vite.config.ts",
+		"vite.config.js",
+		"vite.config.mts"
+	]) if (await exists(path.join(root, file))) vite = await readFile(path.join(root, file), "utf8");
+	const sourceRoot = vite.match(/\bsrcRoot\s*:\s*['"]([^'"]+)['"]/)?.[1] ?? (await exists(path.join(root, "src")) ? "src" : ".");
+	const outputRoot = vite.match(/\boutDir\s*:\s*['"]([^'"]+)['"]/)?.[1] ?? config.miniprogramRoot ?? (dependencies["weapp-vite"] ? "dist" : ".");
+	await safePath(root, sourceRoot);
+	await safePath(root, outputRoot);
+	const app = await json(path.join(root, sourceRoot, "app.json"));
+	const sources = [];
+	const scan = async (directory, depth = 0) => {
+		if (depth > 8 || sources.length > 2e3) return;
+		const entries = await readdir(await safePath(root, directory), { withFileTypes: true }).catch(() => []);
+		for (const entry of entries) {
+			if (entry.isSymbolicLink() || entry.name.startsWith(".") || ["node_modules", "dist"].includes(entry.name)) continue;
+			const relative = path.join(directory, entry.name);
+			if (entry.isDirectory()) await scan(relative, depth + 1);
+			else if (/\.(?:vue|wxml)$/.test(entry.name)) sources.push(path.relative(sourceRoot, relative).split(path.sep).join("/"));
+		}
+	};
+	await scan(sourceRoot);
+	const hasVue = sources.some((file) => file.endsWith(".vue"));
+	const hasNative = sources.some((file) => file.endsWith(".wxml"));
+	const warnings = [];
+	if (vite && !/\bsrcRoot\s*:\s*['"]/.test(vite) && !await exists(path.join(root, sourceRoot, "app.json"))) warnings.push("Dynamic Vite configuration: source/output paths are inferred. Check project_info before editing.");
+	return {
+		root,
+		kind: hasVue && Boolean(dependencies.wevu) ? "wevu" : hasNative || dependencies["weapp-vite"] || config.appid || app.pages ? "native" : "unknown",
+		packageManager: String(pkg.packageManager ?? "").startsWith("yarn") ? "yarn" : String(pkg.packageManager ?? "").startsWith("bun") ? "bun" : await exists(path.join(root, "pnpm-lock.yaml")) || await exists(path.join(root, "pnpm-workspace.yaml")) || String(pkg.packageManager ?? "").startsWith("pnpm") ? "pnpm" : "npm",
+		sourceRoot,
+		outputRoot,
+		pages: Array.isArray(app.pages) ? app.pages : sources.filter((file) => file.startsWith("pages/")).map((file) => file.replace(/\.(vue|wxml)$/, "")),
+		subPackages: (app.subPackages ?? app.subpackages ?? []).map((p) => p.root),
+		scripts: pkg.scripts ?? {},
+		weappViteVersion: dependencies["weapp-vite"],
+		warnings
+	};
+}
+function defaultVerification(project) {
+	return [
+		"typecheck",
+		"build",
+		"test"
+	].filter((kind) => project.scripts[kind]).map((kind) => ({
+		kind,
+		command: project.packageManager,
+		args: ["run", kind],
+		timeoutMs: 12e4
+	}));
+}
+async function projectInstructions(project) {
+	const snippets = [];
+	const add = async (file) => {
+		try {
+			const target = await safePath(project.root, file);
+			snippets.push(`Instructions scoped to ${path.dirname(file)} (${file}):\n${bounded(await readFile(target, "utf8"), 12e3)}`);
+		} catch {}
+	};
+	await add("AGENTS.md");
+	await add("AGENTS.local.md");
+	const visit = async (directory, depth) => {
+		if (depth > 6 || snippets.join("").length > 32e3) return;
+		const entries = await readdir(await safePath(project.root, directory), { withFileTypes: true }).catch(() => []);
+		if (directory !== ".") {
+			if (entries.some((e) => e.name === "AGENTS.md")) await add(path.join(directory, "AGENTS.md"));
+			if (entries.some((e) => e.name === "AGENTS.local.md")) await add(path.join(directory, "AGENTS.local.md"));
+		}
+		for (const e of entries) if (e.isDirectory() && !e.isSymbolicLink() && !e.name.startsWith(".") && ![
+			"node_modules",
+			"dist",
+			"coverage"
+		].includes(e.name)) await visit(path.join(directory, e.name), depth + 1);
+	};
+	await visit(".", 0);
+	const docs = path.join(project.root, "node_modules/weapp-vite/dist/docs");
+	const names = await readdir(docs).catch(() => []);
+	for (const name of names.filter((n) => /^(?:README|ai|cli|getting-started|configuration).*\.md$/i.test(n)).slice(0, 4)) snippets.push(`Installed weapp-vite documentation (${name}):\n${bounded(await readFile(path.join(docs, name), "utf8"), 6e3)}`);
+	return `Project facts:\n${JSON.stringify(project)}\n${snippets.join("\n\n")}`;
+}
+const projectRuntime = /* @__PURE__ */ new Set([
+	"weapp_devtools_connect",
+	"weapp_devtools_active_page",
+	"weapp_devtools_page_stack",
+	"weapp_devtools_route",
+	"weapp_devtools_capture",
+	"weapp_devtools_console",
+	"weapp_runtime_find_node",
+	"weapp_runtime_find_nodes",
+	"weapp_runtime_wait_node",
+	"weapp_runtime_find_node_by_xpath",
+	"weapp_runtime_find_nodes_by_xpath",
+	"weapp_runtime_page_state",
+	"weapp_runtime_tap_node",
+	"weapp_runtime_input_node",
+	"weapp_runtime_component_state",
+	"weapp_runtime_find_child",
+	"weapp_runtime_find_children",
+	"weapp_runtime_node_markup",
+	"weapp_runtime_node_styles",
+	"weapp_runtime_node_attrs",
+	"weapp_runtime_measure_node"
+]);
+async function connectMcp(server, context, options) {
+	const unchanged = options && await projectFingerprint(context.root, options.config) === options.fingerprint;
+	if (!context.trusted || !unchanged) await authorize(context, "mcp", `Connect MCP ${server.name}`, server);
+	const client = new Client({
+		name: "weapp-agent",
+		version: "0.1.0-preview.1"
+	}, { capabilities: {} });
+	let transport;
+	if (server.transport === "stdio") transport = new StdioClientTransport({
+		command: server.command,
+		args: server.args,
+		cwd: context.root,
+		stderr: "pipe"
+	});
+	else {
+		const url = new URL(server.url);
+		if (url.protocol !== "https:" && ![
+			"localhost",
+			"127.0.0.1",
+			"[::1]"
+		].includes(url.hostname)) throw new Error("Remote MCP requires HTTPS");
+		const token = server.tokenEnv ? process.env[server.tokenEnv] : void 0;
+		if (server.tokenEnv && !token) throw new Error(`Set ${server.tokenEnv} for MCP authentication`);
+		transport = new StreamableHTTPClientTransport(url, { requestInit: token ? { headers: { Authorization: `Bearer ${token}` } } : {} });
+	}
+	try {
+		await client.connect(transport, { timeout: 15e3 });
+		const tools = [];
+		let cursor;
+		do {
+			const page = await client.listTools(cursor ? { cursor } : {}, {
+				signal: context.signal,
+				timeout: 15e3
+			});
+			for (const definition of page.tools) {
+				const schema = z.fromJSONSchema(definition.inputSchema);
+				const name = `${server.name}__${definition.name}`;
+				if (name.length > 64) throw new Error(`MCP tool name too long: ${name}`);
+				tools.push({
+					name,
+					description: definition.description ?? definition.name,
+					schema,
+					mutates: true,
+					async execute(input, ctx) {
+						const args = schema.parse(input);
+						const trustedRuntime = options?.builtin && ctx.trusted && projectRuntime.has(definition.name) && args.port === void 0 && args.sessionId === void 0 && args.preferOpenedSession !== true && await projectFingerprint(ctx.root, options.config) === options.fingerprint;
+						if (!trustedRuntime) await authorize(ctx, /upload|publish|deploy/.test(definition.name) ? "publish" : "mcp", `${name}: ${JSON.stringify(args)}`, {
+							server,
+							tool: definition.name,
+							args
+						});
+						if (trustedRuntime) {
+							for (const key of ["projectPath", "outputPath"]) if (typeof args[key] === "string") await safePath(ctx.root, args[key]);
+						}
+						const response = await client.callTool({
+							name: definition.name,
+							arguments: args
+						}, void 0, {
+							signal: ctx.signal,
+							timeout: 12e4
+						});
+						const content = Array.isArray(response.content) ? response.content : [];
+						const text = bounded(content.filter((c) => c.type === "text").map((c) => c.text).join("\n"));
+						if (response.isError) throw new Error(text || `MCP tool failed: ${name}`);
+						return {
+							text,
+							images: content.filter((c) => c.type === "image" && c.data && c.mimeType).map((c) => ({
+								type: "image",
+								data: c.data,
+								mediaType: c.mimeType
+							})),
+							data: response.structuredContent
+						};
+					}
+				});
+			}
+			cursor = page.nextCursor;
+		} while (cursor);
+		return {
+			tools,
+			close: () => client.close()
+		};
+	} catch (error) {
+		await client.close().catch(() => {});
+		throw error;
+	}
+}
+async function verifyProject(config, context, originalFingerprint) {
+	await requireTrust(context);
+	const checks = [];
+	for (const command of config.verification) {
+		context.signal.throwIfAborted();
+		const current = await projectFingerprint(context.root, config);
+		if (current !== originalFingerprint || /publish|upload|deploy/i.test([command.command, ...command.args].join(" "))) await authorize(context, "command", `Verify: ${command.command} ${command.args.join(" ")}`, {
+			command,
+			fingerprint: current
+		});
+		const result = await execa(command.command, command.args, {
+			cwd: context.root,
+			cancelSignal: context.signal,
+			timeout: command.timeoutMs,
+			forceKillAfterDelay: 2e3,
+			reject: false,
+			maxBuffer: 2e6
+		});
+		checks.push({
+			kind: command.kind,
+			status: result.exitCode === 0 ? "passed" : "failed",
+			command: `${command.command} ${command.args.join(" ")}`,
+			exitCode: result.exitCode,
+			output: bounded(`${result.stdout}\n${result.stderr}`)
+		});
+	}
+	for (const kind of [
+		"typecheck",
+		"build",
+		"test",
+		"devtools"
+	]) if (!checks.some((c) => c.kind === kind)) checks.push({
+		kind,
+		status: "unverified",
+		output: kind === "devtools" ? "No real DevTools verification command configured. Web preview is not WeChat runtime evidence." : "No verification command configured."
+	});
+	return {
+		passed: checks.some((c) => c.status === "passed") && !checks.some((c) => c.status === "failed"),
+		checks
+	};
+}
+function verificationTool(config, fingerprint) {
+	return {
+		name: "verify_project",
+		description: "Run configured typecheck/build/test/DevTools commands and return separate passed, failed and unverified results. Fix failures, then rerun. Missing checks are never considered passed.",
+		schema: z.object({}).strict(),
+		mutates: true,
+		async execute(_input, context) {
+			const report = await verifyProject(config, context, fingerprint);
+			return {
+				text: JSON.stringify(report, null, 2),
+				data: report
+			};
+		}
+	};
+}
+var WeappProjectAdapter = class {
+	detect = detectProject;
+	instructions = projectInstructions;
+	async tools(project) {
+		return [{
+			name: "project_info",
+			description: "Inspect the current mini-program project structure, scripts and framework. Re-check after changing project configuration.",
+			schema: z.object({}).strict(),
+			mutates: false,
+			async execute() {
+				return { text: JSON.stringify(await detectProject(project.root), null, 2) };
+			}
+		}];
+	}
+};
+async function builtinMcp(root) {
+	const bin = path.join(root, "node_modules/weapp-vite/bin/weapp-vite.js");
+	if (!await exists(bin)) return;
+	return {
+		name: "weapp",
+		transport: "stdio",
+		command: process.execPath,
+		args: [
+			bin,
+			"mcp",
+			"--workspace-root",
+			root
+		]
+	};
+}
+//#endregion
+//#region ../../packages/providers/dist/index.mjs
+function toModelMessages(messages) {
+	return messages.map((message) => {
+		if (message.role === "user") return {
+			role: "user",
+			content: [{
+				type: "text",
+				text: message.text
+			}, ...(message.images ?? []).map((image) => ({
+				type: "image",
+				image: image.data,
+				mediaType: image.mediaType
+			}))]
+		};
+		if (message.role === "assistant") return {
+			role: "assistant",
+			content: [...message.text ? [{
+				type: "text",
+				text: message.text
+			}] : [], ...(message.calls ?? []).map((call) => ({
+				type: "tool-call",
+				toolCallId: call.id,
+				toolName: call.name,
+				input: call.input
+			}))]
+		};
+		const text = message.result.data === void 0 ? message.result.text : `${message.result.text}\n${JSON.stringify(message.result.data)}`;
+		return {
+			role: "tool",
+			content: [{
+				type: "tool-result",
+				toolCallId: message.callId,
+				toolName: message.name,
+				output: message.result.images?.length ? {
+					type: "content",
+					value: [{
+						type: "text",
+						text
+					}, ...message.result.images.map((image) => ({
+						type: "file",
+						data: {
+							type: "data",
+							data: image.data
+						},
+						mediaType: image.mediaType
+					}))]
+				} : {
+					type: message.error ? "error-text" : "text",
+					value: text
+				}
+			}]
+		};
+	});
+}
+var AiSdkAdapter = class {
+	id;
+	model;
+	constructor(id, model) {
+		this.id = id;
+		this.model = model;
+	}
+	async *stream(request) {
+		const tools = Object.fromEntries(request.tools.map((t) => [t.name, tool({
+			description: t.description,
+			inputSchema: jsonSchema(t.schema)
+		})]));
+		const result = streamText({
+			model: this.model,
+			system: request.system,
+			messages: toModelMessages(request.messages),
+			tools,
+			abortSignal: request.signal,
+			maxRetries: 2,
+			onError: () => {},
+			maxOutputTokens: 8192
+		});
+		for await (const part of result.fullStream) {
+			if (part.type === "text-delta") yield {
+				type: "text",
+				text: part.text
+			};
+			if (part.type === "tool-call") yield {
+				type: "call",
+				call: {
+					id: part.toolCallId,
+					name: part.toolName,
+					input: part.input
+				}
+			};
+			if (part.type === "finish") yield {
+				type: "usage",
+				inputTokens: part.totalUsage.inputTokens ?? 0,
+				outputTokens: part.totalUsage.outputTokens ?? 0
+			};
+			if (part.type === "error") throw part.error;
+			if (part.type === "abort") throw new Error("Model request cancelled");
+		}
+	}
+};
+function apiKeyVariable(config) {
+	return config.apiKeyEnv ?? (config.provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY");
+}
+function createModel(config, environment = process.env) {
+	const variable = apiKeyVariable(config);
+	const apiKey = environment[variable];
+	if (!apiKey) throw new Error(`Set ${variable} in your environment. Credentials are never read from other agents or stored in project config.`);
+	let model;
+	if (config.provider === "anthropic") model = createAnthropic({
+		apiKey,
+		baseURL: config.baseURL
+	})(config.name);
+	else if (config.provider === "openai-compatible") {
+		if (!config.baseURL) throw new Error("openai-compatible requires model.baseURL");
+		model = createOpenAICompatible({
+			name: "weapp-compatible",
+			apiKey,
+			baseURL: config.baseURL
+		})(config.name);
+	} else model = createOpenAI({
+		apiKey,
+		baseURL: config.baseURL
+	}).responses(config.name);
+	return new AiSdkAdapter(`${config.provider}/${config.name}`, model);
+}
+//#endregion
+//#region src/ui.tsx
+function eventText(event) {
+	if (event.type === "text.delta") return String(event.data.text);
+	if (event.type === "tool.started") return `\n↳ ${event.data.name}\n`;
+	if (event.type === "tool.completed") {
+		const result = event.data.result;
+		const edit = ["edit_file", "create_file"].includes(String(event.data.name));
+		return `${event.data.error ? "✗" : "✓"} ${event.data.name}${edit || event.data.error ? `\n${result.text?.slice(0, 5e3)}` : ""}\n`;
+	}
+	if (event.type === "context.compacted") return "\n· Earlier context summarized\n";
+	if (event.type === "run.completed") return `\n[${event.data.status}]\n`;
+	return "";
+}
+function App({ runner, initialSession }) {
+	const { exit } = useApp();
+	const [input, setInput] = useState("");
+	const [transcript, setTranscript] = useState("Describe a mini-program change. /exit to quit. Esc cancels a running task.\n");
+	const [busy, setBusy] = useState(false);
+	const [session, setSession] = useState(initialSession);
+	const [pending, setPending] = useState();
+	const answer = useRef(() => {});
+	const controller = useRef(void 0);
+	const append = (text) => setTranscript((previous) => (previous + text).slice(-3e4));
+	useInput((value, key) => {
+		if (key.ctrl && value === "c") {
+			if (busy) controller.current?.abort();
+			else exit();
+			return;
+		}
+		if (key.escape && busy) controller.current?.abort();
+		if (pending && ["y", "n"].includes(value.toLowerCase())) {
+			answer.current(value.toLowerCase() === "y");
+			setPending(void 0);
+		}
+	});
+	const submit = async (prompt) => {
+		if (!prompt.trim() || busy) return;
+		if (prompt.trim() === "/exit") {
+			exit();
+			return;
+		}
+		setInput("");
+		setBusy(true);
+		append(`\nYou › ${prompt}\n\n`);
+		const abort = new AbortController();
+		controller.current = abort;
+		const approve = (request) => new Promise((resolve) => {
+			setPending(request);
+			const stop = () => {
+				setPending(void 0);
+				resolve(false);
+			};
+			abort.signal.addEventListener("abort", stop, { once: true });
+			answer.current = (value) => {
+				abort.signal.removeEventListener("abort", stop);
+				resolve(value);
+			};
+		});
+		try {
+			const result = await runner(prompt, session, abort.signal, (event) => {
+				append(eventText(event));
+				if (event.type === "run.started") setSession(event.sessionId);
+			}, approve);
+			setSession(result.sessionId);
+			if (result.status !== "completed") append(`${result.text}\n`);
+		} catch (error) {
+			append(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
+		} finally {
+			setBusy(false);
+			setPending(void 0);
+		}
+	};
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		paddingX: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Box, {
+				gap: 2,
+				children: [/* @__PURE__ */ jsx(Text, {
+					bold: true,
+					color: "cyan",
+					children: "WEAPP AGENT"
+				}), /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: session ? `session ${session}` : "mini-program development"
+				})]
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				borderStyle: "single",
+				borderColor: "gray",
+				paddingX: 1,
+				flexDirection: "column",
+				children: /* @__PURE__ */ jsx(Text, { children: transcript })
+			}),
+			pending ? /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				children: [
+					/* @__PURE__ */ jsxs(Text, {
+						color: "yellow",
+						children: ["Approval ·", pending.kind]
+					}),
+					/* @__PURE__ */ jsx(Text, { children: pending.summary }),
+					/* @__PURE__ */ jsx(Text, { children: "Allow this exact operation? [y/n]" })
+				]
+			}) : busy ? /* @__PURE__ */ jsx(Text, {
+				color: "cyan",
+				children: "Working… Esc to cancel"
+			}) : /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+				color: "cyan",
+				children: "› "
+			}), /* @__PURE__ */ jsx(TextInput, {
+				value: input,
+				onChange: setInput,
+				onSubmit: submit
+			})] })
+		]
+	});
+}
+async function interactive(runner, initialSession) {
+	await render(/* @__PURE__ */ jsx(App, {
+		runner,
+		initialSession
+	}), { exitOnCtrlC: false }).waitUntilExit();
+}
+//#endregion
+//#region src/index.ts
+const clean = redactor();
+const program = new Command().name("weapp-agent").description("AI coding agent for WeChat mini-programs").version("0.1.0-preview.1").option("-C, --cwd <directory>", "project directory", process.cwd()).option("--trust", "trust this exact project configuration and scripts").option("--json", "emit machine-readable JSON; disable interactive approvals");
+async function terminalApproval(summary) {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+	const reader = createInterface({
+		input: process.stdin,
+		output: process.stderr
+	});
+	try {
+		return /^y(?:es)?$/i.test((await reader.question(`${summary}\nAllow? [y/N] `)).trim());
+	} finally {
+		reader.close();
+	}
+}
+const approve = (request) => terminalApproval(clean(request.summary));
+function output(value, json) {
+	process.stdout.write(`${clean(json ? JSON.stringify(value) : typeof value === "string" ? value : JSON.stringify(value, null, 2))}\n`);
+}
+async function configAndTrust(root, options, approver) {
+	const config = await loadConfig(root);
+	const fingerprint = await projectFingerprint(root, config);
+	let trusted = await isTrusted(root, fingerprint);
+	if (options.trust) {
+		await trustProject(root, fingerprint);
+		trusted = true;
+	} else if (!trusted && !options.json) {
+		if (await approver({
+			kind: "trust",
+			summary: `Trust ${root}?\nThis permits local edits, configured scripts and MCP server startup.\n${JSON.stringify({
+				verification: config.verification,
+				mcp: config.mcp
+			}, null, 2)}`,
+			fingerprint
+		})) {
+			await trustProject(root, fingerprint);
+			trusted = true;
+		}
+	}
+	return {
+		config,
+		fingerprint,
+		trusted
+	};
+}
+async function images(files) {
+	return Promise.all(files.map(async (file) => {
+		const data = await readFile(path.resolve(file));
+		if (data.length > 10485760) throw new Error(`Image exceeds 10 MB: ${file}`);
+		const type = data.subarray(0, 8).equals(Buffer.from([
+			137,
+			80,
+			78,
+			71,
+			13,
+			10,
+			26,
+			10
+		])) ? "image/png" : data[0] === 255 && data[1] === 216 ? "image/jpeg" : data.subarray(8, 12).toString() === "WEBP" ? "image/webp" : void 0;
+		if (!type) throw new Error(`Use a PNG, JPEG or WebP image: ${file}`);
+		return {
+			type: "image",
+			data: data.toString("base64"),
+			mediaType: type
+		};
+	}));
+}
+async function execute(prompt, options, sessionId, suppliedSignal, onEvent, approver = approve) {
+	const root = await findProjectRoot(options.cwd);
+	const selectedApprover = options.json ? async () => false : approver;
+	const { config, fingerprint, trusted } = await configAndTrust(root, options, selectedApprover);
+	const model = createModel(config.model);
+	const adapter = new WeappProjectAdapter();
+	const project = await adapter.detect(root);
+	const abort = new AbortController();
+	const stop = () => abort.abort();
+	if (!suppliedSignal) process.once("SIGINT", stop);
+	const signal = suppliedSignal ?? abort.signal;
+	const context = {
+		root,
+		trusted,
+		approve: selectedApprover,
+		signal
+	};
+	const connections = [];
+	const warnings = [];
+	try {
+		const tools = [
+			...fileTools(),
+			...await adapter.tools(project),
+			verificationTool(config, fingerprint)
+		];
+		const automatic = trusted ? await builtinMcp(root) : void 0;
+		const servers = [...config.mcp, ...automatic && !config.mcp.some((s) => s.name === automatic.name) ? [automatic] : []];
+		for (const server of servers) try {
+			const connection = await connectMcp(server, context, {
+				config,
+				fingerprint,
+				builtin: server === automatic
+			});
+			connections.push(connection);
+			tools.push(...connection.tools);
+		} catch (error) {
+			warnings.push(`MCP ${server.name} unavailable: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		return await runAgent({
+			root,
+			config,
+			model,
+			tools,
+			prompt,
+			images: await images(options.image ?? []),
+			sessionId,
+			signal,
+			trusted,
+			approve: selectedApprover,
+			acknowledgeInterrupted: options.acknowledgeInterrupted,
+			system: `${await adapter.instructions(project)}\nUnavailable capabilities:\n${warnings.join("\n")}`,
+			onEvent: async (event) => {
+				if (onEvent) onEvent(event);
+				else if (options.json) output(event, true);
+				else {
+					if (event.type === "run.started") process.stderr.write(`Session: ${event.sessionId}\n${warnings.join("\n")}\n`);
+					process.stdout.write(clean(eventText(event)));
+				}
+			}
+		});
+	} finally {
+		if (!suppliedSignal) process.removeListener("SIGINT", stop);
+		await Promise.allSettled(connections.map((c) => c.close()));
+	}
+}
+function exitFor(status) {
+	process.exitCode = {
+		completed: 0,
+		failed: 1,
+		action_required: 2,
+		limit_reached: 3,
+		cancelled: 130
+	}[status] ?? 1;
+}
+program.command("init").description("Configure an existing project, or scaffold one with --create").argument("[directory]", "target directory").option("--create", "create a new weapp-vite project; target must not exist").addOption(new Option("--template <template>", "new project template").choices(["wevu", "native"]).default("wevu")).addOption(new Option("--provider <provider>", "model provider").choices([
+	"openai",
+	"anthropic",
+	"openai-compatible"
+]).default("openai")).requiredOption("--model <model>", "model identifier; no hard-coded model default").option("--base-url <url>", "custom provider endpoint").option("--api-key-env <name>", "environment variable containing the API key").action(async (directory, local, command) => {
+	const opts = command.optsWithGlobals();
+	const root = path.resolve(directory ?? opts.cwd);
+	if (local.create) {
+		if (await exists(root)) throw new Error("Creation target already exists; refusing to overwrite it.");
+		await execa("pnpm", [
+			"dlx",
+			"create-weapp-vite@3.0.1",
+			root,
+			local.template === "native" ? "default" : "wevu",
+			"--no-install-skills"
+		], { stdio: opts.json ? [
+			"ignore",
+			"pipe",
+			"pipe"
+		] : "inherit" });
+	} else await mkdir(root, { recursive: true });
+	const project = await detectProject(root);
+	const config = configSchema.parse({
+		model: {
+			provider: local.provider,
+			name: local.model,
+			baseURL: local.baseUrl,
+			apiKeyEnv: local.apiKeyEnv
+		},
+		verification: defaultVerification(project)
+	});
+	await writeFile(path.join(root, configFilename), `${JSON.stringify(config, null, 2)}\n`, { flag: "wx" });
+	output({
+		status: "created",
+		root,
+		config: configFilename,
+		next: `Set ${apiKeyVariable(config.model)}, install project dependencies, then run weapp-agent --trust.`
+	}, opts.json);
+});
+program.command("run").description("Run a single task").argument("<prompt>").option("--image <file...>", "reference screenshots").action(async (prompt, _local, command) => {
+	const options = command.optsWithGlobals();
+	const result = await execute(prompt, options);
+	if (!options.json && result.status !== "completed") output(result.text, false);
+	exitFor(result.status);
+});
+program.command("resume").description("Resume a saved session without replaying completed tools").argument("<session>").argument("[prompt]", "follow-up task", "Continue the task after inspecting the current project state.").option("--acknowledge-interrupted", "confirm inspection of interrupted tool outcomes; do not replay them").option("--image <file...>").action(async (session, prompt, _local, command) => {
+	const options = command.optsWithGlobals();
+	const result = await execute(prompt, options, session);
+	if (!options.json && result.status !== "completed") output(result.text, false);
+	exitFor(result.status);
+});
+program.command("sessions").description("List sessions for this project").action(async (_local, command) => {
+	const opts = command.optsWithGlobals();
+	output(await Session.list(await findProjectRoot(opts.cwd)), opts.json);
+});
+program.command("doctor").description("Inspect configuration and local prerequisites without calling a model").action(async (_local, command) => {
+	const opts = command.optsWithGlobals();
+	const root = await findProjectRoot(opts.cwd);
+	const project = await detectProject(root);
+	let config;
+	let configError;
+	try {
+		config = await loadConfig(root);
+	} catch (error) {
+		configError = String(error);
+	}
+	const key = config ? apiKeyVariable(config.model) : void 0;
+	output({
+		root,
+		node: process.version,
+		project,
+		config: config ? "valid" : configError,
+		apiKey: key ? {
+			variable: key,
+			present: Boolean(process.env[key])
+		} : null,
+		localMcp: Boolean(await builtinMcp(root)),
+		stateDirectory: stateRoot(),
+		devtools: "unverified: use a real DevTools verification command",
+		trusted: config ? await isTrusted(root, await projectFingerprint(root, config)) : false
+	}, opts.json);
+	if (!config) process.exitCode = 1;
+});
+program.command("verify").description("Run configured checks and report unverified categories").action(async (_local, command) => {
+	const opts = command.optsWithGlobals();
+	const root = await findProjectRoot(opts.cwd);
+	const { config, fingerprint, trusted } = await configAndTrust(root, opts, approve);
+	const abort = new AbortController();
+	const stop = () => abort.abort();
+	process.once("SIGINT", stop);
+	try {
+		const result = await verifyProject(config, {
+			root,
+			trusted,
+			signal: abort.signal,
+			approve: opts.json ? async () => false : approve
+		}, fingerprint);
+		output(result, opts.json);
+		if (!result.passed) process.exitCode = 1;
+	} finally {
+		process.removeListener("SIGINT", stop);
+	}
+});
+program.action(async () => {
+	const options = program.opts();
+	if (!process.stdin.isTTY || options.json) throw new Error("Interactive mode requires a TTY. Use weapp-agent run <prompt> --json for automation.");
+	let trustOnce = options.trust;
+	await interactive((prompt, session, signal, onEvent, approval) => {
+		const current = {
+			...options,
+			trust: trustOnce
+		};
+		trustOnce = false;
+		return execute(prompt, current, session, signal, onEvent, approval);
+	});
+});
+try {
+	await program.parseAsync();
+} catch (error) {
+	const message = clean(error instanceof Error ? error.message : String(error));
+	if (process.argv.includes("--json")) output({
+		version: 1,
+		type: "error",
+		data: { message }
+	}, true);
+	else process.stderr.write(`${message}\n`);
+	process.exitCode = error instanceof Error && error.name === "ApprovalRequired" ? 2 : 1;
+}
+//#endregion
+export {};