@donezone/cli 0.1.15 → 0.1.27

package/dist/index.js

@@ -3,256 +3,267 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import * as fs from "node:fs/promises";
 import path from "node:path";
+import chokidar from "chokidar";
+import pc from "picocolors";
 import { Command } from "commander";
+import { DoneBackendClient } from "@donezone/client";
+import { DoneLocalChain, deployJsContract } from "@donezone/local-chain";
+import { createDoneHttpLocalServer } from "@donezone/http-local";
+import { createDoneEventsLocalServer } from "@donezone/events-local";
 const DEFAULT_TEMPLATE_REPO = "https://github.com/mccallofthewild/done-template.git";
-const program = new Command();
+const program = new Command;
 program.name("done").description("Done developer toolkit (spec-first stub)").version("0.0.0-spec");
-/* NOTE: All of these commands should be expected to be run from a standalone binary, not from the context of this repository / workspace. */
-program
-    .command("build")
-    .description("Bundle Done contracts defined in done.json")
-    .option("-j, --contracts <path>", "Path to done.json")
-    .option("-n, --name <name...>", "Filter contract names")
-    .action(async (options) => {
-    try {
-        await handleBuild(options);
-    }
-    catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
+program.command("build").description("Bundle Done contracts defined in done.json").option("-j, --contracts <path>", "Path to done.json").option("-n, --name <name...>", "Filter contract names").action(async (options) => {
+  try {
+    await handleBuild(options);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
 });
-program
-    .command("dev")
-    .description("Launch frontend dev server plus Done HTTP Local backend, watch sources, rebuild & redeploy contracts automatically")
-    .option("-b, --backend", "Run backend only")
-    .action(() => notImplemented("dev"));
-program
-    .command("init")
-    .argument("[name]", "Project or contract name")
-    .option("-f, --force", "Overwrite existing files if they already exist")
-    .option("--template <repoOrPath>", "Template git repo or local folder (defaults to official Done template)")
-    .option("--no-install", "Skip Bun install after creating a brand new workspace")
-    .description("Set up a new Done workspace or add a contract to an existing workspace")
-    .action(async (rawName, options) => {
-    try {
-        await handleInit(rawName, options);
-    }
-    catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
+program.command("dev").description("Boot Done local chain + HTTP + events stack with live publish_code reloads and optional frontend dev server").option("--backend", "Start backend services (done-local-chain, done-http-local, done-events-local)").option("--frontend", "Start the frontend dev server").action(async (options) => {
+  try {
+    await handleDev(options);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
 });
-program
-    .command("deploy")
-    .description("Deploy latest bundles to the configured Done workspace")
-    .option("-e, --env <profile>", "Environment/profile name")
-    .option("-f, --fresh", "Force rebuild before deploy")
-    .action(() => notImplemented("deploy"));
-program
-    .command("test")
-    .description("Run unit tests for contracts");
-program.parseAsync().catch((error) => {
+program.command("init").argument("[name]", "Project or contract name").option("-f, --force", "Overwrite existing files if they already exist").option("--template <repoOrPath>", "Template git repo or local folder (defaults to official Done template)").option("--no-install", "Skip Bun install after creating a brand new workspace").description("Set up a new Done workspace or add a contract to an existing workspace").action(async (rawName, options) => {
+  try {
+    await handleInit(rawName, options);
+  } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
+  }
 });
-function notImplemented(label) {
-    console.error(`The command segment '${label}' is not implemented yet.\nSee packages/done-cli/SPEC.md for the planned behaviour.`);
+program.command("deploy").description("Deploy latest bundles to the configured Done workspace").option("-e, --env <profile>", "Environment/profile name").option("-f, --fresh", "Force rebuild before deploy").action(() => notImplemented("deploy"));
+program.command("test").description("Run unit tests for contracts").action(() => notImplemented("test"));
+program.command("publish").description("Publish a new JS bundle to an existing Done contract via Done HTTP").requiredOption("-c, --contract <address>", "Target Done contract address").requiredOption("-s, --script <path>", "Path to bundled JS module").option("-m, --msg <jsonOrPath>", "Inline JSON payload or path to migrate message").option("--http <url>", "Done HTTP base URL (defaults to DONE_HTTP or http://localhost:3000)").action(async (options) => {
+  try {
+    await handlePublish(options);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
+  }
+});
+program.parseAsync().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});
+function notImplemented(label) {
+  console.error(`The command segment '${label}' is not implemented yet.\nSee packages/done-cli/SPEC.md for the planned behaviour.`);
+  process.exit(1);
 }
 async function handleInit(rawName, options) {
-    const cwd = process.cwd();
-    const workspace = await detectWorkspace(cwd);
-    if (workspace) {
-        if (!rawName) {
-            throw new Error("Contract name is required when running init inside an existing Done workspace.");
-        }
-        await scaffoldContract(workspace, rawName, options);
-        return;
-    }
+  const cwd = process.cwd();
+  const workspace = await detectWorkspace(cwd);
+  if (workspace) {
     if (!rawName) {
-        throw new Error("Project name is required when creating a brand new Done workspace.");
+      throw new Error("Contract name is required when running init inside an existing Done workspace.");
     }
-    await scaffoldWorkspace(rawName, options);
+    await scaffoldContract(workspace, rawName, options);
+    return;
+  }
+  if (!rawName) {
+    throw new Error("Project name is required when creating a brand new Done workspace.");
+  }
+  await scaffoldWorkspace(rawName, options);
 }
 async function handleBuild(options) {
-    const manifestInfo = await resolveManifest(options.contracts);
-    const contracts = manifestInfo.manifest.contracts ?? [];
-    if (contracts.length === 0) {
-        throw new Error(`No contracts defined in ${path.relative(process.cwd(), manifestInfo.manifestPath) || manifestInfo.manifestPath}`);
-    }
-    const filters = (options.name ?? [])
-        .flatMap((pattern) => pattern.split(","))
-        .map((pattern) => pattern.trim())
-        .filter(Boolean);
-    const matchers = filters.map(createGlobMatcher);
-    const selected = matchers.length === 0
-        ? contracts
-        : contracts.filter((contract) => matchesContract(contract, manifestInfo.manifestDir, matchers));
-    if (selected.length === 0) {
-        throw new Error(`No contracts matched filters: ${filters.join(", ")}`);
-    }
-    console.log(`Building ${selected.length} contract${selected.length === 1 ? "" : "s"} from ${path.relative(process.cwd(), manifestInfo.manifestPath) || manifestInfo.manifestPath}`);
-    for (const contract of selected) {
-        if (!contract.entry) {
-            throw new Error(`Contract '${contract.name}' is missing an 'entry' path in ${manifestInfo.manifestPath}`);
-        }
-        if (!contract.outFile) {
-            throw new Error(`Contract '${contract.name}' is missing an 'outFile' path in ${manifestInfo.manifestPath}`);
-        }
-        const entryPath = path.resolve(manifestInfo.manifestDir, contract.entry);
-        const outFilePath = path.resolve(manifestInfo.manifestDir, contract.outFile);
-        await ensureEntryExists(entryPath, contract.name);
-        await fs.mkdir(path.dirname(outFilePath), { recursive: true });
-        const relEntry = path.relative(process.cwd(), entryPath) || entryPath;
-        const relOutFile = path.relative(process.cwd(), outFilePath) || outFilePath;
-        console.log(`- bundling ${contract.name} (${relEntry})`);
-        const startedAt = Date.now();
-        try {
-            await runBunBuild(entryPath, outFilePath);
-        }
-        catch (error) {
-            console.error(`[error] failed to build ${contract.name}`);
-            throw error;
-        }
-        const duration = Date.now() - startedAt;
-        console.log(`  [done] ${contract.name} -> ${relOutFile} (${formatDuration(duration)})`);
+  const manifestInfo = await resolveManifest(options.contracts);
+  const contracts = manifestInfo.manifest.contracts ?? [];
+  if (contracts.length === 0) {
+    throw new Error(`No contracts defined in ${path.relative(process.cwd(), manifestInfo.manifestPath) || manifestInfo.manifestPath}`);
+  }
+  const filters = (options.name ?? []).flatMap((pattern) => pattern.split(",")).map((pattern) => pattern.trim()).filter(Boolean);
+  const matchers = filters.map(createGlobMatcher);
+  const selected = matchers.length === 0 ? contracts : contracts.filter((contract) => matchesContract(contract, manifestInfo.manifestDir, matchers));
+  if (selected.length === 0) {
+    throw new Error(`No contracts matched filters: ${filters.join(", ")}`);
+  }
+  console.log(`Building ${selected.length} contract${selected.length === 1 ? "" : "s"} from ${path.relative(process.cwd(), manifestInfo.manifestPath) || manifestInfo.manifestPath}`);
+  for (const contract of selected) {
+    if (!contract.entry) {
+      throw new Error(`Contract '${contract.name}' is missing an 'entry' path in ${manifestInfo.manifestPath}`);
+    }
+    if (!contract.outFile) {
+      throw new Error(`Contract '${contract.name}' is missing an 'outFile' path in ${manifestInfo.manifestPath}`);
     }
+    const entryPath = path.resolve(manifestInfo.manifestDir, contract.entry);
+    const outFilePath = path.resolve(manifestInfo.manifestDir, contract.outFile);
+    await ensureEntryExists(entryPath, contract.name);
+    await fs.mkdir(path.dirname(outFilePath), { recursive: true });
+    const relEntry = path.relative(process.cwd(), entryPath) || entryPath;
+    const relOutFile = path.relative(process.cwd(), outFilePath) || outFilePath;
+    console.log(`- bundling ${contract.name} (${relEntry})`);
+    const startedAt = Date.now();
+    try {
+      await runBunBuild(entryPath, outFilePath);
+    } catch (error) {
+      console.error(`[error] failed to build ${contract.name}`);
+      throw error;
+    }
+    const duration = Date.now() - startedAt;
+    console.log(`  [done] ${contract.name} -> ${relOutFile} (${formatDuration(duration)})`);
+  }
+}
+async function handlePublish(options) {
+  const scriptPath = path.resolve(process.cwd(), options.script);
+  await ensureFileExists(scriptPath, "script");
+  const script = await fs.readFile(scriptPath, "utf8");
+  const msg = options.msg ? await loadMsgPayload(options.msg) : undefined;
+  const baseUrl = resolveDoneHttpBase(options.http);
+  const backend = new DoneBackendClient({ baseUrl });
+  console.log(`Publishing ${path.basename(scriptPath)} to ${options.contract} via ${baseUrl}`);
+  const result = await backend.publishCode({
+    contract: options.contract,
+    script,
+    msg
+  });
+  console.log(`  [tx] ${result.transactionHash ?? "(pending)"}`);
+  console.log(`  [height] ${result.height}`);
+  if (typeof result.gasUsed === "number") {
+    console.log(`  [gas] ${result.gasUsed}`);
+  }
+  if (result.data !== undefined) {
+    console.log(`  [data] ${JSON.stringify(result.data)}`);
+  }
 }
 async function detectWorkspace(root) {
-    const manifestPath = path.join(root, "done.json");
-    const configPath = path.join(root, "done.config.json");
-    if (!existsSync(manifestPath) || !existsSync(configPath)) {
-        return null;
-    }
-    const [manifestRaw, configRaw] = await Promise.all([
-        fs.readFile(manifestPath, "utf8"),
-        fs.readFile(configPath, "utf8"),
-    ]);
-    const manifest = JSON.parse(manifestRaw);
-    const config = JSON.parse(configRaw);
-    return { root, manifestPath, configPath, manifest, config };
+  const configPath = path.join(root, "done.config.json");
+  if (!existsSync(configPath)) {
+    return null;
+  }
+  const configRaw = await fs.readFile(configPath, "utf8");
+  const config = JSON.parse(configRaw);
+  const configuredManifestPath = config.contractsFile ? path.isAbsolute(config.contractsFile) ? config.contractsFile : path.resolve(root, config.contractsFile) : path.join(root, "done.json");
+  const fallbackManifestPath = path.join(root, "done.json");
+  const manifestPath = existsSync(configuredManifestPath) ? configuredManifestPath : existsSync(fallbackManifestPath) ? fallbackManifestPath : null;
+  if (!manifestPath) {
+    return null;
+  }
+  const manifestRaw = await fs.readFile(manifestPath, "utf8");
+  const manifest = JSON.parse(manifestRaw);
+  return { root, manifestPath, configPath, manifest, config };
 }
 async function resolveManifest(contractsPathOverride) {
-    if (contractsPathOverride) {
-        const manifestPath = path.resolve(process.cwd(), contractsPathOverride);
-        const manifest = await readManifest(manifestPath);
-        return { manifestPath, manifestDir: path.dirname(manifestPath), manifest };
-    }
-    const workspace = await findWorkspace(process.cwd());
-    if (!workspace) {
-        throw new Error("Unable to find done.json. Run inside a Done workspace or pass --contracts <path>.");
-    }
-    return { manifestPath: workspace.manifestPath, manifestDir: path.dirname(workspace.manifestPath), manifest: workspace.manifest };
+  if (contractsPathOverride) {
+    const manifestPath = path.resolve(process.cwd(), contractsPathOverride);
+    const manifest = await readManifest(manifestPath);
+    return { manifestPath, manifestDir: path.dirname(manifestPath), manifest };
+  }
+  const workspace = await findWorkspace(process.cwd());
+  if (!workspace) {
+    throw new Error("Unable to find done.json. Run inside a Done workspace or pass --contracts <path>.");
+  }
+  return { manifestPath: workspace.manifestPath, manifestDir: path.dirname(workspace.manifestPath), manifest: workspace.manifest };
 }
 async function findWorkspace(startDir) {
-    let current = path.resolve(startDir);
-    while (true) {
-        const workspace = await detectWorkspace(current);
-        if (workspace) {
-            return workspace;
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            return null;
-        }
-        current = parent;
+  let current = path.resolve(startDir);
+  while (true) {
+    const workspace = await detectWorkspace(current);
+    if (workspace) {
+      return workspace;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
     }
+    current = parent;
+  }
 }
 async function readManifest(manifestPath) {
-    let raw;
-    try {
-        raw = await fs.readFile(manifestPath, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            throw new Error(`Could not find ${manifestPath}. Pass a valid --contracts path or run from a Done workspace.`);
-        }
-        throw error;
-    }
-    try {
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        throw new Error(`Failed to parse ${manifestPath}: ${error.message}`);
+  let raw;
+  try {
+    raw = await fs.readFile(manifestPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Could not find ${manifestPath}. Pass a valid --contracts path or run from a Done workspace.`);
     }
+    throw error;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Failed to parse ${manifestPath}: ${error.message}`);
+  }
 }
 async function scaffoldWorkspace(rawName, options) {
-    const slug = toSlug(rawName);
-    if (!slug) {
-        throw new Error(`Could not derive a valid directory name from '${rawName}'.`);
-    }
-    const templateRef = options.template ?? DEFAULT_TEMPLATE_REPO;
-    const cwd = process.cwd();
-    const targetDir = path.resolve(cwd, slug);
-    await prepareTargetDir(targetDir, options.force === true);
-    const localTemplatePath = await resolveLocalTemplate(templateRef);
-    if (localTemplatePath) {
-        await fs.cp(localTemplatePath, targetDir, { recursive: true });
-    }
-    else {
-        await runCommand("git", ["clone", "--depth", "1", templateRef, targetDir]);
-    }
-    await removeGitFolder(targetDir);
-    await updatePackageJson(path.join(targetDir, "package.json"), (pkg) => {
-        pkg.name = slug;
-    });
-    await updatePackageJson(path.join(targetDir, "frontend", "package.json"), (pkg) => {
-        pkg.name = `${slug}-frontend`;
-    });
-    if (options.install !== false) {
-        await runCommand("bun", ["install"], { cwd: targetDir });
-    }
-    console.log(`Done workspace created at ${path.relative(cwd, targetDir) || "."}.`);
-    console.log("Next steps:");
-    console.log(`  cd ${path.relative(cwd, targetDir) || slug}`);
-    if (options.install === false) {
-        console.log("  bun install");
-    }
-    console.log("  bunx done dev");
+  const slug = toSlug(rawName);
+  if (!slug) {
+    throw new Error(`Could not derive a valid directory name from '${rawName}'.`);
+  }
+  const templateRef = options.template ?? DEFAULT_TEMPLATE_REPO;
+  const cwd = process.cwd();
+  const targetDir = path.resolve(cwd, slug);
+  await prepareTargetDir(targetDir, options.force === true);
+  const localTemplatePath = await resolveLocalTemplate(templateRef);
+  if (localTemplatePath) {
+    await fs.cp(localTemplatePath, targetDir, { recursive: true });
+  } else {
+    await runCommand("git", ["clone", "--depth", "1", templateRef, targetDir]);
+  }
+  await removeGitFolder(targetDir);
+  await updatePackageJson(path.join(targetDir, "package.json"), (pkg) => {
+    pkg.name = slug;
+  });
+  await updatePackageJson(path.join(targetDir, "frontend", "package.json"), (pkg) => {
+    pkg.name = `${slug}-frontend`;
+  });
+  if (options.install !== false) {
+    await runCommand("bun", ["install"], { cwd: targetDir });
+  }
+  console.log(`Done workspace created at ${path.relative(cwd, targetDir) || "."}.`);
+  console.log("Next steps:");
+  console.log(`  cd ${path.relative(cwd, targetDir) || slug}`);
+  if (options.install === false) {
+    console.log("  bun install");
+  }
+  console.log("  bunx done dev");
 }
 async function scaffoldContract(workspace, rawName, options) {
-    const slug = toSlug(rawName);
-    if (!slug) {
-        throw new Error(`Could not derive a valid contract directory name from '${rawName}'.`);
-    }
-    const contractName = toContractName(slug);
-    const contractsDir = resolveContractsDir(workspace.root, workspace.config.contractsDir);
-    const contractDir = path.join(contractsDir, slug);
-    await ensureDirAvailable(contractDir, options.force === true);
-    await fs.mkdir(path.join(contractDir, "src"), { recursive: true });
-    const pkgJsonPath = path.join(contractDir, "package.json");
-    const pkgJson = {
-        name: slug,
-        version: "0.1.0",
-        private: true,
-        type: "module",
-        scripts: {
-            typecheck: "tsc -p tsconfig.json --noEmit",
-        },
-        dependencies: {
-            "@donezone/contract-types": "^0.1.0",
-        },
-    };
-    await writeJson(pkgJsonPath, pkgJson);
-    const rootTsconfig = path.join(workspace.root, "tsconfig.json");
-    const tsconfig = {
-        compilerOptions: {
-            module: "ESNext",
-            moduleResolution: "bundler",
-            target: "ES2022",
-            isolatedModules: true,
-            noEmit: true,
-        },
-        include: ["src/**/*.ts"],
-    };
-    if (existsSync(rootTsconfig)) {
-        tsconfig.extends = normalizeJsonPath(path.relative(contractDir, rootTsconfig));
+  const slug = toSlug(rawName);
+  if (!slug) {
+    throw new Error(`Could not derive a valid contract directory name from '${rawName}'.`);
+  }
+  const contractName = toContractName(slug);
+  const contractsDir = resolveContractsDir(workspace.root, workspace.config.contractsDir);
+  const contractDir = path.join(contractsDir, slug);
+  await ensureDirAvailable(contractDir, options.force === true);
+  await fs.mkdir(path.join(contractDir, "src"), { recursive: true });
+  const pkgJsonPath = path.join(contractDir, "package.json");
+  const pkgJson = {
+    name: slug,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      typecheck: "tsc -p tsconfig.json --noEmit"
+    },
+    dependencies: {
+      "done.zone": "^0.1.0"
     }
-    await writeJson(path.join(contractDir, "tsconfig.json"), tsconfig);
-    const storeKey = `${slug}-greeting`;
-    const defaultGreeting = `Hello from ${contractName}`;
-    const contractSource = `const Greeting = Done.item<string>("${storeKey}");
+  };
+  await writeJson(pkgJsonPath, pkgJson);
+  const rootTsconfig = path.join(workspace.root, "tsconfig.json");
+  const tsconfig = {
+    compilerOptions: {
+      module: "ESNext",
+      moduleResolution: "bundler",
+      target: "ES2022",
+      isolatedModules: true,
+      noEmit: true
+    },
+    include: ["src/**/*.ts"]
+  };
+  if (existsSync(rootTsconfig)) {
+    tsconfig.extends = normalizeJsonPath(path.relative(contractDir, rootTsconfig));
+  }
+  await writeJson(path.join(contractDir, "tsconfig.json"), tsconfig);
+  const storeKey = `${slug}-greeting`;
+  const defaultGreeting = `Hello from ${contractName}`;
+  const contractSource = `const Greeting = Done.item<string>("${storeKey}");
 
 interface SetGreetingBody {
   greeting: string;
@@ -294,255 +305,736 @@ export default Done.serve()
     },
   );
 `;
-    await fs.writeFile(path.join(contractDir, "src", "index.ts"), contractSource, "utf8");
-    workspace.manifest.contracts ??= [];
-    const contractDirRel = normalizeJsonPath(path.relative(workspace.root, contractDir));
-    const entry = ensureDotSlash(`${contractDirRel}/src/index.ts`);
-    const outFile = ensureDotSlash(`${contractDirRel}/dist/${slug}.contract.js`);
-    const watch = [ensureDotSlash(`${contractDirRel}/src/**/*.ts`)];
-    const newEntry = {
-        name: contractName,
-        entry,
-        outFile,
-        watch,
-        instantiate: { admin: null },
-    };
-    const existingIndex = workspace.manifest.contracts.findIndex((contract) => contract.name === contractName);
-    if (existingIndex >= 0 && options.force !== true) {
-        throw new Error(`Contract '${contractName}' already exists in done.json. Use --force to replace it.`);
-    }
-    if (existingIndex >= 0) {
-        workspace.manifest.contracts[existingIndex] = newEntry;
-    }
-    else {
-        workspace.manifest.contracts.push(newEntry);
-    }
-    await writeJson(workspace.manifestPath, workspace.manifest);
-    console.log(`Created Done contract '${contractName}' in ${path.relative(workspace.root, contractDir)}`);
-    console.log("Next steps:");
-    console.log("  bunx done build --name", contractName);
-    console.log("  bunx done dev");
+  await fs.writeFile(path.join(contractDir, "src", "index.ts"), contractSource, "utf8");
+  workspace.manifest.contracts ??= [];
+  const contractDirRel = normalizeJsonPath(path.relative(workspace.root, contractDir));
+  const entry = ensureDotSlash(`${contractDirRel}/src/index.ts`);
+  const outFile = ensureDotSlash(`${contractDirRel}/dist/${slug}.contract.js`);
+  const watch = [ensureDotSlash(`${contractDirRel}/src/**/*.ts`)];
+  const newEntry = {
+    name: contractName,
+    entry,
+    outFile,
+    watch,
+    instantiate: { admin: null }
+  };
+  const existingIndex = workspace.manifest.contracts.findIndex((contract) => contract.name === contractName);
+  if (existingIndex >= 0 && options.force !== true) {
+    throw new Error(`Contract '${contractName}' already exists in done.json. Use --force to replace it.`);
+  }
+  if (existingIndex >= 0) {
+    workspace.manifest.contracts[existingIndex] = newEntry;
+  } else {
+    workspace.manifest.contracts.push(newEntry);
+  }
+  await writeJson(workspace.manifestPath, workspace.manifest);
+  console.log(`Created Done contract '${contractName}' in ${path.relative(workspace.root, contractDir)}`);
+  console.log("Next steps:");
+  console.log("  bunx done build --name", contractName);
+  console.log("  bunx done dev");
 }
 async function resolveLocalTemplate(reference) {
-    const potentialPath = path.isAbsolute(reference) ? reference : path.resolve(process.cwd(), reference);
-    try {
-        const stats = await fs.stat(potentialPath);
-        if (stats.isDirectory()) {
-            return potentialPath;
-        }
+  const potentialPath = path.isAbsolute(reference) ? reference : path.resolve(process.cwd(), reference);
+  try {
+    const stats = await fs.stat(potentialPath);
+    if (stats.isDirectory()) {
+      return potentialPath;
     }
-    catch { }
-    return null;
+  } catch {
+  }
+  return null;
 }
 async function prepareTargetDir(targetDir, force) {
-    if (!existsSync(targetDir)) {
-        return;
-    }
-    if (!force) {
-        throw new Error(`Directory '${path.relative(process.cwd(), targetDir) || targetDir}' already exists. Use --force to overwrite.`);
-    }
-    await fs.rm(targetDir, { recursive: true, force: true });
+  if (!existsSync(targetDir)) {
+    return;
+  }
+  if (!force) {
+    throw new Error(`Directory '${path.relative(process.cwd(), targetDir) || targetDir}' already exists. Use --force to overwrite.`);
+  }
+  await fs.rm(targetDir, { recursive: true, force: true });
 }
 async function ensureDirAvailable(targetDir, force) {
-    if (!existsSync(targetDir)) {
-        return;
-    }
-    if (!force) {
-        throw new Error(`Directory '${path.relative(process.cwd(), targetDir) || targetDir}' already exists. Use --force to overwrite.`);
-    }
-    await fs.rm(targetDir, { recursive: true, force: true });
+  if (!existsSync(targetDir)) {
+    return;
+  }
+  if (!force) {
+    throw new Error(`Directory '${path.relative(process.cwd(), targetDir) || targetDir}' already exists. Use --force to overwrite.`);
+  }
+  await fs.rm(targetDir, { recursive: true, force: true });
 }
 async function removeGitFolder(targetDir) {
-    await fs.rm(path.join(targetDir, ".git"), { recursive: true, force: true });
+  await fs.rm(path.join(targetDir, ".git"), { recursive: true, force: true });
 }
 function resolveContractsDir(root, configured) {
-    if (!configured) {
-        return path.join(root, "contracts");
-    }
-    if (path.isAbsolute(configured)) {
-        return configured;
-    }
-    return path.resolve(root, configured);
+  if (!configured) {
+    return path.join(root, "contracts");
+  }
+  if (path.isAbsolute(configured)) {
+    return configured;
+  }
+  return path.resolve(root, configured);
 }
 async function updatePackageJson(file, mutator) {
-    try {
-        const current = JSON.parse(await fs.readFile(file, "utf8"));
-        mutator(current);
-        await writeJson(file, current);
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            return;
-        }
-        throw error;
+  try {
+    const current = JSON.parse(await fs.readFile(file, "utf8"));
+    mutator(current);
+    await writeJson(file, current);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
     }
+    throw error;
+  }
 }
 function ensureDotSlash(value) {
-    return value.startsWith("./") || value.startsWith("../") ? value : `./${value}`;
+  return value.startsWith("./") || value.startsWith("../") ? value : `./${value}`;
 }
 function normalizeJsonPath(relativePath) {
-    const normalized = relativePath.split(path.sep).join("/");
-    return normalized.startsWith("./") || normalized.startsWith("../") ? normalized : `./${normalized}`;
+  const normalized = relativePath.split(path.sep).join("/");
+  return normalized.startsWith("./") || normalized.startsWith("../") ? normalized : `./${normalized}`;
 }
 function matchesContract(contract, manifestDir, matchers) {
-    const candidates = [];
-    if (contract.name) {
-        candidates.push(normalizeMatchValue(contract.name));
-    }
-    if (contract.entry) {
-        candidates.push(normalizeMatchValue(contract.entry));
-        candidates.push(normalizeMatchValue(path.resolve(manifestDir, contract.entry)));
-    }
-    if (contract.outFile) {
-        candidates.push(normalizeMatchValue(contract.outFile));
-        candidates.push(normalizeMatchValue(path.resolve(manifestDir, contract.outFile)));
-    }
-    return matchers.some((matcher) => candidates.some((candidate) => matcher(candidate)));
+  const candidates = [];
+  if (contract.name) {
+    candidates.push(normalizeMatchValue(contract.name));
+  }
+  if (contract.entry) {
+    candidates.push(normalizeMatchValue(contract.entry));
+    candidates.push(normalizeMatchValue(path.resolve(manifestDir, contract.entry)));
+  }
+  if (contract.outFile) {
+    candidates.push(normalizeMatchValue(contract.outFile));
+    candidates.push(normalizeMatchValue(path.resolve(manifestDir, contract.outFile)));
+  }
+  return matchers.some((matcher) => candidates.some((candidate) => matcher(candidate)));
 }
 function createGlobMatcher(pattern) {
-    const normalized = normalizeMatchValue(pattern);
-    const hasWildcards = /[\*\?]/.test(normalized);
-    if (!hasWildcards) {
-        return (candidate) => normalizeMatchValue(candidate) === normalized;
-    }
-    const escaped = escapeRegExp(normalized)
-        .replace(/\\\*/g, ".*")
-        .replace(/\\\?/g, ".");
-    const regex = new RegExp(`^${escaped}$`);
-    return (candidate) => regex.test(normalizeMatchValue(candidate));
+  const normalized = normalizeMatchValue(pattern);
+  const hasWildcards = /[\*\?]/.test(normalized);
+  if (!hasWildcards) {
+    return (candidate) => normalizeMatchValue(candidate) === normalized;
+  }
+  const escaped = escapeRegExp(normalized).replace(/\\\*/g, ".*").replace(/\\\?/g, ".");
+  const regex = new RegExp(`^${escaped}\$`);
+  return (candidate) => regex.test(normalizeMatchValue(candidate));
 }
 function normalizeMatchValue(value) {
-    if (!value) {
-        return "";
-    }
-    let normalized = value.replace(/\\/g, "/");
-    if (normalized.startsWith("./")) {
-        normalized = normalized.slice(2);
-    }
-    return normalized;
+  if (!value) {
+    return "";
+  }
+  let normalized = value.replace(/\\/g, "/");
+  if (normalized.startsWith("./")) {
+    normalized = normalized.slice(2);
+  }
+  return normalized;
 }
 function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 async function ensureEntryExists(entryPath, contractName) {
-    try {
-        const stats = await fs.stat(entryPath);
-        if (!stats.isFile()) {
-            const relPath = path.relative(process.cwd(), entryPath) || entryPath;
-            throw new Error(`Entry path for contract '${contractName}' is not a file (${relPath})`);
-        }
+  try {
+    const stats = await fs.stat(entryPath);
+    if (!stats.isFile()) {
+      const relPath = path.relative(process.cwd(), entryPath) || entryPath;
+      throw new Error(`Entry path for contract '${contractName}' is not a file (${relPath})`);
     }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            const rel = path.relative(process.cwd(), entryPath) || entryPath;
-            throw new Error(`Entry file for contract '${contractName}' not found (${rel})`);
-        }
-        throw error;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      const rel = path.relative(process.cwd(), entryPath) || entryPath;
+      throw new Error(`Entry file for contract '${contractName}' not found (${rel})`);
+    }
+    throw error;
+  }
+}
+async function ensureFileExists(filePath, label) {
+  try {
+    const stats = await fs.stat(filePath);
+    if (!stats.isFile()) {
+      throw new Error(`The ${label} path is not a file (${filePath})`);
     }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`The ${label} file does not exist (${filePath})`);
+    }
+    throw error;
+  }
+}
+async function loadMsgPayload(input) {
+  const potentialPath = path.resolve(process.cwd(), input);
+  if (await pathExists(potentialPath)) {
+    const raw = await fs.readFile(potentialPath, "utf8");
+    return JSON.parse(raw);
+  }
+  return JSON.parse(input);
+}
+function resolveDoneHttpBase(override) {
+  return override ?? process.env.DONE_HTTP ?? process.env.DONE_HTTP_BASE ?? "http://localhost:3000";
+}
+async function pathExists(candidate) {
+  try {
+    await fs.access(candidate);
+    return true;
+  } catch {
+    return false;
+  }
 }
 async function runBunBuild(entryPath, outFilePath) {
-    const bun = getEmbeddedBunRuntime();
-    if (bun) {
-        const result = await bun.build({
-            entrypoints: [entryPath],
-            target: "bun",
-            format: "esm",
-            splitting: false,
-            sourcemap: "none",
-            external: ["bun:*", "node:*"],
-            define: {
-                "process.env.NODE_ENV": '"production"',
-            },
-        });
-        if (!result.success) {
-            const logs = (result.logs ?? []).map((log) => log?.message ?? String(log));
-            throw new Error(logs.join("\n") || "Bun.build failed");
-        }
-        const [output] = result.outputs;
-        if (!output) {
-            throw new Error("Bun.build did not emit an output file");
-        }
-        const bundledSource = await output.text();
-        await fs.writeFile(outFilePath, bundledSource);
-        return;
+  const bun = getEmbeddedBunRuntime();
+  if (bun) {
+    const result = await bun.build({
+      entrypoints: [entryPath],
+      target: "bun",
+      format: "esm",
+      splitting: false,
+      sourcemap: "none",
+      external: ["bun:*", "node:*"],
+      define: {
+        "process.env.NODE_ENV": '"production"'
+      }
+    });
+    if (!result.success) {
+      const logs = (result.logs ?? []).map((log) => log?.message ?? String(log));
+      throw new Error(logs.join("\n") || "Bun.build failed");
+    }
+    const [output] = result.outputs;
+    if (!output) {
+      throw new Error("Bun.build did not emit an output file");
     }
-    await runBunCliBuild(entryPath, outFilePath);
+    const bundledSource = await output.text();
+    await fs.writeFile(outFilePath, bundledSource);
+    return;
+  }
+  await runBunCliBuild(entryPath, outFilePath);
 }
 function getEmbeddedBunRuntime() {
-    const bun = globalThis.Bun;
-    if (!bun || typeof bun.build !== "function") {
-        return null;
-    }
-    return bun;
+  const bun = globalThis.Bun;
+  if (!bun || typeof bun.build !== "function") {
+    return null;
+  }
+  return bun;
 }
 async function runBunCliBuild(entryPath, outFilePath) {
-    const args = [
-        "build",
-        entryPath,
-        "--outfile",
-        outFilePath,
-        "--target",
-        "bun",
-        "--format",
-        "esm",
-        "--sourcemap",
-        "none",
-        "--define",
-        'process.env.NODE_ENV="production"',
-    ];
-    for (const external of ["bun:*", "node:*"]) {
-        args.push("--external", external);
-    }
-    try {
-        await runCommand("bun", args);
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            throw new Error("Bun executable not found in PATH. Install Bun from https://bun.sh and re-run the build.");
-        }
-        throw error;
+  const args = [
+    "build",
+    entryPath,
+    "--outfile",
+    outFilePath,
+    "--target",
+    "bun",
+    "--format",
+    "esm",
+    "--sourcemap",
+    "none",
+    "--define",
+    'process.env.NODE_ENV="production"'
+  ];
+  for (const external of ["bun:*", "node:*"]) {
+    args.push("--external", external);
+  }
+  try {
+    await runCommand("bun", args);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error("Bun executable not found in PATH. Install Bun from https://bun.sh and re-run the build.");
     }
+    throw error;
+  }
 }
 function formatDuration(ms) {
-    if (ms < 1000) {
-        return `${ms}ms`;
-    }
-    return `${(ms / 1000).toFixed(2)}s`;
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  return `${(ms / 1000).toFixed(2)}s`;
 }
 function toSlug(input) {
-    return input
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+/, "")
-        .replace(/-+$/, "");
+  return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
 }
 function toContractName(slug) {
-    const parts = slug.split(/[^a-zA-Z0-9]+/).filter(Boolean);
-    if (parts.length === 0) {
-        return "contract";
-    }
-    const [first, ...rest] = parts;
-    return first + rest.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  const parts = slug.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+  if (parts.length === 0) {
+    return "contract";
+  }
+  const [first, ...rest] = parts;
+  return first + rest.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
 async function writeJson(file, data) {
-    const json = JSON.stringify(data, null, 2);
-    await fs.writeFile(file, `${json}\n`, "utf8");
+  const json = JSON.stringify(data, null, 2);
+  await fs.writeFile(file, `${json}\n`, "utf8");
 }
 async function runCommand(command, args, options = {}) {
-    await new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            cwd: options.cwd,
-            stdio: "inherit",
-        });
-        child.on("close", (code) => {
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`${command} ${args.join(" ")} failed with exit code ${code}`));
-            }
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      stdio: "inherit"
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`${command} ${args.join(" ")} failed with exit code ${code}`));
+      }
+    });
+    child.on("error", (error) => reject(error));
+  });
+}
+async function handleDev(options) {
+  const workspace = await findWorkspace(process.cwd());
+  if (!workspace) {
+    throw new Error("done dev must be run inside a Done workspace." + " Run `bunx done init` from your project root first.");
+  }
+  const startBackend = options.backend || !options.backend && !options.frontend;
+  const startFrontend = options.frontend || !options.backend && !options.frontend;
+  if (!startBackend && !startFrontend) {
+    throw new Error("Specify --backend and/or --frontend to start services.");
+  }
+  const devConfig = resolveDevConfig(workspace);
+  const orchestrator = new DoneDevOrchestrator({
+    workspace,
+    startBackend,
+    startFrontend,
+    devConfig
+  });
+  try {
+    await orchestrator.start();
+    await orchestrator.waitUntilStopped();
+  } finally {
+    await orchestrator.stop();
+  }
+}
+function resolveDevConfig(workspace) {
+  const dev = workspace.config.dev ?? {};
+  const host = dev.host ?? "127.0.0.1";
+  const port = dev.port ?? 8787;
+  const eventsHost = dev.eventsHost ?? host;
+  const eventsPort = dev.eventsPort ?? 7071;
+  const envFile = dev.envFile ? path.isAbsolute(dev.envFile) ? dev.envFile : path.resolve(workspace.root, dev.envFile) : path.resolve(workspace.root, ".done", "dev.env");
+  const frontendCwd = dev.frontend?.cwd ? path.isAbsolute(dev.frontend.cwd) ? dev.frontend.cwd : path.resolve(workspace.root, dev.frontend.cwd) : path.resolve(workspace.root, "frontend");
+  return {
+    envFile,
+    owner: dev.owner ?? "done1owner000000000000000000000000000000000000",
+    routerAddress: dev.routerAddress ?? null,
+    http: { host, port },
+    events: { host: eventsHost, port: eventsPort },
+    frontend: {
+      cwd: frontendCwd,
+      command: dev.frontend?.command ?? "bun run dev",
+      url: dev.frontend?.url ?? "http://127.0.0.1:5173",
+      open: dev.frontend?.open !== false
+    }
+  };
+}
+const DEV_LOG_PREFIX = pc.bold(pc.cyan("[done dev]"));
+const DEV_WARN_PREFIX = pc.bold(pc.yellow("[done dev]"));
+const DEV_ERROR_PREFIX = pc.bold(pc.red("[done dev]"));
+
+class DoneDevOrchestrator {
+  options;
+  chain;
+  httpApp;
+  eventsServer;
+  watchers = [];
+  frontendProcess;
+  contracts = [];
+  envEntries = {};
+  httpUrl;
+  eventsUrl;
+  stopPromise;
+  resolveStop;
+  shuttingDown = false;
+  signalHandlers = [];
+  constructor(options) {
+    this.options = options;
+  }
+  async start() {
+    if (this.options.startBackend) {
+      await this.bootstrapBackend();
+    } else {
+      await this.loadEnvFromDisk();
+    }
+    if (this.options.startFrontend) {
+      await this.launchFrontend();
+    }
+    this.registerSignalHandlers();
+    this.printSummary();
+    if (this.options.startBackend || this.options.startFrontend) {
+      this.logInfo("Press Ctrl+C to stop");
+    }
+  }
+  async waitUntilStopped() {
+    if (!this.stopPromise) {
+      this.stopPromise = new Promise((resolve) => {
+        this.resolveStop = resolve;
+      });
+    }
+    return this.stopPromise;
+  }
+  async stop() {
+    if (this.shuttingDown) {
+      return this.stopPromise ?? Promise.resolve();
+    }
+    this.shuttingDown = true;
+    for (const { event, handler } of this.signalHandlers) {
+      process.off(event, handler);
+    }
+    this.signalHandlers = [];
+    await this.stopFrontend();
+    await Promise.all(this.watchers.map((watcher) => watcher.close().catch(() => {
+    })));
+    this.watchers = [];
+    await Promise.all(this.contracts.map((contract) => contract.queue.catch(() => {
+    })));
+    if (this.httpApp) {
+      await this.httpApp.stop().catch(() => {
+      });
+      this.httpApp = undefined;
+    }
+    if (this.eventsServer) {
+      try {
+        this.eventsServer.unsubscribe();
+      } catch {
+      }
+      await this.eventsServer.app.stop().catch(() => {
+      });
+      this.eventsServer = undefined;
+    }
+    this.chain = undefined;
+    this.resolveStop?.();
+  }
+  registerSignalHandlers() {
+    const shutdown = (signal) => {
+      this.logInfo(`Received ${signal}, shutting down...`);
+      this.stop();
+    };
+    for (const event of ["SIGINT", "SIGTERM"]) {
+      const handler = () => shutdown(event);
+      this.signalHandlers.push({ event, handler });
+      process.on(event, handler);
+    }
+  }
+  async bootstrapBackend() {
+    this.chain = new DoneLocalChain;
+    this.contracts = this.prepareContracts();
+    await this.buildAllContracts();
+    await this.deployContracts();
+    await this.startHttpServer();
+    await this.startEventsServer();
+    await this.writeEnvFile();
+    this.startWatchers();
+  }
+  prepareContracts() {
+    const manifestDir = path.dirname(this.options.workspace.manifestPath);
+    const contracts = this.options.workspace.manifest.contracts ?? [];
+    if (contracts.length === 0) {
+      throw new Error("No contracts defined in done.json. Run `bunx done init <name>` first.");
+    }
+    return contracts.map((contract) => {
+      if (!contract.entry) {
+        throw new Error(`Contract '${contract.name}' is missing an entry path.`);
+      }
+      if (!contract.outFile) {
+        throw new Error(`Contract '${contract.name}' is missing an outFile path.`);
+      }
+      const entryPath = path.resolve(manifestDir, contract.entry);
+      const outFilePath = path.resolve(manifestDir, contract.outFile);
+      const watchGlobs = (contract.watch && contract.watch.length > 0 ? contract.watch : [contract.entry]).map((pattern) => path.resolve(manifestDir, pattern));
+      return {
+        name: contract.name,
+        envKey: toEnvVarKey(contract.name),
+        entryPath,
+        outFilePath,
+        watchGlobs,
+        instantiateMsg: { ...contract.instantiate?.msg ?? {} },
+        admin: contract.instantiate?.admin ?? null,
+        label: contract.instantiate?.label,
+        publishMsg: contract.publish?.msg,
+        queue: Promise.resolve()
+      };
+    });
+  }
+  async buildAllContracts() {
+    for (const contract of this.contracts) {
+      await this.buildBundle(contract, true);
+    }
+  }
+  async buildBundle(contract, initial, reason) {
+    await ensureEntryExists(contract.entryPath, contract.name);
+    await fs.mkdir(path.dirname(contract.outFilePath), { recursive: true });
+    const startedAt = Date.now();
+    const label = initial ? "Building" : "Rebuilding";
+    this.logInfo(`${label} ${contract.name}${reason ? ` (${reason})` : ""}`);
+    await runBunBuild(contract.entryPath, contract.outFilePath);
+    this.logInfo(`  ${pc.green("\u2713")} ${contract.name} bundle ready (${formatDuration(Date.now() - startedAt)})`);
+  }
+  async deployContracts() {
+    if (!this.chain)
+      return;
+    for (const contract of this.contracts) {
+      const deployment = await deployJsContract({
+        chain: this.chain,
+        sender: this.options.devConfig.owner,
+        scriptPath: contract.outFilePath,
+        instantiateMsg: contract.instantiateMsg,
+        cwJsCodeId: this.chain.batteries?.cwJs.codeId,
+        admin: contract.admin ?? undefined,
+        label: contract.label ?? contract.name
+      });
+      if (deployment.result.err) {
+        throw new Error(`Failed to deploy ${contract.name}: ${deployment.result.err}`);
+      }
+      contract.address = deployment.address;
+      this.chain.advanceBlock();
+      this.logInfo(`${pc.green("\u2022")} ${contract.name} deployed at ${deployment.address}`);
+    }
+  }
+  async startHttpServer() {
+    if (!this.chain)
+      return;
+    const { host, port } = this.options.devConfig.http;
+    const httpServer = await createDoneHttpLocalServer({
+      port,
+      owner: this.options.devConfig.owner,
+      routerAddress: this.options.devConfig.routerAddress ?? undefined
+    }, this.chain);
+    httpServer.app.listen({ port, hostname: host });
+    this.httpApp = httpServer.app;
+    this.httpUrl = `http://${host}:${port}`;
+    this.logInfo(`done-http-local listening on ${this.httpUrl}`);
+  }
+  async startEventsServer() {
+    if (!this.chain)
+      return;
+    const { host, port } = this.options.devConfig.events;
+    const eventsServer = createDoneEventsLocalServer({ chain: this.chain });
+    eventsServer.app.listen({ port, hostname: host });
+    this.eventsServer = eventsServer;
+    this.eventsUrl = `http://${host}:${port}`;
+    this.logInfo(`done-events-local listening on ${this.eventsUrl}`);
+  }
+  startWatchers() {
+    for (const contract of this.contracts) {
+      const watcher = chokidar.watch(contract.watchGlobs, { ignoreInitial: true });
+      watcher.on("all", (event, filePath) => {
+        const reason = `${event} ${this.formatWorkspacePath(filePath)}`;
+        this.enqueueContractUpdate(contract, reason);
+      });
+      watcher.on("error", (error) => {
+        this.logError(`Watcher error for ${contract.name}`, error);
+      });
+      this.watchers.push(watcher);
+    }
+  }
+  enqueueContractUpdate(contract, reason) {
+    contract.queue = contract.queue.catch(() => {
+    }).then(async () => {
+      try {
+        await this.buildBundle(contract, false, reason);
+        await this.publishContract(contract);
+      } catch (error) {
+        this.logError(`Failed to refresh ${contract.name}`, error);
+      }
+    });
+  }
+  async publishContract(contract) {
+    if (!this.chain || !contract.address)
+      return;
+    const script = await fs.readFile(contract.outFilePath, "utf8");
+    const execResult = this.chain.execute(contract.address, {
+      publish_code: {
+        script,
+        ...contract.publishMsg ? { msg: contract.publishMsg } : {}
+      }
+    }, {
+      sender: this.options.devConfig.owner,
+      funds: []
+    });
+    if (execResult.result.err) {
+      throw new Error(execResult.result.err);
+    }
+    this.chain.advanceBlock();
+    await this.writeEnvFile({ DONE_DEV_UPDATED_AT: new Date().toISOString() });
+    this.logInfo(`${pc.green("\u21BB")} updated ${contract.name} (height ${this.chain.height})`);
+  }
+  async launchFrontend() {
+    const frontend = this.options.devConfig.frontend;
+    if (!existsSync(frontend.cwd)) {
+      this.logWarn(`Skipping frontend; directory not found (${frontend.cwd})`);
+      return;
+    }
+    if (Object.keys(this.envEntries).length === 0) {
+      await this.loadEnvFromDisk();
+    }
+    const env = { ...process.env, ...this.envEntries };
+    if (this.httpUrl) {
+      env.VITE_DONE_HTTP_URL = this.httpUrl;
+      env.VITE_DONE_HTTP = this.httpUrl;
+      env.VITE_DONE_HTTP_BASE = this.httpUrl;
+    }
+    if (this.eventsUrl) {
+      env.VITE_DONE_EVENTS_URL = this.eventsUrl;
+    }
+    for (const [key, value] of Object.entries(this.envEntries)) {
+      if (key.startsWith("DONE_CONTRACT_")) {
+        env[`VITE_${key}`] = value;
+      }
+    }
+    this.logInfo(`Starting frontend (${frontend.command})`);
+    this.frontendProcess = spawn(frontend.command, {
+      cwd: frontend.cwd,
+      env,
+      stdio: "inherit",
+      shell: true
+    });
+    this.frontendProcess.on("exit", (code) => {
+      if (!this.shuttingDown && code !== 0) {
+        this.logError(`Frontend exited with code ${code ?? 0}`);
+      }
+    });
+    if (frontend.open) {
+      setTimeout(() => {
+        openBrowser(frontend.url).catch((error) => {
+          this.logWarn(`Failed to open browser: ${error.message}`);
         });
-        child.on("error", (error) => reject(error));
+      }, 1500);
+    }
+  }
+  async stopFrontend() {
+    if (!this.frontendProcess) {
+      return;
+    }
+    await new Promise((resolve) => {
+      const child = this.frontendProcess;
+      const timeout = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        resolve();
+      }, 1000);
+      child.once("exit", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      try {
+        child.kill("SIGINT");
+      } catch {
+        resolve();
+      }
+      this.frontendProcess = undefined;
     });
+  }
+  async writeEnvFile(extra = {}) {
+    const env = {
+      ...extra
+    };
+    if (this.httpUrl) {
+      env.DONE_HTTP_URL = this.httpUrl;
+      env.DONE_HTTP_BASE = this.httpUrl;
+      env.DONE_HTTP_LOCAL = this.httpUrl;
+    }
+    if (this.eventsUrl) {
+      env.DONE_EVENTS_URL = this.eventsUrl;
+      env.DONE_EVENTS_LOCAL = this.eventsUrl;
+    }
+    env.DONE_OWNER_ADDRESS = this.options.devConfig.owner;
+    env.DONE_DEV_UPDATED_AT = new Date().toISOString();
+    for (const contract of this.contracts) {
+      if (contract.address) {
+        env[`DONE_CONTRACT_${contract.envKey}`] = contract.address;
+      }
+    }
+    this.envEntries = env;
+    await writeDevEnvFile(this.options.devConfig.envFile, env);
+  }
+  async loadEnvFromDisk() {
+    try {
+      this.envEntries = await readDevEnvFile(this.options.devConfig.envFile);
+    } catch (error) {
+      this.logWarn(`Unable to read ${this.options.devConfig.envFile}: ${error.message}`);
+      this.envEntries = {};
+    }
+  }
+  printSummary() {
+    this.logInfo(pc.bold("Local stack ready"));
+    if (this.httpUrl) {
+      console.log(`  ${pc.dim("http")}: ${this.httpUrl}`);
+    }
+    if (this.eventsUrl) {
+      console.log(`  ${pc.dim("events")}: ${this.eventsUrl}`);
+    }
+    if (this.contracts.length > 0) {
+      console.log("  Contracts:");
+      for (const contract of this.contracts) {
+        if (contract.address) {
+          console.log(`    - ${contract.name}: ${contract.address}`);
+        }
+      }
+    }
+    const relEnv = path.relative(process.cwd(), this.options.devConfig.envFile) || this.options.devConfig.envFile;
+    console.log(`  Env file: ${relEnv}`);
+    if (this.options.startFrontend) {
+      console.log(`  Frontend: ${this.options.devConfig.frontend.url}`);
+    }
+  }
+  formatWorkspacePath(filePath) {
+    return path.relative(this.options.workspace.root, filePath) || filePath;
+  }
+  logInfo(message) {
+    console.log(DEV_LOG_PREFIX, message);
+  }
+  logWarn(message) {
+    console.warn(DEV_WARN_PREFIX, message);
+  }
+  logError(message, error) {
+    if (error) {
+      console.error(DEV_ERROR_PREFIX, `${message}: ${error.message}`);
+    } else {
+      console.error(DEV_ERROR_PREFIX, message);
+    }
+  }
+}
+async function writeDevEnvFile(file, entries) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  const lines = ["# generated by done dev", `# ${new Date().toISOString()}`];
+  for (const key of Object.keys(entries).sort()) {
+    lines.push(`${key}=${entries[key]}`);
+  }
+  await fs.writeFile(file, `${lines.join("\n")}\n`, "utf8");
+}
+async function readDevEnvFile(file) {
+  const data = await fs.readFile(file, "utf8");
+  const entries = {};
+  for (const line of data.split(/\r?\n/)) {
+    if (!line || line.startsWith("#"))
+      continue;
+    const [key, ...rest] = line.split("=");
+    if (!key || rest.length === 0)
+      continue;
+    entries[key.trim()] = rest.join("=").trim();
+  }
+  return entries;
+}
+function toEnvVarKey(name) {
+  return name.replace(/[^a-zA-Z0-9]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+}
+function openBrowser(url) {
+  return new Promise((resolve, reject) => {
+    const platform = process.platform;
+    let child;
+    try {
+      if (platform === "darwin") {
+        child = spawn("open", [url], { stdio: "ignore", detached: true });
+      } else if (platform === "win32") {
+        child = spawn("cmd", ["/c", "start", "", url], {
+          stdio: "ignore",
+          detached: true
+        });
+      } else {
+        child = spawn("xdg-open", [url], { stdio: "ignore", detached: true });
+      }
+      child.unref();
+      resolve();
+    } catch (error) {
+      reject(error);
+    }
+  });
 }